@stream-io/video-client 1.49.0 → 1.51.0

package/src/rtc/Publisher.ts

@@ -20,10 +20,15 @@ import {
   toVideoLayers,
 } from './layers';
 import { isSvcCodec } from './codecs';
+import {
+  fromRTCDegradationPreference,
+  toRTCDegradationPreference,
+} from './helpers/degradationPreference';
 import { isAudioTrackType } from './helpers/tracks';
 import { extractMid, removeCodecsExcept, setStartBitrate } from './helpers/sdp';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { isReactNative } from '../helpers/platforms';
+import { isFirefox } from '../helpers/browsers';
 
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -52,7 +57,16 @@ export class Publisher extends BasePeerConnection {
 
     this.on('changePublishQuality', async (event) => {
       for (const videoSender of event.videoSenders) {
-        await this.changePublishQuality(videoSender);
+        // if not publishing, update the encodingConfigCache and don't modify the state.
+        // we'll apply this config on the next publish/unmute.
+        const { trackType, publishOptionId } = videoSender;
+        const bundle = this.transceiverCache.getBy(publishOptionId, trackType);
+        if (bundle) {
+          this.transceiverCache.update(bundle.publishOption, { videoSender });
+        }
+        if (isFirefox() && !this.isPublishing(trackType)) continue;
+
+        await this.changePublishQuality(videoSender, bundle);
       }
     });
 
@@ -65,9 +79,13 @@ export class Publisher extends BasePeerConnection {
   /**
    * Disposes this Publisher instance.
    */
-  dispose() {
-    super.dispose();
-    this.stopAllTracks();
+  async dispose(): Promise<void> {
+    await super.dispose();
+    try {
+      await this.stopAllTracks();
+    } catch (err) {
+      this.logger.warn('Failed to stop tracks during dispose', err);
+    }
     this.clonedTracks.clear();
   }
 
@@ -97,17 +115,12 @@ export class Publisher extends BasePeerConnection {
       // appear in the SDP in multiple transceivers
       const trackToPublish = this.cloneTrack(track);
 
-      const { transceiver } = this.transceiverCache.get(publishOption) || {};
-      if (!transceiver) {
+      const bundle = this.transceiverCache.get(publishOption);
+      if (!bundle) {
         await this.addTransceiver(trackToPublish, publishOption, options);
       } else {
-        const previousTrack = transceiver.sender.track;
-        await this.updateTransceiver(
-          transceiver,
-          trackToPublish,
-          trackType,
-          options,
-        );
+        const previousTrack = bundle.transceiver.sender.track;
+        await this.updateTransceiver(bundle, trackToPublish, options);
         if (!isReactNative()) {
           this.stopTrack(previousTrack);
         }
@@ -135,7 +148,9 @@ export class Publisher extends BasePeerConnection {
     });
 
     const params = transceiver.sender.getParameters();
-    params.degradationPreference = 'maintain-framerate';
+    params.degradationPreference =
+      toRTCDegradationPreference(publishOption.degradationPreference) ??
+      'maintain-framerate';
     await transceiver.sender.setParameters(params);
 
     const trackType = publishOption.trackType;
@@ -150,15 +165,22 @@ export class Publisher extends BasePeerConnection {
    * Updates the transceiver with the given track and track type.
    */
   private updateTransceiver = async (
-    transceiver: RTCRtpTransceiver,
+    bundle: PublishBundle,
     track: MediaStreamTrack | null,
-    trackType: TrackType,
     options: TrackPublishOptions = {},
   ) => {
+    const { transceiver, publishOption } = bundle;
+    const trackType = publishOption.trackType;
     const sender = transceiver.sender;
     if (sender.track) this.trackIdToTrackType.delete(sender.track.id);
     await sender.replaceTrack(track);
-    if (track) this.trackIdToTrackType.set(track.id, trackType);
+    if (track) {
+      this.trackIdToTrackType.set(track.id, trackType);
+      if (isFirefox() && bundle.videoSender) {
+        // restore the encoding config from the cache, if any
+        await this.changePublishQuality(bundle.videoSender, bundle);
+      }
+    }
     if (isAudioTrackType(trackType)) {
       await this.updateAudioPublishOptions(trackType, options);
     }
@@ -227,7 +249,7 @@ export class Publisher extends BasePeerConnection {
       if (hasPublishOption) continue;
       // it is safe to stop the track here, it is a clone
       this.stopTrack(transceiver.sender.track);
-      await this.updateTransceiver(transceiver, null, publishOption.trackType);
+      await this.updateTransceiver(item, null);
     }
   };
 
@@ -249,41 +271,84 @@ export class Publisher extends BasePeerConnection {
   };
 
   /**
-   * Stops the cloned track that is being published to the SFU.
+   * Re-arms the encoder for the given track type by detaching and
+   * reattaching the currently published track on each matching sender.
+   *
+   * Workaround for a WebKit / iOS Safari quirk: after a system audio
+   * session interruption (Siri, PSTN call), the `RTCRtpSender` encoder
+   * can stop producing RTP packets even though the underlying
+   * `MediaStreamTrack` is `live` and `track.muted === false`.
+   * `replaceTrack(null)` followed by `replaceTrack(track)` resets the
+   * sender's encoder pipeline without renegotiation, restoring packet
+   * flow with the same SSRC.
+   *
+   * No-op when nothing is published for the given track type.
+   *
+   * @param trackType the track type to refresh.
    */
-  stopTracks = (...trackTypes: TrackType[]) => {
+  refreshTrack = async (trackType: TrackType) => {
     for (const item of this.transceiverCache.items()) {
-      const { publishOption, transceiver } = item;
-      if (!trackTypes.includes(publishOption.trackType)) continue;
-      this.stopTrack(transceiver.sender.track);
+      if (item.publishOption.trackType !== trackType) continue;
+      const { sender } = item.transceiver;
+      const track = sender.track;
+      if (!track || track.readyState !== 'live') continue;
+      try {
+        await sender.replaceTrack(null);
+        await sender.replaceTrack(track);
+        this.logger.debug(`Refreshed ${TrackType[trackType]} sender`);
+      } catch (err) {
+        this.logger.warn(`Failed to refresh ${TrackType[trackType]}`, err);
+      }
     }
   };
 
+  /**
+   * Stops the cloned track that is being published to the SFU.
+   */
+  stopTracks = async (...trackTypes: TrackType[]) => {
+    return withoutConcurrency(
+      this.eventLockKey('changePublishQuality'),
+      async () => {
+        for (const item of this.transceiverCache.items()) {
+          const { publishOption, transceiver } = item;
+          if (!trackTypes.includes(publishOption.trackType)) continue;
+          const track = transceiver.sender.track;
+          await this.silenceSenderOnFirefox(item);
+          this.stopTrack(track);
+        }
+      },
+    );
+  };
+
   /**
    * Stops all the cloned tracks that are being published to the SFU.
    */
-  stopAllTracks = () => {
-    for (const { transceiver } of this.transceiverCache.items()) {
-      this.stopTrack(transceiver.sender.track);
-    }
-    for (const track of this.clonedTracks) {
-      this.stopTrack(track);
-    }
+  stopAllTracks = async () => {
+    return withoutConcurrency(
+      this.eventLockKey('changePublishQuality'),
+      async () => {
+        for (const item of this.transceiverCache.items()) {
+          const track = item.transceiver.sender.track;
+          await this.silenceSenderOnFirefox(item);
+          this.stopTrack(track);
+        }
+        for (const track of this.clonedTracks) {
+          this.stopTrack(track);
+        }
+      },
+    );
   };
 
-  private changePublishQuality = async (videoSender: VideoSender) => {
-    const { trackType, layers, publishOptionId } = videoSender;
-    const enabledLayers = layers.filter((l) => l.active);
+  private changePublishQuality = async (
+    videoSender: VideoSender,
+    bundle: PublishBundle | undefined,
+  ) => {
+    const enabledLayers = videoSender.layers.filter((l) => l.active);
 
     const tag = 'Update publish quality:';
     this.logger.info(`${tag} requested layers by SFU:`, enabledLayers);
 
-    const transceiverId = this.transceiverCache.find(
-      (t) =>
-        t.publishOption.id === publishOptionId &&
-        t.publishOption.trackType === trackType,
-    );
-    const sender = transceiverId?.transceiver.sender;
+    const sender = bundle?.transceiver.sender;
     if (!sender) {
       return this.logger.warn(`${tag} no video sender found.`);
     }
@@ -293,7 +358,7 @@ export class Publisher extends BasePeerConnection {
       return this.logger.warn(`${tag} there are no encodings set.`);
     }
 
-    const codecInUse = transceiverId?.publishOption.codec?.name;
+    const codecInUse = bundle?.publishOption.codec?.name;
     const usesSvcCodec = codecInUse && isSvcCodec(codecInUse);
 
     let changed = false;
@@ -344,6 +409,17 @@ export class Publisher extends BasePeerConnection {
       }
     }
 
+    const degradationPreference = toRTCDegradationPreference(
+      videoSender.degradationPreference,
+    );
+    if (
+      degradationPreference &&
+      params.degradationPreference !== degradationPreference
+    ) {
+      params.degradationPreference = degradationPreference;
+      changed = true;
+    }
+
     const activeEncoders = params.encodings.filter((e) => e.active);
     if (!changed) {
       return this.logger.info(`${tag} no change:`, activeEncoders);
@@ -514,4 +590,73 @@ export class Publisher extends BasePeerConnection {
     track.stop();
     this.clonedTracks.delete(track);
   };
+
+  /**
+   * Silences a Firefox sender on the wire during unpublish.
+   *
+   * Firefox keeps emitting RTP after track.stop(), but the right lever
+   * differs by track type:
+   *   - audio: `replaceTrack(null)` is the only reliable silencer;
+   *     `setParameters({encodings:[...active:false]})` does NOT stop
+   *     the Opus encoder.
+   *   - video: `setParameters({encodings:[...active:false]})` pauses
+   *     the encoder; `replaceTrack(null)` does NOT reliably stop the
+   *     video encoder. The prior active=true configuration is captured
+   *     onto `bundle.videoSender` so `updateTransceiver` can restore
+   *     it on the next publish.
+   *
+   * No-op on non-Firefox browsers and during teardown.
+   */
+  private silenceSenderOnFirefox = async (bundle: PublishBundle) => {
+    if (this.isDisposed || !isFirefox()) return;
+    const { transceiver, publishOption } = bundle;
+    if (isAudioTrackType(publishOption.trackType)) {
+      await transceiver.sender.replaceTrack(null).catch((err) => {
+        this.logger.warn('Failed to clear audio sender track', err);
+      });
+      return;
+    }
+    await this.disableAllEncodings(bundle);
+  };
+
+  private disableAllEncodings = async (bundle: PublishBundle) => {
+    const { transceiver, publishOption } = bundle;
+    const sender = transceiver.sender;
+    const params = sender.getParameters();
+    if (!params.encodings || params.encodings.length === 0) return;
+
+    if (!bundle.videoSender) {
+      this.transceiverCache.update(publishOption, {
+        videoSender: {
+          trackType: publishOption.trackType,
+          publishOptionId: publishOption.id,
+          codec: publishOption.codec,
+          degradationPreference: fromRTCDegradationPreference(
+            params.degradationPreference,
+          ),
+          layers: params.encodings.map((e) => ({
+            name: e.rid ?? 'q',
+            active: e.active ?? true,
+            maxBitrate: e.maxBitrate ?? 0,
+            scaleResolutionDownBy: e.scaleResolutionDownBy ?? 0,
+            maxFramerate: e.maxFramerate ?? 0,
+            // @ts-expect-error scalabilityMode is not in the typedefs yet
+            scalabilityMode: e.scalabilityMode ?? '',
+          })),
+        },
+      });
+    }
+
+    let changed = false;
+    for (const encoding of params.encodings) {
+      if (encoding.active !== false) {
+        encoding.active = false;
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    await sender.setParameters(params).catch((err) => {
+      this.logger.error('Failed to disable video sender encodings:', err);
+    });
+  };
 }

package/src/rtc/Subscriber.ts

@@ -1,9 +1,10 @@
 import { BasePeerConnection } from './BasePeerConnection';
 import { BasePeerConnectionOpts } from './types';
 import { NegotiationError } from './NegotiationError';
-import { PeerType } from '../gen/video/sfu/models/models';
+import { PeerType, TrackType } from '../gen/video/sfu/models/models';
 import { SubscriberOffer } from '../gen/video/sfu/event/events';
 import { toTrackType, trackTypeToParticipantStreamKey } from './helpers/tracks';
+import { pushToIfMissing, removeFromIfPresent } from '../helpers/array';
 import { enableStereo, removeCodecsExcept } from './helpers/sdp';
 
 /**
@@ -67,7 +68,8 @@ export class Subscriber extends BasePeerConnection {
   };
 
   private handleOnTrack = (e: RTCTrackEvent) => {
-    const [primaryStream] = e.streams;
+    const { streams, track } = e;
+    const [primaryStream] = streams;
     // example: `e3f6aaf8-b03d-4911-be36-83f47d37a76a:TRACK_TYPE_VIDEO`
     const [trackId, rawTrackType] = primaryStream.id.split(':');
     const participantToUpdate = this.state.participants.find(
@@ -75,30 +77,35 @@ export class Subscriber extends BasePeerConnection {
     );
     this.logger.debug(
       `[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`,
-      e.track.id,
-      e.track,
+      track.id,
+      track,
     );
 
+    const trackType = toTrackType(rawTrackType);
+    if (!trackType) {
+      return this.logger.error(`Unknown track type: ${rawTrackType}`);
+    }
+
     const trackDebugInfo = `${participantToUpdate?.userId} ${rawTrackType}:${trackId}`;
-    e.track.addEventListener('mute', () => {
+    track.addEventListener('mute', () => {
       this.logger.info(`[onTrack]: Track muted: ${trackDebugInfo}`);
+      this.setRemoteTrackInterrupted(trackId, trackType, true);
     });
-
-    e.track.addEventListener('unmute', () => {
+    track.addEventListener('unmute', () => {
       this.logger.info(`[onTrack]: Track unmuted: ${trackDebugInfo}`);
+      this.setRemoteTrackInterrupted(trackId, trackType, false);
     });
-
-    e.track.addEventListener('ended', () => {
+    track.addEventListener('ended', () => {
       this.logger.info(`[onTrack]: Track ended: ${trackDebugInfo}`);
+      this.setRemoteTrackInterrupted(trackId, trackType, false);
       this.state.removeOrphanedTrack(primaryStream.id);
     });
 
-    const trackType = toTrackType(rawTrackType);
-    if (!trackType) {
-      return this.logger.error(`Unknown track type: ${rawTrackType}`);
+    if (track.muted) {
+      this.setRemoteTrackInterrupted(trackId, trackType, true);
     }
 
-    this.trackIdToTrackType.set(e.track.id, trackType);
+    this.trackIdToTrackType.set(track.id, trackType);
 
     if (!participantToUpdate) {
       this.logger.warn(
@@ -133,7 +140,7 @@ export class Subscriber extends BasePeerConnection {
     // now, dispose the previous stream if it exists
     if (previousStream) {
       this.logger.info(
-        `[onTrack]: Cleaning up previous remote ${e.track.kind} tracks for userId: ${participantToUpdate.userId}`,
+        `[onTrack]: Cleaning up previous remote ${track.kind} tracks for userId: ${participantToUpdate.userId}`,
       );
       previousStream.getTracks().forEach((t) => {
         t.stop();
@@ -142,6 +149,27 @@ export class Subscriber extends BasePeerConnection {
     }
   };
 
+  private setRemoteTrackInterrupted = (
+    trackId: string,
+    trackType: TrackType,
+    interrupted: boolean,
+  ) => {
+    if (trackType !== TrackType.AUDIO) return;
+    const target = this.state.participants.find(
+      (p) => p.trackLookupPrefix === trackId,
+    );
+    if (!target) return;
+    this.state.updateParticipant(target.sessionId, (p) => {
+      const current = p.interruptedTracks ?? [];
+      const has = current.includes(trackType);
+      if (interrupted === has) return {};
+      const next = interrupted
+        ? pushToIfMissing([...current], trackType)
+        : removeFromIfPresent([...current], trackType);
+      return { interruptedTracks: next };
+    });
+  };
+
   private negotiate = async (subscriberOffer: SubscriberOffer) => {
     await this.pc.setRemoteDescription({
       type: 'offer',

package/src/rtc/TransceiverCache.ts

@@ -1,4 +1,4 @@
-import { PublishOption } from '../gen/video/sfu/models/models';
+import { PublishOption, TrackType } from '../gen/video/sfu/models/models';
 import type { OptimalVideoLayer } from './layers';
 import type { PublishBundle, TrackLayersCache } from './types';
 
@@ -25,10 +25,17 @@ export class TransceiverCache {
    * Gets the transceiver for the given publish option.
    */
   get = (publishOption: PublishOption): PublishBundle | undefined => {
+    return this.getBy(publishOption.id, publishOption.trackType);
+  };
+
+  /**
+   * Gets the transceiver for the given publish option id and track type.
+   */
+  getBy = (publishOptionId: number, trackType: TrackType) => {
     return this.cache.find(
       (bundle) =>
-        bundle.publishOption.id === publishOption.id &&
-        bundle.publishOption.trackType === publishOption.trackType,
+        bundle.publishOption.id === publishOptionId &&
+        bundle.publishOption.trackType === trackType,
     );
   };
 

package/src/rtc/__tests__/Call.reconnect.test.ts

@@ -43,7 +43,7 @@ const makeCall = () => {
  */
 const primeForReconnect = (call: Call) => {
   // put the call in a non-terminal, non-JOINED state so the do-while iterates
-  call.state.setCallingState(CallingState.JOINING);
+  call.state.setCallingState(CallingState.IDLE);
   // force the strategy-decider in the catch block to always pick REJOIN,
   // so tests that care about the rejoin rate limiter don't bounce to FAST
   // based on wall-clock timing. Individual tests that want to exercise the
@@ -136,7 +136,7 @@ describe('Call reconnect stopping conditions', () => {
       });
 
       for (let i = 0; i < 5; i++) {
-        call.state.setCallingState(CallingState.JOINING);
+        call.state.setCallingState(CallingState.IDLE);
         await call['reconnect'](WebsocketReconnectStrategy.FAST, 'test');
       }
 
@@ -404,6 +404,125 @@ describe('Call reconnect stopping conditions', () => {
   });
 });
 
+/**
+ * Entry-condition bails. `reconnect()` must drop new triggers when:
+ * - A join/reconnect/migrate lifecycle is already in progress.
+ * - A reconnect is already queued via `hasPending(reconnectConcurrencyTag)`.
+ * - The terminal `RECONNECTING_FAILED` state has been reached.
+ *
+ * These are pure short-circuits — none of the strategy implementations
+ * should be invoked.
+ */
+describe('Call reconnect entry-condition bails', () => {
+  let call: Call;
+
+  beforeEach(() => {
+    call = makeCall();
+    vi.spyOn(connectionUtils, 'sleep').mockResolvedValue(undefined);
+    vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+    vi.spyOn(call, 'get').mockResolvedValue({} as never);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const stubAllStrategies = () => ({
+    fast: vi
+      .spyOn(
+        call as unknown as { reconnectFast: () => Promise<void> },
+        'reconnectFast',
+      )
+      .mockResolvedValue(undefined),
+    rejoin: vi
+      .spyOn(
+        call as unknown as { reconnectRejoin: () => Promise<void> },
+        'reconnectRejoin',
+      )
+      .mockResolvedValue(undefined),
+    migrate: vi
+      .spyOn(
+        call as unknown as { reconnectMigrate: () => Promise<void> },
+        'reconnectMigrate',
+      )
+      .mockResolvedValue(undefined),
+  });
+
+  it('bails immediately when state is JOINING — Call.join owns recovery during the initial join window', async () => {
+    const strategies = stubAllStrategies();
+    call.state.setCallingState(CallingState.JOINING);
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(strategies.fast).not.toHaveBeenCalled();
+    expect(strategies.rejoin).not.toHaveBeenCalled();
+    expect(strategies.migrate).not.toHaveBeenCalled();
+  });
+
+  it('bails immediately when state is RECONNECTING — another reconnect is already running', async () => {
+    const strategies = stubAllStrategies();
+    call.state.setCallingState(CallingState.RECONNECTING);
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(strategies.fast).not.toHaveBeenCalled();
+    expect(strategies.rejoin).not.toHaveBeenCalled();
+    expect(strategies.migrate).not.toHaveBeenCalled();
+  });
+
+  it('bails immediately when state is MIGRATING — reconnectMigrate is in flight', async () => {
+    const strategies = stubAllStrategies();
+    call.state.setCallingState(CallingState.MIGRATING);
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(strategies.fast).not.toHaveBeenCalled();
+    expect(strategies.rejoin).not.toHaveBeenCalled();
+    expect(strategies.migrate).not.toHaveBeenCalled();
+  });
+
+  it('bails immediately when state is RECONNECTING_FAILED — terminal, no further attempts', async () => {
+    const strategies = stubAllStrategies();
+    call.state.setCallingState(CallingState.RECONNECTING_FAILED);
+
+    await call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'test');
+
+    expect(strategies.fast).not.toHaveBeenCalled();
+    expect(strategies.rejoin).not.toHaveBeenCalled();
+    expect(strategies.migrate).not.toHaveBeenCalled();
+  });
+
+  it('drops duplicate reconnect calls while one is already pending', async () => {
+    let resolveFirst: () => void = () => {};
+    const firstStrategy = new Promise<void>((resolve) => {
+      resolveFirst = resolve;
+    });
+    const rejoinSpy = vi
+      .spyOn(
+        call as unknown as { reconnectRejoin: () => Promise<void> },
+        'reconnectRejoin',
+      )
+      .mockImplementationOnce(async () => {
+        await firstStrategy;
+        call.state.setCallingState(CallingState.JOINED);
+      });
+
+    primeForReconnect(call);
+
+    const firstCall = call['reconnect'](
+      WebsocketReconnectStrategy.REJOIN,
+      'first',
+    );
+    await Promise.resolve();
+    call['reconnect'](WebsocketReconnectStrategy.REJOIN, 'second');
+
+    expect(rejoinSpy).toHaveBeenCalledTimes(1);
+
+    resolveFirst();
+    await firstCall;
+  });
+});
+
 /**
  * End-to-end-ish wiring tests: simulate failures at the peer-connection layer
  * and verify they propagate through `onReconnectionNeeded` → `Call.reconnect` →