@webex/calling 3.10.0 → 3.11.0-next.10

package/dist/module/CallSettings/WxCallBackendConnector.js

@@ -19,7 +19,9 @@ export class WxCallBackendConnector {
             SDKConnector.setWebex(webex);
         }
         this.webex = this.sdkConnector.getWebex();
-        this.hydraEndpoint = this.webex.internal.services._serviceUrls.hydra;
+        this.hydraEndpoint =
+            this.webex.internal.services._serviceUrls?.hydra ||
+                this.webex.internal.services.get(this.webex.internal.services._activeServices.hydra);
         log.setLogger(logger.level, WEBEX_CALLING_CONNECTOR_FILE);
         this.userId = this.webex.internal.device.userId;
         this.personId = inferIdFromUuid(this.webex.internal.device.userId, DecodeType.PEOPLE);
@@ -66,8 +68,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to get call waiting setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to get call waiting setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = {
                 statusCode: err instanceof Error ? Number(err.message) : '',
@@ -100,8 +101,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to get DoNotDisturb setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to get DoNotDisturb setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
@@ -136,8 +136,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to set DoNotDisturb setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to set DoNotDisturb setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
@@ -168,8 +167,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to get Call Forward setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to get Call Forward setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
@@ -200,8 +198,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to set Call Forward setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to set Call Forward setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
@@ -232,8 +229,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to get Voicemail setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to get Voicemail setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
@@ -264,8 +260,7 @@ export class WxCallBackendConnector {
             return responseDetails;
         }
         catch (err) {
-            const extendedError = new Error(`Failed to set Voicemail setting: ${err}`);
-            log.error(extendedError, loggerContext);
+            log.error(`Failed to set Voicemail setting: ${JSON.stringify(err)}`, loggerContext);
             await uploadLogs();
             const errorInfo = err;
             const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);

package/dist/module/CallingClient/CallingClient.js

@@ -9,7 +9,7 @@ import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../E
 import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, RegistrationStatus, } from '../common/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, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, API_V1, MOBIUS_US_PROD, MOBIUS_EU_PROD, MOBIUS_US_INT, MOBIUS_EU_INT, 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';
@@ -65,28 +65,7 @@ export class CallingClient extends Eventing {
         this.mediaEngine.setLogger(adaptedLogger);
         this.primaryMobiusUris = [];
         this.backupMobiusUris = [];
-        let mobiusServiceHost = '';
-        try {
-            mobiusServiceHost = new URL(this.webex.internal.services._serviceUrls.mobius).host;
-        }
-        catch (error) {
-            log.warn(`Failed to parse mobius service URL`, {
-                file: CALLING_CLIENT_FILE,
-                method: this.constructor.name,
-            });
-        }
-        if (this.webex.internal.services._hostCatalog) {
-            this.mobiusClusters =
-                (mobiusServiceHost && this.webex.internal.services._hostCatalog[mobiusServiceHost]) ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_US_PROD] ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_EU_PROD] ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_US_INT] ||
-                    this.webex.internal.services._hostCatalog[MOBIUS_EU_INT];
-        }
-        else {
-            const mobiusObject = this.webex.internal.services._services.find((item) => item.serviceName === 'mobius');
-            this.mobiusClusters = [mobiusObject.serviceUrls[0].baseUrl];
-        }
+        this.mobiusClusters = this.webex.internal.services.getMobiusClusters();
         this.mobiusHost = '';
         this.registerSessionsListener();
         this.registerCallsClearedListener();
@@ -237,68 +216,38 @@ export class CallingClient extends Eventing {
             method: METHODS.GET_CLIENT_REGION_INFO,
         });
         const regionInfo = {};
