@exotel-npm-dev/webrtc-client-sdk 1.0.0

package/src/listeners/ExWebClient.js

@@ -0,0 +1,468 @@
+import { Call }  from "../api/callAPI/Call";
+import { CallController } from "./CallCtrlerDummy";
+import { CallListener } from '../listeners/CallListener';
+import { DoRegister as DoRegisterRL } from '../api/registerAPI/RegisterListener';
+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 { stopMicDiagnosticsTest as stopMicDiagnosticsTestDL } from '../api/omAPI/DiagnosticsListener';
+import { closeDiagnostics as closeDiagnosticsDL} from '../api/omAPI/DiagnosticsListener';
+
+import { callbacks } from '../listeners/Callback';
+import { registerCallback } from '../listeners/Callback';
+import { sessionCallback } from '../listeners/Callback';
+import { webrtcTroubleshooterEventBus } from "./Callback";
+
+import { webrtcLogger } from "../api/omAPI/WebrtcLogger";
+var webrtcSIPPhone = require('@exotel-npm-dev/webrtc-core-sdk/src/webrtcSIPPhone').webrtcSIPPhone;
+
+var intervalId;
+var intervalIDMap = new Map();
+
+var logger = webrtcLogger();
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * FQDN for fetching IP
+ */
+function fetchPublicIP(sipAccountInfo) {
+    var publicIp = "";
+    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(); 
+      }
+    };
+    sleep(500).then(function () {
+        logger.log("fetchPublicIP: public ip = ", publicIp)
+        if (publicIp == "") {
+            sipAccountInfo.contactHost = window.localStorage.getItem('contactHost');
+        } else {
+            sipAccountInfo.contactHost = publicIp;
+        }
+    });
+    return; 
+};
+
+
+export function ExDelegationHandler(exClient_) {
+    var exClient = exClient_;
+    this.setTestingMode = function(mode) {
+        logger.log("delegationHandler: setTestingMode\n");
+    }
+
+    this.onCallStatSipJsSessionEvent = function(ev) {
+        logger.log("delegationHandler: onCallStatSipJsSessionEvent\n");
+    }
+
+    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.userName,exClient.call)
+        }
+    }
+
+    this.playBeepTone = function() {
+        logger.log("delegationHandler: playBeepTone\n");
+    }
+
+    this.onStatPeerConnectionIceGatheringStateChange = function(iceGatheringState) {
+        logger.log("delegationHandler: onStatPeerConnectionIceGatheringStateChange\n");
+    }
+
+    this.onCallStatIceCandidate = function(ev,icestate) {
+        logger.log("delegationHandler: onCallStatIceCandidate\n");
+    }
+
+    this.onCallStatNegoNeeded = function(icestate) {
+        logger.log("delegationHandler: onCallStatNegoNeeded\n");
+    }
+
+    this.onCallStatSignalingStateChange = function(cstate) {
+        logger.log("delegationHandler: onCallStatSignalingStateChange\n");
+    }
+
+    this.onStatPeerConnectionIceConnectionStateChange = function() {
+        logger.log("delegationHandler: onStatPeerConnectionIceConnectionStateChange\n");
+    }
+
+    this.onStatPeerConnectionConnectionStateChange = function() {
+        logger.log("delegationHandler: onStatPeerConnectionConnectionStateChange\n");
+    }
+
+    this.onGetUserMediaSuccessCallstatCallback = function() {
+        logger.log("delegationHandler: onGetUserMediaSuccessCallstatCallback\n");
+    }
+
+    this.onGetUserMediaErrorCallstatCallback = function() {
+        logger.log("delegationHandler: onGetUserMediaErrorCallstatCallback\n");
+    }
+
+    this.onCallStatAddStream = function() {
+        logger.log("delegationHandler: onCallStatAddStream\n");
+    }
+
+    this.onCallStatRemoveStream = function() {
+        logger.log("delegationHandler: onCallStatRemoveStream\n");
+    }
+
+    this.setWebRTCFSMMapper = function(stack) {
+        logger.log("delegationHandler: setWebRTCFSMMapper : Initialisation complete \n");
+    }
+
+    this.onCallStatSipJsTransportEvent = function() {
+        logger.log("delegationHandler: onCallStatSipJsTransportEvent\n");
+    }
+
+    this.onCallStatSipSendCallback = function() {
+        logger.log("delegationHandler: onCallStatSipSendCallback\n");
+    }
+
+    this.onCallStatSipRecvCallback = function() {
+        logger.log("delegationHandler: onCallStatSipRecvCallback\n");
+    }
+
+    this.stopCallStat = function() {
+        logger.log("delegationHandler: stopCallStat\n");
+    }
+
+    this.onRecieveInvite = function() {
+        logger.log("delegationHandler: onRecieveInvite\n");
+    }
+
+    this.onPickCall = function() {
+        logger.log("delegationHandler: onPickCall\n");
+    }
+
+    this.onRejectCall = function() {
+        logger.log("delegationHandler: onRejectCall\n");
+    }
+
+    this.onCreaterAnswer = function() {
+        logger.log("delegationHandler: onCreaterAnswer\n");
+    }
+
+    this.onSettingLocalDesc = function() {
+        logger.log("delegationHandler: onSettingLocalDesc\n");
+    }
+
+    this.initGetStats = function(pc, callid, username) {
+        logger.log("delegationHandler: initGetStats\n");
+    }
+
+    this.onRegisterWebRTCSIPEngine = function(engine) {
+        logger.log("delegationHandler: onRegisterWebRTCSIPEngine, engine=\n", engine);
+    }    
+}
+
+export function ExSynchronousHandler() {
+
+    this.onFailure = function() {
+        logger.log("synchronousHandler: onFailure, phone is offline.\n");
+    }
+
+    this.onResponse = function() {
+        logger.log("synchronousHandler: onResponse, phone is connected.\n");
+    }
+}
+
+export const ExotelWebClient = {
+
+
+
+    ctrlr : null,
+    call : null,
+    eventListener : null,
+    callListener : null,
+    /* OLD-Way to be revisited for multile phone support */
+    //this.webRTCPhones = {};
+
+    sipAccountInfo : null,
+
+    initWebrtc : (sipAccountInfo_, 
+        RegisterEventCallBack, CallListenerCallback, SessionCallback) => {
+
+        if (!ExotelWebClient.eventListener) {
+            ExotelWebClient.eventListener = new ExotelVoiceClientListener();
+        }
+
+        if (!ExotelWebClient.callListener) {
+            ExotelWebClient.callListener = new CallListener();
+        }
+
+        if (!ExotelWebClient.ctrlr) {
+            ExotelWebClient.ctrlr = new CallController();
+        }
+
+        if (!ExotelWebClient.call) {
+            ExotelWebClient.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"]) {
+            return false;                
+        }
+        ExotelWebClient.sipAccountInfo["sipUri"] = "wss://" + ExotelWebClient.sipAccountInfo["userName"] + "@" + ExotelWebClient.sipAccountInfo["sipdomain"] + ":" + ExotelWebClient.sipAccountInfo["port"];
+
+        callbacks.initializeCallback(CallListenerCallback);
+        registerCallback.initializeRegisterCallback(RegisterEventCallBack);
+        logger.log("Initializing session callback")
+        sessionCallback.initializeSessionCallback(SessionCallback);
+        ExotelWebClient.setEventListener(ExotelWebClient.eventListener);
+        return true;                
+    },
+
+    DoRegister : () => {
+        DoRegisterRL(ExotelWebClient.sipAccountInfo, ExotelWebClient)
+    },
+
+    UnRegister : () => {
+        UnRegisterRL(ExotelWebClient.sipAccountInfo, ExotelWebClient)
+    },
+
+    initDiagnostics : (saveDiagnosticsCallback, keyValueSetCallback) => {
+        initDiagnosticsDL(saveDiagnosticsCallback, keyValueSetCallback)
+    },
+    
+    closeDiagnostics : () => {
+        closeDiagnosticsDL()
+    },
+
+    startSpeakerDiagnosticsTest : () => {
+        startSpeakerDiagnosticsTestDL()
+    },
+
+    stopSpeakerDiagnosticsTest : (speakerTestResponse='none') => {
+        stopSpeakerDiagnosticsTestDL(speakerTestResponse)
+    },
+
+    startMicDiagnosticsTest : () => {
+        startMicDiagnosticsTestDL()
+    },
+
+    stopMicDiagnosticsTest : (micTestResponse='none') => {
+        stopMicDiagnosticsTestDL(micTestResponse)
+    },
+
+    startNetworkDiagnostics : () => {
+        startNetworkDiagnosticsDL()
+        ExotelWebClient.DoRegister()
+    },
+
+    stopNetworkDiagnostics : () => {
+        stopNetworkDiagnosticsDL()
+    },
+
+    SessionListener : () => {
+        SessionListenerSL()
+    },
+
+    /**
+     * function that returns the instance of the call controller object object
+     */
+
+    getCallController :() => {
+        return ExotelWebClient.ctrlr;
+    },
+
+    getCall :() => {
+        if (!ExotelWebClient.call) {
+            ExotelWebClient.call = call = new Call();
+        }        
+        return ExotelWebClient.call;
+    },
+
+    /**
+     * Dummy function to set the event listener object
+     */
+    setEventListener :(eventListener) => {
+        ExotelWebClient.eventListener = eventListener;
+    },
+
+
+    /**
+     * Event listener for registration, any change in registration state will trigger the callback here
+     * @param {*} event 
+     * @param {*} 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
+             */
+             ExotelWebClient.eventListener.onInitializationSuccess(phone);
+        } else if( event === "failed_to_start" || event === "transport_error"){
+            /**
+             * If registration fails
+             */
+             ExotelWebClient.eventListener.onInitializationFailure(phone);
+        } else if( event === "sent_request"){
+            /**
+             * If registration request waiting...
+             */
+             ExotelWebClient.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) => {
+	    logger.log("Dialer: callEventCallback: Received ---> " + event + 'param sent....' + param + 'for phone....' + phone)
+        if (event === "i_new_call") {
+            callListener.onIncomingCall(param,phone)
+        } else if (event === "connected") {
+            callListener.onCallEstablished(param,phone);
+        } else if (event === "terminated") {
+            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) => {
+        webrtcTroubleshooterEventBus.sendDiagnosticEvent(event, phone, param)
+    },
+        
+    /**
+     * Function to unregister a phone
+     * @param {*} sipAccountInfo 
+     */
+    unregister :(sipAccountInfo) => {
+        // webrtcSIPPhone.unregister(sipAccountInfo)
+        webrtcSIPPhone.sipUnRegisterWebRTC();
+    }, 
+
+
+    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) => {
+
+        let wssPort = sipAccountInfo.port;
+        let wsPort = 4442;
+        ExotelWebClient.sipAccntInfo = {
+        'userName':'',
+        'authUser':'',
+        'domain':'',
+        'sipdomain':'',
+        'displayname':'',
+        'accountSid':'',
+        'secret':'',	
+        'sipUri':'',
+        'security':'',
+        'port':'',
+        'contactHost':''
+        }
+                        
+        logger.log('Sending register for the number..', subscriberName);
+
+        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.security = sipAccountInfo.security;
+        ExotelWebClient.port = sipAccountInfo.port;
+        ExotelWebClient.contactHost = sipAccountInfo.contactHost;
+        ExotelWebClient.sipWsPort = 5061;
+        ExotelWebClient.sipPort = 5061;
+        ExotelWebClient.sipSecurePort = 5062;
+        /* Temporary till we figure out the arguments - End */
+
+        /* This is permanent -Start */
+        let webrtcPort = wssPort;
+
+        if (ExotelWebClient.security === 'ws') {
+            webrtcPort = wsPort;
+        }   
+        
+
+
+        ExotelWebClient.sipAccntInfo['userName'] = userName;
+        ExotelWebClient.sipAccntInfo['authUser'] = subscriberName;
+        ExotelWebClient.sipAccntInfo['domain'] = hostName;
+        ExotelWebClient.sipAccntInfo['sipdomain'] = ExotelWebClient.sipdomain;
+        ExotelWebClient.sipAccntInfo['accountName'] = userName;
+        ExotelWebClient.sipAccntInfo['secret'] = ExotelWebClient.password;
+        ExotelWebClient.sipAccntInfo['sipuri'] = ExotelWebClient.sipuri;
+        ExotelWebClient.sipAccntInfo['security'] = ExotelWebClient.security;
+        ExotelWebClient.sipAccntInfo['port'] = ExotelWebClient.webrtcPort;
+        ExotelWebClient.sipAccntInfo['contactHost'] = ExotelWebClient.contactHost;
+        localStorage.setItem('contactHost', ExotelWebClient.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 userName = userName;
+        /* OLD-Way to be revisited for multile phone support */
+        //webRTCPhones[userName] = webRTC;
+
+        /* New-Way  */
+        webrtcSIPPhone.registerPhone("sipjs",delegationHandler);
+        webrtcSIPPhone.registerWebRTCClient(ExotelWebClient.sipAccntInfo, synchronousHandler);
+        
+         /**
+          * Store the intervalID against a map
+          */
+         intervalIDMap.set(userName, intervalId);
+    }
+}
+
+export default ExotelWebClient;

