@webex/web-client-media-engine 3.12.1 → 3.14.0

package/dist/cjs/index.js

@@ -1167,10 +1167,9 @@ function AddEvents(Base) {
     };
 }
 
-var _a$1$1, _b$1;
+var _a$2$1;
 exports.StreamEventNames = void 0;
 (function (StreamEventNames) {
-    StreamEventNames["MuteStateChange"] = "mute-state-change";
     StreamEventNames["Ended"] = "stream-ended";
 })(exports.StreamEventNames || (exports.StreamEventNames = {}));
 /**
@@ -1185,25 +1184,10 @@ class _Stream {
     constructor(stream) {
         // TODO: these should be protected, but we need the helper type in ts-events
         // to hide the 'emit' method from TypedEvent.
-        this[_a$1$1] = new TypedEvent$1();
-        this[_b$1] = new TypedEvent$1();
+        this[_a$2$1] = new TypedEvent$1();
         this.outputStream = stream;
-        this.handleTrackMuted = this.handleTrackMuted.bind(this);
-        this.handleTrackUnmuted = this.handleTrackUnmuted.bind(this);
         this.handleTrackEnded = this.handleTrackEnded.bind(this);
-        this.addTrackHandlers(this.outputTrack);
-    }
-    /**
-     * Handler which is called when a track's mute event fires.
-     */
-    handleTrackMuted() {
-        this[exports.StreamEventNames.MuteStateChange].emit(true);
-    }
-    /**
-     * Handler which is called when a track's unmute event fires.
-     */
-    handleTrackUnmuted() {
-        this[exports.StreamEventNames.MuteStateChange].emit(false);
+        this.addTrackHandlersForStreamEvents(this.outputTrack);
     }
     /**
      * Handler which is called when a track's ended event fires.
@@ -1211,15 +1195,25 @@ class _Stream {
     handleTrackEnded() {
         this[exports.StreamEventNames.Ended].emit();
     }
+    /**
+     * Helper function to add event handlers to a MediaStreamTrack. Unlike the virtual
+     * {@link addTrackHandlers} function, which can be overridden, this function is internal to this
+     * class and will only add the event handlers relevant to this class. It prevents, for example,
+     * accidentally adding the same event handlers multiple times, which could happen if the virtual
+     * `addTrackHandlers` method was called from a subclass's constructor.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlersForStreamEvents(track) {
+        track.addEventListener('ended', this.handleTrackEnded);
+    }
     /**
      * Add event handlers to a MediaStreamTrack.
      *
      * @param track - The MediaStreamTrack.
      */
     addTrackHandlers(track) {
-        track.addEventListener('mute', this.handleTrackMuted);
-        track.addEventListener('unmute', this.handleTrackUnmuted);
-        track.addEventListener('ended', this.handleTrackEnded);
+        this.addTrackHandlersForStreamEvents(track);
     }
     /**
      * Remove event handlers from a MediaStreamTrack.
@@ -1227,8 +1221,6 @@ class _Stream {
      * @param track - The MediaStreamTrack.
      */
     removeTrackHandlers(track) {
-        track.removeEventListener('mute', this.handleTrackMuted);
-        track.removeEventListener('unmute', this.handleTrackUnmuted);
         track.removeEventListener('ended', this.handleTrackEnded);
     }
     /**
@@ -1248,12 +1240,14 @@ class _Stream {
         return this.outputStream.getTracks()[0];
     }
 }
-_a$1$1 = exports.StreamEventNames.MuteStateChange, _b$1 = exports.StreamEventNames.Ended;
+_a$2$1 = exports.StreamEventNames.Ended;
 const Stream = AddEvents(_Stream);
 
-var _a$6, _b, _c;
+var _a$1$1, _b, _c, _d, _e;
 exports.LocalStreamEventNames = void 0;
 (function (LocalStreamEventNames) {
+    LocalStreamEventNames["UserMuteStateChange"] = "user-mute-state-change";
+    LocalStreamEventNames["SystemMuteStateChange"] = "system-mute-state-change";
     LocalStreamEventNames["ConstraintsChange"] = "constraints-change";
     LocalStreamEventNames["OutputTrackChange"] = "output-track-change";
     LocalStreamEventNames["EffectAdded"] = "effect-added";
@@ -1269,12 +1263,54 @@ class _LocalStream extends Stream {
      */
     constructor(stream) {
         super(stream);
-        this[_a$6] = new TypedEvent$1();
+        this[_a$1$1] = new TypedEvent$1();
         this[_b] = new TypedEvent$1();
         this[_c] = new TypedEvent$1();
+        this[_d] = new TypedEvent$1();
+        this[_e] = new TypedEvent$1();
         this.effects = [];
         this.loadingEffects = new Map();
         this.inputStream = stream;
+        this.handleTrackMutedBySystem = this.handleTrackMutedBySystem.bind(this);
+        this.handleTrackUnmutedBySystem = this.handleTrackUnmutedBySystem.bind(this);
+        this.addTrackHandlersForLocalStreamEvents(this.inputTrack);
+    }
+    /**
+     * Handler which is called when a track's mute event fires.
+     */
+    handleTrackMutedBySystem() {
+        this[exports.LocalStreamEventNames.SystemMuteStateChange].emit(true);
+    }
+    /**
+     * Handler which is called when a track's unmute event fires.
+     */
+    handleTrackUnmutedBySystem() {
+        this[exports.LocalStreamEventNames.SystemMuteStateChange].emit(false);
+    }
+    /**
+     * Helper function to add event handlers to a MediaStreamTrack. See
+     * {@link Stream.addTrackHandlersForStreamEvents} for why this is useful.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlersForLocalStreamEvents(track) {
+        track.addEventListener('mute', this.handleTrackMutedBySystem);
+        track.addEventListener('unmute', this.handleTrackUnmutedBySystem);
+    }
+    /**
+     * @inheritdoc
+     */
+    addTrackHandlers(track) {
+        super.addTrackHandlers(track);
+        this.addTrackHandlersForLocalStreamEvents(track);
+    }
+    /**
+     * @inheritdoc
+     */
+    removeTrackHandlers(track) {
+        super.removeTrackHandlers(track);
+        track.removeEventListener('mute', this.handleTrackMutedBySystem);
+        track.removeEventListener('unmute', this.handleTrackUnmutedBySystem);
     }
     /**
      * Get the track within the MediaStream with which this LocalStream was created.
@@ -1286,42 +1322,45 @@ class _LocalStream extends Stream {
         return this.inputStream.getTracks()[0];
     }
     /**
-     * @inheritdoc
+     * Check whether or not this stream is muted. This considers both whether the stream has been
+     * muted by the user (see {@link userMuted}) and whether the stream has been muted by the system
+     * (see {@link systemMuted}).
+     *
+     * @returns True if the stream is muted, false otherwise.
      */
