feat: re-acquire mic track when effects require specific audio constraints

src/media/local-stream.spec.ts

@@ -1,6 +1,8 @@
 import { WebrtcCoreError } from '../errors';
-import { createMockedStream } from '../util/test-utils';
+import * as media from '.';
+import { createMockedAudioStream, createMockedStream } from '../util/test-utils';
 import { LocalStream, LocalStreamEventNames, TrackEffect } from './local-stream';
+import { StreamEventNames } from './stream';
 
 /**
  * A dummy LocalStream implementation, so we can instantiate it for testing.
@@ -187,6 +189,252 @@ describe('LocalStream', () => {
     });
   });
 
+  describe('handleConstraintsRequired', () => {
+    const audioSettings: MediaTrackSettings = {
+      deviceId: 'test-device-id',
+      sampleRate: 48000,
+      channelCount: 1,
+      sampleSize: 16,
+      echoCancellation: true,
+      autoGainControl: true,
+      noiseSuppression: true,
+    };
+
+    let audioStream: MediaStream;
+    let audioLocalStream: LocalStream;
+    let effect: TrackEffect;
+    let constraintsHandler: (constraints: MediaTrackConstraints) => Promise<void>;
+    let getUserMediaSpy: jest.SpyInstance;
+    let newAudioTrack: MediaStreamTrack;
+
+    beforeEach(async () => {
+      audioStream = createMockedAudioStream();
+      audioLocalStream = new TestLocalStream(audioStream);
+
+      const inputTrack = audioStream.getTracks()[0];
+      jest.spyOn(inputTrack, 'getSettings').mockReturnValue(audioSettings);
+
+      const eventHandlers = new Map<string, (...args: unknown[]) => void>();
+      effect = {
+        id: 'nr-effect',
+        kind: 'noise-reduction',
+        isEnabled: false,
+        dispose: jest.fn().mockResolvedValue(undefined),
+        load: jest.fn().mockResolvedValue(undefined),
+        replaceInputTrack: jest.fn().mockResolvedValue(undefined),
+        on: jest.fn().mockImplementation((event: string, handler: (...args: unknown[]) => void) => {
+          eventHandlers.set(event, handler);
+        }),
+        off: jest.fn(),
+      } as unknown as TrackEffect;
+
+      const newMockStream = createMockedAudioStream();
+      [newAudioTrack] = newMockStream.getTracks();
+      (newMockStream.getAudioTracks as jest.Mock).mockReturnValue([newAudioTrack]);
+
+      getUserMediaSpy = jest.spyOn(media, 'getUserMedia').mockResolvedValue(newMockStream);
+
+      await audioLocalStream.addEffect(effect);
+      constraintsHandler = eventHandlers.get('constraints-required') as (
+        constraints: MediaTrackConstraints
+      ) => Promise<void>;
+    });
+
+    afterEach(() => {
+      getUserMediaSpy.mockRestore();
+    });
+
+    it('should call getUserMedia with current settings and effect constraints', async () => {
+      expect.hasAssertions();
+
+      await constraintsHandler({ autoGainControl: false, noiseSuppression: false });
+
+      expect(getUserMediaSpy).toHaveBeenCalledWith({
+        audio: {
+          deviceId: { exact: 'test-device-id' },
+          sampleRate: 48000,
+          channelCount: 1,
+          sampleSize: 16,
+          echoCancellation: true,
+          autoGainControl: false,
+          noiseSuppression: false,
+        },
+      });
+    });
+
+    it('should skip re-acquisition when constraints are empty and nothing saved', async () => {
+      expect.hasAssertions();
+
+      await constraintsHandler({});
+
+      expect(getUserMediaSpy).not.toHaveBeenCalled();
+    });
+
+    it('should skip re-acquisition when constraints are already satisfied', async () => {
+      expect.hasAssertions();
+
+      await constraintsHandler({ autoGainControl: true, noiseSuppression: true });
+
+      expect(getUserMediaSpy).not.toHaveBeenCalled();
+    });
+
+    it('should restore saved user constraints when empty constraints are received', async () => {
+      expect.hasAssertions();
+
+      await constraintsHandler({ autoGainControl: false, noiseSuppression: false });
+      getUserMediaSpy.mockClear();
+
+      (audioStream.getTracks as jest.Mock).mockReturnValue([newAudioTrack]);
+      jest.spyOn(newAudioTrack, 'getSettings').mockReturnValue({
+        ...audioSettings,
+        autoGainControl: false,
+        noiseSuppression: false,
+      });
+
+      await constraintsHandler({});
+
+      expect(getUserMediaSpy).toHaveBeenCalledWith({
+        audio: expect.objectContaining({
+          autoGainControl: true,
+          noiseSuppression: true,
+        }),
+      });
+    });
+
+    it('should not restore a second time after saved constraints are cleared', async () => {
+      expect.hasAssertions();
+
+      await constraintsHandler({ autoGainControl: false });
+      getUserMediaSpy.mockClear();
+
+      (audioStream.getTracks as jest.Mock).mockReturnValue([newAudioTrack]);
+      jest.spyOn(newAudioTrack, 'getSettings').mockReturnValue({
+        ...audioSettings,
+        autoGainControl: false,
+      });
+
+      await constraintsHandler({});
+      getUserMediaSpy.mockClear();
+
+      await constraintsHandler({});
+
+      expect(getUserMediaSpy).not.toHaveBeenCalled();
+    });
+
+    it('should replace the input track on the first effect', async () => {
+      expect.hasAssertions();
+
+      await constraintsHandler({ autoGainControl: false });
+
+      expect(effect.replaceInputTrack).toHaveBeenCalledWith(newAudioTrack);
+    });
+
+    it('should remove track handlers before stopping the current track', async () => {
+      expect.hasAssertions();
+
+      const currentTrack = audioStream.getTracks()[0];
+      const callOrder: string[] = [];
+
+      jest.spyOn(currentTrack, 'removeEventListener').mockImplementation(() => {
+        callOrder.push('removeEventListener');
+      });
+      jest.spyOn(currentTrack, 'stop').mockImplementation(() => {
+        callOrder.push('stop');
+      });
+
+      await constraintsHandler({ autoGainControl: false });
+
+      const firstRemove = callOrder.indexOf('removeEventListener');
+      const firstStop = callOrder.indexOf('stop');
+      expect(firstRemove).toBeGreaterThanOrEqual(0);
+      expect(firstStop).toBeGreaterThan(firstRemove);
+    });
+
+    it('should stop the current track before calling getUserMedia', async () => {
+      expect.hasAssertions();
+
+      const currentTrack = audioStream.getTracks()[0];
+      const callOrder: string[] = [];
+
+      jest.spyOn(currentTrack, 'stop').mockImplementation(() => {
+        callOrder.push('stop');
+      });
+      getUserMediaSpy.mockImplementation(async () => {
+        callOrder.push('getUserMedia');
+        return createMockedAudioStream();
+      });
+
+      await constraintsHandler({ autoGainControl: false });
+
+      expect(callOrder).toStrictEqual(['stop', 'getUserMedia']);
+    });
+
+    it('should fall back to getUserMedia without effect constraints when first call fails', async () => {
+      expect.hasAssertions();
+
+      const fallbackStream = createMockedAudioStream();
+      getUserMediaSpy
+        .mockRejectedValueOnce(new Error('OverconstrainedError'))
+        .mockResolvedValueOnce(fallbackStream);
+
+      await constraintsHandler({ autoGainControl: false });
+
+      expect(getUserMediaSpy).toHaveBeenCalledTimes(2);
+      expect(getUserMediaSpy).toHaveBeenLastCalledWith({
+        audio: {
+          deviceId: { exact: 'test-device-id' },
+          sampleRate: 48000,
+          channelCount: 1,
+          sampleSize: 16,
+          echoCancellation: true,
+          autoGainControl: true,
+          noiseSuppression: true,
+        },
+      });
+    });
+
+    it('should emit Ended when both getUserMedia calls fail', async () => {
+      expect.hasAssertions();
+
+      const endedSpy = jest.spyOn(audioLocalStream[StreamEventNames.Ended], 'emit');
+
+      getUserMediaSpy
+        .mockRejectedValueOnce(new Error('OverconstrainedError'))
+        .mockRejectedValueOnce(new Error('NotFoundError'));
+
+      await constraintsHandler({ autoGainControl: false });
+
+      expect(getUserMediaSpy).toHaveBeenCalledTimes(2);
+      expect(endedSpy).toHaveBeenCalledWith();
+    });
+
+    it('should not register constraints-required handler for video tracks', async () => {
+      expect.hasAssertions();
+
+      const videoStream = createMockedStream();
+      const videoLocalStream = new TestLocalStream(videoStream);
+
+      const videoEventHandlers = new Map<string, (...args: unknown[]) => void>();
+      const videoEffect = {
+        id: 'video-effect',
+        kind: 'video-kind',
+        isEnabled: false,
+        dispose: jest.fn().mockResolvedValue(undefined),
+        load: jest.fn().mockResolvedValue(undefined),
+        on: jest.fn().mockImplementation((event: string, handler: (...args: unknown[]) => void) => {
+          videoEventHandlers.set(event, handler);
+        }),
+        off: jest.fn(),
+      } as unknown as TrackEffect;
+
+      await videoLocalStream.addEffect(videoEffect);
+
+      expect(videoEventHandlers.has('constraints-required')).toBe(false);
+      expect(videoEventHandlers.has('track-updated')).toBe(true);
+      expect(videoEventHandlers.has('disposed')).toBe(true);
+    });
+  });
+
   describe('toJSON', () => {
     it('should correctly serialize data', () => {
       expect.assertions(1);