package/src/listeners/ExotelVoiceClientListener.js

@@ -0,0 +1,45 @@
+import { registerCallback } from "./Callback";
+import { diagnosticsCallback } from "./Callback";
+
+export class ExotelVoiceClientListener{
+    onInitializationSuccess(phone) {
+        /**
+         * Abstract class for Initialization Success
+         */
+        registerCallback.initializeRegister("registered", phone);
+        /**
+         * Triggers UI callback to indicate the status of the registered phone
+         */
+        registerCallback.triggerRegisterCallback();
+        diagnosticsCallback.triggerKeyValueSetCallback("userReg", "registered", phone); 
+    }
+    
+    onInitializationFailure(phone){
+        /**
+         * If register fails send error message to Callback function 
+         */
+        registerCallback.initializeRegister("unregistered", phone);
+        registerCallback.triggerRegisterCallback();
+        diagnosticsCallback.triggerKeyValueSetCallback("userReg", "unregistered", phone); 
+    }
+
+    onInitializationWaiting(phone){
+        /**
+         * If register fails send error message to Callback function 
+         */
+        registerCallback.initializeRegister("sent_request", phone);
+        registerCallback.triggerRegisterCallback();
+        diagnosticsCallback.triggerKeyValueSetCallback("userReg", "sent_request", phone); 
+    }
+
+    onLog(LogLevel, tag, message){
+        /**
+         * To get SDK logs
+         */
+    }
+    onAuthenticationFailure(){
+        /**
+         * In case if there is any authentication error in registration, handle here
+         */
+    }
+}

