@exotel-npm-dev/webrtc-client-sdk 1.0.2 → 1.0.4

package/dist/ringbacktone.wav

@@ -0,0 +1 @@
+export default __webpack_public_path__ + "9b002be293af5cfbf781cfd215e3ea86.wav";

package/dist/ringtone.wav

@@ -0,0 +1 @@
+export default __webpack_public_path__ + "c79bd9a78f9efa815c0f1b4a5db3a98b.wav";

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@exotel-npm-dev/webrtc-client-sdk",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "client sdk for webrtc based on webrtc core sdk",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "webpack --config webpack.config.js"
   },
   "repository": {
     "type": "git",
@@ -21,5 +22,13 @@
   "homepage": "https://bitbucket.org/Exotel/webrtc#readme",
   "dependencies": {
     "@exotel-npm-dev/webrtc-core-sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "babel-loader": "^8.2.5",
+    "circular-dependency-plugin": "^5.2.2",
+    "file-loader": "^6.2.0",
+    "uuid": "^9.0.0",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0"
   }
 }

package/src/listeners/ExWebClient.js

@@ -87,7 +87,7 @@ export function ExDelegationHandler(exClient_) {
         if (sipMethod == "CONNECTION") {
             exClient.registerEventCallback(eventType, exClient.userName)
         } else if (sipMethod == "CALL") {
-            exClient.callEventCallback(eventType, exClient.userName,exClient.call)
+            exClient.callEventCallback(eventType, exClient.callFromNumber,exClient.call)
         }
     }
 
@@ -155,8 +155,9 @@ export function ExDelegationHandler(exClient_) {
         logger.log("delegationHandler: stopCallStat\n");
     }
 
