@webex/calling 0.0.1-next.0 → 0.0.1-next.1

package/dist/module/CallingClient/CallingClient.js

@@ -1,268 +1,268 @@
-import * as Media from '@webex/internal-media-core';
-import { Mutex } from 'async-mutex';
-import { filterMobiusUris, handleCallingClientErrors, validateServiceData } from '../common/Utils';
-import { ERROR_TYPE } from '../Errors/types';
-import { LOGGER } from '../Logger/types';
-import SDKConnector from '../SDKConnector';
-import { Eventing } from '../Events/impl';
-import { EVENT_KEYS, MOBIUS_EVENT_KEYS, SessionType, } from '../Events/types';
-import { MobiusStatus, CallDirection, ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
-import log from '../Logger';
-import { getCallManager } from './calling/callManager';
-import { CALLING_CLIENT_FILE, VALID_PHONE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, } from './constants';
-import { CallingClientError } from '../Errors';
-import Line from './line';
-import { LINE_EVENTS, LineStatus } from './line/types';
-import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
-import { getMetricManager } from '../Metrics';
-export class CallingClient extends Eventing {
-    sdkConnector;
-    webex;
-    mutex;
-    callManager;
-    metricManager;
-    sdkConfig;
-    primaryMobiusUris;
-    backupMobiusUris;
-    mediaEngine;
-    lineDict = {};
-    constructor(webex, config) {
-        super();
-        this.sdkConnector = SDKConnector;
-        if (!this.sdkConnector.getWebex()) {
-            SDKConnector.setWebex(webex);
-        }
-        this.mutex = new Mutex();
-        this.webex = this.sdkConnector.getWebex();
-        this.sdkConfig = config;
-        const serviceData = this.sdkConfig?.serviceData?.indicator
-            ? this.sdkConfig.serviceData
-            : { indicator: ServiceIndicator.CALLING, domain: '' };
-        const logLevel = this.sdkConfig?.logger?.level ? this.sdkConfig.logger.level : LOGGER.ERROR;
-        validateServiceData(serviceData);
-        this.callManager = getCallManager(this.webex, serviceData.indicator);
-        this.metricManager = getMetricManager(this.webex, serviceData.indicator);
-        this.mediaEngine = Media;
-        this.primaryMobiusUris = [];
-        this.backupMobiusUris = [];
-        this.registerSessionsListener();
-        log.setLogger(logLevel, CALLING_CLIENT_FILE);
-        this.incomingCallListener();
-        this.registerCallsClearedListener();
-    }
-    async init() {
-        await this.getMobiusServers();
-        await this.createLine();
-        this.detectNetworkChange();
-    }
-    incomingCallListener() {
-        const logContext = {
-            file: CALLING_CLIENT_FILE,
-            method: this.incomingCallListener.name,
-        };
-        log.log('Listening for incoming calls... ', logContext);
-        this.callManager.on(EVENT_KEYS.INCOMING_CALL, (callObj) => {
-            this.emit(EVENT_KEYS.INCOMING_CALL, callObj);
-        });
-    }
-    async detectNetworkChange() {
-        let retry = false;
-        const line = Object.values(this.lineDict)[0];
-        setInterval(async () => {
-            if (!this.webex.internal.mercury.connected &&
-                !retry &&
-                !Object.keys(this.callManager.getActiveCalls()).length) {
-                log.warn(`Network has flapped, waiting for mercury connection to be up`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: this.detectNetworkChange.name,
-                });
-                line.lineEmitter(LINE_EVENTS.UNREGISTERED);
-                line.registration.clearKeepaliveTimer();
-                retry = true;
-            }
-            if (retry && this.webex.internal.mercury.connected) {
-                retry = await line.registration.handleConnectionRestoration(retry);
-            }
-        }, NETWORK_FLAP_TIMEOUT);
-    }
-    async getClientRegionInfo() {
-        const regionInfo = {};
-        try {
-            const temp = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.mobius}${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,
-            });
-            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,
-                },
-            });
-            const clientRegionInfo = response.body;
-            regionInfo.clientRegion = clientRegionInfo?.clientRegion ? clientRegionInfo.clientRegion : '';
-            regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
-        }
-        catch (err) {
-            handleCallingClientErrors(err, (clientError) => {
-                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                this.emit(EVENT_KEYS.ERROR, clientError);
-            }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-            regionInfo.clientRegion = '';
-            regionInfo.countryCode = '';
-        }
-        return regionInfo;
-    }
-    async getMobiusServers() {
-        let useDefault = false;
-        let clientRegion;
-        let countryCode;
-        if (this.sdkConfig?.discovery?.country && this.sdkConfig?.discovery?.region) {
-            log.info('Updating region and country from the SDK config', {
-                file: CALLING_CLIENT_FILE,
-                method: GET_MOBIUS_SERVERS_UTIL,
-            });
-            clientRegion = this.sdkConfig?.discovery?.region;
-            countryCode = this.sdkConfig?.discovery?.country;
-        }
-        else {
-            log.info('Updating region and country through Region discovery', {
-                file: CALLING_CLIENT_FILE,
-                method: GET_MOBIUS_SERVERS_UTIL,
-            });
-            const regionInfo = await this.getClientRegionInfo();
-            clientRegion = regionInfo.clientRegion;
-            countryCode = regionInfo.countryCode;
-        }
-        if (clientRegion && countryCode) {
-            log.log(`Found Region: ${clientRegion} and country: ${countryCode}, going to fetch Mobius server`, '');
-            try {
-                const temp = await this.webex.request({
-                    uri: `${this.webex.internal.services._serviceUrls.mobius}${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', '');
-                const mobiusServers = temp.body;
-                const mobiusUris = filterMobiusUris(mobiusServers, this.webex.internal.services._serviceUrls.mobius);
-                this.primaryMobiusUris = mobiusUris.primary;
-                this.backupMobiusUris = mobiusUris.backup;
-                log.info(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, '');
-            }
-            catch (err) {
-                handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                    this.emit(EVENT_KEYS.ERROR, clientError);
-                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-                useDefault = true;
-            }
-        }
-        else {
-            useDefault = true;
-        }
-        if (useDefault) {
-            log.warn('Error in finding Mobius Servers. Will use the default URL.', '');
-            this.primaryMobiusUris = [
-                `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}`,
-            ];
-        }
-    }
-    registerCallsClearedListener() {
-        const logContext = {
-            file: CALLING_CLIENT_FILE,
-            method: this.registerCallsClearedListener.name,
-        };
-        log.log('Registering listener for all calls cleared event', logContext);
-        this.callManager.on(EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
-    }
-    callsClearedHandler = async () => {
-        const { registration } = Object.values(this.lineDict)[0];
-        if (!registration.isDeviceRegistered()) {
-            await this.mutex.runExclusive(async () => {
-                if (registration.isReconnectPending()) {
-                    log.log('All calls cleared, reconnecting', {
-                        file: CALLING_CLIENT_FILE,
-                        method: CALLS_CLEARED_HANDLER_UTIL,
-                    });
-                    await registration.reconnectOnFailure(CALLS_CLEARED_HANDLER_UTIL);
-                }
-            });
-        }
-    };
-    getLoggingLevel() {
-        return log.getLogLevel();
-    }
-    getCall = (correlationId) => {
-        return this.callManager.getCall(correlationId);
-    };
-    makeCall = (dest) => {
-        let call;
-        const { registration } = Object.values(this.lineDict)[0];
-        if (dest) {
-            const match = dest.address.match(VALID_PHONE);
-            if (match && match[0].length === dest.address.length) {
-                const sanitizedNumber = dest.address
-                    .replace(/[^[*+]\d#]/gi, '')
-                    .replace(/\s+/gi, '')
-                    .replace(/-/gi, '');
-                const formattedDest = {
-                    type: dest.type,
-                    address: `tel:${sanitizedNumber}`,
-                };
-                call = this.callManager.createCall(formattedDest, CallDirection.OUTBOUND, registration.getDeviceInfo().device?.deviceId);
-                log.log(`New call created, callId: ${call.getCallId()}`, {});
-            }
-            else {
-                log.warn('Invalid phone number detected', {});
-                const err = new CallingClientError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, MobiusStatus.ACTIVE);
-                this.emit(EVENT_KEYS.ERROR, err);
-            }
-            return call;
-        }
-        return undefined;
-    };
-    getSDKConnector() {
-        return this.sdkConnector;
-    }
-    registerSessionsListener() {
-        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
-            if (event && event.data.userSessions.userSessions) {
-                const sessionArr = event?.data.userSessions.userSessions;
-                if (sessionArr.length === 1) {
-                    if (sessionArr[0].sessionType !== SessionType.WEBEX_CALLING) {
-                        return;
-                    }
-                }
-                for (let i = 0; i < sessionArr.length; i += 1) {
-                    if (sessionArr[i].sessionType !== SessionType.WEBEX_CALLING) {
-                        sessionArr.splice(i, 1);
-                    }
-                }
-                this.emit(EVENT_KEYS.USER_SESSION_INFO, event);
-            }
-        });
-    }
-    async createLine() {
-        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, LineStatus.INACTIVE, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData);
-        this.lineDict[line.lineId] = line;
-    }
-    getLines() {
-        return this.lineDict;
-    }
-}
-export const createClient = async (webex, config) => {
-    const callingClientInstance = new CallingClient(webex, config);
-    await callingClientInstance.init();
-    return callingClientInstance;
-};
+import * as Media from '@webex/internal-media-core';
+import { Mutex } from 'async-mutex';
+import { filterMobiusUris, handleCallingClientErrors, validateServiceData } from '../common/Utils';
+import { ERROR_TYPE } from '../Errors/types';
+import { LOGGER } from '../Logger/types';
+import SDKConnector from '../SDKConnector';
+import { Eventing } from '../Events/impl';
+import { EVENT_KEYS, MOBIUS_EVENT_KEYS, SessionType, } from '../Events/types';
+import { MobiusStatus, CallDirection, ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
+import log from '../Logger';
+import { getCallManager } from './calling/callManager';
+import { CALLING_CLIENT_FILE, VALID_PHONE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, } from './constants';
+import { CallingClientError } from '../Errors';
+import Line from './line';
+import { LINE_EVENTS, LineStatus } from './line/types';
+import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
+import { getMetricManager } from '../Metrics';
+export class CallingClient extends Eventing {
+    sdkConnector;
+    webex;
+    mutex;
+    callManager;
+    metricManager;
+    sdkConfig;
+    primaryMobiusUris;
+    backupMobiusUris;
+    mediaEngine;
+    lineDict = {};
+    constructor(webex, config) {
+        super();
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.mutex = new Mutex();
+        this.webex = this.sdkConnector.getWebex();
+        this.sdkConfig = config;
+        const serviceData = this.sdkConfig?.serviceData?.indicator
+            ? this.sdkConfig.serviceData
+            : { indicator: ServiceIndicator.CALLING, domain: '' };
+        const logLevel = this.sdkConfig?.logger?.level ? this.sdkConfig.logger.level : LOGGER.ERROR;
+        validateServiceData(serviceData);
+        this.callManager = getCallManager(this.webex, serviceData.indicator);
+        this.metricManager = getMetricManager(this.webex, serviceData.indicator);
+        this.mediaEngine = Media;
+        this.primaryMobiusUris = [];
+        this.backupMobiusUris = [];
+        this.registerSessionsListener();
+        log.setLogger(logLevel, CALLING_CLIENT_FILE);
+        this.incomingCallListener();
+        this.registerCallsClearedListener();
+    }
+    async init() {
+        await this.getMobiusServers();
+        await this.createLine();
+        this.detectNetworkChange();
+    }
+    incomingCallListener() {
+        const logContext = {
+            file: CALLING_CLIENT_FILE,
+            method: this.incomingCallListener.name,
+        };
+        log.log('Listening for incoming calls... ', logContext);
+        this.callManager.on(EVENT_KEYS.INCOMING_CALL, (callObj) => {
+            this.emit(EVENT_KEYS.INCOMING_CALL, callObj);
+        });
+    }
+    async detectNetworkChange() {
+        let retry = false;
+        const line = Object.values(this.lineDict)[0];
+        setInterval(async () => {
+            if (!this.webex.internal.mercury.connected &&
+                !retry &&
+                !Object.keys(this.callManager.getActiveCalls()).length) {
+                log.warn(`Network has flapped, waiting for mercury connection to be up`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: this.detectNetworkChange.name,
+                });
+                line.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                line.registration.clearKeepaliveTimer();
+                retry = true;
+            }
+            if (retry && this.webex.internal.mercury.connected) {
+                retry = await line.registration.handleConnectionRestoration(retry);
+            }
+        }, NETWORK_FLAP_TIMEOUT);
+    }
+    async getClientRegionInfo() {
+        const regionInfo = {};
+        try {
+            const temp = await this.webex.request({
+                uri: `${this.webex.internal.services._serviceUrls.mobius}${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,
+            });
+            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,
+                },
+            });
+            const clientRegionInfo = response.body;
+            regionInfo.clientRegion = clientRegionInfo?.clientRegion ? clientRegionInfo.clientRegion : '';
+            regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
+        }
+        catch (err) {
+            handleCallingClientErrors(err, (clientError) => {
+                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                this.emit(EVENT_KEYS.ERROR, clientError);
+            }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+            regionInfo.clientRegion = '';
+            regionInfo.countryCode = '';
+        }
+        return regionInfo;
+    }
+    async getMobiusServers() {
+        let useDefault = false;
+        let clientRegion;
+        let countryCode;
+        if (this.sdkConfig?.discovery?.country && this.sdkConfig?.discovery?.region) {
+            log.info('Updating region and country from the SDK config', {
+                file: CALLING_CLIENT_FILE,
+                method: GET_MOBIUS_SERVERS_UTIL,
+            });
+            clientRegion = this.sdkConfig?.discovery?.region;
+            countryCode = this.sdkConfig?.discovery?.country;
+        }
+        else {
+            log.info('Updating region and country through Region discovery', {
+                file: CALLING_CLIENT_FILE,
+                method: GET_MOBIUS_SERVERS_UTIL,
+            });
+            const regionInfo = await this.getClientRegionInfo();
+            clientRegion = regionInfo.clientRegion;
+            countryCode = regionInfo.countryCode;
+        }
+        if (clientRegion && countryCode) {
+            log.log(`Found Region: ${clientRegion} and country: ${countryCode}, going to fetch Mobius server`, '');
+            try {
+                const temp = await this.webex.request({
+                    uri: `${this.webex.internal.services._serviceUrls.mobius}${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', '');
+                const mobiusServers = temp.body;
+                const mobiusUris = filterMobiusUris(mobiusServers, this.webex.internal.services._serviceUrls.mobius);
+                this.primaryMobiusUris = mobiusUris.primary;
+                this.backupMobiusUris = mobiusUris.backup;
+                log.info(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, '');
+            }
+            catch (err) {
+                handleCallingClientErrors(err, (clientError) => {
+                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                    this.emit(EVENT_KEYS.ERROR, clientError);
+                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+                useDefault = true;
+            }
+        }
+        else {
+            useDefault = true;
+        }
+        if (useDefault) {
+            log.warn('Error in finding Mobius Servers. Will use the default URL.', '');
+            this.primaryMobiusUris = [
+                `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}`,
+            ];
+        }
+    }
+    registerCallsClearedListener() {
+        const logContext = {
+            file: CALLING_CLIENT_FILE,
+            method: this.registerCallsClearedListener.name,
+        };
+        log.log('Registering listener for all calls cleared event', logContext);
+        this.callManager.on(EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
+    }
+    callsClearedHandler = async () => {
+        const { registration } = Object.values(this.lineDict)[0];
+        if (!registration.isDeviceRegistered()) {
+            await this.mutex.runExclusive(async () => {
+                if (registration.isReconnectPending()) {
+                    log.log('All calls cleared, reconnecting', {
+                        file: CALLING_CLIENT_FILE,
+                        method: CALLS_CLEARED_HANDLER_UTIL,
+                    });
+                    await registration.reconnectOnFailure(CALLS_CLEARED_HANDLER_UTIL);
+                }
+            });
+        }
+    };
+    getLoggingLevel() {
+        return log.getLogLevel();
+    }
+    getCall = (correlationId) => {
+        return this.callManager.getCall(correlationId);
+    };
+    makeCall = (dest) => {
+        let call;
+        const { registration } = Object.values(this.lineDict)[0];
+        if (dest) {
+            const match = dest.address.match(VALID_PHONE);
+            if (match && match[0].length === dest.address.length) {
+                const sanitizedNumber = dest.address
+                    .replace(/[^[*+]\d#]/gi, '')
+                    .replace(/\s+/gi, '')
+                    .replace(/-/gi, '');
+                const formattedDest = {
+                    type: dest.type,
+                    address: `tel:${sanitizedNumber}`,
+                };
+                call = this.callManager.createCall(formattedDest, CallDirection.OUTBOUND, registration.getDeviceInfo().device?.deviceId);
+                log.log(`New call created, callId: ${call.getCallId()}`, {});
+            }
+            else {
+                log.warn('Invalid phone number detected', {});
+                const err = new CallingClientError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, MobiusStatus.ACTIVE);
+                this.emit(EVENT_KEYS.ERROR, err);
+            }
+            return call;
+        }
+        return undefined;
+    };
+    getSDKConnector() {
+        return this.sdkConnector;
+    }
+    registerSessionsListener() {
+        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
+            if (event && event.data.userSessions.userSessions) {
+                const sessionArr = event?.data.userSessions.userSessions;
+                if (sessionArr.length === 1) {
+                    if (sessionArr[0].sessionType !== SessionType.WEBEX_CALLING) {
+                        return;
+                    }
+                }
+                for (let i = 0; i < sessionArr.length; i += 1) {
+                    if (sessionArr[i].sessionType !== SessionType.WEBEX_CALLING) {
+                        sessionArr.splice(i, 1);
+                    }
+                }
+                this.emit(EVENT_KEYS.USER_SESSION_INFO, event);
+            }
+        });
+    }
+    async createLine() {
+        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, LineStatus.INACTIVE, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData);
+        this.lineDict[line.lineId] = line;
+    }
+    getLines() {
+        return this.lineDict;
+    }
+}
+export const createClient = async (webex, config) => {
+    const callingClientInstance = new CallingClient(webex, config);
+    await callingClientInstance.init();
+    return callingClientInstance;
+};