@webex/calling 3.12.0-next.4 → 3.12.0-next.41

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

@@ -1,106 +1,71 @@
 const webWorkerStr = `/* eslint-env worker */
 
-const uuid = () => {
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === 'x' ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-};
-
-// Enum values from the original imports
-const HTTP_METHODS = {
-  GET: 'GET',
-  POST: 'POST',
-  PUT: 'PUT',
-  DELETE: 'DELETE',
-  PATCH: 'PATCH',
-};
-
 const WorkerMessageType = {
   START_KEEPALIVE: 'START_KEEPALIVE',
   CLEAR_KEEPALIVE: 'CLEAR_KEEPALIVE',
+  SEND_KEEPALIVE: 'SEND_KEEPALIVE',
+  KEEPALIVE_RESULT: 'KEEPALIVE_RESULT',
   KEEPALIVE_SUCCESS: 'KEEPALIVE_SUCCESS',
   KEEPALIVE_FAILURE: 'KEEPALIVE_FAILURE',
 };
 
 let keepaliveTimer;
+let keepAliveRetryCount = 0;
+let keepaliveInFlight = false;
+
+const clearKeepaliveTimer = () => {
+  if (keepaliveTimer) {
+    clearInterval(keepaliveTimer);
+    keepaliveTimer = undefined;
+  }
+};
 
 const messageHandler = (event) => {
   const {type} = event.data;
 
-  const postKeepAlive = async (accessToken, deviceUrl, url) => {
-    const response = await fetch(\`\${url}/status\`, {
-      method: HTTP_METHODS.POST,
-      headers: {
-        'cisco-device-url': deviceUrl,
-        'spark-user-agent': 'webex-calling/beta',
-        Authorization: \`\${accessToken}\`,
-        trackingId: \`web_worker_\${uuid()}\`,
-      },
-    });
-
-    if (!response.ok) {
-      throw response;
-    }
-
-    return response;
-  };
-
   if (type === WorkerMessageType.START_KEEPALIVE) {
-    let keepAliveRetryCount = 0;
-    const {accessToken, deviceUrl, interval, retryCountThreshold, url} = event.data;
-
-    if (keepaliveTimer) {
-      clearInterval(keepaliveTimer);
-      keepaliveTimer = undefined;
-    }
-
-    keepaliveTimer = setInterval(async () => {
-      if (keepAliveRetryCount < retryCountThreshold) {
-        try {
-          const res = await postKeepAlive(accessToken, deviceUrl, url);
-          const statusCode = res.status;
-          if (keepAliveRetryCount > 0) {
-            self.postMessage({
-              type: WorkerMessageType.KEEPALIVE_SUCCESS,
-              statusCode,
-            });
-          }
-          keepAliveRetryCount = 0;
-        } catch (err) {
-          let headers = {};
-          if(err.headers?.has('Retry-After')) {
-            headers['retry-after'] = err.headers.get('Retry-After');
-          } 
-
-          if(err.headers?.has('Trackingid')) {
-            headers['trackingid'] = err.headers.get('Trackingid');
-          }   
+    const {interval, retryCountThreshold} = event.data;
+
+    clearKeepaliveTimer();
+    keepAliveRetryCount = 0;
+    keepaliveInFlight = false;
+
+    keepaliveTimer = setInterval(() => {
+      if (keepAliveRetryCount < retryCountThreshold && !keepaliveInFlight) {
+        keepaliveInFlight = true;
+        self.postMessage({
+          type: WorkerMessageType.SEND_KEEPALIVE,
+        });
+      }
+    }, interval * 1000);
+  }
 
-          const error = {
-            headers,
-            statusCode: err.status,
-            statusText: err.statusText,
-            type: err.type,
-          };
+  if (type === WorkerMessageType.KEEPALIVE_RESULT) {
+    keepaliveInFlight = false;
 
-          keepAliveRetryCount += 1
-          self.postMessage({
-            type: WorkerMessageType.KEEPALIVE_FAILURE,
-            err: error,
-            keepAliveRetryCount,
-          });
-        }
+    if (event.data.err === undefined) {
+      if (keepAliveRetryCount > 0) {
+        self.postMessage({
+          type: WorkerMessageType.KEEPALIVE_SUCCESS,
+          statusCode: event.data.statusCode,
+        });
       }
-    }, interval * 1000);
+
+      keepAliveRetryCount = 0;
+    } else {
+      keepAliveRetryCount += 1;
+      self.postMessage({
+        type: WorkerMessageType.KEEPALIVE_FAILURE,
+        err: event.data.err,
+        keepAliveRetryCount,
+      });
+    }
   }
 
   if (type === WorkerMessageType.CLEAR_KEEPALIVE) {
-    if (keepaliveTimer) {
-      clearInterval(keepaliveTimer);
-      keepaliveTimer = undefined;
-    }
+    clearKeepaliveTimer();
+    keepAliveRetryCount = 0;
+    keepaliveInFlight = false;
   }
 };
 

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';

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

@@ -0,0 +1,72 @@
+import { HTTP_METHODS } from '../../common/types';
+import log from '../../Logger';
+import { METHODS, MOBIUS_SOCKET_MAPPER_FILE } from '../constants';
+import { MOBIUS_SOCKET_MESSAGE_TYPE } from './constants';
+export function deriveMobiusSocketMessageType(uri, httpMethodType) {
+    const logContext = {
+        file: MOBIUS_SOCKET_MAPPER_FILE,
+        method: METHODS.DERIVE_MOBIUS_SOCKET_MESSAGE_TYPE,
+    };
+    if (!uri) {
+        log.warn('Cannot derive Mobius socket message type: uri is empty', logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.includes('/services')) {
+        if (uri.includes('/callhold/hold')) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_HOLD;
+        }
+        if (uri.includes('/callhold/resume')) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_RESUME;
+        }
+        if (uri.includes('/calltransfer/commit')) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_TRANSFER;
+        }
+        log.warn(`Unrecognized supplementary service uri - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.includes('/calls/') && uri.includes('/media')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_MEDIA;
+    }
+    if (uri.includes('/calls/') && uri.includes('/status')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_STATUS;
+    }
+    if (uri.match(/\/calls\/[^/]+$/)) {
+        if (httpMethodType === HTTP_METHODS.PATCH) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_STATE;
+        }
+        if (httpMethodType === HTTP_METHODS.DELETE) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_DELETE;
+        }
+        log.warn(`Unrecognized httpMethod for calls/{callId} - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.endsWith('/call')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.CALL_SETUP;
+    }
+    if (uri.includes('/devices/') && uri.endsWith('/status')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_STATUS;
+    }
+    if (uri.endsWith('/device')) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.REGISTER;
+    }
+    if (uri.match(/\/devices\/[^/?]+$/) && !uri.includes('/calls')) {
+        if (httpMethodType === HTTP_METHODS.DELETE) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.UNREGISTER;
+        }
+        if (httpMethodType === HTTP_METHODS.GET) {
+            return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_GET;
+        }
+        log.warn(`Unrecognized httpMethod for devices/{deviceId} - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+        return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+    }
+    if (uri.includes('/devices') && !uri.match(/\/devices\/[^/?]+/)) {
+        return MOBIUS_SOCKET_MESSAGE_TYPE.DEVICE_LIST;
+    }
+    log.warn(`Unrecognized uri pattern for Mobius socket - uri: ${uri}, httpMethod: ${httpMethodType}`, logContext);
+    return MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN;
+}
+export const isSupplementaryServiceMessageType = (type) => [
+    MOBIUS_SOCKET_MESSAGE_TYPE.CALL_HOLD,
+    MOBIUS_SOCKET_MESSAGE_TYPE.CALL_RESUME,
+    MOBIUS_SOCKET_MESSAGE_TYPE.CALL_TRANSFER,
+].includes(type);

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

