@stream-io/video-client 1.43.0 → 1.44.0

package/dist/src/StreamVideoClient.d.ts

@@ -2,15 +2,9 @@ import { Call } from './Call';
 import { StreamClient } from './coordinator/connection/client';
 import { StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore } from './store';
 import type { ConnectedEvent, CreateDeviceRequest, CreateGuestRequest, CreateGuestResponse, GetEdgesResponse, ListDevicesResponse, QueryAggregateCallStatsRequest, QueryAggregateCallStatsResponse, QueryCallsRequest, QueryCallStatsRequest, QueryCallStatsResponse } from './gen/coordinator';
-import { AllClientEvents, ClientEventListener, StreamClientOptions, TokenOrProvider, TokenProvider, User } from './coordinator/connection/types';
+import { AllClientEvents, ClientEventListener, StreamClientOptions, TokenOrProvider, User } from './coordinator/connection/types';
+import type { StreamVideoClientOptions } from './types';
 import { ScopedLogger } from './logger';
-export type StreamVideoClientOptions = {
-    apiKey: string;
-    options?: StreamClientOptions;
-    user?: User;
-    token?: string;
-    tokenProvider?: TokenProvider;
-};
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
  */

package/dist/src/coordinator/connection/types.d.ts

@@ -2,6 +2,7 @@ import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { ConnectedEvent, UserRequest, VideoEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 import type { ConfigureLoggersOptions, LogLevel } from '@stream-io/logger';
+import type { DevicePersistenceOptions } from '../../devices/devicePersistence';
 export type UR = Record<string, unknown>;
 export type User = (Omit<UserRequest, 'role'> & {
     type?: 'authenticated';
@@ -185,6 +186,10 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
      * When set to true, the incoming calls are rejected when the user is busy in an another call.
      */
     rejectCallWhenBusy?: boolean;
+    /**
+     * Device persistence preference options (web only).
+     */
+    devicePersistence?: DevicePersistenceOptions;
 };
 export type ClientAppIdentifier = {
     sdkName?: 'react' | 'react-native' | 'plain-javascript' | (string & {});

package/dist/src/devices/CameraManager.d.ts

@@ -3,21 +3,26 @@ import { Call } from '../Call';
 import { CameraDirection, CameraManagerState } from './CameraManagerState';
 import { DeviceManager } from './DeviceManager';
 import { VideoSettingsResponse } from '../gen/coordinator';
+import { DevicePersistenceOptions } from './devicePersistence';
 export declare class CameraManager extends DeviceManager<CameraManagerState> {
     private targetResolution;
     /**
      * Constructs a new CameraManager.
      *
      * @param call the call instance.
+     * @param devicePersistence the device persistence preferences to use.
      */
-    constructor(call: Call);
+    constructor(call: Call, devicePersistence: Required<DevicePersistenceOptions>);
     private isDirectionSupportedByDevice;
     /**
      * Select the camera direction.
      *
      * @param direction the direction of the camera to select.
+     * @param options additional direction selection options.
      */
-    selectDirection(direction: Exclude<CameraDirection, undefined>): Promise<void>;
+    selectDirection(direction: Exclude<CameraDirection, undefined>, options?: {
+        enableCamera?: boolean;
+    }): Promise<void>;
     /**
      * Flips the camera direction: if it's front it will change to back, if it's back, it will change to front.
      *

package/dist/src/devices/DeviceManager.d.ts

@@ -5,6 +5,7 @@ import { DeviceManagerState } from './DeviceManagerState';
 import { ScopedLogger } from '../logger';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { MediaStreamFilter, MediaStreamFilterRegistrationResult } from './filters';
+import { DevicePersistenceOptions } from './devicePersistence';
 export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C = MediaTrackConstraints> {
     /**
      * if true, stops the media stream when call is left
@@ -12,28 +13,16 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     stopOnLeave: boolean;
     logger: ScopedLogger;
     state: S;
-    /**
-     * When `true`, the `apply()` method will skip automatically enabling/disabling
-     * the device based on server defaults (`mic_default_on`, `camera_default_on`).
-     *
-     * This is useful when application code wants to handle device preferences
-     * (e.g., persisted user preferences) and prevent server defaults from
-     * overriding them.
-     *
-     * @default false
-     *
-     * @internal
-     */
-    deferServerDefaults: boolean;
     protected readonly call: Call;
     protected readonly trackType: TrackType;
-    protected subscriptions: Function[];
+    protected subscriptions: (() => void)[];
+    protected devicePersistence: Required<DevicePersistenceOptions>;
     protected areSubscriptionsSetUp: boolean;
     private isTrackStoppedDueToTrackEnd;
     private filters;
     private statusChangeConcurrencyTag;
     private filterRegistrationConcurrencyTag;
-    protected constructor(call: Call, state: S, trackType: TrackType);
+    protected constructor(call: Call, state: S, trackType: TrackType, devicePersistence: Required<DevicePersistenceOptions>);
     setup(): void;
     /**
      * Lists the available audio/video devices
@@ -115,4 +104,7 @@ export declare abstract class DeviceManager<S extends DeviceManagerState<C>, C =
     private get mediaDeviceKind();
     private handleDisconnectedOrReplacedDevices;
     protected findDevice(devices: MediaDeviceInfo[], deviceId: string): MediaDeviceInfo | undefined;
+    private persistPreference;
+    protected applyPersistedPreferences(enabledInCallType: boolean): Promise<boolean>;
+    private applyMutedState;
 }

package/dist/src/devices/MicrophoneManager.d.ts

@@ -6,6 +6,7 @@ import { MicrophoneManagerState } from './MicrophoneManagerState';
 import { TrackDisableMode } from './DeviceManagerState';
 import { AudioBitrateProfile } from '../gen/video/sfu/models/models';
 import { AudioSettingsResponse } from '../gen/coordinator';
+import { DevicePersistenceOptions } from './devicePersistence';
 export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneManagerState> {
     private speakingWhileMutedNotificationEnabled;
     private soundDetectorConcurrencyTag;
@@ -18,7 +19,7 @@ export declare class MicrophoneManager extends AudioDeviceManager<MicrophoneMana
     private noiseCancellationRegistration?;
     private unregisterNoiseCancellation?;
     private silenceThresholdMs;
-    constructor(call: Call, disableMode?: TrackDisableMode);
+    constructor(call: Call, devicePersistence: Required<DevicePersistenceOptions>, disableMode?: TrackDisableMode);
     setup(): void;
     /**
      * Enables noise cancellation for the microphone.

package/dist/src/devices/SpeakerManager.d.ts

@@ -1,14 +1,18 @@
 import { Call } from '../Call';
 import { SpeakerState } from './SpeakerState';
 import { CallSettingsResponse } from '../gen/coordinator';
+import { DevicePersistenceOptions } from './devicePersistence';
 export declare class SpeakerManager {
     readonly state: SpeakerState;
     private subscriptions;
     private areSubscriptionsSetUp;
     private readonly call;
     private defaultDevice?;
-    constructor(call: Call);
+    private readonly devicePersistence;
+    constructor(call: Call, devicePreferences: Required<DevicePersistenceOptions>);
     apply(settings: CallSettingsResponse): void;
+    private applyWeb;
+    private applyRN;
     setup(): void;
     /**
      * Lists the available audio output devices
@@ -47,4 +51,5 @@ export declare class SpeakerManager {
      * @param volume a number between 0 and 1. Set it to `undefined` to use the default volume.
      */
     setParticipantVolume(sessionId: string, volume: number | undefined): void;
+    private persistSpeakerDevicePreference;
 }

package/dist/src/devices/devicePersistence.d.ts

@@ -0,0 +1,27 @@
+export type DevicePersistenceOptions = {
+    /**
+     * Enables device preference persistence on web.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Storage key for persisted preferences.
+     * @default '@stream-io/device-preferences'
+     */
+    storageKey?: string;
+};
+export type DevicePreferenceKey = 'microphone' | 'camera' | 'speaker';
+export type LocalDevicePreference = {
+    selectedDeviceId: string;
+    selectedDeviceLabel: string;
+    muted?: boolean;
+};
+export type LocalDevicePreferences = {
+    [type in DevicePreferenceKey]?: LocalDevicePreference | LocalDevicePreference[];
+};
+export declare const defaultDeviceId = "default";
+export declare const normalize: (options: DevicePersistenceOptions | undefined) => Required<DevicePersistenceOptions>;
+export declare const createSyntheticDevice: (deviceId: string, kind: MediaDeviceKind) => MediaDeviceInfo;
+export declare const readPreferences: (storageKey: string) => LocalDevicePreferences;
+export declare const writePreferences: (currentDevice: MediaDeviceInfo | undefined, deviceKey: DevicePreferenceKey, muted: boolean | undefined, storageKey: string) => void;
+export declare const toPreferenceList: (preference?: LocalDevicePreference | LocalDevicePreference[]) => LocalDevicePreference[];

package/dist/src/helpers/clientUtils.d.ts

@@ -1,6 +1,6 @@
 import type { StreamClientOptions, TokenOrProvider, User } from '../coordinator/connection/types';
 import { StreamClient } from '../coordinator/connection/client';
-import type { StreamVideoClientOptions } from '../StreamVideoClient';
+import type { StreamVideoClientOptions } from '../types';
 /**
  * Utility function to get the instance key.
  */

package/dist/src/permissions/PermissionsContext.d.ts

@@ -33,7 +33,7 @@ export declare class PermissionsContext {
      * Helper method that checks whether the current user has the permission
      * to publish the given track type.
      */
-    canPublish: (trackType: TrackType) => boolean | undefined;
+    canPublish: (trackType: TrackType) => boolean;
     /**
      * Checks if the current user can request a specific permission
      * within the call.

package/dist/src/types.d.ts

@@ -1,10 +1,10 @@
 import type { Participant, TrackType, VideoDimension } from './gen/video/sfu/models/models';
-import type { CallRecordingStartedEventRecordingTypeEnum, JoinCallRequest, MemberResponse, OwnCapability, ReactionResponse, AudioSettingsRequestDefaultDeviceEnum, StartRecordingRequest, StartRecordingResponse } from './gen/coordinator';
+import type { AudioSettingsRequestDefaultDeviceEnum, CallRecordingStartedEventRecordingTypeEnum, JoinCallRequest, MemberResponse, OwnCapability, ReactionResponse, StartRecordingRequest, StartRecordingResponse } from './gen/coordinator';
 import type { StreamClient } from './coordinator/connection/client';
+import type { RejectReason, StreamClientOptions, TokenProvider, User } from './coordinator/connection/types';
 import type { Comparator } from './sorting';
 import type { StreamVideoWriteableStateStore } from './store';
 import { AxiosError } from 'axios';
-import { RejectReason } from './coordinator/connection/types';
 export type StreamReaction = Pick<ReactionResponse, 'type' | 'emoji_code' | 'custom'>;
 export declare enum VisibilityState {
     UNKNOWN = "UNKNOWN",
@@ -273,6 +273,42 @@ export type CallConstructor = {
      */
     clientStore: StreamVideoWriteableStateStore;
 };
+type StreamVideoClientBaseOptions = {
+    apiKey: string;
+    options?: StreamClientOptions;
+};
+type StreamVideoClientOptionsWithoutUser = StreamVideoClientBaseOptions & {
+    user?: undefined;
+    token?: never;
+    tokenProvider?: never;
+};
+type GuestUser = Extract<User, {
+    type: 'guest';
+}>;
+type AnonymousUser = Extract<User, {
+    type: 'anonymous';
+}>;
+type AuthenticatedUser = Exclude<User, GuestUser | AnonymousUser>;
+type StreamVideoClientOptionsWithGuestUser = StreamVideoClientBaseOptions & {
+    user: GuestUser;
+    token?: never;
+    tokenProvider?: never;
+};
+type StreamVideoClientOptionsWithAnonymousUser = StreamVideoClientBaseOptions & {
+    user: AnonymousUser;
+    token?: string;
+    tokenProvider?: TokenProvider;
+};
+type StreamVideoClientOptionsWithAuthenticatedUser = StreamVideoClientBaseOptions & {
+    user: AuthenticatedUser;
+} & ({
+    token: string;
+    tokenProvider?: TokenProvider;
+} | {
+    token?: string;
+    tokenProvider: TokenProvider;
+});
+export type StreamVideoClientOptions = StreamVideoClientOptionsWithoutUser | StreamVideoClientOptionsWithGuestUser | StreamVideoClientOptionsWithAnonymousUser | StreamVideoClientOptionsWithAuthenticatedUser;
 export type CallRecordingType = CallRecordingStartedEventRecordingTypeEnum;
 export type StartCallRecordingFnType = {
     (): Promise<StartRecordingResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "1.43.0",
+  "version": "1.44.0",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",
   "browser": "dist/index.browser.es.js",

package/src/Call.ts

@@ -162,6 +162,7 @@ import {
   ScreenShareManager,
   SpeakerManager,
 } from './devices';
+import { normalize } from './devices/devicePersistence';
 import { hasPending, withoutConcurrency } from './helpers/concurrency';
 import { ensureExhausted } from './helpers/ensureExhausted';
 import { pushToIfMissing } from './helpers/array';
@@ -341,9 +342,10 @@ export class Call {
       ringing ? CallingState.RINGING : CallingState.IDLE,
     );
 
-    this.camera = new CameraManager(this);
-    this.microphone = new MicrophoneManager(this);
-    this.speaker = new SpeakerManager(this);
+    const preferences = normalize(streamClient.options.devicePersistence);
+    this.camera = new CameraManager(this, preferences);
+    this.microphone = new MicrophoneManager(this, preferences);
+    this.speaker = new SpeakerManager(this, preferences);
     this.screenShare = new ScreenShareManager(this);
     this.dynascaleManager = new DynascaleManager(
       this.state,

package/src/StreamVideoClient.ts

@@ -27,10 +27,10 @@ import {
   ErrorFromResponse,
   StreamClientOptions,
   TokenOrProvider,
-  TokenProvider,
   User,
   UserWithId,
 } from './coordinator/connection/types';
+import type { StreamVideoClientOptions } from './types';
 import { retryInterval, sleep } from './coordinator/connection/utils';
 import {
   createCoordinatorClient,
@@ -42,14 +42,6 @@ import { logToConsole, ScopedLogger, videoLoggerSystem } from './logger';
 import { withoutConcurrency } from './helpers/concurrency';
 import { enableTimerWorker } from './timers';
 
-export type StreamVideoClientOptions = {
-  apiKey: string;
-  options?: StreamClientOptions;
-  user?: User;
-  token?: string;
-  tokenProvider?: TokenProvider;
-};
-
 /**
  * A `StreamVideoClient` instance lets you communicate with our API, and authenticate users.
  */

package/src/coordinator/connection/types.ts

@@ -2,6 +2,7 @@ import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { ConnectedEvent, UserRequest, VideoEvent } from '../../gen/coordinator';
 import { AllSfuEvents } from '../../rtc';
 import type { ConfigureLoggersOptions, LogLevel } from '@stream-io/logger';
+import type { DevicePersistenceOptions } from '../../devices/devicePersistence';
 
 export type UR = Record<string, unknown>;
 
@@ -258,6 +259,11 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    * When set to true, the incoming calls are rejected when the user is busy in an another call.
    */
   rejectCallWhenBusy?: boolean;
+
+  /**
+   * Device persistence preference options (web only).
+   */
+  devicePersistence?: DevicePersistenceOptions;
 };
 
 export type ClientAppIdentifier = {

package/src/devices/CameraManager.ts

@@ -7,6 +7,7 @@ import { VideoSettingsResponse } from '../gen/coordinator';
 import { TrackType } from '../gen/video/sfu/models/models';
 import { isMobile } from '../helpers/compatibility';
 import { isReactNative } from '../helpers/platforms';
+import { DevicePersistenceOptions } from './devicePersistence';
 
 export class CameraManager extends DeviceManager<CameraManagerState> {
   private targetResolution = {
@@ -18,9 +19,13 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
    * Constructs a new CameraManager.
    *
    * @param call the call instance.
+   * @param devicePersistence the device persistence preferences to use.
    */
-  constructor(call: Call) {
-    super(call, new CameraManagerState(), TrackType.VIDEO);
+  constructor(
+    call: Call,
+    devicePersistence: Required<DevicePersistenceOptions>,
+  ) {
+    super(call, new CameraManagerState(), TrackType.VIDEO, devicePersistence);
   }
 
   private isDirectionSupportedByDevice() {
@@ -31,8 +36,12 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
    * Select the camera direction.
    *
    * @param direction the direction of the camera to select.
+   * @param options additional direction selection options.
    */
-  async selectDirection(direction: Exclude<CameraDirection, undefined>) {
+  async selectDirection(
+    direction: Exclude<CameraDirection, undefined>,
+    options: { enableCamera?: boolean } = {},
+  ) {
     if (!this.isDirectionSupportedByDevice()) {
       this.logger.warn('Setting direction is not supported on this device');
       return;
@@ -47,9 +56,10 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
     // providing both device id and direction doesn't work, so we deselect the device
     this.state.setDirection(direction);
     this.state.setDevice(undefined);
-    if (isReactNative()) {
-      return;
-    }
+
+    const { enableCamera = true } = options;
+    if (isReactNative() || !enableCamera) return;
+
     this.getTracks().forEach((track) => track.stop());
     try {
       await this.unmuteStream();
@@ -120,16 +130,26 @@ export class CameraManager extends DeviceManager<CameraManagerState> {
     await this.statusChangeSettled();
     await this.selectTargetResolution(settings.target_resolution);
 
-    // apply a direction and enable the camera only if in "pristine" state
-    // and server defaults are not deferred to application code
+    const enabledInCallType = settings.enabled ?? true;
+    const shouldApplyDefaults =
+      this.state.status === undefined &&
+      this.state.optimisticStatus === undefined;
+    let persistedPreferencesApplied = false;
+    if (shouldApplyDefaults && this.devicePersistence.enabled) {
+      persistedPreferencesApplied =
+        await this.applyPersistedPreferences(enabledInCallType);
+    }
+
+    // apply a direction and enable the camera only if in "pristine" state,
+    // and there are no persisted preferences
     const canPublish = this.call.permissionsContext.canPublish(this.trackType);
-    if (this.state.status === undefined && !this.deferServerDefaults) {
+    if (shouldApplyDefaults && !persistedPreferencesApplied) {
       if (!this.state.direction && !this.state.selectedDevice) {
         const direction = settings.camera_facing === 'front' ? 'front' : 'back';
-        await this.selectDirection(direction);
+        await this.selectDirection(direction, { enableCamera: false });
       }
 
-      if (canPublish && settings.camera_default_on && settings.enabled) {
+      if (canPublish && settings.camera_default_on && enabledInCallType) {
         await this.enable();
       }
     }

package/src/devices/DeviceManager.ts

@@ -1,9 +1,12 @@
-import { combineLatest, Observable, pairwise } from 'rxjs';
+import { combineLatest, firstValueFrom, Observable, pairwise } from 'rxjs';
 import { Call } from '../Call';
 import { TrackPublishOptions } from '../rtc';
 import { CallingState } from '../store';
-import { createSubscription } from '../store/rxUtils';
-import { DeviceManagerState } from './DeviceManagerState';
+import { createSubscription, getCurrentValue } from '../store/rxUtils';
+import {
+  DeviceManagerState,
+  type InputDeviceStatus,
+} from './DeviceManagerState';
 import { isMobile } from '../helpers/compatibility';
 import { isReactNative } from '../helpers/platforms';
 import { ScopedLogger, videoLoggerSystem } from '../logger';
@@ -19,6 +22,15 @@ import {
   MediaStreamFilterEntry,
   MediaStreamFilterRegistrationResult,
 } from './filters';
+import {
+  createSyntheticDevice,
+  defaultDeviceId,
+  DevicePersistenceOptions,
+  DevicePreferenceKey,
+  readPreferences,
+  toPreferenceList,
+  writePreferences,
+} from './devicePersistence';
 
 export abstract class DeviceManager<
   S extends DeviceManagerState<C>,
@@ -32,23 +44,10 @@ export abstract class DeviceManager<
 
   state: S;
 
-  /**
-   * When `true`, the `apply()` method will skip automatically enabling/disabling
-   * the device based on server defaults (`mic_default_on`, `camera_default_on`).
-   *
-   * This is useful when application code wants to handle device preferences
-   * (e.g., persisted user preferences) and prevent server defaults from
-   * overriding them.
-   *
-   * @default false
-   *
-   * @internal
-   */
-  deferServerDefaults = false;
-
   protected readonly call: Call;
   protected readonly trackType: TrackType;
-  protected subscriptions: Function[] = [];
+  protected subscriptions: (() => void)[] = [];
+  protected devicePersistence: Required<DevicePersistenceOptions>;
   protected areSubscriptionsSetUp = false;
   private isTrackStoppedDueToTrackEnd = false;
   private filters: MediaStreamFilterEntry[] = [];
@@ -57,10 +56,16 @@ export abstract class DeviceManager<
     'filterRegistrationConcurrencyTag',
   );
 
-  protected constructor(call: Call, state: S, trackType: TrackType) {
+  protected constructor(
+    call: Call,
+    state: S,
+    trackType: TrackType,
+    devicePersistence: Required<DevicePersistenceOptions>,
+  ) {
     this.call = call;
     this.state = state;
     this.trackType = trackType;
+    this.devicePersistence = devicePersistence;
     this.logger = videoLoggerSystem.getLogger(
       `${TrackType[trackType].toLowerCase()} manager`,
     );
@@ -68,10 +73,7 @@ export abstract class DeviceManager<
   }
 
   setup() {
-    if (this.areSubscriptionsSetUp) {
-      return;
-    }
-
+    if (this.areSubscriptionsSetUp) return;
     this.areSubscriptionsSetUp = true;
 
     if (
@@ -81,6 +83,18 @@ export abstract class DeviceManager<
     ) {
       this.handleDisconnectedOrReplacedDevices();
     }
+
+    if (this.devicePersistence.enabled) {
+      this.subscriptions.push(
+        createSubscription(
+          combineLatest([this.state.selectedDevice$, this.state.status$]),
+          ([selectedDevice, status]) => {
+            if (!status) return;
+            this.persistPreference(selectedDevice, status);
+          },
+        ),
+      );
+    }
   }
 
   /**
@@ -495,14 +509,10 @@ export abstract class DeviceManager<
     }
   }
 
-  private get mediaDeviceKind() {
-    if (this.trackType === TrackType.AUDIO) {
-      return 'audioinput';
-    }
-    if (this.trackType === TrackType.VIDEO) {
-      return 'videoinput';
-    }
-    return '';
+  private get mediaDeviceKind(): MediaDeviceKind {
+    if (this.trackType === TrackType.AUDIO) return 'audioinput';
+    if (this.trackType === TrackType.VIDEO) return 'videoinput';
+    throw new Error('Invalid track type');
   }
 
   private handleDisconnectedOrReplacedDevices() {
@@ -562,4 +572,76 @@ export abstract class DeviceManager<
     const kind = this.mediaDeviceKind;
     return devices.find((d) => d.deviceId === deviceId && d.kind === kind);
   }
+
+  private persistPreference(
+    selectedDevice: string | undefined,
+    status: InputDeviceStatus,
+  ) {
+    const deviceKind = this.mediaDeviceKind;
+    const deviceKey = deviceKind === 'audioinput' ? 'microphone' : 'camera';
+    const muted =
+      status === 'disabled' ? true : status === 'enabled' ? false : undefined;
+
+    const { storageKey } = this.devicePersistence;
+    if (!selectedDevice) {
+      writePreferences(undefined, deviceKey, muted, storageKey);
+      return;
+    }
+
+    const devices = getCurrentValue(this.listDevices()) || [];
+    const currentDevice =
+      this.findDevice(devices, selectedDevice) ??
+      createSyntheticDevice(selectedDevice, deviceKind);
+
+    writePreferences(currentDevice, deviceKey, muted, storageKey);
+  }
+
+  protected async applyPersistedPreferences(enabledInCallType: boolean) {
+    const deviceKey: DevicePreferenceKey =
+      this.trackType === TrackType.AUDIO ? 'microphone' : 'camera';
+    const preferences = readPreferences(this.devicePersistence.storageKey);
+    const preferenceList = toPreferenceList(preferences[deviceKey]);
+
+    if (preferenceList.length === 0) return false;
+
+    let muted: boolean | undefined;
+    let appliedDevice = false;
+    let appliedMute = false;
+
+    const devices = await firstValueFrom(this.listDevices());
+    for (const preference of preferenceList) {
+      muted ??= preference.muted;
+      if (preference.selectedDeviceId === defaultDeviceId) break;
+
+      const device =
+        devices.find((d) => d.deviceId === preference.selectedDeviceId) ??
+        devices.find((d) => d.label === preference.selectedDeviceLabel);
+
+      if (device) {
+        appliedDevice = true;
+        if (!this.state.selectedDevice) {
+          await this.select(device.deviceId);
+        }
+        muted = preference.muted;
+        break;
+      }
+    }
+
+    const canPublish = this.call.permissionsContext.canPublish(this.trackType);
+    if (typeof muted === 'boolean' && enabledInCallType && canPublish) {
+      await this.applyMutedState(muted);
+      appliedMute = true;
+    }
+
+    return appliedDevice || appliedMute;
+  }
+
+  private async applyMutedState(muted: boolean) {
+    if (this.state.status !== undefined) return;
+    if (muted) {
+      await this.disable();
+    } else {
+      await this.enable();
+    }
+  }
 }