@webex/calling 0.0.1-next.6 → 0.0.1-next.8

package/README.md

@@ -1,52 +1,74 @@
-# @webex/calling
+### Table of Contents
+- [Getting Started](#getting-started)
+- [Developing](#developing)
+- [Building](#building) 
+- [Testing](#testing)
+- [Samples](#samples) 
+- [Consuming SDK](#consuming-sdk)
+  - [NPM](#npm)
+  - [CDN](#cdn)
+- [Kitchen Sink App](#kitchen-sink-app)
+---
 
+## Getting Started
 With the Webex Calling SDK, you can effortlessly integrate fundamental audio calling capabilities into your solutions, enhancing the way your users connect.
 
-> [Introduction to the Webex Web Calling SDK](https://github.com/webex/webex-js-sdk/wiki/Introducing-the-Webex-Web-Calling-SDK)
-> [Quickstart guide](https://github.com/webex/webex-js-sdk/wiki/Quickstart-Guide-(Calling))
-> API guide - TBD
-
+- [Introduction to the Webex Web Calling SDK](https://github.com/webex/webex-js-sdk/wiki/Introducing-the-Webex-Web-Calling-SDK)
+- [Quickstart guide](https://github.com/webex/webex-js-sdk/wiki/Quickstart-Guide-(Calling)).
  
 ## Developing
 
-```shell
+```bash
 git clone https://github.com/\<your-fork\>/webex-js-sdk.git
 cd web-js-sdk/
 yarn install
 ```
 
-### Building
+## Building
 
 If your project needs some additional steps for the developer to build the
 project after some code changes, state them here:
 
-```shell
+```bash
 yarn workspaces foreach --parallel --verbose run build:src
 
 yarn build:local
 ```
 
-### Testing
+## Testing
 
-```shell
+```bash
  yarn workspace @webex/calling run test
 ```
 
-### Testing on samples
-```shell
- yarn run samples:serve
+## Samples 
+```bash
+  yarn run samples:serve
 ```
 
-### Consuming the SDK
-
-The Calling package can be incorporated into an existing project by updating the package.json. Add the line pasted below to get access to the calling-sdk package located in the artifactory.
+## Consuming SDK
+To consume the latest stable version of the Calling SDK one can use NPM or CDN.
+# NPM
+```javascript
+  npm install @webex/calling
+```
+(or)
 
+```javascript
+  yarn add @webex/calling
+```
 
-Use the following commands to update the package.json and package.lock/yarn.lock with the latest version of the calling-sdk package.
-```shell
-npm install @webex/web-calling-sdk
+```javascript
+  import Calling from '@webex/calling'
 ```
-(or)
-```shell 
-yarn add @webex/web-calling-sdk
-```
+# CDN
+```javascript
+  <script src="../calling.min.js"></script>
+```
+
+### Kitchen Sink App
+To test Calling SDK API, use this Kitchen Sink app: https://webex.github.io/webex-js-sdk/samples/calling/ 
+
+
+
+

package/dist/module/CallHistory/CallHistory.js

@@ -4,7 +4,7 @@ import log from '../Logger';
 import { serviceErrorCodeHandler } from '../common/Utils';
 import { CALL_HISTORY_FILE, FROM_DATE, HISTORY, LIMIT, NUMBER_OF_DAYS } from './constants';
 import { STATUS_CODE, SUCCESS_MESSAGE, USER_SESSIONS } from '../common/constants';
-import { EVENT_KEYS, MOBIUS_EVENT_KEYS, } from '../Events/types';
+import { COMMON_EVENT_KEYS, MOBIUS_EVENT_KEYS, } from '../Events/types';
 import { Eventing } from '../Events/impl';
 export class CallHistory extends Eventing {
     sdkConnector;
@@ -70,13 +70,10 @@ export class CallHistory extends Eventing {
             return errorStatus;
         }
     }
-    getSDKConnector() {
-        return this.sdkConnector;
-    }
     registerSessionsListener() {
         this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
             if (event && event.data.userSessions.userSessions) {
-                this.emit(EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, event);
+                this.emit(COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, event);
             }
         });
     }

package/dist/module/CallingClient/CallingClient.js

@@ -1,16 +1,14 @@
 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 { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../Events/types';
+import { 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 { 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, NETWORK_FLAP_TIMEOUT, } from './constants';
 import Line from './line';
 import { LINE_EVENTS, LineStatus } from './line/types';
 import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
@@ -47,7 +45,6 @@ export class CallingClient extends Eventing {
         this.backupMobiusUris = [];
         this.registerSessionsListener();
         log.setLogger(logLevel, CALLING_CLIENT_FILE);
-        this.incomingCallListener();
         this.registerCallsClearedListener();
     }
     async init() {
@@ -55,16 +52,6 @@ export class CallingClient extends Eventing {
         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];
@@ -113,7 +100,7 @@ export class CallingClient extends Eventing {
         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);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
             }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
             regionInfo.clientRegion = '';
             regionInfo.countryCode = '';
@@ -163,7 +150,7 @@ export class CallingClient extends Eventing {
             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);
+                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
                 }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
                 useDefault = true;
             }
@@ -184,7 +171,7 @@ export class CallingClient extends Eventing {
             method: this.registerCallsClearedListener.name,
         };
         log.log('Registering listener for all calls cleared event', logContext);
-        this.callManager.on(EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
+        this.callManager.on(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
     }
     callsClearedHandler = async () => {
         const { registration } = Object.values(this.lineDict)[0];
@@ -203,35 +190,6 @@ export class CallingClient extends Eventing {
     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;
     }
@@ -249,7 +207,7 @@ export class CallingClient extends Eventing {
                         sessionArr.splice(i, 1);
                     }
                 }
-                this.emit(EVENT_KEYS.USER_SESSION_INFO, event);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.USER_SESSION_INFO, event);
             }
         });
     }
@@ -260,6 +218,28 @@ export class CallingClient extends Eventing {
     getLines() {
         return this.lineDict;
     }
+    getActiveCalls() {
+        const activeCalls = {};
+        const calls = this.callManager.getActiveCalls();
+        Object.keys(calls).forEach((correlationId) => {
+            const call = calls[correlationId];
+            if (!activeCalls[call.lineId]) {
+                activeCalls[call.lineId] = [];
+            }
+            activeCalls[call.lineId].push(call);
+        });
+        return activeCalls;
+    }
+    getConnectedCall() {
+        let connectCall;
+        const calls = this.callManager.getActiveCalls();
+        Object.keys(calls).forEach((correlationId) => {
+            if (calls[correlationId].isConnected() && !calls[correlationId].isHeld()) {
+                connectCall = calls[correlationId];
+            }
+        });
+        return connectCall;
+    }
 }
 export const createClient = async (webex, config) => {
     const callingClientInstance = new CallingClient(webex, config);

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

@@ -8,7 +8,7 @@ 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, INITIAL_SEQ_NUMBER, MEDIA_ENDPOINT_RESOURCE, RESUME_ENDPOINT, SPARK_USER_AGENT, SUPPLEMENTARY_SERVICES_TIMEOUT, TRANSFER_ENDPOINT, } from '../constants';
 import SDKConnector from '../../SDKConnector';
 import { Eventing } from '../../Events/impl';
-import { EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
+import { CALL_EVENT_KEYS, MEDIA_CONNECTION_EVENT_KEYS, MOBIUS_MIDCALL_STATE, SUPPLEMENTARY_SERVICES, } from '../../Events/types';
 import { DisconnectCause, DisconnectCode, MidCallEventType, MobiusCallState, RoapScenario, TransferType, } from './types';
 import log from '../../Logger';
 import { createCallerId } from './CallerId';
@@ -23,6 +23,7 @@ export class Call extends Eventing {
     callId;
     correlationId;
     deviceId;
+    lineId;
     disconnectReason;
     callStateMachine;
     mediaStateMachine;
@@ -54,13 +55,14 @@ export class Call extends Eventing {
     isHeld() {
         return this.held;
     }
-    constructor(activeUrl, webex, destination, direction, deviceId, deleteCb, indicator) {
+    constructor(activeUrl, webex, destination, direction, deviceId, lineId, deleteCb, indicator) {
         super();
         this.destination = destination;
         this.direction = direction;
         this.sdkConnector = SDKConnector;
         this.deviceId = deviceId;
         this.serviceIndicator = indicator;
+        this.lineId = lineId;
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
@@ -88,7 +90,7 @@ export class Call extends Eventing {
                 correlationId: this.correlationId,
                 callerId: this.callerInfo,
             };
-            this.emit(EVENT_KEYS.CALLER_ID, emitObj);
+            this.emit(CALL_EVENT_KEYS.CALLER_ID, emitObj);
         });
         this.remoteRoapMessage = null;
         this.disconnectReason = { code: DisconnectCode.NORMAL, cause: DisconnectCause.NORMAL };
@@ -581,7 +583,7 @@ export class Call extends Eventing {
             });
             const errData = e;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.CALL_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
@@ -606,7 +608,7 @@ export class Call extends Eventing {
                         method: this.handleCallHold.name,
                     });
                     const callError = createCallError('An error occurred while placing the call on hold. Wait a moment and try again.', errorContext, ERROR_TYPE.TIMEOUT, this.getCorrelationId(), ERROR_LAYER.CALL_CONTROL);
-                    this.emit(EVENT_KEYS.HOLD_ERROR, callError);
+                    this.emit(CALL_EVENT_KEYS.HOLD_ERROR, callError);
                     this.submitCallErrorMetric(callError);
                 }, SUPPLEMENTARY_SERVICES_TIMEOUT);
             }
@@ -618,7 +620,7 @@ export class Call extends Eventing {
             });
             const errData = e;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.HOLD_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.HOLD_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
@@ -643,7 +645,7 @@ export class Call extends Eventing {
                         method: this.handleCallResume.name,
                     });
                     const callError = createCallError('An error occurred while resuming the call. Wait a moment and try again.', errorContext, ERROR_TYPE.TIMEOUT, this.getCorrelationId(), ERROR_LAYER.CALL_CONTROL);
-                    this.emit(EVENT_KEYS.RESUME_ERROR, callError);
+                    this.emit(CALL_EVENT_KEYS.RESUME_ERROR, callError);
                     this.submitCallErrorMetric(callError);
                 }, SUPPLEMENTARY_SERVICES_TIMEOUT);
             }
@@ -655,7 +657,7 @@ export class Call extends Eventing {
             });
             const errData = e;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.RESUME_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.RESUME_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, CALL_FILE);
@@ -687,7 +689,7 @@ export class Call extends Eventing {
             });
             this.startCallerIdResolution(data.callerId);
         }
-        this.emit(EVENT_KEYS.PROGRESS, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.PROGRESS, this.correlationId);
     }
     handleIncomingRoapOfferRequest(context, event) {
         log.info(`handleIncomingRoapOfferRequest: ${this.getCorrelationId()}  `, {
@@ -739,7 +741,7 @@ export class Call extends Eventing {
             });
             const errData = err;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.CALL_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallAlerting.name, CALL_FILE);
@@ -750,7 +752,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: this.handleIncomingCallConnect.name,
         });
-        this.emit(EVENT_KEYS.CONNECT, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.CONNECT, this.correlationId);
         if (this.earlyMedia || this.mediaNegotiationCompleted) {
             this.mediaNegotiationCompleted = false;
             this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED' });
@@ -783,7 +785,7 @@ export class Call extends Eventing {
             });
             const errData = err;
             handleCallErrors((error) => {
-                this.emit(EVENT_KEYS.CALL_ERROR, error);
+                this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                 this.submitCallErrorMetric(error);
                 this.sendCallStateMachineEvt({ type: 'E_UNKNOWN', data: errData });
             }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.handleOutgoingCallConnect.name, CALL_FILE);
@@ -818,7 +820,7 @@ export class Call extends Eventing {
         }
         this.sendMediaStateMachineEvt({ type: 'E_ROAP_TEARDOWN' });
         this.sendCallStateMachineEvt({ type: 'E_CALL_CLEARED' });
-        this.emit(EVENT_KEYS.DISCONNECT, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
     }
     async handleOutgoingCallDisconnect(event) {
         this.setDisconnectReason();
@@ -851,7 +853,7 @@ export class Call extends Eventing {
             file: CALL_FILE,
             method: this.handleCallEstablished.name,
         });
-        this.emit(EVENT_KEYS.ESTABLISHED, this.correlationId);
+        this.emit(CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
         this.earlyMedia = false;
         this.connected = true;
         if (this.sessionTimer) {
@@ -875,7 +877,7 @@ export class Call extends Eventing {
                     clearInterval(this.sessionTimer);
                 }
                 handleCallErrors((callError) => {
-                    this.emit(EVENT_KEYS.CALL_ERROR, callError);
+                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, callError);
                     this.submitCallErrorMetric(callError);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => {
                     setTimeout(() => {
@@ -930,7 +932,7 @@ export class Call extends Eventing {
         return (error) => {
             switch (this.callStateMachine.state.value) {
                 case 'S_CALL_HOLD':
-                    this.emit(EVENT_KEYS.HOLD_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.HOLD_ERROR, error);
                     if (this.supplementaryServicesTimer) {
                         clearTimeout(this.supplementaryServicesTimer);
                         this.supplementaryServicesTimer = undefined;
@@ -939,12 +941,12 @@ export class Call extends Eventing {
                     this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
                     return;
                 case 'S_CALL_RESUME':
-                    this.emit(EVENT_KEYS.RESUME_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.RESUME_ERROR, error);
                     this.submitCallErrorMetric(error);
                     this.sendCallStateMachineEvt({ type: 'E_CALL_ESTABLISHED', data: errData });
                     return;
                 default:
-                    this.emit(EVENT_KEYS.CALL_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                     this.submitCallErrorMetric(error);
                     if (!this.connected) {
                         this.sendMediaStateMachineEvt({ type: 'E_ROAP_ERROR', data: errData });
@@ -1043,7 +1045,7 @@ export class Call extends Eventing {
                 });
                 const errData = err;
                 handleCallErrors((error) => {
-                    this.emit(EVENT_KEYS.CALL_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.CALL_ERROR, error);
                     this.submitCallErrorMetric(error);
                 }, ERROR_LAYER.MEDIA, (interval) => undefined, this.getCorrelationId(), errData, this.handleRoapError.name, CALL_FILE);
             }
@@ -1382,7 +1384,7 @@ export class Call extends Eventing {
                 });
                 const errData = e;
                 handleCallErrors((error) => {
-                    this.emit(EVENT_KEYS.TRANSFER_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.BLIND);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
             }
@@ -1407,7 +1409,7 @@ export class Call extends Eventing {
                 });
                 const errData = e;
                 handleCallErrors((error) => {
-                    this.emit(EVENT_KEYS.TRANSFER_ERROR, error);
+                    this.emit(CALL_EVENT_KEYS.TRANSFER_ERROR, error);
                     this.submitCallErrorMetric(error, TRANSFER_ACTION.CONSULT);
                 }, ERROR_LAYER.CALL_CONTROL, (interval) => undefined, this.getCorrelationId(), errData, this.completeTransfer.name, CALL_FILE);
             }
@@ -1500,7 +1502,7 @@ export class Call extends Eventing {
     mediaTrackListener() {
         this.mediaConnection.on(Event.REMOTE_TRACK_ADDED, (e) => {
             if (e.type === MEDIA_CONNECTION_EVENT_KEYS.MEDIA_TYPE_AUDIO) {
-                this.emit(EVENT_KEYS.REMOTE_MEDIA, e.track);
+                this.emit(CALL_EVENT_KEYS.REMOTE_MEDIA, e.track);
             }
         });
     }
@@ -1558,7 +1560,7 @@ export class Call extends Eventing {
                             file: CALL_FILE,
                             method: 'handleMidCallEvent',
                         });
-                        this.emit(EVENT_KEYS.HELD, this.correlationId);
+                        this.emit(CALL_EVENT_KEYS.HELD, this.correlationId);
                         this.held = true;
                         if (this.supplementaryServicesTimer) {
                             clearTimeout(this.supplementaryServicesTimer);
@@ -1571,7 +1573,7 @@ export class Call extends Eventing {
                             file: CALL_FILE,
                             method: 'handleMidCallEvent',
                         });
-                        this.emit(EVENT_KEYS.RESUMED, this.correlationId);
+                        this.emit(CALL_EVENT_KEYS.RESUMED, this.correlationId);
                         this.held = false;
                         if (this.supplementaryServicesTimer) {
                             clearTimeout(this.supplementaryServicesTimer);
@@ -1646,4 +1648,4 @@ export class Call extends Eventing {
         return this.getCallStats();
     }
 }
-export const createCall = (activeUrl, webex, dest, dir, deviceId, deleteCb, indicator) => new Call(activeUrl, webex, dest, dir, deviceId, deleteCb, indicator);
+export const createCall = (activeUrl, webex, dest, dir, deviceId, lineId, deleteCb, indicator) => new Call(activeUrl, webex, dest, dir, deviceId, lineId, deleteCb, indicator);

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

@@ -1,5 +1,5 @@
 import { CALL_MANAGER_FILE } from '../constants';
-import { EVENT_KEYS } from '../../Events/types';
+import { CALLING_CLIENT_EVENT_KEYS, LINE_EVENT_KEYS } from '../../Events/types';
 import { Eventing } from '../../Events/impl';
 import SDKConnector from '../../SDKConnector';
 import { CallDirection } from '../../common/types';
@@ -13,6 +13,7 @@ export class CallManager extends Eventing {
     callCollection;
     activeMobiusUrl;
     serviceIndicator;
+    lineDict;
     constructor(webex, indicator) {
         super();
         this.sdkConnector = SDKConnector;
@@ -20,19 +21,20 @@ export class CallManager extends Eventing {
         if (!this.sdkConnector.getWebex()) {
             SDKConnector.setWebex(webex);
         }
+        this.lineDict = {};
         this.webex = this.sdkConnector.getWebex();
         this.callCollection = {};
         this.activeMobiusUrl = '';
         this.listenForWsEvents();
     }
-    createCall = (destination, direction, deviceId) => {
+    createCall = (destination, direction, deviceId, lineId) => {
         log.log('Creating call object', {});
-        const newCall = createCall(this.activeMobiusUrl, this.webex, destination, direction, deviceId, (correlationId) => {
+        const newCall = createCall(this.activeMobiusUrl, this.webex, destination, direction, deviceId, lineId, (correlationId) => {
             delete this.callCollection[correlationId];
             const activeCalls = Object.keys(this.getActiveCalls()).length;
             log.info(`DELETE:: Deleted corelationId: ${newCall.getCorrelationId()} from CallManager, Number of call records :- ${activeCalls}`, {});
             if (activeCalls === 0) {
-                this.emit(EVENT_KEYS.ALL_CALLS_CLEARED);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED);
             }
         }, this.serviceIndicator);
         this.callCollection[newCall.getCorrelationId()] = newCall;
@@ -75,7 +77,8 @@ export class CallManager extends Eventing {
                 const newId = Object.keys(this.callCollection).find((id) => this.callCollection[id].getCallId() === callId);
                 let newCall;
                 if (!newId) {
-                    newCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId);
+                    const lineId = this.getLineId(mobiusEvent.data.deviceId);
+                    newCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId, lineId);
                     log.log(`New incoming call created with correlationId from Call Setup message: ${newCall.getCorrelationId()}`, {
                         file: CALL_MANAGER_FILE,
                         method: 'dequeueWsEvents',
@@ -103,7 +106,7 @@ export class CallManager extends Eventing {
                     });
                     newCall.startCallerIdResolution(mobiusEvent.data.callerId);
                 }
-                this.emit(EVENT_KEYS.INCOMING_CALL, newCall);
+                this.emit(LINE_EVENT_KEYS.INCOMING_CALL, newCall);
                 newCall.sendCallStateMachineEvt({ type: 'E_RECV_CALL_SETUP', data: mobiusEvent.data });
                 break;
             }
@@ -135,7 +138,8 @@ export class CallManager extends Eventing {
                         activeCall = this.getCall(newId);
                     }
                     else {
-                        activeCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId);
+                        const lineId = this.getLineId(mobiusEvent.data.deviceId);
+                        activeCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId, lineId);
                         log.log(`New incoming call created with correlationId from ROAP Message: ${activeCall.getCorrelationId()}`, {
                             file: CALL_MANAGER_FILE,
                             method: 'dequeueWsEvents',
@@ -265,6 +269,12 @@ export class CallManager extends Eventing {
     getActiveCalls = () => {
         return this.callCollection;
     };
+    updateLine(deviceId, line) {
+        this.lineDict[deviceId] = line;
+    }
+    getLineId(deviceId) {
+        return this.lineDict[deviceId].lineId;
+    }
 }
 export const getCallManager = (webex, indicator) => {
     if (!callManager) {

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

@@ -1,12 +1,16 @@
 import { v4 as uuid } from 'uuid';
-import { MobiusStatus, ServiceIndicator } from '../../common/types';
-import { LINE_EVENTS } from './types';
-import { LINE_FILE } from '../constants';
+import { CallDirection, MobiusStatus, ServiceIndicator, } from '../../common/types';
+import { LINE_EVENTS, LineStatus } from './types';
+import { LINE_FILE, VALID_PHONE } from '../constants';
 import log from '../../Logger';
 import { createRegistration } from '../registration';
 import { Eventing } from '../../Events/impl';
+import { LineError } from '../../Errors/catalog/LineError';
 import { validateServiceData } from '../../common';
 import SDKConnector from '../../SDKConnector';
+import { LINE_EVENT_KEYS } from '../../Events/types';
+import { getCallManager } from '../calling/callManager';
+import { ERROR_TYPE } from '../../Errors/types';
 export default class Line extends Eventing {
     #webex;
     #mutex;
@@ -29,6 +33,7 @@ export default class Line extends Eventing {
     rehomingIntervalMax;
     voicePortalNumber;
     voicePortalExtension;
+    callManager;
     #primaryMobiusUris;
     #backupMobiusUris;
     constructor(userId, clientDeviceUri, status, mutex, primaryMobiusUris, backupMobiusUris, logLevel, serviceDataConfig, phoneNumber, extension, voicemail) {
@@ -52,6 +57,8 @@ export default class Line extends Eventing {
         this.registration = createRegistration(this.#webex, serviceData, this.#mutex, this.lineEmitter, logLevel);
         this.registration.setStatus(MobiusStatus.DEFAULT);
         log.setLogger(logLevel, LINE_FILE);
+        this.callManager = getCallManager(this.#webex, serviceData.indicator);
+        this.incomingCallListener();
     }
     async register() {
         await this.#mutex.runExclusive(async () => {
@@ -60,6 +67,9 @@ export default class Line extends Eventing {
             this.registration.setMobiusServers(this.#primaryMobiusUris, this.#backupMobiusUris);
             await this.registration.triggerRegistration();
         });
+        if (this.mobiusDeviceId) {
+            this.callManager.updateLine(this.mobiusDeviceId, this);
+        }
     }
     async deregister() {
         this.registration.deregister();
@@ -107,4 +117,42 @@ export default class Line extends Eventing {
     }
     getRegistrationStatus = () => this.registration.getStatus();
     getDeviceId = () => this.registration.getDeviceInfo().device?.deviceId;
+    makeCall = (dest) => {
+        let call;
+        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, this.registration.getDeviceInfo().device?.deviceId, this.lineId);
+                log.log(`New call created, callId: ${call.getCallId()}`, {});
+            }
+            else {
+                log.warn('Invalid phone number detected', {});
+                const err = new LineError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, LineStatus.ACTIVE);
+                this.emit(LINE_EVENTS.ERROR, err);
+            }
+            return call;
+        }
+        return undefined;
+    };
+    incomingCallListener() {
+        const logContext = {
+            file: LINE_FILE,
+            method: this.incomingCallListener.name,
+        };
+        log.log('Listening for incoming calls... ', logContext);
+        this.callManager.on(LINE_EVENT_KEYS.INCOMING_CALL, (callObj) => {
+            this.emit(LINE_EVENTS.INCOMING_CALL, callObj);
+        });
+    }
+    getCall = (correlationId) => {
+        return this.callManager.getCall(correlationId);
+    };
 }

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

@@ -11,4 +11,5 @@ export var LINE_EVENTS;
     LINE_EVENTS["RECONNECTING"] = "reconnecting";
     LINE_EVENTS["REGISTERED"] = "registered";
     LINE_EVENTS["UNREGISTERED"] = "unregistered";
+    LINE_EVENTS["INCOMING_CALL"] = "line:incoming_call";
 })(LINE_EVENTS || (LINE_EVENTS = {}));

package/dist/module/Contacts/ContactsClient.js

@@ -24,9 +24,6 @@ export class ContactsClient {
         this.defaultGroupId = '';
         log.setLogger(logger.level, CONTACTS_FILE);
     }
-    getSDKConnector() {
-        return this.sdkConnector;
-    }
     async decryptContactDetail(encryptionKeyUrl, contactDetails) {
         const decryptedContactDetail = [...contactDetails];
         const decryptedValues = await Promise.all(decryptedContactDetail.map((detail) => this.webex.internal.encryption.decryptText(encryptionKeyUrl, detail.value)));

package/dist/module/Events/types.js

@@ -1,26 +1,35 @@
-export var EVENT_KEYS;
-(function (EVENT_KEYS) {
-    EVENT_KEYS["ALERTING"] = "call:alerting";
-    EVENT_KEYS["CALL_ERROR"] = "call:error";
-    EVENT_KEYS["CALLER_ID"] = "call:caller_id";
-    EVENT_KEYS["CONNECT"] = "call:connect";
-    EVENT_KEYS["DISCONNECT"] = "call:disconnect";
-    EVENT_KEYS["ERROR"] = "callingClient:error";
-    EVENT_KEYS["ESTABLISHED"] = "call:established";
-    EVENT_KEYS["HELD"] = "call:held";
-    EVENT_KEYS["HOLD_ERROR"] = "call:hold_error";
-    EVENT_KEYS["INCOMING_CALL"] = "callingClient:incoming_call";
-    EVENT_KEYS["OUTGOING_CALL"] = "callingClient:outgoing_call";
-    EVENT_KEYS["PROGRESS"] = "call:progress";
-    EVENT_KEYS["REMOTE_MEDIA"] = "call:remote_media";
-    EVENT_KEYS["RESUME_ERROR"] = "call:resume_error";
-    EVENT_KEYS["RESUMED"] = "call:resumed";
-    EVENT_KEYS["TRANSFER_ERROR"] = "call:transfer_error";
-    EVENT_KEYS["USER_SESSION_INFO"] = "callingClient:user_recent_sessions";
-    EVENT_KEYS["CB_VOICEMESSAGE_CONTENT_GET"] = "call_back_voicemail_content_get";
-    EVENT_KEYS["CALL_HISTORY_USER_SESSION_INFO"] = "callHistory:user_recent_sessions";
-    EVENT_KEYS["ALL_CALLS_CLEARED"] = "callingClient:all_calls_cleared";
-})(EVENT_KEYS || (EVENT_KEYS = {}));
+export var COMMON_EVENT_KEYS;
+(function (COMMON_EVENT_KEYS) {
+    COMMON_EVENT_KEYS["CB_VOICEMESSAGE_CONTENT_GET"] = "call_back_voicemail_content_get";
+    COMMON_EVENT_KEYS["CALL_HISTORY_USER_SESSION_INFO"] = "callHistory:user_recent_sessions";
+})(COMMON_EVENT_KEYS || (COMMON_EVENT_KEYS = {}));
+export var LINE_EVENT_KEYS;
+(function (LINE_EVENT_KEYS) {
+    LINE_EVENT_KEYS["INCOMING_CALL"] = "incoming_call";
+})(LINE_EVENT_KEYS || (LINE_EVENT_KEYS = {}));
+export var CALLING_CLIENT_EVENT_KEYS;
+(function (CALLING_CLIENT_EVENT_KEYS) {
+    CALLING_CLIENT_EVENT_KEYS["ERROR"] = "callingClient:error";
+    CALLING_CLIENT_EVENT_KEYS["OUTGOING_CALL"] = "callingClient:outgoing_call";
+    CALLING_CLIENT_EVENT_KEYS["USER_SESSION_INFO"] = "callingClient:user_recent_sessions";
+    CALLING_CLIENT_EVENT_KEYS["ALL_CALLS_CLEARED"] = "callingClient:all_calls_cleared";
+})(CALLING_CLIENT_EVENT_KEYS || (CALLING_CLIENT_EVENT_KEYS = {}));
+export var CALL_EVENT_KEYS;
+(function (CALL_EVENT_KEYS) {
+    CALL_EVENT_KEYS["ALERTING"] = "alerting";
+    CALL_EVENT_KEYS["CALL_ERROR"] = "call_error";
+    CALL_EVENT_KEYS["CALLER_ID"] = "caller_id";
+    CALL_EVENT_KEYS["CONNECT"] = "connect";
+    CALL_EVENT_KEYS["DISCONNECT"] = "disconnect";
+    CALL_EVENT_KEYS["ESTABLISHED"] = "established";
+    CALL_EVENT_KEYS["HELD"] = "held";
+    CALL_EVENT_KEYS["HOLD_ERROR"] = "hold_error";
+    CALL_EVENT_KEYS["PROGRESS"] = "progress";
+    CALL_EVENT_KEYS["REMOTE_MEDIA"] = "remote_media";
+    CALL_EVENT_KEYS["RESUME_ERROR"] = "resume_error";
+    CALL_EVENT_KEYS["RESUMED"] = "resumed";
+    CALL_EVENT_KEYS["TRANSFER_ERROR"] = "transfer_error";
+})(CALL_EVENT_KEYS || (CALL_EVENT_KEYS = {}));
 export var SUPPLEMENTARY_SERVICES;
 (function (SUPPLEMENTARY_SERVICES) {
     SUPPLEMENTARY_SERVICES["HOLD"] = "hold";

package/dist/module/api.js

@@ -0,0 +1,6 @@
+import { CallHistory } from './CallHistory/CallHistory';
+import { CallSettings } from './CallSettings/CallSettings';
+import { CallingClient } from './CallingClient/CallingClient';
+import { ContactsClient } from './Contacts/ContactsClient';
+import { Voicemail } from './Voicemail/Voicemail';
+export { CallHistory, CallSettings, CallingClient, ContactsClient, Voicemail };

package/package.json

@@ -31,7 +31,7 @@
     "test:style": "eslint 'src/**/*.ts'",
     "fix:lint": "eslint 'src/**/*.ts' --fix",
     "fix:prettier": "prettier \"src/**/*.ts\" --write",
-    "build:docs": "typedoc --out docs/",
+    "build:docs": "typedoc --out ../../docs/calling",
     "docs": "typedoc --emit none",
     "deploy:npm": "npm publish"
   },
@@ -97,7 +97,7 @@
     "sinon": "12.0.1",
     "ts-jest": "27.1.4",
     "typed-emitter": "2.1.0",
-    "typedoc": "0.22.13",
+    "typedoc": "0.23.26",
     "typescript": "4.9.5"
   },
   "commitlint": {
@@ -129,5 +129,5 @@
     "staticpath": "docs",
     "noprompt": true
   },
-  "version": "0.0.1-next.6"
+  "version": "0.0.1-next.8"
 }