-    handleTrackMuted() {
-        if (this.inputTrack.enabled) {
-            super.handleTrackMuted();
-        }
+    get muted() {
+        return this.userMuted || this.systemMuted;
     }
     /**
-     * @inheritdoc
+     * Check whether or not this stream has been muted by the user. This is equivalent to checking the
+     * MediaStreamTrack "enabled" state.
+     *
+     * @returns True if the stream has been muted by the user, false otherwise.
      */
-    handleTrackUnmuted() {
-        if (this.inputTrack.enabled) {
-            super.handleTrackUnmuted();
-        }
+    get userMuted() {
+        return !this.inputTrack.enabled;
     }
     /**
-     * @inheritdoc
+     * Check whether or not this stream has been muted by the user. This is equivalent to checking the
+     * MediaStreamTrack "muted" state.
+     *
+     * @returns True if the stream has been muted by the system, false otherwise.
      */
-    get muted() {
-        // Calls to `setMuted` will only affect the "enabled" state, but there are specific cases in
-        // which the browser may mute the track, which will affect the "muted" state but not the
-        // "enabled" state, e.g. minimizing a shared window or unplugging a shared screen.
-        return !this.inputTrack.enabled || this.inputTrack.muted;
+    get systemMuted() {
+        return this.inputTrack.muted;
     }
     /**
-     * Set the mute state of this stream.
+     * Set the user mute state of this stream.
+     *
+     * Note: This sets the user-toggled mute state, equivalent to changing the "enabled" state of the
+     * track. It is separate from the system-toggled mute state.
      *
      * @param isMuted - True to mute, false to unmute.
      */
-    setMuted(isMuted) {
+    setUserMuted(isMuted) {
         if (this.inputTrack.enabled === isMuted) {
             this.inputTrack.enabled = !isMuted;
-            // setting `enabled` will not automatically emit MuteStateChange, so we emit it here
-            if (!this.inputTrack.muted) {
-                this[exports.StreamEventNames.MuteStateChange].emit(isMuted);
-            }
+            this[exports.LocalStreamEventNames.UserMuteStateChange].emit(isMuted);
         }
     }
     /**
@@ -1411,13 +1450,13 @@ class _LocalStream extends Stream {
              * @param track - The new output track of the effect.
              */
             const handleEffectTrackUpdated = (track) => {
-                var _d;
+                var _f;
                 const effectIndex = this.effects.findIndex((e) => e.id === effect.id);
                 if (effectIndex === this.effects.length - 1) {
                     this.changeOutputTrack(track);
                 }
                 else if (effectIndex >= 0) {
-                    (_d = this.effects[effectIndex + 1]) === null || _d === void 0 ? void 0 : _d.replaceInputTrack(track);
+                    (_f = this.effects[effectIndex + 1]) === null || _f === void 0 ? void 0 : _f.replaceInputTrack(track);
                 }
                 else {
                     logger$3.error(`Effect with ID ${effect.id} not found in effects list.`);
@@ -1535,7 +1574,7 @@ class _LocalStream extends Stream {
         });
     }
 }
-_a$6 = exports.LocalStreamEventNames.ConstraintsChange, _b = exports.LocalStreamEventNames.OutputTrackChange, _c = exports.LocalStreamEventNames.EffectAdded;
+_a$1$1 = exports.LocalStreamEventNames.UserMuteStateChange, _b = exports.LocalStreamEventNames.SystemMuteStateChange, _c = exports.LocalStreamEventNames.ConstraintsChange, _d = exports.LocalStreamEventNames.OutputTrackChange, _e = exports.LocalStreamEventNames.EffectAdded;
 const LocalStream = AddEvents(_LocalStream);
 
 /**
@@ -1637,15 +1676,77 @@ class LocalMicrophoneStream extends LocalAudioStream {
 class LocalSystemAudioStream extends LocalAudioStream {
 }
 
+var _a$6;
+exports.RemoteMediaState = void 0;
+(function (RemoteMediaState) {
+    RemoteMediaState["Started"] = "started";
+    RemoteMediaState["Stopped"] = "stopped";
+})(exports.RemoteMediaState || (exports.RemoteMediaState = {}));
+exports.RemoteStreamEventNames = void 0;
+(function (RemoteStreamEventNames) {
+    RemoteStreamEventNames["MediaStateChange"] = "media-state-change";
+})(exports.RemoteStreamEventNames || (exports.RemoteStreamEventNames = {}));
 /**
  * A stream originating from a remote peer.
  */
-class RemoteStream extends Stream {
+class _RemoteStream extends Stream {
+    /**
+     * Create a RemoteStream from the given values.
+     *
+     * @param stream - The initial output MediaStream for this Stream.
+     */
+    constructor(stream) {
+        super(stream);
+        this[_a$6] = new TypedEvent$1();
+        this.handleMediaStarted = this.handleMediaStarted.bind(this);
+        this.handleMediaStopped = this.handleMediaStopped.bind(this);
+        this.outputTrack.addEventListener('mute', this.handleMediaStopped);
+        this.outputTrack.addEventListener('unmute', this.handleMediaStarted);
+    }
     /**
      * @inheritdoc
      */
-    get muted() {
-        return !this.outputTrack.enabled;
+    handleMediaStarted() {
+        this[exports.RemoteStreamEventNames.MediaStateChange].emit(exports.RemoteMediaState.Started);
+    }
+    /**
+     * @inheritdoc
+     */
+    handleMediaStopped() {
+        this[exports.RemoteStreamEventNames.MediaStateChange].emit(exports.RemoteMediaState.Stopped);
+    }
+    /**
+     * Helper function to add event handlers to a MediaStreamTrack. See
+     * {@link Stream.addTrackHandlersForStreamEvents} for why this is useful.
+     *
+     * @param track - The MediaStreamTrack.
+     */
+    addTrackHandlersForRemoteStreamEvents(track) {
+        track.addEventListener('mute', this.handleMediaStopped);
+        track.addEventListener('unmute', this.handleMediaStarted);
+    }
+    /**
+     * @inheritdoc
+     */
+    addTrackHandlers(track) {
+        super.addTrackHandlers(track);
+        this.addTrackHandlersForRemoteStreamEvents(track);
+    }
+    /**
+     * @inheritdoc
+     */
+    removeTrackHandlers(track) {
+        super.removeTrackHandlers(track);
+        track.removeEventListener('mute', this.handleMediaStopped);
+        track.removeEventListener('unmute', this.handleMediaStarted);
+    }
+    /**
+     * Get whether the media on this stream has started or stopped.
+     *
+     * @returns The state of the media.
+     */
+    get mediaState() {
+        return this.outputTrack.muted ? exports.RemoteMediaState.Stopped : exports.RemoteMediaState.Started;
     }
     /**
      * @inheritdoc
@@ -1664,6 +1765,14 @@ class RemoteStream extends Stream {
         this.outputStream.removeTrack(oldTrack);
         this.outputStream.addTrack(newTrack);
         this.addTrackHandlers(newTrack);
+        if (oldTrack.muted !== newTrack.muted) {
+            if (newTrack.muted) {
+                this.handleMediaStopped();
+            }
+            else {
+                this.handleMediaStarted();
+            }
+        }
         // TODO: Chrome/React may not automatically refresh the media element with the new track when
         // the output track has changed, so we may need to emit an event here if this is the case.
         // this[StreamEventNames.OutputTrackChange].emit(newTrack);
@@ -1676,7 +1785,9 @@ class RemoteStream extends Stream {
         // calling stop() will not automatically emit Ended, so we emit it here
         this[exports.StreamEventNames.Ended].emit();
     }
-}
+}
+_a$6 = exports.RemoteStreamEventNames.MediaStateChange;
+const RemoteStream = AddEvents(_RemoteStream);
 
 var commonjsGlobal$3 = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -10280,15 +10391,15 @@ class ReceiveSlot extends EventEmitter$2 {
     constructor(idGetter, track) {
         super();
         this._idGetter = idGetter;
-        this.handleStreamMuteStateChange = this.handleStreamMuteStateChange.bind(this);
+        this.handleStreamMediaStateChange = this.handleStreamMediaStateChange.bind(this);
         this.handleStreamEnded = this.handleStreamEnded.bind(this);
         this._stream = new RemoteStream(new MediaStream([track]));
         this._sourceState = 'no source';
-        this._stream.on(exports.StreamEventNames.MuteStateChange, this.handleStreamMuteStateChange);
+        this._stream.on(exports.RemoteStreamEventNames.MediaStateChange, this.handleStreamMediaStateChange);
         this._stream.on(exports.StreamEventNames.Ended, this.handleStreamEnded);
     }
-    handleStreamMuteStateChange(muted) {
-        if (muted) {
+    handleStreamMediaStateChange(state) {
+        if (state === exports.RemoteMediaState.Stopped) {
             this.emit(exports.ReceiveSlotEvents.MediaStopped);
         }
         else {
@@ -10309,7 +10420,7 @@ class ReceiveSlot extends EventEmitter$2 {
         }
     }
     close() {
-        this._stream.off(exports.StreamEventNames.MuteStateChange, this.handleStreamMuteStateChange);
+        this._stream.off(exports.RemoteStreamEventNames.MediaStateChange, this.handleStreamMediaStateChange);
         this._stream.off(exports.StreamEventNames.Ended, this.handleStreamEnded);
     }
     get id() {
@@ -14157,14 +14268,16 @@ class SendOnlyTransceiver extends Transceiver {
             const oldStream = this.publishedStream;
             oldStream === null || oldStream === void 0 ? void 0 : oldStream.off(exports.LocalStreamEventNames.OutputTrackChange, this.handleTrackChange);
             oldStream === null || oldStream === void 0 ? void 0 : oldStream.off(exports.LocalStreamEventNames.ConstraintsChange, this.handleStreamConstraintsChange);
-            oldStream === null || oldStream === void 0 ? void 0 : oldStream.off(exports.StreamEventNames.MuteStateChange, this.handleStreamMuteStateChange);
+            oldStream === null || oldStream === void 0 ? void 0 : oldStream.off(exports.LocalStreamEventNames.UserMuteStateChange, this.handleStreamMuteStateChange);
+            oldStream === null || oldStream === void 0 ? void 0 : oldStream.off(exports.LocalStreamEventNames.SystemMuteStateChange, this.handleStreamMuteStateChange);
             if (this.requested) {
                 yield this.replaceSenderSource(newStream);
             }
             this.publishedStream = newStream;
             newStream === null || newStream === void 0 ? void 0 : newStream.on(exports.LocalStreamEventNames.OutputTrackChange, this.handleTrackChange);
             newStream === null || newStream === void 0 ? void 0 : newStream.on(exports.LocalStreamEventNames.ConstraintsChange, this.handleStreamConstraintsChange);
-            newStream === null || newStream === void 0 ? void 0 : newStream.on(exports.StreamEventNames.MuteStateChange, this.handleStreamMuteStateChange);
+            newStream === null || newStream === void 0 ? void 0 : newStream.on(exports.LocalStreamEventNames.UserMuteStateChange, this.handleStreamMuteStateChange);
+            newStream === null || newStream === void 0 ? void 0 : newStream.on(exports.LocalStreamEventNames.SystemMuteStateChange, this.handleStreamMuteStateChange);
             if ((!oldStream && newStream && !newStream.muted) ||
                 (oldStream && !newStream && !oldStream.muted)) {
                 this.streamPublishStateChange.emit();
@@ -14228,6 +14341,22 @@ class SendOnlyTransceiver extends Transceiver {
             }));
         });
     }
+    getRequestedBitrate(ssrc) {
+        const index = this.senderIds.findIndex((streamId) => streamId.ssrc === ssrc);
+        if (this.requestedIdEncodingParamsMap.has(index)) {
+            const encodingParams = this.requestedIdEncodingParamsMap.get(index);
+            return encodingParams === null || encodingParams === void 0 ? void 0 : encodingParams.maxPayloadBitsPerSecond;
+        }
+        return undefined;
+    }
+    getRequestedFrameSize(ssrc) {
+        const index = this.senderIds.findIndex((streamId) => streamId.ssrc === ssrc);
+        if (this.requestedIdEncodingParamsMap.has(index)) {
+            const encodingParams = this.requestedIdEncodingParamsMap.get(index);
+            return encodingParams === null || encodingParams === void 0 ? void 0 : encodingParams.maxFs;
+        }
+        return undefined;
+    }
     isSimulcastEnabled() {
         const params = this.sender.getParameters();
         return params.encodings.length > 1;
@@ -15063,6 +15192,17 @@ class MultistreamConnection extends EventEmitter$2 {
                 }
             });
             jmpSession.sendRequests(streamRequests.map((sr) => sr._toJmpStreamRequest()));
+            streamRequests.forEach((sr) => {
+                var _a;
+                const isAffectedInStreamRequest = (t) => sr.receiveSlots.some((rs) => rs.id && compareStreamIds(rs.id, t.receiverId));
+                const affectedTransceivers = (_a = this.recvTransceivers
+                    .get(mediaType)) === null || _a === void 0 ? void 0 : _a.filter(isAffectedInStreamRequest);
+                affectedTransceivers === null || affectedTransceivers === void 0 ? void 0 : affectedTransceivers.forEach((t) => {
+                    var _a, _b;
+                    t.requestedBitrate = sr.maxPayloadBitsPerSecond;
+                    t.requestedFrameSize = (_b = (_a = sr.codecInfos[0]) === null || _a === void 0 ? void 0 : _a.h264) === null || _b === void 0 ? void 0 : _b.maxFs;
+                });
+            });
         };
         if (((_a = this.dataChannel) === null || _a === void 0 ? void 0 : _a.readyState) === 'open') {
             task();
@@ -15135,6 +15275,8 @@ class MultistreamConnection extends EventEmitter$2 {
                         statsToModify.mid = transceiver.mid;
                         statsToModify.csi = transceiver.csi;
                         statsToModify.calliopeMediaType = mediaType;
+                        statsToModify.requestedBitrate = transceiver.getRequestedBitrate(senderStats.ssrc);
+                        statsToModify.requestedFrameSize = transceiver.getRequestedFrameSize(senderStats.ssrc);
                         const trackSettings = (_a = transceiver.publishedStream) === null || _a === void 0 ? void 0 : _a.getSettings();
                         if (trackSettings === null || trackSettings === void 0 ? void 0 : trackSettings.frameRate) {
                             statsToModify.targetFrameRate = trackSettings === null || trackSettings === void 0 ? void 0 : trackSettings.frameRate;
@@ -15157,6 +15299,8 @@ class MultistreamConnection extends EventEmitter$2 {
                             statsToModify.mid = (_a = transceiver.receiveSlot.id) === null || _a === void 0 ? void 0 : _a.mid;
                             statsToModify.csi = transceiver.receiveSlot.currentRxCsi;
                             statsToModify.calliopeMediaType = mediaType;
+                            statsToModify.requestedBitrate = transceiver.requestedBitrate;
+                            statsToModify.requestedFrameSize = transceiver.requestedFrameSize;
                             Object.assign(statsToModify, transceiver.receiverId);
                             stats.set(receiverStats.id, statsToModify);
                         }