@stream-io/video-client 1.54.0 → 1.55.0

package/src/rtc/__tests__/Subscriber.test.ts

@@ -141,26 +141,6 @@ describe('Subscriber', () => {
       );
     });
 
-    it(`isStable() returns true only when ICE is connected/completed and connectionState is connected`, () => {
-      // @ts-expect-error - private field
-      subscriber['pc'].iceConnectionState = 'connected';
-      // @ts-expect-error - private field
-      subscriber['pc'].connectionState = 'connected';
-      expect(subscriber.isStable()).toBe(true);
-
-      // @ts-expect-error - private field
-      subscriber['pc'].iceConnectionState = 'completed';
-      expect(subscriber.isStable()).toBe(true);
-
-      // @ts-expect-error - private field
-      subscriber['pc'].iceConnectionState = 'disconnected';
-      expect(subscriber.isStable()).toBe(false);
-
-      // @ts-expect-error - private field
-      subscriber['pc'].iceConnectionState = 'new';
-      expect(subscriber.isStable()).toBe(false);
-    });
-
     it(`iceHasEverConnected tracks lifetime connectivity`, () => {
       expect(subscriber['iceHasEverConnected']).toBe(false);
       simulatePriorIceConnected();
@@ -194,6 +174,277 @@ describe('Subscriber', () => {
     });
   });
 
+  describe('Subscriber negotiation', () => {
+    const subscriberOffer: SubscriberOffer = {
+      sdp: 'subscriber-offer-sdp',
+      iceRestart: false,
+      negotiationId: 10,
+    };
+
+    beforeEach(() => {
+      sfuClient.sendAnswer = vi.fn().mockResolvedValue({ response: {} });
+    });
+
+    it('resets isIceRestarting once a negotiation completes', async () => {
+      subscriber['isIceRestarting'] = true;
+
+      await subscriber['negotiate'](subscriberOffer);
+
+      expect(sfuClient.sendAnswer).toHaveBeenCalledWith({
+        peerType: PeerType.SUBSCRIBER,
+        sdp: '',
+        negotiationId: 10,
+      });
+      expect(subscriber['isIceRestarting']).toBe(false);
+    });
+
+    it('resets isIceRestarting even when the negotiation fails', async () => {
+      subscriber['isIceRestarting'] = true;
+      sfuClient.sendAnswer = vi
+        .fn()
+        .mockRejectedValue(new Error('send answer failed'));
+
+      await expect(subscriber['negotiate'](subscriberOffer)).rejects.toThrow(
+        'send answer failed',
+      );
+      expect(subscriber['isIceRestarting']).toBe(false);
+    });
+
+    it('rolls back the remote description when a negotiation fails mid-offer', async () => {
+      const setRemoteDescription = vi.fn().mockResolvedValue({});
+      subscriber['pc'].setRemoteDescription = setRemoteDescription;
+      // @ts-expect-error - readonly field
+      subscriber['pc'].signalingState = 'have-remote-offer';
+      sfuClient.sendAnswer = vi
+        .fn()
+        .mockRejectedValue(new Error('send answer failed'));
+
+      await expect(subscriber['negotiate'](subscriberOffer)).rejects.toThrow(
+        'send answer failed',
+      );
+      expect(setRemoteDescription).toHaveBeenCalledWith({ type: 'rollback' });
+    });
+
+    it('does not roll back when the peer connection never applied the offer', async () => {
+      // signalingState stays 'stable' because setRemoteDescription rejected
+      subscriber['pc'].setRemoteDescription = vi
+        .fn()
+        .mockRejectedValue(new Error('set remote description failed'));
+
+      await expect(subscriber['negotiate'](subscriberOffer)).rejects.toThrow(
+        'set remote description failed',
+      );
+      expect(subscriber['pc'].setRemoteDescription).not.toHaveBeenCalledWith({
+        type: 'rollback',
+      });
+    });
+
+    it('propagates the original error even when the rollback itself fails', async () => {
+      subscriber['pc'].setRemoteDescription = vi
+        .fn()
+        .mockResolvedValueOnce({}) // applying the offer succeeds
+        .mockRejectedValueOnce(new Error('rollback failed')); // rollback fails
+      // @ts-expect-error - readonly field
+      subscriber['pc'].signalingState = 'have-remote-offer';
+      sfuClient.sendAnswer = vi
+        .fn()
+        .mockRejectedValue(new Error('send answer failed'));
+
+      await expect(subscriber['negotiate'](subscriberOffer)).rejects.toThrow(
+        'send answer failed',
+      );
+    });
+
+    it('restores the previous generation in the buffer when a negotiation rolls back', async () => {
+      const sdp = (ufrag: string) =>
+        `v=0\r\na=ice-ufrag:${ufrag}\r\na=ice-pwd:pwd\r\n`;
+      const updateActiveGeneration = vi.spyOn(
+        sfuClient.iceTrickleBuffer,
+        'updateActiveGeneration',
+      );
+      // previously-committed generation u0; the new (failing) offer is u1
+      // @ts-expect-error - overriding readonly mock field
+      subscriber['pc'].currentRemoteDescription = {
+        type: 'offer',
+        sdp: sdp('u0'),
+      };
+      // @ts-expect-error - overriding readonly mock field
+      subscriber['pc'].remoteDescription = { type: 'offer', sdp: sdp('u1') };
+      // @ts-expect-error - readonly field
+      subscriber['pc'].signalingState = 'have-remote-offer';
+      sfuClient.sendAnswer = vi
+        .fn()
+        .mockRejectedValue(new Error('send answer failed'));
+
+      await expect(subscriber['negotiate'](subscriberOffer)).rejects.toThrow(
+        'send answer failed',
+      );
+
+      // advanced to the new generation, then restored to the rolled-back one
+      expect(updateActiveGeneration).toHaveBeenCalledWith(
+        PeerType.SUBSCRIBER,
+        sdp('u1'),
+      );
+      expect(updateActiveGeneration).toHaveBeenLastCalledWith(
+        PeerType.SUBSCRIBER,
+        sdp('u0'),
+      );
+    });
+  });
+
+  describe('negotiation failure recovery', () => {
+    const offer = SubscriberOffer.create({
+      sdp: 'offer-sdp',
+      iceRestart: false,
+    });
+    const dispatchOffer = () =>
+      dispatcher.dispatch(
+        SfuEvent.create({
+          eventPayload: {
+            oneofKind: 'subscriberOffer',
+            subscriberOffer: offer,
+          },
+        }) as DispatchableMessage<'subscriberOffer'>,
+        'test',
+      );
+    const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+    it('retries via ICE restart on a single negotiation failure', async () => {
+      // @ts-expect-error - private method
+      subscriber.negotiate = vi.fn().mockRejectedValue(new Error('boom'));
+      // @ts-expect-error - protected method
+      subscriber.tryRestartIce = vi.fn();
+      subscriber['onReconnectionNeeded'] = vi.fn();
+
+      dispatchOffer();
+      await flush();
+
+      // @ts-expect-error - protected method
+      expect(subscriber.tryRestartIce).toHaveBeenCalledTimes(1);
+      expect(subscriber['onReconnectionNeeded']).not.toHaveBeenCalled();
+    });
+
+    it('escalates to REJOIN after repeated failures instead of looping ICE restarts', async () => {
+      // @ts-expect-error - private method
+      subscriber.negotiate = vi.fn().mockRejectedValue(new Error('boom'));
+      // @ts-expect-error - protected method
+      subscriber.tryRestartIce = vi.fn();
+      subscriber['onReconnectionNeeded'] = vi.fn();
+
+      // three consecutive failures (the configured ceiling)
+      for (let i = 0; i < 3; i++) {
+        dispatchOffer();
+        await flush();
+      }
+
+      // the first two fall through to an ICE restart; the third gives up and rejoins
+      // @ts-expect-error - protected method
+      expect(subscriber.tryRestartIce).toHaveBeenCalledTimes(2);
+      expect(subscriber['onReconnectionNeeded']).toHaveBeenCalledWith(
+        WebsocketReconnectStrategy.REJOIN,
+        ReconnectReason.SUBSCRIBER_NEGOTIATION_FAILED,
+        PeerType.SUBSCRIBER,
+      );
+    });
+
+    it('resets the failure counter after a successful negotiation', async () => {
+      // @ts-expect-error - private method
+      subscriber.negotiate = vi
+        .fn()
+        .mockRejectedValueOnce(new Error('boom'))
+        .mockRejectedValueOnce(new Error('boom'))
+        .mockResolvedValueOnce(undefined)
+        .mockRejectedValueOnce(new Error('boom'))
+        .mockRejectedValueOnce(new Error('boom'));
+      // @ts-expect-error - protected method
+      subscriber.tryRestartIce = vi.fn();
+      subscriber['onReconnectionNeeded'] = vi.fn();
+
+      for (let i = 0; i < 5; i++) {
+        dispatchOffer();
+        await flush();
+      }
+
+      // four failures total, but never three in a row, so no REJOIN
+      expect(subscriber['onReconnectionNeeded']).not.toHaveBeenCalled();
+      // @ts-expect-error - protected method
+      expect(subscriber.tryRestartIce).toHaveBeenCalledTimes(4);
+    });
+  });
+
+  describe('ICE candidate trickling', () => {
+    const trickle = (ufrag: string, candidate: string) => ({
+      peerType: PeerType.SUBSCRIBER,
+      iceCandidate: JSON.stringify({ usernameFragment: ufrag, candidate }),
+    });
+
+    const sdp = (ufrag: string) =>
+      `v=0\r\na=ice-ufrag:${ufrag}\r\na=ice-pwd:pwd\r\n`;
+
+    const setRemoteUfrag = (ufrag: string) => {
+      // @ts-expect-error - overriding readonly remoteDescription on the mock
+      subscriber['pc'].remoteDescription = { type: 'offer', sdp: sdp(ufrag) };
+    };
+
+    const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+    it('declares the active generation from the remote description and adds emitted candidates', async () => {
+      const addIceCandidate = vi
+        .spyOn(subscriber['pc'], 'addIceCandidate')
+        .mockResolvedValue();
+      const updateActiveGeneration = vi.spyOn(
+        sfuClient.iceTrickleBuffer,
+        'updateActiveGeneration',
+      );
+      setRemoteUfrag('u1');
+      sfuClient.iceTrickleBuffer.push(trickle('u1', 'c1'));
+
+      subscriber['addTrickledIceCandidates']();
+      await flush();
+
+      expect(updateActiveGeneration).toHaveBeenCalledWith(
+        PeerType.SUBSCRIBER,
+        sdp('u1'),
+      );
+      expect(addIceCandidate).toHaveBeenCalledWith({
+        usernameFragment: 'u1',
+        candidate: 'c1',
+      });
+    });
+
+    it('does not re-add a superseded-generation candidate after an ICE restart', async () => {
+      const addIceCandidate = vi
+        .spyOn(subscriber['pc'], 'addIceCandidate')
+        .mockResolvedValue();
+
+      setRemoteUfrag('u0');
+      sfuClient.iceTrickleBuffer.push(trickle('u0', 'c0'));
+      subscriber['addTrickledIceCandidates']();
+      await flush();
+      expect(addIceCandidate).toHaveBeenCalledWith({
+        usernameFragment: 'u0',
+        candidate: 'c0',
+      });
+
+      addIceCandidate.mockClear();
+
+      // ICE restart -> generation u1; the old u0 candidate must not be re-added
+      setRemoteUfrag('u1');
+      sfuClient.iceTrickleBuffer.push(trickle('u1', 'c1'));
+      subscriber['addTrickledIceCandidates']();
+      await flush();
+
+      expect(addIceCandidate).toHaveBeenCalledWith({
+        usernameFragment: 'u1',
+        candidate: 'c1',
+      });
+      expect(addIceCandidate).not.toHaveBeenCalledWith({
+        usernameFragment: 'u0',
+        candidate: 'c0',
+      });
+    });
+  });
+
   describe('OnTrack', () => {
     it('should add unknown tracks to the to the call state', () => {
       const mediaStream = new MediaStream();

package/src/rtc/helpers/__tests__/iceCandiates.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest';
+import { getCandidateUfrag, parseIceUfrag, toJSON } from '../iceCandiates';
+
+describe('iceCandiates helpers', () => {
+  describe('toJSON', () => {
+    it('parses the ufrag from the candidate string when usernameFragment is missing (react-native-webrtc)', () => {
+      const candidate = {
+        candidate:
+          'candidate:1 1 udp 100 1.2.3.4 5000 typ host ufrag ABC network-id 1',
+        sdpMid: '0',
+      } as RTCIceCandidate;
+
+      const result = JSON.parse(toJSON(candidate));
+      expect(result.usernameFragment).toBe('ABC');
+      expect(result.sdpMid).toBe('0');
+    });
+
+    it('leaves usernameFragment undefined when it is missing and the candidate has no ufrag token', () => {
+      const candidate = {
+        candidate: 'candidate:1 1 udp 100 1.2.3.4 5000 typ host generation 0',
+      } as unknown as RTCIceCandidate;
+
+      const result = JSON.parse(toJSON(candidate));
+      expect(result.usernameFragment).toBeUndefined();
+    });
+  });
+
+  describe('parseIceUfrag', () => {
+    it('extracts the ice-ufrag from an SDP', () => {
+      const sdp = 'v=0\r\na=ice-ufrag:F7gIaBcD\r\na=ice-pwd:somepwd\r\n';
+      expect(parseIceUfrag(sdp)).toBe('F7gIaBcD');
+    });
+
+    it('returns undefined when the SDP has no ice-ufrag', () => {
+      expect(parseIceUfrag('v=0\r\na=ice-pwd:somepwd\r\n')).toBeUndefined();
+    });
+
+    it('returns undefined for an undefined SDP', () => {
+      expect(parseIceUfrag(undefined)).toBeUndefined();
+    });
+  });
+
+  describe('getCandidateUfrag', () => {
+    it('uses usernameFragment when present', () => {
+      expect(
+        getCandidateUfrag({
+          candidate: 'candidate:1 1 udp 100 1.2.3.4 5000 typ host',
+          usernameFragment: 'DEF',
+        }),
+      ).toBe('DEF');
+    });
+
+    it('prefers usernameFragment over the candidate-string ufrag token', () => {
+      expect(
+        getCandidateUfrag({
+          candidate: 'candidate:1 1 udp 100 1.2.3.4 5000 typ host ufrag ABC',
+          usernameFragment: 'DEF',
+        }),
+      ).toBe('DEF');
+    });
+
+    it('falls back to the ufrag token in the candidate string when usernameFragment is absent', () => {
+      expect(
+        getCandidateUfrag({
+          candidate:
+            'candidate:1 1 udp 100 1.2.3.4 5000 typ host ufrag ABC network-id 1',
+        }),
+      ).toBe('ABC');
+    });
+
+    it('reads the ufrag from a realistic SFU trickled candidate string', () => {
+      // The SFU embeds the generation as a `ufrag` token in the candidate
+      // string, so the consumer can classify it without a usernameFragment.
+      const candidate =
+        'candidate:842163049 1 udp 1677729535 203.0.113.1 56789 typ srflx raddr 0.0.0.0 rport 0 generation 0 ufrag F7gIaBcD network-id 1 network-cost 10';
+      expect(getCandidateUfrag({ candidate })).toBe('F7gIaBcD');
+    });
+
+    it('returns undefined when neither a usernameFragment nor a ufrag token is present', () => {
+      expect(
+        getCandidateUfrag({
+          candidate: 'candidate:1 1 udp 100 1.2.3.4 5000 typ host',
+        }),
+      ).toBeUndefined();
+      expect(getCandidateUfrag({})).toBeUndefined();
+    });
+  });
+});

package/src/rtc/helpers/degradationPreference.ts

@@ -18,6 +18,7 @@ export const toRTCDegradationPreference = (
       return undefined;
     default:
       ensureExhausted(preference, 'Unknown degradation preference');
+      return undefined;
   }
 };
 

package/src/rtc/helpers/iceCandiates.ts

@@ -0,0 +1,35 @@
+/**
+ * Converts the ICE candidate to a JSON string.
+ */
+export const toJSON = (candidate: RTCIceCandidate) => {
+  if (!candidate.usernameFragment) {
+    // react-native-webrtc doesn't include usernameFragment in the candidate
+    const usernameFragment = parseUfragFromCandidate(candidate.candidate);
+    return JSON.stringify({ ...candidate, usernameFragment });
+  }
+  return JSON.stringify(candidate.toJSON());
+};
+
+/**
+ * Extracts the ICE ufrag from an SDP, or `undefined` when absent.
+ */
+export const parseIceUfrag = (sdp: string | undefined): string | undefined => {
+  return sdp?.match(/^a=ice-ufrag:(\S+)/m)?.[1];
+};
+
+/**
+ * Extracts the ICE ufrag (generation) a trickled candidate was gathered under.
+ */
+export const getCandidateUfrag = (ice: RTCIceCandidateInit) => {
+  return ice.usernameFragment ?? parseUfragFromCandidate(ice.candidate);
+};
+
+/**
+ * Parses the `ufrag` token from a raw ICE candidate string
+ * (e.g. `candidate:... ufrag <value> ...`). Returns `undefined` when absent.
+ */
+const parseUfragFromCandidate = (candidate: string | undefined) => {
+  const segments = candidate?.split(' ') ?? [];
+  const index = segments.indexOf('ufrag');
+  return index !== -1 ? segments[index + 1] : undefined;
+};

package/src/rtc/helpers/sdp.ts

@@ -158,11 +158,12 @@ export const removeCodecsExcept = (
     // If a specific fmtp profile is requested, only keep payloads whose fmtp config matches it
     if (fmtpProfileToKeep) {
       const filtered = new Set<number>();
-      const required = new Set(fmtpProfileToKeep.split(';'));
+      const required = fmtpProfileToKeep.split(';');
       for (const fmtp of media.fmtp) {
+        const actual = new Set(fmtp.config.split(';'));
         if (
           payloadsToKeep.has(fmtp.payload) &&
-          required.difference(new Set(fmtp.config.split(';'))).size === 0
+          required.every((part) => actual.has(part))
         ) {
           filtered.add(fmtp.payload);
         }

package/src/rtc/helpers/tracks.ts

@@ -23,6 +23,7 @@ export const trackTypeToParticipantStreamKey = (
       throw new Error('Track type is unspecified');
     default:
       ensureExhausted(trackType, 'Unknown track type');
+      return undefined;
   }
 };
 
@@ -40,6 +41,7 @@ export const muteTypeToTrackType = (
       return TrackType.SCREEN_SHARE_AUDIO;
     default:
       ensureExhausted(muteType, 'Unknown mute type');
+      return undefined;
   }
 };
 

package/src/rtc/types.ts

@@ -28,6 +28,8 @@ export const ReconnectReason = {
   CONNECTION_FAILED: 'connection_failed',
   /** `restartIce()` rejected. */
   RESTART_ICE_FAILED: 'restart_ice_failed',
+  /** Subscriber renegotiation kept failing, escalate to REJOIN. */
+  SUBSCRIBER_NEGOTIATION_FAILED: 'subscriber_negotiation_failed',
   /** SFU `goAway` event, migrate to a new SFU. */
   GO_AWAY: 'go_away',
   /** Network came back online after going offline. */