@webex/calling 3.12.0-task-refactor.1 → 3.12.0-webex-services-ready.2

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

@@ -1,7 +1,7 @@
 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';
@@ -14,9 +14,10 @@ import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUP
 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,143 @@ export class Call extends Eventing {
     broadworksCorrelationInfo;
     serviceIndicator;
     mediaNegotiationCompleted;
+    connectPending;
     receivedRoapOKSeq;
     localAudioStream;
     rtcMetrics;
     callKeepaliveRetryCount = 0;
+    apiRequest;
+    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;
     }
@@ -86,6 +220,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 +237,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 +417,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 +983,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 +993,7 @@ export class Call extends Eventing {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
+            this.connectPending = true;
             return;
         }
         try {
@@ -910,10 +1053,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 +1097,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 +1151,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 +1209,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,
@@ -1235,7 +1382,7 @@ export class Call extends Eventing {
             });
         }
         catch (err) {
-            log.warn('Failed to process MediaOk request', {
+            log.warn('Failed to send MediaOffer request', {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_ROAP_OFFER,
             });
@@ -1434,6 +1581,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 +1612,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 +1633,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 +1657,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 +1722,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 +1836,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 +1858,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);
@@ -1808,7 +1925,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 +1950,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) {

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,6 +16,8 @@ export class CallManager extends Eventing {
     activeMobiusUrl;
     serviceIndicator;
     lineDict;
+    apiRequest;
+    isMobiusSocketListenerRegistered = false;
     constructor(webex, indicator) {
         super();
         this.sdkConnector = SDKConnector;
@@ -24,6 +27,7 @@ export class CallManager extends Eventing {
         }
         this.lineDict = {};
         this.webex = this.sdkConnector.getWebex();
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
         this.callCollection = {};
         this.activeMobiusUrl = '';
         this.listenForWsEvents();
@@ -57,15 +61,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}`, {
@@ -137,9 +154,31 @@ export class CallManager extends Eventing {
                     method: METHODS.DEQUEUE_WS_EVENTS,
                 });
                 const call = this.getCall(correlationId);
+                if (mobiusEvent.data.callerId) {
+                    log.info('Processing Caller-Id data', {
+                        file: CALL_MANAGER_FILE,
+                        method: METHODS.DEQUEUE_WS_EVENTS,
+                    });
+                    call.startCallerIdResolution(mobiusEvent.data.callerId);
+                }
                 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,

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,9 @@ 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 WCC_CALLING_RTMS_DOMAIN = 'wcc-calling-rtms-domain';
 export const METHODS = {
     CONSTRUCTOR: 'constructor',
     CREATE_CALL: 'createCall',
@@ -178,6 +183,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 +231,27 @@ 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',
+    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) {