@stream-io/video-client 1.46.0 → 1.46.1

package/dist/src/helpers/RNSpeechDetector.d.ts

@@ -1,9 +1,10 @@
 import { SoundStateChangeHandler } from './sound-detector';
 export declare class RNSpeechDetector {
-    private pc1;
-    private pc2;
+    private readonly pc1;
+    private readonly pc2;
     private audioStream;
     private externalAudioStream;
+    private isStopped;
     constructor(externalAudioStream?: MediaStream);
     /**
      * Starts the speech detection.
@@ -18,4 +19,5 @@ export declare class RNSpeechDetector {
      */
     private onSpeakingDetectedStateChange;
     private cleanupAudioStream;
+    private forwardIceCandidate;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.46.0",
+  "version": "1.46.1",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

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,31 +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', (e) => {
-        this.pc2.addIceCandidate(e.candidate).catch(() => {
-          // do nothing
-        });
-      });
-      this.pc2.addEventListener('icecandidate', async (e) => {
-        this.pc1.addIceCandidate(e.candidate).catch(() => {
-          // do nothing
-        });
-      });
-      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()
@@ -51,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 () => {};
@@ -69,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();
 
@@ -185,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__/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();
+  });
+});