@exotel-npm-dev/webrtc-client-sdk 1.0.6 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exotel-npm-dev/webrtc-client-sdk",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "client sdk for webrtc based on webrtc core sdk",
   "main": "index.js",
   "scripts": {
@@ -21,7 +21,7 @@
   },
   "homepage": "https://bitbucket.org/Exotel/webrtc#readme",
   "dependencies": {
-    "@exotel-npm-dev/webrtc-core-sdk": "^1.0.6"
+    "@exotel-npm-dev/webrtc-core-sdk": "^1.0.7"
   },
   "devDependencies": {
     "babel-loader": "^8.2.5",
@@ -31,4 +31,4 @@
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0"
   }
-}
+}

package/src/listeners/ExWebClient.js

@@ -1,4 +1,4 @@
-import { Call }  from "../api/callAPI/Call";
+import { Call } from "../api/callAPI/Call";
 import { CallController } from "./CallCtrlerDummy";
 import { CallListener } from '../listeners/CallListener';
 import { DoRegister as DoRegisterRL } from '../api/registerAPI/RegisterListener';
@@ -6,14 +6,14 @@ import { UnRegister as UnRegisterRL } from '../api/registerAPI/RegisterListener'
 import { ExotelVoiceClientListener } from '../listeners/ExotelVoiceClientListener';
 import { SessionListener as SessionListenerSL } from '../listeners/SessionListeners';
 
-import { initDiagnostics as initDiagnosticsDL} from '../api/omAPI/DiagnosticsListener';
-import { startNetworkDiagnostics as startNetworkDiagnosticsDL} from '../api/omAPI/DiagnosticsListener';
-import { stopNetworkDiagnostics as stopNetworkDiagnosticsDL} from '../api/omAPI/DiagnosticsListener';
-import { startSpeakerDiagnosticsTest as startSpeakerDiagnosticsTestDL} from '../api/omAPI/DiagnosticsListener';
-import { stopSpeakerDiagnosticsTest as stopSpeakerDiagnosticsTestDL} from '../api/omAPI/DiagnosticsListener';
-import { startMicDiagnosticsTest as startMicDiagnosticsTestDL} from '../api/omAPI/DiagnosticsListener';
+import { initDiagnostics as initDiagnosticsDL } from '../api/omAPI/DiagnosticsListener';
+import { startNetworkDiagnostics as startNetworkDiagnosticsDL } from '../api/omAPI/DiagnosticsListener';
+import { stopNetworkDiagnostics as stopNetworkDiagnosticsDL } from '../api/omAPI/DiagnosticsListener';
+import { startSpeakerDiagnosticsTest as startSpeakerDiagnosticsTestDL } from '../api/omAPI/DiagnosticsListener';
+import { stopSpeakerDiagnosticsTest as stopSpeakerDiagnosticsTestDL } from '../api/omAPI/DiagnosticsListener';
+import { startMicDiagnosticsTest as startMicDiagnosticsTestDL } from '../api/omAPI/DiagnosticsListener';
 import { stopMicDiagnosticsTest as stopMicDiagnosticsTestDL } from '../api/omAPI/DiagnosticsListener';
-import { closeDiagnostics as closeDiagnosticsDL} from '../api/omAPI/DiagnosticsListener';
+import { closeDiagnostics as closeDiagnosticsDL } from '../api/omAPI/DiagnosticsListener';
 
 import { callbacks } from '../listeners/Callback';
 import { registerCallback } from '../listeners/Callback';
