@stream-io/video-client 0.7.10 → 0.7.11

package/dist/index.es.js

@@ -9514,7 +9514,7 @@ const toRtcConfiguration = (config) => {
  *
  * @param report the report to flatten.
  */
-const flatten$1 = (report) => {
+const flatten = (report) => {
     const stats = [];
     report.forEach((s) => {
         stats.push(s);
@@ -9668,7 +9668,7 @@ const createStatsReporter = ({ subscriber, publisher, state, pollingIntervalInMs
 const transform = (report, opts) => {
     const { trackKind, kind } = opts;
     const direction = kind === 'subscriber' ? 'inbound-rtp' : 'outbound-rtp';
-    const stats = flatten$1(report);
+    const stats = flatten(report);
     const streams = stats
         .filter((stat) => stat.type === direction &&
         stat.kind === trackKind)
@@ -9764,8 +9764,8 @@ class SfuStatsReporter {
         this.logger = getLogger(['SfuStatsReporter']);
         this.run = async () => {
             const [subscriberStats, publisherStats] = await Promise.all([
-                this.subscriber.getStats().then(flatten$1).then(JSON.stringify),
-                this.publisher.getStats().then(flatten$1).then(JSON.stringify),
+                this.subscriber.getStats().then(flatten).then(JSON.stringify),
+                this.publisher.getStats().then(flatten).then(JSON.stringify),
             ]);
             await this.sfuClient.sendStats({
                 sdk: this.sdkName,
@@ -10738,7 +10738,7 @@ class InputMediaDeviceManager {
                 // @ts-expect-error called to dispose the stream in RN
                 this.state.mediaStream.release();
             }
-            this.state.setMediaStream(undefined);
+            this.state.setMediaStream(undefined, undefined);
         }
     }
     muteTracks() {
@@ -10773,6 +10773,7 @@ class InputMediaDeviceManager {
     async unmuteStream() {
         this.logger('debug', 'Starting stream');
         let stream;
+        let rootStream;
         if (this.state.mediaStream &&
             this.getTracks().every((t) => t.readyState === 'live')) {
             stream = this.state.mediaStream;
@@ -10838,14 +10839,17 @@ class InputMediaDeviceManager {
                 });
                 return filterStream;
             };
+            // the rootStream represents the stream coming from the actual device
+            // e.g. camera or microphone stream
+            rootStream = this.getStream(constraints);
             // we publish the last MediaStream of the chain
-            stream = await this.filters.reduce((parent, filter) => parent.then(filter).then(chainWith(parent)), this.getStream(constraints));
+            stream = await this.filters.reduce((parent, filter) => parent.then(filter).then(chainWith(parent)), rootStream);
         }
         if (this.call.state.callingState === CallingState.JOINED) {
             await this.publishStream(stream);
         }
         if (this.state.mediaStream !== stream) {
-            this.state.setMediaStream(stream);
+            this.state.setMediaStream(stream, await rootStream);
             this.getTracks().forEach((track) => {
                 track.addEventListener('ended', async () => {
                     if (this.enablePromise) {
@@ -11039,13 +11043,17 @@ class InputMediaDeviceManagerState {
         this.setCurrentValue(this.statusSubject, status);
     }
     /**
+     * Updates the `mediaStream` state variable.
+     *
      * @internal
      * @param stream the stream to set.
+     * @param rootStream the root stream, applicable when filters are used
+     * as this is the stream that holds the actual deviceId information.
      */
-    setMediaStream(stream) {
+    setMediaStream(stream, rootStream) {
         this.setCurrentValue(this.mediaStreamSubject, stream);
-        if (stream) {
-            this.setDevice(this.getDeviceIdFromStream(stream));
+        if (rootStream) {
+            this.setDevice(this.getDeviceIdFromStream(rootStream));
         }
     }
     /**
@@ -11100,8 +11108,8 @@ class CameraManagerState extends InputMediaDeviceManagerState {
     /**
      * @internal
      */
-    setMediaStream(stream) {
-        super.setMediaStream(stream);
+    setMediaStream(stream, rootStream) {
+        super.setMediaStream(stream, rootStream);
         if (stream) {
             // RN getSettings() doesn't return facingMode, so we don't verify camera direction
             const direction = isReactNative()
@@ -11113,7 +11121,8 @@ class CameraManagerState extends InputMediaDeviceManagerState {
         }
     }
     getDeviceIdFromStream(stream) {
-        return stream.getVideoTracks()[0]?.getSettings().deviceId;
+        const [track] = stream.getVideoTracks();
+        return track?.getSettings().deviceId;
     }
 }
 
@@ -11206,8 +11215,8 @@ class CameraManager extends InputMediaDeviceManager {
 }
 
 class MicrophoneManagerState extends InputMediaDeviceManagerState {
-    constructor() {
-        super('disable-tracks', 
+    constructor(disableMode) {
+        super(disableMode, 
         // `microphone` is not in the W3C standard yet,
         // but it's supported by Chrome and Safari.
         'microphone');
@@ -11231,7 +11240,8 @@ class MicrophoneManagerState extends InputMediaDeviceManagerState {
         this.setCurrentValue(this.speakingWhileMutedSubject, isSpeaking);
     }
     getDeviceIdFromStream(stream) {
-        return stream.getAudioTracks()[0]?.getSettings().deviceId;
+        const [track] = stream.getAudioTracks();
+        return track?.getSettings().deviceId;
     }
 }
 
@@ -11288,18 +11298,6 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
     };
 };
 
-/**
- * Flatten the stats report into an array of stats objects.
- *
- * @param report the report to flatten.
- */
-const flatten = (report) => {
-    const stats = [];
-    report.forEach((s) => {
-        stats.push(s);
-    });
-    return stats;
-};
 const AUDIO_LEVEL_THRESHOLD = 0.2;
 class RNSpeechDetector {
     constructor() {
@@ -11382,20 +11380,24 @@ class RNSpeechDetector {
 }
 
 class MicrophoneManager extends InputMediaDeviceManager {
-    constructor(call) {
-        super(call, new MicrophoneManagerState(), TrackType.AUDIO);
-        combineLatest([
+    constructor(call, disableMode = isReactNative()
+        ? 'disable-tracks'
+        : 'stop-tracks') {
+        super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
+        this.speakingWhileMutedNotificationEnabled = true;
+        this.subscriptions.push(createSubscription(combineLatest([
             this.call.state.callingState$,
             this.call.state.ownCapabilities$,
             this.state.selectedDevice$,
             this.state.status$,
-        ]).subscribe(async ([callingState, ownCapabilities, deviceId, status]) => {
-            if (callingState !== CallingState.JOINED) {
-                if (callingState === CallingState.LEFT) {
-                    await this.stopSpeakingWhileMutedDetection();
-                }
-                return;
+        ]), async ([callingState, ownCapabilities, deviceId, status]) => {
+            if (callingState === CallingState.LEFT) {
+                await this.stopSpeakingWhileMutedDetection();
             }
+            if (callingState !== CallingState.JOINED)
+                return;
+            if (!this.speakingWhileMutedNotificationEnabled)
+                return;
             if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
                 if (status === 'disabled') {
                     await this.startSpeakingWhileMutedDetection(deviceId);
@@ -11407,7 +11409,7 @@ class MicrophoneManager extends InputMediaDeviceManager {
             else {
                 await this.stopSpeakingWhileMutedDetection();
             }
-        });
+        }));
         this.subscriptions.push(createSubscription(this.call.state.callingState$, (callingState) => {
             // do nothing when noise filtering isn't turned on
             if (!this.noiseCancellationRegistration || !this.noiseCancellation)
@@ -11502,6 +11504,22 @@ class MicrophoneManager extends InputMediaDeviceManager {
         });
         await this.call.notifyNoiseCancellationStopped();
     }
+    /**
+     * Enables speaking while muted notification.
+     */
+    async enableSpeakingWhileMutedNotification() {
+        this.speakingWhileMutedNotificationEnabled = true;
+        if (this.state.status === 'disabled') {
+            await this.startSpeakingWhileMutedDetection(this.state.selectedDevice);
+        }
+    }
+    /**
+     * Disables speaking while muted notification.
+     */
+    async disableSpeakingWhileMutedNotification() {
+        this.speakingWhileMutedNotificationEnabled = false;
+        await this.stopSpeakingWhileMutedDetection();
+    }
     getDevices() {
         return getAudioDevices();
     }
@@ -11539,9 +11557,8 @@ class MicrophoneManager extends InputMediaDeviceManager {
         }
     }
     async stopSpeakingWhileMutedDetection() {
-        if (!this.soundDetectorCleanup) {
+        if (!this.soundDetectorCleanup)
             return;
-        }
         this.state.setSpeakingWhileMuted(false);
         try {
             await this.soundDetectorCleanup();
@@ -14864,7 +14881,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.7.10" ;
+            const version = "0.7.11" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };