@stream-io/video-client 0.7.10 → 0.7.12

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [0.7.12](https://github.com/GetStream/stream-video-js/compare/@stream-io/video-client-0.7.11...@stream-io/video-client-0.7.12) (2024-05-03)
+
+
+### Features
+
+* support target_resolution backend setting for screensharing ([#1336](https://github.com/GetStream/stream-video-js/issues/1336)) ([1e9f796](https://github.com/GetStream/stream-video-js/commit/1e9f7963009ac7fc27ee24abc00eb68749cc19d8))
+
+### [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)
 
 

package/dist/index.browser.es.js

@@ -6420,7 +6420,7 @@ const withSimulcastConstraints = (settings, optimalVideoLayers) => {
         rid: ridMapping[index], // reassign rid
     }));
 };
-const findOptimalScreenSharingLayers = (videoTrack, preferences) => {
+const findOptimalScreenSharingLayers = (videoTrack, preferences, defaultMaxBitrate = 3000000) => {
     const settings = videoTrack.getSettings();
     return [
         {
@@ -6429,7 +6429,7 @@ const findOptimalScreenSharingLayers = (videoTrack, preferences) => {
             width: settings.width || 0,
             height: settings.height || 0,
             scaleResolutionDownBy: 1,
-            maxBitrate: preferences?.maxBitrate ?? 3000000,
+            maxBitrate: preferences?.maxBitrate ?? defaultMaxBitrate,
             maxFramerate: preferences?.maxFramerate ?? 30,
         },
     ];
@@ -7937,10 +7937,11 @@ class Publisher {
             if (!transceiver) {
                 const { settings } = this.state;
                 const targetResolution = settings?.video.target_resolution;
+                const screenShareBitrate = settings?.screensharing.target_resolution?.bitrate;
                 const videoEncodings = trackType === TrackType.VIDEO
                     ? findOptimalVideoLayers(track, targetResolution)
                     : trackType === TrackType.SCREEN_SHARE
-                        ? findOptimalScreenSharingLayers(track, opts.screenShareSettings)
+                        ? findOptimalScreenSharingLayers(track, opts.screenShareSettings, screenShareBitrate)
                         : undefined;
                 let preferredCodec = opts.preferredCodec;
                 if (!preferredCodec && trackType === TrackType.VIDEO) {
@@ -9513,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);
@@ -9667,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)
@@ -9763,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,
@@ -10737,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() {
@@ -10772,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;
@@ -10837,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) {
@@ -11038,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));
         }
     }
     /**
@@ -11099,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()
@@ -11112,7 +11121,8 @@ class CameraManagerState extends InputMediaDeviceManagerState {
         }
     }
     getDeviceIdFromStream(stream) {
-        return stream.getVideoTracks()[0]?.getSettings().deviceId;
+        const [track] = stream.getVideoTracks();
+        return track?.getSettings().deviceId;
     }
 }
 
@@ -11205,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');
@@ -11230,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;
     }
 }
 
@@ -11287,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() {
@@ -11381,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);
@@ -11406,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)
@@ -11501,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();
     }
@@ -11538,9 +11557,8 @@ class MicrophoneManager extends InputMediaDeviceManager {
         }
     }
     async stopSpeakingWhileMutedDetection() {
-        if (!this.soundDetectorCleanup) {
+        if (!this.soundDetectorCleanup)
             return;
-        }
         this.state.setSpeakingWhileMuted(false);
         try {
             await this.soundDetectorCleanup();
@@ -11605,6 +11623,17 @@ class ScreenShareState extends InputMediaDeviceManagerState {
 class ScreenShareManager extends InputMediaDeviceManager {
     constructor(call) {
         super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
+        this.subscriptions.push(createSubscription(call.state.settings$, (settings) => {
+            const maybeTargetResolution = settings?.screensharing.target_resolution;
+            if (maybeTargetResolution) {
+                this.setDefaultConstraints({
+                    video: {
+                        width: maybeTargetResolution.width,
+                        height: maybeTargetResolution.height,
+                    },
+                });
+            }
+        }));
     }
     /**
      * Will enable screen share audio options on supported platforms.
@@ -14865,7 +14894,7 @@ class StreamClient {
             });
         };
         this.getUserAgent = () => {
-            const version = "0.7.10" ;
+            const version = "0.7.12" ;
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };