@stream-io/video-client 0.3.13 → 0.3.15

package/dist/index.cjs.js

@@ -6432,6 +6432,14 @@ class Publisher {
             [TrackType.SCREEN_SHARE_AUDIO]: undefined,
             [TrackType.UNSPECIFIED]: undefined,
         };
+        /**
+         * A map keeping track of track types that were published to the SFU.
+         * This map shouldn't be cleared when unpublishing a track, as it is used
+         * to determine whether a track was published before.
+         *
+         * @private
+         */
+        this.trackTypePublishHistory = new Map();
         this.isIceRestarting = false;
         this.createPeerConnection = (connectionConfig) => {
             const pc = new RTCPeerConnection(connectionConfig);
@@ -6513,6 +6521,9 @@ class Publisher {
                 // by an external factor as permission revokes, device disconnected, etc.
                 // keep in mind that `track.stop()` doesn't trigger this event.
                 track.addEventListener('ended', handleTrackEnded);
+                if (!track.enabled) {
+                    track.enabled = true;
+                }
                 transceiver = this.pc.addTransceiver(track, {
                     direction: 'sendonly',
                     streams: trackType === TrackType.VIDEO || trackType === TrackType.SCREEN_SHARE
@@ -6523,6 +6534,7 @@ class Publisher {
                 logger$3('debug', `Added ${TrackType[trackType]} transceiver`);
                 this.transceiverInitOrder.push(trackType);
                 this.transceiverRegistry[trackType] = transceiver;
+                this.trackTypePublishHistory.set(trackType, true);
                 if ('setCodecPreferences' in transceiver && codecPreferences) {
                     logger$3('info', `Setting ${TrackType[trackType]} codec preferences`, codecPreferences);
                     transceiver.setCodecPreferences(codecPreferences);
@@ -6550,16 +6562,25 @@ class Publisher {
          * @param stopTrack specifies whether track should be stopped or just disabled
          */
         this.unpublishStream = (trackType, stopTrack) => __awaiter(this, void 0, void 0, function* () {
+            var _b;
             const transceiver = this.pc
                 .getTransceivers()
                 .find((t) => t === this.transceiverRegistry[trackType] && t.sender.track);
             if (transceiver &&
                 transceiver.sender.track &&
-                transceiver.sender.track.readyState === 'live') {
+                (stopTrack
+                    ? transceiver.sender.track.readyState === 'live'
+                    : transceiver.sender.track.enabled)) {
                 stopTrack
                     ? transceiver.sender.track.stop()
                     : (transceiver.sender.track.enabled = false);
-                return this.notifyTrackMuteStateChanged(undefined, transceiver.sender.track, trackType, true);
+                // We don't need to notify SFU if unpublishing in response to remote soft mute
+                if (!((_b = this.state.localParticipant) === null || _b === void 0 ? void 0 : _b.publishedTracks.includes(trackType))) {
+                    return;
+                }
+                else {
+                    return this.notifyTrackMuteStateChanged(undefined, transceiver.sender.track, trackType, true);
+                }
             }
         });
         /**
@@ -6568,6 +6589,32 @@ class Publisher {
          * @param trackType the track type to check.
          */
         this.isPublishing = (trackType) => {
+            const transceiverForTrackType = this.transceiverRegistry[trackType];
+            if (transceiverForTrackType && transceiverForTrackType.sender) {
+                const sender = transceiverForTrackType.sender;
+                return (!!sender.track &&
+                    sender.track.readyState === 'live' &&
+                    sender.track.enabled);
+            }
+            return false;
+        };
+        /**
+         * Returns true if the given track type was ever published to the SFU.
+         * Contrary to `isPublishing`, this method returns true if a certain
+         * track type was published before, even if it is currently unpublished.
+         *
+         * @param trackType the track type to check.
+         */
+        this.hasEverPublished = (trackType) => {
+            var _a;
+            return (_a = this.trackTypePublishHistory.get(trackType)) !== null && _a !== void 0 ? _a : false;
+        };
+        /**
+         * Returns true if the given track type is currently live
+         *
+         * @param trackType the track type to check.
+         */
+        this.isLive = (trackType) => {
             const transceiverForTrackType = this.transceiverRegistry[trackType];
             if (transceiverForTrackType && transceiverForTrackType.sender) {
                 const sender = transceiverForTrackType.sender;
@@ -6608,9 +6655,9 @@ class Publisher {
             });
         };
         this.updateVideoPublishQuality = (enabledRids) => __awaiter(this, void 0, void 0, function* () {
-            var _b;
+            var _c;
             logger$3('info', 'Update publish quality, requested rids by SFU:', enabledRids);
-            const videoSender = (_b = this.transceiverRegistry[TrackType.VIDEO]) === null || _b === void 0 ? void 0 : _b.sender;
+            const videoSender = (_c = this.transceiverRegistry[TrackType.VIDEO]) === null || _c === void 0 ? void 0 : _c.sender;
             if (!videoSender) {
                 logger$3('warn', 'Update publish quality, no video sender found.');
                 return;
@@ -6708,8 +6755,8 @@ class Publisher {
          * @param options the optional offer options to use.
          */
         this.negotiate = (options) => __awaiter(this, void 0, void 0, function* () {
-            var _c;
-            this.isIceRestarting = (_c = options === null || options === void 0 ? void 0 : options.iceRestart) !== null && _c !== void 0 ? _c : false;
+            var _d;
+            this.isIceRestarting = (_d = options === null || options === void 0 ? void 0 : options.iceRestart) !== null && _d !== void 0 ? _d : false;
             const offer = yield this.pc.createOffer(options);
             offer.sdp = this.mungeCodecs(offer.sdp);
             const trackInfos = this.getCurrentTrackInfos(offer.sdp);
@@ -7497,6 +7544,9 @@ const retryable = (rpc, logger) => __awaiter(void 0, void 0, void 0, function* (
         retryAttempt++;
     } while (((_a = rpcCallResult.response.error) === null || _a === void 0 ? void 0 : _a.shouldRetry) &&
         retryAttempt < MAX_RETRIES);
+    if (rpcCallResult.response.error) {
+        throw rpcCallResult.response.error;
+    }
     return rpcCallResult;
 });
 
@@ -9820,6 +9870,190 @@ class CameraManagerState extends InputMediaDeviceManagerState {
     }
 }
 
+class InputMediaDeviceManager {
+    constructor(call, state, trackType) {
+        this.call = call;
+        this.state = state;
+        this.trackType = trackType;
+        this.logger = getLogger([`${TrackType[trackType].toLowerCase()} manager`]);
+    }
+    /**
+     * Lists the available audio/video devices
+     *
+     * Note: It prompts the user for a permission to use devices (if not already granted)
+     *
+     * @returns an Observable that will be updated if a device is connected or disconnected
+     */
+    listDevices() {
+        return this.getDevices();
+    }
+    /**
+     * Starts camera/microphone
+     */
+    enable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'enabled') {
+                return;
+            }
+            this.enablePromise = this.unmuteStream();
+            try {
+                yield this.enablePromise;
+                this.state.setStatus('enabled');
+            }
+            catch (error) {
+                this.enablePromise = undefined;
+                throw error;
+            }
+        });
+    }
+    /**
+     * Stops camera/microphone
+     *
+     * @returns
+     */
+    disable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state.prevStatus = this.state.status;
+            if (this.state.status === 'disabled') {
+                return;
+            }
+            this.disablePromise = this.muteStream(this.state.disableMode === 'stop-tracks');
+            try {
+                yield this.disablePromise;
+                this.state.setStatus('disabled');
+                this.disablePromise = undefined;
+            }
+            catch (error) {
+                this.disablePromise = undefined;
+                throw error;
+            }
+        });
+    }
+    /**
+     * If status was previously enabled, it will reenable the device.
+     */
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.prevStatus === 'enabled' &&
+                this.state.status === 'disabled') {
+                this.enable();
+            }
+        });
+    }
+    /**
+     * If current device statis is disabled, it will enable the device, else it will disable it.
+     *
+     * @returns
+     */
+    toggle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'enabled') {
+                return this.disable();
+            }
+            else {
+                return this.enable();
+            }
+        });
+    }
+    /**
+     * Select device
+     *
+     * Note: this method is not supported in React Native
+     *
+     * @param deviceId
+     */
+    select(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isReactNative()) {
+                throw new Error('This method is not supported in React Native');
+            }
+            if (deviceId === this.state.selectedDevice) {
+                return;
+            }
+            this.state.setDevice(deviceId);
+            yield this.applySettingsToStream();
+        });
+    }
+    applySettingsToStream() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.status === 'enabled') {
+                yield this.muteStream();
+                yield this.unmuteStream();
+            }
+        });
+    }
+    muteStream(stopTracks = true) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.state.mediaStream) {
+                return;
+            }
+            this.logger('debug', `${stopTracks ? 'Stopping' : 'Disabling'} stream`);
+            if (this.call.state.callingState === exports.CallingState.JOINED) {
+                yield this.stopPublishStream(stopTracks);
+            }
+            this.muteLocalStream(stopTracks);
+            if (((_a = this.getTrack()) === null || _a === void 0 ? void 0 : _a.readyState) === 'ended') {
+                // @ts-expect-error release() is present in react-native-webrtc and must be called to dispose the stream
+                if (typeof this.state.mediaStream.release === 'function') {
+                    // @ts-expect-error
+                    this.state.mediaStream.release();
+                }
+                this.state.setMediaStream(undefined);
+            }
+        });
+    }
+    muteTrack() {
+        const track = this.getTrack();
+        if (!track || !track.enabled) {
+            return;
+        }
+        track.enabled = false;
+    }
+    unmuteTrack() {
+        const track = this.getTrack();
+        if (!track || track.enabled) {
+            return;
+        }
+        track.enabled = true;
+    }
+    stopTrack() {
+        const track = this.getTrack();
+        if (!track || track.readyState === 'ended') {
+            return;
+        }
+        track.stop();
+    }
+    muteLocalStream(stopTracks) {
+        if (!this.state.mediaStream) {
+            return;
+        }
+        stopTracks ? this.stopTrack() : this.muteTrack();
+    }
+    unmuteStream() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger('debug', 'Starting stream');
+            let stream;
+            if (this.state.mediaStream && ((_a = this.getTrack()) === null || _a === void 0 ? void 0 : _a.readyState) === 'live') {
+                stream = this.state.mediaStream;
+                this.unmuteTrack();
+            }
+            else {
+                if (this.state.mediaStream) {
+                    this.stopTrack();
+                }
+                const constraints = { deviceId: this.state.selectedDevice };
+                stream = yield this.getStream(constraints);
+            }
+            if (this.call.state.callingState === exports.CallingState.JOINED) {
+                yield this.publishStream(stream);
+            }
+            this.state.setMediaStream(stream);
+        });
+    }
+}
+
 const getDevices = (constraints) => {
     return new rxjs.Observable((subscriber) => {
         navigator.mediaDevices
@@ -10068,156 +10302,9 @@ const disposeOfMediaStream = (stream) => {
     }
 };
 
-class InputMediaDeviceManager {
-    constructor(call, state) {
-        this.call = call;
-        this.state = state;
-    }
-    /**
-     * Lists the available audio/video devices
-     *
-     * Note: It prompts the user for a permission to use devices (if not already granted)
-     *
-     * @returns an Observable that will be updated if a device is connected or disconnected
-     */
-    listDevices() {
-        return this.getDevices();
-    }
-    /**
-     * Starts camera/microphone
-     */
-    enable() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.status === 'enabled') {
-                return;
-            }
-            this.enablePromise = this.unmuteStream();
-            try {
-                yield this.enablePromise;
-                this.state.setStatus('enabled');
-            }
-            catch (error) {
-                this.enablePromise = undefined;
-                throw error;
-            }
-        });
-    }
-    /**
-     * Stops camera/microphone
-     *
-     * @returns
-     */
-    disable() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.state.prevStatus = this.state.status;
-            if (this.state.status === 'disabled') {
-                return;
-            }
-            this.disablePromise = this.muteStream(this.state.disableMode === 'stop-tracks');
-            try {
-                yield this.disablePromise;
-                this.state.setStatus('disabled');
-                this.disablePromise = undefined;
-            }
-            catch (error) {
-                this.disablePromise = undefined;
-                throw error;
-            }
-        });
-    }
-    /**
-     * If status was previously enabled, it will reenable the device.
-     */
-    resume() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.prevStatus === 'enabled' &&
-                this.state.status === 'disabled') {
-                this.enable();
-            }
-        });
-    }
-    /**
-     * If current device statis is disabled, it will enable the device, else it will disable it.
-     *
-     * @returns
-     */
-    toggle() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.status === 'enabled') {
-                return this.disable();
-            }
-            else {
-                return this.enable();
-            }
-        });
-    }
-    /**
-     * Select device
-     *
-     * Note: this method is not supported in React Native
-     *
-     * @param deviceId
-     */
-    select(deviceId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isReactNative()) {
-                throw new Error('This method is not supported in React Native');
-            }
-            if (deviceId === this.state.selectedDevice) {
-                return;
-            }
-            this.state.setDevice(deviceId);
-            yield this.applySettingsToStream();
-        });
-    }
-    applySettingsToStream() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.status === 'enabled') {
-                yield this.muteStream();
-                yield this.unmuteStream();
-            }
-        });
-    }
-    muteStream(stopTracks = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.state.mediaStream) {
-                return;
-            }
-            if (this.call.state.callingState === exports.CallingState.JOINED) {
-                yield this.stopPublishStream(stopTracks);
-            }
-            else if (this.state.mediaStream) {
-                stopTracks
-                    ? disposeOfMediaStream(this.state.mediaStream)
-                    : this.muteTracks();
-            }
-            if (stopTracks) {
-                this.state.setMediaStream(undefined);
-            }
-        });
-    }
-    unmuteStream() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let stream;
-            if (this.state.mediaStream) {
-                stream = this.state.mediaStream;
-                this.unmuteTracks();
-            }
-            else {
-                const constraints = { deviceId: this.state.selectedDevice };
-                stream = yield this.getStream(constraints);
-            }
-            if (this.call.state.callingState === exports.CallingState.JOINED) {
-                yield this.publishStream(stream);
-            }
-            this.state.setMediaStream(stream);
-        });
-    }
-}
-
 class CameraManager extends InputMediaDeviceManager {
     constructor(call) {
-        super(call, new CameraManagerState());
+        super(call, new CameraManagerState(), TrackType.VIDEO);
         this.targetResolution = {
             width: 1280,
             height: 720,
@@ -10269,6 +10356,7 @@ class CameraManager extends InputMediaDeviceManager {
                 if (width !== this.targetResolution.width ||
                     height !== this.targetResolution.height)
                     yield this.applySettingsToStream();
+                this.logger('debug', `${width}x${height} target resolution applied to media stream`);
             }
         });
     }
