@stream-io/video-client 1.57.0 → 1.59.0

package/src/devices/CameraManager.ts

@@ -124,13 +124,56 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
     }
   }
 
+  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();
+  }
+
   /**
    * Applies the video settings to the camera.
    *
    * @param settings the video settings to apply.
    * @param publish whether to publish the stream after applying the settings.
+   * @param forceDisabled whether to keep the camera disabled, regardless of server-side or local preferences.
    */
-  async apply(settings: VideoSettingsResponse, publish: boolean) {
+  async apply(
+    settings: VideoSettingsResponse,
+    publish: boolean,
+    forceDisabled: boolean = false,
+  ): Promise<void> {
     // Wait for any in progress camera operation
     await this.statusChangeSettled();
     await this.selectTargetResolution(settings.target_resolution);
@@ -148,8 +191,10 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
       this.devicePersistence.enabled &&
       permissionState === 'granted'
     ) {
-      persistedPreferencesApplied =
-        await this.applyPersistedPreferences(enabledInCallType);
+      persistedPreferencesApplied = await this.applyPersistedPreferences(
+        enabledInCallType,
+        forceDisabled,
+      );
     }
 
     // apply a direction and enable the camera only if in "pristine" state,
@@ -161,14 +206,25 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
         await this.selectDirection(direction, { enableCamera: false });
       }
 
-      if (canPublish && settings.camera_default_on && enabledInCallType) {
+      if (
+        !forceDisabled &&
+        canPublish &&
+        settings.camera_default_on &&
+        enabledInCallType
+      ) {
         await this.enable();
       }
     }
 
-    const { mediaStream } = this.state;
-    if (canPublish && publish && this.enabled && mediaStream) {
-      await this.publishStream(mediaStream);
+    if (isReactNative() && publish && canPublish) {
+      // On RN the camera 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);
+      }
     }
   }
 
@@ -196,9 +252,12 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
     return constraints;
   }
 
-  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 getVideoStream(constraints, this.call.tracer);
   }
 }

package/src/devices/DeviceManager.ts

@@ -509,6 +509,23 @@ export abstract class DeviceManager<
     }
   }
 
