@stream-io/video-client 1.43.0 → 1.44.0

package/dist/index.es.js

@@ -7,7 +7,7 @@ import { TwirpFetchTransport, TwirpErrorCode } from '@protobuf-ts/twirp-transpor
 import * as scopedLogger from '@stream-io/logger';
 export { LogLevelEnum } from '@stream-io/logger';
 import { parse, write } from 'sdp-transform';
-import { ReplaySubject, combineLatest, BehaviorSubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, of } from 'rxjs';
+import { ReplaySubject, combineLatest, BehaviorSubject, shareReplay, map, distinctUntilChanged, startWith, takeWhile, distinctUntilKeyChanged, fromEventPattern, concatMap, merge, from, fromEvent, tap, debounceTime, pairwise, firstValueFrom, of } from 'rxjs';
 import { UAParser } from 'ua-parser-js';
 import { WorkerTimer } from '@stream-io/worker-timer';
 import https from 'https';
@@ -5065,7 +5065,7 @@ const paginatedLayoutSortPreset = combineComparators(pinned, ifInvisibleOrUnknow
 /**
  * The sorting preset for livestreams and audio rooms.
  */
-const livestreamOrAudioRoomSortPreset = combineComparators(ifInvisibleBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
+const livestreamOrAudioRoomSortPreset = combineComparators(ifInvisibleOrUnknownBy(combineComparators(dominantSpeaker, speaking, reactionType('raised-hand'), withVideoIngressSource, publishingVideo, publishingAudio)), role('admin', 'host', 'speaker'));
 
 const ensureExhausted = (x, message) => {
     videoLoggerSystem.getLogger('helpers').warn(message, x);
@@ -5315,7 +5315,7 @@ class CallState {
         this.updateParticipant = (sessionId, patch) => {
             const participant = this.findParticipantBySessionId(sessionId);
             if (!participant) {
-                this.logger.warn(`Participant with sessionId ${sessionId} not found`);
+                this.logger.debug(`Participant with sessionId ${sessionId} not found`);
                 return;
             }
             const thePatch = typeof patch === 'function' ? patch(participant) : patch;
@@ -6232,7 +6232,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.43.0";
+const version = "1.44.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -10000,6 +10000,7 @@ class PermissionsContext {
                     return false;
                 default:
                     ensureExhausted(trackType, 'Unknown track type');
+                    return false;
             }
         };
         /**
@@ -10336,7 +10337,7 @@ const getDeviceChangeObserver = lazy((tracer) => {
  * the observable errors.
  */
 const getAudioDevices = lazy((tracer) => {
-    return merge(getDeviceChangeObserver(tracer), getAudioBrowserPermission().asObservable()).pipe(startWith(undefined), concatMap(() => getDevices(getAudioBrowserPermission(), 'audioinput', tracer)), shareReplay(1));
+    return merge(getDeviceChangeObserver(tracer), getAudioBrowserPermission().asObservable()).pipe(startWith([]), concatMap(() => getDevices(getAudioBrowserPermission(), 'audioinput', tracer)), shareReplay(1));
 });
 /**
  * Prompts the user for a permission to use video devices (if not already granted
@@ -10345,7 +10346,7 @@ const getAudioDevices = lazy((tracer) => {
  * the observable errors.
  */
 const getVideoDevices = lazy((tracer) => {
-    return merge(getDeviceChangeObserver(tracer), getVideoBrowserPermission().asObservable()).pipe(startWith(undefined), concatMap(() => getDevices(getVideoBrowserPermission(), 'videoinput', tracer)), shareReplay(1));
+    return merge(getDeviceChangeObserver(tracer), getVideoBrowserPermission().asObservable()).pipe(startWith([]), concatMap(() => getDevices(getVideoBrowserPermission(), 'videoinput', tracer)), shareReplay(1));
 });
 /**
  * Prompts the user for a permission to use video devices (if not already granted
@@ -10354,7 +10355,7 @@ const getVideoDevices = lazy((tracer) => {
  * the observable errors.
  */
 const getAudioOutputDevices = lazy((tracer) => {
-    return merge(getDeviceChangeObserver(tracer), getAudioBrowserPermission().asObservable()).pipe(startWith(undefined), concatMap(() => getDevices(getAudioBrowserPermission(), 'audiooutput', tracer)), shareReplay(1));
+    return merge(getDeviceChangeObserver(tracer), getAudioBrowserPermission().asObservable()).pipe(startWith([]), concatMap(() => getDevices(getAudioBrowserPermission(), 'audiooutput', tracer)), shareReplay(1));
 });
 let getUserMediaExecId = 0;
 const getStream = async (constraints, tracer) => {
@@ -10561,25 +10562,66 @@ function resolveDeviceId(deviceId, kind) {
  */
 const isMobile = () => /Mobi/i.test(navigator.userAgent);
 
+const defaultDeviceId = 'default';
+const isLocalStorageAvailable = () => typeof window !== 'undefined' && typeof window.localStorage !== 'undefined';
+const normalize = (options) => {
+    return {
+        storageKey: options?.storageKey ?? `@stream-io/device-preferences`,
+        enabled: isLocalStorageAvailable() && !isReactNative()
+            ? (options?.enabled ?? true)
+            : false,
+    };
+};
+const createSyntheticDevice = (deviceId, kind) => {
+    return { deviceId, kind, label: '', groupId: '' };
+};
+const readPreferences = (storageKey) => {
+    try {
+        const raw = window.localStorage.getItem(storageKey) || '{}';
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+};
+const writePreferences = (currentDevice, deviceKey, muted, storageKey) => {
+    if (!isLocalStorageAvailable())
+        return;
+    const selectedDeviceId = currentDevice?.deviceId ?? defaultDeviceId;
+    const selectedDeviceLabel = currentDevice?.label ?? '';
+    const preferences = readPreferences(storageKey);
+    const preferenceHistory = [preferences[deviceKey] ?? []]
+        .flat()
+        .filter((p) => p.selectedDeviceId !== selectedDeviceId &&
+        (p.selectedDeviceLabel === '' ||
+            p.selectedDeviceLabel !== selectedDeviceLabel));
+    const nextPreferences = {
+        ...preferences,
+        [deviceKey]: [
+            {
+                selectedDeviceId,
+                selectedDeviceLabel,
+                ...(typeof muted === 'boolean' ? { muted } : {}),
+            },
+            ...preferenceHistory,
+        ].slice(0, 3),
+    };
+    try {
+        window.localStorage.setItem(storageKey, JSON.stringify(nextPreferences));
+    }
+    catch (err) {
+        const logger = videoLoggerSystem.getLogger('DevicePersistence');
+        logger.error('failed to save device preferences', err);
+    }
+};
+const toPreferenceList = (preference) => (preference ? [preference].flat() : []);
+
 class DeviceManager {
-    constructor(call, state, trackType) {
+    constructor(call, state, trackType, devicePersistence) {
         /**
          * if true, stops the media stream when call is left
          */
         this.stopOnLeave = true;
-        /**
-         * 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
-         */
-        this.deferServerDefaults = false;
         this.subscriptions = [];
         this.areSubscriptionsSetUp = false;
         this.isTrackStoppedDueToTrackEnd = false;
@@ -10599,19 +10641,26 @@ class DeviceManager {
         this.call = call;
         this.state = state;
         this.trackType = trackType;
+        this.devicePersistence = devicePersistence;
         this.logger = videoLoggerSystem.getLogger(`${TrackType[trackType].toLowerCase()} manager`);
         this.setup();
     }
     setup() {
-        if (this.areSubscriptionsSetUp) {
+        if (this.areSubscriptionsSetUp)
             return;
-        }
         this.areSubscriptionsSetUp = true;
         if (deviceIds$ &&
             !isReactNative() &&
             (this.trackType === TrackType.AUDIO || this.trackType === TrackType.VIDEO)) {
             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);
+            }));
+        }
     }
     /**
      * Lists the available audio/video devices
@@ -10962,13 +11011,11 @@ class DeviceManager {
         }
     }
     get mediaDeviceKind() {
-        if (this.trackType === TrackType.AUDIO) {
+        if (this.trackType === TrackType.AUDIO)
             return 'audioinput';
-        }
-        if (this.trackType === TrackType.VIDEO) {
+        if (this.trackType === TrackType.VIDEO)
             return 'videoinput';
-        }
-        return '';
+        throw new Error('Invalid track type');
     }
     handleDisconnectedOrReplacedDevices() {
         this.subscriptions.push(createSubscription(combineLatest([
@@ -11016,6 +11063,62 @@ class DeviceManager {
         const kind = this.mediaDeviceKind;
         return devices.find((d) => d.deviceId === deviceId && d.kind === kind);
     }
+    persistPreference(selectedDevice, status) {
+        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);
+    }
+    async applyPersistedPreferences(enabledInCallType) {
+        const deviceKey = 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;
+        let appliedDevice = false;
+        let appliedMute = false;
+        const devices = await firstValueFrom(this.listDevices());
+        for (const preference of preferenceList) {
+            muted ?? (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;
+    }
+    async applyMutedState(muted) {
+        if (this.state.status !== undefined)
+            return;
+        if (muted) {
+            await this.disable();
+        }
+        else {
+            await this.enable();
+        }
+    }
 }
 
 class DeviceManagerState {
@@ -11197,9 +11300,10 @@ class CameraManager extends DeviceManager {
      * Constructs a new CameraManager.
      *
      * @param call the call instance.
+     * @param devicePersistence the device persistence preferences to use.
      */
-    constructor(call) {
-        super(call, new CameraManagerState(), TrackType.VIDEO);
+    constructor(call, devicePersistence) {
+        super(call, new CameraManagerState(), TrackType.VIDEO, devicePersistence);
         this.targetResolution = {
             width: 1280,
             height: 720,
@@ -11212,8 +11316,9 @@ class CameraManager extends DeviceManager {
      * Select the camera direction.
      *
      * @param direction the direction of the camera to select.
+     * @param options additional direction selection options.
      */
-    async selectDirection(direction) {
+    async selectDirection(direction, options = {}) {
         if (!this.isDirectionSupportedByDevice()) {
             this.logger.warn('Setting direction is not supported on this device');
             return;
@@ -11227,9 +11332,9 @@ class CameraManager extends DeviceManager {
         // providing both device id and direction doesn't work, so we deselect the device
         this.state.setDirection(direction);
         this.state.setDevice(undefined);
-        if (isReactNative()) {
+        const { enableCamera = true } = options;
+        if (isReactNative() || !enableCamera)
             return;
-        }
         this.getTracks().forEach((track) => track.stop());
         try {
             await this.unmuteStream();
@@ -11297,15 +11402,23 @@ class CameraManager extends DeviceManager {
         // Wait for any in progress camera operation
         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();
             }
         }
@@ -11741,8 +11854,8 @@ class RNSpeechDetector {
 }
 
 class MicrophoneManager extends AudioDeviceManager {
-    constructor(call, disableMode = 'stop-tracks') {
-        super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
+    constructor(call, devicePersistence, disableMode = 'stop-tracks') {
+        super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO, devicePersistence);
         this.speakingWhileMutedNotificationEnabled = true;
         this.soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
         this.silenceThresholdMs = 5000;
@@ -11831,7 +11944,7 @@ class MicrophoneManager extends AudioDeviceManager {
                 if (this.silenceThresholdMs <= 0)
                     return;
                 const deviceId = this.state.selectedDevice;
-                const devices = getCurrentValue(this.listDevices());
+                const devices = await firstValueFrom(this.listDevices());
                 const label = devices.find((d) => d.deviceId === deviceId)?.label;
                 this.noAudioDetectorCleanup = createNoAudioDetector(mediaStream, {
                     noAudioThresholdMs: this.silenceThresholdMs,
@@ -11844,6 +11957,7 @@ class MicrophoneManager extends AudioDeviceManager {
                             deviceId,
                             label,
                         };
+                        console.log(event);
                         this.call.tracer.trace('mic.capture_report', event);
                         this.call.streamClient.dispatchEvent(event);
                     },
@@ -11995,10 +12109,16 @@ class MicrophoneManager extends AudioDeviceManager {
     async apply(settings, publish) {
         // Wait for any in progress mic operation
         await this.statusChangeSettled();
-        const canPublish = this.call.permissionsContext.canPublish(this.trackType);
         // apply server-side settings only when the device state is pristine
-        // and server defaults are not deferred to application code
-        if (this.state.status === undefined && !this.deferServerDefaults) {
+        // and there are no persisted preferences
+        const shouldApplyDefaults = this.state.status === undefined &&
+            this.state.optimisticStatus === undefined;
+        let persistedPreferencesApplied = false;
+        if (shouldApplyDefaults && this.devicePersistence.enabled) {
+            persistedPreferencesApplied = await this.applyPersistedPreferences(true);
+        }
+        const canPublish = this.call.permissionsContext.canPublish(this.trackType);
+        if (shouldApplyDefaults && !persistedPreferencesApplied) {
             if (canPublish && settings.mic_default_on) {
                 await this.enable();
             }
@@ -12149,7 +12269,7 @@ class ScreenShareState extends AudioDeviceManagerState {
 
 class ScreenShareManager extends AudioDeviceManager {
     constructor(call) {
-        super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
+        super(call, new ScreenShareState(), TrackType.SCREEN_SHARE, normalize({ enabled: false }));
     }
     setup() {
         if (this.areSubscriptionsSetUp)
@@ -12298,7 +12418,7 @@ class SpeakerState {
 }
 
 class SpeakerManager {
-    constructor(call) {
+    constructor(call, devicePreferences) {
         this.subscriptions = [];
         this.areSubscriptionsSetUp = false;
         /**
@@ -12307,18 +12427,35 @@ class SpeakerManager {
          * @internal
          */
         this.dispose = () => {
-            this.subscriptions.forEach((s) => s.unsubscribe());
+            this.subscriptions.forEach((unsubscribe) => unsubscribe());
             this.subscriptions = [];
             this.areSubscriptionsSetUp = false;
         };
         this.call = call;
         this.state = new SpeakerState(call.tracer);
+        this.devicePersistence = devicePreferences;
         this.setup();
     }
     apply(settings) {
-        if (!isReactNative()) {
+        return isReactNative() ? this.applyRN(settings) : this.applyWeb();
+    }
+    applyWeb() {
+        const { enabled, storageKey } = this.devicePersistence;
+        if (!enabled)
             return;
+        const preferences = readPreferences(storageKey);
+        const preferenceList = toPreferenceList(preferences.speaker);
+        if (preferenceList.length === 0)
+            return;
+        const preference = preferenceList[0];
+        const nextDeviceId = preference.selectedDeviceId === defaultDeviceId
+            ? ''
+            : preference.selectedDeviceId;
+        if (this.state.selectedDevice !== nextDeviceId) {
+            this.select(nextDeviceId);
         }
+    }
+    applyRN(settings) {
         /// Determines if the speaker should be enabled based on a priority hierarchy of
         /// settings.
         ///
@@ -12347,19 +12484,21 @@ class SpeakerManager {
         }
     }
     setup() {
-        if (this.areSubscriptionsSetUp) {
+        if (this.areSubscriptionsSetUp)
             return;
-        }
         this.areSubscriptionsSetUp = true;
         if (deviceIds$ && !isReactNative()) {
-            this.subscriptions.push(combineLatest([deviceIds$, this.state.selectedDevice$]).subscribe(([devices, deviceId]) => {
-                if (!deviceId) {
+            this.subscriptions.push(createSubscription(combineLatest([deviceIds$, this.state.selectedDevice$]), ([devices, deviceId]) => {
+                if (!deviceId)
                     return;
-                }
                 const device = devices.find((d) => d.deviceId === deviceId && d.kind === 'audiooutput');
-                if (!device) {
+                if (!device)
                     this.select('');
-                }
+            }));
+        }
+        if (!isReactNative() && this.devicePersistence.enabled) {
+            this.subscriptions.push(createSubscription(this.state.selectedDevice$, (selectedDevice) => {
+                this.persistSpeakerDevicePreference(selectedDevice);
             }));
         }
     }
@@ -12419,6 +12558,13 @@ class SpeakerManager {
             return { audioVolume: volume };
         });
     }
+    persistSpeakerDevicePreference(selectedDevice) {
+        const { storageKey } = this.devicePersistence;
+        const devices = getCurrentValue(this.listDevices()) || [];
+        const currentDevice = devices.find((d) => d.deviceId === selectedDevice) ??
+            createSyntheticDevice(selectedDevice, 'audiooutput');
+        writePreferences(currentDevice, 'speaker', undefined, storageKey);
+    }
 }
 const assertUnsupportedInReactNative = () => {
     if (isReactNative()) {
@@ -14523,9 +14669,10 @@ class Call {
         this.state.setMembers(members || []);
         this.state.setOwnCapabilities(ownCapabilities || []);
         this.state.setCallingState(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, this.speaker, this.tracer);
     }
@@ -15669,7 +15816,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.43.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.44.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),