@stream-io/video-client 1.47.0 → 1.49.0

package/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -12,11 +12,12 @@ import {
 import { of } from 'rxjs';
 import '../../rtc/__tests__/mocks/webrtc.mocks';
 import { OwnCapability } from '../../gen/coordinator';
-import { SoundStateChangeHandler } from '../../helpers/sound-detector';
 import { settled, withoutConcurrency } from '../../helpers/concurrency';
 
-let handler: SoundStateChangeHandler = () => {};
-let unsubscribeHandlers: ReturnType<typeof vi.fn>[] = [];
+let speechActivityCallback:
+  | ((state: { isSoundDetected: boolean }) => void)
+  | null = null;
+let unsubscribeMocks: ReturnType<typeof vi.fn>[] = [];
 
 vi.mock('../../helpers/platforms.ts', () => {
   return {
@@ -46,28 +47,21 @@ vi.mock('../../Call.ts', () => {
   };
 });
 
-vi.mock('../../helpers/RNSpeechDetector.ts', () => {
-  console.log('MOCKING RNSpeechDetector');
-  return {
-    RNSpeechDetector: vi.fn().mockImplementation(() => ({
-      start: vi.fn((callback) => {
-        handler = callback;
-        const unsubscribe = vi.fn();
-        unsubscribeHandlers.push(unsubscribe);
-        return unsubscribe;
-      }),
-      stop: vi.fn(),
-      onSpeakingDetectedStateChange: vi.fn(),
-    })),
-  };
-});
-
 describe('MicrophoneManager React Native', () => {
   let manager: MicrophoneManager;
   let checkPermissionMock: ReturnType<typeof vi.fn>;
+  let subscribeMock: ReturnType<typeof vi.fn>;
+
   beforeEach(() => {
-    unsubscribeHandlers = [];
+    speechActivityCallback = null;
+    unsubscribeMocks = [];
     checkPermissionMock = vi.fn(async () => true);
+    subscribeMock = vi.fn((cb) => {
+      speechActivityCallback = cb;
+      const unsub = vi.fn();
+      unsubscribeMocks.push(unsub);
+      return unsub;
+    });
 
     globalThis.streamRNVideoSDK = {
       callManager: {
@@ -78,6 +72,11 @@ describe('MicrophoneManager React Native', () => {
       permissions: {
         check: checkPermissionMock,
       },
+      nativeEvents: {
+        speechActivity: {
+          subscribe: subscribeMock,
+        },
+      },
     };
 
     const devicePersistence = { enabled: false, storageKey: '' };
@@ -100,7 +99,7 @@ describe('MicrophoneManager React Native', () => {
 
     await vi.waitUntil(() => fn.mock.calls.length > 0, { timeout: 100 });
     expect(fn).toHaveBeenCalled();
-    expect(manager['rnSpeechDetector']?.start).toHaveBeenCalled();
+    expect(subscribeMock).toHaveBeenCalled();
   });
 
   it('should check native microphone permission before starting detection', async () => {
@@ -146,15 +145,15 @@ describe('MicrophoneManager React Native', () => {
 
   it('should update speaking while muted state', async () => {
     await manager['startSpeakingWhileMutedDetection']();
-    expect(manager['rnSpeechDetector']?.start).toHaveBeenCalled();
+    expect(subscribeMock).toHaveBeenCalled();
 
     expect(manager.state.speakingWhileMuted).toBe(false);
 
-    handler!({ isSoundDetected: true, audioLevel: 2 });
+    speechActivityCallback!({ isSoundDetected: true });
 
     expect(manager.state.speakingWhileMuted).toBe(true);
 
-    handler!({ isSoundDetected: false, audioLevel: 0 });
+    speechActivityCallback!({ isSoundDetected: false });
 
     expect(manager.state.speakingWhileMuted).toBe(false);
   });
@@ -163,21 +162,21 @@ describe('MicrophoneManager React Native', () => {
     await manager['startSpeakingWhileMutedDetection']('device-1');
     await manager['startSpeakingWhileMutedDetection']('device-1');
 
-    expect(unsubscribeHandlers).toHaveLength(1);
+    expect(unsubscribeMocks).toHaveLength(1);
 
     await manager['stopSpeakingWhileMutedDetection']();
-    expect(unsubscribeHandlers[0]).toHaveBeenCalledTimes(1);
+    expect(unsubscribeMocks[0]).toHaveBeenCalledTimes(1);
   });
 
   it('should cleanup previous speech detector before starting a new one', async () => {
     await manager['startSpeakingWhileMutedDetection']('device-1');
     await manager['startSpeakingWhileMutedDetection']('device-2');
 
-    expect(unsubscribeHandlers).toHaveLength(2);
-    expect(unsubscribeHandlers[0]).toHaveBeenCalledTimes(1);
+    expect(unsubscribeMocks).toHaveLength(2);
+    expect(unsubscribeMocks[0]).toHaveBeenCalledTimes(1);
 
     await manager['stopSpeakingWhileMutedDetection']();
-    expect(unsubscribeHandlers[1]).toHaveBeenCalledTimes(1);
+    expect(unsubscribeMocks[1]).toHaveBeenCalledTimes(1);
   });
 
   it('should stop speaking while muted notifications if user loses permission to send audio', async () => {

package/src/devices/__tests__/ScreenShareManager.test.ts

@@ -34,7 +34,6 @@ describe('ScreenShareManager', () => {
   let manager: ScreenShareManager;
 
   beforeEach(() => {
-    const devicePersistence = { enabled: false, storageKey: '' };
     manager = new ScreenShareManager(
       new Call({
         id: '',
@@ -42,7 +41,6 @@ describe('ScreenShareManager', () => {
         streamClient: new StreamClient('abc123'),
         clientStore: new StreamVideoWriteableStateStore(),
       }),
-      devicePersistence,
     );
   });
 

package/src/devices/devices.ts

@@ -340,7 +340,6 @@ export const getScreenShareStream = async (
   const tag = `navigator.mediaDevices.getDisplayMedia.${getDisplayMediaExecId++}.`;
   try {
     const constraints: DisplayMediaStreamOptions = {
-      // @ts-expect-error - not present in types yet
       systemAudio: 'include',
       ...options,
       video:
@@ -357,6 +356,8 @@ export const getScreenShareStream = async (
           ? options.audio
           : {
               channelCount: { ideal: 2 },
+              // @ts-expect-error not yet present in the types
+              restrictOwnAudio: true,
               echoCancellation: false,
               autoGainControl: false,
               noiseSuppression: false,

package/src/helpers/SlidingWindowRateLimiter.ts

@@ -0,0 +1,49 @@
+/**
+ * A generic sliding-window rate limiter.
+ *
+ * Allows at most `maxAttempts` registrations inside a rolling `windowMs`.
+ * Attempts spaced further apart than `windowMs` are always allowed.
+ */
+export class SlidingWindowRateLimiter {
+  private maxAttempts: number;
+  private windowMs: number;
+  private timestamps: number[] = [];
+
+  constructor(maxAttempts: number, windowMs: number) {
+    this.maxAttempts = maxAttempts;
+    this.windowMs = windowMs;
+  }
+
+  /**
+   * Attempts to register a new event at `now`. Returns `true` if the attempt
+   * fits inside the budget (and records it), or `false` if the budget is
+   * exhausted (in which case no timestamp is recorded).
+   */
+  tryRegister = (now: number = Date.now()): boolean => {
+    this.prune(now);
+    if (this.timestamps.length >= this.maxAttempts) return false;
+    this.timestamps.push(now);
+    return true;
+  };
+
+  /**
+   * Clears the attempt history.
+   */
+  reset = (): void => {
+    this.timestamps = [];
+  };
+
+  /**
+   * Updates the budget and window size. Existing timestamps are kept; they
+   * will be pruned by the next `tryRegister` call.
+   */
+  setLimits = (maxAttempts: number, windowMs: number): void => {
+    this.maxAttempts = maxAttempts;
+    this.windowMs = windowMs;
+  };
+
+  private prune = (now: number): void => {
+    const cutoff = now - this.windowMs;
+    this.timestamps = this.timestamps.filter((t) => t >= cutoff);
+  };
+}

package/src/helpers/__tests__/SlidingWindowRateLimiter.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { SlidingWindowRateLimiter } from '../SlidingWindowRateLimiter';
+
+describe('SlidingWindowRateLimiter', () => {
+  it('allows up to the configured number of attempts inside the window', () => {
+    const limiter = new SlidingWindowRateLimiter(3, 1000);
+    expect(limiter.tryRegister(0)).toBe(true);
+    expect(limiter.tryRegister(10)).toBe(true);
+    expect(limiter.tryRegister(20)).toBe(true);
+    // fourth attempt inside the same window is denied
+    expect(limiter.tryRegister(30)).toBe(false);
+  });
+
+  it('prunes timestamps outside the rolling window so attempts after it pass', () => {
+    const limiter = new SlidingWindowRateLimiter(2, 1000);
+    expect(limiter.tryRegister(0)).toBe(true);
+    expect(limiter.tryRegister(500)).toBe(true);
+    expect(limiter.tryRegister(900)).toBe(false);
+    // at t=1501 cutoff=501, so both 0 and 500 fall out of window
+    expect(limiter.tryRegister(1501)).toBe(true);
+  });
+
+  it('reset() clears the attempt history', () => {
+    const limiter = new SlidingWindowRateLimiter(2, 1000);
+    limiter.tryRegister(0);
+    limiter.tryRegister(100);
+    expect(limiter.tryRegister(200)).toBe(false);
+    limiter.reset();
+    expect(limiter.tryRegister(300)).toBe(true);
+    expect(limiter.tryRegister(400)).toBe(true);
+    expect(limiter.tryRegister(500)).toBe(false);
+  });
+
+  it('setLimits() updates the budget and window in place', () => {
+    const limiter = new SlidingWindowRateLimiter(2, 1000);
+    limiter.tryRegister(0);
+    limiter.tryRegister(100);
+    expect(limiter.tryRegister(200)).toBe(false);
+    // raising the limit lets the next attempt through without reset
+    limiter.setLimits(5, 1000);
+    expect(limiter.tryRegister(300)).toBe(true);
+  });
+});

package/src/rpc/retryable.ts

@@ -44,7 +44,6 @@ export const retryable = async <
   let result: FinishedUnaryCall<I, O> | undefined = undefined;
   do {
     if (attempt > 0) await sleep(retryInterval(attempt));
-    if (signal?.aborted) throw new Error(signal.reason);
 
     try {
       result = await rpc({ attempt });

package/src/rtc/BasePeerConnection.ts

@@ -13,7 +13,12 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { AllSfuEvents, Dispatcher } from './Dispatcher';
 import { withoutConcurrency } from '../helpers/concurrency';
 import { StatsTracer, Tracer, traceRTCPeerConnection } from '../stats';
-import type { BasePeerConnectionOpts, OnReconnectionNeeded } from './types';
+import {
+  BasePeerConnectionOpts,
+  OnIceConnected,
+  OnReconnectionNeeded,
+  ReconnectReason,
+} from './types';
 import type { ClientPublishOptions } from '../types';
 
 /**
@@ -31,8 +36,11 @@ export abstract class BasePeerConnection {
   protected sfuClient: StreamSfuClient;
 
   private onReconnectionNeeded?: OnReconnectionNeeded;
+  private onIceConnected?: OnIceConnected;
   private readonly iceRestartDelay: number;
+  private iceHasEverConnected = false;
   private iceRestartTimeout?: NodeJS.Timeout;
+  private preConnectStuckTimeout?: NodeJS.Timeout;
   protected isIceRestarting = false;
   private isDisposed = false;
 
@@ -56,6 +64,7 @@ export abstract class BasePeerConnection {
       state,
       dispatcher,
       onReconnectionNeeded,
+      onIceConnected,
       tag,
       enableTracing,
       clientPublishOptions,
@@ -70,6 +79,7 @@ export abstract class BasePeerConnection {
     this.clientPublishOptions = clientPublishOptions;
     this.tag = tag;
     this.onReconnectionNeeded = onReconnectionNeeded;
+    this.onIceConnected = onIceConnected;
     this.logger = videoLoggerSystem.getLogger(
       peerType === PeerType.SUBSCRIBER ? 'Subscriber' : 'Publisher',
       { tags: [tag] },
@@ -108,7 +118,10 @@ export abstract class BasePeerConnection {
   dispose() {
     clearTimeout(this.iceRestartTimeout);
     this.iceRestartTimeout = undefined;
+    clearTimeout(this.preConnectStuckTimeout);
+    this.preConnectStuckTimeout = undefined;
     this.onReconnectionNeeded = undefined;
+    this.onIceConnected = undefined;
     this.isDisposed = true;
     this.detachEventHandlers();
     this.pc.close();
@@ -145,14 +158,17 @@ export abstract class BasePeerConnection {
    */
   protected tryRestartIce = () => {
     this.restartIce().catch((e) => {
-      const reason = 'restartICE() failed, initiating reconnect';
-      this.logger.error(reason, e);
+      this.logger.error('restartICE() failed, initiating reconnect', e);
       const strategy =
         e instanceof NegotiationError &&
         e.error.code === ErrorCode.PARTICIPANT_SIGNAL_LOST
           ? WebsocketReconnectStrategy.FAST
           : WebsocketReconnectStrategy.REJOIN;
-      this.onReconnectionNeeded?.(strategy, reason, this.peerType);
+      this.onReconnectionNeeded?.(
+        strategy,
+        ReconnectReason.RESTART_ICE_FAILED,
+        this.peerType,
+      );
     });
   };
 
@@ -239,6 +255,20 @@ export abstract class BasePeerConnection {
     return !failedStates.has(iceState) && !failedStates.has(connectionState);
   };
 
+  /**
+   * Returns true only when the peer connection is currently fully established
+   * (ICE `connected`/`completed` AND connection state `connected`).
+   * Transient states like `disconnected`, `checking`, or `new` return false.
+   */
+  isStable = () => {
+    const iceState = this.pc.iceConnectionState;
+    const connectionState = this.pc.connectionState;
+    return (
+      (iceState === 'connected' || iceState === 'completed') &&
+      connectionState === 'connected'
+    );
+  };
+
   /**
    * Handles the ICECandidate event and
    * Initiates an ICE Trickle process with the SFU.
@@ -292,7 +322,7 @@ export abstract class BasePeerConnection {
     if (state === 'failed') {
       this.onReconnectionNeeded?.(
         WebsocketReconnectStrategy.REJOIN,
-        'Connection failed',
+        ReconnectReason.CONNECTION_FAILED,
         this.peerType,
       );
       return;
@@ -320,6 +350,54 @@ export abstract class BasePeerConnection {
     // do nothing when ICE is restarting
     if (this.isIceRestarting) return;
 
+    // Pre-connect handling: ICE has never reached `connected`/`completed`.
+    // Restart is futile here (the data plane was never established), but
+    // these two terminal-ish states need different treatment:
+    // - `failed` is terminal, escalate to REJOIN so a new SFU/credentials
+    //   /PC configuration gets a chance, and let `Call.reconnect` count
+    //   this toward the unsupported-network budget.
+    // - `disconnected` is transient, the browser may yet move back to
+    //   `checking`/`connected`. Don't restart, don't escalate; wait it
+    //   out. If it ultimately fails, ICE will transition to `failed` and
+    //   the branch above will take over.
+    if (!this.iceHasEverConnected) {
+      if (state === 'failed') {
+        this.logger.info('ICE failed before connected, escalating to REJOIN');
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = undefined;
+        this.onReconnectionNeeded?.(
+          WebsocketReconnectStrategy.REJOIN,
+          ReconnectReason.ICE_NEVER_CONNECTED,
+          this.peerType,
+        );
+        return;
+      }
+      if (state === 'disconnected') {
+        this.logger.info('ICE disconnected before connected, wait to recover');
+        // Watchdog: if the browser stays in `disconnected` without ever
+        // reaching `connected` or transitioning to `failed`, escalate to
+        // REJOIN ourselves so we don't wait silently forever. Rare but
+        // observed on flaky mobile networks.
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = setTimeout(() => {
+          if (
+            !this.iceHasEverConnected &&
+            this.pc.iceConnectionState === 'disconnected'
+          ) {
+            this.logger.info(
+              'ICE stuck in pre-connect disconnected, escalating to REJOIN',
+            );
+            this.onReconnectionNeeded?.(
+              WebsocketReconnectStrategy.REJOIN,
+              ReconnectReason.ICE_NEVER_CONNECTED,
+              this.peerType,
+            );
+          }
+        }, this.iceRestartDelay * 2);
+        return;
+      }
+    }
+
     switch (state) {
       case 'failed':
         // in the `failed` state, we try to restart ICE immediately
@@ -341,12 +419,24 @@ export abstract class BasePeerConnection {
         break;
 
       case 'connected':
-        // in the `connected` state, we clear the ice restart timeout if it exists
+      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');
           clearTimeout(this.iceRestartTimeout);
           this.iceRestartTimeout = undefined;
         }
+        // clear the pre-connect watchdog if it was armed
+        clearTimeout(this.preConnectStuckTimeout);
+        this.preConnectStuckTimeout = undefined;
         break;
     }
   };

package/src/rtc/Publisher.ts

@@ -460,7 +460,8 @@ export class Publisher extends BasePeerConnection {
     const trackInfos: TrackInfo[] = [];
     for (const publishOption of this.publishOptions) {
       const bundle = this.transceiverCache.get(publishOption);
-      if (!bundle || !bundle.transceiver.sender.track) continue;
+      const track = bundle?.transceiver.sender.track;
+      if (!bundle || !track || track.readyState !== 'live') continue;
       trackInfos.push(this.toTrackInfo(bundle, sdp));
     }
     return trackInfos;