@@ -10292,13 +10380,9 @@ class CameraManager extends InputMediaDeviceManager {
     stopPublishStream(stopTracks) {
         return this.call.stopPublish(TrackType.VIDEO, stopTracks);
     }
-    muteTracks() {
-        var _a;
-        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getVideoTracks().forEach((t) => (t.enabled = false));
-    }
-    unmuteTracks() {
+    getTrack() {
         var _a;
-        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getVideoTracks().forEach((t) => (t.enabled = true));
+        return (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getVideoTracks()[0];
     }
 }
 
@@ -10314,7 +10398,7 @@ class MicrophoneManagerState extends InputMediaDeviceManagerState {
 
 class MicrophoneManager extends InputMediaDeviceManager {
     constructor(call) {
-        super(call, new MicrophoneManagerState());
+        super(call, new MicrophoneManagerState(), TrackType.AUDIO);
     }
     getDevices() {
         return getAudioDevices();
@@ -10328,13 +10412,9 @@ class MicrophoneManager extends InputMediaDeviceManager {
     stopPublishStream(stopTracks) {
         return this.call.stopPublish(TrackType.AUDIO, stopTracks);
     }
-    muteTracks() {
-        var _a;
-        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((t) => (t.enabled = false));
-    }
-    unmuteTracks() {
+    getTrack() {
         var _a;
-        (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks().forEach((t) => (t.enabled = true));
+        return (_a = this.state.mediaStream) === null || _a === void 0 ? void 0 : _a.getAudioTracks()[0];
     }
 }
 
@@ -11020,7 +11100,7 @@ class Call {
          */
         this.stopPublish = (trackType, stopTrack = true) => __awaiter(this, void 0, void 0, function* () {
             var _j;
-            this.logger('info', `stopPublish ${TrackType[trackType]}`);
+            this.logger('info', `stopPublish ${TrackType[trackType]}, stop tracks: ${stopTrack}`);
             yield ((_j = this.publisher) === null || _j === void 0 ? void 0 : _j.unpublishStream(trackType, stopTrack));
         });
         /**
@@ -11598,6 +11678,40 @@ class Call {
         this.leaveCallHooks.add(createSubscription(this.trackSubscriptionsSubject.pipe(rxjs.debounce((v) => rxjs.timer(v.type)), rxjs.map((v) => v.data)), (subscriptions) => { var _a; return (_a = this.sfuClient) === null || _a === void 0 ? void 0 : _a.updateSubscriptions(subscriptions); }));
         this.camera = new CameraManager(this);
         this.microphone = new MicrophoneManager(this);
+        // FIXME OL: disable soft-mutes as they are not working properly
+        // this.state.localParticipant$.subscribe(async (p) => {
+        //   if (!this.publisher) return;
+        //   // Mute via device manager
+        //   // If integrator doesn't use device manager, we mute using stopPublish
+        //   if (
+        //     this.publisher.hasEverPublished(TrackType.VIDEO) &&
+        //     this.publisher.isPublishing(TrackType.VIDEO) &&
+        //     !p?.publishedTracks.includes(TrackType.VIDEO)
+        //   ) {
+        //     this.logger(
+        //       'info',
+        //       `Local participant's video track is muted remotely`,
+        //     );
+        //     await this.camera.disable();
+        //     if (this.publisher.isPublishing(TrackType.VIDEO)) {
+        //       await this.stopPublish(TrackType.VIDEO);
+        //     }
+        //   }
+        //   if (
+        //     this.publisher.hasEverPublished(TrackType.AUDIO) &&
+        //     this.publisher.isPublishing(TrackType.AUDIO) &&
+        //     !p?.publishedTracks.includes(TrackType.AUDIO)
+        //   ) {
+        //     this.logger(
+        //       'info',
+        //       `Local participant's audio track is muted remotely`,
+        //     );
+        //     await this.microphone.disable();
+        //     if (this.publisher.isPublishing(TrackType.AUDIO)) {
+        //       await this.stopPublish(TrackType.AUDIO);
+        //     }
+        //   }
+        // });
         this.speaker = new SpeakerManager();
     }
     registerEffects() {
@@ -11623,9 +11737,27 @@ class Call {
             };
             for (const [permission, trackType] of Object.entries(permissionToTrackType)) {
                 const hasPermission = this.permissionsContext.hasPermission(permission);
-                if (!hasPermission && this.publisher.isPublishing(trackType)) {
-                    this.stopPublish(trackType).catch((err) => {
+                if (!hasPermission &&
+                    (this.publisher.isPublishing(trackType) ||
+                        this.publisher.isLive(trackType))) {
+                    // Stop tracks, then notify device manager
+                    this.stopPublish(trackType)
+                        .catch((err) => {
                         this.logger('error', `Error stopping publish ${trackType}`, err);
+                    })
+                        .then(() => {
+                        if (trackType === TrackType.VIDEO &&
+                            this.camera.state.status === 'enabled') {
+                            this.camera
+                                .disable()
+                                .catch((err) => this.logger('error', `Error disabling camera after pemission revoked`, err));
+                        }
+                        if (trackType === TrackType.AUDIO &&
+                            this.microphone.state.status === 'enabled') {
+                            this.microphone
+                                .disable()
+                                .catch((err) => this.logger('error', `Error disabling microphone after pemission revoked`, err));
+                        }
                     });
                 }
             }
@@ -12889,11 +13021,11 @@ class WSConnectionFallback {
     }
 }
 
-const version = '0.3.13';
+const version = '0.3.15';
 
 const logger = getLogger(['location']);
 const HINT_URL = `https://hint.stream-io-video.com/`;
-const getLocationHint = (hintUrl = HINT_URL, timeout = 1500) => __awaiter(void 0, void 0, void 0, function* () {
+const getLocationHint = (hintUrl = HINT_URL, timeout = 2000) => __awaiter(void 0, void 0, void 0, function* () {
     const abortController = new AbortController();
     const timeoutId = setTimeout(() => abortController.abort(), timeout);
     try {
@@ -12906,7 +13038,7 @@ const getLocationHint = (hintUrl = HINT_URL, timeout = 1500) => __awaiter(void 0
         return awsPop.substring(0, 3); // AMS1-P2 -> AMS
     }
     catch (e) {
-        logger('error', `Failed to get location hint from ${HINT_URL}`, e);
+        logger('warn', `Failed to get location hint from ${HINT_URL}`, e);
         return 'ERR';
     }
     finally {