@desklink/react-native 0.5.4 → 0.5.6

package/README.md

@@ -277,8 +277,9 @@ view.
   network is still down. Renegotiation transients from a restart the session
   asked for itself are expected, not a new outage: they neither flip the
   status nor trigger another restart for a short grace window. A picture
-  that keeps moving holds off the heartbeat watchdog for up to ~20 s, since
-  the control channel lags the video after an outage.
+  that keeps moving holds off the heartbeat watchdog for up to ~20 s from
+  the later of the last heartbeat and the picture's return, since the
+  control channel lags the video after an outage.
 - **Roaming keeps the session.** The signalling carrier is not the session:
   when it closes, or a restart request on it gets no reply within 1.5 s, the
   session drops that carrier for good (calling its optional `close()`) and
@@ -289,7 +290,10 @@ view.
   fires. While the loop runs, a session that has shown a picture never reports
   `failed` or a transport failure; one that never showed a picture reports the
   first-frame transport failure after 20 s and the loop stops. A new carrier
-  picks up the same session after a 300 ms grace for the old ICE pair: if the
+  picks up the same session after a short grace for the old ICE pair, sized by
+  how long the picture has been still: stills under 4 s wait out the blip
+  (200 ms), stills past it take one stats beat (50 ms) and ask for the restart
+  at once. If the
   picture advanced during it, there is no restart (and a `reconnecting`
   session returns to `live`); otherwise the session moves to `reconnecting`
   and asks for an ICE restart. Failures caused

package/android/src/main/java/expo/modules/desklink/DesktopView.kt

@@ -474,8 +474,9 @@ class DesktopView(context: Context, appContext: AppContext) : ExpoView(context,
   private fun fillScale(): Float {
     // Portrait fits the width unless the app opted into cover; landscape
     // covers. Either way the fill never goes below the fit or above the zoom cap.
-    val wide = if (width <= height && !cover) safeWidth() else width.toFloat()
-    val fill = max(wide / surfaceWidth, (height - insetTop) / surfaceHeight)
+    val covers = width > height || cover
+    val fill = if (!covers) safeWidth() / surfaceWidth
+      else max(width.toFloat() / surfaceWidth, (height - insetTop) / surfaceHeight)
     return max(fitScale(), min(fill, MAX_SCALE))
   }
 

package/package.json

@@ -1,7 +1,12 @@
 {
     "name": "@desklink/react-native",
-    "version": "0.5.4",
+    "version": "0.5.6",
     "license": "Apache-2.0",
+    "repository": {
+      "type": "git",
+      "url": "https://github.com/umeranjum17/desklink.git",
+      "directory": "packages/desktop-client"
+    },
     "description": "Render and drive a desktop session from a React Native app",
     "main": "index.ts",
     "types": "index.ts",
@@ -37,6 +42,7 @@
     },
     "scripts": {
         "test:reconnect": "node test/reconnect-flow.mjs",
-        "test:ios": "node test/ios-flow.mjs"
+        "test:ios": "node test/ios-flow.mjs",
+        "test:reattach-race": "node test/reattach-grace-race-flow.mjs"
     }
 }

package/src/useDesktopSession.ts

@@ -56,7 +56,12 @@ const STALL_AFTER_MS = 1200;
  * trigger another restart while the window lasts.
  */
 const RESTART_GRACE_MS = 2500;
-/** How long a moving picture outlasts silent heartbeats: after an outage the data channel lags the video. */
+/**
+ * How long a moving picture outlasts silent heartbeats, from the later of the
+ * last heartbeat and the picture's return from a freeze: after an outage the
+ * data channel lags the video, as SCTP's retransmissions back off (to 15 s,
+ * then 31 s, after the first loss).
+ */
 const QUIET_PICTURE_MS = 20_000;
 /** How long a restart offer may go unanswered before the next attempt. */
 const RESTART_REPLY_MS = 5000;
@@ -68,8 +73,24 @@ const DIAL_RETRY_MS = 250;
 const DIAL_TIMEOUT_MS = 5000;
 /** How long the host holds a session with no carrier (the bridge's `reattachMs`); past it, reopen. */
 const REATTACH_WINDOW_MS = 30_000;
-/** How long a reattached carrier waits for the old ICE pair before asking for a restart. */
-const REATTACH_GRACE_MS = 300;
+/**
+ * How long a reattached carrier waits for the old ICE pair before asking for
+ * a restart — the wait for a brief blip: on an unchanged path the old pair
+ * resumes in ~100 ms and only the carrier was missing, so the wait keeps the
+ * restart unspent while the picture comes back on its own.
+ */
+const REATTACH_GRACE_MS = 200;
+/**
+ * A picture still this long is a real outage, not a blip: the old pair is
+ * not resuming, so the wait that protects a blip would only cost the recovery
+ * its 2 s bar. The line separates the two measured regimes — blips of about
+ * a second heal on the old pair in ~100 ms; by 12 s the pair is gone. The
+ * picture's own last motion is the clock: a re-dialled carrier's age resets
+ * with every refused attempt, so it cannot tell the two apart.
+ */
+const REATTACH_GRACE_BLIP_MAX_MS = 4000;
+/** A real outage's wait: one stats beat — enough to see a picture already moving. */
+const REATTACH_GRACE_SETTLE_MS = 50;
 /**
  * How long the media path may carry nothing at all before a session that says
  * `live` stops saying so. The engine's transport state reaches the client over
@@ -372,6 +393,8 @@ export function useDesktopSession(options: DesktopSessionOptions): DesktopSessio
     const mediaMovingAt = useRef<number | null>(null);
     /** Whether the picture of an open session has stopped advancing. */
     const frozen = useRef(false);
