podasync-ws-only 2.7.11 → 2.7.12-snapshot.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "podasync-ws-only",
-  "version": "2.7.11",
+  "version": "2.7.12-snapshot.0",
   "description": "Fanap's POD Async service (DIRANA) - Websocket only",
   "main": "./src/network/async.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "publish:snapshot": "npm run version:snapshot && npm publish --tag snapshot",
     "version:snapshot": "npm version prerelease --preid snapshot",
     "publish:release": "npm run version:release && npm publish",
-    "version:release": "npm version 2.7.11"
+    "version:release": "npm version 2.8.0"
   },
   "repository": {
     "type": "git",

package/src/network/async.js

@@ -13,10 +13,12 @@
          *******************************************************/
 
         var PodSocketClass,
+            WebRTCClass,
             PodUtility,
             LogLevel
         if (typeof(require) !== 'undefined' && typeof(exports) !== 'undefined') {
             PodSocketClass = require('./socket.js');
+            WebRTCClass = require('./webrtc.js');
             PodUtility = require('../utility/utility.js');
             LogLevel = require('../utility/logger.js');
         }
@@ -42,6 +44,7 @@
             },
             ackCallback = {},
             socket,
+            webRTCClass,
             asyncMessageType = {
                 PING: 0,
                 SERVER_REGISTER: 1,
@@ -90,7 +93,8 @@
                 ? params.asyncLogging.onMessageReceive
                 : false,
             onSendLogging = (params.asyncLogging && typeof params.asyncLogging.onMessageSend === 'boolean') ? params.asyncLogging.onMessageSend : false,
-            workerId = (params.asyncLogging && typeof parseInt(params.asyncLogging.workerId) === 'number') ? params.asyncLogging.workerId : 0;
+            workerId = (params.asyncLogging && typeof parseInt(params.asyncLogging.workerId) === 'number') ? params.asyncLogging.workerId : 0,
+            webrtcConfig = (params.webrtcConfig ? params.webrtcConfig : null);
 
         // function setRetryStep(val){
         //     console.log("new retryStep value:", val);
@@ -121,6 +125,9 @@
                     case 'websocket':
                         initSocket();
                         break;
+                    case 'webrtc':
+                        initWebrtc();
+                        break;
                 }
             },
 
@@ -288,6 +295,124 @@
                     });
                 });
             },
