@webex/calling 3.11.0 → 3.12.0-llmrefactor.2

package/dist/module/CallingClient/calling/call.js

@@ -1,22 +1,23 @@
 import { MediaConnectionEventNames, LocalStreamEventNames, RoapMediaConnection, } from '@webex/internal-media-core';
 import { createMachine, interpret } from 'xstate';
 import { v4 as uuid } from 'uuid';
-import { EffectEvent } from '@webex/web-media-effects';
+import { EffectEvent } from '@webex/media-helpers';
 import { RtcMetrics } from '@webex/internal-plugin-metrics';
 import { ERROR_LAYER, ERROR_TYPE } from '../../Errors/types';
 import { handleCallErrors, modifySdpForIPv4, parseMediaQualityStatistics, serviceErrorCodeHandler, uploadLogs, } from '../../common/Utils';
 import { ALLOWED_SERVICES, CallDirection, HTTP_METHODS, } from '../../common/types';
 import { createCallError } from '../../Errors/catalog/CallError';
-import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MAX_CALL_KEEPALIVE_RETRY_COUNT, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
+import { CALL_ENDPOINT_RESOURCE, CALL_FILE, CALL_HOLD_SERVICE, CALL_STATUS_RESOURCE, CALL_TRANSFER_SERVICE, CALLING_USER_AGENT, CALLS_ENDPOINT_RESOURCE, CISCO_DEVICE_URL, DEFAULT_LOCAL_CALL_ID, DEFAULT_SESSION_TIMER, DEVICES_ENDPOINT_RESOURCE, HOLD_ENDPOINT, ICE_CANDIDATES_TIMEOUT, ICE_LITE_CANDIDATES_TIMEOUT, INITIAL_SEQ_NUMBER, MAX_CALL_KEEPALIVE_RETRY_COUNT, MEDIA_ENDPOINT_RESOURCE, METHODS, NOISE_REDUCTION_EFFECT, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
 import SDKConnector from '../../SDKConnector';
 import { Eventing } from '../../Events/impl';
 import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
 import { DisconnectCause, DisconnectCode, MidCallEventType, MobiusCallState, MUTE_TYPE, RoapScenario, TransferType, } from './types';
 import log from '../../Logger';
 import { createCallerId } from './CallerId';
-import { METRIC_TYPE, METRIC_EVENT, TRANSFER_ACTION } from '../../Metrics/types';
+import { METRIC_TYPE, METRIC_EVENT, TRANSFER_ACTION, MEDIA_CONNECTION_ACTION, } from '../../Metrics/types';
 import { getMetricManager } from '../../Metrics';
 import { METHOD_START_MESSAGE, SERVICES_ENDPOINT } from '../../common/constants';
+import { APIRequest } from '../utils/request';
 export class Call extends Eventing {
     sdkConnector;
     webex;
@@ -48,10 +49,144 @@ export class Call extends Eventing {
     broadworksCorrelationInfo;
     serviceIndicator;
     mediaNegotiationCompleted;
+    connectPending;
     receivedRoapOKSeq;
     localAudioStream;
     rtcMetrics;
     callKeepaliveRetryCount = 0;
+    apiRequest;
+    iceGatheringConfig;
+    handleMediaRoapEvent = async (event) => {
+        log.info(`ROAP message to send (rcv from MEDIA-SDK) :
+          \n type:  ${event.roapMessage?.messageType}, seq: ${event.roapMessage.seq} , version: ${event.roapMessage.version}`, { file: CALL_FILE, method: METHODS.MEDIA_ROAP_EVENTS_LISTENER });
+        log.info(`SDP message to send : \n ${event.roapMessage?.sdp}`, {
+            file: CALL_FILE,
+            method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+        });
+        switch (event.roapMessage.messageType) {
+            case RoapScenario.OK: {
+                const mediaOk = {
+                    received: false,
+                    message: event.roapMessage,
+                };
+                this.sendMediaStateMachineEvt({ type: 'E_ROAP_OK', data: mediaOk });
+                break;
+            }
+            case RoapScenario.OFFER: {
+                if (!event.roapMessage.sdp) {
+                    log.warn('Received OFFER without SDP from media SDK', {
+                        file: CALL_FILE,
+                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+                    });
+                    break;
+                }
+                log.info(`before modifying sdp: ${event.roapMessage.sdp}`, {
+                    file: CALL_FILE,
+                    method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+                });
+                event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
+                const sdpVideoPortZero = event.roapMessage.sdp.replace(/^m=(video) (?:\d+) /gim, 'm=$1 0 ');
+                log.info(`after modification sdp: ${sdpVideoPortZero}`, {
+                    file: CALL_FILE,
+                    method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+                });
+                event.roapMessage.sdp = sdpVideoPortZero;
+                this.localRoapMessage = event.roapMessage;
+                this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_SETUP', data: event.roapMessage });
+                break;
+            }
+            case RoapScenario.ANSWER:
+                if (!event.roapMessage.sdp) {
+                    log.warn('Received OFFER without SDP from media SDK', {
+                        file: CALL_FILE,
+                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+                    });
+                    break;
+                }
+                event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
+                this.localRoapMessage = event.roapMessage;
+                if (this.connectPending) {
+                    this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_CONNECT' });
+                }
+                this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_ANSWER', data: event.roapMessage });
+                break;
+            case RoapScenario.ERROR:
+                this.sendMediaStateMachineEvt({ type: 'E_ROAP_ERROR', data: event.roapMessage });
+                break;
+            case RoapScenario.OFFER_RESPONSE:
+                if (!event.roapMessage.sdp) {
+                    log.warn('Received OFFER without SDP from media SDK', {
+                        file: CALL_FILE,
+                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+                    });
+                    break;
+                }
+                event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
+                this.localRoapMessage = event.roapMessage;
+                if (this.connectPending) {
+                    this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_CONNECT' });
+                }
+                this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_OFFER', data: event.roapMessage });
+                break;
+            default:
+        }
+    };
+    handleRemoteTrackAdded = (event) => {
+        if (event.type === MEDIA_CONNECTION_EVENT_KEYS.MEDIA_TYPE_AUDIO) {
+            this.emit(CALL_EVENT_KEYS.REMOTE_MEDIA, event.track);
+        }
+    };
+    static getPeerConnectionStateFromEvent(event, preferredKey) {
+        return event[preferredKey] || event.state || 'unknown';
+    }
+    handleIceGatheringStateChanged = (event) => {
+        const iceGatheringState = Call.getPeerConnectionStateFromEvent(event, 'iceGatheringState');
+        log.info(`ICE gathering state changed to: ${iceGatheringState}`, {
+            file: CALL_FILE,
+            method: METHODS.MEDIA_ICE_EVENTS_LISTENER,
+        });
+        this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA, MEDIA_CONNECTION_ACTION.ICE_GATHERING_STATE_CHANGED, METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, undefined, undefined, iceGatheringState);
+    };
+    handlePeerConnectionStateChanged = (event) => {
+        const connectionState = Call.getPeerConnectionStateFromEvent(event, 'connectionState');
+        log.info(`Peer connection state changed to: ${connectionState}`, {
+            file: CALL_FILE,
+            method: METHODS.MEDIA_ICE_EVENTS_LISTENER,
+        });
+        this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA, MEDIA_CONNECTION_ACTION.PEER_CONNECTION_STATE_CHANGED, METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, undefined, undefined, connectionState);
+    };
+    handleIceConnectionStateChanged = (event) => {
+        const iceConnectionState = Call.getPeerConnectionStateFromEvent(event, 'iceConnectionState');
+        log.info(`ICE connection state changed to: ${iceConnectionState}`, {
+            file: CALL_FILE,
+            method: METHODS.MEDIA_ICE_EVENTS_LISTENER,
+        });
+        this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA, MEDIA_CONNECTION_ACTION.ICE_CONNECTION_STATE_CHANGED, METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, undefined, undefined, iceConnectionState);
+    };
+    handleIceCandidateError = (event) => {
+        const iceErrorPayload = {
+            address: event.address ?? null,
+            errorCode: event.errorCode,
+            errorText: event.errorText,
+            port: event.port ?? null,
+            url: event.url,
+        };
+        log.warn(`ICE candidate error occurred: ${JSON.stringify(iceErrorPayload)}`, {
+            file: CALL_FILE,
+            method: METHODS.MEDIA_ICE_EVENTS_LISTENER,
+        });
+        const callError = createCallError(`ICE candidate error occurred: ${JSON.stringify(iceErrorPayload)}`, { file: CALL_FILE, method: METHODS.MEDIA_ICE_EVENTS_LISTENER }, ERROR_TYPE.CALL_ERROR, this.correlationId, ERROR_LAYER.MEDIA);
+        this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA_ERROR, MEDIA_CONNECTION_ACTION.ICE_CANDIDATE_ERROR, METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, undefined, undefined, undefined, callError);
+    };
+    handleRoapFailure = (error) => {
+        const failureMessage = error.message || 'Unknown ROAP failure received from media SDK';
+        log.warn(`ROAP failure occurred: ${failureMessage}`, {
+            file: CALL_FILE,
+            method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
+        });
+        const callError = createCallError(`ROAP failure occurred: ${failureMessage}`, { file: CALL_FILE, method: METHODS.MEDIA_ROAP_EVENTS_LISTENER }, ERROR_TYPE.CALL_ERROR, this.correlationId, ERROR_LAYER.MEDIA);
+        this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA_ERROR, MEDIA_CONNECTION_ACTION.ROAP_FAILURE, METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, undefined, undefined, undefined, callError);
+    };
     isMuted() {
         return this.muted;
     }