-        for (const mobius of this.mobiusClusters) {
-            if (mobius.host) {
-                this.mobiusHost = `https://${mobius.host}${API_V1}`;
-            }
-            else {
-                this.mobiusHost = mobius;
-            }
-            try {
-                const temp = await this.webex.request({
-                    uri: `${this.mobiusHost}${URL_ENDPOINT}${IP_ENDPOINT}`,
-                    method: HTTP_METHODS.GET,
-                    headers: {
-                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
-                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                    },
-                    service: ALLOWED_SERVICES.MOBIUS,
-                });
-                log.log(`Response trackingId: ${temp?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                });
-                const myIP = temp.body.ipv4;
-                const response = await this.webex.request({
-                    uri: `${DISCOVERY_URL}/${myIP}`,
-                    method: HTTP_METHODS.GET,
-                    addAuthHeader: false,
-                    headers: {
-                        [SPARK_USER_AGENT]: null,
-                    },
-                });
-                log.log(`Response trackingId: ${response?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                });
-                const clientRegionInfo = response.body;
-                regionInfo.clientRegion = clientRegionInfo?.clientRegion
-                    ? clientRegionInfo.clientRegion
-                    : '';
-                regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
-                log.log(`Successfully fetched Client region info: ${regionInfo.clientRegion}, countryCode: ${regionInfo.countryCode}, and response trackingid: ${response?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                });
-                this.metricManager.submitRegionInfoMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.REGION_INFO, METRIC_TYPE.BEHAVIORAL, this.mobiusHost, clientRegionInfo.clientRegion, clientRegionInfo.countryCode, response?.headers?.trackingid ?? '');
-                break;
-            }
-            catch (err) {
-                const extendedError = new Error(`Failed to get client region info: ${err}`);
-                log.error(extendedError, {
-                    method: METHODS.GET_CLIENT_REGION_INFO,
-                    file: CALLING_CLIENT_FILE,
-                });
-                abort = await handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
-                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
-                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-                regionInfo.clientRegion = '';
-                regionInfo.countryCode = '';
-                if (abort) {
-                    await uploadLogs();
-                    return regionInfo;
-                }
+        try {
+            const response = await this.webex.request({
+                uri: `${DISCOVERY_URL}`,
+                method: HTTP_METHODS.GET,
+                addAuthHeader: false,
+                headers: {
+                    [SPARK_USER_AGENT]: null,
+                },
+            });
+            const clientRegionInfo = response.body;
+            regionInfo.clientRegion = clientRegionInfo?.clientRegion || '';
+            regionInfo.countryCode = clientRegionInfo?.countryCode || '';
+            log.log(`Successfully fetched Client region info: ${regionInfo.clientRegion}, countryCode: ${regionInfo.countryCode}, and response trackingid: ${response?.headers?.trackingid}`, {
+                file: CALLING_CLIENT_FILE,
+                method: METHODS.GET_CLIENT_REGION_INFO,
+            });
+            this.metricManager.submitRegionInfoMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.REGION_INFO, METRIC_TYPE.BEHAVIORAL, this.mobiusHost, clientRegionInfo.clientRegion, clientRegionInfo.countryCode, response?.headers?.trackingid ?? '');
+        }
+        catch (err) {
+            log.error(`Failed to get client region info: ${JSON.stringify(err)}`, {
+                method: METHODS.GET_CLIENT_REGION_INFO,
+                file: CALLING_CLIENT_FILE,
+            });
+            abort = await handleCallingClientErrors(err, (clientError) => {
+                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
+            }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+            regionInfo.clientRegion = '';
+            regionInfo.countryCode = '';
+            if (abort) {
+                await uploadLogs();
+                return regionInfo;
             }
         }
         return regionInfo;
@@ -318,7 +267,9 @@ export class CallingClient extends Eventing {
             });
             clientRegion = this.sdkConfig?.discovery?.region;
             countryCode = this.sdkConfig?.discovery?.country;
-            this.mobiusHost = this.webex.internal.services._serviceUrls.mobius;
+            this.mobiusHost =
+                this.webex.internal.services._serviceUrls?.mobius ||
+                    this.webex.internal.services.get(this.webex.internal.services._activeServices.mobius);
         }
         else {
             log.log('Updating region and country through Region discovery', {
@@ -334,44 +285,53 @@ export class CallingClient extends Eventing {
                 file: CALLING_CLIENT_FILE,
                 method: GET_MOBIUS_SERVERS_UTIL,
             });
-            try {
-                const response = await this.webex.request({
-                    uri: `${this.mobiusHost}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
-                    method: HTTP_METHODS.GET,
-                    headers: {
-                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
-                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                    },
-                    service: ALLOWED_SERVICES.MOBIUS,
-                });
-                log.log(`Mobius Server found for the region. Response trackingId: ${response?.headers?.trackingid}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: GET_MOBIUS_SERVERS_UTIL,
-                });
-                const mobiusServers = response.body;
-                this.metricManager.submitMobiusServersMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.MOBIUS_SERVERS, METRIC_TYPE.BEHAVIORAL, mobiusServers, response?.headers?.trackingid ?? '');
-                const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
-                this.primaryMobiusUris = mobiusUris.primary;
-                this.backupMobiusUris = mobiusUris.backup;
-                log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: GET_MOBIUS_SERVERS_UTIL,
-                });
-            }
-            catch (err) {
-                const extendedError = new Error(`Failed to get Mobius servers: ${err}`);
-                log.error(extendedError, {
-                    method: METHODS.GET_MOBIUS_SERVERS,
-                    file: CALLING_CLIENT_FILE,
-                });
-                const abort = await handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
-                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
-                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-                if (abort) {
-                    await uploadLogs();
+            for (const mobius of this.mobiusClusters) {
+                if (mobius.host) {
+                    this.mobiusHost = `https://${mobius.host}${API_V1}`;
+                }
+                else {
+                    this.mobiusHost = mobius;
+                }
+                try {
+                    const response = await this.webex.request({
+                        uri: `${this.mobiusHost}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
+                        method: HTTP_METHODS.GET,
+                        headers: {
+                            [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                            [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                        },
+                        service: ALLOWED_SERVICES.MOBIUS,
+                    });
+                    log.log(`Mobius Server found for the region. Response trackingId: ${response?.headers?.trackingid}`, {
+                        file: CALLING_CLIENT_FILE,
+                        method: GET_MOBIUS_SERVERS_UTIL,
+                    });
+                    const mobiusServers = response.body;
+                    this.metricManager.submitMobiusServersMetric(METRIC_EVENT.MOBIUS_DISCOVERY, MOBIUS_SERVER_ACTION.MOBIUS_SERVERS, METRIC_TYPE.BEHAVIORAL, mobiusServers, response?.headers?.trackingid ?? '');
+                    const mobiusUris = filterMobiusUris(mobiusServers, this.mobiusHost);
+                    this.primaryMobiusUris = mobiusUris.primary;
+                    this.backupMobiusUris = mobiusUris.backup;
+                    log.log(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, {
+                        file: CALLING_CLIENT_FILE,
+                        method: GET_MOBIUS_SERVERS_UTIL,
+                    });
+                    break;
+                }
+                catch (err) {
+                    log.error(`Failed to get Mobius servers: ${JSON.stringify(err)}`, {
+                        method: METHODS.GET_MOBIUS_SERVERS,
+                        file: CALLING_CLIENT_FILE,
+                    });
+                    const abort = await handleCallingClientErrors(err, (clientError) => {
+                        this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, GET_MOBIUS_SERVERS_UTIL, 'UNKNOWN', err.headers?.trackingId ?? '', undefined, clientError);
+                        this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
+                    }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+                    if (abort) {
+                        useDefault = true;
+                        await uploadLogs();
+                        break;
+                    }
                 }
-                useDefault = true;
             }
         }
         else {
@@ -450,6 +410,48 @@ export class CallingClient extends Eventing {
     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.webex.request({
+                    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,13 +1,13 @@
 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, 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, 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';
@@ -51,6 +51,7 @@ export class Call extends Eventing {
     receivedRoapOKSeq;
     localAudioStream;
     rtcMetrics;
+    callKeepaliveRetryCount = 0;
     isMuted() {
         return this.muted;
     }
@@ -639,8 +640,7 @@ export class Call extends Eventing {
             });
         }
         catch (e) {
-            const extendedError = new Error(`Failed to setup the call: ${e}`);
-            log.error(extendedError, {
+            log.error(`Failed to setup the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_SETUP,
             });
@@ -682,8 +682,7 @@ export class Call extends Eventing {
             }
         }
         catch (e) {
-            const extendedError = new Error(`Failed to put the call on hold: ${e}`);
-            log.error(extendedError, {
+            log.error(`Failed to put the call on hold: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_CALL_HOLD,
             });
@@ -725,8 +724,7 @@ export class Call extends Eventing {
             }
         }
         catch (e) {
-            const extendedError = new Error(`Failed to resume the call: ${e}`);
-            log.error(extendedError, {
+            log.error(`Failed to resume the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_CALL_RESUME,
             });
@@ -814,13 +812,12 @@ export class Call extends Eventing {
                 method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
             });
         }
-        catch (err) {
-            const extendedError = new Error(`Failed to signal call progression: ${err}`);
-            log.error(extendedError, {
+        catch (e) {
+            log.error(`Failed to signal call progression: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_ALERTING,
             });
-            const errData = err;
+            const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
@@ -864,13 +861,12 @@ export class Call extends Eventing {
                 method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
         }
-        catch (err) {
-            const extendedError = new Error(`Failed to connect the call: ${err}`);
-            log.error(extendedError, {
+        catch (e) {
+            log.error(`Failed to connect the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
                 method: METHODS.HANDLE_OUTGOING_CALL_CONNECT,
             });
-            const errData = err;
+            const errData = e;
             handleCallErrors((error) => {
                 this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
@@ -886,20 +882,21 @@ export class Call extends Eventing {
     async handleIncomingCallDisconnect(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
             file: CALL_FILE,
-            method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+            method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
         });
+        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
         this.setDisconnectReason();
         try {
             const response = await this.delete();
             log.log(`Response code: ${response.statusCode}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
         }
         catch (e) {
-            log.warn('Failed to delete the call', {
+            log.warn(`Failed to delete the call: ${JSON.stringify(e)}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_OUTGOING_CALL_DISCONNECT,
+                method: METHODS.HANDLE_INCOMING_CALL_DISCONNECT,
             });
             uploadLogs({
                 correlationId: this.correlationId,
@@ -916,12 +913,11 @@ 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' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
-        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
     }
     async handleOutgoingCallDisconnect(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
@@ -966,50 +962,71 @@ export class Call extends Eventing {
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
     }
-    handleCallEstablished(event) {
-        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
-            file: CALL_FILE,
-            method: METHODS.HANDLE_CALL_ESTABLISHED,
-        });
-        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
-        this.earlyMedia = false;
-        this.connected = true;
-        if (this.sessionTimer) {
-            log.log('Resetting session timer', {
+    callKeepaliveRetryCallback = (interval) => {
+        if (this.callKeepaliveRetryCount === MAX_CALL_KEEPALIVE_RETRY_COUNT) {
+            log.warn(`Max keepalive retry attempts reached. Aborting call keepalive for callId: ${this.callId}`, {
                 file: CALL_FILE,
-                method: METHODS.HANDLE_CALL_ESTABLISHED,
+                method: 'keepaliveRetryCallback',
             });
+            return;
+        }
+        this.callKeepaliveRetryCount += 1;
+        setTimeout(async () => {
+            try {
+                await this.postStatus();
+                this.scheduleCallKeepaliveInterval();
+            }
+            catch (err) {
+                await this.handleCallKeepaliveError(err);
+            }
+        }, interval * 1000);
+    };
+    handleCallKeepaliveError = async (err) => {
+        const error = err;
+        if (this.sessionTimer) {
             clearInterval(this.sessionTimer);
         }
+        const abort = await handleCallErrors((callError) => {
+            this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
+            this.submitCallErrorMetric(callError);
+        }, ERROR_LAYER.CALL_CONTROL, this.callKeepaliveRetryCallback, this.getCorrelationId(), error, 'handleCallEstablished', CALL_FILE);
+        if (abort) {
+            this.sendCallStateMachineEvt({ type: 'E_SEND_CALL_DISCONNECT' });
+            this.emit(CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
+            this.callKeepaliveRetryCount = 0;
+        }
+        await uploadLogs({
+            correlationId: this.correlationId,
+            callId: this.callId,
+            broadworksCorrelationInfo: this.broadworksCorrelationInfo,
+        });
+    };
+    scheduleCallKeepaliveInterval = () => {
+        const loggerContext = {
+            file: CALL_FILE,
+            method: 'scheduleCallKeepaliveInterval',
+        };
+        clearInterval(this.sessionTimer);
         this.sessionTimer = setInterval(async () => {
             try {
                 const res = await this.postStatus();
-                log.info(`Session refresh successful`, {
-                    file: CALL_FILE,
-                    method: METHODS.HANDLE_CALL_ESTABLISHED,
-                });
+                log.info(`Session refresh successful`, loggerContext);
             }
             catch (err) {
-                const error = err;
-                if (this.sessionTimer) {
-                    clearInterval(this.sessionTimer);
-                }
-                handleCallErrors((callError) => {
-                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
-                    this.submitCallErrorMetric(callError);
-                }, ERROR_LAYER.CALL_CONTROL, (interval) => {
-                    setTimeout(() => {
-                        this.postStatus();
-                        this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
-                    }, interval * 1000);
-                }, this.getCorrelationId(), error, this.handleCallEstablished.name, CALL_FILE);
-                await uploadLogs({
-                    correlationId: this.correlationId,
-                    callId: this.callId,
-                    broadworksCorrelationInfo: this.broadworksCorrelationInfo,
-                });
+                await this.handleCallKeepaliveError(err);
             }
         }, DEFAULT_SESSION_TIMER);
+    };
+    handleCallEstablished(event) {
+        const loggerContext = {
+            file: CALL_FILE,
+            method: METHODS.HANDLE_CALL_ESTABLISHED,
+        };
+        log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, loggerContext);
+        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
+        this.earlyMedia = false;
+        this.connected = true;
+        this.scheduleCallKeepaliveInterval();
     }
     async handleUnknownState(event) {
         log.info(`${METHOD_START_MESSAGE} with: ${this.getCorrelationId()}`, {
@@ -1164,7 +1181,7 @@ export class Call extends Eventing {
             method: METHODS.HANDLE_ROAP_ERROR,
         });
         const message = event.data;
-        if (message) {
+        if (message && message.messageType === 'ERROR') {
             try {
                 const res = await this.postMedia(message);
                 log.info(`Response code: ${res.statusCode}`, {
@@ -1219,7 +1236,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,
             });
@@ -1332,9 +1349,8 @@ export class Call extends Eventing {
         }
         catch (error) {
             const errorInfo = error;
-            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
-            const errorLog = new Error(`Failed to upload webrtc telemetry statistics. ${errorStatus}`);
-            log.error(errorLog, loggerContext);
+            const errorStatus = await serviceErrorCodeHandler(errorInfo, loggerContext);
+            log.error(`Failed to upload webrtc telemetry statistics. ${JSON.stringify(errorStatus)}`, loggerContext);
             await uploadLogs({
                 correlationId: this.correlationId,
                 callId: this.callId,

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

@@ -137,6 +137,13 @@ 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;
             }