@@ -0,0 +1,165 @@
+import { v4 as uuid } from 'uuid';
+import { getMobiusSocketInstance } from '../../mobius-socket';
+import log from '../../Logger';
+import { deriveMobiusSocketMessageType, isSupplementaryServiceMessageType, } from './mobiusSocketMapper';
+import { MOBIUS_SOCKET_MESSAGE_TYPE } from './constants';
+import { isMobiusWssEnabled } from './wsFeatureFlag';
+import { CALLING_USER_AGENT, METHODS, REQUEST_FILE } from '../constants';
+import { getMetricManager } from '../../Metrics';
+import { METRIC_EVENT, METRIC_TYPE, MOBIUS_SOCKET_ACTION } from '../../Metrics/types';
+function normalizeWsResponse(wsResponse) {
+    return {
+        statusCode: wsResponse.statusCode,
+        body: wsResponse.data ?? undefined,
+        headers: {
+            trackingid: wsResponse.trackingId,
+            ...(wsResponse.metadata ?? {}),
+        },
+    };
+}
+function normalizeWsError(err) {
+    const wsErr = err;
+    return {
+        statusCode: wsErr.statusCode,
+        body: wsErr.response?.data ?? undefined,
+        headers: {
+            trackingid: wsErr.trackingId ?? wsErr.response?.trackingId ?? '',
+            ...(wsErr.response?.metadata ?? {}),
+        },
+    };
+}
+export class APIRequest {
+    static instance;
+    isMobiusSocketEnabled;
+    webex;
+    mobiusSocket;
+    metricManager;
+    static getInstance(config) {
+        if (!APIRequest.instance) {
+            APIRequest.instance = new APIRequest(config);
+        }
+        return APIRequest.instance;
+    }
+    static resetInstance() {
+        APIRequest.instance = undefined;
+    }
+    constructor(config) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.CONSTRUCTOR,
+        };
+        if (!config.webex) {
+            log.error('APIRequest instantiation failed: WebexSDK instance is required', logContext);
+            throw new Error('WebexSDK instance is required');
+        }
+        this.webex = config.webex;
+        this.isMobiusSocketEnabled = isMobiusWssEnabled(config.webex) || false;
+        this.mobiusSocket = getMobiusSocketInstance(this.webex);
+        this.metricManager = getMetricManager(this.webex);
+        log.info(`APIRequest initialized with transport: ${this.isMobiusSocketEnabled ? 'WSS' : 'HTTP'}`, logContext);
+    }
+    isSocketEnabled() {
+        return this.isMobiusSocketEnabled;
+    }
+    async connectToMobiusSocket(wssUrl) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.CONNECT_TO_MOBIUS_SOCKET,
+        };
+        if (this.mobiusSocket.isConnected()) {
+            log.info('Mobius WebSocket already connected', logContext);
+            return this.mobiusSocket.getConnectedWebSocketUrl();
+        }
+        log.info('Mobius WebSocket not connected, initiating connection', logContext);
+        try {
+            await this.mobiusSocket.connect(wssUrl);
+            log.log('Mobius WebSocket connected successfully', logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.CONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl);
+            return wssUrl;
+        }
+        catch (err) {
+            log.warn(`Mobius WebSocket connection failed: ${String(err)}`, logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET_ERROR, MOBIUS_SOCKET_ACTION.CONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl, undefined, String(err));
+            throw normalizeWsError(err);
+        }
+    }
+    getConnectedWebSocketUrl() {
+        return this.mobiusSocket.getConnectedWebSocketUrl();
+    }
+    async disconnectFromMobiusSocket(options) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.DISCONNECT_FROM_MOBIUS_SOCKET,
+        };
+        log.info('Disconnecting from Mobius WebSocket', logContext);
+        const wssUrl = this.mobiusSocket.getConnectedWebSocketUrl();
+        try {
+            await this.mobiusSocket.disconnect(options);
+            log.log('Mobius WebSocket disconnected successfully', logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.DISCONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl);
+        }
+        catch (err) {
+            log.warn(`Mobius WebSocket disconnection failed: ${String(err)}`, logContext);
+            this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET_ERROR, MOBIUS_SOCKET_ACTION.DISCONNECT, METRIC_TYPE.BEHAVIORAL, wssUrl, undefined, String(err));
+        }
+    }
+    async makeRequest(request) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.MAKE_REQUEST,
+        };
+        log.info(`Dispatching request via ${this.isMobiusSocketEnabled ? 'WSS' : 'HTTP'} `, logContext);
+        if (this.isMobiusSocketEnabled) {
+            const trackingId = `webex-js-sdk_${uuid()}`;
+            const socketType = deriveMobiusSocketMessageType(request.uri, request.method);
+            if (socketType === MOBIUS_SOCKET_MESSAGE_TYPE.UNKNOWN) {
+                log.error(`Unknown Mobius Socket message type for uri: ${request.uri}, httpMethod: ${request.method}`, logContext);
+                throw new Error(`Unknown Mobius Socket message type: ${socketType}`);
+            }
+            const isSupplementaryService = isSupplementaryServiceMessageType(socketType);
+            try {
+                const wsResponse = await this.mobiusSocket.sendWssRequest({
+                    type: socketType,
+                    trackingId,
+                    metadata: {
+                        ...request.headers,
+                        userAgent: CALLING_USER_AGENT,
+                        authorization: `${(isSupplementaryService && (await this.webex.credentials.getUserToken())) || ''}`,
+                    },
+                    data: request.body,
+                });
+                log.log(`WSS request succeeded - socketType: ${socketType}, trackingId: ${trackingId}, statusCode: ${wsResponse.statusCode}`, logContext);
+                return normalizeWsResponse(wsResponse);
+            }
+            catch (err) {
+                log.error(`WSS request failed - socketType: ${socketType}, trackingId: ${trackingId}, error: ${String(err)}`, logContext);
+                throw normalizeWsError(err);
+            }
+        }
+        return this.webex.request(request);
+    }
+    registerMobiusSocketListener(cb) {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.REGISTER_MOBIUS_SOCKET_LISTENER,
+        };
+        log.info('Attaching Mobius async event listener', logContext);
+        this.mobiusSocket.on('event:async_event', (data) => {
+            log.trace(`Mobius async event received - eventType: ${data?.data?.eventType ?? 'unknown'}`, logContext);
+            cb(data);
+        });
+        log.log('Mobius async event listener attached', logContext);
+        this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.LISTENER_REGISTERED, METRIC_TYPE.BEHAVIORAL);
+    }
+    unregisterMobiusSocketListener() {
+        const logContext = {
+            file: REQUEST_FILE,
+            method: METHODS.UNREGISTER_MOBIUS_SOCKET_LISTENER,
+        };
+        log.info('Detaching Mobius async event listener', logContext);
+        this.mobiusSocket.off('event:async_event');
+        log.log('Mobius async event listener detached', logContext);
+        this.metricManager?.submitMobiusSocketMetric(METRIC_EVENT.MOBIUS_SOCKET, MOBIUS_SOCKET_ACTION.LISTENER_UNREGISTERED, METRIC_TYPE.BEHAVIORAL);
+    }
+}
+export const createAPIRequest = (config) => APIRequest.getInstance(config);

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,41 @@
+import log from '../../Logger';
+import { METHODS, WS_FEATURE_FLAG_FILE } from '../constants';
+export const WEBRTC_CALLING_OVER_WS_FEATURE_KEY = 'webrtc-calling-over-ws-CALL-219562';
+const ALLOWED_ORIGINS = ['localhost', '127.0.0.1', 'web-sdk.webex.com'];
+function samplesPageToggleValue() {
+    if (typeof window === 'undefined' || !window.localStorage) {
+        return null;
+    }
+    const hostname = window.location.hostname;
+    const isAllowedOrigin = ALLOWED_ORIGINS.some((origin) => hostname === origin || hostname.endsWith(`.${origin}`));
+    if (!isAllowedOrigin) {
+        return null;
+    }
+    const localStorageValue = localStorage.getItem('mobius-wss-enabled');
+    if (localStorageValue === 'true') {
+        log.trace(`Mobius WSS force-enabled via samples page localStorage override on ${hostname}`, {
+            file: WS_FEATURE_FLAG_FILE,
+            method: METHODS.IS_MOBIUS_WSS_ENABLED,
+        });
+        return true;
+    }
+    if (localStorageValue === 'false') {
+        log.trace(`Mobius WSS force-disabled via samples page localStorage override on ${hostname}`, {
+            file: WS_FEATURE_FLAG_FILE,
+            method: METHODS.IS_MOBIUS_WSS_ENABLED,
+        });
+        return false;
+    }
+    return null;
+}
+export function isMobiusWssEnabled(webex) {
+    const enabled = webex.internal?.device?.features?.developer?.get(WEBRTC_CALLING_OVER_WS_FEATURE_KEY)?.value ===
+        true;
+    const localStorageOverride = samplesPageToggleValue();
+    const finalValue = localStorageOverride !== null ? localStorageOverride : enabled;
+    log.trace(`Mobius WSS feature flag '${WEBRTC_CALLING_OVER_WS_FEATURE_KEY}' resolved to: ${finalValue} (backend: ${enabled}, localStorage: ${localStorageOverride})`, {
+        file: WS_FEATURE_FLAG_FILE,
+        method: METHODS.IS_MOBIUS_WSS_ENABLED,
+    });
+    return finalValue;
+}