@@ -61,7 +196,7 @@ export class Call extends Eventing {
     isHeld() {
         return this.held;
     }
-    constructor(activeUrl, webex, direction, deviceId, lineId, deleteCb, indicator, destination) {
+    constructor(activeUrl, webex, direction, deviceId, lineId, deleteCb, indicator, destination, iceGatheringConfig) {
         super();
         this.destination = destination;
         this.direction = direction;
@@ -69,6 +204,7 @@ export class Call extends Eventing {
         this.deviceId = deviceId;
         this.serviceIndicator = indicator;
         this.lineId = lineId;
+        this.iceGatheringConfig = iceGatheringConfig;
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
@@ -86,6 +222,7 @@ export class Call extends Eventing {
         this.mobiusUrl = activeUrl;
         this.receivedRoapOKSeq = 0;
         this.mediaNegotiationCompleted = false;
+        this.connectPending = false;
         log.info(`Webex Calling Url:- ${this.mobiusUrl}`, {
             file: CALL_FILE,
             method: METHODS.CONSTRUCTOR,
@@ -102,6 +239,7 @@ export class Call extends Eventing {
         this.remoteRoapMessage = null;
         this.disconnectReason = { code: DisconnectCode.NORMAL, cause: DisconnectCause.NORMAL };
         this.rtcMetrics = new RtcMetrics(this.webex, { callId: this.callId }, this.correlationId);
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
         const callMachine = createMachine({
             schema: {
                 context: {},
@@ -281,6 +419,11 @@ export class Call extends Eventing {
                         },
                     },
                     on: {
+                        E_SEND_CALL_CONNECT: {
+                            cond: () => this.connectPending,
+                            target: 'S_SEND_CALL_CONNECT',
+                            actions: ['outgoingCallConnect'],
+                        },
                         E_CALL_ESTABLISHED: {
                             target: 'S_CALL_ESTABLISHED',
                             actions: ['callEstablished'],
@@ -842,6 +985,7 @@ export class Call extends Eventing {
         }
     }
     async handleOutgoingCallConnect(event) {
+        this.connectPending = false;
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
             method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
@@ -851,6 +995,7 @@ export class Call extends Eventing {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
+            this.connectPending = true;
             return;
         }
         try {
@@ -910,10 +1055,11 @@ export class Call extends Eventing {
             clearInterval(this.sessionTimer);
         }
         if (this.mediaConnection) {
+            this.unregisterMediaConnectionListeners();
             this.mediaConnection.close();
             log.info('Closing media channel', {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
@@ -953,6 +1099,7 @@ export class Call extends Eventing {
             clearInterval(this.sessionTimer);
         }
         if (this.mediaConnection) {
+            this.unregisterMediaConnectionListeners();
             this.mediaConnection.close();
             log.info('Closing media channel', {
                 file: CALL_FILE,
@@ -1006,6 +1153,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: 'scheduleCallKeepaliveInterval',
         };
+        clearInterval(this.sessionTimer);
         this.sessionTimer = setInterval(async () => {
             try {
                 const res = await this.postStatus();
@@ -1063,6 +1211,7 @@ export class Call extends Eventing {
             clearInterval(this.sessionTimer);
         }
         if (this.mediaConnection) {
+            this.unregisterMediaConnectionListeners();
             this.mediaConnection.close();
             log.info('Closing media channel', {
                 file: CALL_FILE,
@@ -1357,11 +1506,25 @@ export class Call extends Eventing {
             });
         }
     };
+    getIceCandidatesTimeout() {
+        if (!this.iceGatheringConfig?.reduceTimeoutForIceLite) {
+            return ICE_CANDIDATES_TIMEOUT;
+        }
+        const remoteSdp = this.remoteRoapMessage?.sdp;
+        if (remoteSdp && /^a=ice-lite[\r\n]*$/im.test(remoteSdp)) {
+            log.info('Remote offer advertises ice-lite, using reduced ICE candidates timeout', {
+                file: CALL_FILE,
+                method: METHODS.INIT_MEDIA_CONNECTION,
+            });
+            return this.iceGatheringConfig.iceLiteTimeout ?? ICE_LITE_CANDIDATES_TIMEOUT;
+        }
+        return ICE_CANDIDATES_TIMEOUT;
+    }
     initMediaConnection(localAudioTrack, debugId) {
         const mediaConnection = new RoapMediaConnection({
             skipInactiveTransceivers: true,
             iceServers: [],
-            iceCandidatesTimeout: ICE_CANDIDATES_TIMEOUT,
+            iceCandidatesTimeout: this.getIceCandidatesTimeout(),
             sdpMunging: {
                 convertPort9to0: true,
                 addContentSlides: false,
@@ -1434,6 +1597,7 @@ export class Call extends Eventing {
             this.initMediaConnection(localAudioTrack);
             this.mediaRoapEventsListener();
             this.mediaTrackListener();
+            this.mediaIceEventsListener();
             this.registerListeners(localAudioStream);
         }
         if (this.callStateMachine.state.value === 'S_SEND_CALL_PROGRESS') {
@@ -1464,6 +1628,7 @@ export class Call extends Eventing {
             this.initMediaConnection(localAudioTrack);
             this.mediaRoapEventsListener();
             this.mediaTrackListener();
+            this.mediaIceEventsListener();
             this.registerListeners(localAudioStream);
         }
         if (this.mediaStateMachine.state.value === 'S_ROAP_IDLE') {
@@ -1484,7 +1649,7 @@ export class Call extends Eventing {
                 mediaId: uuid(),
             },
         };
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALL_ENDPOINT_RESOURCE}`,
             method: HTTP_METHODS.POST,
             service: ALLOWED_SERVICES.MOBIUS,
@@ -1508,7 +1673,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: 'patch',
         });
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALLS_ENDPOINT_RESOURCE}/${this.callId}`,
             method: HTTP_METHODS.PATCH,
             service: ALLOWED_SERVICES.MOBIUS,
@@ -1573,10 +1738,10 @@ export class Call extends Eventing {
                 });
             }
         }
-        return this.webex.request(request);
+        return this.apiRequest.makeRequest(request);
     }
     async postStatus() {
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALLS_ENDPOINT_RESOURCE}/${this.callId}/${CALL_STATUS_RESOURCE}`,
             method: HTTP_METHODS.POST,
             service: ALLOWED_SERVICES.MOBIUS,
@@ -1687,7 +1852,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: METHODS.POST_MEDIA,
         });
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALLS_ENDPOINT_RESOURCE}/${this.callId}/${MEDIA_ENDPOINT_RESOURCE}`,
             method: HTTP_METHODS.POST,
             service: ALLOWED_SERVICES.MOBIUS,
@@ -1709,61 +1874,29 @@ export class Call extends Eventing {
         });
     }
     mediaRoapEventsListener() {
-        this.mediaConnection.on(MediaConnectionEventNames.ROAP_MESSAGE_TO_SEND, async (event) => {
-            log.info(`ROAP message to send (rcv from MEDIA-SDK) :
-          \n type:  ${event.roapMessage?.messageType}, seq: ${event.roapMessage.seq} , version: ${event.roapMessage.version}`, { file: CALL_FILE, method: METHODS.MEDIA_ROAP_EVENTS_LISTENER });
-            log.info(`SDP message to send : \n ${event.roapMessage?.sdp}`, {
-                file: CALL_FILE,
-                method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
-            });
-            switch (event.roapMessage.messageType) {
-                case RoapScenario.OK: {
-                    const mediaOk = {
-                        received: false,
-                        message: event.roapMessage,
-                    };
-                    this.sendMediaStateMachineEvt({ type: 'E_ROAP_OK', data: mediaOk });
-                    break;
-                }
-                case RoapScenario.OFFER: {
-                    log.info(`before modifying sdp: ${event.roapMessage.sdp}`, {
-                        file: CALL_FILE,
-                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
-                    });
-                    event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
-                    const sdpVideoPortZero = event.roapMessage.sdp.replace(/^m=(video) (?:\d+) /gim, 'm=$1 0 ');
-                    log.info(`after modification sdp: ${sdpVideoPortZero}`, {
-                        file: CALL_FILE,
-                        method: METHODS.MEDIA_ROAP_EVENTS_LISTENER,
-                    });
-                    event.roapMessage.sdp = sdpVideoPortZero;
-                    this.localRoapMessage = event.roapMessage;
-                    this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_SETUP', data: event.roapMessage });
-                    break;
-                }
-                case RoapScenario.ANSWER:
-                    event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
-                    this.localRoapMessage = event.roapMessage;
-                    this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_ANSWER', data: event.roapMessage });
-                    break;
-                case RoapScenario.ERROR:
-                    this.sendMediaStateMachineEvt({ type: 'E_ROAP_ERROR', data: event.roapMessage });
-                    break;
-                case RoapScenario.OFFER_RESPONSE:
-                    event.roapMessage.sdp = modifySdpForIPv4(event.roapMessage.sdp);
-                    this.localRoapMessage = event.roapMessage;
-                    this.sendMediaStateMachineEvt({ type: 'E_SEND_ROAP_OFFER', data: event.roapMessage });
-                    break;
-                default:
-            }
-        });
+        this.mediaConnection.on(MediaConnectionEventNames.ROAP_MESSAGE_TO_SEND, this.handleMediaRoapEvent);
+        this.mediaConnection.on(MediaConnectionEventNames.ROAP_FAILURE, this.handleRoapFailure);
     }
     mediaTrackListener() {
-        this.mediaConnection.on(MediaConnectionEventNames.REMOTE_TRACK_ADDED, (e) => {
-            if (e.type === MEDIA_CONNECTION_EVENT_KEYS.MEDIA_TYPE_AUDIO) {
-                this.emit(CALL_EVENT_KEYS.REMOTE_MEDIA, e.track);
-            }
-        });
+        this.mediaConnection.on(MediaConnectionEventNames.REMOTE_TRACK_ADDED, this.handleRemoteTrackAdded);
+    }
+    mediaIceEventsListener() {
+        this.mediaConnection.on(MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED, this.handleIceGatheringStateChanged);
+        this.mediaConnection.on(MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED, this.handlePeerConnectionStateChanged);
+        this.mediaConnection.on(MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED, this.handleIceConnectionStateChanged);
+        this.mediaConnection.on(MediaConnectionEventNames.ICE_CANDIDATE_ERROR, this.handleIceCandidateError);
+    }
+    unregisterMediaConnectionListeners() {
+        if (!this.mediaConnection || typeof this.mediaConnection.off !== 'function') {
+            return;
+        }
+        this.mediaConnection.off(MediaConnectionEventNames.ROAP_MESSAGE_TO_SEND, this.handleMediaRoapEvent);
+        this.mediaConnection.off(MediaConnectionEventNames.ROAP_FAILURE, this.handleRoapFailure);
+        this.mediaConnection.off(MediaConnectionEventNames.REMOTE_TRACK_ADDED, this.handleRemoteTrackAdded);
+        this.mediaConnection.off(MediaConnectionEventNames.ICE_GATHERING_STATE_CHANGED, this.handleIceGatheringStateChanged);
+        this.mediaConnection.off(MediaConnectionEventNames.PEER_CONNECTION_STATE_CHANGED, this.handlePeerConnectionStateChanged);
+        this.mediaConnection.off(MediaConnectionEventNames.ICE_CONNECTION_STATE_CHANGED, this.handleIceConnectionStateChanged);
+        this.mediaConnection.off(MediaConnectionEventNames.ICE_CANDIDATE_ERROR, this.handleIceCandidateError);
     }
     onEffectEnabled = () => {
         this.metricManager.submitBNRMetric(METRIC_EVENT.BNR_ENABLED, METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId);
@@ -1777,7 +1910,7 @@ export class Call extends Eventing {
     registerEffectListener = (addedEffect) => {
         if (this.localAudioStream) {
             const effect = this.localAudioStream.getEffectByKind(NOISE_REDUCTION_EFFECT);
-            if (effect === addedEffect) {
+            if (effect && effect === addedEffect) {
                 effect.on(EffectEvent.Enabled, this.onEffectEnabled);
                 effect.on(EffectEvent.Disabled, this.onEffectDisabled);
             }
@@ -1808,7 +1941,7 @@ export class Call extends Eventing {
     }
     async delete() {
         const disconnectMetrics = await this.getCallStats();
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${this.mobiusUrl}${DEVICES_ENDPOINT_RESOURCE}/${this.deviceId}/${CALLS_ENDPOINT_RESOURCE}/${this.callId}`,
             method: HTTP_METHODS.DELETE,
             service: ALLOWED_SERVICES.MOBIUS,
@@ -1833,7 +1966,7 @@ export class Call extends Eventing {
             this.metricManager.submitCallMetric(METRIC_EVENT.CALL_ERROR, transferMetricAction || this.callStateMachine.state.value.toString(), METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, error);
         }
         else {
-            this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA_ERROR, this.mediaStateMachine.state.value.toString(), METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, this.localRoapMessage.sdp, this.remoteRoapMessage?.sdp, error);
+            this.metricManager.submitMediaMetric(METRIC_EVENT.MEDIA_ERROR, this.mediaStateMachine.state.value.toString(), METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, this.localRoapMessage.sdp, this.remoteRoapMessage?.sdp, undefined, error);
         }
     }
     handleMidCallEvent(event) {
@@ -2013,4 +2146,4 @@ export class Call extends Eventing {
         });
     }
 }
-export const createCall = (activeUrl, webex, dir, deviceId, lineId, deleteCb, indicator, dest) => new Call(activeUrl, webex, dir, deviceId, lineId, deleteCb, indicator, dest);
+export const createCall = (activeUrl, webex, dir, deviceId, lineId, deleteCb, indicator, dest, iceGatheringConfig) => new Call(activeUrl, webex, dir, deviceId, lineId, deleteCb, indicator, dest, iceGatheringConfig);

package/dist/module/CallingClient/calling/callManager.js

@@ -1,3 +1,4 @@
+import { APIRequest } from '../utils/request';
 import { METHOD_START_MESSAGE } from '../../common/constants';
 import { CALL_MANAGER_FILE, METHODS } from '../constants';
 import { CALLING_CLIENT_EVENT_KEYS, LINE_EVENT_KEYS } from '../../Events/types';
@@ -15,15 +16,20 @@ export class CallManager extends Eventing {
     activeMobiusUrl;
     serviceIndicator;
     lineDict;
-    constructor(webex, indicator) {
+    apiRequest;
+    isMobiusSocketListenerRegistered = false;
+    iceGatheringConfig;
+    constructor(webex, indicator, iceGatheringConfig) {
         super();
         this.sdkConnector = SDKConnector;
         this.serviceIndicator = indicator;
+        this.iceGatheringConfig = iceGatheringConfig;
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
         this.lineDict = {};
         this.webex = this.sdkConnector.getWebex();
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
         this.callCollection = {};
         this.activeMobiusUrl = '';
         this.listenForWsEvents();
@@ -45,7 +51,7 @@ export class CallManager extends Eventing {
                     method: METHODS.CREATE_CALL,
                 });
             }
-        }, this.serviceIndicator, destination);
+        }, this.serviceIndicator, destination, this.iceGatheringConfig);
         this.callCollection[newCall.getCorrelationId()] = newCall;
         log.log(`New call created with correlationId: ${newCall.getCorrelationId()}`, {});
         log.info(`ADD:: Added corelationId: ${newCall.getCorrelationId()} to CallManager , Number of call records now:- ${Object.keys(this.getActiveCalls()).length}`, {});
@@ -57,15 +63,28 @@ export class CallManager extends Eventing {
             file: CALL_MANAGER_FILE,
             method: METHODS.UPDATE_ACTIVE_MOBIUS,
         });
+        this.listenForWsEvents();
     }
     listenForWsEvents() {
-        this.sdkConnector.registerListener('event:mobius', async (event) => {
-            this.dequeueWsEvents(event);
-        });
-        log.info('Successfully registered listener for Mobius events', {
-            file: CALL_MANAGER_FILE,
-            method: METHODS.REGISTER_SESSIONS_LISTENER,
-        });
+        const socketEnabled = this.apiRequest.isSocketEnabled();
+        if (!socketEnabled && !this.isMobiusSocketListenerRegistered) {
+            this.sdkConnector.registerListener('event:mobius', async (event) => {
+                this.dequeueWsEvents(event);
+            });
+            this.isMobiusSocketListenerRegistered = true;
+            log.info('Successfully registered listener for Mobius events', {
+                file: CALL_MANAGER_FILE,
+                method: METHODS.REGISTER_SESSIONS_LISTENER,
+            });
+        }
+        else if (socketEnabled && this.isMobiusSocketListenerRegistered) {
+            this.sdkConnector.unregisterListener('event:mobius');
+            this.isMobiusSocketListenerRegistered = false;
+            log.info('Unregistered Mercury listener for Mobius events; using WebSocket transport', {
+                file: CALL_MANAGER_FILE,
+                method: METHODS.REGISTER_SESSIONS_LISTENER,
+            });
+        }
     }
     dequeueWsEvents(event) {
         log.info(`${METHOD_START_MESSAGE} with event ${event}`, {
@@ -147,6 +166,21 @@ export class CallManager extends Eventing {
                 call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_PROGRESS', data: mobiusEvent.data });
                 break;
             }
+            case MobiusEventType.CALL_INFO: {
+                log.log(`Received call info mobiusEvent for call: ${correlationId}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: METHODS.DEQUEUE_WS_EVENTS,
+                });
+                const call = this.getCall(correlationId);
+                if (call && mobiusEvent.data.callerId) {
+                    log.info('Processing Caller-Id data', {
+                        file: CALL_MANAGER_FILE,
+                        method: METHODS.DEQUEUE_WS_EVENTS,
+                    });
+                    call.startCallerIdResolution(mobiusEvent.data.callerId);
+                }
+                break;
+            }
             case MobiusEventType.CALL_MEDIA: {
                 log.log(`Received call media mobiusEvent for call: ${correlationId}`, {
                     file: CALL_MANAGER_FILE,
@@ -301,10 +335,16 @@ export class CallManager extends Eventing {
     getLineId(deviceId) {
         return this.lineDict[deviceId].lineId;
     }
+    setIceGatheringConfig(iceGatheringConfig) {
+        this.iceGatheringConfig = iceGatheringConfig;
+    }
 }
-export const getCallManager = (webex, indicator) => {
+export const getCallManager = (webex, indicator, iceGatheringConfig) => {
     if (!callManager) {
-        callManager = new CallManager(webex, indicator);
+        callManager = new CallManager(webex, indicator, iceGatheringConfig);
+    }
+    else if (iceGatheringConfig) {
+        callManager.setIceGatheringConfig(iceGatheringConfig);
     }
     return callManager;
 };

package/dist/module/CallingClient/calling/types.js

@@ -5,6 +5,8 @@ export var MobiusEventType;
     MobiusEventType["CALL_CONNECTED"] = "mobius.callconnected";
     MobiusEventType["CALL_MEDIA"] = "mobius.media";
     MobiusEventType["CALL_DISCONNECTED"] = "mobius.calldisconnected";
+    MobiusEventType["CALL_INFO"] = "mobius.callinfo";
+    MobiusEventType["REGISTRATION_DOWN"] = "registration.down";
 })(MobiusEventType || (MobiusEventType = {}));
 export var MediaState;
 (function (MediaState) {

package/dist/module/CallingClient/constants.js

@@ -69,6 +69,9 @@ export const CALL_FILE = 'call';
 export const CALL_MANAGER_FILE = 'callManager';
 export const METRIC_FILE = 'metric';
 export const REGISTRATION_FILE = 'register';
+export const REQUEST_FILE = 'REQUEST';
+export const MOBIUS_SOCKET_MAPPER_FILE = 'mobiusSocketMapper';
+export const WS_FEATURE_FLAG_FILE = 'wsFeatureFlag';
 export const CODEC_ID = 'codecId';
 export const MEDIA_ID = 'id';
 export const RTC_ICE_CANDIDATE_PAIR = 'RTCIceCandidatePair_';
@@ -125,7 +128,11 @@ export const MOBIUS_EU_PROD = 'mobius-eu-central-1.prod.infra.webex.com';
 export const MOBIUS_US_INT = 'mobius-us-east-1.int.infra.webex.com';
 export const MOBIUS_EU_INT = 'mobius-eu-central-1.int.infra.webex.com';
 export const FAILOVER_CACHE_PREFIX = 'wxc-failover-state';
+export const ACTIVE_MOBIUS_STORAGE_KEY = 'wxc-active-mobius';
 export const ICE_CANDIDATES_TIMEOUT = 3000;
+export const ICE_LITE_CANDIDATES_TIMEOUT = 500;
+export const WCC_CALLING_RTMS_DOMAIN = 'wcc-calling-rtms-domain';
+export const SESSION_SUPERSEDED_MESSAGE = 'This calling session has been superseded by another registration for the same user, for example calling opened in another browser tab or device. Calling is no longer available on this session.';
 export const METHODS = {
     CONSTRUCTOR: 'constructor',
     CREATE_CALL: 'createCall',
@@ -178,6 +185,7 @@ export const METHODS = {
     POST_MEDIA: 'postMedia',
     MEDIA_ROAP_EVENTS_LISTENER: 'mediaRoapEventsListener',
     MEDIA_TRACK_LISTENER: 'mediaTrackListener',
+    MEDIA_ICE_EVENTS_LISTENER: 'mediaIceEventsListener',
     ON_EFFECT_ENABLED: 'onEffectEnabled',
     ON_EFFECT_DISABLED: 'onEffectDisabled',
     UPDATE_TRACK: 'updateTrack',
@@ -225,7 +233,28 @@ export const METHODS = {
     REGISTER_SESSIONS_LISTENER: 'registerSessionsListener',
     CREATE_LINE: 'createLine',
     GET_LINES: 'getLines',
+    GET_DEVICES: 'getDevices',
     UPLOAD_LOGS: 'uploadLogs',
     GET_SDK_CONNECTOR: 'getSDKConnector',
     GET_CONNECTED_CALL: 'getConnectedCall',
+    CONNECT_TO_MOBIUS_SOCKET: 'connectToMobiusSocket',
+    SET_SOCKET_ENABLED: 'setSocketEnabled',
+    REGISTER_MOBIUS_SOCKET_LISTENER: 'registerMobiusSocketListener',
+    UNREGISTER_MOBIUS_SOCKET_LISTENER: 'unregisterMobiusSocketListener',
+    REGISTER_MOBIUS_SOCKET_CONNECTION_LISTENER: 'registerMobiusSocketConnectionListener',
+    UNREGISTER_MOBIUS_SOCKET_CONNECTION_LISTENER: 'unregisterMobiusSocketConnectionListener',
+    HANDLE_MOBIUS_ASYNC_EVENT: 'handleMobiusAsyncEvent',
+    HANDLE_REGISTRATION_DOWN_EVENT: 'handleRegistrationDownEvent',
+    DISCONNECT_FROM_MOBIUS_SOCKET: 'disconnectFromMobiusSocket',
+    MAKE_REQUEST: 'makeRequest',
+    DERIVE_MOBIUS_SOCKET_MESSAGE_TYPE: 'deriveMobiusSocketMessageType',
+    IS_MOBIUS_WSS_ENABLED: 'isMobiusWssEnabled',
+    RESTORE_PREVIOUS_REGISTRATION: 'restorePreviousRegistration',
+    RESTART_REGISTRATION: 'restartRegistration',
+    TRIGGER_REGISTRATION: 'triggerRegistration',
+    HANDLE_404_KEEPALIVE_FAILURE: 'handle404KeepaliveFailure',
+    HANDLE_409_KEEPALIVE_FAILURE: 'handle409KeepaliveFailure',
+    INITIATE_FAILBACK: 'initiateFailback',
+    EXECUTE_FAILBACK: 'executeFailback',
+    GET_RTMS_DOMAIN: 'getRTMSDomain',
 };

package/dist/module/CallingClient/line/index.js

@@ -70,12 +70,12 @@ export default class Line extends Eventing {
             await this.registration.triggerRegistration();
         });
     }
-    async deregister() {
+    async deregister(closeMobiusWss = false) {
         log.info(METHOD_START_MESSAGE, {
             file: LINE_FILE,
             method: METHODS.DEREGISTER,
         });
-        await this.registration.deregister();
+        await this.registration.deregister(closeMobiusWss);
         this.registration.setStatus(RegistrationStatus.IDLE);
     }
     normalizeLine(deviceInfo) {
@@ -107,6 +107,8 @@ export default class Line extends Eventing {
                 }
                 break;
             case LINE_EVENTS.UNREGISTERED:
+                this.emit(event, lineError);
+                break;
             case LINE_EVENTS.RECONNECTED:
             case LINE_EVENTS.RECONNECTING:
                 this.emit(event);