@@ -37,26 +37,26 @@ function sleep(ms) {
  */
 function fetchPublicIP(sipAccountInfo) {
     var publicIp = "";
-    const pc = new RTCPeerConnection({ iceServers: [ {urls: 'stun:stun.l.google.com:19302'} ] });
+    const pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] });
     pc.createDataChannel('');
     pc.createOffer().then(offer => pc.setLocalDescription(offer))
     pc.onicecandidate = (ice) => {
-    if (!ice || !ice.candidate || !ice.candidate.candidate) {
-    logger.log("all done.");
-    pc.close(); 
-    return "";
-    }
-    logger.log("iceCandidate =" + ice.candidate.candidate);
-    let split = ice.candidate.candidate.split(" ");
-    if (split[7] === "host") {
-    logger.log(`fetchPublicIP:Local IP : ${split[4]}`);
-    } else {
-    logger.log(`fetchPublicIP:External IP : ${split[4]}`);
-    publicIp = `${split[4]}` 
-    logger.log("fetchPublicIP:Public IP :" + publicIp);
-    localStorage.setItem("contactHost", publicIp);
-    pc.close(); 
-      }
+        if (!ice || !ice.candidate || !ice.candidate.candidate) {
+            logger.log("all done.");
+            pc.close();
+            return "";
+        }
+        logger.log("iceCandidate =" + ice.candidate.candidate);
+        let split = ice.candidate.candidate.split(" ");
+        if (split[7] === "host") {
+            logger.log(`fetchPublicIP:Local IP : ${split[4]}`);
+        } else {
+            logger.log(`fetchPublicIP:External IP : ${split[4]}`);
+            publicIp = `${split[4]}`
+            logger.log("fetchPublicIP:Public IP :" + publicIp);
+            localStorage.setItem("contactHost", publicIp);
+            pc.close();
+        }
     };
     sleep(500).then(function () {
         logger.log("fetchPublicIP: public ip = ", publicIp)
@@ -66,137 +66,137 @@ function fetchPublicIP(sipAccountInfo) {
             sipAccountInfo.contactHost = publicIp;
         }
     });
