@exotel-npm-dev/webrtc-client-sdk 2.0.1 → 3.0.0

package/index.js

@@ -1 +1,2 @@
-export * from './src/listeners/ExWebClient';
+import { ExotelWebClient } from './src/listeners/ExWebClient';
+export { ExotelWebClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exotel-npm-dev/webrtc-client-sdk",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "description": "client sdk for webrtc based on webrtc core sdk",
   "main": "index.js",
   "scripts": {
@@ -29,6 +29,6 @@
     "webpack-cli": "^4.10.0"
   },
   "dependencies": {
-    "@exotel-npm-dev/webrtc-core-sdk": "^1.0.20"
+    "@exotel-npm-dev/webrtc-core-sdk": "^3.0.0"
   }
 }

package/src/api/callAPI/Call.js

@@ -1,9 +1,13 @@
 import { CallDetails } from "./CallDetails";
+import { getLogger } from '@exotel-npm-dev/webrtc-core-sdk';
 
-import { webrtcSIPPhone } from '@exotel-npm-dev/webrtc-core-sdk';
-var logger = webrtcSIPPhone.getLogger();
+const logger = getLogger();
+
+export function Call(webrtcSIPPhone) {
+    if (!webrtcSIPPhone) {
+        throw new Error("webrtcSIPPhone is required for Call");
+    }
 
-export function Call() {
     this.Answer = function () {
         /**
          * When agent accepts phone, add appropriate msg to be sent to webclient
@@ -32,25 +36,25 @@ export function Call() {
         /**
          * When agent clicks on mute
          */
-        var isMicEnabled = webrtcSIPPhone.getMuteStatus();
-        logger.log('Call: Mute: isMicEnabled: ', isMicEnabled);
-        if (isMicEnabled) {
+        var isMuted = webrtcSIPPhone.getMuteStatus();
+        logger.log('Call: Mute: isMuted: ', isMuted);
+        if (!isMuted) {
             webrtcSIPPhone.muteAction(true);
         } else {
-            logger.log('Call: Mute:  Already muted');
+            logger.log('Call: Mute: Already muted');
         }
     }
     
     this.UnMute = function () {
         /**
-         * When agent clicks on mute
+         * When agent clicks on unmute
          */
-        var isMicEnabled = webrtcSIPPhone.getMuteStatus();
-        logger.log('Call: UnMute: isMicEnabled: ', isMicEnabled);
-        if (isMicEnabled) {
-            logger.log('Call: Unmute: Already unmuted');
-        } else {
+        var isMuted = webrtcSIPPhone.getMuteStatus();
+        logger.log('Call: UnMute: isMuted: ', isMuted);
+        if (isMuted) {
             webrtcSIPPhone.muteAction(false);
+        } else {
+            logger.log('Call: UnMute: Already unmuted');
         }
     }
 

package/src/api/omAPI/Diagnostics.js

@@ -1,7 +1,8 @@
+import { getLogger } from "@exotel-npm-dev/webrtc-core-sdk";
 import { diagnosticsCallback } from "../../listeners/Callback";
 
-import { webrtcSIPPhone } from '@exotel-npm-dev/webrtc-core-sdk';
-var logger = webrtcSIPPhone.getLogger();
+const logger = getLogger();
+
 var speakerNode;
 var micNode;
 var audioTrack;
@@ -24,6 +25,21 @@ eventMapper.sipml5.terminated_REGISTER = "USER_REG_TEST_FAIL";
 
 var candidateProcessData = {};
 
+export class Diagnostics {
+    constructor() {
+        this.report = {};
+    }
+
+    setReport(key, value) {
+        this.report[key] = value;
+        logger.log("Diagnostics: setReport", key, value);
+    }
+
+    getReport() {
+        return this.report;
+    }
+}
+
 export var ameyoWebRTCTroubleshooter = {
   js_yyyy_mm_dd_hh_mm_ss: function () {
     var now = new Date();
@@ -139,35 +155,45 @@ export var ameyoWebRTCTroubleshooter = {
     return browserName + "/" + version;
   },
 
-  stopSpeakerTesttone: function () {
+  stopSpeakerTesttone: function (webrtcSIPPhone) {
+    if (!webrtcSIPPhone) {
+      logger.log("stopSpeakerTesttone: webrtcSIPPhone not provided");
+      return;
+    }
     speakerTestTone = webrtcSIPPhone.getSpeakerTestTone();
     speakerTestTone.pause();
   },
 
-  stopSpeakerTesttoneWithSuccess: function () {
-    this.stopSpeakerTest();
+  stopSpeakerTesttoneWithSuccess: function (webrtcSIPPhone) {
+    this.stopSpeakerTest(webrtcSIPPhone);
     this.sendDeviceTestingEvent("SPEAKER_TEST_PASS");
     this.addToTrobuleshootReport("INFO", "Speaker device testing is successfull");
     this.addToTrobuleshootReport("INFO", "Speaker device testing is completed");
   },
 
-  stopSpeakerTesttoneWithFailure: function () {
-    this.stopSpeakerTest();
+  stopSpeakerTesttoneWithFailure: function (webrtcSIPPhone) {
+    this.stopSpeakerTest(webrtcSIPPhone);
     this.sendDeviceTestingEvent("SPEAKER_TEST_FAIL");
     this.addToTrobuleshootReport("INFO", "Speaker device testing is failed");
     this.addToTrobuleshootReport("INFO", "Speaker device testing is completed");
   },
 
-  startSpeakerTest: function () {
+  startSpeakerTest: function (webrtcSIPPhone) {
     var parent = this;
-
+    if (!webrtcSIPPhone) {
+      logger.log("startSpeakerTest: webrtcSIPPhone not provided");
+      return;
+    }
+    if (intervalID) {
+      logger.log("startSpeakerTest: already running");
+      return;
+    }
     try {
       intervalID = setInterval(function () {
 
         try {
           speakerTestTone = webrtcSIPPhone.getSpeakerTestTone();
-          /* Close last pending tracks.. */
-          logger.log("close last track")
+          logger.log("close last track");
           speakerTestTone.pause();
           parent.closeAudioTrack();
 
@@ -223,14 +249,18 @@ export var ameyoWebRTCTroubleshooter = {
 
   },
 
-  stopSpeakerTest: function () {
+  stopSpeakerTest: function (webrtcSIPPhone) {
     var parent = this;
+    if (!webrtcSIPPhone) {
+      logger.log("stopSpeakerTest: webrtcSIPPhone not provided");
+      return;
+    }
     speakerTestTone = webrtcSIPPhone.getSpeakerTestTone();
-    //Enable this for tone loop - Start
     try {
-      clearInterval(intervalID)
-      intervalID = 0
-      //Enable this for tone loop - End
+      if (intervalID) {
+        clearInterval(intervalID);
+        intervalID = 0;
+      }
       speakerTestTone.pause();
       parent.closeAudioTrack();
       parent.addToTrobuleshootReport("INFO", "Speaker device testing is stopped");
@@ -437,9 +467,8 @@ export var ameyoWebRTCTroubleshooter = {
     logger.log("No explicit registration sent during testing...")
   },
 
-  setWSTroubleshootData: function (txtWsStatus) {
-    //Already done during init, no need to do again. 
-    let txtWSSUrl = webrtcSIPPhone.getWSSUrl();
+  setWSTroubleshootData: function (txtWsStatus, webrtcSIPPhone) {
+    let txtWSSUrl = webrtcSIPPhone && webrtcSIPPhone.getWSSUrl ? webrtcSIPPhone.getWSSUrl() : '';
     diagnosticsCallback.triggerKeyValueSetCallback("wss", txtWsStatus, txtWSSUrl)
   },
 

package/src/api/omAPI/DiagnosticsListener.js

@@ -1,9 +1,9 @@
+import { getLogger } from "@exotel-npm-dev/webrtc-core-sdk";
 import { diagnosticsCallback } from '../../listeners/Callback';
 import { ameyoWebRTCTroubleshooter } from './Diagnostics';
-import { webrtcSIPPhone } from '@exotel-npm-dev/webrtc-core-sdk';
 
+const logger = getLogger();
 
-var logger = webrtcSIPPhone.getLogger();
 
 export function initDiagnostics(setDiagnosticsReportCallback, keyValueSetCallback) {
     if (!keyValueSetCallback || !setDiagnosticsReportCallback) {
@@ -23,27 +23,27 @@ export function closeDiagnostics() {
     return;
 }
 
-export function startSpeakerDiagnosticsTest() {
+export function startSpeakerDiagnosticsTest(webrtcSIPPhone) {
     /**
      * When user registers the agent phone for the first time, register your callback onto webrtc client
      */
     logger.log("Request to startSpeakerTest:\n");
-    ameyoWebRTCTroubleshooter.startSpeakerTest()
+    ameyoWebRTCTroubleshooter.startSpeakerTest(webrtcSIPPhone)
     return;
 }
 
-export function stopSpeakerDiagnosticsTest(speakerTestResponse) {
+export function stopSpeakerDiagnosticsTest(speakerTestResponse, webrtcSIPPhone) {
     /**
      * When user registers the agent phone for the first time, register your callback onto webrtc client
      */
 
     logger.log("Request to stopSpeakerTest - Suuccessful Test:\n");
     if (speakerTestResponse == 'yes') {
-        ameyoWebRTCTroubleshooter.stopSpeakerTesttoneWithSuccess()
+        ameyoWebRTCTroubleshooter.stopSpeakerTesttoneWithSuccess(webrtcSIPPhone)
     } else if (speakerTestResponse == 'no') {
-        ameyoWebRTCTroubleshooter.stopSpeakerTesttoneWithFailure()
+        ameyoWebRTCTroubleshooter.stopSpeakerTesttoneWithFailure(webrtcSIPPhone)
     } else {
-        ameyoWebRTCTroubleshooter.stopSpeakerTest()
+        ameyoWebRTCTroubleshooter.stopSpeakerTest(webrtcSIPPhone)
     }
     return;
 }
@@ -93,4 +93,15 @@ export function stopNetworkDiagnostics() {
      */
     logger.log("Request to stop network diagnostics:\n");
     return;
+}
+
+export class DiagnosticsListener {
+    constructor(diagnosticsCallback) {
+        this.diagnosticsCallback = diagnosticsCallback;
+    }
+
+    onDiagnosticsEvent(event) {
+        logger.log("DiagnosticsListener: onDiagnosticsEvent", event);
+        this.diagnosticsCallback.triggerCallback(event);
+    }
 }

package/src/api/registerAPI/RegisterListener.js

@@ -1,6 +1,6 @@
-import { webrtcSIPPhone } from "@exotel-npm-dev/webrtc-core-sdk";
+import { getLogger } from "@exotel-npm-dev/webrtc-core-sdk";
 
-var logger = webrtcSIPPhone.getLogger();
+const logger = getLogger();
 
 /**
  * Function to register the phone onto a webRTC client

package/src/listeners/CallListener.js

@@ -1,38 +1,35 @@
-import { callbacks } from "./Callback";
-import { webrtcSIPPhone } from "@exotel-npm-dev/webrtc-core-sdk";
+import { getLogger } from "@exotel-npm-dev/webrtc-core-sdk";
 
-var logger = webrtcSIPPhone.getLogger();
+const logger = getLogger();
 
-export function CallListener() {
-    this.onIncomingCall = function (call, phone) {
-        /**
-         * When there is an incoming call, [INVITE is received on SIP] send a call back to the 
-         */
-        logger.log("CallListener:Initialise call")
-        callbacks.initializeCall(call, phone)
+export class CallListener {
+    constructor(callCallback) {
+        this.callCallback = callCallback;
+    }
+
+    onIncomingCall(call, phone) {
+        logger.log("CallListener: onIncomingCall", call, phone);
+        this.callCallback.initializeCall(call, phone);
+        this.callCallback.triggerCallback("call", call, "incoming", phone);
+    }
 
-        /** Triggers the callback on the UI end with message indicating it to be an incoming call */
-        logger.log("CallListener:Trigger Incoming")
-        callbacks.triggerCallback("incoming");
+    onCallEstablished(call, phone) {
+        logger.log("CallListener: onCallEstablished", call, phone);
+        this.callCallback.triggerCallback("call", call, "connected", phone);
     }
-    this.onCallEstablished = function (call, phone) {
-        /**
-         * When connection is established [ACK is sent by other party on SIP]
-         */
-        logger.log("CallListener:Initialise call")
-        callbacks.initializeCall(call, phone)
-        /** Triggers the callback on the UI end with message indicating call has been established*/
-        logger.log("CallListener:Trigger Connected")
-        callbacks.triggerCallback("connected")
+
+    onCallEnded(call, phone) {
+        logger.log("CallListener: onCallEnded", call, phone);
+        this.callCallback.triggerCallback("call", call, "callEnded", phone);
     }
-    this.onCallEnded = function (call, phone) {
-        /**
-         * When other party ends the call [BYE is received and sent by SIP]
-         */
-        logger.log("CallListener:Initialise call")
-        callbacks.initializeCall(call, phone)
-        /** Triggers the callback on the UI end with message indicating call has ended */
-        logger.log("CallListener:Trigger Call Ended")
-        callbacks.triggerCallback("callEnded")
+
+    onCallEvent(event) {
+        logger.log("CallListener: onCallEvent", event);
+        this.callCallback.triggerCallback(event);
+    }
+
+    onRinging(call, phone) {
+        logger.log("CallListener: onRinging", call, phone);
+        this.callCallback.triggerCallback("call", call, "ringing", phone);
     }
 }

package/src/listeners/Callback.js

@@ -1,6 +1,6 @@
-import { webrtcSIPPhone } from "@exotel-npm-dev/webrtc-core-sdk";
+import { getLogger } from "@exotel-npm-dev/webrtc-core-sdk";
 
-var logger = webrtcSIPPhone.getLogger();
+const logger = getLogger();
 
 /**
  * The call backs are called through this function. First initiates the call object and then
@@ -10,43 +10,52 @@ var logger = webrtcSIPPhone.getLogger();
 /**
  * Initializes call event callbacks and also sends to which phone callback was received
  */
-export var callbacks = {
-    callback: null,
-    call: null,
-    phone: '',
-    initializeCallback: function (CallListenerCallback) {
-        this.callback = CallListenerCallback;
-    },
-    initializeCall: function (call, phone) {
+export class Callback {
+    constructor() {
+        this.callbacks = {};
+        this.call = null;
+        this.phone = '';
+    }
+
+    registerCallback(event, callback) {
+        this.callbacks[event] = callback;
+    }
+
+    initializeCall(call, phone) {
         this.call = call;
         this.phone = phone;
-    },
-    triggerCallback: function (eventType) {
-        const callbackFunc = this.callback;
-        const call = this.call;
-        return callbackFunc(call, eventType, this.phone);
     }
-};
+
+    triggerCallback(event, ...args) {
+        if (this.callbacks[event]) {
+            this.callbacks[event](...args);
+        } else {
+            logger.log("No callback registered for event:", event);
+        }
+    }
+}
+
 /**
  * Initializes register callback and also sets to which phone registration was renewed
  */
-export var registerCallback = {
-    registerCallbackHandler: null,
-    registerState: null,
-    phone: '',
-    initializeRegisterCallback: function (RegisterEventCallBack) {
-        registerCallback.registerCallbackHandler = RegisterEventCallBack;
-    },
-    initializeRegister: function (state, phone) {
-        registerCallback.registerState = state;
-        registerCallback.phone = phone;
-    },
-    triggerRegisterCallback: function () {
-        const callbackFunc = registerCallback.registerCallbackHandler;
-        const state = registerCallback.registerState
-        return callbackFunc(state, registerCallback.phone);
-    }
-};
+
+export class RegisterCallback  {
+    registerCallbackHandler = null;
+    registerState= null;
+    phone= '';
+    initializeRegisterCallback= function (RegisterEventCallBack) {
+        this.registerCallbackHandler = RegisterEventCallBack;
+    };
+    initializeRegister= function (state, phone) {
+        this.registerState = state;
+        this.phone = phone;
+    };
+    triggerRegisterCallback= function () {
+        const callbackFunc = this.registerCallbackHandler;
+        const state = this.registerState
+        return callbackFunc(state, this.phone);
+    };
+}
 /**
  * Sets all the phone instances
  */
@@ -79,30 +88,30 @@ export var phoneInstance = {
     }
 };
 
-export var sessionCallback = {
-    sessioncallback: null,
-    callState: null,
-    document: null,
-    documentCallback: null,
-    phone: '',
-    initializeSessionCallback: function (SessionCallback) {
+export class SessionCallback  {
+    sessioncallback = null;
+    callState= null;
+    document= null;
+    documentCallback= null;
+    phone= '';
+    initializeSessionCallback= function (SessionCallback) {
         this.sessioncallback = SessionCallback;
-    },
-    intializeDocumentCallback: function (DocumentCallback) {
+    };
+    intializeDocumentCallback= function (DocumentCallback) {
         this.documentCallback = DocumentCallback;
-    },
-    initializeSession: function (state, phone) {
+    };
+    initializeSession= function (state, phone) {
         this.callState = state;
         this.phone = phone;
-    },
-    initializeDocument: function (calldocument) {
+    };
+    initializeDocument= function (calldocument) {
         this.document = calldocument;
-    },
-    triggerDocumentCallback: function () {
+    };
+    triggerDocumentCallback= function () {
         const documentCallbackFunc = this.documentCallback;
         return documentCallbackFunc(this.document);
-    },
-    triggerSessionCallback: function () {
+    };
+    triggerSessionCallback= function () {
         const sessionCallBackFunc = this.sessioncallback;
         if (sessionCallBackFunc) {
             return sessionCallBackFunc(this.callState, this.phone);