package/dist/module/Contacts/ContactsClient.js

@@ -283,7 +283,7 @@ export class ContactsClient {
             return this.encryptionKeyUrl;
         }
         if (this.groups === undefined) {
-            this.getContacts();
+            await this.getContacts();
         }
         if (this.groups && this.groups.length) {
             return this.groups[0].encryptionKeyUrl;

package/dist/module/Events/types.js

@@ -77,13 +77,3 @@ var CALL_STATE;
     CALL_STATE["REMOTE_HELD"] = "remoteheld";
     CALL_STATE["CONNECTED"] = "connected";
 })(CALL_STATE || (CALL_STATE = {}));
-export const WEBSOCKET_SCOPE = 'mobius';
-export var WEBSOCKET_KEYS;
-(function (WEBSOCKET_KEYS) {
-    WEBSOCKET_KEYS["CALL_PROGRESS"] = "callprogress";
-    WEBSOCKET_KEYS["CALL_CONNECTED"] = "callconnected";
-    WEBSOCKET_KEYS["CALL_DISCONNECTED"] = "callconnected";
-    WEBSOCKET_KEYS["CALL_INFO"] = "callinfo";
-    WEBSOCKET_KEYS["CALL"] = "call";
-    WEBSOCKET_KEYS["ROAP"] = "ROAP";
-})(WEBSOCKET_KEYS || (WEBSOCKET_KEYS = {}));