-    return; 
+    return;
 };
 
 
 export function ExDelegationHandler(exClient_) {
     var exClient = exClient_;
-    this.setTestingMode = function(mode) {
+    this.setTestingMode = function (mode) {
         logger.log("delegationHandler: setTestingMode\n");
     }
 
-    this.onCallStatSipJsSessionEvent = function(ev) {
+    this.onCallStatSipJsSessionEvent = function (ev) {
         logger.log("delegationHandler: onCallStatSipJsSessionEvent\n");
     }
 
-    this.sendWebRTCEventsToFSM = function(eventType, sipMethod) {
+    this.sendWebRTCEventsToFSM = function (eventType, sipMethod) {
         logger.log("delegationHandler: sendWebRTCEventsToFSM\n");
         logger.log("delegationHandler: eventType\n", eventType);
         logger.log("delegationHandler: sipMethod\n", sipMethod);
         if (sipMethod == "CONNECTION") {
             exClient.registerEventCallback(eventType, exClient.userName)
         } else if (sipMethod == "CALL") {
-            exClient.callEventCallback(eventType, exClient.callFromNumber,exClient.call)
+            exClient.callEventCallback(eventType, exClient.callFromNumber, exClient.call)
         }
     }
 
-    this.playBeepTone = function() {
+    this.playBeepTone = function () {
         logger.log("delegationHandler: playBeepTone\n");
     }
 
-    this.onStatPeerConnectionIceGatheringStateChange = function(iceGatheringState) {
+    this.onStatPeerConnectionIceGatheringStateChange = function (iceGatheringState) {
         logger.log("delegationHandler: onStatPeerConnectionIceGatheringStateChange\n");
     }
 
-    this.onCallStatIceCandidate = function(ev,icestate) {
+    this.onCallStatIceCandidate = function (ev, icestate) {
         logger.log("delegationHandler: onCallStatIceCandidate\n");
     }
 
-    this.onCallStatNegoNeeded = function(icestate) {
+    this.onCallStatNegoNeeded = function (icestate) {
         logger.log("delegationHandler: onCallStatNegoNeeded\n");
     }
 
-    this.onCallStatSignalingStateChange = function(cstate) {
+    this.onCallStatSignalingStateChange = function (cstate) {
         logger.log("delegationHandler: onCallStatSignalingStateChange\n");
     }
 
-    this.onStatPeerConnectionIceConnectionStateChange = function() {
+    this.onStatPeerConnectionIceConnectionStateChange = function () {
         logger.log("delegationHandler: onStatPeerConnectionIceConnectionStateChange\n");
     }
 
-    this.onStatPeerConnectionConnectionStateChange = function() {
+    this.onStatPeerConnectionConnectionStateChange = function () {
         logger.log("delegationHandler: onStatPeerConnectionConnectionStateChange\n");
     }
 
-    this.onGetUserMediaSuccessCallstatCallback = function() {
+    this.onGetUserMediaSuccessCallstatCallback = function () {
         logger.log("delegationHandler: onGetUserMediaSuccessCallstatCallback\n");
     }
 
-    this.onGetUserMediaErrorCallstatCallback = function() {
+    this.onGetUserMediaErrorCallstatCallback = function () {
         logger.log("delegationHandler: onGetUserMediaErrorCallstatCallback\n");
     }
 
-    this.onCallStatAddStream = function() {
+    this.onCallStatAddStream = function () {
         logger.log("delegationHandler: onCallStatAddStream\n");
     }
 
-    this.onCallStatRemoveStream = function() {
+    this.onCallStatRemoveStream = function () {
         logger.log("delegationHandler: onCallStatRemoveStream\n");
     }
 
-    this.setWebRTCFSMMapper = function(stack) {
+    this.setWebRTCFSMMapper = function (stack) {
         logger.log("delegationHandler: setWebRTCFSMMapper : Initialisation complete \n");
     }
 
-    this.onCallStatSipJsTransportEvent = function() {
+    this.onCallStatSipJsTransportEvent = function () {
         logger.log("delegationHandler: onCallStatSipJsTransportEvent\n");
     }
 
-    this.onCallStatSipSendCallback = function() {
+    this.onCallStatSipSendCallback = function () {
         logger.log("delegationHandler: onCallStatSipSendCallback\n");
     }
 
-    this.onCallStatSipRecvCallback = function() {
+    this.onCallStatSipRecvCallback = function () {
         logger.log("delegationHandler: onCallStatSipRecvCallback\n");
     }
 
-    this.stopCallStat = function() {
+    this.stopCallStat = function () {
         logger.log("delegationHandler: stopCallStat\n");
     }
 
-    this.onRecieveInvite = function(incomingSession) {
+    this.onRecieveInvite = function (incomingSession) {
         logger.log("delegationHandler: onRecieveInvite\n");
         exClient.callFromNumber = incomingSession.incomingInviteRequest.message.from.displayName;
     }
 
-    this.onPickCall = function() {
+    this.onPickCall = function () {
         logger.log("delegationHandler: onPickCall\n");
     }
 
-    this.onRejectCall = function() {
+    this.onRejectCall = function () {
         logger.log("delegationHandler: onRejectCall\n");
     }
 
-    this.onCreaterAnswer = function() {
+    this.onCreaterAnswer = function () {
         logger.log("delegationHandler: onCreaterAnswer\n");
     }
 
-    this.onSettingLocalDesc = function() {
+    this.onSettingLocalDesc = function () {
         logger.log("delegationHandler: onSettingLocalDesc\n");
     }
 
-    this.initGetStats = function(pc, callid, username) {
+    this.initGetStats = function (pc, callid, username) {
         logger.log("delegationHandler: initGetStats\n");
     }
 
-    this.onRegisterWebRTCSIPEngine = function(engine) {
+    this.onRegisterWebRTCSIPEngine = function (engine) {
         logger.log("delegationHandler: onRegisterWebRTCSIPEngine, engine=\n", engine);
-    }    
+    }
 }
 
 export function ExSynchronousHandler() {
 
-    this.onFailure = function() {
+    this.onFailure = function () {
         logger.log("synchronousHandler: onFailure, phone is offline.\n");
     }
 
-    this.onResponse = function() {
+    this.onResponse = function () {
         logger.log("synchronousHandler: onResponse, phone is connected.\n");
     }
 }
 
-export class ExotelWebClient  {
+export class ExotelWebClient {
 
 
 
@@ -210,7 +210,7 @@ export class ExotelWebClient  {
 
     sipAccountInfo = null;
 
-    initWebrtc = (sipAccountInfo_, 
+    initWebrtc = (sipAccountInfo_,
         RegisterEventCallBack, CallListenerCallback, SessionCallback) => {
 
         if (!this.eventListener) {
@@ -231,8 +231,8 @@ export class ExotelWebClient  {
 
         logger.log("Exotel Client Initialised with " + JSON.stringify(sipAccountInfo_))
         this.sipAccountInfo = sipAccountInfo_;
-        if ( !this.sipAccountInfo["userName"] || !this.sipAccountInfo["sipdomain"] || !this.sipAccountInfo["port"]) {
-            return false;                
+        if (!this.sipAccountInfo["userName"] || !this.sipAccountInfo["sipdomain"] || !this.sipAccountInfo["port"]) {
+            return false;
         }
         this.sipAccountInfo["sipUri"] = "wss://" + this.sipAccountInfo["userName"] + "@" + this.sipAccountInfo["sipdomain"] + ":" + this.sipAccountInfo["port"];
 
@@ -241,7 +241,7 @@ export class ExotelWebClient  {
         logger.log("Initializing session callback")
         sessionCallback.initializeSessionCallback(SessionCallback);
         this.setEventListener(this.eventListener);
-        return true;                
+        return true;
     };
 
     DoRegister = () => {
@@ -255,7 +255,7 @@ export class ExotelWebClient  {
     initDiagnostics = (saveDiagnosticsCallback, keyValueSetCallback) => {
         initDiagnosticsDL(saveDiagnosticsCallback, keyValueSetCallback)
     };
-    
+
     closeDiagnostics = () => {
         closeDiagnosticsDL()
     };
@@ -264,7 +264,7 @@ export class ExotelWebClient  {
         startSpeakerDiagnosticsTestDL()
     };
 
-    stopSpeakerDiagnosticsTest = (speakerTestResponse='none') => {
+    stopSpeakerDiagnosticsTest = (speakerTestResponse = 'none') => {
         stopSpeakerDiagnosticsTestDL(speakerTestResponse)
     };
 
@@ -272,7 +272,7 @@ export class ExotelWebClient  {
         startMicDiagnosticsTestDL()
     };
 
-    stopMicDiagnosticsTest = (micTestResponse='none') => {
+    stopMicDiagnosticsTest = (micTestResponse = 'none') => {
         stopMicDiagnosticsTestDL(micTestResponse)
     };
 
@@ -293,21 +293,21 @@ export class ExotelWebClient  {
      * function that returns the instance of the call controller object object
      */
 
-    getCallController =() => {
+    getCallController = () => {
         return this.ctrlr;
     };
 
-    getCall =() => {
+    getCall = () => {
         if (!this.call) {
             this.call = call = new Call();
-        }        
+        }
         return this.call;
     };
 
     /**
      * Dummy function to set the event listener object
      */
-    setEventListener =(eventListener) => {
+    setEventListener = (eventListener) => {
         this.eventListener = eventListener;
     };
 
@@ -319,25 +319,25 @@ export class ExotelWebClient  {
      * @param {*} param 
      */
 
-     registerEventCallback =(event, phone, param) => {
-        
-	    logger.log("Dialer: registerEventCallback: Received ---> " + event + 'phone....', phone + 'param....', param)
+    registerEventCallback = (event, phone, param) => {
+
+        logger.log("Dialer: registerEventCallback: Received ---> " + event + 'phone....', phone + 'param....', param)
         if (event === "connected") {
             /**
              * When registration is successful then send the phone number of the same to UI
              */
-             this.eventListener.onInitializationSuccess(phone);
-        } else if( event === "failed_to_start" || event === "transport_error"){
+            this.eventListener.onInitializationSuccess(phone);
+        } else if (event === "failed_to_start" || event === "transport_error") {
             /**
              * If registration fails
              */
-             this.eventListener.onInitializationFailure(phone);
-        } else if( event === "sent_request"){
+            this.eventListener.onInitializationFailure(phone);
+        } else if (event === "sent_request") {
             /**
              * If registration request waiting...
              */
-             this.eventListener.onInitializationWaiting(phone);
-        } 
+            this.eventListener.onInitializationWaiting(phone);
+        }
     };
     /**
      * Event listener for calls, any change in sipjsphone will trigger the callback here
@@ -345,65 +345,65 @@ export class ExotelWebClient  {
      * @param {*} phone 
      * @param {*} param 
      */
-    callEventCallback =(event, phone, param) => {
-	    logger.log("Dialer: callEventCallback: Received ---> " + event + 'param sent....' + param + 'for phone....' + phone)
+    callEventCallback = (event, phone, param) => {
+        logger.log("Dialer: callEventCallback: Received ---> " + event + 'param sent....' + param + 'for phone....' + phone)
         if (event === "i_new_call") {
-            this.callListener.onIncomingCall(param,phone)
+            this.callListener.onIncomingCall(param, phone)
         } else if (event === "connected") {
-            this.callListener.onCallEstablished(param,phone);
+            this.callListener.onCallEstablished(param, phone);
         } else if (event === "terminated") {
-            this.callListener.onCallEnded(param,phone);          
+            this.callListener.onCallEnded(param, phone);
         }
     };
-    
+
     /**
      * Event listener for diagnostic tests, any change in diagnostic tests will trigger this callback
      * @param {*} event 
      * @param {*} phone 
      * @param {*} param 
      */
-     diagnosticEventCallback =(event, phone, param) => {
+    diagnosticEventCallback = (event, phone, param) => {
         webrtcTroubleshooterEventBus.sendDiagnosticEvent(event, phone, param)
     };
-        
+
     /**
      * Function to unregister a phone
      * @param {*} sipAccountInfo 
      */
-    unregister =(sipAccountInfo) => {
+    unregister = (sipAccountInfo) => {
         // webrtcSIPPhone.unregister(sipAccountInfo)
         webrtcSIPPhone.sipUnRegisterWebRTC();
     };
 
 
-    webRTCStatusCallbackHandler =(msg1, arg1) => {
+    webRTCStatusCallbackHandler = (msg1, arg1) => {
         logger.log("webRTCStatusCallbackHandler: " + msg1 + " " + arg1)
     };
 
     /**
      * initialize function called when user wants to register client
      */
-    initialize =(uiContext, hostName,subscriberName,
-            displayName,accountSid,subscriberToken,
-            sipAccountInfo) => {
+    initialize = (uiContext, hostName, subscriberName,
+        displayName, accountSid, subscriberToken,
+        sipAccountInfo) => {
 
         let wssPort = sipAccountInfo.port;
         let wsPort = 4442;
         this.sipAccntInfo = {
-        'userName':'',
-        'authUser':'',
-        'domain':'',
-        'sipdomain':'',
-        'displayname':'',
-        'accountSid':'',
-        'secret':'',	
-        'sipUri':'',
-        'security':'',
-        'endpoint':'',
-        'port':'',
-        'contactHost':''
+            'userName': '',
+            'authUser': '',
+            'domain': '',
+            'sipdomain': '',
+            'displayname': '',
+            'accountSid': '',
+            'secret': '',
+            'sipUri': '',
+            'security': '',
+            'endpoint': '',
+            'port': '',
+            'contactHost': ''
         }
-                        
+
         logger.log('Sending register for the number..', subscriberName);
 
         fetchPublicIP(sipAccountInfo);
@@ -431,8 +431,8 @@ export class ExotelWebClient  {
 
         if (this.security === 'ws') {
             webrtcPort = wsPort;
-        }  
-        
+        }
+
 
 
         this.sipAccntInfo['userName'] = this.userName;
@@ -448,7 +448,7 @@ export class ExotelWebClient  {
         this.sipAccntInfo['contactHost'] = this.contactHost;
         localStorage.setItem('contactHost', this.contactHost);
         /* This is permanent -End */
-        
+
         /**
          * Call the webclient function inside this and pass register and call callbacks as arg
          */
@@ -460,13 +460,60 @@ export class ExotelWebClient  {
         //webRTCPhones[userName] = webRTC;
 
         /* New-Way  */
-        webrtcSIPPhone.registerPhone("sipjs",delegationHandler);
+        webrtcSIPPhone.registerPhone("sipjs", delegationHandler);
         webrtcSIPPhone.registerWebRTCClient(this.sipAccntInfo, synchronousHandler);
-        
-         /**
-          * Store the intervalID against a map
-          */
-         intervalIDMap.set(userName, intervalId);
+
+        /**
+         * Store the intervalID against a map
+         */
+        intervalIDMap.set(userName, intervalId);
+    };
+
+    checkClientStatus = (callback) => {
+        // using this function , first it will check mic permission is given or not
+        // then it will check if transport is intialize or not
+        // then it will check if user is registered or not
+        // based on this we can evaludate SDK is ready for call
+        var constraints = { audio: true, video: false };
+        navigator.mediaDevices
+            .getUserMedia(constraints)
+            .then(function (mediaStream) {
+                var transportState = webrtcSIPPhone.getTransportState();
+
+                switch (transportState) {
+                    case "":
+                        callback("not_intialized");
+                        break;
+                    case "unknown":
+                    case "Connecting":
+                        callback(transportState);
+                        break;
+
+                    default:
+                        var registerationState = webrtcSIPPhone.getRegistrationState();
+                        switch (registerationState) {
+                            case "":
+                                callback("websocket_connection_failed");
+                                break;
+                            case "Registered":
+                                if (transportState != "Connected") {
+                                    callback("Disconnected");
+                                } else {
+                                    callback(registerationState);
+                                }
+                                break;
+                            default:
+                                callback(registerationState);
+
+                        }
+
+
+                }
+            })
+            .catch(function (error) {
+                console.log("something went wrong during checkClientStatus ", error);
+                callback("media_permission_denied");
+            });
     };
 }