@stream-io/video-client 1.61.1 → 1.62.0

package/src/ringing/__tests__/reconcileRingState.test.ts

@@ -202,6 +202,39 @@ describe('reconcileRingState', () => {
         message: 'ring: call ended',
       });
     });
+
+    describe('as the callee', () => {
+      const ended = { reason: 'ended', message: 'ring: call ended' };
+
+      it('leaves when the session has ended', async () => {
+        const call = ringingCall({ currentUserId: 'm2', createdById: 'm1' });
+        setSession(call, { ended_at: timestamp() });
+
+        expect(await reconcile(call)).toBe(true);
+        expect(call.leave).toHaveBeenCalledWith(ended);
+      });
+
+      it('leaves when the call itself has ended', async () => {
+        const call = ringingCall({ currentUserId: 'm2', createdById: 'm1' });
+        setSession(call, {});
+        call.state.setEndedAt(new Date());
+
+        expect(await reconcile(call)).toBe(true);
+        expect(call.leave).toHaveBeenCalledWith(ended);
+      });
+
+      it('leaves once with the ended message when the creator also rejected', async () => {
+        const call = ringingCall({ currentUserId: 'm2', createdById: 'm1' });
+        setSession(call, {
+          ended_at: timestamp(),
+          rejected_by: { m1: timestamp() },
+        });
+
+        expect(await reconcile(call)).toBe(true);
+        expect(call.leave).toHaveBeenCalledTimes(1);
+        expect(call.leave).toHaveBeenCalledWith(ended);
+      });
+    });
   });
 
   it('is terminal once the call is no longer ringing', async () => {

package/src/ringing/reconcileRingState.ts

@@ -6,15 +6,16 @@ import type { CallLeaveOptions } from '../types';
 /**
  * Decides what a ringing call should do next, based on the current call state.
  *
- * The `call.accepted`, `call.rejected` and `call.missed` handlers and the ring
- * state poller both run this. They differ only in how the state got there: the
- * handlers rely on `CallState.updateFromEvent`, which runs before them, and the
- * poller applies the polled ring state itself.
+ * The `call.accepted` and `call.rejected` handlers, the ring state poller and
+ * the rewatch after a WS reconnect all run this. They differ only in how the
+ * state got there: the handlers rely on `CallState.updateFromEvent`, which runs
+ * before them, while the poller applies the polled ring state itself and the
+ * rewatch applies the queried call state.
  *
  * @param call the call to reconcile.
- * @param joinSource which of the two triggered this run, reported on the
- * caller's join: `ring-ws` for the event handlers, `ring-poll-api` for the
- * poller.
+ * @param joinSource what triggered this run, reported on the caller's join:
+ * `ring-ws` for the event handlers, `ring-poll-api` for the poller and the
+ * rewatch (both come from an API response).
  * @returns whether the ring reached a terminal state. A failed join is not
  * terminal: the caller should keep trying while the ring is open.
  */
@@ -79,10 +80,17 @@ const reconcileAsCaller = async (
 };
 
 // the current user's own accept or reject, on this or another device, is
-// handled by `resolveOwnRingOutcome`, and `call.ended` by `watchCallEnded`.
+// handled by `resolveOwnRingOutcome`, and a live `call.ended` by
+// `watchCallEnded`. An end missed while offline is handled here.
 const reconcileAsCallee = async (call: Call): Promise<boolean> => {
-  const createdById = call.state.createdBy?.id;
-  const rejectedBy = call.state.session?.rejected_by ?? {};
+  const { session, endedAt, createdBy } = call.state;
+  if (endedAt || session?.ended_at) {
+    call.logger.info('ring: the call has ended, leaving');
+    return leave(call, { reason: 'ended', message: 'ring: call ended' });
+  }
+
+  const createdById = createdBy?.id;
+  const rejectedBy = session?.rejected_by ?? {};
   if (createdById && rejectedBy[createdById]) {
     call.logger.info('ring: the caller cancelled, leaving');
     return leave(call, {

package/src/rtc/BasePeerConnection.ts

@@ -19,6 +19,7 @@ import { toJSON } from './helpers/iceCandiates';
 import {
   BasePeerConnectionOpts,
   OnIceConnected,
+  OnNoLocalCandidates,
   OnPeerConnectionStateChange,
   OnReconnectionNeeded,
   OnRemoteTrackUnmute,
@@ -43,10 +44,12 @@ export abstract class BasePeerConnection {
 
   protected onReconnectionNeeded?: OnReconnectionNeeded;
   private onIceConnected?: OnIceConnected;
+  private onNoLocalCandidates?: OnNoLocalCandidates;
   private onPeerConnectionStateChange?: OnPeerConnectionStateChange;
   protected onRemoteTrackUnmute?: OnRemoteTrackUnmute;
   private readonly iceRestartDelay: number;
   private iceHasEverConnected = false;
+  private localCandidatesGathered = 0;
   private iceRestartTimeout?: NodeJS.Timeout;
   private preConnectStuckTimeout?: NodeJS.Timeout;
   protected isIceRestarting = false;
@@ -73,6 +76,7 @@ export abstract class BasePeerConnection {
       dispatcher,
       onReconnectionNeeded,
       onIceConnected,
+      onNoLocalCandidates,
       onPeerConnectionStateChange,
       onRemoteTrackUnmute,
       tag,
@@ -93,6 +97,7 @@ export abstract class BasePeerConnection {
     this.tag = tag;
     this.onReconnectionNeeded = onReconnectionNeeded;
     this.onIceConnected = onIceConnected;
+    this.onNoLocalCandidates = onNoLocalCandidates;
     this.onPeerConnectionStateChange = onPeerConnectionStateChange;
     this.onRemoteTrackUnmute = onRemoteTrackUnmute;
     this.logger = videoLoggerSystem.getLogger(
@@ -148,6 +153,7 @@ export abstract class BasePeerConnection {
     this.preConnectStuckTimeout = undefined;
     this.onReconnectionNeeded = undefined;
     this.onIceConnected = undefined;
+    this.onNoLocalCandidates = undefined;
     this.onPeerConnectionStateChange = undefined;
     this.onRemoteTrackUnmute = undefined;
     this.isDisposed = true;
@@ -285,6 +291,20 @@ export abstract class BasePeerConnection {
     return this.trackIdToTrackType.get(trackId);
   };
 
+  /**
+   * Returns `true` once ICE has reached `connected`/`completed` at least
+   * once during the lifetime of this peer connection.
+   */
+  hasIceEverConnected = () => this.iceHasEverConnected;
+
+  /**
+   * Returns `true` when the latest ICE gathering round completed without
+   * producing a single local candidate.
+   */
+  hasNoLocalCandidates = () =>
+    this.pc.iceGatheringState === 'complete' &&
+    this.localCandidatesGathered === 0;
+
   /**
    * Checks if the `RTCPeerConnection` is healthy.
    * It checks the ICE connection state and the peer connection state.
@@ -311,6 +331,7 @@ export abstract class BasePeerConnection {
       this.logger.debug('null ice candidate');
       return;
     }
+    if (candidate.candidate) this.localCandidatesGathered++;
 
     const iceCandidate = toJSON(candidate);
     this.sfuClient
@@ -389,6 +410,20 @@ export abstract class BasePeerConnection {
   private handleConnectionStateUpdate = (
     state: RTCIceConnectionState | RTCPeerConnectionState,
   ) => {
+    // Fire `onIceConnected` exactly once per peer-connection lifetime, the
+    // first time ICE reaches `connected`/`completed` end-to-end. Recorded
+    // ahead of the guards below so a connection established while offline,
+    // reconnecting or restarting ICE is not missed. Used by `Call` to reset
+    // the unsupported-network failure counter only after WebRTC has actually
+    // recovered, not merely on SFU join.
+    if (
+      (state === 'connected' || state === 'completed') &&
+      !this.iceHasEverConnected
+    ) {
+      this.iceHasEverConnected = true;
+      this.onIceConnected?.(this.peerType);
+    }
+
     const { callingState } = this.state;
     if (callingState === CallingState.OFFLINE) return;
     if (callingState === CallingState.RECONNECTING) return;
@@ -466,14 +501,6 @@ export abstract class BasePeerConnection {
 
       case 'connected':
       case 'completed':
-        // Fire `onIceConnected` exactly once per peer-connection lifetime —
-        // the first time ICE reaches `connected`/`completed` end-to-end.
-        // Used by `Call` to reset the unsupported-network failure counter
-        // only after WebRTC has actually recovered, not merely on SFU join.
-        if (!this.iceHasEverConnected) {
-          this.iceHasEverConnected = true;
-          this.onIceConnected?.(this.peerType);
-        }
         // clear any scheduled restartICE since the connection is healthy
         if (this.iceRestartTimeout) {
           this.logger.info('connected connection, canceling restartICE');
@@ -502,7 +529,18 @@ export abstract class BasePeerConnection {
    * Handles the ICE gathering state change event.
    */
   private onIceGatherChange = () => {
-    this.logger.debug(`ICE Gathering State`, this.pc.iceGatheringState);
+    const state = this.pc.iceGatheringState;
+    this.logger.debug(`ICE Gathering State`, state);
+    if (state === 'gathering') {
+      this.localCandidatesGathered = 0;
+    } else if (
+      state === 'complete' &&
+      this.localCandidatesGathered === 0 &&
+      !this.iceHasEverConnected
+    ) {
+      this.logger.info('ICE gathering completed without local candidates');
+      this.onNoLocalCandidates?.(this.peerType);
+    }
   };
 
   /**