+  protected reconcileOptimisticStatus = async (): Promise<void> => {
+    const target = this.state.optimisticStatus;
+    await withCancellation(this.statusChangeConcurrencyTag, async (signal) => {
+      try {
+        if (target === 'enabled' && this.state.status !== 'enabled') {
+          await this.unmuteStream();
+          if (!signal.aborted) this.state.setStatus('enabled');
+        } else if (target === 'disabled' && this.state.status === 'enabled') {
+          // mirror whatever disable() does to stop/pause the track per disableMode
+          if (!signal.aborted) this.state.setStatus('disabled');
+        }
+      } finally {
+        if (!signal.aborted) this.state.setPendingStatus(this.state.status);
+      }
+    });
+  };
+
   private disableTracks() {
     this.getTracks().forEach((track) => {
       if (track.enabled) track.enabled = false;
@@ -825,7 +842,10 @@ export abstract class DeviceManager<
     writePreferences(currentDevice, deviceKey, muted, storageKey);
   }
 
-  protected async applyPersistedPreferences(enabledInCallType: boolean) {
+  protected async applyPersistedPreferences(
+    enabledInCallType: boolean,
+    forceDisabled = false,
+  ) {
     const deviceKey: DevicePreferenceKey =
       this.trackType === TrackType.AUDIO ? 'microphone' : 'camera';
     const preferences = readPreferences(this.devicePersistence.storageKey);
@@ -858,15 +878,15 @@ export abstract class DeviceManager<
 
     const canPublish = this.call.permissionsContext.canPublish(this.trackType);
     if (typeof muted === 'boolean' && enabledInCallType && canPublish) {
-      await this.applyMutedState(muted);
+      await this.applyMutedState(muted, forceDisabled);
       appliedMute = true;
     }
 
     return appliedDevice || appliedMute;
   }
 
-  private async applyMutedState(muted: boolean) {
-    if (this.state.status !== undefined) return;
+  private async applyMutedState(muted: boolean, forceDisabled: boolean) {
+    if (forceDisabled || this.state.status !== undefined) return;
     if (muted) {
       await this.disable();
     } else {

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.
    *
@@ -347,8 +388,13 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
    * Applies the audio settings to the microphone.
    * @param settings the audio settings to apply.
    * @param publish whether to publish the stream after applying the settings.
+   * @param forceDisabled whether to keep the mic disabled, regardless of server-side or local preferences.
    */
-  async apply(settings: AudioSettingsResponse, publish: boolean) {
+  async apply(
+    settings: AudioSettingsResponse,
+    publish: boolean,
+    forceDisabled: boolean = false,
+  ) {
     // Wait for any in progress mic operation
     await this.statusChangeSettled();
 
@@ -366,19 +412,28 @@ export class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState
       this.devicePersistence.enabled &&
       permissionState === 'granted'
     ) {
-      persistedPreferencesApplied = await this.applyPersistedPreferences(true);
+      persistedPreferencesApplied = await this.applyPersistedPreferences(
+        true,
+        forceDisabled,
+      );
     }
 
     const canPublish = this.call.permissionsContext.canPublish(this.trackType);
     if (shouldApplyDefaults && !persistedPreferencesApplied) {
-      if (canPublish && settings.mic_default_on) {
+      if (!forceDisabled && canPublish && settings.mic_default_on) {
         await this.enable();
       }
     }
 
-    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 +441,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__/CameraManager.test.ts

@@ -357,11 +357,37 @@ describe('CameraManager', () => {
         true,
       );
 
-      expect(applySpy).toHaveBeenCalledWith(true);
+      expect(applySpy).toHaveBeenCalledWith(true, false);
       expect(selectDirectionSpy).not.toHaveBeenCalled();
       expect(enableSpy).not.toHaveBeenCalled();
     });
 
+    it('should apply persisted device preferences without enabling when forced disabled', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
+      const devicePersistence = { enabled: true, storageKey: '' };
+      const persistedManager = new CameraManager(call, devicePersistence);
+      const applySpy = vi
+        .spyOn(persistedManager as never, 'applyPersistedPreferences')
+        .mockResolvedValue(true);
+      const enableSpy = vi.spyOn(persistedManager, 'enable');
+
+      await persistedManager.apply(
+        fromPartial({
+          enabled: true,
+          target_resolution: { width: 640, height: 480 },
+          camera_facing: 'front',
+          camera_default_on: true,
+        }),
+        false,
+        true,
+      );
+
+      expect(applySpy).toHaveBeenCalledWith(true, true);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
     it('should skip persisted preferences when permission is not granted', async () => {
       vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
         of('prompt'),

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

@@ -21,7 +21,7 @@ import { DeviceManagerState } from '../DeviceManagerState';
 import { firstValueFrom, of } from 'rxjs';
 import { TrackType } from '../../gen/video/sfu/models/models';
 import { PermissionsContext } from '../../permissions';
-import { readPreferences } from '../devicePersistence';
+import { defaultDeviceId, readPreferences } from '../devicePersistence';
 
 vi.mock('../../reporting/ClientEventReporter', () => ({
   ClientEventReporter: vi.fn(function () {
@@ -1010,6 +1010,54 @@ describe('Device Manager', () => {
       expect(selectSpy).toHaveBeenCalledWith(mockVideoDevices[1].deviceId);
     });
 
+    it('selects the device without unmuting when forced disabled', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: mockVideoDevices[0].deviceId,
+              selectedDeviceLabel: mockVideoDevices[0].label,
+              muted: false,
+            },
+          ],
+        }),
+      );
+
+      const selectSpy = vi.spyOn(manager, 'select');
+      const enableSpy = vi.spyOn(manager, 'enable');
+
+      // @ts-expect-error - private API
+      const result = await manager.applyPersistedPreferences(true, true);
+
+      expect(result).toBe(true);
+      expect(selectSpy).toHaveBeenCalledWith(mockVideoDevices[0].deviceId);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
+    it('retains a default-device mute preference when forced disabled', async () => {
+      localStorageMock.setItem(
+        storageKey,
+        JSON.stringify({
+          camera: [
+            {
+              selectedDeviceId: defaultDeviceId,
+              selectedDeviceLabel: '',
+              muted: false,
+            },
+          ],
+        }),
+      );
+
+      const enableSpy = vi.spyOn(manager, 'enable');
+
+      // @ts-expect-error - private API
+      const result = await manager.applyPersistedPreferences(true, true);
+
+      expect(result).toBe(true);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
     it('applies muted state without selecting when default device is stored', async () => {
       localStorageMock.setItem(
         storageKey,

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

@@ -486,7 +486,29 @@ describe('MicrophoneManager', () => {
       // @ts-expect-error - partial data
       await persistedManager.apply({ mic_default_on: true }, true);
 
-      expect(applySpy).toHaveBeenCalledWith(true);
+      expect(applySpy).toHaveBeenCalledWith(true, false);
+      expect(enableSpy).not.toHaveBeenCalled();
+    });
+
+    it('should apply persisted device preferences without enabling when forced disabled', async () => {
+      vi.spyOn(mockBrowserPermission, 'asStateObservable').mockReturnValue(
+        of('granted'),
+      );
+      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 }, false, true);
+
+      expect(applySpy).toHaveBeenCalledWith(true, true);
       expect(enableSpy).not.toHaveBeenCalled();
     });
 

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,
@@ -263,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();