@webex/calling 3.11.0-webex-services-ready.1 → 3.12.0-mobius-socket.1

package/dist/module/CallingClient/CallingClient.js

@@ -1,19 +1,23 @@
 import * as Media from '@webex/internal-media-core';
+import { getMobiusSocketInstance } from '@webex/internal-plugin-mobius-socket';
 import { Mutex } from 'async-mutex';
 import { METHOD_START_MESSAGE } from '../common/constants';
-import { filterMobiusUris, handleCallingClientErrors, uploadLogs, validateServiceData, } from '../common/Utils';
+import { filterMobiusUris, handleCallingClientErrors, normalizeMobiusUris, uploadLogs, validateServiceData, } from '../common/Utils';
 import { LOGGER } from '../Logger/types';
 import SDKConnector from '../SDKConnector';
 import { Eventing } from '../Events/impl';
 import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../Events/types';
 import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, } from '../common/types';
+import { MobiusEventType } from './calling/types';
 import log from '../Logger';
 import { getCallManager } from './calling/callManager';
-import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, METHODS, NETWORK_FLAP_TIMEOUT, } from './constants';
+import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, METHODS, NETWORK_FLAP_TIMEOUT, DEVICES_ENDPOINT_RESOURCE, } from './constants';
 import Line from './line';
 import { METRIC_EVENT, REG_ACTION, METRIC_TYPE, CONNECTION_ACTION, MOBIUS_SERVER_ACTION, } from '../Metrics/types';
 import { getMetricManager } from '../Metrics';
 import windowsChromiumIceWarmup from './windowsChromiumIceWarmupUtils';