+    /** When a frozen picture last moved again, or 0 while it has not. */
+    const pictureBackAt = useRef(0);
     /** Renegotiation transients are not a new outage before this time. */
     const restartGraceUntil = useRef(0);
     /** ICE-restart attempts spent on the current drop. */
@@ -723,6 +746,7 @@ export function useDesktopSession(options: DesktopSessionOptions): DesktopSessio
                 mediaMovingAt.current = Date.now();
                 if (!frozen.current) return;
                 frozen.current = false;
+                pictureBackAt.current = Date.now();
                 // The picture advances again, so the transport can be believed
                 // for this session: live returns without waiting for it to say so.
                 if (statusRef.current === 'reconnecting' || (statusRef.current === 'failed' && heldIceFailureAt.current !== null)) onTransportState('connected', false);
@@ -763,7 +787,14 @@ export function useDesktopSession(options: DesktopSessionOptions): DesktopSessio
             stallTimer.current = setTimeout(() => checkStallRef.current(), restartGraceUntil.current - Date.now());
             return;
         }
-        if (pictureMoving(STALL_AFTER_MS) && !frozen.current && quietMs < QUIET_PICTURE_MS) {
+        // The outage's own silence is not the data channel lagging the
+        // picture: that lag starts when the picture comes back. Until the
+        // heartbeat catches up, the picture is held to the freeze bar: a
+        // still desktop's keepalive frames, a second apart, read up to
+        // 1.5 s apart through the stats poll.
+        const lagging = pictureBackAt.current > lastPingAt.current;
+        const lagMs = Date.now() - Math.max(lastPingAt.current, pictureBackAt.current);
+        if (pictureMoving(lagging ? FROZEN_AFTER_MS : STALL_AFTER_MS) && !frozen.current && lagMs < QUIET_PICTURE_MS) {
             stallTimer.current = setTimeout(() => checkStallRef.current(), STALL_AFTER_MS);
             return;
         }
@@ -885,6 +916,7 @@ export function useDesktopSession(options: DesktopSessionOptions): DesktopSessio
         mediaRef.current = null;
         mediaMovingAt.current = null;
         frozen.current = false;
+        pictureBackAt.current = 0;
         opened.current = null;
         dropCarrier(false);
         setNativeId(null);
@@ -1154,9 +1186,16 @@ export function useDesktopSession(options: DesktopSessionOptions): DesktopSessio
                 void establish(authorization);
                 return;
             }
-            // The old pair on an unchanged path resumes in ~100 ms: give it a moment before spending a restart.
+            // A picture that has only just stopped may still be riding its
+            // old ICE pair back: on an unchanged path that pair resumes in
+            // ~100 ms, so a brief blip waits that moment out before a restart
+            // is spent. A picture still past the line is a real outage — the
+            // wait shortens to one stats beat, because waiting out a blip
+            // that never comes would cost the recovery its bar.
             const held = opened.current, before = mediaRef.current;
             cancelRestart();
+            const stillMs = mediaMovingAt.current === null ? Infinity : Date.now() - mediaMovingAt.current;
+            const graceMs = stillMs < REATTACH_GRACE_BLIP_MAX_MS ? REATTACH_GRACE_MS : REATTACH_GRACE_SETTLE_MS;
             restartTimer.current = setTimeout(() => {
                 restartTimer.current = null;
                 void getStats().catch(() => []).then((rows) => {
@@ -1168,9 +1207,14 @@ export function useDesktopSession(options: DesktopSessionOptions): DesktopSessio
                     }
                     if (statusRef.current !== 'reconnecting') update({ status: 'reconnecting' });
                     restartAttempts.current = restartCycles.current = 0;
+                    // A transport `disconnected` that landed while the stats read
+                    // above was in flight armed `scheduleRestart(RESTART_AFTER_MS)`;
+                    // without clearing it first the request here would return early
+                    // on the armed timer and the restart would slip by up to 2 s.
+                    cancelRestart();
                     scheduleRestart(0);
                 });
-            }, REATTACH_GRACE_MS);
+            }, graceMs);
         })();
     }, [adoptCarrier, cancelReconnect, cancelRestart, discardSession, establish, getStats, onTransportState, scheduleRestart, stopDialing, teardown, update]);