@stream-io/video-client 1.45.0 → 1.46.1

package/src/helpers/RNSpeechDetector.ts

@@ -3,10 +3,11 @@ import { SoundStateChangeHandler } from './sound-detector';
 import { videoLoggerSystem } from '../logger';
 
 export class RNSpeechDetector {
-  private pc1 = new RTCPeerConnection({});
-  private pc2 = new RTCPeerConnection({});
+  private readonly pc1 = new RTCPeerConnection({});
+  private readonly pc2 = new RTCPeerConnection({});
   private audioStream: MediaStream | undefined;
   private externalAudioStream: MediaStream | undefined;
+  private isStopped = false;
 
   constructor(externalAudioStream?: MediaStream) {
     this.externalAudioStream = externalAudioStream;
@@ -16,27 +17,40 @@ export class RNSpeechDetector {
    * Starts the speech detection.
    */
   public async start(onSoundDetectedStateChanged: SoundStateChangeHandler) {
+    let detachListeners: (() => void) | undefined;
+    let unsubscribe: (() => void) | undefined;
+
     try {
+      this.isStopped = false;
       const audioStream =
         this.externalAudioStream != null
           ? this.externalAudioStream
           : await navigator.mediaDevices.getUserMedia({ audio: true });
       this.audioStream = audioStream;
 
-      this.pc1.addEventListener('icecandidate', async (e) => {
-        await this.pc2.addIceCandidate(e.candidate);
-      });
-      this.pc2.addEventListener('icecandidate', async (e) => {
-        await this.pc1.addIceCandidate(e.candidate);
-      });
-      this.pc2.addEventListener('track', (e) => {
+      const onPc1IceCandidate = (e: RTCPeerConnectionIceEvent) => {
+        this.forwardIceCandidate(this.pc2, e.candidate);
+      };
+      const onPc2IceCandidate = (e: RTCPeerConnectionIceEvent) => {
+        this.forwardIceCandidate(this.pc1, e.candidate);
+      };
+      const onTrackPc2 = (e: RTCTrackEvent) => {
         e.streams[0].getTracks().forEach((track) => {
           // In RN, the remote track is automatically added to the audio output device
           // so we need to mute it to avoid hearing the audio back
           // @ts-expect-error _setVolume is a private method in react-native-webrtc
           track._setVolume(0);
         });
-      });
+      };
+
+      this.pc1.addEventListener('icecandidate', onPc1IceCandidate);
+      this.pc2.addEventListener('icecandidate', onPc2IceCandidate);
+      this.pc2.addEventListener('track', onTrackPc2);
+      detachListeners = () => {
+        this.pc1.removeEventListener('icecandidate', onPc1IceCandidate);
+        this.pc2.removeEventListener('icecandidate', onPc2IceCandidate);
+        this.pc2.removeEventListener('track', onTrackPc2);
+      };
 
       audioStream
         .getTracks()
@@ -47,14 +61,19 @@ export class RNSpeechDetector {
       const answer = await this.pc2.createAnswer();
       await this.pc1.setRemoteDescription(answer);
       await this.pc2.setLocalDescription(answer);
-      const unsubscribe = this.onSpeakingDetectedStateChange(
+      unsubscribe = this.onSpeakingDetectedStateChange(
         onSoundDetectedStateChanged,
       );
       return () => {
-        unsubscribe();
+        detachListeners?.();
+        unsubscribe?.();
         this.stop();
       };
     } catch (error) {
+      detachListeners?.();
+      unsubscribe?.();
+      this.stop();
+
       const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
       logger.error('error handling permissions: ', error);
       return () => {};
@@ -65,6 +84,9 @@ export class RNSpeechDetector {
    * Stops the speech detection and releases all allocated resources.
    */
   private stop() {
+    if (this.isStopped) return;
+    this.isStopped = true;
+
     this.pc1.close();
     this.pc2.close();
 
@@ -181,4 +203,22 @@ export class RNSpeechDetector {
       this.audioStream.release();
     }
   }
+
+  private forwardIceCandidate(
+    destination: RTCPeerConnection,
+    candidate: RTCIceCandidate | null,
+  ) {
+    if (
+      this.isStopped ||
+      !candidate ||
+      destination.signalingState === 'closed'
+    ) {
+      return;
+    }
+    destination.addIceCandidate(candidate).catch(() => {
+      // silently ignore the error
+      const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
+      logger.info('cannot add ice candidate - ignoring');
+    });
+  }
 }

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

@@ -18,6 +18,7 @@ import { DynascaleManager } from '../DynascaleManager';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { StreamVideoWriteableStateStore } from '../../store';
+import { getCurrentValue } from '../../store/rxUtils';
 import { VisibilityState } from '../../types';
 import { noopComparator } from '../../sorting';
 import { TrackType } from '../../gen/video/sfu/models/models';
@@ -647,6 +648,125 @@ describe('DynascaleManager', () => {
       expect(unregisterSpy).toHaveBeenCalledWith('session-id', 'audioTrack');
     });
 
+    it('audio: should track blocked audio elements on NotAllowedError', async () => {
+      vi.useFakeTimers();
+      const audioElement = document.createElement('audio');
+      Object.defineProperty(audioElement, 'srcObject', { writable: true });
+      const notAllowedError = new DOMException('', 'NotAllowedError');
+      vi.spyOn(audioElement, 'play').mockRejectedValue(notAllowedError);
+
+      // @ts-expect-error incomplete data
+      call.state.updateOrAddParticipant('session-id', {
+        userId: 'user-id',
+        sessionId: 'session-id',
+        publishedTracks: [],
+      });
+
+      const cleanup = dynascaleManager.bindAudioElement(
+        audioElement,
+        'session-id',
+        'audioTrack',
+      );
+
+      const mediaStream = new MediaStream();
+      call.state.updateParticipant('session-id', {
+        audioStream: mediaStream,
+      });
+
+      vi.runAllTimers();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(getCurrentValue(dynascaleManager.autoplayBlocked$)).toBe(true);
+
+      cleanup?.();
+      expect(getCurrentValue(dynascaleManager.autoplayBlocked$)).toBe(false);
+    });
+
+    it('audio: should unblock audio elements on explicit resumeAudio call', async () => {
+      vi.useFakeTimers();
+      const audioElement = document.createElement('audio');
+      Object.defineProperty(audioElement, 'srcObject', { writable: true });
+      const playSpy = vi
+        .spyOn(audioElement, 'play')
+        .mockRejectedValueOnce(new DOMException('', 'NotAllowedError'))
+        .mockResolvedValue(undefined);
+
+      // @ts-expect-error incomplete data
+      call.state.updateOrAddParticipant('session-id', {
+        userId: 'user-id',
+        sessionId: 'session-id',
+        publishedTracks: [],
+      });
+
+      const cleanup = dynascaleManager.bindAudioElement(
+        audioElement,
+        'session-id',
+        'audioTrack',
+      );
+
+      const mediaStream = new MediaStream();
+      call.state.updateParticipant('session-id', {
+        audioStream: mediaStream,
+      });
+
+      vi.runAllTimers();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(getCurrentValue(dynascaleManager.autoplayBlocked$)).toBe(true);
+
+      await dynascaleManager.resumeAudio();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(playSpy).toHaveBeenCalledTimes(2);
+      expect(getCurrentValue(dynascaleManager.autoplayBlocked$)).toBe(false);
+
+      cleanup?.();
+    });
+
+    it('audio: should clear blocked state when the audio stream is removed', async () => {
+      vi.useFakeTimers();
+      const audioElement = document.createElement('audio');
+      Object.defineProperty(audioElement, 'srcObject', { writable: true });
+      vi.spyOn(audioElement, 'play').mockRejectedValue(
+        new DOMException('', 'NotAllowedError'),
+      );
+
+      // @ts-expect-error incomplete data
+      call.state.updateOrAddParticipant('session-id', {
+        userId: 'user-id',
+        sessionId: 'session-id',
+        publishedTracks: [],
+      });
+
+      const cleanup = dynascaleManager.bindAudioElement(
+        audioElement,
+        'session-id',
+        'audioTrack',
+      );
+
+      const mediaStream = new MediaStream();
+      call.state.updateParticipant('session-id', {
+        audioStream: mediaStream,
+      });
+
+      vi.runAllTimers();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(getCurrentValue(dynascaleManager.autoplayBlocked$)).toBe(true);
+
+      call.state.updateParticipant('session-id', {
+        audioStream: undefined,
+      });
+
+      vi.runAllTimers();
+      await vi.advanceTimersByTimeAsync(0);
+
+      expect(audioElement.srcObject).toBeNull();
+      expect(getCurrentValue(dynascaleManager.autoplayBlocked$)).toBe(false);
+
+      cleanup?.();
+    });
+
     it('audio: should warn when binding an already-bound session', () => {
       const watchdog = dynascaleManager.audioBindingsWatchdog!;
       // @ts-expect-error private property

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

@@ -0,0 +1,52 @@
+import '../../rtc/__tests__/mocks/webrtc.mocks';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { RNSpeechDetector } from '../RNSpeechDetector';
+
+describe('RNSpeechDetector', () => {
+  // Shared test setup stubs RTCPeerConnection with a vi.fn constructor.
+  // We keep a typed handle to that constructor to inspect created instances.
+  let rtcPeerConnectionMockCtor: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    rtcPeerConnectionMockCtor =
+      globalThis.RTCPeerConnection as unknown as ReturnType<typeof vi.fn>;
+    rtcPeerConnectionMockCtor.mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('ignores late ICE candidates after cleanup', async () => {
+    const stream = {
+      getTracks: () => [],
+    } as unknown as MediaStream;
+    const detector = new RNSpeechDetector(stream);
+
+    const cleanup = await detector.start(() => {});
+    cleanup();
+
+    // start() creates two peer connections (pc1 and pc2). We pull them from
+    // constructor call results to inspect listener wiring and ICE forwarding.
+    const [pc1, pc2] = rtcPeerConnectionMockCtor.mock.results.map(
+      (result) => result.value,
+    );
+
+    // Find the registered ICE callback and invoke it manually after cleanup to
+    // simulate a late ICE event arriving during teardown.
+    const onIceCandidate = pc1.addEventListener.mock.calls.find(
+      ([eventName]: [string]) => eventName === 'icecandidate',
+    )?.[1] as ((e: RTCPeerConnectionIceEvent) => void) | undefined;
+
+    expect(onIceCandidate).toBeDefined();
+    onIceCandidate?.({
+      candidate: { candidate: 'candidate:1 1 UDP 0 127.0.0.1 11111 typ host' },
+    } as unknown as RTCPeerConnectionIceEvent);
+
+    expect(pc1.removeEventListener).toHaveBeenCalledWith(
+      'icecandidate',
+      onIceCandidate,
+    );
+    expect(pc2.addIceCandidate).not.toHaveBeenCalled();
+  });
+});

package/src/store/stateStore.ts

@@ -42,7 +42,7 @@ export class StreamVideoWriteableStateStore {
    * The currently connected user.
    */
   get connectedUser(): OwnUserResponse | undefined {
-    return RxUtils.getCurrentValue(this.connectedUserSubject);
+    return this.connectedUserSubject.getValue();
   }
 
   /**

package/src/types.ts

@@ -23,6 +23,7 @@ import type {
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
+import type { Call } from './Call';
 
 export type StreamReaction = Pick<
   ReactionResponse,
@@ -392,26 +393,68 @@ export type StartCallRecordingFnType = {
   ): Promise<StartRecordingResponse>;
 };
 
+type StreamRNVideoSDKCallManagerRingingParams = {
+  isRingingTypeCall: boolean;
+};
+
+type StreamRNVideoSDKCallManagerSetupParams =
+  StreamRNVideoSDKCallManagerRingingParams & {
+    defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
+  };
+
+type StreamRNVideoSDKEndCallReason =
+  /** Call ended by the local user (e.g., hanging up). */
+  | 'local'
+  /** Call ended by the remote party, or outgoing call was not answered. */
+  | 'remote'
+  /** Call was rejected/declined by the user. */
+  | 'rejected'
+  /** Remote party was busy. */
+  | 'busy'
+  /** Call was answered on another device. */
+  | 'answeredElsewhere'
+  /** No response to an incoming call. */
+  | 'missed'
+  /** Call failed due to an error (e.g., network issue). */
+  | 'error'
+  /** Call was canceled before the remote party could answer. */
+  | 'canceled'
+  /** Call restricted (e.g., airplane mode, dialing restrictions). */
+  | 'restricted'
+  /** Unknown or unspecified disconnect reason. */
+  | 'unknown';
+
+type StreamRNVideoSDKCallingX = {
+  joinCall: (call: Call, activeCalls: Call[]) => Promise<void>;
+  endCall: (
+    call: Call,
+    reason?: StreamRNVideoSDKEndCallReason,
+  ) => Promise<void>;
+  registerOutgoingCall: (call: Call) => Promise<void>;
+};
+
 export type StreamRNVideoSDKGlobals = {
+  callingX: StreamRNVideoSDKCallingX;
   callManager: {
     /**
      * Sets up the in call manager.
      */
     setup({
       defaultDevice,
-    }: {
-      defaultDevice: AudioSettingsRequestDefaultDeviceEnum;
-    }): void;
+      isRingingTypeCall,
+    }: StreamRNVideoSDKCallManagerSetupParams): void;
 
     /**
      * Starts the in call manager.
      */
-    start(): void;
+    start({
+      isRingingTypeCall,
+    }: StreamRNVideoSDKCallManagerRingingParams): void;
 
     /**
      * Stops the in call manager.
      */
-    stop(): void;
+    stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
   };
   permissions: {
     /**