fix(client): prevent stale speaking-while-muted detector

Author: oliverlaz

packages/client/src/devices/MicrophoneManager.ts

@@ -34,6 +34,7 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
   private speakingWhileMutedNotificationEnabled = true;
   private soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
   private soundDetectorCleanup?: () => Promise<void>;
+  private soundDetectorDeviceId?: string;
   private noAudioDetectorCleanup?: () => Promise<void>;
   private rnSpeechDetector: RNSpeechDetector | undefined;
   private noiseCancellation: INoiseCancellation | undefined;
@@ -385,6 +386,11 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
 
   private async startSpeakingWhileMutedDetection(deviceId?: string) {
     await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
+      if (this.soundDetectorCleanup && this.soundDetectorDeviceId === deviceId)
+        return;
+
+      await this.teardownSpeakingWhileMutedDetection();
+
       if (isReactNative()) {
         this.rnSpeechDetector = new RNSpeechDetector();
         const unsubscribe = await this.rnSpeechDetector.start((event) => {
@@ -404,16 +410,26 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
           this.state.setSpeakingWhileMuted(event.isSoundDetected);
         });
       }
+
+      this.soundDetectorDeviceId = deviceId;
     });
   }
 
   private async stopSpeakingWhileMutedDetection() {
     await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
-      if (!this.soundDetectorCleanup) return;
-      const soundDetectorCleanup = this.soundDetectorCleanup;
-      this.soundDetectorCleanup = undefined;
-      this.state.setSpeakingWhileMuted(false);
-      await soundDetectorCleanup();
+      return this.teardownSpeakingWhileMutedDetection();
+    });
+  }
+
+  private async teardownSpeakingWhileMutedDetection(): Promise<void> {
+    const soundDetectorCleanup = this.soundDetectorCleanup;
+    this.soundDetectorCleanup = undefined;
+    this.soundDetectorDeviceId = undefined;
+    this.state.setSpeakingWhileMuted(false);
+    if (!soundDetectorCleanup) return;
+
+    await soundDetectorCleanup().catch((err) => {
+      this.logger.warn('Failed to stop speaking while muted detector', err);
     });
   }
 

packages/client/src/devices/__tests__/MicrophoneManager.test.ts

@@ -222,6 +222,38 @@ describe('MicrophoneManager', () => {
       }
     });
 
+    it('should not create duplicate sound detectors for the same device', async () => {
+      const detectorMock = vi.mocked(createSoundDetector);
+      const cleanup = vi.fn(async () => {});
+      detectorMock.mockImplementationOnce(() => cleanup);
+
+      await manager['startSpeakingWhileMutedDetection']('device-1');
+      await manager['startSpeakingWhileMutedDetection']('device-1');
+
+      expect(detectorMock).toHaveBeenCalledTimes(1);
+
+      await manager['stopSpeakingWhileMutedDetection']();
+      expect(cleanup).toHaveBeenCalledTimes(1);
+    });
+
+    it('should cleanup previous detector before starting a new device detector', async () => {
+      const detectorMock = vi.mocked(createSoundDetector);
+      const cleanupFirst = vi.fn(async () => {});
+      const cleanupSecond = vi.fn(async () => {});
+      detectorMock
+        .mockImplementationOnce(() => cleanupFirst)
+        .mockImplementationOnce(() => cleanupSecond);
+
+      await manager['startSpeakingWhileMutedDetection']('device-1');
+      await manager['startSpeakingWhileMutedDetection']('device-2');
+
+      expect(detectorMock).toHaveBeenCalledTimes(2);
+      expect(cleanupFirst).toHaveBeenCalledTimes(1);
+
+      await manager['stopSpeakingWhileMutedDetection']();
+      expect(cleanupSecond).toHaveBeenCalledTimes(1);
+    });
+
     // --- this ---
     it('should stop speaking while muted notifications if user loses permission to send audio', async () => {
       await manager.enable();

packages/client/src/devices/__tests__/MicrophoneManagerRN.test.ts

@@ -16,6 +16,7 @@ import { SoundStateChangeHandler } from '../../helpers/sound-detector';
 import { settled, withoutConcurrency } from '../../helpers/concurrency';
 
 let handler: SoundStateChangeHandler = () => {};
+let unsubscribeHandlers: ReturnType<typeof vi.fn>[] = [];
 
 vi.mock('../../helpers/platforms.ts', () => {
   return {
@@ -51,7 +52,9 @@ vi.mock('../../helpers/RNSpeechDetector.ts', () => {
     RNSpeechDetector: vi.fn().mockImplementation(() => ({
       start: vi.fn((callback) => {
         handler = callback;
-        return vi.fn();
+        const unsubscribe = vi.fn();
+        unsubscribeHandlers.push(unsubscribe);
+        return unsubscribe;
       }),
       stop: vi.fn(),
       onSpeakingDetectedStateChange: vi.fn(),
@@ -63,6 +66,7 @@ describe('MicrophoneManager React Native', () => {
   let manager: MicrophoneManager;
   let checkPermissionMock: ReturnType<typeof vi.fn>;
   beforeEach(() => {
+    unsubscribeHandlers = [];
     checkPermissionMock = vi.fn(async () => true);
 
     globalThis.streamRNVideoSDK = {
@@ -153,6 +157,27 @@ describe('MicrophoneManager React Native', () => {
     expect(manager.state.speakingWhileMuted).toBe(false);
   });
 
+  it('should not create duplicate speech detectors for the same device', async () => {
+    await manager['startSpeakingWhileMutedDetection']('device-1');
+    await manager['startSpeakingWhileMutedDetection']('device-1');
+
+    expect(unsubscribeHandlers).toHaveLength(1);
+
+    await manager['stopSpeakingWhileMutedDetection']();
+    expect(unsubscribeHandlers[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);
+
+    await manager['stopSpeakingWhileMutedDetection']();
+    expect(unsubscribeHandlers[1]).toHaveBeenCalledTimes(1);
+  });
+
   it('should stop speaking while muted notifications if user loses permission to send audio', async () => {
     await manager.enable();
     await manager.disable();