@stream-io/video-client 0.7.9 → 0.7.11

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [0.7.11](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-0.7.10...@stream-io/video-client-0.7.11) (2024-05-03)
+
+
+### Bug Fixes
+
+* **devices:** API to disable speaking while muted notifications ([#1335](https://github.com/GetStream/stream-video-js/issues/1335)) ([cdff0e0](https://github.com/GetStream/stream-video-js/commit/cdff0e036bf4afca763e4f7a1563c23e806be190)), closes [#1329](https://github.com/GetStream/stream-video-js/issues/1329)
+
+### [0.7.10](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-0.7.9...@stream-io/video-client-0.7.10) (2024-04-30)
+
+
+### Bug Fixes
+
+* **state:** optimized Call State updates ([#1330](https://github.com/GetStream/stream-video-js/issues/1330)) ([e5f9f88](https://github.com/GetStream/stream-video-js/commit/e5f9f882df95761bfecbd6b38832f013b0e7a75e))
+
 ### [0.7.9](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-0.7.8...@stream-io/video-client-0.7.9) (2024-04-26)
 
 

package/dist/index.browser.es.js

@@ -6843,6 +6843,7 @@ class CallState {
         this.anonymousParticipantCountSubject = new BehaviorSubject(0);
         this.participantsSubject = new BehaviorSubject([]);
         this.callStatsReportSubject = new BehaviorSubject(undefined);
+        this.logger = getLogger(['CallState']);
         /**
          * A list of comparators that are used to sort the participants.
          *
@@ -7003,21 +7004,22 @@ class CallState {
          * @param participant the participant to update or add.
          */
         this.updateOrAddParticipant = (sessionId, participant) => {
-            if (!this.findParticipantBySessionId(sessionId)) {
-                return this.setParticipants((participants) => [
-                    ...participants,
-                    participant,
-                ]);
-            }
-            return this.setParticipants((participants) => participants.map((p) => {
-                if (p.sessionId === sessionId) {
-                    return {
-                        ...p,
-                        ...participant,
-                    };
-                }
-                return p;
-            }));
+            return this.setParticipants((participants) => {
+                let add = true;
+                const nextParticipants = participants.map((p) => {
+                    if (p.sessionId === sessionId) {
+                        add = false;
+                        return {
+                            ...p,
+                            ...participant,
+                        };
+                    }
+                    return p;
+                });
+                if (add)
+                    nextParticipants.push(participant);
+                return nextParticipants;
+            });
         };
         /**
          * Updates all participants in the current call whose session ID is in the given `sessionIds`.
@@ -7242,7 +7244,6 @@ class CallState {
                 this.setCurrentValue(this.ownCapabilitiesSubject, event.own_capabilities);
             }
         };
-        this.logger = getLogger(['CallState']);
         this.participants$ = this.participantsSubject.asObservable().pipe(
         // maintain stable-sort by mutating the participants stored
         // in the original subject
@@ -7252,30 +7253,52 @@ class CallState {
         this.pinnedParticipants$ = this.participants$.pipe(map$1((participants) => participants.filter((p) => !!p.pin)), shareReplay({ bufferSize: 1, refCount: true }));
         this.dominantSpeaker$ = this.participants$.pipe(map$1((participants) => participants.find((p) => p.isDominantSpeaker)), shareReplay({ bufferSize: 1, refCount: true }));
         this.hasOngoingScreenShare$ = this.participants$.pipe(map$1((participants) => participants.some((p) => p.publishedTracks.includes(TrackType.SCREEN_SHARE))), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
-        this.startedAt$ = this.startedAtSubject.asObservable();
-        this.participantCount$ = this.participantCountSubject.asObservable();
-        this.anonymousParticipantCount$ =
-            this.anonymousParticipantCountSubject.asObservable();
-        this.callStatsReport$ = this.callStatsReportSubject.asObservable();
-        this.members$ = this.membersSubject.asObservable();
-        this.ownCapabilities$ = this.ownCapabilitiesSubject.asObservable();
-        this.callingState$ = this.callingStateSubject.asObservable();
-        this.backstage$ = this.backstageSubject.asObservable();
-        this.blockedUserIds$ = this.blockedUserIdsSubject.asObservable();
+        // dates
         this.createdAt$ = this.createdAtSubject.asObservable();
         this.endedAt$ = this.endedAtSubject.asObservable();
         this.startsAt$ = this.startsAtSubject.asObservable();
+        this.startedAt$ = this.startedAtSubject.asObservable();
         this.updatedAt$ = this.updatedAtSubject.asObservable();
+        this.callStatsReport$ = this.callStatsReportSubject.asObservable();
+        this.members$ = this.membersSubject.asObservable();
+        // complex objects should work as streams of data
         this.createdBy$ = this.createdBySubject.asObservable();
         this.custom$ = this.customSubject.asObservable();
         this.egress$ = this.egressSubject.asObservable();
         this.ingress$ = this.ingressSubject.asObservable();
-        this.recording$ = this.recordingSubject.asObservable();
         this.session$ = this.sessionSubject.asObservable();
         this.settings$ = this.settingsSubject.asObservable();
-        this.transcribing$ = this.transcribingSubject.asObservable();
         this.endedBy$ = this.endedBySubject.asObservable();
         this.thumbnails$ = this.thumbnailsSubject.asObservable();
+        /**
+         * Performs shallow comparison of two arrays.
+         * Expects primitive values: [1, 2, 3] is equal to [2, 1, 3].
+         */
+        const isShallowEqual = (a, b) => {
+            if (a.length !== b.length)
+                return false;
+            for (const item of a)
+                if (!b.includes(item))
+                    return false;
+            for (const item of b)
+                if (!a.includes(item))
+                    return false;
+            return true;
+        };
+        /**
+         * Creates an Observable from the given subject by piping to the
+         * `distinctUntilChanged()` operator.
+         */
+        const duc = (subject, comparator) => subject.asObservable().pipe(distinctUntilChanged(comparator));
+        // primitive values should only emit once the value they hold changes
+        this.anonymousParticipantCount$ = duc(this.anonymousParticipantCountSubject);
+        this.blockedUserIds$ = duc(this.blockedUserIdsSubject, isShallowEqual);
+        this.backstage$ = duc(this.backstageSubject);
+        this.callingState$ = duc(this.callingStateSubject);
+        this.ownCapabilities$ = duc(this.ownCapabilitiesSubject, isShallowEqual);
+        this.participantCount$ = duc(this.participantCountSubject);
+        this.recording$ = duc(this.recordingSubject);
+        this.transcribing$ = duc(this.transcribingSubject);
         this.eventHandlers = {
             // these events are not updating the call state:
             'call.closed_caption': undefined,
@@ -9490,7 +9513,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);
@@ -9644,7 +9667,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)
@@ -9740,8 +9763,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,
@@ -10714,7 +10737,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() {
@@ -10749,6 +10772,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;
@@ -10814,14 +10838,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) {
@@ -11015,13 +11042,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));
         }
     }
     /**
@@ -11076,8 +11107,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()
@@ -11089,7 +11120,8 @@ class CameraManagerState extends InputMediaDeviceManagerState {
         }
     }
     getDeviceIdFromStream(stream) {
-        return stream.getVideoTracks()[0]?.getSettings().deviceId;
+        const [track] = stream.getVideoTracks();
+        return track?.getSettings().deviceId;
     }
 }
 
@@ -11182,8 +11214,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');
@@ -11207,7 +11239,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;
     }
 }
 
@@ -11264,18 +11297,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() {
@@ -11358,20 +11379,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);
@@ -11383,7 +11408,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)
@@ -11478,6 +11503,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();
     }
@@ -11515,9 +11556,8 @@ class MicrophoneManager extends InputMediaDeviceManager {
         }
     }
     async stopSpeakingWhileMutedDetection() {
-        if (!this.soundDetectorCleanup) {
+        if (!this.soundDetectorCleanup)
             return;
-        }
         this.state.setSpeakingWhileMuted(false);
         try {
             await this.soundDetectorCleanup();
@@ -14842,7 +14882,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.7.9" ;
+            const version = "0.7.11" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };