@stream-io/video-client 1.43.0 → 1.44.0

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

@@ -1,10 +1,13 @@
+/* @vitest-environment happy-dom */
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+  createLocalStorageMock,
   emitDeviceIds,
+  LocalStorageMock,
   mockBrowserPermission,
   mockCall,
   mockDeviceIds$,
@@ -16,6 +19,8 @@ import { DeviceManager } from '../DeviceManager';
 import { DeviceManagerState } from '../DeviceManagerState';
 import { of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
+import { PermissionsContext } from '../../permissions';
+import { readPreferences } from '../devicePersistence';
 
 vi.mock('../../Call.ts', () => {
   console.log('MOCKING Call');
@@ -47,7 +52,10 @@ class TestInputMediaDeviceManager extends DeviceManager<TestInputMediaDeviceMana
   public stopPublishStream = vi.fn();
   public getTracks = () => this.state.mediaStream?.getTracks() ?? [];
 
-  constructor(call: Call) {
+  constructor(
+    call: Call,
+    devicePersistence = { enabled: false, storageKey: '' },
+  ) {
     super(
       call,
       new TestInputMediaDeviceManagerState(
@@ -55,14 +63,23 @@ class TestInputMediaDeviceManager extends DeviceManager<TestInputMediaDeviceMana
         mockBrowserPermission,
       ),
       TrackType.VIDEO,
+      devicePersistence,
     );
   }
 }
 
-describe('InputMediaDeviceManager.test', () => {
+describe('Device Manager', () => {
   let manager: TestInputMediaDeviceManager;
+  let localStorageMock: LocalStorageMock;
+  let storageKey: string;
 
   beforeEach(() => {
+    storageKey = '@test/device-preferences';
+    localStorageMock = createLocalStorageMock();
+    Object.defineProperty(window, 'localStorage', {
+      configurable: true,
+      value: localStorageMock,
+    });
     manager = new TestInputMediaDeviceManager(
       new Call({
         id: '',
@@ -70,6 +87,7 @@ describe('InputMediaDeviceManager.test', () => {
         streamClient: new StreamClient('abc123'),
         clientStore: new StreamVideoWriteableStateStore(),
       }),
+      { enabled: false, storageKey },
     );
   });
 
@@ -366,8 +384,172 @@ describe('InputMediaDeviceManager.test', () => {
     vi.useRealTimers();
   });
 
+  describe('persistPreference', () => {
+    it('stores selected device and muted state', () => {
+      const persistenceEnabledManager = new TestInputMediaDeviceManager(
+        manager['call'],
+        { enabled: true, storageKey },
+      );
+      persistenceEnabledManager.state.setDevice(mockVideoDevices[1].deviceId);
+      persistenceEnabledManager.state.setStatus('enabled');
+
+      const preferences = readPreferences(storageKey);
+      expect(preferences.camera).toEqual([
+        {
+          selectedDeviceId: mockVideoDevices[1].deviceId,
+          selectedDeviceLabel: mockVideoDevices[1].label,
+          muted: false,
+        },
+      ]);
+    });
+
+    it('stores default device when selection is cleared', () => {
+      const persistenceEnabledManager = new TestInputMediaDeviceManager(
+        manager['call'],
+        { enabled: true, storageKey },
+      );
+      persistenceEnabledManager.state.setDevice(undefined);
+      persistenceEnabledManager.state.setStatus('disabled');
+
+      const preferences = readPreferences(storageKey);
+      expect(preferences.camera).toEqual([
+        {
+          selectedDeviceId: 'default',
+          selectedDeviceLabel: '',
+          muted: true,
+        },
+      ]);
+    });
+
+    it('persists device history when selection changes', () => {
+      const persistenceEnabledManager = new TestInputMediaDeviceManager(
+        manager['call'],
+        { enabled: true, storageKey },
+      );
+
+      persistenceEnabledManager.state.setDevice(mockVideoDevices[0].deviceId);
+      persistenceEnabledManager.state.setStatus('enabled');
+
+      persistenceEnabledManager.state.setDevice(mockVideoDevices[1].deviceId);
+      persistenceEnabledManager.state.setStatus('enabled');
+
+      const preferences = readPreferences(storageKey);
+      expect(preferences.camera).toEqual([
+        {
+          selectedDeviceId: mockVideoDevices[1].deviceId,
+          selectedDeviceLabel: mockVideoDevices[1].label,
+          muted: false,
+        },
+        {
+          selectedDeviceId: mockVideoDevices[0].deviceId,
+          selectedDeviceLabel: mockVideoDevices[0].label,
+          muted: false,
+        },
+      ]);
+    });
+  });
+
+  describe('applyPersistedPreferences', () => {
+    beforeEach(() => {
+      manager.dispose();
+      manager = new TestInputMediaDeviceManager(manager['call'], {
+        enabled: true,
+        storageKey,
+      });
+      // @ts-expect-error - read only property
+      manager['call'].permissionsContext = new PermissionsContext();
+      manager['call'].permissionsContext.canPublish = vi
+        .fn()
+        .mockReturnValue(true);
+    });
+
+    it('returns false when no preferences exist', async () => {
+      // @ts-expect-error - private api
+      const result = await manager.applyPersistedPreferences(true);
+      expect(result).toBe(false);
+    });
+
+    it('selects device by id and applies muted state', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: mockVideoDevices[0].deviceId,
+              selectedDeviceLabel: mockVideoDevices[0].label,
+              muted: true,
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(manager, 'select');
+      const disableSpy = vi.spyOn(manager, 'disable');
+
+      // @ts-expect-error - private API
+      const result = await manager.applyPersistedPreferences(true);
+
+      expect(result).toBe(true);
+      expect(selectSpy).toHaveBeenCalledWith(mockVideoDevices[0].deviceId);
+      expect(disableSpy).toHaveBeenCalled();
+    });
+
+    it('selects device by label when device id is not found', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: 'missing-device',
+              selectedDeviceLabel: mockVideoDevices[1].label,
+              muted: false,
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(manager, 'select');
+
+      // @ts-expect-error private api
+      const result = await manager.applyPersistedPreferences(true);
+
+      expect(result).toBe(true);
+      expect(selectSpy).toHaveBeenCalledWith(mockVideoDevices[1].deviceId);
+    });
+
+    it('applies muted state without selecting when default device is stored', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: 'default',
+              selectedDeviceLabel: '',
+              muted: true,
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(manager, 'select');
+      const disableSpy = vi.spyOn(manager, 'disable');
+
+      // @ts-expect-error private api
+      const result = await manager.applyPersistedPreferences(true);
+
+      expect(result).toBe(true);
+      expect(selectSpy).not.toHaveBeenCalled();
+      expect(disableSpy).toHaveBeenCalled();
+    });
+  });
+
   afterEach(() => {
+    manager.dispose();
     vi.clearAllMocks();
     vi.resetModules();
+    Object.defineProperty(window, 'localStorage', {
+      configurable: true,
+      value: undefined,
+    });
   });
 });

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

@@ -28,6 +28,7 @@ class TestInputMediaDeviceManager extends DeviceManager<TestInputMediaDeviceMana
   public getTracks = () => this.state.mediaStream?.getTracks() ?? [];
 
   constructor(call: Call) {
+    const devicePersistence = { enabled: false, storageKey: '' };
     super(
       call,
       new TestInputMediaDeviceManagerState(
@@ -35,6 +36,7 @@ class TestInputMediaDeviceManager extends DeviceManager<TestInputMediaDeviceMana
         mockBrowserPermission,
       ),
       TrackType.VIDEO,
+      devicePersistence,
     );
   }
 }

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

@@ -14,12 +14,15 @@ import {
 } from '../../gen/video/sfu/models/models';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
 import {
+  createLocalStorageMock,
+  emitDeviceIds,
   mockAudioDevices,
   mockAudioStream,
   mockBrowserPermission,
   mockCall,
   mockDeviceIds$,
 } from './mocks';
+import { createAudioStreamForDevice } from './mediaStreamTestHelpers';
 import { setupAudioContextMock } from './web-audio.mocks';
 import { getAudioStream } from '../devices';
 import { MicrophoneManager } from '../MicrophoneManager';
@@ -35,6 +38,11 @@ import {
 import { PermissionsContext } from '../../permissions';
 import { Tracer } from '../../stats';
 import { settled, withoutConcurrency } from '../../helpers/concurrency';
+import {
+  defaultDeviceId,
+  readPreferences,
+  toPreferenceList,
+} from '../devicePersistence';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices API');
@@ -88,7 +96,8 @@ describe('MicrophoneManager', () => {
       streamClient: new StreamClient('abc123'),
       clientStore: new StreamVideoWriteableStateStore(),
     });
-    manager = new MicrophoneManager(call, 'disable-tracks');
+    const devicePersistence = { enabled: false, storageKey: '' };
+    manager = new MicrophoneManager(call, devicePersistence, 'disable-tracks');
   });
   it('list devices', () => {
     const spy = vi.fn();
@@ -174,7 +183,12 @@ describe('MicrophoneManager', () => {
       vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
         of('denied'),
       );
-      const innerManager = new MicrophoneManager(call, 'disable-tracks');
+      const devicePersistence = { enabled: false, storageKey: '' };
+      const innerManager = new MicrophoneManager(
+        call,
+        devicePersistence,
+        'disable-tracks',
+      );
       // @ts-expect-error private api
       const fn = vi.spyOn(innerManager, 'startSpeakingWhileMutedDetection');
 
@@ -408,6 +422,13 @@ describe('MicrophoneManager', () => {
       call.permissionsContext.canPublish = vi.fn().mockReturnValue(true);
     });
 
+    it('should apply defaults when mic_default_on is true and enabled is pristine', async () => {
+      const enable = vi.spyOn(manager, 'enable');
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: true }, true);
+      expect(enable).toHaveBeenCalled();
+    });
+
     it('should turn the mic on when set on dashboard', async () => {
       const enable = vi.spyOn(manager, 'enable');
       // @ts-expect-error - partial data
@@ -438,6 +459,37 @@ describe('MicrophoneManager', () => {
       await manager.apply({ mic_default_on: true }, true);
       expect(manager['publishStream']).toHaveBeenCalled();
     });
+
+    it('should skip defaults when preferences are applied', async () => {
+      const devicePersistence = { enabled: true, storageKey: '' };
+      const persistedManager = new MicrophoneManager(
+        call,
+        devicePersistence,
+        'disable-tracks',
+      );
+      const applySpy = vi
+        .spyOn(persistedManager as never, 'applyPersistedPreferences')
+        .mockResolvedValue(true);
+      const enableSpy = vi.spyOn(persistedManager, 'enable');
+
+      // @ts-expect-error - partial data
+      await persistedManager.apply({ mic_default_on: true }, true);
+
+      expect(applySpy).toHaveBeenCalledWith(true);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
+    it('should not apply defaults when mic is not pristine', async () => {
+      manager.state.setStatus('enabled');
+      const applySpy = vi.spyOn(manager as never, 'applyPersistedPreferences');
+      const enableSpy = vi.spyOn(manager, 'enable');
+
+      // @ts-expect-error - partial data
+      await manager.apply({ mic_default_on: true }, true);
+
+      expect(applySpy).not.toHaveBeenCalled();
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
   });
 
   describe('Hi-Fi Audio', () => {
@@ -582,6 +634,98 @@ describe('MicrophoneManager', () => {
     });
   });
 
+  describe('Device Persistence Stress', () => {
+    it('persists the final microphone and muted state after rapid toggles, switches, and unplug', async () => {
+      const storageKey = '@test/device-preferences-microphone-stress';
+      const localStorageMock = createLocalStorageMock();
+      const originalWindow = globalThis.window;
+      Object.defineProperty(globalThis, 'window', {
+        configurable: true,
+        value: { localStorage: localStorageMock },
+      });
+
+      const getAudioStreamMock = vi.mocked(getAudioStream);
+      getAudioStreamMock.mockImplementation((constraints) => {
+        const requestedDeviceId = (constraints?.deviceId as { exact?: string })
+          ?.exact;
+        const selectedDevice =
+          mockAudioDevices.find((d) => d.deviceId === requestedDeviceId) ??
+          mockAudioDevices[0];
+        return Promise.resolve(
+          createAudioStreamForDevice(
+            selectedDevice.deviceId,
+            selectedDevice.label,
+          ),
+        );
+      });
+
+      const stressManager = new MicrophoneManager(
+        call,
+        { enabled: true, storageKey },
+        'disable-tracks',
+      );
+
+      try {
+        const finalDevice = mockAudioDevices[2];
+        emitDeviceIds(mockAudioDevices);
+
+        await Promise.allSettled([
+          stressManager.enable(),
+          stressManager.select(mockAudioDevices[1].deviceId),
+          stressManager.toggle(),
+          stressManager.select(finalDevice.deviceId),
+          stressManager.toggle(),
+          stressManager.enable(),
+        ]);
+        await stressManager.statusChangeSettled();
+        await stressManager.select(finalDevice.deviceId);
+        await stressManager.enable();
+        await stressManager.statusChangeSettled();
+
+        expect(stressManager.state.selectedDevice).toBe(finalDevice.deviceId);
+        expect(stressManager.state.status).toBe('enabled');
+
+        const persistedBeforeUnplug = toPreferenceList(
+          readPreferences(storageKey).microphone,
+        );
+        expect(persistedBeforeUnplug[0]).toEqual({
+          selectedDeviceId: finalDevice.deviceId,
+          selectedDeviceLabel: finalDevice.label,
+          muted: false,
+        });
+
+        emitDeviceIds(
+          mockAudioDevices.filter((d) => d.deviceId !== finalDevice.deviceId),
+        );
+
+        await vi.waitFor(() => {
+          expect(stressManager.state.selectedDevice).toBe(undefined);
+          expect(stressManager.state.status).toBe('disabled');
+        });
+
+        const persistedAfterUnplug = toPreferenceList(
+          readPreferences(storageKey).microphone,
+        );
+        expect(persistedAfterUnplug[0]).toEqual({
+          selectedDeviceId: defaultDeviceId,
+          selectedDeviceLabel: '',
+          muted: true,
+        });
+        expect(persistedAfterUnplug).toContainEqual({
+          selectedDeviceId: finalDevice.deviceId,
+          selectedDeviceLabel: finalDevice.label,
+          muted: true,
+        });
+      } finally {
+        stressManager.dispose();
+        Object.defineProperty(globalThis, 'window', {
+          configurable: true,
+          value: originalWindow,
+        });
+      }
+    });
+  });
+
   afterEach(() => {
     vi.restoreAllMocks();
     vi.clearAllMocks();

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

@@ -80,6 +80,7 @@ describe('MicrophoneManager React Native', () => {
       },
     };
 
+    const devicePersistence = { enabled: false, storageKey: '' };
     manager = new MicrophoneManager(
       new Call({
         id: '',
@@ -87,6 +88,7 @@ describe('MicrophoneManager React Native', () => {
         streamClient: new StreamClient('abc123'),
         clientStore: new StreamVideoWriteableStateStore(),
       }),
+      devicePersistence,
     );
   });
 

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

@@ -34,6 +34,7 @@ describe('ScreenShareManager', () => {
   let manager: ScreenShareManager;
 
   beforeEach(() => {
+    const devicePersistence = { enabled: false, storageKey: '' };
     manager = new ScreenShareManager(
       new Call({
         id: '',
@@ -41,6 +42,7 @@ describe('ScreenShareManager', () => {
         streamClient: new StreamClient('abc123'),
         clientStore: new StreamVideoWriteableStateStore(),
       }),
+      devicePersistence,
     );
   });
 

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

@@ -1,7 +1,10 @@
+/* @vitest-environment happy-dom */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { fromPartial } from '@total-typescript/shoehorn';
 import {
+  createLocalStorageMock,
   emitDeviceIds,
+  LocalStorageMock,
   mockAudioDevices,
   mockBrowserPermission,
   mockDeviceIds$,
@@ -12,6 +15,7 @@ import { checkIfAudioOutputChangeSupported } from '../devices';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 import { StreamVideoWriteableStateStore } from '../../store';
+import { defaultDeviceId } from '../devicePersistence';
 
 vi.mock('../devices.ts', () => {
   console.log('MOCKING devices');
@@ -27,8 +31,17 @@ vi.mock('../devices.ts', () => {
 
 describe('SpeakerManager.test', () => {
   let manager: SpeakerManager;
+  let storageKey: string;
+  let localStorageMock: LocalStorageMock;
 
   beforeEach(() => {
+    storageKey = '@test/speaker-preferences';
+    localStorageMock = createLocalStorageMock();
+    Object.defineProperty(window, 'localStorage', {
+      configurable: true,
+      value: localStorageMock,
+    });
+    const devicePersistence = { enabled: false, storageKey };
     manager = new SpeakerManager(
       new Call({
         id: '',
@@ -36,6 +49,7 @@ describe('SpeakerManager.test', () => {
         streamClient: new StreamClient('abc123'),
         clientStore: new StreamVideoWriteableStateStore(),
       }),
+      devicePersistence,
     );
   });
 
@@ -111,8 +125,84 @@ describe('SpeakerManager.test', () => {
     expect(manager.state.selectedDevice).toBe('');
   });
 
+  describe('apply (web)', () => {
+    it('does nothing when persistence is disabled', () => {
+      const selectSpy = vi.spyOn(manager, 'select');
+      // @ts-expect-error - partial data
+      manager.apply({});
+      expect(selectSpy).not.toHaveBeenCalled();
+    });
+
+    it('selects the persisted speaker device', () => {
+      const persistedManager = new SpeakerManager(
+        new Call({
+          id: '',
+          type: '',
+          streamClient: new StreamClient('abc123'),
+          clientStore: new StreamVideoWriteableStateStore(),
+        }),
+        { enabled: true, storageKey },
+      );
+
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          speaker: [
+            {
+              selectedDeviceId: 'speaker-1',
+              selectedDeviceLabel: 'Speaker 1',
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(persistedManager, 'select');
+      // @ts-expect-error - partial data
+      persistedManager.apply({});
+
+      expect(selectSpy).toHaveBeenCalledWith('speaker-1');
+      expect(persistedManager.state.selectedDevice).toBe('speaker-1');
+    });
+
+    it('selects system default when persisted device is default', () => {
+      const persistedManager = new SpeakerManager(
+        new Call({
+          id: '',
+          type: '',
+          streamClient: new StreamClient('abc123'),
+          clientStore: new StreamVideoWriteableStateStore(),
+        }),
+        { enabled: true, storageKey },
+      );
+      persistedManager.select('previous-device');
+
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          speaker: [
+            {
+              selectedDeviceId: defaultDeviceId,
+              selectedDeviceLabel: '',
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(persistedManager, 'select');
+      // @ts-expect-error - partial data
+      persistedManager.apply({});
+
+      expect(selectSpy).toHaveBeenCalledWith('');
+      expect(persistedManager.state.selectedDevice).toBe('');
+    });
+  });
+
   afterEach(() => {
     vi.clearAllMocks();
     vi.resetModules();
+    Object.defineProperty(window, 'localStorage', {
+      configurable: true,
+      value: undefined,
+    });
   });
 });