@webex/web-client-media-engine 1.39.0 → 1.40.0

package/dist/cjs/index.js

@@ -978,6 +978,10 @@ exports.LocalTrackEvents = void 0;
      * Fires when there has been a change in the underlying track.
      */
     LocalTrackEvents["UnderlyingTrackChange"] = "underlying-track-change";
+    /**
+     * Fires when the applyConstraints() has been called for the track.
+     */
+    LocalTrackEvents["TrackConstraintsChange"] = "track-constraints-change";
 })(exports.LocalTrackEvents || (exports.LocalTrackEvents = {}));
 // TBD: Fix this once types are published separately
 // export type TrackEffect = BaseMicrophoneEffect | BaseCameraEffect;
@@ -1151,7 +1155,7 @@ class LocalTrack extends EventEmitter$2 {
         return effect;
     }
     /**
-     * Cleanup local microphone track.
+     * Cleanup the local microphone track.
      */
     disposeEffects() {
         if (this.effects.size > 0) {
@@ -1161,6 +1165,59 @@ class LocalTrack extends EventEmitter$2 {
             this.emit(exports.LocalTrackEvents.UnderlyingTrackChange);
         }
     }
+    /**
+     * Apply constraints to the track.
+     *
+     * @param constraints - The constraints to apply to the track.
+     * @returns A promise which resolves when the constraints have been successfully applied.
+     */
+    applyConstraints(constraints) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+            logger$3.log(`Applying constraints to local track:`, constraints);
+            const ret = this.underlyingTrack.applyConstraints(constraints).then(() => {
+                this.emit(exports.LocalTrackEvents.TrackConstraintsChange);
+            });
+            return ret;
+        });
+    }
+    /**
+     * Get the current constraints of the track.
+     *
+     * @returns The constraints of the track.
+     */
+    getConstraints() {
+        return this.underlyingTrack.getConstraints();
+    }
+    /**
+     * Get the current settings of the track.
+     *
+     * @returns The settings of the track.
+     */
+    getSettings() {
+        return this.underlyingTrack.getSettings();
+    }
+    /**
+     * Check the resolution and then return how many layers will be active.
+     *
+     * @returns The active layers count.
+     */
+    getNumActiveSimulcastLayers() {
+        let activeSimulcastLayersNumber = 0;
+        if (this.trackState.type === 'audio') {
+            return activeSimulcastLayersNumber;
+        }
+        const videoHeight = this.underlyingTrack.getSettings().height;
+        if (videoHeight <= 180) {
+            activeSimulcastLayersNumber = 1;
+        }
+        else if (videoHeight <= 360) {
+            activeSimulcastLayersNumber = 2;
+        }
+        else {
+            activeSimulcastLayersNumber = 3;
+        }
+        return activeSimulcastLayersNumber;
+    }
 }
 LocalTrack.Events = exports.LocalTrackEvents;
 
@@ -1204,7 +1261,10 @@ class WcmeError {
     }
 }
 /**
- * Creates a camera video track.
+ * Creates a camera video track. Please note that the constraint params in second getUserMedia call would NOT take effect when:
+ *
+ * 1. Previous captured video track from the same device is not stopped .
+ * 2. Previous createCameraTrack() call for the same device is in progress.
  *
  * @param constraints - Video device constraints.
  * @returns A LocalTrack object or an error.
@@ -4995,6 +5055,44 @@ class PeerConnection extends EventEmitter$2 {
     get iceGatheringState() {
         return this.pc.iceGatheringState;
     }
+    /**
+     * Returns the type of a connection that has been established.
+     *
+     * @returns The connection type which would be `ConnectionType`.
+     */
+    getCurrentConnectionType() {
+        var _a;
+        return __awaiter$1(this, void 0, void 0, function* () {
+            // make sure this method only can be called when the ice connection is established;
+            const isIceConnected = this.pc.iceConnectionState === 'connected' || this.pc.iceConnectionState === 'completed';
+            if (!isIceConnected) {
+                throw new Error('Ice connection is not established');
+            }
+            const succeededLocalCandidateIds = new Set();
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const localCandidateStatsReports = [];
+            (yield this.pc.getStats()).forEach((report) => {
+                var _a;
+                // collect all local candidate ids from `candidate-pair` stats reports with `succeeded` state.
+                if (report.type === 'candidate-pair' && ((_a = report.state) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'succeeded') {
+                    succeededLocalCandidateIds.add(report.localCandidateId);
+                }
+                // collect all `local-candidate` stats.
+                if (report.type === 'local-candidate') {
+                    localCandidateStatsReports.push(report);
+                }
+            });
+            // find the `local-candidate` stats which report id contains in `succeededLocalCandidateIds`.
+            const localCandidate = localCandidateStatsReports.find((report) => succeededLocalCandidateIds.has(report.id));
+            if (!localCandidate) {
+                return 'unknown';
+            }
+            if (localCandidate.relayProtocol) {
+                return `TURN-${localCandidate.relayProtocol.toUpperCase()}`;
+            }
+            return (_a = localCandidate.protocol) === null || _a === void 0 ? void 0 : _a.toUpperCase();
+        });
+    }
 }
 PeerConnection.Events = PeerConnectionEvents;
 