+import { APIRequest } from './utils/request';
+import { isMobiusWssEnabled } from './utils';
 export class CallingClient extends Eventing {
     sdkConnector;
     webex;
@@ -23,10 +27,15 @@ export class CallingClient extends Eventing {
     sdkConfig;
     primaryMobiusUris;
     backupMobiusUris;
+    primaryWssMobiusUris;
+    backupWssMobiusUris;
     mobiusClusters;
     mobiusHost;
     mediaEngine;
     lineDict = {};
+    apiRequest;
+    isMobiusSocketEnabled;
+    mobiusSocket;
     isNetworkDown = false;
     networkDownTimestamp = '';
     networkUpTimestamp = '';
@@ -51,7 +60,9 @@ export class CallingClient extends Eventing {
         const logLevel = this.sdkConfig?.logger?.level ? this.sdkConfig.logger.level : LOGGER.ERROR;
         log.setLogger(logLevel, CALLING_CLIENT_FILE);
         validateServiceData(serviceData);
-        this.callManager = getCallManager(this.webex, serviceData.indicator);
+        this.isMobiusSocketEnabled =
+            isMobiusWssEnabled(this.webex) || (config?.isMobiusSocketEnabled ?? false);
+        this.callManager = getCallManager(this.webex, serviceData.indicator, this.isMobiusSocketEnabled);
         this.metricManager = getMetricManager(this.webex, serviceData.indicator);
         this.mediaEngine = Media;
         const adaptedLogger = {
@@ -65,8 +76,17 @@ export class CallingClient extends Eventing {
         this.mediaEngine.setLogger(adaptedLogger);
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
+        this.primaryWssMobiusUris = [];
+        this.backupWssMobiusUris = [];
         this.mobiusClusters = this.webex.internal.services.getMobiusClusters();
         this.mobiusHost = '';
+        if (this.isMobiusSocketEnabled) {
+            this.mobiusSocket = getMobiusSocketInstance(this.webex);
+        }
+        this.apiRequest = APIRequest.getInstance({
+            webex: this.webex,
+            isMobiusSocketEnabled: this.isMobiusSocketEnabled,
+        });
         this.registerSessionsListener();
         this.registerCallsClearedListener();
     }
@@ -97,6 +117,10 @@ export class CallingClient extends Eventing {
             }
         }
         await this.getMobiusServers();
+        if (this.isMobiusSocketEnabled) {
+            await this.connectToMobiusSocket();
+            this.registerMobiusSocketListener();
+        }
         await this.createLine();
         this.setupNetworkEventListeners();
     }
@@ -311,6 +335,8 @@ export class CallingClient extends Eventing {
                     const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
                     this.primaryMobiusUris = mobiusUris.primary;
                     this.backupMobiusUris = mobiusUris.backup;
+                    this.primaryWssMobiusUris = mobiusUris.primaryWss;
+                    this.backupWssMobiusUris = mobiusUris.backupWss;
                     log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
                         file: CALLING_CLIENT_FILE,
                         method: GET_MOBIUS_SERVERS_UTIL,
@@ -346,6 +372,87 @@ export class CallingClient extends Eventing {
             this.primaryMobiusUris = [`${this.mobiusHost}${URL_ENDPOINT}`];
         }
     }
+    async connectToMobiusSocket() {
+        const loggerContext = {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.CONNECT_TO_MOBIUS_SOCKET,
+        };
+        log.info(METHOD_START_MESSAGE, loggerContext);
+        if (!this.primaryWssMobiusUris.length && !this.backupWssMobiusUris.length) {
+            log.warn('No WSS URIs available from Mobius discovery, skipping socket connection', loggerContext);
+            return;
+        }
+        if (this.primaryWssMobiusUris.length) {
+            log.log(`Attempting Mobius socket connection using primary WSS URIs (${this.primaryWssMobiusUris.length} available)`, loggerContext);
+            for (const wssUri of this.primaryWssMobiusUris) {
+                try {
+                    log.log(`Trying primary WSS URI: ${wssUri}`, loggerContext);
+                    await this.mobiusSocket.connect(wssUri);
+                    log.log(`Successfully connected to Mobius socket on primary WSS URI: ${wssUri}`, loggerContext);
+                    return;
+                }
+                catch (err) {
+                    log.warn(`Primary WSS URI connection failed for ${wssUri}: ${err}`, loggerContext);
+                }
+            }
+            log.warn('All primary WSS URI connection attempts failed', loggerContext);
+        }
+        else {
+            log.warn('No primary WSS URIs available, skipping to backup', loggerContext);
+        }
+        if (this.backupWssMobiusUris.length) {
+            log.log(`Attempting Mobius socket connection using backup WSS URIs (${this.backupWssMobiusUris.length} available)`, loggerContext);
+            for (const wssUri of this.backupWssMobiusUris) {
+                try {
+                    log.log(`Trying backup WSS URI: ${wssUri}`, loggerContext);
+                    await this.mobiusSocket.connect(wssUri);
+                    log.log(`Successfully connected to Mobius socket on backup WSS URI: ${wssUri}`, loggerContext);
+                    return;
+                }
+                catch (err) {
+                    log.warn(`Backup WSS URI connection failed for ${wssUri}: ${err}`, loggerContext);
+                }
+            }
+            log.warn('All backup WSS URI connection attempts failed', loggerContext);
+        }
+        else {
+            log.warn('No backup WSS URIs available', loggerContext);
+        }
+        log.warn('All Mobius socket connection attempts exhausted for both primary and backup, continuing without socket', loggerContext);
+    }
+    registerMobiusSocketListener() {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
+        });
+        this.sdkConnector.registerMobiusSocketListener('async_event', (event) => {
+            this.handleMobiusAsyncEvent(event);
+        });
+        log.info('Successfully registered listener for Mobius events', {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
+        });
+    }
+    handleMobiusAsyncEvent = async (event) => {
+        log.info(METHOD_START_MESSAGE, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.HANDLE_MOBIUS_ASYNC_EVENT,
+        });
+        const eventType = event?.data.eventType;
+        if (!eventType) {
+            log.warn('Dropping unsupported mobius socket payload', {
+                file: CALLING_CLIENT_FILE,
+                method: METHODS.HANDLE_MOBIUS_ASYNC_EVENT,
+            });
+            return;
+        }
+        if (eventType === MobiusEventType.REGISTRATION_DOWN) {
+            return;
+        }
+        if (eventType.startsWith('mobius.')) {
+            this.callManager.dequeueWsEvents(event);
+        }
+    };
     registerCallsClearedListener() {
         log.info(METHOD_START_MESSAGE, {
             file: CALLING_CLIENT_FILE,
@@ -404,12 +511,58 @@ export class CallingClient extends Eventing {
             file: CALLING_CLIENT_FILE,
             method: METHODS.CREATE_LINE,
         });
-        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData, this.sdkConfig?.jwe);
+        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, this.mutex, this.apiRequest.isSocketEnabled()
+            ? normalizeMobiusUris(this.primaryWssMobiusUris)
+            : this.primaryMobiusUris, this.apiRequest.isSocketEnabled()
+            ? normalizeMobiusUris(this.backupWssMobiusUris)
+            : this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData, this.sdkConfig?.jwe);
         this.lineDict[line.lineId] = line;
     }
     getLines() {
         return this.lineDict;
     }