-    this.onRecieveInvite = function() {
+    this.onRecieveInvite = function(incomingSession) {
         logger.log("delegationHandler: onRecieveInvite\n");
+        exClient.callFromNumber = incomingSession.incomingInviteRequest.message.from.displayName;
     }
 
     this.onPickCall = function() {
@@ -195,119 +196,120 @@ export function ExSynchronousHandler() {
     }
 }
 
-export const ExotelWebClient = {
+export class ExotelWebClient  {
 
 
 
-    ctrlr : null,
-    call : null,
-    eventListener : null,
-    callListener : null,
+    ctrlr = null;
+    call = null;
+    eventListener = null;
+    callListener = null;
+    callFromNumber = null;
     /* OLD-Way to be revisited for multile phone support */
     //this.webRTCPhones = {};
 
-    sipAccountInfo : null,
+    sipAccountInfo = null;
 
-    initWebrtc : (sipAccountInfo_, 
+    initWebrtc = (sipAccountInfo_, 
         RegisterEventCallBack, CallListenerCallback, SessionCallback) => {
 
-        if (!ExotelWebClient.eventListener) {
-            ExotelWebClient.eventListener = new ExotelVoiceClientListener();
+        if (!this.eventListener) {
+            this.eventListener = new ExotelVoiceClientListener();
         }
 
-        if (!ExotelWebClient.callListener) {
-            ExotelWebClient.callListener = new CallListener();
+        if (!this.callListener) {
+            this.callListener = new CallListener();
         }
 
-        if (!ExotelWebClient.ctrlr) {
-            ExotelWebClient.ctrlr = new CallController();
+        if (!this.ctrlr) {
+            this.ctrlr = new CallController();
         }
 
-        if (!ExotelWebClient.call) {
-            ExotelWebClient.call = new Call();
+        if (!this.call) {
+            this.call = new Call();
         }
 
         logger.log("Exotel Client Initialised with " + JSON.stringify(sipAccountInfo_))
-        ExotelWebClient.sipAccountInfo = sipAccountInfo_;
-        if ( !ExotelWebClient.sipAccountInfo["userName"] || !ExotelWebClient.sipAccountInfo["sipdomain"] || !ExotelWebClient.sipAccountInfo["port"]) {
+        this.sipAccountInfo = sipAccountInfo_;
+        if ( !this.sipAccountInfo["userName"] || !this.sipAccountInfo["sipdomain"] || !this.sipAccountInfo["port"]) {
             return false;                
         }
-        ExotelWebClient.sipAccountInfo["sipUri"] = "wss://" + ExotelWebClient.sipAccountInfo["userName"] + "@" + ExotelWebClient.sipAccountInfo["sipdomain"] + ":" + ExotelWebClient.sipAccountInfo["port"];
+        this.sipAccountInfo["sipUri"] = "wss://" + this.sipAccountInfo["userName"] + "@" + this.sipAccountInfo["sipdomain"] + ":" + this.sipAccountInfo["port"];
 
         callbacks.initializeCallback(CallListenerCallback);
         registerCallback.initializeRegisterCallback(RegisterEventCallBack);
         logger.log("Initializing session callback")
         sessionCallback.initializeSessionCallback(SessionCallback);
-        ExotelWebClient.setEventListener(ExotelWebClient.eventListener);
+        this.setEventListener(this.eventListener);
         return true;                
-    },
+    };
 
-    DoRegister : () => {
-        DoRegisterRL(ExotelWebClient.sipAccountInfo, ExotelWebClient)
-    },
+    DoRegister = () => {
+        DoRegisterRL(this.sipAccountInfo, this)
+    };
 
-    UnRegister : () => {
-        UnRegisterRL(ExotelWebClient.sipAccountInfo, ExotelWebClient)
-    },
+    UnRegister = () => {
+        UnRegisterRL(this.sipAccountInfo, this)
+    };
 
-    initDiagnostics : (saveDiagnosticsCallback, keyValueSetCallback) => {
+    initDiagnostics = (saveDiagnosticsCallback, keyValueSetCallback) => {
         initDiagnosticsDL(saveDiagnosticsCallback, keyValueSetCallback)
-    },
+    };
     
-    closeDiagnostics : () => {
+    closeDiagnostics = () => {
         closeDiagnosticsDL()
-    },
+    };
 
-    startSpeakerDiagnosticsTest : () => {
+    startSpeakerDiagnosticsTest = () => {
         startSpeakerDiagnosticsTestDL()
-    },
+    };
 
-    stopSpeakerDiagnosticsTest : (speakerTestResponse='none') => {
+    stopSpeakerDiagnosticsTest = (speakerTestResponse='none') => {
         stopSpeakerDiagnosticsTestDL(speakerTestResponse)
-    },
+    };
 
-    startMicDiagnosticsTest : () => {
+    startMicDiagnosticsTest = () => {
         startMicDiagnosticsTestDL()
-    },
+    };
 
-    stopMicDiagnosticsTest : (micTestResponse='none') => {
+    stopMicDiagnosticsTest = (micTestResponse='none') => {
         stopMicDiagnosticsTestDL(micTestResponse)
-    },
+    };
 
-    startNetworkDiagnostics : () => {
+    startNetworkDiagnostics = () => {
         startNetworkDiagnosticsDL()
-        ExotelWebClient.DoRegister()
-    },
+        this.DoRegister()
+    };
 
-    stopNetworkDiagnostics : () => {
+    stopNetworkDiagnostics = () => {
         stopNetworkDiagnosticsDL()
-    },
+    };
 
-    SessionListener : () => {
+    SessionListener = () => {
         SessionListenerSL()
-    },
+    };
 
     /**
      * function that returns the instance of the call controller object object
      */
 
-    getCallController :() => {
-        return ExotelWebClient.ctrlr;
-    },
+    getCallController =() => {
+        return this.ctrlr;
+    };
 
-    getCall :() => {
-        if (!ExotelWebClient.call) {
-            ExotelWebClient.call = call = new Call();
+    getCall =() => {
+        if (!this.call) {
+            this.call = call = new Call();
         }        
-        return ExotelWebClient.call;
-    },
+        return this.call;
+    };
 
     /**
      * Dummy function to set the event listener object
      */
-    setEventListener :(eventListener) => {
-        ExotelWebClient.eventListener = eventListener;
-    },
+    setEventListener =(eventListener) => {
+        this.eventListener = eventListener;
+    };
 
 
     /**
@@ -317,42 +319,42 @@ export const ExotelWebClient = {
      * @param {*} param 
      */
 
-     registerEventCallback :(event, phone, 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
              */
-             ExotelWebClient.eventListener.onInitializationSuccess(phone);
+             this.eventListener.onInitializationSuccess(phone);
         } else if( event === "failed_to_start" || event === "transport_error"){
             /**
              * If registration fails
              */
-             ExotelWebClient.eventListener.onInitializationFailure(phone);
+             this.eventListener.onInitializationFailure(phone);
         } else if( event === "sent_request"){
             /**
              * If registration request waiting...
              */
-             ExotelWebClient.eventListener.onInitializationWaiting(phone);
+             this.eventListener.onInitializationWaiting(phone);
         } 
-    },
+    };
     /**
      * Event listener for calls, any change in sipjsphone will trigger the callback here
      * @param {*} event 
      * @param {*} phone 
      * @param {*} param 
      */
-    callEventCallback :(event, phone, param) => {
+    callEventCallback =(event, phone, param) => {
 	    logger.log("Dialer: callEventCallback: Received ---> " + event + 'param sent....' + param + 'for phone....' + phone)
         if (event === "i_new_call") {
-            ExotelWebClient.callListener.onIncomingCall(param,phone)
+            this.callListener.onIncomingCall(param,phone)
         } else if (event === "connected") {
-            ExotelWebClient.callListener.onCallEstablished(param,phone);
+            this.callListener.onCallEstablished(param,phone);
         } else if (event === "terminated") {
-            ExotelWebClient.callListener.onCallEnded(param,phone);          
+            this.callListener.onCallEnded(param,phone);          
         }
-    },
+    };
     
     /**
      * Event listener for diagnostic tests, any change in diagnostic tests will trigger this callback
@@ -360,34 +362,34 @@ export const ExotelWebClient = {
      * @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,
+    initialize =(uiContext, hostName,subscriberName,
             displayName,accountSid,subscriberToken,
             sipAccountInfo) => {
 
         let wssPort = sipAccountInfo.port;
-        let wsPort = 8089;
-        ExotelWebClient.sipAccntInfo = {
+        let wsPort = 4442;
+        this.sipAccntInfo = {
         'userName':'',
         'authUser':'',
         'domain':'',
@@ -407,65 +409,65 @@ export const ExotelWebClient = {
         fetchPublicIP(sipAccountInfo);
 
         /* Temporary till we figure out the arguments - Start */
-        ExotelWebClient.domain = hostName = sipAccountInfo.domain;
-        ExotelWebClient.sipdomain = sipAccountInfo.sipdomain;
-        ExotelWebClient.accountName = ExotelWebClient.userName = sipAccountInfo.userName;
-        ExotelWebClient.authUser = subscriberName = sipAccountInfo.authUser;
-        ExotelWebClient.displayName = sipAccountInfo.displayName;
-        ExotelWebClient.accountSid = 'exotelt1';
-        ExotelWebClient.subscriberToken = sipAccountInfo.secret;
-        ExotelWebClient.secret = ExotelWebClient.password = sipAccountInfo.secret;
-        ExotelWebClient.endpoint = sipAccountInfo.endpoint;
-        ExotelWebClient.port = sipAccountInfo.port;
-        ExotelWebClient.contactHost = sipAccountInfo.contactHost;
-        ExotelWebClient.sipWsPort = 5061;
-        ExotelWebClient.sipPort = 5061;
-        ExotelWebClient.sipSecurePort = 5062;
+        this.domain = hostName = sipAccountInfo.domain;
+        this.sipdomain = sipAccountInfo.sipdomain;
+        this.accountName = this.userName = sipAccountInfo.userName;
+        this.authUser = subscriberName = sipAccountInfo.authUser;
+        this.displayName = sipAccountInfo.displayName;
+        this.accountSid = 'exotelt1';
+        this.subscriberToken = sipAccountInfo.secret;
+        this.secret = this.password = sipAccountInfo.secret;
+        this.security = sipAccountInfo.security ? sipAccountInfo.security : "wss";
+        this.endpoint = sipAccountInfo.endpoint ? sipAccountInfo.endpoint : "wss";
+        this.port = sipAccountInfo.port;
+        this.contactHost = sipAccountInfo.contactHost;
+        this.sipWsPort = 5061;
+        this.sipPort = 5061;
+        this.sipSecurePort = 5062;
         /* Temporary till we figure out the arguments - End */
 
         /* This is permanent -Start */
-        let webrtcPort = wsPort;
+        let webrtcPort = wssPort;
 
-        if (ExotelWebClient.endpoint === 'wss') {
-            ExotelWebClient.security = 'wss';
-            webrtcPort = wssPort;
-        } 
+        if (this.security === 'ws') {
+            webrtcPort = wsPort;
+        }  
         
 
 
-        ExotelWebClient.sipAccntInfo['userName'] = ExotelWebClient.userName;
-        ExotelWebClient.sipAccntInfo['authUser'] = subscriberName;
-        ExotelWebClient.sipAccntInfo['domain'] = hostName;
-        ExotelWebClient.sipAccntInfo['sipdomain'] = ExotelWebClient.sipdomain;
-        ExotelWebClient.sipAccntInfo['accountName'] = ExotelWebClient.userName;
-        ExotelWebClient.sipAccntInfo['secret'] = ExotelWebClient.password;
-        ExotelWebClient.sipAccntInfo['sipuri'] = ExotelWebClient.sipuri;
-        ExotelWebClient.sipAccntInfo['security'] = ExotelWebClient.security;
-        ExotelWebClient.sipAccntInfo['endpoint'] = ExotelWebClient.endpoint;
-        ExotelWebClient.sipAccntInfo['port'] = webrtcPort;
-        ExotelWebClient.sipAccntInfo['contactHost'] = ExotelWebClient.contactHost;
-        localStorage.setItem('contactHost', ExotelWebClient.contactHost);
+        this.sipAccntInfo['userName'] = this.userName;
+        this.sipAccntInfo['authUser'] = subscriberName;
+        this.sipAccntInfo['domain'] = hostName;
+        this.sipAccntInfo['sipdomain'] = this.sipdomain;
+        this.sipAccntInfo['accountName'] = this.userName;
+        this.sipAccntInfo['secret'] = this.password;
+        this.sipAccntInfo['sipuri'] = this.sipuri;
+        this.sipAccntInfo['security'] = this.security;
+        this.sipAccntInfo['endpoint'] = this.endpoint;
+        this.sipAccntInfo['port'] = webrtcPort;
+        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
          */
-        var synchronousHandler = new ExSynchronousHandler(ExotelWebClient);
-        var delegationHandler = new ExDelegationHandler(ExotelWebClient);
+        var synchronousHandler = new ExSynchronousHandler(this);
+        var delegationHandler = new ExDelegationHandler(this);
 
-        var userName = ExotelWebClient.userName;
+        var userName = this.userName;
         /* OLD-Way to be revisited for multile phone support */
         //webRTCPhones[userName] = webRTC;
 
         /* New-Way  */
         webrtcSIPPhone.registerPhone("sipjs",delegationHandler);
-        webrtcSIPPhone.registerWebRTCClient(ExotelWebClient.sipAccntInfo, synchronousHandler);
+        webrtcSIPPhone.registerWebRTCClient(this.sipAccntInfo, synchronousHandler);
         
          /**
           * Store the intervalID against a map
           */
          intervalIDMap.set(userName, intervalId);
-    }
+    };
 }
 
 export default ExotelWebClient;

package/webpack.config.js

@@ -0,0 +1,75 @@
+const path = require('path');
+var webpack = require('webpack');
+var TerserPlugin = require('terser-webpack-plugin');
+const CircularDependencyPlugin = require('circular-dependency-plugin')
+
+var pkg = require('./package.json');
+var banner = '\
+\n\
+WebRTC CLient SIP version ' + pkg.version + '\n\
+';
+
+module.exports = {
+  entry: {
+    exotelsdk: './index.js'
+  },  
+  devtool: 'source-map',
+  mode: 'development',
+  output: {
+    filename:'[name].js',
+    path: path.resolve(__dirname, 'dist'),
+    libraryTarget: 'umd',
+    library: 'exotelSDK',
+    globalObject: 'this',
+    assetModuleFilename: '[name][ext][query]'
+  },
+  module: {
+    rules: [
+      { test: /\.wav$/,exclude: /node_modules/, use: 'file-loader',type: 'asset/resource' },
+      {
+        test: /\.ts$/,
+        exclude: /node_modules/,
+        loader: "ts-loader",
+        options: {
+          compilerOptions: {
+            "declaration": false,
+            "declarationMap": false,
+            "outDir": path.resolve(__dirname, 'dist')
+          }
+        }
+      },
+      {
+        test: /\.(js)$/,
+        exclude: /node_modules/,
+        use: 'babel-loader',
+      }
+    ],
+  },
+  resolve: {
+    extensions: ['.ts', '.d.ts', '.js']
+  },
+  optimization: {
+    minimizer: [
+      new TerserPlugin({
+        terserOptions: {
+          output: {
+            ascii_only: true
+          }
+        }
+      })
+    ]
+  },
+  plugins: [
+    new CircularDependencyPlugin({
+      // exclude detection of files based on a RegExp
+      exclude: /a\.js|node_modules/,
+      // add errors to webpack instead of warnings
+      failOnError: true,
+      // set the current working directory for displaying module paths
+      cwd: process.cwd(),
+    }),
+    new webpack.BannerPlugin({
+      banner: banner
+    })
+  ]
+};