fix(mediaplayer): stop the seek bar bouncing to the pre-seek position on short seeks

The scrubber holds the handle at the seek target while the (asynchronous)
networking seek applies, releasing once the reported position "lands". The landed
test was "within 4s of the target", which can't distinguish a not-yet-applied seek
from a landed one when the jump is shorter than 4s — so on short seeks it released
early and the bar tracked the still-advancing pre-seek playhead for a moment before
snapping to the target. Capture the pre-seek position and release only once the
reported position is nearer the target than that origin, which disambiguates at any
seek distance.

Author: towneh

Basis/Packages/com.basis.mediaplayer/Runtime/UI/BasisMediaPlayerPanelProvider.cs

@@ -35,6 +35,7 @@ public class BasisMediaPlayerPanelProvider : BasisMenuActionProvider<BasisMainMe
         private float _seekPendingPct;
         private bool _drivingSeekSlider;      /* our write, not the user's drag */
         private double _seekAwaitPosS;        /* issued seek target, held until position lands */
+        private double _seekAwaitFromS;       /* pre-seek position, to tell "landed" from "not yet moved" */
         private float _seekAwaitUntil = -1f;
         private const float SeekDebounceSeconds = 0.35f;
         private int _lastPosSec = -1;
@@ -764,16 +765,20 @@ private void RefreshSeekBar()
                 _seekPendingAt = -1f;
                 double targetS = Mathf.Clamp(_seekPendingPct, 0f, 100f) / 100.0 * durS;
                 var target = System.TimeSpan.FromSeconds(targetS);
+                // Capture where we're seeking FROM before the seek applies — the
+                // networking path is asynchronous, so the reported position keeps
+                // reading the pre-seek playhead until it lands.
+                double fromS = _activePlayer.Position.TotalSeconds;
                 if (_activeNetworking != null) _ = _activeNetworking.Seek(target);
                 else
                 {
                     try { _activePlayer.Seek(target); }
                     catch (System.NotSupportedException) { }
                 }
-                // The native seek is asynchronous: hold the handle at the target
-                // until the reported position lands nearby (or give up after a
-                // refetch-worth of time), instead of tweening back to the old
-                // playhead and forward again.
+                // Hold the handle at the target until the reported position lands
+                // (or give up after a refetch-worth of time), instead of tweening
+                // back to the old playhead and forward again.
+                _seekAwaitFromS = fromS;
                 _seekAwaitPosS = targetS;
                 _seekAwaitUntil = Time.unscaledTime + 6f;
                 return;
@@ -782,7 +787,12 @@ private void RefreshSeekBar()
             double posS = _activePlayer.Position.TotalSeconds;
             if (_seekAwaitUntil > 0f)
             {
-                bool landed = System.Math.Abs(posS - _seekAwaitPosS) < 4.0; /* keyframe granularity */
+                // Landed once the reported position is nearer the target than the
+                // pre-seek playhead. A plain "within N seconds of target" test can't
+                // tell a not-yet-applied seek from a landed one when the jump is
+                // shorter than N, which released the hold early and bounced the bar
+                // back to the old position on small seeks.
+                bool landed = System.Math.Abs(posS - _seekAwaitPosS) <= System.Math.Abs(posS - _seekAwaitFromS);
                 if (!landed && Time.unscaledTime < _seekAwaitUntil)
                 {
                     posS = _seekAwaitPosS;