+            initWebrtc = function () {
+                webRTCClass = new WebRTCClass({
+                    baseUrl: (webrtcConfig ? webrtcConfig.baseUrl : null),
+                    configuration : (webrtcConfig ? webrtcConfig.configuration : null),
+                    connectionCheckTimeout: params.connectionCheckTimeout,
+                    logLevel: logLevel
+                });
+
+                checkIfSocketHasOpennedTimeoutId = setTimeout(function () {
+                    if (!isSocketOpen) {
+                        fireEvent('error', {
+                            errorCode: 4001,
+                            errorMessage: 'Can not open Socket!'
+                        });
+                    }
+                }, 65000);
+
+                webRTCClass.on('open', function () {
+                    checkIfSocketHasOpennedTimeoutId && clearTimeout(checkIfSocketHasOpennedTimeoutId);
+                    socketReconnectRetryInterval && clearTimeout(socketReconnectRetryInterval);
+                    socketReconnectCheck && clearTimeout(socketReconnectCheck);
+
+                    isSocketOpen = true;
+                    retryStep.set(4);
+
+                    socketState = socketStateType.OPEN;
+                    fireEvent('stateChange', {
+                        socketState: socketState,
+                        timeUntilReconnect: 0,
+                        deviceRegister: isDeviceRegister,
+                        serverRegister: isServerRegister,
+                        peerId: peerId
+                    });
+                });
+
+                webRTCClass.on('message', function (msg) {
+                    console.log({msg})
+                    handleSocketMessage(msg);
+                    if (onReceiveLogging) {
+                        asyncLogger('Receive', msg);
+                    }
+                });
+
+                webRTCClass.on('close', function (event) {
+                    isSocketOpen = false;
+                    isDeviceRegister = false;
+                    oldPeerId = peerId;
+
+                    fireEvent('disconnect', event);
+
+                    if (reconnectOnClose) {
+                        if (asyncLogging) {
+                            if (workerId > 0) {
+                                Utility.asyncStepLogger(workerId + '\t Reconnecting after ' + retryStep.get() + 's');
+                            }
+                            else {
+                                Utility.asyncStepLogger('Reconnecting after ' + retryStep.get() + 's');
+                            }
+                        }
+
+                        logLevel.debug && console.debug("[Async][async.js] on connection close, retryStep:", retryStep.get());
+
+                        socketState = socketStateType.CLOSED;
+                        fireEvent('stateChange', {
+                            socketState: socketState,
+                            timeUntilReconnect: 1000 * retryStep.get(),
+                            deviceRegister: isDeviceRegister,
+                            serverRegister: isServerRegister,
+                            peerId: peerId
+                        });
+
+                        socketReconnectRetryInterval && clearTimeout(socketReconnectRetryInterval);
+
+                        socketReconnectRetryInterval = setTimeout(function () {
+                            webRTCClass.connect();
+                        }, 1000 * retryStep.get());
+
+                        if (retryStep.get() < 64) {
+                            // retryStep += 3;
+                            retryStep.set(retryStep.get() + 3)
+                        }
+                    }
+                    else {
+                        socketReconnectRetryInterval && clearTimeout(socketReconnectRetryInterval);
+                        socketReconnectCheck && clearTimeout(socketReconnectCheck);
+                        fireEvent('error', {
+                            errorCode: 4005,
+                            errorMessage: 'Connection Closed!'
+                        });
+
+                        socketState = socketStateType.CLOSED;
+                        fireEvent('stateChange', {
+                            socketState: socketState,
+                            timeUntilReconnect: 0,
+                            deviceRegister: isDeviceRegister,
+                            serverRegister: isServerRegister,
+                            peerId: peerId
+                        });
+                    }
+
+                });
+
+                webRTCClass.on('customError', function (error) {
+                    fireEvent('error', {
+                        errorCode: error.errorCode,
+                        errorMessage: error.errorMessage,
+                        errorEvent: error.errorEvent
+                    });
+                });
+
+                webRTCClass.on('error', function (error) {
+                    fireEvent('error', {
+                        errorCode: '',
+                        errorMessage: '',
+                        errorEvent: error
+                    });
+                });
+            },
 
             handleSocketMessage = function (msg) {
                 var ack;
@@ -538,6 +663,15 @@
                         else {
                             pushSendDataQueue.push(msg);
                         }
+                        break;
+                    case 'webrtc':
+                        if (socketState === socketStateType.OPEN) {
+                            webRTCClass.emit(msg);
+                        }
+                        else {
+                            pushSendDataQueue.push(msg);
+                        }
+
                         break;
                 }
             },
@@ -558,16 +692,16 @@
 
             fireEvent = function (eventName, param, ack) {
                 // try {
-                    if (ack) {
-                        for (var id in eventCallbacks[eventName]) {
-                            eventCallbacks[eventName][id](param, ack);
-                        }
+                if (ack) {
+                    for (var id in eventCallbacks[eventName]) {
+                        eventCallbacks[eventName][id](param, ack);
                     }
-                    else {
-                        for (var id in eventCallbacks[eventName]) {
-                            eventCallbacks[eventName][id](param);
-                        }
+                }
+                else {
+                    for (var id in eventCallbacks[eventName]) {
+                        eventCallbacks[eventName][id](param);
                     }
+                }
                 // }
                 // catch (e) {
                 //     fireEvent('error', {
@@ -668,6 +802,20 @@
 
                     socketReconnectRetryInterval && clearTimeout(socketReconnectRetryInterval);
                     socket.close();
+                    break;
+                case 'webrtc':
+                    socketState = socketStateType.CLOSED;
+                    fireEvent('stateChange', {
+                        socketState: socketState,
+                        timeUntilReconnect: 0,
+                        deviceRegister: isDeviceRegister,
+                        serverRegister: isServerRegister,
+                        peerId: peerId
+                    });
+
+                    socketReconnectRetryInterval && clearTimeout(socketReconnectRetryInterval);
+                    webRTCClass.close();
+
                     break;
             }
         };
@@ -697,6 +845,20 @@
                     reconnectOnClose = false;
 
                     socket.close();
+                    break;
+                case 'webrtc':
+                    socketState = socketStateType.CLOSED;
+                    fireEvent('stateChange', {
+                        socketState: socketState,
+                        timeUntilReconnect: 0,
+                        deviceRegister: isDeviceRegister,
+                        serverRegister: isServerRegister,
+                        peerId: peerId
+                    });
+
+                    reconnectOnClose = false;
+                    webRTCClass.close();
+
                     break;
             }
         };