+    async getDevices(userId) {
+        const userid = userId || this.webex.internal.device.userId;
+        if (!userid) {
+            throw new Error('userId is required to fetch devices');
+        }
+        log.info(METHOD_START_MESSAGE, { file: CALLING_CLIENT_FILE, method: METHODS.GET_DEVICES });
+        const mobiusUrls = [...this.primaryMobiusUris, ...this.backupMobiusUris];
+        if (mobiusUrls.length === 0) {
+            throw new Error('Mobius URLs are not available');
+        }
+        let finalError;
+        for (const mobiusUrl of mobiusUrls) {
+            const normalizedMobiusUrl = mobiusUrl.replace(/\/+$/, '/');
+            const uri = `${normalizedMobiusUrl}${DEVICES_ENDPOINT_RESOURCE}?userid=${encodeURIComponent(userid)}`;
+            try {
+                const response = (await this.apiRequest.makeRequest({
+                    uri,
+                    method: HTTP_METHODS.GET,
+                    service: ALLOWED_SERVICES.MOBIUS,
+                    headers: {
+                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                    },
+                }));
+                if (response.statusCode !== 200) {
+                    throw new Error(`API call failed with ${response.statusCode}`);
+                }
+                const body = response.body;
+                Object.values(this.lineDict)[0].registration.setDeviceInfo(body);
+                Object.values(this.lineDict)[0].registration.setActiveMobiusUrl(normalizedMobiusUrl);
+                return body.devices ?? [];
+            }
+            catch (error) {
+                finalError = error;
+            }
+        }
+        log.error(`Failed to fetch devices for userId ${userId}: ${JSON.stringify(finalError)}`, {
+            file: CALLING_CLIENT_FILE,
+            method: METHODS.GET_DEVICES,
+        });
+        throw finalError;
+    }
     getActiveCalls() {
         const activeCalls = {};
         const calls = this.callManager.getActiveCalls();

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';
@@ -17,6 +17,7 @@ import { createCallerId } from './CallerId';
 import { METRIC_TYPE, METRIC_EVENT, TRANSFER_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;
@@ -52,6 +53,7 @@ export class Call extends Eventing {
     localAudioStream;
     rtcMetrics;
     callKeepaliveRetryCount = 0;
+    apiRequest;
     isMuted() {
         return this.muted;
     }
@@ -102,6 +104,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: {},
@@ -913,7 +916,7 @@ export class Call extends Eventing {
             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' });
@@ -1006,6 +1009,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: 'scheduleCallKeepaliveInterval',
         };
+        clearInterval(this.sessionTimer);
         this.sessionTimer = setInterval(async () => {
             try {
                 const res = await this.postStatus();
@@ -1484,7 +1488,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 +1512,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 +1577,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 +1691,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,
@@ -1808,7 +1812,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,

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

@@ -11,14 +11,16 @@ let callManager;
 export class CallManager extends Eventing {
     sdkConnector;
     webex;
+    isMobiusSocketEnabled;
     callCollection;
     activeMobiusUrl;
     serviceIndicator;
     lineDict;
-    constructor(webex, indicator) {
+    constructor(webex, indicator, isMobiusSocketEnabled) {
         super();
         this.sdkConnector = SDKConnector;
         this.serviceIndicator = indicator;
+        this.isMobiusSocketEnabled = isMobiusSocketEnabled;
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
@@ -59,13 +61,15 @@ export class CallManager extends Eventing {
         });
     }
     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,
-        });
+        if (!this.isMobiusSocketEnabled) {
+            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,
+            });
+        }
     }
     dequeueWsEvents(event) {
         log.info(`${METHOD_START_MESSAGE} with event ${event}`, {
@@ -147,6 +151,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,
@@ -302,9 +321,9 @@ export class CallManager extends Eventing {
         return this.lineDict[deviceId].lineId;
     }
 }
-export const getCallManager = (webex, indicator) => {
+export const getCallManager = (webex, indicator, isMobiusSocketEnabled = false) => {
     if (!callManager) {
-        callManager = new CallManager(webex, indicator);
+        callManager = new CallManager(webex, indicator, isMobiusSocketEnabled);
     }
     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,7 @@ 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 CODEC_ID = 'codecId';
 export const MEDIA_ID = 'id';
 export const RTC_ICE_CANDIDATE_PAIR = 'RTCIceCandidatePair_';
@@ -125,6 +126,7 @@ 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 METHODS = {
     CONSTRUCTOR: 'constructor',
@@ -225,7 +227,13 @@ 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',
+    REGISTER_MOBIUS_SOCKET_LISTENER: 'registerMobiusSocketListener',
+    UNREGISTER_MOBIUS_SOCKET_LISTENER: 'unregisterMobiusSocketListener',
+    HANDLE_MOBIUS_ASYNC_EVENT: 'handleMobiusAsyncEvent',
+    HANDLE_REGISTRATION_DOWN_EVENT: 'handleRegistrationDownEvent',
 };

package/dist/module/CallingClient/registration/register.js

@@ -1,4 +1,3 @@
-import { v4 as uuid } from 'uuid';
 import { METHOD_START_MESSAGE } from '../../common/constants';
 import { emitFinalFailure, handleRegistrationErrors, uploadLogs } from '../../common';
 import webWorkerStr from './webWorkerStr';
@@ -8,8 +7,9 @@ import { getCallManager } from '../calling';
 import log from '../../Logger';
 import SDKConnector from '../../SDKConnector';
 import { ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, ServiceIndicator, WorkerMessageType, } from '../../common/types';
-import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, WEBEX_WEB_CLIENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
+import { CALLING_USER_AGENT, CISCO_DEVICE_URL, DEVICES_ENDPOINT_RESOURCE, SPARK_USER_AGENT, BASE_REG_RETRY_TIMER_VAL_IN_SEC, BASE_REG_TIMER_MFACTOR, SEC_TO_MSEC_MFACTOR, REG_RANDOM_T_FACTOR_UPPER_LIMIT, REG_TRY_BACKUP_TIMER_VAL_IN_SEC, MINUTES_TO_SEC_MFACTOR, REG_429_RETRY_UTIL, REG_FAILBACK_429_MAX_RETRIES, FAILBACK_UTIL, REGISTRATION_FILE, DEFAULT_REHOMING_INTERVAL_MIN, DEFAULT_REHOMING_INTERVAL_MAX, DEFAULT_KEEPALIVE_INTERVAL, FAILOVER_UTIL, REGISTER_UTIL, RETRY_TIMER_UPPER_LIMIT, KEEPALIVE_UTIL, REGISTRATION_UTIL, METHODS, URL_ENDPOINT, RECONNECT_ON_FAILURE_UTIL, FAILOVER_CACHE_PREFIX, } from '../constants';
 import { LINE_EVENTS } from '../line/types';
+import { APIRequest } from '../utils/request';
 export class Registration {
     sdkConnector;
     webex;
@@ -36,6 +36,7 @@ export class Registration {
     retryAfter;
     scheduled429Retry = false;
     webWorker;
+    apiRequest;
     constructor(webex, serviceData, mutex, lineEmitter, logLevel, jwe) {
         this.jwe = jwe;
         this.sdkConnector = SDKConnector;
@@ -57,6 +58,7 @@ export class Registration {
         this.lineEmitter = lineEmitter;
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
+        this.apiRequest = APIRequest.getInstance({ webex: this.webex });
     }
     getFailoverCacheKey() {
         return `${FAILOVER_CACHE_PREFIX}.${this.userId || 'unknown'}`;
@@ -116,6 +118,14 @@ export class Registration {
         this.activeMobiusUrl = url;
         this.callManager.updateActiveMobius(url);
     }
+    setDeviceInfo(devicesInfo) {
+        const [device] = devicesInfo.devices;
+        this.deviceInfo = {
+            userId: devicesInfo.userId,
+            device,
+            devices: devicesInfo.devices,
+        };
+    }
     setMobiusServers(primaryMobiusUris, backupMobiusUris) {
         log.log(METHOD_START_MESSAGE, { method: METHODS.SET_MOBIUS_SERVERS, file: REGISTRATION_FILE });
         this.primaryMobiusUris = primaryMobiusUris;
@@ -123,16 +133,22 @@ export class Registration {
     }
     async deleteRegistration(url, deviceId, deviceUrl) {
         let response;
+        const requestObj = {
+            uri: `${url}${DEVICES_ENDPOINT_RESOURCE}/${deviceId}`,
+            method: HTTP_METHODS.DELETE,
+            headers: {
+                [CISCO_DEVICE_URL]: deviceUrl,
+                [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+            },
+            service: ALLOWED_SERVICES.MOBIUS,
+        };
+        if (this.apiRequest.isSocketEnabled()) {
+            requestObj.body = {
+                deviceId,
+            };
+        }
         try {
-            response = await fetch(`${url}${DEVICES_ENDPOINT_RESOURCE}/${deviceId}`, {
-                method: HTTP_METHODS.DELETE,
-                headers: {
-                    [CISCO_DEVICE_URL]: deviceUrl,
-                    Authorization: await this.webex.credentials.getUserToken(),
-                    trackingId: `${WEBEX_WEB_CLIENT}_${uuid()}`,
-                    [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                },
-            });
+            response = await this.apiRequest.makeRequest(requestObj);
         }
         catch (error) {
             log.warn(`Delete failed with Mobius: ${JSON.stringify(error)}`, {
@@ -143,7 +159,7 @@ export class Registration {
         }
         this.setStatus(RegistrationStatus.INACTIVE);
         this.lineEmitter(LINE_EVENTS.UNREGISTERED);
-        return response?.json();
+        return response;
     }
     async postRegistration(url) {
         const deviceInfo = {
@@ -151,7 +167,7 @@ export class Registration {
             clientDeviceUri: this.webex.internal.device.url,
             serviceData: this.jwe ? { ...this.serviceData, jwe: this.jwe } : this.serviceData,
         };
-        return this.webex.request({
+        return this.apiRequest.makeRequest({
             uri: `${url}device`,
             method: HTTP_METHODS.POST,
             headers: {
@@ -303,7 +319,7 @@ export class Registration {
             await uploadLogs();
             emitFinalFailure((clientError) => {
                 this.lineEmitter(LINE_EVENTS.ERROR, undefined, clientError);
-            }, loggerContext);
+            }, loggerContext, interval < 0 ? 'Timer threshold exceeded during failover' : undefined);
         }
     }
     clearFailbackTimer() {
@@ -316,7 +332,7 @@ export class Registration {
         let status;
         for (const mobiusUrl of this.primaryMobiusUris) {
             try {
-                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/');
+                const baseUri = mobiusUrl.replace(URL_ENDPOINT, '/').replace('wss://', 'https://');
                 const response = await this.webex.request({
                     uri: `${baseUri}ping`,
                     method: HTTP_METHODS.GET,
@@ -383,6 +399,12 @@ export class Registration {
                         method: this.executeFailback.name,
                     });
                     await this.deregister();
+                    if (this.apiRequest.isSocketEnabled()) {
+                        await this.apiRequest.disconnectFromMobiusSocket({
+                            code: 3050,
+                            reason: 'done (permanent)',
+                        });
+                    }
                     const abort = await this.attemptRegistrationWithServers(FAILBACK_UTIL);
                     if (this.scheduled429Retry || abort || this.isDeviceRegistered()) {
                         return;
@@ -527,6 +549,10 @@ export class Registration {
                     file: REGISTRATION_FILE,
                     method: REGISTER_UTIL,
                 });
+                if (this.apiRequest.isSocketEnabled()) {
+                    const wssNormalizedUrl = url.endsWith('/') ? url.slice(0, -1) : url;
+                    await this.apiRequest.connectToMobiusSocket(wssNormalizedUrl);
+                }
                 const resp = await this.postRegistration(url);
                 this.clearFailoverState();
                 this.deviceInfo = resp.body;
@@ -545,6 +571,7 @@ export class Registration {
                 break;
             }
             catch (err) {
+                await this.apiRequest.disconnectFromMobiusSocket({ code: 3050, reason: 'done (permanent)' });
                 const body = err;
                 abort = await handleRegistrationErrors(body, (clientError, finalError) => {
                     if (finalError) {
@@ -675,7 +702,10 @@ export class Registration {
                 rehomingIntervalMin: DEFAULT_REHOMING_INTERVAL_MIN,
             };
             const stringToReplace = `${DEVICES_ENDPOINT_RESOURCE}/${restoreData.devices[0].deviceId}`;
-            const uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+            let uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+            if (this.apiRequest.isSocketEnabled()) {
+                uri = uri.replace('https://', 'wss://');
+            }
             this.setActiveMobiusUrl(uri);
             this.registrationStatus = RegistrationStatus.ACTIVE;
             return true;

package/dist/module/CallingClient/utils/constants.js

@@ -0,0 +1,30 @@
+export var MOBIUS_SOCKET_MESSAGE_TYPE;
+(function (MOBIUS_SOCKET_MESSAGE_TYPE) {
+    MOBIUS_SOCKET_MESSAGE_TYPE["UNKNOWN"] = "UNKNOWN";
+    MOBIUS_SOCKET_MESSAGE_TYPE["REGISTER"] = "register";
+    MOBIUS_SOCKET_MESSAGE_TYPE["REGISTER_RESPONSE"] = "register.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["UNREGISTER"] = "unregister";
+    MOBIUS_SOCKET_MESSAGE_TYPE["UNREGISTER_RESPONSE"] = "unregister.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_STATUS"] = "device_status";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_STATUS_RESPONSE"] = "device_status.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_GET"] = "device_get";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_GET_RESPONSE"] = "device_get.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_LIST"] = "device_list";
+    MOBIUS_SOCKET_MESSAGE_TYPE["DEVICE_LIST_RESPONSE"] = "device_list.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_SETUP"] = "call_setup";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_SETUP_RESPONSE"] = "call_setup.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATE"] = "call_state";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATE_RESPONSE"] = "call_state.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATUS"] = "call_status";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_STATUS_RESPONSE"] = "call_status.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_MEDIA"] = "call_media";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_MEDIA_RESPONSE"] = "call_media.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_HOLD"] = "call_hold";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_HOLD_RESPONSE"] = "call_hold.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_RESUME"] = "call_resume";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_RESUME_RESPONSE"] = "call_resume.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_TRANSFER"] = "call_transfer";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_TRANSFER_RESPONSE"] = "call_transfer.response";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_DELETE"] = "call_delete";
+    MOBIUS_SOCKET_MESSAGE_TYPE["CALL_DELETE_RESPONSE"] = "call_delete.response";
+})(MOBIUS_SOCKET_MESSAGE_TYPE || (MOBIUS_SOCKET_MESSAGE_TYPE = {}));

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

@@ -0,0 +1,5 @@
+export * from './request';
+export * from './types';
+export * from './mobiusSocketMapper';
+export * from './constants';
+export * from './wsFeatureFlag';