@stream-io/video-client 1.61.1 → 1.62.0

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

@@ -17,7 +17,8 @@ import {
 import { createVideoStreamForDevice } from './mediaStreamTestHelpers';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { CameraManager } from '../CameraManager';
-import { of } from 'rxjs';
+import { getVideoDevices } from '../devices';
+import { NEVER, of } from 'rxjs';
 import { PermissionsContext } from '../../permissions';
 import { Tracer } from '../../stats';
 import {
@@ -598,6 +599,54 @@ describe('CameraManager', () => {
         });
       }
     });
+
+    it('persists the label from the active track when the device list is not enumerated yet', async () => {
+      const storageKey = '@test/device-preferences-camera-cold-list';
+      const localStorageMock = createLocalStorageMock();
+      const originalWindow = globalThis.window;
+      Object.defineProperty(globalThis, 'window', {
+        configurable: true,
+        value: { localStorage: localStorageMock },
+      });
+
+      const device = mockVideoDevices[1];
+      vi.mocked(getVideoDevices).mockReturnValue(NEVER);
+      vi.mocked(getVideoStream).mockResolvedValue(
+        createVideoStreamForDevice(device.deviceId, 'user', device.label),
+      );
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
+
+      const coldListManager = new CameraManager(call, {
+        enabled: true,
+        storageKey,
+      });
+
+      try {
+        await coldListManager.enable();
+        await coldListManager.statusChangeSettled();
+
+        expect(coldListManager.state.selectedDevice).toBe(device.deviceId);
+        const [persisted] = toPreferenceList(
+          readPreferences(storageKey).camera,
+        );
+        expect(persisted).toEqual({
+          selectedDeviceId: device.deviceId,
+          selectedDeviceLabel: device.label,
+          muted: false,
+        });
+      } finally {
+        coldListManager.dispose();
+        vi.mocked(getVideoDevices).mockImplementation(() =>
+          of(mockVideoDevices),
+        );
+        Object.defineProperty(globalThis, 'window', {
+          configurable: true,
+          value: originalWindow,
+        });
+      }
+    });
   });
 
   afterEach(() => {

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

@@ -22,6 +22,7 @@ import { firstValueFrom, of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { PermissionsContext } from '../../permissions';
 import { defaultDeviceId, readPreferences } from '../devicePersistence';
+import { promiseWithResolvers } from '../../helpers/promise';
 
 vi.mock('../../reporting/ClientEventReporter', () => ({
   ClientEventReporter: vi.fn(function () {
@@ -172,6 +173,34 @@ describe('Device Manager', () => {
     expect(manager.state.status).toBe('disabled');
   });
 
+  it('clears a startup error when disabling an already disabled device', async () => {
+    await manager.disable();
+    const error = new Error('Camera failed to start');
+    manager.getStream.mockRejectedValueOnce(error);
+
+    await expect(manager.enable()).rejects.toThrow(error);
+    expect(manager.state.status).toBe('disabled');
+    expect(manager.state.error).toBe(error);
+
+    await manager.disable();
+
+    expect(manager.state.error).toBeUndefined();
+  });
+
+  it('clears a pending startup error when the queued disable completes', async () => {
+    const { promise, reject } = promiseWithResolvers<MediaStream>();
+    const error = new Error('Camera failed to start');
+    manager.getStream.mockReturnValueOnce(promise);
+
+    const enabling = expect(manager.enable()).rejects.toThrow(error);
+    const disabling = manager.disable();
+    reject(error);
+    await Promise.all([enabling, disabling]);
+
+    expect(manager.state.status).toBe('disabled');
+    expect(manager.state.error).toBeUndefined();
+  });
+
   it('toggle device', async () => {
     vi.spyOn(manager, 'disable');
     vi.spyOn(manager, 'enable');

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

@@ -327,6 +327,241 @@ describe('MicrophoneManager', () => {
       await manager.disable();
       expect(manager['startSpeakingWhileMutedDetection']).toHaveBeenCalled();
     });
+
+    describe('mute hand-off', () => {
+      let micTrack: MediaStreamTrack;
+      let clonedTrack: MediaStreamTrack;
+
+      beforeEach(() => {
+        vi.stubGlobal(
+          'MediaStream',
+          vi.fn(function (this: object, tracks: MediaStreamTrack[]) {
+            Object.assign(this, { getTracks: () => tracks });
+          }),
+        );
+        const stream = mockAudioStream();
+        [micTrack] = stream.getAudioTracks();
+        [clonedTrack] = mockAudioStream().getAudioTracks();
+        micTrack.clone = vi.fn(() => clonedTrack);
+        vi.mocked(getAudioStream).mockResolvedValueOnce(stream);
+        manager.dispose();
+        const devicePersistence = { enabled: false, storageKey: '' };
+        manager = new MicrophoneManager(call, devicePersistence);
+      });
+
+      afterEach(() => {
+        vi.unstubAllGlobals();
+      });
+
+      const enableAndSettle = async () => {
+        await manager.enable();
+        await sleep(25);
+        vi.mocked(micTrack.clone).mockClear();
+        vi.mocked(getAudioStream).mockClear();
+        vi.mocked(createSoundDetector).mockClear();
+      };
+
+      it('keeps the mic captured by handing a clone to the detector', async () => {
+        await enableAndSettle();
+        await manager.disable();
+        await sleep(25);
+
+        expect(micTrack.readyState).toBe('ended');
+        expect(clonedTrack.readyState).toBe('live');
+        expect(createSoundDetector).toHaveBeenCalledTimes(1);
+        const [detectorStream] = vi.mocked(createSoundDetector).mock.calls[0];
+        expect(detectorStream.getTracks()).toEqual([clonedTrack]);
+        expect(getAudioStream).not.toHaveBeenCalled();
+      });
+
+      it('releases the clone after unmute opened the new capture', async () => {
+        await enableAndSettle();
+        const cleanup = vi.fn(async () => {});
+        vi.mocked(createSoundDetector).mockImplementationOnce(() => cleanup);
+        await manager.disable();
+        await sleep(25);
+        await manager.enable();
+        await sleep(25);
+
+        expect(cleanup).toHaveBeenCalledTimes(1);
+        expect(getAudioStream).toHaveBeenCalledTimes(1);
+        const [captureOrder] =
+          vi.mocked(getAudioStream).mock.invocationCallOrder;
+        expect(captureOrder).toBeLessThan(cleanup.mock.invocationCallOrder[0]);
+      });
+
+      it('releases the clone and keeps the mic live when muting fails', async () => {
+        await enableAndSettle();
+        vi.mocked(call.stopPublish).mockRejectedValueOnce(
+          new Error('SFU unavailable'),
+        );
+
+        await expect(manager.disable()).rejects.toThrow('SFU unavailable');
+        await sleep(25);
+
+        expect(manager.state.status).toBe('enabled');
+        expect(micTrack.readyState).toBe('live');
+        expect(clonedTrack.readyState).toBe('ended');
+        expect(createSoundDetector).not.toHaveBeenCalled();
+      });
+
+      it('releases the clone and falls back when the detector cannot start', async () => {
+        await enableAndSettle();
+        vi.mocked(createSoundDetector).mockImplementationOnce(() => {
+          throw new Error('AudioContext unavailable');
+        });
+
+        await manager.disable();
+        await sleep(25);
+
+        expect(manager.state.status).toBe('disabled');
+        expect(clonedTrack.readyState).toBe('ended');
+        expect(getAudioStream).toHaveBeenCalledTimes(1);
+      });
+
+      it('unpublishes without waiting for the detector queue', async () => {
+        await enableAndSettle();
+        let unblock!: () => void;
+        const blocker = new Promise<void>((resolve) => (unblock = resolve));
+        withoutConcurrency(
+          manager['soundDetectorConcurrencyTag'],
+          () => blocker,
+        );
+
+        const muted = manager.disable();
+        await sleep(25);
+
+        expect(call.stopPublish).toHaveBeenCalledWith(TrackType.AUDIO);
+        expect(micTrack.readyState).toBe('ended');
+        expect(clonedTrack.readyState).toBe('live');
+        unblock();
+        await muted;
+      });
+
+      it('does not open a capture before muting an ended mic track', async () => {
+        await enableAndSettle();
+        micTrack.stop();
+
+        await manager.disable();
+        await sleep(25);
+
+        expect(micTrack.clone).not.toHaveBeenCalled();
+        const [unpublished] = vi.mocked(call.stopPublish).mock
+          .invocationCallOrder;
+        vi.mocked(getAudioStream).mock.invocationCallOrder.forEach((order) => {
+          expect(order).toBeGreaterThan(unpublished);
+        });
+      });
+
+      it('releases the handed-off track when a detector already runs', async () => {
+        await manager['startSpeakingWhileMutedDetection']('device-1');
+        await manager['startSpeakingWhileMutedDetection'](
+          'device-1',
+          clonedTrack,
+        );
+
+        expect(clonedTrack.readyState).toBe('ended');
+      });
+
+      const blockUnpublish = () => {
+        let unblock!: () => void;
+        vi.mocked(call.stopPublish).mockImplementationOnce(
+          () => new Promise<void>((resolve) => (unblock = resolve)),
+        );
+        return () => unblock();
+      };
+
+      it('falls back to a new capture when the mic ends while unpublishing', async () => {
+        await enableAndSettle();
+        const unblock = blockUnpublish();
+
+        const muted = manager.disable();
+        await sleep(25);
+        clonedTrack.stop();
+        unblock();
+        await muted;
+        await sleep(25);
+
+        expect(createSoundDetector).toHaveBeenCalledTimes(1);
+        const [detectorStream] = vi.mocked(createSoundDetector).mock.calls[0];
+        expect(detectorStream.getTracks()).not.toContain(clonedTrack);
+        expect(getAudioStream).toHaveBeenCalledTimes(1);
+      });
+
+      it.each([
+        [
+          'the call is left',
+          () => call.state.setCallingState(CallingState.LEFT),
+        ],
+        ['sending audio is revoked', () => call.state.setOwnCapabilities([])],
+        [
+          'the notification is disabled',
+          () => manager.disableSpeakingWhileMutedNotification(),
+        ],
+      ])('releases the clone when %s while unpublishing', async (_, change) => {
+        await enableAndSettle();
+        const unblock = blockUnpublish();
+
+        const muted = manager.disable();
+        await sleep(25);
+        await change();
+        unblock();
+        await muted;
+        await sleep(25);
+
+        expect(clonedTrack.readyState).toBe('ended');
+        expect(createSoundDetector).not.toHaveBeenCalled();
+      });
+
+      it('releases the clone when another mic is selected while unpublishing', async () => {
+        await enableAndSettle();
+        const unblock = blockUnpublish();
+
+        const muted = manager.disable();
+        await sleep(25);
+        const selected = manager.select('other-mic');
+        unblock();
+        await Promise.all([muted, selected]);
+        await sleep(25);
+
+        expect(clonedTrack.readyState).toBe('ended');
+        expect(getAudioStream).toHaveBeenCalledWith(
+          expect.objectContaining({ deviceId: { exact: 'other-mic' } }),
+          expect.any(Tracer),
+        );
+      });
+
+      it('keeps the detector when a stale unmute is handled after muting again', async () => {
+        await enableAndSettle();
+        const cleanup = vi.fn(async () => {});
+        vi.mocked(createSoundDetector).mockImplementationOnce(() => cleanup);
+        let unblock!: () => void;
+        const blocker = new Promise<void>((resolve) => (unblock = resolve));
+        withoutConcurrency(
+          manager['soundDetectorConcurrencyTag'],
+          () => blocker,
+        );
+
+        await manager.disable();
+        await manager.enable();
+        await manager.disable();
+        unblock();
+        await sleep(25);
+
+        expect(manager.state.status).toBe('disabled');
+        expect(cleanup).not.toHaveBeenCalled();
+        expect(clonedTrack.readyState).toBe('live');
+      });
+
+      it('does not hand off the mic when leaving the call', async () => {
+        await enableAndSettle();
+        call.state.setCallingState(CallingState.LEFT);
+        await manager.disable(true);
+
+        expect(micTrack.clone).not.toHaveBeenCalled();
+        expect(micTrack.readyState).toBe('ended');
+      });
+    });
   });
 
   describe('Noise Cancellation', () => {

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

@@ -234,6 +234,33 @@ describe('SpeakerManager.test', () => {
       expect(persistedManager.state.selectedDevice).toBe('speaker-1');
     });
 
+    it('does not restore a speaker when output selection is not supported', async () => {
+      const persistedManager = createPersistedManager();
+      Object.defineProperty(
+        persistedManager.state,
+        'isDeviceSelectionSupported',
+        { value: false },
+      );
+      vi.spyOn(persistedManager, 'listDevices').mockReturnValue(
+        of([
+          {
+            deviceId: 'speaker-1',
+            kind: 'audiooutput',
+            label: 'Speaker 1',
+            groupId: 'speaker-group',
+          } as MediaDeviceInfo,
+        ]),
+      );
+      persist('speaker-1', 'Speaker 1');
+
+      const selectSpy = vi.spyOn(persistedManager, 'select');
+      // @ts-expect-error - partial data
+      await persistedManager.apply({});
+
+      expect(selectSpy).not.toHaveBeenCalled();
+      expect(persistedManager.state.selectedDevice).toBe('');
+    });
+
     it('does not select a missing persisted speaker device', async () => {
       const persistedManager = createPersistedManager();
       vi.spyOn(persistedManager, 'listDevices').mockReturnValue(

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

@@ -23,6 +23,7 @@ vi.mock('../BrowserPermission', () => {
 vi.mock('../../helpers/browsers', () => ({
   isSafari: vi.fn(),
   isFirefox: vi.fn(),
+  isWebKit: vi.fn(),
 }));
 
 type MediaDevicesMock = MediaDevices &
@@ -66,11 +67,11 @@ describe('devices', () => {
     vi.resetModules();
   });
 
-  it('checkIfAudioOutputChangeSupported uses audio element when not Safari', async () => {
+  it('checkIfAudioOutputChangeSupported uses audio element when not WebKit', async () => {
     setupMediaDevices();
     const { checkIfAudioOutputChangeSupported } = await loadDevicesModule();
     const browsers = await import('../../helpers/browsers');
-    vi.mocked(browsers.isSafari).mockReturnValue(false);
+    vi.mocked(browsers.isWebKit).mockReturnValue(false);
     const createElementSpy = vi
       .spyOn(document, 'createElement')
       .mockReturnValue({ setSinkId: vi.fn() } as unknown as HTMLMediaElement);
@@ -79,21 +80,16 @@ describe('devices', () => {
     expect(createElementSpy).toHaveBeenCalledWith('audio');
   });
 
-  it('checkIfAudioOutputChangeSupported uses AudioContext in Safari', async () => {
+  it('checkIfAudioOutputChangeSupported is false on WebKit', async () => {
     setupMediaDevices();
-    class AudioContextStub {}
-    (
-      AudioContextStub.prototype as { setSinkId?: () => Promise<void> }
-    ).setSinkId = vi.fn();
-    Object.defineProperty(globalThis, 'AudioContext', {
-      configurable: true,
-      value: AudioContextStub as typeof AudioContext,
-    });
-
     const { checkIfAudioOutputChangeSupported } = await loadDevicesModule();
     const browsers = await import('../../helpers/browsers');
-    vi.mocked(browsers.isSafari).mockReturnValue(true);
-    expect(checkIfAudioOutputChangeSupported()).toBe(true);
+    vi.mocked(browsers.isWebKit).mockReturnValue(true);
+    vi.spyOn(document, 'createElement').mockReturnValue({
+      setSinkId: vi.fn(),
+    } as unknown as HTMLMediaElement);
+
+    expect(checkIfAudioOutputChangeSupported()).toBe(false);
   });
 
   it('getAudioDevices prompts and filters devices', async () => {

package/src/devices/__tests__/mediaStreamTestHelpers.ts

@@ -10,6 +10,7 @@ const createTrack = (
     getSettings: () => settings,
     enabled: true,
     readyState: 'live',
+    clone: () => createTrack(settings, extras),
     stop: () => {
       // @ts-expect-error read-only property
       track.readyState = 'ended';
@@ -43,13 +44,17 @@ export const createAudioStreamForDevice = (
 export const createVideoStreamForDevice = (
   deviceId: string,
   facingMode: 'user' | 'environment' = 'user',
+  label = '',
 ): MediaStream => {
-  const track = createTrack({
-    deviceId,
-    width: 1280,
-    height: 720,
-    facingMode,
-  });
+  const track = createTrack(
+    {
+      deviceId,
+      width: 1280,
+      height: 720,
+      facingMode,
+    },
+    { label },
+  );
 
   return {
     getTracks: () => [track],

package/src/devices/__tests__/mocks.ts

@@ -157,6 +157,7 @@ export const mockAudioStream = () => {
     label: mockAudioDevices[0].label,
     enabled: true,
     readyState: 'live',
+    clone: () => mockAudioStream().getAudioTracks()[0],
     stop: () => {
       track.readyState = 'ended';
     },

package/src/devices/devices.ts

@@ -11,7 +11,7 @@ import {
 } from 'rxjs';
 import { BrowserPermission } from './BrowserPermission';
 import { lazy } from '../helpers/lazy';
-import { isFirefox } from '../helpers/browsers';
+import { isFirefox, isWebKit } from '../helpers/browsers';
 import { dumpStream, Tracer } from '../stats';
 import { getCurrentValue } from '../store/rxUtils';
 import { videoLoggerSystem } from '../logger';
@@ -58,9 +58,15 @@ const getDevices = (
 /**
  * Tells if the browser supports audio output change on 'audio' elements,
  * see https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId.
+ *
+ * WebKit (Safari, iOS browsers, WKWebView) is reported as unsupported:
+ * setSinkId requires a user gesture, a per-device output can run at a
+ * different sample rate than the remote audio mixer (pitched/slowed audio),
+ * and audio goes silent when the selected device disconnects.
  */
 export const checkIfAudioOutputChangeSupported = () => {
   if (typeof document === 'undefined') return false;
+  if (isWebKit()) return false;
   const element = document.createElement('audio');
   return 'setSinkId' in element;
 };

package/src/gen/video/sfu/signal_rpc/signal.ts

@@ -12,7 +12,6 @@ import { PerformanceStats } from '../models/models';
 import { RTMPIngress } from '../models/models';
 import { AppleState } from '../models/models';
 import { AndroidState } from '../models/models';
-import { InputDevices } from '../models/models';
 import { RemoteOutboundRtp } from '../models/models';
 import { RemoteInboundRtp } from '../models/models';
 import { OutboundRtp } from '../models/models';
@@ -135,14 +134,6 @@ export interface SendStatsRequest {
    * @generated from protobuf field: string session_id = 1;
    */
   sessionId: string;
-  /**
-   * @generated from protobuf field: string subscriber_stats = 2;
-   */
-  subscriberStats: string;
-  /**
-   * @generated from protobuf field: string publisher_stats = 3;
-   */
-  publisherStats: string;
   /**
    * @generated from protobuf field: string webrtc_version = 4;
    */
@@ -155,14 +146,6 @@ export interface SendStatsRequest {
    * @generated from protobuf field: string sdk_version = 6;
    */
   sdkVersion: string;
-  /**
-   * @generated from protobuf field: stream.video.sfu.models.InputDevices audio_devices = 7;
-   */
-  audioDevices?: InputDevices;
-  /**
-   * @generated from protobuf field: stream.video.sfu.models.InputDevices video_devices = 8;
-   */
-  videoDevices?: InputDevices;
   /**
    * @generated from protobuf oneof: device_state
    */
@@ -192,16 +175,6 @@ export interface SendStatsRequest {
    * @generated from protobuf field: stream.video.sfu.models.RTMPIngress rtmp = 12;
    */
   rtmp?: RTMPIngress;
-  /**
-   * @deprecated
-   * @generated from protobuf field: string subscriber_rtc_stats = 13 [deprecated = true];
-   */
-  subscriberRtcStats: string;
-  /**
-   * @deprecated
-   * @generated from protobuf field: string publisher_rtc_stats = 14 [deprecated = true];
-   */
-  publisherRtcStats: string;
   /**
    * @generated from protobuf field: string rtc_stats = 15;
    */
@@ -600,18 +573,6 @@ class SendStatsRequest$Type extends MessageType<SendStatsRequest> {
   constructor() {
     super('stream.video.sfu.signal.SendStatsRequest', [
       { no: 1, name: 'session_id', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
-      {
-        no: 2,
-        name: 'subscriber_stats',
-        kind: 'scalar',
-        T: 9 /*ScalarType.STRING*/,
-      },
-      {
-        no: 3,
-        name: 'publisher_stats',
-        kind: 'scalar',
-        T: 9 /*ScalarType.STRING*/,
-      },
       {
         no: 4,
         name: 'webrtc_version',
@@ -625,8 +586,6 @@ class SendStatsRequest$Type extends MessageType<SendStatsRequest> {
         kind: 'scalar',
         T: 9 /*ScalarType.STRING*/,
       },
-      { no: 7, name: 'audio_devices', kind: 'message', T: () => InputDevices },
-      { no: 8, name: 'video_devices', kind: 'message', T: () => InputDevices },
       {
         no: 9,
         name: 'android',
@@ -643,18 +602,6 @@ class SendStatsRequest$Type extends MessageType<SendStatsRequest> {
       },
       { no: 11, name: 'telemetry', kind: 'message', T: () => Telemetry },
       { no: 12, name: 'rtmp', kind: 'message', T: () => RTMPIngress },
-      {
-        no: 13,
-        name: 'subscriber_rtc_stats',
-        kind: 'scalar',
-        T: 9 /*ScalarType.STRING*/,
-      },
-      {
-        no: 14,
-        name: 'publisher_rtc_stats',
-        kind: 'scalar',
-        T: 9 /*ScalarType.STRING*/,
-      },
       { no: 15, name: 'rtc_stats', kind: 'scalar', T: 9 /*ScalarType.STRING*/ },
       {
         no: 16,