@@ -717,12 +879,18 @@
             });
 
             socketReconnectRetryInterval && clearTimeout(socketReconnectRetryInterval);
-            socket.close();
+            if(protocol === "websocket")
+                socket.close();
+            else if(protocol == "webrtc")
+                webRTCClass.close()
 
             socketReconnectRetryInterval = setTimeout(function () {
                 // retryStep = 4;
                 retryStep.set(4);
-                socket.connect();
+                if(protocol === "websocket")
+                    socket.close();
+                else if(protocol == "webrtc")
+                    webRTCClass.close()
             }, 2000);
         };
 

package/src/network/socket.js

@@ -17,15 +17,15 @@
      *******************************************************/
 
     var address = params.socketAddress,
-      wsConnectionWaitTime = params.wsConnectionWaitTime || 500,
-      connectionCheckTimeout = params.connectionCheckTimeout || 10000,
-      eventCallback = {},
-      socket,
-      waitForSocketToConnectTimeoutId,
-      socketRealTimeStatusInterval,
-      logLevel = params.logLevel,
-      pingController = new PingManager({waitTime: connectionCheckTimeout}),
-      socketWatchTimeout;
+        wsConnectionWaitTime = params.wsConnectionWaitTime || 500,
+        connectionCheckTimeout = params.connectionCheckTimeout || 10000,
+        eventCallback = {},
+        socket,
+        waitForSocketToConnectTimeoutId,
+        socketRealTimeStatusInterval,
+        logLevel = params.logLevel,
+        pingController = new PingManager({waitTime: connectionCheckTimeout}),
+        socketWatchTimeout;
 
 
     function PingManager(params) {
@@ -39,7 +39,7 @@
           first: null,
           second: null,
           third: null,
-          fourth: null
+          //fourth: null
         }
       }
 
@@ -51,13 +51,13 @@
         setPingTimeout() {
           config.timeoutIds.first = setTimeout(()=>{
             ping();
-            config.timeoutIds.first = setTimeout(()=>{
+            config.timeoutIds.second = setTimeout(()=>{
               ping();
-                config.timeoutIds.fourth = setTimeout(()=>{
-                  logLevel.debug && console.debug("[Async][Socket.js] Force closing socket.");
-                  onCloseHandler(null);
-                  socket.close();
-                }, 2000);
+              config.timeoutIds.third = setTimeout(()=>{
+                logLevel.debug && console.debug("[Async][Socket.js] Force closing socket.");
+                onCloseHandler(null);
+                socket.close();
+              }, 2000);
             }, 2000);
           }, 8000);
         },
@@ -65,7 +65,7 @@
           clearTimeout(config.timeoutIds.first);
           clearTimeout(config.timeoutIds.second);
           clearTimeout(config.timeoutIds.third);
-          clearTimeout(config.timeoutIds.fourth);
+          // clearTimeout(config.timeoutIds.fourth);
         },
       }
     }
@@ -75,135 +75,135 @@
      *******************************************************/
 
     var init = function() {
-        connect();
-      },
+          connect();
+        },
 
