@webex/web-client-media-engine 3.20.3 → 3.21.0

package/dist/cjs/index.js

@@ -2365,7 +2365,8 @@ exports.ConnectionState = void 0;
 })(exports.ConnectionState || (exports.ConnectionState = {}));
 var ConnectionStateEvents;
 (function (ConnectionStateEvents) {
-    ConnectionStateEvents["ConnectionStateChanged"] = "ConnectionStateChanged";
+    ConnectionStateEvents["PeerConnectionStateChanged"] = "PeerConnectionStateChanged";
+    ConnectionStateEvents["IceConnectionStateChanged"] = "IceConnectionStateChanged";
 })(ConnectionStateEvents || (ConnectionStateEvents = {}));
 /**
  * Listens on the connection's ICE and DTLS state changes and emits a single
@@ -2381,29 +2382,20 @@ class ConnectionStateHandler extends EventEmitter$4 {
     constructor(getCurrentStatesCallback) {
         super();
         this.getCurrentStatesCallback = getCurrentStatesCallback;
-        this.mediaConnectionState = this.evaluateMediaConnectionState();
     }
     /**
      * Handler for connection state change.
      */
-    onConnectionStateChange() {
-        this.handleAnyConnectionStateChange();
+    onPeerConnectionStateChange() {
+        const state = this.getPeerConnectionState();
+        this.emit(ConnectionStateEvents.PeerConnectionStateChanged, state);
     }
     /**
      * Handler for ice connection state change.
      */
     onIceConnectionStateChange() {
-        this.handleAnyConnectionStateChange();
-    }
-    /**
-     * Method to be called whenever ice connection or dtls connection state is changed.
-     */
-    handleAnyConnectionStateChange() {
-        const newConnectionState = this.evaluateMediaConnectionState();
-        if (newConnectionState !== this.mediaConnectionState) {
-            this.mediaConnectionState = newConnectionState;
-            this.emit(ConnectionStateEvents.ConnectionStateChanged, this.mediaConnectionState);
-        }
+        const state = this.getIceConnectionState();
+        this.emit(ConnectionStateEvents.IceConnectionStateChanged, state);
     }
     /**
      * Evaluates the overall connection state based on peer connection's
@@ -2441,8 +2433,26 @@ class ConnectionStateHandler extends EventEmitter$4 {
      *
      * @returns Current connection state.
      */
+    getPeerConnectionState() {
+        const { connectionState } = this.getCurrentStatesCallback();
+        return connectionState;
+    }
+    /**
+     * Gets current ice connection state.
+     *
+     * @returns Current ice connection state.
+     */
+    getIceConnectionState() {
+        const { iceState } = this.getCurrentStatesCallback();
+        return iceState;
+    }
+    /**
+     * Gets current overall connection state.
+     *
+     * @returns Current overall connection state.
+     */
     getConnectionState() {
-        return this.mediaConnectionState;
+        return this.evaluateMediaConnectionState();
     }
 }
 ConnectionStateHandler.Events = ConnectionStateEvents;
@@ -5824,7 +5834,8 @@ var PeerConnectionEvents;
 (function (PeerConnectionEvents) {
     PeerConnectionEvents["IceGatheringStateChange"] = "icegatheringstatechange";
     PeerConnectionEvents["IceCandidate"] = "icecandidate";
-    PeerConnectionEvents["ConnectionStateChange"] = "connectionstatechange";
+    PeerConnectionEvents["PeerConnectionStateChange"] = "peerconnectionstatechange";
+    PeerConnectionEvents["IceConnectionStateChange"] = "iceconnectionstatechange";
     PeerConnectionEvents["CreateOfferOnSuccess"] = "createofferonsuccess";
     PeerConnectionEvents["CreateAnswerOnSuccess"] = "createansweronsuccess";
     PeerConnectionEvents["SetLocalDescriptionOnSuccess"] = "setlocaldescriptiononsuccess";
@@ -5849,19 +5860,23 @@ class PeerConnection extends EventEmitter$4 {
                 iceState: this.pc.iceConnectionState,
             };
         });
