@stream-io/video-client 1.43.0-beta.0 → 1.44.0

package/src/Call.ts

@@ -39,6 +39,8 @@ import type {
   Credentials,
   DeleteCallRequest,
   DeleteCallResponse,
+  DeleteRecordingResponse,
+  DeleteTranscriptionResponse,
   EndCallResponse,
   GetCallReportResponse,
   GetCallResponse,
@@ -59,6 +61,8 @@ import type {
   PinResponse,
   QueryCallMembersRequest,
   QueryCallMembersResponse,
+  QueryCallParticipantsRequest,
+  QueryCallParticipantsResponse,
   QueryCallSessionParticipantStatsResponse,
   QueryCallSessionParticipantStatsTimelineResponse,
   QueryCallStatsMapResponse,
@@ -158,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';
@@ -337,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,
@@ -414,7 +420,6 @@ export class Call {
         const currentUserId = this.currentUserId;
         if (currentUserId && blockedUserIds.includes(currentUserId)) {
           this.logger.info('Leaving call because of being blocked');
-          globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'restricted');
           await this.leave({ message: 'user blocked' }).catch((err) => {
             this.logger.error('Error leaving call after being blocked', err);
           });
@@ -459,10 +464,6 @@ export class Call {
           (isAcceptedElsewhere || isRejectedByMe) &&
           !hasPending(this.joinLeaveConcurrencyTag)
         ) {
-          globalThis.streamRNVideoSDK?.callingX?.endCall(
-            this,
-            isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected',
-          );
           this.leave().catch(() => {
             this.logger.error(
               'Could not leave a call that was accepted or rejected elsewhere',
@@ -634,30 +635,16 @@ export class Call {
 
       if (callingState === CallingState.RINGING && reject !== false) {
         if (reject) {
-          const reasonToEndCallReason = {
-            timeout: 'missed',
-            cancel: 'canceled',
-            busy: 'busy',
-            decline: 'rejected',
-          } as const;
-          const rejectReason = reason ?? 'decline';
-          const endCallReason =
-            reasonToEndCallReason[
-              rejectReason as keyof typeof reasonToEndCallReason
-            ] ?? 'rejected';
-          globalThis.streamRNVideoSDK?.callingX?.endCall(this, endCallReason);
-          await this.reject(rejectReason);
+          await this.reject(reason ?? 'decline');
         } else {
           // if reject was undefined, we still have to cancel the call automatically
           // when I am the creator and everyone else left the call
           const hasOtherParticipants = this.state.remoteParticipants.length > 0;
           if (this.isCreatedByMe && !hasOtherParticipants) {
-            globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'canceled');
             await this.reject('cancel');
           }
         }
       }
-      globalThis.streamRNVideoSDK?.callingX?.endCall(this);
 
       this.statsReporter?.stop();
       this.statsReporter = undefined;
@@ -692,9 +679,7 @@ export class Call {
       this.cancelAutoDrop();
       this.clientStore.unregisterCall(this);
 
-      globalThis.streamRNVideoSDK?.callManager.stop({
-        isRingingTypeCall: this.ringing,
-      });
+      globalThis.streamRNVideoSDK?.callManager.stop();
 
       this.camera.dispose();
       this.microphone.dispose();
@@ -779,7 +764,6 @@ export class Call {
     video?: boolean;
   }): Promise<GetCallResponse> => {
     await this.setup();
-
     const response = await this.streamClient.get<GetCallResponse>(
       this.streamClientBasePath,
       params,
@@ -810,7 +794,6 @@ export class Call {
    */
   getOrCreate = async (data?: GetOrCreateCallRequest) => {
     await this.setup();
-
     const response = await this.streamClient.post<
       GetOrCreateCallResponse,
       GetOrCreateCallRequest
@@ -926,73 +909,60 @@ export class Call {
     joinResponseTimeout?: number;
     rpcRequestTimeout?: number;
   } = {}): Promise<void> => {
+    await this.setup();
     const callingState = this.state.callingState;
 
     if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
       throw new Error(`Illegal State: call.join() shall be called only once`);
     }
 
-    if (data?.ring) {
-      this.ringingSubject.next(true);
-    }
-    const callingX = globalThis.streamRNVideoSDK?.callingX;
-    if (callingX) {
-      // for Android/iOS, we need to start the call in the callingx library as soon as possible
-      await callingX.startCall(this);
-    }
-
-    await this.setup();
-
     this.joinResponseTimeout = joinResponseTimeout;
     this.rpcRequestTimeout = rpcRequestTimeout;
+
     // we will count the number of join failures per SFU.
     // once the number of failures reaches 2, we will piggyback on the `migrating_from`
     // field to force the coordinator to provide us another SFU
     const sfuJoinFailures = new Map<string, number>();
     const joinData: JoinCallData = data;
     maxJoinRetries = Math.max(maxJoinRetries, 1);
-    try {
-      for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
-        try {
-          this.logger.trace(`Joining call (${attempt})`, this.cid);
-          await this.doJoin(data);
-          delete joinData.migrating_from;
-          delete joinData.migrating_from_list;
-          break;
-        } catch (err) {
-          this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-          if (
-            (err instanceof ErrorFromResponse && err.unrecoverable) ||
-            (err instanceof SfuJoinError && err.unrecoverable)
-          ) {
-            // if the error is unrecoverable, we should not retry as that signals
-            // that connectivity is good, but the coordinator doesn't allow the user
-            // to join the call due to some reason (e.g., ended call, expired token...)
-            throw err;
-          }
+    for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+      try {
+        this.logger.trace(`Joining call (${attempt})`, this.cid);
+        await this.doJoin(data);
+        delete joinData.migrating_from;
+        delete joinData.migrating_from_list;
+        break;
+      } catch (err) {
+        this.logger.warn(`Failed to join call (${attempt})`, this.cid);
+        if (
+          (err instanceof ErrorFromResponse && err.unrecoverable) ||
+          (err instanceof SfuJoinError && err.unrecoverable)
+        ) {
+          // if the error is unrecoverable, we should not retry as that signals
+          // that connectivity is good, but the coordinator doesn't allow the user
+          // to join the call due to some reason (e.g., ended call, expired token...)
+          throw err;
+        }
 
-          // immediately switch to a different SFU in case of recoverable join error
-          const switchSfu =
-            err instanceof SfuJoinError &&
-            SfuJoinError.isJoinErrorCode(err.errorEvent);
-
-          const sfuId = this.credentials?.server.edge_name || '';
-          const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
-          sfuJoinFailures.set(sfuId, failures);
-          if (switchSfu || failures >= 2) {
-            joinData.migrating_from = sfuId;
-            joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
-          }
+        // immediately switch to a different SFU in case of recoverable join error
+        const switchSfu =
+          err instanceof SfuJoinError &&
+          SfuJoinError.isJoinErrorCode(err.errorEvent);
+
+        const sfuId = this.credentials?.server.edge_name || '';
+        const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
+        sfuJoinFailures.set(sfuId, failures);
+        if (switchSfu || failures >= 2) {
+          joinData.migrating_from = sfuId;
+          joinData.migrating_from_list = Array.from(sfuJoinFailures.keys());
+        }
 
-          if (attempt === maxJoinRetries - 1) {
-            throw err;
-          }
+        if (attempt === maxJoinRetries - 1) {
+          throw err;
         }
-        await sleep(retryInterval(attempt));
       }
-    } catch (error) {
-      callingX?.endCall(this, 'error');
-      throw error;
+
+      await sleep(retryInterval(attempt));
     }
   };
 
@@ -1175,9 +1145,7 @@ export class Call {
     // re-apply them on later reconnections or server-side data fetches
     if (!this.deviceSettingsAppliedOnce && this.state.settings) {
       await this.applyDeviceConfig(this.state.settings, true);
-      globalThis.streamRNVideoSDK?.callManager.start({
-        isRingingTypeCall: this.ringing,
-      });
+      globalThis.streamRNVideoSDK?.callManager.start();
       this.deviceSettingsAppliedOnce = true;
     }
 
@@ -1722,7 +1690,6 @@ export class Call {
       if (SfuJoinError.isJoinErrorCode(e)) return;
       if (strategy === WebsocketReconnectStrategy.UNSPECIFIED) return;
       if (strategy === WebsocketReconnectStrategy.DISCONNECT) {
-        globalThis.streamRNVideoSDK?.callingX?.endCall(this, 'error');
         this.leave({ message: 'SFU instructed to disconnect' }).catch((err) => {
           this.logger.warn(`Can't leave call after disconnect request`, err);
         });
@@ -1958,6 +1925,7 @@ export class Call {
         'Updating publish options after joining the call does not have an effect',
       );
     }
+    this.tracer.trace('updatePublishOptions', options);
     this.clientPublishOptions = { ...this.clientPublishOptions, ...options };
   };
 
@@ -2533,6 +2501,22 @@ export class Call {
     });
   };
 
+  /**
+   * Query call participants with optional filters.
+   *
+   * @param data the request data.
+   * @param params optional query parameters.
+   */
+  queryParticipants = async (
+    data: QueryCallParticipantsRequest = {},
+    params: { limit?: number } = {},
+  ): Promise<QueryCallParticipantsResponse> => {
+    return this.streamClient.post<
+      QueryCallParticipantsResponse,
+      QueryCallParticipantsRequest
+    >(`${this.streamClientBasePath}/participants`, data, params);
+  };
+
   /**
    * Will update the call members.
    *
@@ -2594,9 +2578,24 @@ export class Call {
    * Otherwise, all recordings for the current call will be returned.
    *
    * @param callSessionId the call session id to retrieve recordings for.
+   * @deprecated use {@link listRecordings} instead.
    */
   queryRecordings = async (
     callSessionId?: string,
+  ): Promise<ListRecordingsResponse> => {
+    return this.listRecordings(callSessionId);
+  };
+
+  /**
+   * Retrieves the list of recordings for the current call or call session.
+   *
+   * If `callSessionId` is provided, it will return the recordings for that call session.
+   * Otherwise, all recordings for the current call will be returned.
+   *
+   * @param callSessionId the call session id to retrieve recordings for.
+   */
+  listRecordings = async (
+    callSessionId?: string,
   ): Promise<ListRecordingsResponse> => {
     let endpoint = this.streamClientBasePath;
     if (callSessionId) {
@@ -2607,12 +2606,52 @@ export class Call {
     );
   };
 
+  /**
+   * Deletes a recording for the given call session.
+   *
+   * @param callSessionId the call session id that the recording belongs to.
+   * @param filename the recording filename.
+   */
+  deleteRecording = async (
+    callSessionId: string,
+    filename: string,
+  ): Promise<DeleteRecordingResponse> => {
+    return this.streamClient.delete<DeleteRecordingResponse>(
+      `${this.streamClientBasePath}/${encodeURIComponent(callSessionId)}/recordings/${encodeURIComponent(filename)}`,
+    );
+  };
+
+  /**
+   * Deletes a transcription for the given call session.
+   *
+   * @param callSessionId the call session id that the transcription belongs to.
+   * @param filename the transcription filename.
+   */
+  deleteTranscription = async (
+    callSessionId: string,
+    filename: string,
+  ): Promise<DeleteTranscriptionResponse> => {
+    return this.streamClient.delete<DeleteTranscriptionResponse>(
+      `${this.streamClientBasePath}/${encodeURIComponent(callSessionId)}/transcriptions/${encodeURIComponent(filename)}`,
+    );
+  };
+
   /**
    * Retrieves the list of transcriptions for the current call.
    *
    * @returns the list of transcriptions.
+   * @deprecated use {@link listTranscriptions} instead.
    */
   queryTranscriptions = async (): Promise<ListTranscriptionsResponse> => {
+    return this.listTranscriptions();
+  };
+
+  /**
+   * Retrieves the list of transcriptions for the current call.
+   *
+   * @returns the list of transcriptions.
+   */
+  listTranscriptions = async (): Promise<ListTranscriptionsResponse> => {
     return this.streamClient.get<ListTranscriptionsResponse>(
       `${this.streamClientBasePath}/transcriptions`,
     );

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();
+    }
+  }
 }