package/dist/module/Metrics/index.js

@@ -260,7 +260,7 @@ class MetricManager {
             this.webex.internal.metrics.submitClientMetrics(name, data);
         }
     }
-    submitMediaMetric(name, metricAction, type, callId, correlationId, localSdp, remoteSdp, callError) {
+    submitMediaMetric(name, metricAction, type, callId, correlationId, localSdp, remoteSdp, state, callError) {
         let data;
         switch (name) {
             case METRIC_EVENT.MEDIA: {
@@ -278,6 +278,7 @@ class MetricManager {
                         correlation_id: correlationId,
                         local_media_details: localSdp,
                         remote_media_details: remoteSdp,
+                        state,
                     },
                     type,
                 };
@@ -396,6 +397,52 @@ class MetricManager {
             this.webex.internal.metrics.submitClientMetrics(name, data);
         }
     }
+    submitMobiusSocketMetric(name, metricAction, type, wssUrl, trackingId, error, eventType) {
+        let data;
+        const commonTags = {
+            action: metricAction,
+            device_id: this.deviceInfo?.device?.deviceId,
+            service_indicator: this.serviceIndicator,
+        };
+        const commonFields = {
+            device_url: this.deviceInfo?.device?.clientDeviceUri,
+            mobius_url: this.deviceInfo?.device?.uri,
+            calling_sdk_version: process.env.CALLING_SDK_VERSION || VERSION,
+            wss_url: wssUrl,
+            tracking_id: trackingId,
+            event_type: eventType,
+        };
+        switch (name) {
+            case METRIC_EVENT.MOBIUS_SOCKET: {
+                data = {
+                    tags: commonTags,
+                    fields: commonFields,
+                    type,
+                };
+                break;
+            }
+            case METRIC_EVENT.MOBIUS_SOCKET_ERROR: {
+                data = {
+                    tags: commonTags,
+                    fields: {
+                        ...commonFields,
+                        error,
+                    },
+                    type,
+                };
+                break;
+            }
+            default:
+                log.warn('Invalid metric name received. Rejecting request to submit metric.', {
+                    file: METRIC_FILE,
+                    method: 'submitMobiusSocketMetric',
+                });
+                break;
+        }
+        if (data) {
+            this.webex.internal.metrics.submitClientMetrics(name, data);
+        }
+    }
 }
 export const getMetricManager = (webex, indicator) => {
     if (!metricManager && webex) {

package/dist/module/Metrics/types.js

@@ -20,6 +20,8 @@ export var METRIC_EVENT;
     METRIC_EVENT["UPLOAD_LOGS_SUCCESS"] = "web-calling-sdk-upload-logs-success";
     METRIC_EVENT["UPLOAD_LOGS_FAILED"] = "web-calling-sdk-upload-logs-failed";
     METRIC_EVENT["MOBIUS_DISCOVERY"] = "web-calling-sdk-mobius-discovery";
+    METRIC_EVENT["MOBIUS_SOCKET"] = "web-calling-sdk-mobius-socket";
+    METRIC_EVENT["MOBIUS_SOCKET_ERROR"] = "web-calling-sdk-mobius-socket-error";
 })(METRIC_EVENT || (METRIC_EVENT = {}));
 export var MOBIUS_SERVER_ACTION;
 (function (MOBIUS_SERVER_ACTION) {
@@ -32,6 +34,14 @@ export var REG_ACTION;
     REG_ACTION["DEREGISTER"] = "deregister";
     REG_ACTION["KEEPALIVE_FAILURE"] = "keepaliveFailure";
 })(REG_ACTION || (REG_ACTION = {}));
+export var MOBIUS_SOCKET_ACTION;
+(function (MOBIUS_SOCKET_ACTION) {
+    MOBIUS_SOCKET_ACTION["CONNECT"] = "connect";
+    MOBIUS_SOCKET_ACTION["DISCONNECT"] = "disconnect";
+    MOBIUS_SOCKET_ACTION["LISTENER_REGISTERED"] = "listener_registered";
+    MOBIUS_SOCKET_ACTION["LISTENER_UNREGISTERED"] = "listener_unregistered";
+    MOBIUS_SOCKET_ACTION["REGISTRATION_DOWN"] = "registration_down";
+})(MOBIUS_SOCKET_ACTION || (MOBIUS_SOCKET_ACTION = {}));
 export var TRANSFER_ACTION;
 (function (TRANSFER_ACTION) {
     TRANSFER_ACTION["BLIND"] = "TRANSFER_BLIND";
@@ -54,3 +64,11 @@ export var CONNECTION_ACTION;
     CONNECTION_ACTION["MERCURY_DOWN"] = "mercury_down";
     CONNECTION_ACTION["MERCURY_UP"] = "mercury_up";
 })(CONNECTION_ACTION || (CONNECTION_ACTION = {}));
+export var MEDIA_CONNECTION_ACTION;
+(function (MEDIA_CONNECTION_ACTION) {
+    MEDIA_CONNECTION_ACTION["ICE_GATHERING_STATE_CHANGED"] = "ICE_GATHERING_STATE_CHANGED";
+    MEDIA_CONNECTION_ACTION["PEER_CONNECTION_STATE_CHANGED"] = "PEER_CONNECTION_STATE_CHANGED";
+    MEDIA_CONNECTION_ACTION["ICE_CONNECTION_STATE_CHANGED"] = "ICE_CONNECTION_STATE_CHANGED";
+    MEDIA_CONNECTION_ACTION["ICE_CANDIDATE_ERROR"] = "ICE_CANDIDATE_ERROR";
+    MEDIA_CONNECTION_ACTION["ROAP_FAILURE"] = "ROAP_FAILURE";
+})(MEDIA_CONNECTION_ACTION || (MEDIA_CONNECTION_ACTION = {}));