package/src/listeners/SessionListeners.js

@@ -0,0 +1,123 @@
+import { sessionCallback } from './Callback';
+import { v4 as uuidv4 } from 'uuid';
+import { FetchTabInfo } from '../constants/common';
+import { webrtcLogger } from "../api/omAPI/WebrtcLogger"
+
+var logger = webrtcLogger()
+/**
+ * Session listeners is invoked when user opens two tabs, the data in tab 1 is
+ * copied into tab 2
+ */
+export function SessionListener () {
+
+        const channel = new BroadcastChannel('app-data');
+        channel.addEventListener ('message', (event) => {
+        if(event.data.message == "re-register-needed"){
+          /** Send the hash to app seeking for reregistration */
+          sessionCallback.initializeSession('re-register', event.data.hashMsg);
+          sessionCallback.triggerSessionCallback();
+        }else if(event.data.message == 'logout'){
+          sessionCallback.initializeSession('logout', '');
+          sessionCallback.triggerSessionCallback();
+        }else if(event.data.message == 'login-successful'){
+          const loginObj = {
+            phone: window.localStorage.getItem('currentUser'),
+            tabHash: event.data.tabHash
+          }
+          sessionCallback.initializeSession('login-successful', JSON.stringify(loginObj));
+          sessionCallback.triggerSessionCallback();
+        }else if(window.sessionStorage.getItem("activeSessionTab") !== null){
+          if(event.data.callState !== null && event.data.callState !== undefined){
+            sessionCallback.initializeSession(event.data.callState, event.data.callNumber);
+          }
+          sessionCallback.triggerSessionCallback();
+        }
+        });
+        /**
+         * Add listeners for all storage events
+         */
+         window.localStorage.setItem('REQUESTING_SHARED_CREDENTIALS', Date.now().toString())
+         window.localStorage.removeItem('REQUESTING_SHARED_CREDENTIALS')
+
+         const credentials = {
+             user: window.sessionStorage.getItem('user'),
+             selectedPhone: window.localStorage.getItem('selectedPhone'),
+         }
+  
+         window.addEventListener('storage', (event) => {
+                /**
+                * When user tries to duplicate tab, this gets called in Tab1
+                */
+            if(event.key === 'REQUESTING_SHARED_CREDENTIALS' && credentials) {
+                window.localStorage.setItem('CREDENTIALS_SHARING', JSON.stringify(credentials))
+                window.localStorage.removeItem('CREDENTIALS_SHARING')
+                /**
+                 * When the data is to be shared between two tabs then add the current state onto that session storage
+                 */
+                //sessionCallback.triggerSessionCallback();
+              }
+              if(event.key === 'CREDENTIALS_SHARING' && credentials !== null){
+              
+                  const newData = JSON.parse(event.newValue);
+                  if(event.newValue !== null){
+                    window.sessionStorage.setItem('user', newData.user);
+                    window.sessionStorage.setItem('isAuthenticated', true);
+                  }
+                    /**
+                     * Fetch the array of tabs and add the tab, put it on session also
+                     */
+                     const currentTab = {
+                      tabID: uuidv4(),
+                      tabType: 'child',
+                      tabStatus: 'active'
+                    }
+                    const tabArr = JSON.parse(window.localStorage.getItem('tabs'));
+                    /** Based on activeSessionTab id fetch the type */
+                  
+                    if(window.sessionStorage.getItem('activeSessionTab') !== null && window.sessionStorage.getItem('activeSessionTab') == "parent0"){
+                      logger.log('Adding a child tab spawned from parent....');
+                      /** In order to keep tabID same for all the child ones, we are using below IF to distinguish */
+                     
+                      if(tabArr.length > 1 && window.sessionStorage.getItem('activeSessionTab') == "parent0") {
+                        if(!document.hidden){
+                          const lastIndex = (tabArr.length) - 1;
+                        window.sessionStorage.setItem('activeSessionTab', tabArr[lastIndex].tabID);
+                        } 
+                        
+                      }else {
+                        tabArr.push(currentTab);
+                        window.localStorage.removeItem('tabs');
+                        window.localStorage.setItem('tabs', JSON.stringify(tabArr));
+                        const lastIndex = (tabArr.length) - 1;
+                        window.sessionStorage.setItem('activeSessionTab', tabArr[lastIndex].tabID);
+                      }
+                      
+                      
+                    } else {
+                      /** pull from the tabarray and then add it to the session storage */
+                      
+                      const lastIndex = (tabArr.length) - 1;
+                      window.sessionStorage.setItem('activeSessionTab', tabArr[lastIndex].tabID);
+                    }
+                    //window.localStorage.setItem('selectedPhone', newData.selectedPhone);
+                    return;
+                  //}
+                 
+              }
+              /**
+               * When a tab is closed
+               */
+              if(event.key === 'CREDENTIALS_FLUSH' && credentials){
+                window.sessionStorage.removeItem('user');
+                window.sessionStorage.removeItem('selectedPhone');
+                window.sessionStorage.removeItem('isAuthenticated')
+                window.sessionStorage.removeItem('activeSession');
+              }
+              /**
+               * When any tab is closed, active call gets terminated
+               */
+              if(event.key === 'CALL_FLUSH'){
+                window.sessionStorage.removeItem('activeSession');
+              }
+          });
+};