-        this.connectionStateHandler.on(ConnectionStateHandler.Events.ConnectionStateChanged, (state) => {
-            this.emit(PeerConnection.Events.ConnectionStateChange, state);
+        this.connectionStateHandler.on(ConnectionStateHandler.Events.PeerConnectionStateChanged, (state) => {
+            this.emit(PeerConnection.Events.PeerConnectionStateChange, state);
+        });
+        this.connectionStateHandler.on(ConnectionStateHandler.Events.IceConnectionStateChanged, (state) => {
+            this.emit(PeerConnection.Events.IceConnectionStateChange, state);
         });
         // Forward the connection state related events to connection state handler
         // eslint-disable-next-line jsdoc/require-jsdoc
         this.pc.oniceconnectionstatechange = () => this.connectionStateHandler.onIceConnectionStateChange();
         // eslint-disable-next-line jsdoc/require-jsdoc
-        this.pc.onconnectionstatechange = () => this.connectionStateHandler.onConnectionStateChange();
+        this.pc.onconnectionstatechange = () => this.connectionStateHandler.onPeerConnectionStateChange();
         // Subscribe to underlying PeerConnection events and emit them via the EventEmitter
         /* eslint-disable jsdoc/require-jsdoc */
         this.pc.onicegatheringstatechange = (ev) => {
             this.emit(PeerConnection.Events.IceGatheringStateChange, ev);
         };
+        /* eslint-disable jsdoc/require-jsdoc */
         this.pc.onicecandidate = (ev) => {
             this.emit(PeerConnection.Events.IceCandidate, ev);
         };
@@ -5882,6 +5897,22 @@ class PeerConnection extends EventEmitter$4 {
     getConnectionState() {
         return this.connectionStateHandler.getConnectionState();
     }
+    /**
+     * Gets the connection state of the underlying RTCPeerConnection.
+     *
+     * @returns The underlying RTCPeerConnection connection state.
+     */
+    getPeerConnectionState() {
+        return this.connectionStateHandler.getPeerConnectionState();
+    }
+    /**
+     * Gets the ICE connection state of the underlying RTCPeerConnection.
+     *
+     * @returns The underlying RTCPeerConnection ICE connection state.
+     */
+    getIceConnectionState() {
+        return this.connectionStateHandler.getIceConnectionState();
+    }
     /**
      * Adds a new media track to the set of tracks which will be transmitted to the other peer.
      *
@@ -7919,6 +7950,7 @@ var rtcStats = function (pc, logger, intervalTime, statsPreProcessor) {
                 var args = arguments;
                 trace("on".concat(method), makeEvent(method === 'addIceCandidate' ? arguments[0] : arguments[0].sdp));
                 return nativeMethod.apply(this, [arguments[0]]).then(function () {
+                    var _a;
                     trace("on".concat(method, "OnSuccess"), makeEvent('success'));
                     if (method.endsWith('Description')) {
                         if (!_this.transportEventsPreviouslyAdded) {
@@ -7960,7 +7992,8 @@ var rtcStats = function (pc, logger, intervalTime, statsPreProcessor) {
                             }
                         }
                         if (!_this.sctpEventsPreviouslyAdded) {
-                            if (_this.sctp) {
+                            // Some Firefox versions prior to 113 have sctp defined but not the events, so check both here.
+                            if ((_a = _this.sctp) === null || _a === void 0 ? void 0 : _a.addEventListener) {
                                 _this.sctp.addEventListener('statechange', function () {
                                     trace('onsctpStateChange', makeEvent(_this.sctp.state));
                                 });
@@ -14700,7 +14733,8 @@ exports.MultistreamConnectionEventNames = void 0;
     MultistreamConnectionEventNames["VideoSourceCountUpdate"] = "video-source-count-update";
     MultistreamConnectionEventNames["AudioSourceCountUpdate"] = "audio-source-count-update";
     MultistreamConnectionEventNames["ActiveSpeakerNotification"] = "active-speaker-notification";
-    MultistreamConnectionEventNames["ConnectionStateUpdate"] = "connection-state-update";
+    MultistreamConnectionEventNames["PeerConnectionStateUpdate"] = "peer-connection-state-update";
+    MultistreamConnectionEventNames["IceConnectionStateUpdate"] = "ice-connection-state-update";
     MultistreamConnectionEventNames["IceGatheringStateUpdate"] = "ice-gathering-state-update";
     MultistreamConnectionEventNames["NegotiationNeeded"] = "negotiation-needed";
     MultistreamConnectionEventNames["CreateOfferOnSuccess"] = "createofferonsuccess";
@@ -14754,8 +14788,11 @@ class MultistreamConnection extends EventEmitter$2 {
         this.createDataChannel();
     }
     propagatePeerConnectionEvents() {
-        this.pc.on(PeerConnection.Events.ConnectionStateChange, (state) => {
-            this.emit(exports.MultistreamConnectionEventNames.ConnectionStateUpdate, state);
+        this.pc.on(PeerConnection.Events.PeerConnectionStateChange, (state) => {
+            this.emit(exports.MultistreamConnectionEventNames.PeerConnectionStateUpdate, state);
+        });
+        this.pc.on(PeerConnection.Events.IceConnectionStateChange, (state) => {
+            this.emit(exports.MultistreamConnectionEventNames.IceConnectionStateUpdate, state);
         });
         this.pc.on(PeerConnection.Events.CreateOfferOnSuccess, (description) => {
             this.emit(exports.MultistreamConnectionEventNames.CreateOfferOnSuccess, description);
@@ -14776,6 +14813,15 @@ class MultistreamConnection extends EventEmitter$2 {
     getConnectionState() {
         return this.pc.getConnectionState();
     }
+    getPeerConnectionState() {
+        return this.pc.getPeerConnectionState();
+    }
+    getIceConnectionState() {
+        return this.pc.getIceConnectionState();
+    }
+    getCurrentConnectionType() {
+        return this.pc.getCurrentConnectionType();
+    }
     getIceGatheringState() {
         return this.pc.iceGatheringState;
     }