-      connect = function() {
-        try {
-          if (socket && socket.readyState == 1) {
-            return;
-          }
+        connect = function() {
+          try {
+            if (socket && socket.readyState == 1) {
+              return;
+            }
+
+            socket = new WebSocket(address, []);
+
+            // socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
+            // socketRealTimeStatusInterval = setInterval(function() {
+            //   switch (socket.readyState) {
+            //     case 2:
+            //       onCloseHandler(null);
+            //       socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
+            //       break;
+            //     case 3:
+            //
+            //       break;
+            //   }
+            // }, 5000);
+
+            /**
+             * Watches the socket to make sure it's state changes to 1 in 5 seconds
+             */
+            socketWatchTimeout && clearTimeout(socketWatchTimeout);
+            socketWatchTimeout = setTimeout(() => {
+              // if(socket.readyState !== 1) {
+              logLevel.debug && console.debug("[Async][Socket.js] socketWatchTimeout triggered.");
+              onCloseHandler(null);
+              socket.close();
+              // }
+            }, 5000);
+
+            socket.onopen = function(event) {
+              waitForSocketToConnect(function() {
+                pingController.resetPingLoop();
+                eventCallback["open"]();
+                socketWatchTimeout && clearTimeout(socketWatchTimeout);
+              });
+            }
 
-          socket = new WebSocket(address, []);
-
-          // socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
-          // socketRealTimeStatusInterval = setInterval(function() {
-          //   switch (socket.readyState) {
-          //     case 2:
-          //       onCloseHandler(null);
-          //       socketRealTimeStatusInterval && clearInterval(socketRealTimeStatusInterval);
-          //       break;
-          //     case 3:
-          //
-          //       break;
-          //   }
-          // }, 5000);
-
-          /**
-           * Watches the socket to make sure it's state changes to 1 in 5 seconds
-           */
-          socketWatchTimeout && clearTimeout(socketWatchTimeout);
-          socketWatchTimeout = setTimeout(() => {
-            // if(socket.readyState !== 1) {
-            logLevel.debug && console.debug("[Async][Socket.js] socketWatchTimeout triggered.");
-            onCloseHandler(null);
-            socket.close();
-            // }
-          }, 5000);
-
-          socket.onopen = function(event) {
-            waitForSocketToConnect(function() {
+            socket.onmessage = function(event) {
               pingController.resetPingLoop();
-              eventCallback["open"]();
+
+              var messageData = JSON.parse(event.data);
+              eventCallback["message"](messageData);
+            }
+
+            socket.onclose = function(event) {
+              pingController.stopPingLoop();
+              logLevel.debug && console.debug("[Async][Socket.js] socket.onclose happened. EventData:", event);
+              onCloseHandler(event);
+              socketWatchTimeout && clearTimeout(socketWatchTimeout);
+            }
+
+            socket.onerror = function(event) {
+              logLevel.debug && console.debug("[Async][Socket.js] socket.onerror happened. EventData:", event);
+              eventCallback["error"](event);
               socketWatchTimeout && clearTimeout(socketWatchTimeout);
+            }
+          } catch (error) {
+            eventCallback["customError"]({
+              errorCode: 4000,
+              errorMessage: "ERROR in WEBSOCKET!",
+              errorEvent: error
             });
           }
+        },
 
-          socket.onmessage = function(event) {
-            pingController.resetPingLoop();
+        onCloseHandler = function(event) {
+          pingController.stopPingLoop();
+          socket.onclose = null;
+          socket.onmessage = null;
+          socket.onerror = null;
+          socket.onopen = null;
+          eventCallback["close"](event);
+        },
 
-            var messageData = JSON.parse(event.data);
-            eventCallback["message"](messageData);
-          }
+        ping = function() {
+          sendData({
+            type: 0
+          });
+        },
 
-          socket.onclose = function(event) {
-            pingController.stopPingLoop();
-            logLevel.debug && console.debug("[Async][Socket.js] socket.onclose happened. EventData:", event);
-            onCloseHandler(event);
-            socketWatchTimeout && clearTimeout(socketWatchTimeout);
-          }
+        waitForSocketToConnect = function(callback) {
+          waitForSocketToConnectTimeoutId && clearTimeout(waitForSocketToConnectTimeoutId);
 
-          socket.onerror = function(event) {
-            logLevel.debug && console.debug("[Async][Socket.js] socket.onerror happened. EventData:", event);
-            eventCallback["error"](event);
-            socketWatchTimeout && clearTimeout(socketWatchTimeout);
+          if (socket.readyState === 1) {
+            callback();
+          } else {
+            waitForSocketToConnectTimeoutId = setTimeout(function() {
+              if (socket.readyState === 1) {
+                callback();
+              } else {
+                waitForSocketToConnect(callback);
+              }
+            }, wsConnectionWaitTime);
           }
-        } catch (error) {
-          eventCallback["customError"]({
-            errorCode: 4000,
-            errorMessage: "ERROR in WEBSOCKET!",
-            errorEvent: error
-          });
-        }
-      },
-
-      onCloseHandler = function(event) {
-        pingController.stopPingLoop();
-        socket.onclose = null;
-        socket.onmessage = null;
-        socket.onerror = null;
-        socket.onopen = null;
-        eventCallback["close"](event);
-      },
-
-      ping = function() {
-        sendData({
-          type: 0
-        });
-      },
-
-      waitForSocketToConnect = function(callback) {
-        waitForSocketToConnectTimeoutId && clearTimeout(waitForSocketToConnectTimeoutId);
-
-        if (socket.readyState === 1) {
-          callback();
-        } else {
-          waitForSocketToConnectTimeoutId = setTimeout(function() {
-            if (socket.readyState === 1) {
-              callback();
-            } else {
-              waitForSocketToConnect(callback);
-            }
-          }, wsConnectionWaitTime);
-        }
-      },
-
-      sendData = function(params) {
-        var data = {
-          type: params.type,
-          uniqueId: params.uniqueId
-        };
+        },
 
-        if (params.trackerId) {
-          data.trackerId = params.trackerId;
-        }
+        sendData = function(params) {
+          var data = {
+            type: params.type,
+            uniqueId: params.uniqueId
+          };
 
-        try {
-          if (params.content) {
-            data.content = JSON.stringify(params.content);
+          if (params.trackerId) {
+            data.trackerId = params.trackerId;
           }
 
-          if (socket.readyState === 1) {
-            socket.send(JSON.stringify(data));
+          try {
+            if (params.content) {
+              data.content = JSON.stringify(params.content);
+            }
+
+            if (socket.readyState === 1) {
+              socket.send(JSON.stringify(data));
+            }
+          } catch (error) {
+            eventCallback["customError"]({
+              errorCode: 4004,
+              errorMessage: "Error in Socket sendData!",
+              errorEvent: error
+            });
           }
-        } catch (error) {
-          eventCallback["customError"]({
-            errorCode: 4004,
-            errorMessage: "Error in Socket sendData!",
-            errorEvent: error
-          });
-        }
-      };
+        };
 
     /*******************************************************
      *             P U B L I C   M E T H O D S             *

package/src/network/webrtc.js

@@ -0,0 +1,459 @@
+let defaultConfig = {
+        baseUrl: "http://109.201.0.97/webrtc/",
+        registerEndpoint: "register/",
+        addICEEndpoint: "add-ice/",
+        getICEEndpoint: "get-ice/?",
+        configuration: {
+            bundlePolicy: "balanced",
+            iceTransportPolicy: "relay",
+            iceServers: [{
+                "urls": "turn:turnsandbox.podstream.ir:3478", "username": "mkhorrami", "credential": "mkh_123456"
+            }]
+        },
+        connectionCheckTimeout: 10000,
+        logLevel: null
+    },
+    variables = {
+        peerConnection: null,
+        dataChannel: null,
+        pingController: new PingManager({waitTime: defaultConfig.connectionCheckTimeout}),
+        candidatesQueue: [],
+        // candidatesSendQueue: [],
+        candidateManager: new CandidatesSendQueueManager(),
+        clientId: null,
+        deviceId: null,
+        apiCallRetries: {
+            register: 3,
+            getIce: 3,
+            addIce: 5
+        }
+    };
+
+function CandidatesSendQueueManager() {
+    let config = {
+        candidatesToSend: [],
+        alreadyReceivedServerCandidates: false,
+        reCheckTimeout: null
+    }
+
+    function trySendingCandidates() {
+        timoutCallback();
+        function timoutCallback() {
+            if(variables.peerConnection.signalingState === 'stable') {
+                config.reCheckTimeout && clearTimeout(config.reCheckTimeout);
+                if (config.candidatesToSend.length) {
+                    let entry = config.candidatesToSend.shift();
+                    handshakingFunctions
+                        .sendCandidate(entry)
+                        .then(function (result) {
+                            if (result.length) {
+                                addServerCandidates(result);
+
+                                config.alreadyReceivedServerCandidates = true;
+                            }
+                            trySendingCandidates();
+                        });
+
+                } else if (!config.alreadyReceivedServerCandidates) {
+                    handshakingFunctions.getCandidates(variables.clientId).then(function (result) {
+                        addServerCandidates(result)
+                    }).catch();
+                }
+            } else {
+                config.reCheckTimeout && clearTimeout(config.reCheckTimeout);
+                config.reCheckTimeout = setTimeout(timoutCallback, 1000);
+            }
+        }
+    }
+
+    function addServerCandidates(candidates) {
+        for(let i in candidates) {
+            webrtcFunctions.putCandidateToQueue(candidates[i]);
+        }
+    }
+
+    return {
+        add: function (candidate) {
+            config.candidatesToSend.push(candidate);
+            trySendingCandidates();
+        },
+        destroy: function (){
+            config.reCheckTimeout && clearTimeout(config.reCheckTimeout);
+        }
+    }
+}
+
+function PingManager(params) {
+    const config = {
+        normalWaitTime: params.waitTime,
+
+        lastRequestTimeoutId: null,
+        lastReceivedMessageTime: 0,
+        totalNoMessageCount: 0,
+        timeoutIds: {
+            first: null,
+            second: null,
+            third: null,
+            fourth: null
+        }
+    }
+
+    return {
+        resetPingLoop() {
+            this.stopPingLoop();
+            this.setPingTimeout();
+        },
+        setPingTimeout() {
+            config.timeoutIds.first = setTimeout(() => {
+                ping();
+                config.timeoutIds.second = setTimeout(() => {
+                    ping();
+                    config.timeoutIds.third = setTimeout(() => {
+                        defaultConfig.logLevel.debug && console.debug("[Async][Webrtc.js] Force closing connection.");
+                        publicized.close();
+                    }, 2000);
+                }, 2000);
+            }, 8000);
+        },
+        stopPingLoop() {
+            clearTimeout(config.timeoutIds.first);
+            clearTimeout(config.timeoutIds.second);
+            clearTimeout(config.timeoutIds.third);
+            // clearTimeout(config.timeoutIds.fourth);
+        },
+    }
+}
+
+function connect() {
+    webrtcFunctions.createPeerConnection();
+    webrtcFunctions.createDataChannel();
+    webrtcFunctions.generateSdpOffer()
+        .then(sendOfferToServer);
+
+    function sendOfferToServer(offer) {
+        handshakingFunctions
+            .register(offer.sdp)
+            .then(processRegisterResult).catch();
+
+        variables
+            .peerConnection.setLocalDescription(offer)
+            .catch(error => console.error(error));
+    }
+
+    function processRegisterResult(result) {
+        variables.clientId = result.clientId;
+        variables.deviceId = result.deviceId;
+        webrtcFunctions.processAnswer(result.sdpAnswer);
+    }
+}
+
+let webrtcFunctions = {
+    createPeerConnection: function () {
+        variables.peerConnection = new RTCPeerConnection(defaultConfig.configuration);
+        variables.peerConnection.addEventListener('signalingstatechange', webrtcFunctions.signalingStateChangeCallback);
+        variables.peerConnection.onicecandidate = function (event) {
+            if (event.candidate) {
+                variables.candidateManager.add(event.candidate);
+                webrtcFunctions.putCandidateToQueue(event.candidate);
+            }
+        };
+    },
+    signalingStateChangeCallback: function () {
+        if (variables.peerConnection.signalingState === 'stable') {
+            // handshakingFunctions.getCandidates().catch()
+            webrtcFunctions.addTheCandidates();
+        }
+    },
+    createDataChannel: function () {
+        variables.dataChannel = variables.peerConnection.createDataChannel("dataChannel", {ordered: false});
+        variables.dataChannel.onopen = dataChannelCallbacks.onopen;
+        variables.dataChannel.onmessage = dataChannelCallbacks.onmessage;
+        variables.dataChannel.onerror = dataChannelCallbacks.onerror;
+        variables.dataChannel.onclose = dataChannelCallbacks.onclose;
+    },
+    generateSdpOffer: function () {
+        return new Promise(function (resolve, reject) {
+            variables.peerConnection.createOffer(function (offer) {
+                resolve(offer)
+            }, function (error) {
+                reject(error);
+                console.error(error);
+            }).then(r => console.log(r));
+        })
+    },
+    processAnswer: function (answer) {
+        let remoteDesc = {
+            type: "answer", sdp: answer
+        };
+        variables
+            .peerConnection
+            .setRemoteDescription(new RTCSessionDescription(remoteDesc))
+            .catch(function (error) {
+                console.error(error)
+            });
+    },
+    addTheCandidates: function () {
+        while (variables.candidatesQueue.length) {
+            let entry = variables.candidatesQueue.shift();
+            variables.peerConnection.addIceCandidate(entry.candidate);
+        }
+    },
+    putCandidateToQueue: function (candidate) {
+        variables.candidatesQueue.push({
+            candidate: new RTCIceCandidate(candidate)
+        });
+        if (variables.peerConnection.signalingState === 'stable') {
+            webrtcFunctions.addTheCandidates();
+        }
+    },
+    sendData: function(params) {
+        if(!variables.dataChannel) {
+            console.error("Connection is closed, do not send messages.")
+            return;
+        }
+        var data = {
+            type: params.type,
+            uniqueId: params.uniqueId
+        };
+
+        if (params.trackerId) {
+            data.trackerId = params.trackerId;
+        }
+
+        try {
+            if (params.content) {
+                data.content = JSON.stringify(params.content);
+            }
+
+            if (variables.peerConnection.signalingState === 'stable') {
+                //defaultConfig.logLevel.debug &&
+                console.log("[Async][WebRTC] Send ", data);
+                variables.dataChannel.send(JSON.stringify(data));
+            }
+        } catch (error) {
+            eventCallback["customError"]({
+                errorCode: 4004,
+                errorMessage: "Error in Socket sendData!",
+                errorEvent: error
+            });
+        }
+    }
+}
+
+let dataChannelCallbacks = {
+    onopen: function (event) {
+        console.log("********* dataChannel open *********");
+        variables.pingController.resetPingLoop();
+        eventCallback["open"]();
+
+        const deviceRegister = {
+            "type": "2",
+            "content": {"deviceId": variables.deviceId, "appId": "PodChat", "refresh": false, "renew": true}
+        };
+        deviceRegister.content = JSON.stringify(deviceRegister.content)
+        variables.dataChannel.send(JSON.stringify(deviceRegister));
+    },
+
+    onmessage: function (event) {
+
+        variables.pingController.resetPingLoop();
+        var messageData = JSON.parse(event.data);
+        console.log("[Async][WebRTC] Receive ", event.data);
+        eventCallback["message"](messageData);
+    },
+
+    onerror: function (error) {
+        logLevel.debug && console.debug("[Async][Socket.js] dataChannel.onerror happened. EventData:", event);
+        eventCallback["error"](event);
+    },
+    onclose: function (event) {
+        resetVariables();
+        eventCallback["close"](event);
+    }
+}
+
+let handshakingFunctions = {
+    register: function (offer) {
+        let retries = variables.apiCallRetries.register;
+        return new Promise(promiseHandler);
+        function promiseHandler(resolve, reject) {
+            let registerEndPoint = defaultConfig.baseUrl + defaultConfig.registerEndpoint
+            fetch(registerEndPoint, {
+                method: "POST",
+                body: JSON.stringify({
+                    offer: offer
+                })
+            })
+                .then(function (response) {
+                    if(response.ok)
+                        return response.json();
+                    else if(retries){
+                        retryTheRequest(resolve, reject);
+                        retries--;
+                    } else reject();
+                })
+                .then(result => resolve(result))
+                .catch(err => {
+                    if(retries){
+                        retryTheRequest(resolve, reject);
+                        retries--;
+                    } else {
+                        publicized.close();
+                    }
+                    console.error(err);
+                });
+        }
+        function retryTheRequest(resolve, reject){
+            setTimeout(function (){promiseHandler(resolve, reject)}, 1000);
+        }
+    },
+    getCandidates: function (clientId) {
+        let addIceCandidateEndPoint = defaultConfig.baseUrl + defaultConfig.getICEEndpoint
+        addIceCandidateEndPoint += "clientId=" + clientId;
+
+        let retries = variables.apiCallRetries.getIce;
+        return new Promise(promiseHandler);
+        function promiseHandler(resolve, reject) {
+            fetch(addIceCandidateEndPoint, {
+                method: "GET"
+            })
+                .then(function (response) {
+                    if(response.ok)
+                        return response.json();
+                    else if(retries){
+                        retryTheRequest(resolve, reject);
+                        retries--;
+                    } else reject();
+                })
+                .then(function (result) {
+                    resolve(result.iceCandidates)
+                    // if(result.iceCandidates && result.iceCandidates.length) {
+                    //     // result.iceCandidates.forEach((item) => {
+                    //     //     webrtcFunctions.putCandidateToQueue(item);
+                    //     // });
+                    //     resolve(result.iceCandidates)
+                    // }
+                    // else {
+                    //     if(retries){
+                    //         retryTheRequest(resolve, reject);
+                    //         retries--;
+                    //     } else reject();
+                    // }
+                })
+                .catch(function (err) {
+                    if(retries){
+                        retryTheRequest(resolve, reject);
+                        retries--;
+                    } else reject(err);
+                    console.error(err);
+                });
+        }
+
+        function retryTheRequest(resolve, reject){
+            setTimeout(function (){promiseHandler(resolve, reject)}, 1000);
+        }
+
+    },
+    sendCandidate: function (candidate) {
+        let addIceCandidateEndPoint = defaultConfig.baseUrl + defaultConfig.addICEEndpoint
+            , retries = variables.apiCallRetries.addIce;
+
+        return new Promise(promiseHandler);
+        function promiseHandler(resolve, reject) {
+            fetch(addIceCandidateEndPoint, {
+                method: "POST",
+                body: JSON.stringify({
+                    "clientId": variables.clientId,
+                    "candidate": candidate
+                })
+            })
+                .then(function (response) {
+                    if(response.ok)
+                        return response.json();
+                    else if(retries){
+                        retryTheRequest(resolve, reject);
+                        retries--;
+                    } else reject();
+                })
+                .then(function (result) {
+                    resolve(result.iceCandidates);
+                })
+                .catch(err => {
+                    if(retries){
+                        retryTheRequest(resolve, reject);
+                        retries--;
+                    } else reject(err);
+                    console.error(err);
+                });
+        }
+
+        function retryTheRequest(resolve, reject){
+            setTimeout(function (){promiseHandler(resolve, reject)}, 2000);
+        }
+    }
+}
+
+eventCallback = {};
+
+function resetVariables() {
+    console.log("resetVariables");
+    eventCallback["close"]();
+    variables.pingController.stopPingLoop();
+    variables.dataChannel.close();
+    variables.dataChannel = null;
+    variables.peerConnection.close();
+    variables.peerConnection = null;
+    variables.candidatesQueue = [];
+    variables.clientId = null;
+    variables.deviceId = null;
+    variables.candidateManager.destroy();
+    variables.candidateManager = new CandidatesSendQueueManager()
+}
+
+function ping() {
+    webrtcFunctions.sendData({
+        type: 0
+    });
+}
+function removeCallbacks(){
+    variables.peerConnection.onicecandidate = null;
+    variables.dataChannel.onclose = null;
+    variables.dataChannel.onmessage = null;
+    variables.dataChannel.onerror = null;
+    variables.dataChannel.onopen = null;
+}
+
+function WebRTCClass({
+    baseUrl,
+    configuration,
+    connectionCheckTimeout = 10000,
+    logLevel
+}) {
+    let config = {}
+    if (baseUrl)
+        config.baseUrl = baseUrl;
+    if (configuration)
+        config.configuration = configuration;
+    if (connectionCheckTimeout)
+        config.connectionCheckTimeout = connectionCheckTimeout;
+    if (logLevel)
+        config.logLevel = logLevel;
+
+    defaultConfig = Object.assign(defaultConfig, config);
+    connect();
+    return publicized;
+}
+
+let publicized = {
+    on: function (messageName, callback) {
+        eventCallback[messageName] = callback;
+    },
+    emit: webrtcFunctions.sendData,
+    connect: connect,
+    close: function () {
+        removeCallbacks();
+        resetVariables();
+    }
+};
+
+module.exports = WebRTCClass;