@stream-io/video-client 1.56.0 → 1.58.0

package/src/devices/MicrophoneManager.ts

@@ -76,7 +76,10 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
         ]) => {
           try {
             if (callingState === CallingState.LEFT) {
-              this.setMutedRecordingPrepared(false);
+              // The muted-recording-prepared mode is reset in `callManager.stop()`
+              // (during leave, while the call factory is still alive), not here —
+              // this subscription fires asynchronously and could land after the
+              // factory is disposed, forcing a default-ADM rebuild.
               await this.stopSpeakingWhileMutedDetection();
             }
             if (callingState !== CallingState.JOINED) return;
@@ -187,6 +190,44 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
     }
   }
 
+  override enable(): Promise<void> {
+    if (isReactNative() && !this.call.hasMediaEngine) {
+      this.state.setPendingStatus('enabled');
+      return Promise.resolve();
+    }
+
+    return super.enable();
+  }
+
+  override disable(options: { forceStop?: boolean }): Promise<void>;
+  override disable(forceStop?: boolean): Promise<void>;
+  override async disable(
+    forceStopOrOptions?: boolean | { forceStop?: boolean },
+  ): Promise<void> {
+    if (isReactNative() && !this.call.hasMediaEngine) {
+      this.state.setPendingStatus('disabled');
+      return;
+    }
+
+    // forward verbatim to the base, narrowing so the right overload is selected
+    if (forceStopOrOptions === undefined) return super.disable();
+    if (typeof forceStopOrOptions === 'boolean') {
+      return super.disable(forceStopOrOptions);
+    }
+    return super.disable(forceStopOrOptions);
+  }
+
+  override toggle(): Promise<void> {
+    if (isReactNative() && !this.call.hasMediaEngine) {
+      this.state.setPendingStatus(
+        this.state.optimisticStatus === 'enabled' ? 'disabled' : 'enabled',
+      );
+      return Promise.resolve();
+    }
+
+    return super.toggle();
+  }
+
   /**
    * Enables noise cancellation for the microphone.
    *
@@ -376,9 +417,15 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
       }
     }
 
-    const { mediaStream } = this.state;
-    if (canPublish && publish && this.enabled && mediaStream) {
-      await this.publishStream(mediaStream);
+    if (isReactNative() && publish && canPublish) {
+      // On RN the microphone is enabled/disabled optimistically before JOINED. Reconcile now
+      // acquires the track and publishes it, so it fully owns the publish.
+      await this.reconcileOptimisticStatus();
+    } else {
+      const { mediaStream } = this.state;
+      if (canPublish && publish && this.enabled && mediaStream) {
+        await this.publishStream(mediaStream);
+      }
     }
   }
 
@@ -386,9 +433,12 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
     return getAudioDevices(this.call.tracer);
   }
 
-  protected override getStream(
+  protected override async getStream(
     constraints: MediaTrackConstraints,
   ): Promise<MediaStream> {
+    // Ensure the call's media factory exists before capture so the resulting
+    // track is owned by it (the WebRTC globals resolve to the live factory).
+    await this.call.ensureMediaFactory();
     return getAudioStream(constraints, this.call.tracer);
   }
 

package/src/devices/ScreenShareManager.ts

@@ -90,6 +90,9 @@ export class ScreenShareManager extends AudioDeviceManager<
     if (!this.state.audioEnabled) {
       constraints.audio = false;
     }
+    // Ensure the call's media factory exists before capture so the resulting
+    // track is owned by it (the WebRTC globals resolve to the live factory).
+    await this.call.ensureMediaFactory();
     const stream = await getScreenShareStream(constraints, this.call.tracer);
     const [track] = stream.getVideoTracks();
     const { contentHint } = this.state.settings || {};

package/src/devices/SpeakerManager.ts

@@ -1,4 +1,4 @@
-import { combineLatest } from 'rxjs';
+import { combineLatest, firstValueFrom, pairwise } from 'rxjs';
 import { Call } from '../Call';
 import { isReactNative } from '../helpers/platforms';
 import { SpeakerState } from './SpeakerState';
@@ -39,11 +39,15 @@ export class SpeakerManager {
     this.setup();
   }
 
-  apply(settings: CallSettingsResponse) {
-    return isReactNative() ? this.applyRN(settings) : this.applyWeb();
+  async apply(settings: CallSettingsResponse): Promise<void> {
+    if (isReactNative()) {
+      this.applyRN(settings);
+      return;
+    }
+    await this.applyWeb();
   }
 
-  private applyWeb() {
+  private async applyWeb() {
     const { enabled, storageKey } = this.devicePersistence;
     if (!enabled) return;
 
@@ -56,8 +60,26 @@ export class SpeakerManager {
       preference.selectedDeviceId === defaultDeviceId
         ? ''
         : preference.selectedDeviceId;
-    if (this.state.selectedDevice !== nextDeviceId) {
-      this.select(nextDeviceId);
+    if (!nextDeviceId) {
+      if (this.state.selectedDevice !== nextDeviceId) {
+        this.select(nextDeviceId);
+      }
+      return;
+    }
+
+    const permissionState = await firstValueFrom(
+      getAudioBrowserPermission(this.call.tracer).asStateObservable(),
+    );
+    if (permissionState !== 'granted') return;
+
+    const devices = await firstValueFrom(this.listDevices());
+    const device =
+      this.findDevice(devices, nextDeviceId) ??
+      (preference.selectedDeviceLabel
+        ? devices.find((d) => d.label === preference.selectedDeviceLabel)
+        : undefined);
+    if (device && this.state.selectedDevice !== device.deviceId) {
+      this.select(device.deviceId);
     }
   }
 
@@ -90,6 +112,7 @@ export class SpeakerManager {
       globalThis.streamRNVideoSDK?.callManager.setup({
         defaultDevice,
         isRingingTypeCall: this.call.ringing,
+        cid: this.call.cid,
       });
     }
   }
@@ -101,13 +124,16 @@ export class SpeakerManager {
     if (deviceIds$ && !isReactNative()) {
       this.subscriptions.push(
         createSubscription(
-          combineLatest([deviceIds$, this.state.selectedDevice$]),
-          ([devices, deviceId]) => {
+          combineLatest([
+            deviceIds$!.pipe(pairwise()),
+            this.state.selectedDevice$,
+          ]),
+          ([[prevDevices, currentDevices], deviceId]) => {
             if (!deviceId) return;
-            const device = devices.find(
-              (d) => d.deviceId === deviceId && d.kind === 'audiooutput',
-            );
-            if (!device) this.select('');
+            const isDisconnected =
+              this.findDevice(prevDevices, deviceId) &&
+              !this.findDevice(currentDevices, deviceId);
+            if (isDisconnected) this.select('');
           },
         ),
       );
@@ -164,6 +190,7 @@ export class SpeakerManager {
     this.subscriptions.forEach((unsubscribe) => unsubscribe());
     this.subscriptions = [];
     this.areSubscriptionsSetUp = false;
+    this.defaultDevice = undefined;
   };
 
   /**
@@ -201,6 +228,9 @@ export class SpeakerManager {
     });
   }
 
+  private findDevice = (devices: MediaDeviceInfo[], deviceId: string) =>
+    devices.find((d) => d.deviceId === deviceId && d.kind === 'audiooutput');
+
   private persistSpeakerDevicePreference(selectedDevice: string) {
     const { storageKey } = this.devicePersistence;
     const devices = getCurrentValue(this.listDevices()) || [];

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

@@ -2,7 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { MicrophoneManager } from '../MicrophoneManager';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
-import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { StreamVideoWriteableStateStore } from '../../store';
 import {
   mockAudioDevices,
   mockAudioStream,
@@ -16,8 +16,7 @@ import { settled, withoutConcurrency } from '../../helpers/concurrency';
 import { ClientEventReporter } from '../../reporting';
 
 let speechActivityCallback:
-  | ((state: { isSoundDetected: boolean }) => void)
-  | null = null;
+  ((state: { isSoundDetected: boolean }) => void) | null = null;
 let unsubscribeMocks: ReturnType<typeof vi.fn>[] = [];
 
 vi.mock('../../helpers/platforms.ts', () => {
@@ -264,25 +263,6 @@ describe('MicrophoneManager React Native', () => {
     expect(setMutedRecordingPreparedMock).not.toHaveBeenCalledWith(true);
   });
 
-  it('should release prepared muted recording when the call is left', async () => {
-    await manager.disable();
-    await vi.waitUntil(
-      () =>
-        setMutedRecordingPreparedMock.mock.calls.some(([arg]) => arg === true),
-      { timeout: 100 },
-    );
-    setMutedRecordingPreparedMock.mockClear();
-
-    manager['call'].state.setCallingState(CallingState.LEFT);
-
-    await vi.waitUntil(
-      () =>
-        setMutedRecordingPreparedMock.mock.calls.some(([arg]) => arg === false),
-      { timeout: 100 },
-    );
-    expect(setMutedRecordingPreparedMock).toHaveBeenCalledWith(false);
-  });
-
   afterEach(() => {
     globalThis.streamRNVideoSDK = undefined;
     vi.clearAllMocks();

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

@@ -6,8 +6,10 @@ import {
   emitDeviceIds,
   LocalStorageMock,
   mockAudioDevices,
+  mockAudioOutputDevices,
   mockBrowserPermission,
   mockDeviceIds$,
+  mockDevicesWithoutAudioPermission,
 } from './mocks';
 import { of } from 'rxjs';
 import { SpeakerManager } from '../SpeakerManager';
@@ -122,15 +124,36 @@ describe('SpeakerManager.test', () => {
   });
 
   it('should disable device if selected device is disconnected', () => {
-    emitDeviceIds(mockAudioDevices);
-    const deviceId = mockAudioDevices[1].deviceId;
+    const deviceId = mockAudioOutputDevices[0].deviceId;
+    emitDeviceIds([...mockAudioDevices, ...mockAudioOutputDevices]);
     manager.select(deviceId);
 
-    emitDeviceIds(mockAudioDevices.slice(2));
+    emitDeviceIds([...mockAudioDevices, ...mockAudioOutputDevices.slice(1)]);
 
     expect(manager.state.selectedDevice).toBe('');
   });
 
+  it('should keep the selection when the device list never exposed audio ids', () => {
+    const deviceId = mockAudioOutputDevices[0].deviceId;
+    emitDeviceIds(mockDevicesWithoutAudioPermission);
+
+    manager.select(deviceId);
+    expect(manager.state.selectedDevice).toBe(deviceId);
+
+    emitDeviceIds(mockDevicesWithoutAudioPermission);
+    expect(manager.state.selectedDevice).toBe(deviceId);
+  });
+
+  it('should keep the selection when the device appears in a later enumeration', () => {
+    const deviceId = mockAudioOutputDevices[0].deviceId;
+    emitDeviceIds(mockDevicesWithoutAudioPermission);
+    manager.select(deviceId);
+
+    emitDeviceIds([...mockAudioDevices, ...mockAudioOutputDevices]);
+
+    expect(manager.state.selectedDevice).toBe(deviceId);
+  });
+
   it('persists speaker selection when permission is granted', async () => {
     const streamClient = new StreamClient('abc123');
     const persistedManager = new SpeakerManager(
@@ -159,16 +182,9 @@ describe('SpeakerManager.test', () => {
   });
 
   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 createPersistedManager = () => {
       const streamClient = new StreamClient('abc123');
-      const persistedManager = new SpeakerManager(
+      return new SpeakerManager(
         new Call({
           id: '',
           type: '',
@@ -178,56 +194,136 @@ describe('SpeakerManager.test', () => {
         }),
         { enabled: true, storageKey },
       );
+    };
 
+    const persist = (selectedDeviceId: string, selectedDeviceLabel: string) => {
       localStorageMock.setItem(
         storageKey,
         JSON.stringify({
-          speaker: [
-            {
-              selectedDeviceId: 'speaker-1',
-              selectedDeviceLabel: 'Speaker 1',
-            },
-          ],
+          speaker: [{ selectedDeviceId, selectedDeviceLabel }],
         }),
       );
+    };
+
+    it('does nothing when persistence is disabled', async () => {
+      const selectSpy = vi.spyOn(manager, 'select');
+      // @ts-expect-error - partial data
+      await manager.apply({});
+      expect(selectSpy).not.toHaveBeenCalled();
+    });
+
+    it('selects the persisted speaker device', async () => {
+      const persistedManager = createPersistedManager();
+      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
-      persistedManager.apply({});
+      await persistedManager.apply({});
 
       expect(selectSpy).toHaveBeenCalledWith('speaker-1');
       expect(persistedManager.state.selectedDevice).toBe('speaker-1');
     });
 
-    it('selects system default when persisted device is default', () => {
-      const streamClient = new StreamClient('abc123');
-      const persistedManager = new SpeakerManager(
-        new Call({
-          id: '',
-          type: '',
-          streamClient,
-          clientEventReporter: new ClientEventReporter({ streamClient }),
-          clientStore: new StreamVideoWriteableStateStore(),
-        }),
-        { enabled: true, storageKey },
+    it('does not select a missing persisted speaker device', async () => {
+      const persistedManager = createPersistedManager();
+      vi.spyOn(persistedManager, 'listDevices').mockReturnValue(
+        of(mockAudioOutputDevices),
       );
-      persistedManager.select('previous-device');
+      persist('speaker-1', 'Speaker 1');
 
-      localStorageMock.setItem(
-        storageKey,
-        JSON.stringify({
-          speaker: [
-            {
-              selectedDeviceId: defaultDeviceId,
-              selectedDeviceLabel: '',
-            },
-          ],
-        }),
+      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 restore a speaker preference when audio permission is not granted', async () => {
+      const persistedManager = createPersistedManager();
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('prompt'),
+      );
+      const listDevicesSpy = vi.spyOn(persistedManager, 'listDevices');
+      persist('speaker-1', 'Speaker 1');
+
+      const selectSpy = vi.spyOn(persistedManager, 'select');
+      // @ts-expect-error - partial data
+      await persistedManager.apply({});
+
+      expect(listDevicesSpy).not.toHaveBeenCalled();
+      expect(selectSpy).not.toHaveBeenCalled();
+      expect(persistedManager.state.selectedDevice).toBe('');
+    });
+
+    it('does not restore a speaker preference from a non-output device with the same label', async () => {
+      const persistedManager = createPersistedManager();
+      const videoDevice = {
+        deviceId: 'video-device-id',
+        kind: 'videoinput',
+        label: 'RODECaster Video (19f7:006b)',
+        groupId: 'video-group',
+      } as MediaDeviceInfo;
+      const outputDevice = {
+        deviceId: 'speaker-device-id',
+        kind: 'audiooutput',
+        label: 'RODECaster Video (19f7:006b)',
+        groupId: 'speaker-group',
+      } as MediaDeviceInfo;
+      vi.spyOn(persistedManager, 'listDevices').mockReturnValue(
+        of([outputDevice]),
       );
+      persist('missing-speaker-device-id', outputDevice.label);
+
+      const selectSpy = vi.spyOn(persistedManager, 'select');
+      // @ts-expect-error - partial data
+      await persistedManager.apply({});
+
+      expect(selectSpy).toHaveBeenCalledWith(outputDevice.deviceId);
+      expect(selectSpy).not.toHaveBeenCalledWith(videoDevice.deviceId);
+      expect(persistedManager.state.selectedDevice).toBe(outputDevice.deviceId);
+    });
+
+    it('does not restore a speaker preference from an empty label placeholder', async () => {
+      const persistedManager = createPersistedManager();
+      vi.spyOn(persistedManager, 'listDevices').mockReturnValue(
+        of([
+          {
+            deviceId: '',
+            kind: 'audiooutput',
+            label: '',
+            groupId: '',
+          } as MediaDeviceInfo,
+        ]),
+      );
+      persist('missing-speaker-device-id', '');
+
+      const selectSpy = vi.spyOn(persistedManager, 'select');
+      // @ts-expect-error - partial data
+      await persistedManager.apply({});
+
+      expect(selectSpy).not.toHaveBeenCalled();
+      expect(persistedManager.state.selectedDevice).toBe('');
+    });
+
+    it('selects system default when persisted device is default', async () => {
+      const persistedManager = createPersistedManager();
+      persistedManager.select('previous-device');
+      persist(defaultDeviceId, '');
 
       const selectSpy = vi.spyOn(persistedManager, 'select');
       // @ts-expect-error - partial data
-      persistedManager.apply({});
+      await persistedManager.apply({});
 
       expect(selectSpy).toHaveBeenCalledWith('');
       expect(persistedManager.state.selectedDevice).toBe('');

package/src/devices/__tests__/mocks.ts

@@ -6,7 +6,7 @@ import {
   OwnCapability,
 } from '../../gen/coordinator';
 import { Call } from '../../Call';
-import { of, Subject } from 'rxjs';
+import { of, ReplaySubject } from 'rxjs';
 import { BrowserPermission } from '../BrowserPermission';
 import { Tracer } from '../../stats';
 
@@ -71,6 +71,35 @@ export const mockAudioDevices = [
   },
 ] as MediaDeviceInfo[];
 
+export const mockAudioOutputDevices = [
+  {
+    deviceId:
+      'f1602a62d9d363c0711de07182751b646b87cfc0edd9e89d2849289e49304158',
+    kind: 'audiooutput',
+    label: 'RODECaster Video (19f7:006b)',
+    groupId: '27f43ef815ab224429532d6e8ebbeb00d7a895e0cbb0c2e4fcbe5b370f234259',
+  },
+  {
+    deviceId:
+      'd542885e6a47d7a38837aee0323bd2c50e825971690f47295cb338e1f1061283',
+    kind: 'audiooutput',
+    label: 'MacBook Pro Speakers (Built-in)',
+    groupId: 'a8708545cb3969c0b7e3712d2ffdbc381992aeb5577b06cd71ba7a94ee20cf3e',
+  },
+] as MediaDeviceInfo[];
+
+export const mockDevicesWithoutAudioPermission = [
+  { deviceId: '', kind: 'audioinput', label: '', groupId: '' },
+  {
+    deviceId:
+      'f10561a0bbd3effbd25645e7f06fc2e261255afeb05f6bc4fdaba3ed7bd9c2b7',
+    kind: 'videoinput',
+    label: 'RODECaster Video (19f7:006b)',
+    groupId: '27f43ef815ab224429532d6e8ebbeb00d7a895e0cbb0c2e4fcbe5b370f234259',
+  },
+  { deviceId: '', kind: 'audiooutput', label: '', groupId: '' },
+] as MediaDeviceInfo[];
+
 export const mockCall = (): Partial<Call> => {
   const callState = new CallState();
   callState.setCallingState(CallingState.JOINED);
@@ -97,6 +126,7 @@ export const mockCall = (): Partial<Call> => {
   return {
     cid: 'default:test-call',
     state: callState,
+    hasMediaEngine: true,
     publish: vi.fn(),
     stopPublish: vi.fn(),
     streamClient: fromPartial({
@@ -106,6 +136,9 @@ export const mockCall = (): Partial<Call> => {
     notifyNoiseCancellationStopped: vi.fn().mockResolvedValue(undefined),
     notifyTrackMuteState: vi.fn().mockResolvedValue(undefined),
     refreshPublishedTrack: vi.fn().mockResolvedValue(undefined),
+    ensureMediaFactory: vi.fn().mockResolvedValue({
+      dispose: vi.fn().mockResolvedValue(undefined),
+    }),
     tracer: new Tracer('tests'),
   };
 };
@@ -252,9 +285,9 @@ export const createLocalStorageMock = (): LocalStorageMock => {
   };
 };
 
-let deviceIds: Subject<MediaDeviceInfo[]>;
+let deviceIds: ReplaySubject<MediaDeviceInfo[]>;
 export const mockDeviceIds$ = () => {
-  deviceIds = new Subject();
+  deviceIds = new ReplaySubject(1);
   return deviceIds;
 };
 

package/src/devices/devicePersistence.ts

@@ -24,8 +24,7 @@ export type LocalDevicePreference = {
 
 export type LocalDevicePreferences = {
   [type in DevicePreferenceKey]?:
-    | LocalDevicePreference
-    | LocalDevicePreference[];
+    LocalDevicePreference | LocalDevicePreference[];
 };
 
 export const defaultDeviceId = 'default';