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

package/dist/src/Call.d.ts

@@ -761,7 +761,7 @@ export declare class Call {
      *
      * @internal
      */
-    applyDeviceConfig: (settings: CallSettingsResponse, publish: boolean) => Promise<void>;
+    applyDeviceConfig: (settings: CallSettingsResponse, publish: boolean, skipSpeakerApply?: boolean) => Promise<void>;
     /**
      * Will begin tracking the given element for visibility changes within the
      * configured viewport element (`call.setViewport`).

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.1-beta.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';
@@ -171,6 +172,7 @@ import {
   promiseWithResolvers,
 } from './helpers/promise';
 import { GetCallStatsResponse } from './gen/shims';
+import { isReactNative } from './helpers/platforms';
 
 /**
  * An object representation of a `Call`.
@@ -341,9 +343,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,
@@ -744,7 +747,8 @@ export class Call {
     // const calls = useCalls().filter((c) => c.ringing);
     const calls = this.clientStore.calls.filter((c) => c.cid !== this.cid);
     this.clientStore.setCalls([this, ...calls]);
-    await this.applyDeviceConfig(settings, false);
+    const skipSpeakerApply = isReactNative() && true;
+    await this.applyDeviceConfig(settings, false, skipSpeakerApply);
   };
 
   /**
@@ -779,8 +783,14 @@ export class Call {
       this.watching = true;
       this.clientStore.registerOrUpdateCall(this);
     }
-
-    await this.applyDeviceConfig(response.call.settings, false);
+    const skipSpeakerApply = isReactNative()
+      ? (params?.ring ?? this.ringing)
+      : false;
+    await this.applyDeviceConfig(
+      response.call.settings,
+      false,
+      skipSpeakerApply,
+    );
 
     return response;
   };
@@ -810,7 +820,14 @@ export class Call {
       this.clientStore.registerOrUpdateCall(this);
     }
 
-    await this.applyDeviceConfig(response.call.settings, false);
+    const skipSpeakerApply = isReactNative()
+      ? (data?.ring ?? this.ringing)
+      : false;
+    await this.applyDeviceConfig(
+      response.call.settings,
+      false,
+      skipSpeakerApply,
+    );
 
     return response;
   };
@@ -2794,8 +2811,11 @@ export class Call {
   applyDeviceConfig = async (
     settings: CallSettingsResponse,
     publish: boolean,
+    skipSpeakerApply: boolean = false,
   ) => {
-    this.speaker.apply(settings);
+    if (!skipSpeakerApply) {
+      this.speaker.apply(settings);
+    }
     await this.camera.apply(settings.video, publish).catch((err) => {
       this.logger.warn('Camera init failed', err);
     });

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