@stream-io/video-client 0.4.5 → 0.4.7

package/dist/index.cjs.js

@@ -10001,8 +10001,7 @@ const getDevices = (constraints, kind) => {
 /**
  * [Tells if the browser supports audio output change on 'audio' elements](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/setSinkId).
  *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- */
+ *  */
 const checkIfAudioOutputChangeSupported = () => {
     if (typeof document === 'undefined')
         return false;
@@ -10162,90 +10161,10 @@ const getScreenShareStream = async (options) => {
         throw e;
     }
 };
-const watchForDisconnectedDevice = (kind, deviceId$) => {
-    let devices$;
-    switch (kind) {
-        case 'audioinput':
-            devices$ = getAudioDevices();
-            break;
-        case 'videoinput':
-            devices$ = getVideoDevices();
-            break;
-        case 'audiooutput':
-            devices$ = getAudioOutputDevices();
-            break;
-    }
-    return rxjs.combineLatest([devices$, deviceId$]).pipe(rxjs.filter(([devices, deviceId]) => !!deviceId && !devices.find((d) => d.deviceId === deviceId)), rxjs.map(() => true));
-};
-/**
- * Notifies the subscriber if a given 'audioinput' device is disconnected
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param deviceId$ an Observable that specifies which device to watch for
- * @returns
- */
-const watchForDisconnectedAudioDevice = (deviceId$) => {
-    return watchForDisconnectedDevice('audioinput', deviceId$);
-};
-/**
- * Notifies the subscriber if a given 'videoinput' device is disconnected
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param deviceId$ an Observable that specifies which device to watch for
- * @returns
- */
-const watchForDisconnectedVideoDevice = (deviceId$) => {
-    return watchForDisconnectedDevice('videoinput', deviceId$);
-};
-/**
- * Notifies the subscriber if a given 'audiooutput' device is disconnected
- *
- * @angular It's recommended to use the [`DeviceManagerService`](./DeviceManagerService.md) for a higher level API, use this low-level method only if the `DeviceManagerService` doesn't suit your requirements.
- * @param deviceId$ an Observable that specifies which device to watch for
- * @returns
- */
-const watchForDisconnectedAudioOutputDevice = (deviceId$) => {
-    return watchForDisconnectedDevice('audiooutput', deviceId$);
-};
-const watchForAddedDefaultDevice = (kind) => {
-    let devices$;
-    switch (kind) {
-        case 'audioinput':
-            devices$ = getAudioDevices();
-            break;
-        case 'videoinput':
-            devices$ = getVideoDevices();
-            break;
-        case 'audiooutput':
-            devices$ = getAudioOutputDevices();
-            break;
-        default:
-            throw new Error('Unknown MediaDeviceKind', kind);
-    }
-    return devices$.pipe(rxjs.pairwise(), rxjs.filter(([prev, current]) => {
-        const prevDefault = prev.find((device) => device.deviceId === 'default');
-        const currentDefault = current.find((device) => device.deviceId === 'default');
-        return !!(current.length > prev.length &&
-            prevDefault &&
-            currentDefault &&
-            prevDefault.groupId !== currentDefault.groupId);
-    }), rxjs.map(() => true));
-};
-/**
- * Notifies the subscriber about newly added default audio input device.
- * @returns Observable<boolean>
- */
-const watchForAddedDefaultAudioDevice = () => watchForAddedDefaultDevice('audioinput');
-/**
- * Notifies the subscriber about newly added default audio output device.
- * @returns Observable<boolean>
- */
-const watchForAddedDefaultAudioOutputDevice = () => watchForAddedDefaultDevice('audiooutput');
-/**
- * Notifies the subscriber about newly added default video input device.
- * @returns Observable<boolean>
- */
-const watchForAddedDefaultVideoDevice = () => watchForAddedDefaultDevice('videoinput');
+const deviceIds$ = typeof navigator !== 'undefined' &&
+    typeof navigator.mediaDevices !== 'undefined'
+    ? memoizedObservable(() => rxjs.merge(rxjs.from(navigator.mediaDevices.enumerateDevices()), getDeviceChangeObserver()).pipe(rxjs.shareReplay(1)))()
+    : undefined;
 /**
  * Deactivates MediaStream (stops and removes tracks) to be later garbage collected
  *
@@ -10271,7 +10190,17 @@ class InputMediaDeviceManager {
         this.call = call;
         this.state = state;
         this.trackType = trackType;
+        this.subscriptions = [];
+        this.isTrackStoppedDueToTrackEnd = false;
+        this.removeSubscriptions = () => {
+            this.subscriptions.forEach((s) => s.unsubscribe());
+        };
         this.logger = getLogger([`${TrackType[trackType].toLowerCase()} manager`]);
+        if (deviceIds$ &&
+            !isReactNative() &&
+            (this.trackType === TrackType.AUDIO || this.trackType === TrackType.VIDEO)) {
+            this.handleDisconnectedOrReplacedDevices();
+        }
     }
     /**
      * Lists the available audio/video devices
@@ -10349,11 +10278,10 @@ class InputMediaDeviceManager {
         this.state.setDefaultConstraints(constraints);
     }
     /**
-     * Select device
+     * Selects a device.
      *
      * Note: this method is not supported in React Native
-     *
-     * @param deviceId
+     * @param deviceId the device id to select.
      */
     async select(deviceId) {
         if (isReactNative()) {
@@ -10431,9 +10359,6 @@ class InputMediaDeviceManager {
             this.unmuteTracks();
         }
         else {
-            if (this.state.mediaStream) {
-                this.stopTracks();
-            }
             const defaultConstraints = this.state.defaultConstraints;
             const constraints = {
                 ...defaultConstraints,
@@ -10446,13 +10371,93 @@ class InputMediaDeviceManager {
         }
         if (this.state.mediaStream !== stream) {
             this.state.setMediaStream(stream);
+            this.getTracks().forEach((track) => {
+                track.addEventListener('ended', async () => {
+                    if (this.enablePromise) {
+                        await this.enablePromise;
+                    }
+                    if (this.disablePromise) {
+                        await this.disablePromise;
+                    }
+                    if (this.state.status === 'enabled') {
+                        this.isTrackStoppedDueToTrackEnd = true;
+                        setTimeout(() => {
+                            this.isTrackStoppedDueToTrackEnd = false;
+                        }, 2000);
+                        await this.disable();
+                    }
+                });
+            });
+        }
+    }
+    get mediaDeviceKind() {
+        if (this.trackType === TrackType.AUDIO) {
+            return 'audioinput';
         }
+        if (this.trackType === TrackType.VIDEO) {
+            return 'videoinput';
+        }
+        return '';
+    }
+    handleDisconnectedOrReplacedDevices() {
+        this.subscriptions.push(rxjs.combineLatest([
+            deviceIds$.pipe(rxjs.pairwise()),
+            this.state.selectedDevice$,
+        ]).subscribe(async ([[prevDevices, currentDevices], deviceId]) => {
+            if (!deviceId) {
+                return;
+            }
+            if (this.enablePromise) {
+                await this.enablePromise;
+            }
+            if (this.disablePromise) {
+                await this.disablePromise;
+            }
+            let isDeviceDisconnected = false;
+            let isDeviceReplaced = false;
+            const currentDevice = this.findDeviceInList(currentDevices, deviceId);
+            const prevDevice = this.findDeviceInList(prevDevices, deviceId);
+            if (!currentDevice && prevDevice) {
+                isDeviceDisconnected = true;
+            }
+            else if (currentDevice &&
+                prevDevice &&
+                currentDevice.deviceId === prevDevice.deviceId &&
+                currentDevice.groupId !== prevDevice.groupId) {
+                isDeviceReplaced = true;
+            }
+            if (isDeviceDisconnected) {
+                await this.disable();
+                this.select(undefined);
+            }
+            if (isDeviceReplaced) {
+                if (this.isTrackStoppedDueToTrackEnd &&
+                    this.state.status === 'disabled') {
+                    await this.enable();
+                    this.isTrackStoppedDueToTrackEnd = false;
+                }
+                else {
+                    await this.applySettingsToStream();
+                }
+            }
+        }));
+    }
+    findDeviceInList(devices, deviceId) {
+        return devices.find((d) => d.deviceId === deviceId && d.kind === this.mediaDeviceKind);
     }
 }
 
 class InputMediaDeviceManagerState {
-    constructor(disableMode = 'stop-tracks') {
+    /**
+     * Constructs new InputMediaDeviceManagerState instance.
+     *
+     * @param disableMode the disable mode to use.
+     * @param permissionName the permission name to use for querying.
+     * `undefined` means no permission is required.
+     */
+    constructor(disableMode = 'stop-tracks', permissionName = undefined) {
         this.disableMode = disableMode;
+        this.permissionName = permissionName;
         this.statusSubject = new rxjs.BehaviorSubject(undefined);
         this.mediaStreamSubject = new rxjs.BehaviorSubject(undefined);
         this.selectedDeviceSubject = new rxjs.BehaviorSubject(undefined);
@@ -10476,6 +10481,33 @@ class InputMediaDeviceManagerState {
          * The default constraints for the device.
          */
         this.defaultConstraints$ = this.defaultConstraintsSubject.asObservable();
+        /**
+         * An observable that will emit `true` if browser/system permission
+         * is granted, `false` otherwise.
+         */
+        this.hasBrowserPermission$ = new rxjs.Observable((subscriber) => {
+            const notifyGranted = () => subscriber.next(true);
+            if (isReactNative() || !this.permissionName)
+                return notifyGranted();
+            let permissionState;
+            const notify = () => subscriber.next(permissionState.state === 'granted');
+            navigator.permissions
+                .query({ name: this.permissionName })
+                .then((permissionStatus) => {
+                permissionState = permissionStatus;
+                permissionState.addEventListener('change', notify);
+                notify();
+            })
+                .catch(() => {
+                // permission doesn't exist or can't be queried -> assume it's granted
+                // an example would be Firefox,
+                // where neither camera microphone permission can be queried
+                notifyGranted();
+            });
+            return () => {
+                permissionState?.removeEventListener('change', notify);
+            };
+        }).pipe(rxjs.shareReplay(1));
         /**
          * Gets the current value of an observable, or undefined if the observable has
          * not emitted a value yet.
@@ -10557,7 +10589,10 @@ class InputMediaDeviceManagerState {
 
 class CameraManagerState extends InputMediaDeviceManagerState {
     constructor() {
-        super('stop-tracks');
+        super('stop-tracks', 
+        // `camera` is not in the W3C standard yet,
+        // but it's supported by Chrome and Safari.
+        'camera');
         this.directionSubject = new rxjs.BehaviorSubject(undefined);
         this.direction$ = this.directionSubject
             .asObservable()
@@ -10687,7 +10722,10 @@ class CameraManager extends InputMediaDeviceManager {
 
 class MicrophoneManagerState extends InputMediaDeviceManagerState {
     constructor() {
-        super('disable-tracks');
+        super('disable-tracks', 
+        // `microphone` is not in the W3C standard yet,
+        // but it's supported by Chrome and Safari.
+        'microphone');
         this.speakingWhileMutedSubject = new rxjs.BehaviorSubject(false);
         this.speakingWhileMuted$ = this.speakingWhileMutedSubject
             .asObservable()
@@ -11014,6 +11052,21 @@ class SpeakerState {
 class SpeakerManager {
     constructor() {
         this.state = new SpeakerState();
+        this.subscriptions = [];
+        this.removeSubscriptions = () => {
+            this.subscriptions.forEach((s) => s.unsubscribe());
+        };
+        if (deviceIds$ && !isReactNative()) {
+            this.subscriptions.push(rxjs.combineLatest([deviceIds$, this.state.selectedDevice$]).subscribe(([devices, deviceId]) => {
+                if (!deviceId) {
+                    return;
+                }
+                const device = devices.find((d) => d.deviceId === deviceId && d.kind === 'audiooutput');
+                if (!device) {
+                    this.select('');
+                }
+            }));
+        }
     }
     /**
      * Lists the available audio output devices
@@ -11131,6 +11184,10 @@ class Call {
             this.leaveCallHooks.forEach((hook) => hook());
             this.clientStore.unregisterCall(this);
             this.state.setCallingState(exports.CallingState.LEFT);
+            this.camera.removeSubscriptions();
+            this.microphone.removeSubscriptions();
+            this.screenShare.removeSubscriptions();
+            this.speaker.removeSubscriptions();
         };
         /**
          * Loads the information about the call.
@@ -11504,7 +11561,7 @@ class Call {
                     await this.initMic({ setStatus: true });
                 }
                 catch (error) {
-                    this.logger('warn', 'Camera and/or mic init failed during join call');
+                    this.logger('warn', 'Camera and/or mic init failed during join call', error);
                 }
                 // 3. once we have the "joinResponse", and possibly reconciled the local state
                 // we schedule a fast subscription update for all remote participants
@@ -13977,7 +14034,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.4.5" ;
+            const version = "0.4.7" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };
@@ -14560,6 +14617,7 @@ exports.conditional = conditional;
 exports.createSoundDetector = createSoundDetector;
 exports.defaultSortPreset = defaultSortPreset;
 exports.descending = descending;
+exports.deviceIds$ = deviceIds$;
 exports.disposeOfMediaStream = disposeOfMediaStream;
 exports.dominantSpeaker = dominantSpeaker;
 exports.getAudioDevices = getAudioDevices;
@@ -14592,10 +14650,4 @@ exports.setOSInfo = setOSInfo;
 exports.setSdkInfo = setSdkInfo;
 exports.speakerLayoutSortPreset = speakerLayoutSortPreset;
 exports.speaking = speaking;
-exports.watchForAddedDefaultAudioDevice = watchForAddedDefaultAudioDevice;
-exports.watchForAddedDefaultAudioOutputDevice = watchForAddedDefaultAudioOutputDevice;
-exports.watchForAddedDefaultVideoDevice = watchForAddedDefaultVideoDevice;
-exports.watchForDisconnectedAudioDevice = watchForDisconnectedAudioDevice;
-exports.watchForDisconnectedAudioOutputDevice = watchForDisconnectedAudioOutputDevice;
-exports.watchForDisconnectedVideoDevice = watchForDisconnectedVideoDevice;
 //# sourceMappingURL=index.cjs.js.map