@@ -9604,6 +9702,10 @@ const defaultMultistreamConnectionOptions = {
     enableMainAudio: true,
     enableMainVideo: true,
 };
+const defaultVideoCodecParameters = {
+    'max-mbps': `${defaultMaxVideoEncodeMbps}`,
+    'max-fs': `${defaultMaxVideoEncodeFrameSize}`,
+};
 class MultistreamConnection extends EventEmitter {
     constructor(userOptions = {}) {
         var _a, _b;
@@ -9614,6 +9716,7 @@ class MultistreamConnection extends EventEmitter {
         this.pendingJmpTasks = [];
         this.metricsCallback = () => { };
         this.overuseUpdateCallback = () => { };
+        this.customCodecParameters = new Map();
         this.midMap = new Map();
         this.currentMid = 0;
         this.options = Object.assign(Object.assign({}, defaultMultistreamConnectionOptions), userOptions);
@@ -9626,6 +9729,7 @@ class MultistreamConnection extends EventEmitter {
         const mainSceneId = generateSceneId();
         const videoMainEncodingOptions = this.getVideoEncodingOptions(MediaContent.Main);
         this.createSendTransceiver(MediaType.VideoMain, mainSceneId, videoMainEncodingOptions);
+        this.setCodecParameters(MediaType.VideoMain, defaultVideoCodecParameters);
         this.createSendTransceiver(MediaType.AudioMain, mainSceneId);
         (_a = this.sendTransceivers.get(MediaType.VideoMain)) === null || _a === void 0 ? void 0 : _a.setActive(this.options.enableMainVideo);
         (_b = this.sendTransceivers.get(MediaType.AudioMain)) === null || _b === void 0 ? void 0 : _b.setActive(this.options.enableMainAudio);
@@ -9633,6 +9737,7 @@ class MultistreamConnection extends EventEmitter {
             const videoPresentationEncodingOptions = this.getVideoEncodingOptions(MediaContent.Slides);
             const contentSceneId = generateSceneId();
             this.createSendTransceiver(MediaType.VideoSlides, contentSceneId, videoPresentationEncodingOptions);
+            this.setCodecParameters(MediaType.VideoSlides, defaultVideoCodecParameters);
             this.createSendTransceiver(MediaType.AudioSlides, contentSceneId);
         }
     }
@@ -9997,20 +10102,7 @@ class MultistreamConnection extends EventEmitter {
                 return ingressSignaler.getReceiverId();
             });
             if (this.pc.getRemoteDescription()) {
-                yield this.pc
-                    .createOffer()
-                    .then((offer) => {
-                    if (!offer.sdp) {
-                        throw new Error('No SDP offer');
-                    }
-                    offer.sdp = this.preProcessLocalOffer(offer.sdp);
-                    return this.pc.setLocalDescription(offer);
-                })
-                    .then(() => {
-                    var _a;
-                    const answer = this.preProcessRemoteAnswer((_a = this.pc.getRemoteDescription()) === null || _a === void 0 ? void 0 : _a.sdp);
-                    return this.pc.setRemoteDescription({ type: 'answer', sdp: answer });
-                });
+                yield this.doLocalOfferAnswer();
             }
             this.recvTransceivers.set(mediaType, [
                 ...(this.recvTransceivers.get(mediaType) || []),
@@ -10076,8 +10168,26 @@ class MultistreamConnection extends EventEmitter {
     }
     setAnswer(answer) {
         return __awaiter(this, void 0, void 0, function* () {
+            const isInitialAnswer = !this.pc.getRemoteDescription();
             const sdp = this.preProcessRemoteAnswer(answer);
-            return this.pc.setRemoteDescription({ type: 'answer', sdp });
+            return this.pc.setRemoteDescription({ type: 'answer', sdp }).then(() => {
+                if (isInitialAnswer && this.customCodecParameters.size > 0) {
+                    this.doLocalOfferAnswer();
+                }
+            });
+        });
+    }
+    doLocalOfferAnswer() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const offer = yield this.pc.createOffer();
+            if (!offer.sdp) {
+                throw new Error('No SDP offer');
+            }
+            offer.sdp = this.preProcessLocalOffer(offer.sdp);
+            yield this.pc.setLocalDescription(offer);
+            const answer = this.preProcessRemoteAnswer((_a = this.pc.getRemoteDescription()) === null || _a === void 0 ? void 0 : _a.sdp);
+            return this.pc.setRemoteDescription({ type: 'answer', sdp: answer });
         });
     }
     enableMultistreamAudio(enabled) {
@@ -10104,12 +10214,20 @@ class MultistreamConnection extends EventEmitter {
             const simulcastEnabled = !!av.simulcast;
             const rtxEnabled = av.type === 'video';
             egressSignaler.signalStreams(simulcastEnabled, rtxEnabled, av);
-            if (av.type === 'video') {
+            const mediaType = [...this.sendTransceivers.keys()].find((key) => { var _a; return ((_a = this.sendTransceivers.get(key)) === null || _a === void 0 ? void 0 : _a.mid) === av.mid; });
+            if (mediaType && this.customCodecParameters.has(mediaType)) {
                 [...av.codecs.values()]
-                    .filter((ci) => ci.name === 'H264')
+                    .filter((ci) => ci.name === (av.type === 'audio' ? 'opus' : 'H264'))
                     .forEach((ci) => {
-                    ci.fmtParams.set('max-mbps', `${defaultMaxVideoEncodeMbps}`);
-                    ci.fmtParams.set('max-fs', `${defaultMaxVideoEncodeFrameSize}`);
+                    var _a;
+                    (_a = this.customCodecParameters.get(mediaType)) === null || _a === void 0 ? void 0 : _a.forEach((value, param) => {
+                        if (value === null) {
+                            ci.fmtParams.delete(param);
+                        }
+                        else {
+                            ci.fmtParams.set(param, `${value}`);
+                        }
+                    });
                 });
             }
         });
@@ -10165,6 +10283,30 @@ class MultistreamConnection extends EventEmitter {
             .map((transceiver) => transceiver.publishedTrack)
             .filter(Boolean);
     }
+    setCodecParameters(mediaType, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentParams = this.customCodecParameters.get(mediaType) || new Map();
+            Object.entries(parameters).forEach(([param, value]) => {
+                currentParams.set(param, value);
+            });
+            this.customCodecParameters.set(mediaType, currentParams);
+            if (this.pc.getRemoteDescription()) {
+                yield this.doLocalOfferAnswer();
+            }
+        });
+    }
+    deleteCodecParameters(mediaType, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentParams = this.customCodecParameters.get(mediaType) || new Map();
+            parameters.forEach((param) => {
+                currentParams.set(param, null);
+            });
+            this.customCodecParameters.set(mediaType, currentParams);
+            if (this.pc.getRemoteDescription()) {
+                yield this.doLocalOfferAnswer();
+            }
+        });
+    }
     requestMedia(mediaType, mediaRequests) {
         var _a;
         const task = () => {