@techsee/techsee-media-service 999.0.2-switch → 999.0.3-alpha2

package/lib/oldCode/webrtc/session-turn.v2.js

@@ -1,583 +1,592 @@
-'use strict';
+"use strict";
 
-exports.__esModule = true;
-exports.TurnWebRtcSessionV2 = undefined;
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TurnWebRtcSessionV2 = void 0;
 
-var _session = require('../session');
+var _session = require("../session");
 
-var _socket = require('socket.io-client');
+var io = _interopRequireWildcard(require("socket.io-client"));
 
-var io = _interopRequireWildcard(_socket);
+var _constants = require("./constants");
 
-var _constants = require('./constants');
+var _stream = require("./stream");
 
-var _stream = require('./stream');
+var _tracer = require("../tracer");
 
-var _tracer = require('../tracer');
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-var tracer = (0, _tracer.getTracer)();
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
-//Currently this version supports subscribing only. Publishing will be implemented as needed.
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
-var TurnWebRtcSessionV2 = exports.TurnWebRtcSessionV2 = function (_TsMediaSession) {
-    _inherits(TurnWebRtcSessionV2, _TsMediaSession);
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-    _createClass(TurnWebRtcSessionV2, [{
-        key: 'id',
-        get: function get() {
-            return this._credentials.sessionId;
-        }
-    }]);
-
-    function TurnWebRtcSessionV2(_ref) {
-        var credentials = _ref.credentials,
-            constraints = _ref.constraints,
-            clientType = _ref.clientType,
-            streamFactory = _ref.streamFactory;
-
-        _classCallCheck(this, TurnWebRtcSessionV2);
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
 
-        var _this = _possibleConstructorReturn(this, _TsMediaSession.call(this));
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-        _this._socket = null;
-        _this._localPeer = null;
-        _this._pendingPeersIce = {};
-        _this._peerConnections = new Map();
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-        _this._credentials = credentials;
-        _this._constraints = constraints;
-        _this._selfClientType = clientType;
-        _this._localStreamFactory = streamFactory;
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
-        _this._connectPromise = null;
-
-        var iceServers = credentials.ice.map(function (item) {
-            return {
-                urls: item.url,
-                username: item.login,
-                credential: item.password
-            };
-        });
+var tracer = (0, _tracer.getTracer)(); //Currently this version supports subscribing only. Publishing will be implemented as needed.
 
-        _this._configuration = {
-            iceServers: iceServers,
-            iceTransportPolicy: 'relay'
-        };
+var TurnWebRtcSessionV2 = /*#__PURE__*/function (_TsMediaSession) {
+  _inherits(TurnWebRtcSessionV2, _TsMediaSession);
 
-        _this._joinResponseHandler = _this._joinResponseHandler.bind(_this);
-        _this._iceCandidateReceivedHandler = _this._iceCandidateReceivedHandler.bind(_this);
-        _this._sendOfferHandler = _this._sendOfferHandler.bind(_this);
-        _this._sdpOfferHandler = _this._sdpOfferHandler.bind(_this);
-        _this._initiatorReconnectHandler = _this._initiatorReconnectHandler.bind(_this);
-        _this._peerDisconnectedHandler = _this._peerDisconnectedHandler.bind(_this);
+  var _super = _createSuper(TurnWebRtcSessionV2);
 
-        _this._extendPeerConnection();
-        return _this;
-    }
+  function TurnWebRtcSessionV2(_ref) {
+    var _this;
 
-    //#region Socket Connectivity
+    var credentials = _ref.credentials,
+        constraints = _ref.constraints,
+        clientType = _ref.clientType,
+        streamFactory = _ref.streamFactory;
 
-    TurnWebRtcSessionV2.prototype.connect = function connect() {
-        var _this2 = this;
+    _classCallCheck(this, TurnWebRtcSessionV2);
 
-        var connectOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    _this = _super.call(this);
+    _this._socket = null;
+    _this._localPeer = null;
+    _this._pendingPeersIce = {};
+    _this._peerConnections = new Map();
+    _this._credentials = credentials;
+    _this._constraints = constraints;
+    _this._selfClientType = clientType;
+    _this._localStreamFactory = streamFactory;
+    _this._connectPromise = null;
+    var iceServers = credentials.ice.map(function (item) {
+      return {
+        urls: item.url,
+        username: item.login,
+        credential: item.password
+      };
+    });
+    _this._configuration = {
+      iceServers: iceServers,
+      iceTransportPolicy: 'relay'
+    };
+    _this._joinResponseHandler = _this._joinResponseHandler.bind(_assertThisInitialized(_this));
+    _this._iceCandidateReceivedHandler = _this._iceCandidateReceivedHandler.bind(_assertThisInitialized(_this));
+    _this._sendOfferHandler = _this._sendOfferHandler.bind(_assertThisInitialized(_this));
+    _this._sdpOfferHandler = _this._sdpOfferHandler.bind(_assertThisInitialized(_this));
+    _this._initiatorReconnectHandler = _this._initiatorReconnectHandler.bind(_assertThisInitialized(_this));
+    _this._peerDisconnectedHandler = _this._peerDisconnectedHandler.bind(_assertThisInitialized(_this));
 
-        if (this._connectPromise) {
-            tracer.trace('already connecting');
-            return this._connectPromise;
-        }
+    _this._extendPeerConnection();
 
-        tracer.trace('connect');
+    return _this;
+  } //#region Socket Connectivity
 
-        this._connectPromise = this._connectSocket(this._credentials.url, connectOnly).then(function () {
-            tracer.trace('Joining SessionId: ' + _this2._credentials.sessionId);
 
-            _this2._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.JOIN_ROOM, {
-                clientType: _this2._selfClientType,
-                sessionId: _this2._credentials.sessionId
-            });
+  _createClass(TurnWebRtcSessionV2, [{
+    key: "id",
+    get: function get() {
+      return this._credentials.sessionId;
+    }
+  }, {
+    key: "connect",
+    value: function connect() {
+      var _this2 = this;
 
-            _this2._connectPromise = null;
-        }).catch(function (error) {
-            setTimeout(function () {
-                return _this2._connectPromise = null;
-            });
-            _this2.emit(_session.SESSION_EVENTS.EXCEPTION, { source: 'connect', error: error });
-            throw error;
-        });
+      var connectOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
 
+      if (this._connectPromise) {
+        tracer.trace('already connecting');
         return this._connectPromise;
-    };
-
-    TurnWebRtcSessionV2.prototype.disconnect = function disconnect() {
-        var _this3 = this;
+      }
 
-        tracer.trace('Disconnecting from media session');
+      tracer.trace('connect');
+      this._connectPromise = this._connectSocket(this._credentials.url, connectOnly).then(function () {
+        tracer.trace('Joining SessionId: ' + _this2._credentials.sessionId);
 
-        this._peerConnections.forEach(function (peerConnection) {
-            _this3._destroyPeerConnection(peerConnection);
+        _this2._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.JOIN_ROOM, {
+          clientType: _this2._selfClientType,
+          sessionId: _this2._credentials.sessionId
         });
 
-        this._socket.off();
-        this._socket.disconnect();
+        _this2._connectPromise = null;
+      })["catch"](function (error) {
+        setTimeout(function () {
+          return _this2._connectPromise = null;
+        });
 
-        this.emit(_session.SESSION_EVENTS.DISCONNECTED, { reason: 'disconnected' });
-    };
+        _this2.emit(_session.SESSION_EVENTS.EXCEPTION, {
+          source: 'connect',
+          error: error
+        });
 
-    TurnWebRtcSessionV2.prototype._connectSocket = function _connectSocket(url, connectOnly) {
-        var _this4 = this;
+        throw error;
+      });
+      return this._connectPromise;
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      var _this3 = this;
 
-        return new Promise(function (resolve, reject) {
-            var socket = _this4._socket = io.connect(url, {
-                'forceNew': true,
-                'reconnectionDelay': _constants.SOCKET_RECONNECTION_DELAY,
-                'reconnectionDelayMax': _constants.SOCKET_RECONNECTION_DELAY_MAX,
-                'reconnectionAttempts': _constants.SOCKET_RECONNECTION_ATTEMPTS,
-                'path': _constants.SOCKET_PATH
-            });
+      tracer.trace('Disconnecting from media session');
 
-            var done = _.once(function (err) {
-                err ? reject(err) : resolve();
-            });
+      this._peerConnections.forEach(function (peerConnection) {
+        _this3._destroyPeerConnection(peerConnection);
+      });
 
-            socket.once('connect', function () {
-                return done();
-            });
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.ERROR, done);
-            socket.on('connect_error', done);
-            socket.on('connect_timeout', done);
+      this._socket.off();
 
-            socket.on('reconnect_attempt', function (args) {
-                tracer.trace('Session Socket reconnect_attempt', args);
-            });
+      this._socket.disconnect();
 
-            socket.on('reconnecting', function (args) {
-                tracer.trace('Session Socket reconnecting', args);
-            });
+      this.emit(_session.SESSION_EVENTS.DISCONNECTED, {
+        reason: 'disconnected'
+      });
+    }
+  }, {
+    key: "_connectSocket",
+    value: function _connectSocket(url, connectOnly) {
+      var _this4 = this;
+
+      return new Promise(function (resolve, reject) {
+        var socket = _this4._socket = io.connect(url, {
+          'forceNew': true,
+          'reconnectionDelay': _constants.SOCKET_RECONNECTION_DELAY,
+          'reconnectionDelayMax': _constants.SOCKET_RECONNECTION_DELAY_MAX,
+          'reconnectionAttempts': _constants.SOCKET_RECONNECTION_ATTEMPTS,
+          'path': _constants.SOCKET_PATH
+        });
 
-            socket.on('disconnect', function (reason) {
-                tracer.trace('Session Socket disconnected, reason:', reason);
-                // The initial example of differentiating between "forced" disconnect and "network" disconnect is taken from:
-                // https://socket.io/docs/client-api/#Event-%E2%80%98disconnect%E2%80%99
-                //if (reason !== 'io server disconnect' && reason !== 'io client disconnect') {
-                // the disconnection was initiated by the server or by client, you need to call (connect) manually
-                _this4.disconnect();
-                //}
-            });
+        var done = _.once(function (err) {
+          err ? reject(err) : resolve();
+        });
 
-            if (!connectOnly) {
-                //PUBLISHING NOT SUPPORTED YET
-                //socket.on(SOCKET_EVENTS.INCOMING.SEND_OFFER, this._sendOfferHandler);
-                //socket.on(SOCKET_EVENTS.INCOMING.JOIN_RESPONSE, this._joinResponseHandler);
-                //socket.on(SOCKET_EVENTS.INCOMING.PEER_DISCONNECTED, this._peerDisconnectedHandler);
+        socket.once('connect', function () {
+          return done();
+        });
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.ERROR, done);
+        socket.on('connect_error', done);
+        socket.on('connect_timeout', done);
+        socket.on('reconnect_attempt', function (args) {
+          tracer.trace('Session Socket reconnect_attempt', args);
+        });
+        socket.on('reconnecting', function (args) {
+          tracer.trace('Session Socket reconnecting', args);
+        });
+        socket.on('disconnect', function (reason) {
+          tracer.trace('Session Socket disconnected, reason:', reason); // The initial example of differentiating between "forced" disconnect and "network" disconnect is taken from:
+          // https://socket.io/docs/client-api/#Event-%E2%80%98disconnect%E2%80%99
+          //if (reason !== 'io server disconnect' && reason !== 'io client disconnect') {
+          // the disconnection was initiated by the server or by client, you need to call (connect) manually
 
-                socket.on(_constants.SOCKET_EVENTS.INCOMING.SDP_OFFER, _this4._sdpOfferHandler);
-                socket.on(_constants.SOCKET_EVENTS.INCOMING.PUBLISHER_RECONNECT, _this4._initiatorReconnectHandler);
+          _this4.disconnect(); //}
 
-                socket.on(_constants.SOCKET_EVENTS.INCOMING.ICE_CANDIDATE, _this4._iceCandidateReceivedHandler);
-            }
         });
-    };
-
-    //#endregion
 
+        if (!connectOnly) {
+          //PUBLISHING NOT SUPPORTED YET
+          //socket.on(SOCKET_EVENTS.INCOMING.SEND_OFFER, this._sendOfferHandler);
+          //socket.on(SOCKET_EVENTS.INCOMING.JOIN_RESPONSE, this._joinResponseHandler);
+          //socket.on(SOCKET_EVENTS.INCOMING.PEER_DISCONNECTED, this._peerDisconnectedHandler);
+          socket.on(_constants.SOCKET_EVENTS.INCOMING.SDP_OFFER, _this4._sdpOfferHandler);
+          socket.on(_constants.SOCKET_EVENTS.INCOMING.PUBLISHER_RECONNECT, _this4._initiatorReconnectHandler);
+          socket.on(_constants.SOCKET_EVENTS.INCOMING.ICE_CANDIDATE, _this4._iceCandidateReceivedHandler);
+        }
+      });
+    } //#endregion
     //#region WebRTC Initiator - session Initiator (User on mobile device)
-
     // Received by Initiator, causing him to emit SDP_OFFER
 
-
-    TurnWebRtcSessionV2.prototype._sendOfferHandler = function _sendOfferHandler(_ref2) {
-        var _this5 = this;
-
-        var uid = _ref2.uid,
-            peerId = _ref2.peerId;
-
-        tracer.trace('_sendOfferHandler');
-
-        var peerConnection = this._createPeerConnection(peerId, _constants.CLIENT_TYPES.GUEST);
-        var offerParams = { offerToReceiveAudio: true, offerToReceiveVideo: true };
-
-        this._localStreamFactory(this._constraints).then(function (localStream) {
-            tracer.trace('_sendOfferHandler stream and peer created');
-
-            var peerConnectionStream = new _stream.TsWebRTCStream(_this5, localStream.clone(), _constants.DEFAULT_STREAM_NAMES.MOBILE_CLIENT_VIDEO_STREAM, false);
-
-            peerConnectionStream.peerConnection = peerConnection;
-
-            localStream.getTracks().forEach(function (track) {
-                tracer.trace('Adding local tracks to peer connection');
-                peerConnection.addTrack(track, peerConnectionStream._mediaStream);
-            });
-
-            _this5.registerStream(peerConnectionStream.id, peerConnectionStream);
-        }).then(function () {
-            return peerConnection.createOffer(offerParams);
-        }).then(function (offerDesc) {
-            tracer.trace('Initiator has created sdp offer', { offerDesc: offerDesc });
-
-            _this5._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_OFFER, {
-                uid: uid,
-                peerId: peerId,
-                sessionId: _this5._credentials.sessionId,
-                sdpOffer: offerDesc.sdp
-            });
-
-            return peerConnection.setLocalDescription(offerDesc).then(function () {
-                tracer.trace('Local description was set on');
-            });
-        }).catch(function (e) {
-            tracer.trace('Error', e);
+  }, {
+    key: "_sendOfferHandler",
+    value: function _sendOfferHandler(_ref2) {
+      var _this5 = this;
+
+      var uid = _ref2.uid,
+          peerId = _ref2.peerId;
+      tracer.trace('_sendOfferHandler');
+
+      var peerConnection = this._createPeerConnection(peerId, _constants.CLIENT_TYPES.GUEST);
+
+      var offerParams = {
+        offerToReceiveAudio: true,
+        offerToReceiveVideo: true
+      };
+
+      this._localStreamFactory(this._constraints).then(function (localStream) {
+        tracer.trace('_sendOfferHandler stream and peer created');
+        var peerConnectionStream = new _stream.TsWebRTCStream(_this5, localStream.clone(), _constants.DEFAULT_STREAM_NAMES.MOBILE_CLIENT_VIDEO_STREAM, false);
+        peerConnectionStream.peerConnection = peerConnection;
+        localStream.getTracks().forEach(function (track) {
+          tracer.trace('Adding local tracks to peer connection');
+          peerConnection.addTrack(track, peerConnectionStream._mediaStream);
         });
-    };
-
-    // Received by the Initiator: Indicates that publish should be started
-
-
-    TurnWebRtcSessionV2.prototype._joinResponseHandler = function _joinResponseHandler(_ref3) {
-        var _this6 = this;
-
-        var sdpAnswer = _ref3.sdpAnswer,
-            uid = _ref3.uid,
-            peerId = _ref3.peerId;
-
-        tracer.trace('joinResponse Received', sdpAnswer);
-
-        this._withPeerConnection(peerId, function (peerConnection) {
-            var answer = new RTCSessionDescription({
-                type: 'answer',
-                sdp: sdpAnswer
-            });
 
-            peerConnection.setRemoteDescription(answer).then(function () {
-                tracer.trace('Remote description was set', answer);
-
-                _this6._processQueuedIceCandidates(peerId);
-            }).catch(function (e) {
-                tracer.trace('Error', e);
-            });
+        _this5.registerStream(peerConnectionStream.id, peerConnectionStream);
+      }).then(function () {
+        return peerConnection.createOffer(offerParams);
+      }).then(function (offerDesc) {
+        tracer.trace('Initiator has created sdp offer', {
+          offerDesc: offerDesc
         });
-    };
-
-    // Received by Initiator after a guests socket has been disconnected
-
 
-    TurnWebRtcSessionV2.prototype._peerDisconnectedHandler = function _peerDisconnectedHandler(_ref4) {
-        var peerId = _ref4.peerId;
-
-        tracer.trace('_peerDisconnectedHandler');
-    };
+        _this5._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_OFFER, {
+          uid: uid,
+          peerId: peerId,
+          sessionId: _this5._credentials.sessionId,
+          sdpOffer: offerDesc.sdp
+        });
 
-    //#endregion WebRTC Initiator - session Initiator (User on mobile device)
+        return peerConnection.setLocalDescription(offerDesc).then(function () {
+          tracer.trace('Local description was set on');
+        });
+      })["catch"](function (e) {
+        tracer.trace('Error', e);
+      });
+    } // Received by the Initiator: Indicates that publish should be started
+
+  }, {
+    key: "_joinResponseHandler",
+    value: function _joinResponseHandler(_ref3) {
+      var _this6 = this;
+
+      var sdpAnswer = _ref3.sdpAnswer,
+          uid = _ref3.uid,
+          peerId = _ref3.peerId;
+      tracer.trace('joinResponse Received', sdpAnswer);
+
+      this._withPeerConnection(peerId, function (peerConnection) {
+        var answer = new RTCSessionDescription({
+          type: 'answer',
+          sdp: sdpAnswer
+        });
+        peerConnection.setRemoteDescription(answer).then(function () {
+          tracer.trace('Remote description was set', answer);
 
+          _this6._processQueuedIceCandidates(peerId);
+        })["catch"](function (e) {
+          tracer.trace('Error', e);
+        });
+      });
+    } // Received by Initiator after a guests socket has been disconnected
+
+  }, {
+    key: "_peerDisconnectedHandler",
+    value: function _peerDisconnectedHandler(_ref4) {
+      var peerId = _ref4.peerId;
+      tracer.trace('_peerDisconnectedHandler');
+    } //#endregion WebRTC Initiator - session Initiator (User on mobile device)
     //#region WebRTC Guest - session Guest (Agent on dashboard platform)
-
     // Received by Guest, causing him to emit SDP_ANSWER
 
+  }, {
+    key: "_sdpOfferHandler",
+    value: function _sdpOfferHandler(_ref5) {
+      var _this7 = this;
 
-    TurnWebRtcSessionV2.prototype._sdpOfferHandler = function _sdpOfferHandler(_ref5) {
-        var _this7 = this;
-
-        var sdpOffer = _ref5.sdpOffer,
-            peerId = _ref5.peerId,
-            uid = _ref5.uid;
-
-        tracer.trace('sdpOffer Received', { sdpOffer: sdpOffer });
-
-        var peerConnection = this._createPeerConnection(peerId, _constants.CLIENT_TYPES.INITIATOR);
-
-        var subscriberInitChain = Promise.resolve();
-
-        if (this._constraints.audio) {
-            subscriberInitChain = subscriberInitChain.then(function () {
-                tracer.trace('Creating agent local streams');
-
-                return _this7._localStreamFactory(_this7._constraints).then(function (localStream) {
-                    localStream.getTracks().forEach(function (track) {
-                        tracer.trace('Adding local tracks to peer connection');
-
-                        if (track.kind === 'audio') {
+      var sdpOffer = _ref5.sdpOffer,
+          peerId = _ref5.peerId,
+          uid = _ref5.uid;
+      tracer.trace('sdpOffer Received', {
+        sdpOffer: sdpOffer
+      });
 
-                            var stream = new MediaStream([track]);
-                            var streamName = _constants.DEFAULT_STREAM_NAMES.DASHBOARD_AUDIO_STREAM;
-                            var agentAudioStream = new _stream.TsWebRTCStream(_this7, stream, streamName, false);
+      var peerConnection = this._createPeerConnection(peerId, _constants.CLIENT_TYPES.INITIATOR);
 
-                            _this7.registerStream(agentAudioStream.id, agentAudioStream);
-                            peerConnection.addTrack(track, peerConnection.peerLogicalStream);
+      var subscriberInitChain = Promise.resolve();
 
-                            tracer.trace('Agent audio stream added to peerConnection');
-                        }
-                    });
-                });
-            });
-        }
-
-        subscriberInitChain.then(function () {
-            var remoteDesc = new RTCSessionDescription({ type: 'offer', sdp: sdpOffer });
-
-            return peerConnection.setRemoteDescription(remoteDesc).then(function () {
-                tracer.trace('Remote description was set', remoteDesc);
-
-                return peerConnection.createAnswer().then(function (sdpAnswer) {
-                    tracer.trace('_sdpOfferHandler answer created', sdpAnswer);
+      if (this._constraints.audio) {
+        subscriberInitChain = subscriberInitChain.then(function () {
+          tracer.trace('Creating agent local streams');
+          return _this7._localStreamFactory(_this7._constraints).then(function (localStream) {
+            localStream.getTracks().forEach(function (track) {
+              tracer.trace('Adding local tracks to peer connection');
 
-                    _this7._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_ANSWER, {
-                        uid: uid,
-                        peerId: peerId,
-                        sessionId: _this7._credentials.sessionId,
-                        sdpAnswer: sdpAnswer.sdp
-                    });
+              if (track.kind === 'audio') {
+                var stream = new MediaStream([track]);
+                var streamName = _constants.DEFAULT_STREAM_NAMES.DASHBOARD_AUDIO_STREAM;
+                var agentAudioStream = new _stream.TsWebRTCStream(_this7, stream, streamName, false);
 
-                    return peerConnection.setLocalDescription(sdpAnswer).then(function () {
-                        tracer.trace('_sdpOfferHandler local desc was set');
+                _this7.registerStream(agentAudioStream.id, agentAudioStream);
 
-                        _this7._processQueuedIceCandidates(peerId);
-                    });
-                });
+                peerConnection.addTrack(track, peerConnection.peerLogicalStream);
+                tracer.trace('Agent audio stream added to peerConnection');
+              }
             });
+          });
         });
+      }
 
-        return subscriberInitChain.catch(function (e) {
-            tracer.trace('Error in _sdpOfferHandler', e);
-            throw e;
+      subscriberInitChain.then(function () {
+        var remoteDesc = new RTCSessionDescription({
+          type: 'offer',
+          sdp: sdpOffer
         });
-    };
-
-    // Received by Guest after an Initiator reconnects to room
-
-
-    TurnWebRtcSessionV2.prototype._initiatorReconnectHandler = function _initiatorReconnectHandler() {
-        tracer.trace('_initiatorReconnectHandler');
+        return peerConnection.setRemoteDescription(remoteDesc).then(function () {
+          tracer.trace('Remote description was set', remoteDesc);
+          return peerConnection.createAnswer().then(function (sdpAnswer) {
+            tracer.trace('_sdpOfferHandler answer created', sdpAnswer);
+
+            _this7._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_ANSWER, {
+              uid: uid,
+              peerId: peerId,
+              sessionId: _this7._credentials.sessionId,
+              sdpAnswer: sdpAnswer.sdp
+            });
 
-        var initiatorPeer = this._getInitiatorPeer();
+            return peerConnection.setLocalDescription(sdpAnswer).then(function () {
+              tracer.trace('_sdpOfferHandler local desc was set');
 
-        if (initiatorPeer) {
-            this._destroyPeerConnection(initiatorPeer);
-        }
+              _this7._processQueuedIceCandidates(peerId);
+            });
+          });
+        });
+      });
+      return subscriberInitChain["catch"](function (e) {
+        tracer.trace('Error in _sdpOfferHandler', e);
+        throw e;
+      });
+    } // Received by Guest after an Initiator reconnects to room
 
-        this.emit(_session.SESSION_EVENTS.RECONNECT_TURN_SERVER);
-    };
+  }, {
+    key: "_initiatorReconnectHandler",
+    value: function _initiatorReconnectHandler() {
+      tracer.trace('_initiatorReconnectHandler');
 
-    TurnWebRtcSessionV2.prototype._getInitiatorPeer = function _getInitiatorPeer() {
-        var peer = this._getPeerConnectionsByType(_constants.CLIENT_TYPES.INITIATOR);
+      var initiatorPeer = this._getInitiatorPeer();
 
-        return peer.length > 0 ? peer[0] : null;
-    };
+      if (initiatorPeer) {
+        this._destroyPeerConnection(initiatorPeer);
+      }
 
-    //#endregion WebRTC Guest - session Guest (Agent on dashboard platform)
+      this.emit(_session.SESSION_EVENTS.RECONNECT_TURN_SERVER);
+    }
+  }, {
+    key: "_getInitiatorPeer",
+    value: function _getInitiatorPeer() {
+      var peer = this._getPeerConnectionsByType(_constants.CLIENT_TYPES.INITIATOR);
 
+      return peer.length > 0 ? peer[0] : null;
+    } //#endregion WebRTC Guest - session Guest (Agent on dashboard platform)
     //#region Peer Connection
 
-    TurnWebRtcSessionV2.prototype._createPeerConnection = function _createPeerConnection(peerId, peerConnectionType) {
-        var _this8 = this;
-
-        if (this._peerConnections.get(peerId)) {
-            throw new Error(this._selfClientType + ' peer connection for ' + peerId + ' already exists');
-        }
-
-        var peerConnection = new RTCPeerConnection(this._configuration);
-
-        peerConnection.peerId = peerId;
-        peerConnection.peerType = peerConnectionType;
-        peerConnection.peerLogicalStream = new MediaStream();
-
-        peerConnection.oniceconnectionstatechange = function (state) {
-            tracer.trace('ICE Connection state for peer ' + peerId + ' was changed to: ' + state.currentTarget.iceConnectionState, state);
-            var cnnState = state.currentTarget.iceConnectionState;
-            if (cnnState === 'disconnected') {
-                //According to https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceConnectionState
-                //Connection can become active again, so we will do nothing.
-                // if (peerConnection.peerType === CLIENT_TYPES.INITIATOR) {
-                //     //this._destroyPeerConnection(peerConnection);
-                //     this.disconnect();
-                // }
-            } else if (cnnState === 'failed' || cnnState === 'closed') {
-                //According to https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceConnectionState
-                //When iceConnectionState is failed or closed, the peer connection can be destroyed.
-                //In our case, we disconnecting from media session, and when session will be needed again, it will be connected.
-                _this8.disconnect();
-            }
-        };
-
-        peerConnection.onicecandidate = function (event) {
-            if (event.candidate) {
-                tracer.trace(_this8._selfClientType + ' peerConn.onicecandidate', event.candidate);
-                _this8._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.ICE_CANDIDATE, {
-                    sessionId: _this8._credentials.sessionId,
-                    peerId: peerId,
-                    candidate: event.candidate,
-                    clientType: _this8._selfClientType
-                });
-            } else {
-                tracer.trace('ICE Candidate is null in peerConnection', event);
-            }
-        };
-
-        if (this._selfClientType === _constants.CLIENT_TYPES.GUEST) {
-            peerConnection.ontrack = function (trackEvent) {
-                var track = trackEvent.track,
-                    streams = trackEvent.streams;
-
-
-                tracer.trace('Stream created from peer connection track: ' + track.kind, track, streams.length > 0 ? streams[0] : 'NO STREAM');
-
-                var tsStream = new _stream.TsWebRTCStream(_this8, new MediaStream([track]));
-
-                tsStream.peerConnection = peerConnection;
-                tsStream.remote = true;
-
-                _this8.registerStream(tsStream.id, tsStream);
-
-                _this8.emit(_session.SESSION_EVENTS.STREAM_CREATED, tsStream);
-            };
-        }
-
-        this._peerConnections.set(peerId, peerConnection);
-
-        tracer.trace(this._selfClientType + ' peerConnection created');
-
-        return peerConnection;
-    };
-
-    TurnWebRtcSessionV2.prototype._destroyPeerConnection = function _destroyPeerConnection(peerConnection) {
-        var _this9 = this;
-
-        if (this._selfClientType === _constants.CLIENT_TYPES.GUEST) {
-            this._getRemoteStreams(peerConnection).forEach(function (stream) {
-                _this9.unregisterStream(stream.id);
-                _this9.emit(_session.SESSION_EVENTS.STREAM_DESTROYED, { stream: stream });
-            });
+  }, {
+    key: "_createPeerConnection",
+    value: function _createPeerConnection(peerId, peerConnectionType) {
+      var _this8 = this;
+
+      if (this._peerConnections.get(peerId)) {
+        throw new Error("".concat(this._selfClientType, " peer connection for ").concat(peerId, " already exists"));
+      }
+
+      var peerConnection = new RTCPeerConnection(this._configuration);
+      peerConnection.peerId = peerId;
+      peerConnection.peerType = peerConnectionType;
+      peerConnection.peerLogicalStream = new MediaStream();
+
+      peerConnection.oniceconnectionstatechange = function (state) {
+        tracer.trace("ICE Connection state for peer ".concat(peerId, " was changed to: ").concat(state.currentTarget.iceConnectionState), state);
+        var cnnState = state.currentTarget.iceConnectionState;
+
+        if (cnnState === 'disconnected') {//According to https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceConnectionState
+          //Connection can become active again, so we will do nothing.
+          // if (peerConnection.peerType === CLIENT_TYPES.INITIATOR) {
+          //     //this._destroyPeerConnection(peerConnection);
+          //     this.disconnect();
+          // }
+        } else if (cnnState === 'failed' || cnnState === 'closed') {
+          //According to https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceConnectionState
+          //When iceConnectionState is failed or closed, the peer connection can be destroyed.
+          //In our case, we disconnecting from media session, and when session will be needed again, it will be connected.
+          _this8.disconnect();
         }
-
-        if (this._selfClientType === _constants.CLIENT_TYPES.INITIATOR && this._peerConnections.size === 0) {
-            //TODO - ALEX: When initiator will be implemented, here we need to destroy local stream (or better raise, event).
+      };
+
+      peerConnection.onicecandidate = function (event) {
+        if (event.candidate) {
+          tracer.trace("".concat(_this8._selfClientType, " peerConn.onicecandidate"), event.candidate);
+
+          _this8._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.ICE_CANDIDATE, {
+            sessionId: _this8._credentials.sessionId,
+            peerId: peerId,
+            candidate: event.candidate,
+            clientType: _this8._selfClientType
+          });
+        } else {
+          tracer.trace('ICE Candidate is null in peerConnection', event);
         }
+      };
 
-        this._peerConnections.delete(peerConnection.peerId);
-        peerConnection.close();
-    };
+      if (this._selfClientType === _constants.CLIENT_TYPES.GUEST) {
+        peerConnection.ontrack = function (trackEvent) {
+          var track = trackEvent.track,
+              streams = trackEvent.streams;
+          tracer.trace("Stream created from peer connection track: ".concat(track.kind), track, streams.length > 0 ? streams[0] : 'NO STREAM');
+          var tsStream = new _stream.TsWebRTCStream(_this8, new MediaStream([track]));
+          tsStream.peerConnection = peerConnection;
+          tsStream.remote = true;
 
-    TurnWebRtcSessionV2.prototype._getRemoteStreams = function _getRemoteStreams(peerConnection) {
-        var result = [];
+          _this8.registerStream(tsStream.id, tsStream);
 
-        this.streams.forEach(function (stream) {
-            if (stream.peerConnection === peerConnection && stream.remote) {
-                result.push(stream);
-            }
-        });
-
-        return result;
-    };
+          _this8.emit(_session.SESSION_EVENTS.STREAM_CREATED, tsStream);
+        };
+      }
 
-    TurnWebRtcSessionV2.prototype._getPeerConnectionsByType = function _getPeerConnectionsByType(peerType) {
-        var result = [];
+      this._peerConnections.set(peerId, peerConnection);
 
-        this._peerConnections.forEach(function (peerConnection) {
-            if (peerConnection.peerType === peerType) {
-                result.push(peerConnection);
-            }
+      tracer.trace("".concat(this._selfClientType, " peerConnection created"));
+      return peerConnection;
+    }
+  }, {
+    key: "_destroyPeerConnection",
+    value: function _destroyPeerConnection(peerConnection) {
+      var _this9 = this;
+
+      if (this._selfClientType === _constants.CLIENT_TYPES.GUEST) {
+        this._getRemoteStreams(peerConnection).forEach(function (stream) {
+          _this9.unregisterStream(stream.id);
+
+          _this9.emit(_session.SESSION_EVENTS.STREAM_DESTROYED, {
+            stream: stream
+          });
         });
+      }
 
-        return result;
-    };
+      if (this._selfClientType === _constants.CLIENT_TYPES.INITIATOR && this._peerConnections.size === 0) {//TODO - ALEX: When initiator will be implemented, here we need to destroy local stream (or better raise, event).
+      }
 
-    TurnWebRtcSessionV2.prototype._withPeerConnection = function _withPeerConnection(peerId, callback) {
-        if (this._peerConnections.get(peerId)) {
-            return callback(this._peerConnections.get(peerId));
-        }
+      this._peerConnections["delete"](peerConnection.peerId);
 
-        return null;
-    };
-
-    TurnWebRtcSessionV2.prototype._extendPeerConnection = function _extendPeerConnection() {
-        //TODO - Alex: Need to modify IE shim, and add these methods inside shim itself
-
-        if (!RTCPeerConnection.prototype.peerId) {
-            RTCPeerConnection.prototype.peerId = '';
-        }
-
-        if (!RTCPeerConnection.prototype.peerType) {
-            RTCPeerConnection.prototype.peerType = null;
+      peerConnection.close();
+    }
+  }, {
+    key: "_getRemoteStreams",
+    value: function _getRemoteStreams(peerConnection) {
+      var result = [];
+      this.streams.forEach(function (stream) {
+        if (stream.peerConnection === peerConnection && stream.remote) {
+          result.push(stream);
         }
-
-        if (!RTCPeerConnection.prototype.peerLogicalStream) {
-            RTCPeerConnection.prototype.peerLogicalStream = null;
+      });
+      return result;
+    }
+  }, {
+    key: "_getPeerConnectionsByType",
+    value: function _getPeerConnectionsByType(peerType) {
+      var result = [];
+
+      this._peerConnections.forEach(function (peerConnection) {
+        if (peerConnection.peerType === peerType) {
+          result.push(peerConnection);
         }
-    };
-
-    //#endregion
+      });
 
+      return result;
+    }
+  }, {
+    key: "_withPeerConnection",
+    value: function _withPeerConnection(peerId, callback) {
+      if (this._peerConnections.get(peerId)) {
+        return callback(this._peerConnections.get(peerId));
+      }
+
+      return null;
+    }
+  }, {
+    key: "_extendPeerConnection",
+    value: function _extendPeerConnection() {
+      //TODO - Alex: Need to modify IE shim, and add these methods inside shim itself
+      if (!RTCPeerConnection.prototype.peerId) {
+        RTCPeerConnection.prototype.peerId = '';
+      }
+
+      if (!RTCPeerConnection.prototype.peerType) {
+        RTCPeerConnection.prototype.peerType = null;
+      }
+
+      if (!RTCPeerConnection.prototype.peerLogicalStream) {
+        RTCPeerConnection.prototype.peerLogicalStream = null;
+      }
+    } //#endregion
     //#region ICE Candidates
 
-    TurnWebRtcSessionV2.prototype._iceCandidateReceivedHandler = function _iceCandidateReceivedHandler(_ref6) {
-        var candidate = _ref6.candidate,
-            peerId = _ref6.peerId;
-
-        tracer.trace('_iceCandidateReceivedHandler', candidate);
-        if (!candidate) {
-            tracer.trace('NO iceCandidate');
-
-            return;
-        }
-
-        var peerConnection = this._peerConnections.get(peerId);
+  }, {
+    key: "_iceCandidateReceivedHandler",
+    value: function _iceCandidateReceivedHandler(_ref6) {
+      var candidate = _ref6.candidate,
+          peerId = _ref6.peerId;
+      tracer.trace('_iceCandidateReceivedHandler', candidate);
 
-        if (!peerConnection || !peerConnection.remoteDescription) {
-            tracer.trace('Queueing iceCandidate', candidate);
-            this._queueIceCandidate(candidate, peerId);
+      if (!candidate) {
+        tracer.trace('NO iceCandidate');
+        return;
+      }
 
-            return;
-        }
+      var peerConnection = this._peerConnections.get(peerId);
 
-        tracer.trace('Going to add iceCandidate', candidate);
-        this._addIceCandidateToPeer(candidate, peerConnection);
-    };
+      if (!peerConnection || !peerConnection.remoteDescription) {
+        tracer.trace('Queueing iceCandidate', candidate);
 
-    TurnWebRtcSessionV2.prototype._addIceCandidateToPeer = function _addIceCandidateToPeer(iceCandidate, peerConnection) {
-        return peerConnection.addIceCandidate(iceCandidate).then(function () {
-            tracer.trace('ICE Candidate add to peer connection');
-        }).catch(function (e) {
-            tracer.trace('Error adding ICE Candidate to peer connection', e);
-        });
-    };
+        this._queueIceCandidate(candidate, peerId);
 
-    TurnWebRtcSessionV2.prototype._processQueuedIceCandidates = function _processQueuedIceCandidates(peerId) {
-        var _this10 = this;
+        return;
+      }
 
-        this._withPeerConnection(peerId, function (peerConnection) {
-            var pendingIces = _this10._pendingPeersIce[peerId];
+      tracer.trace('Going to add iceCandidate', candidate);
 
-            if (pendingIces) {
-                pendingIces.forEach(function (pendingIce) {
-                    tracer.trace('Adding pending ICE to peer connections');
-                    _this10._addIceCandidateToPeer(pendingIce, peerConnection);
-                });
-            } else {
-                tracer.trace('No pending ICE found for peer', peerId);
-            }
-        });
-    };
-
-    TurnWebRtcSessionV2.prototype._queueIceCandidate = function _queueIceCandidate(iceCandidate, peerId) {
-        if (!this._pendingPeersIce[peerId]) {
-            this._pendingPeersIce[peerId] = [];
+      this._addIceCandidateToPeer(candidate, peerConnection);
+    }
+  }, {
+    key: "_addIceCandidateToPeer",
+    value: function _addIceCandidateToPeer(iceCandidate, peerConnection) {
+      return peerConnection.addIceCandidate(iceCandidate).then(function () {
+        tracer.trace('ICE Candidate add to peer connection');
+      })["catch"](function (e) {
+        tracer.trace('Error adding ICE Candidate to peer connection', e);
+      });
+    }
+  }, {
+    key: "_processQueuedIceCandidates",
+    value: function _processQueuedIceCandidates(peerId) {
+      var _this10 = this;
+
+      this._withPeerConnection(peerId, function (peerConnection) {
+        var pendingIces = _this10._pendingPeersIce[peerId];
+
+        if (pendingIces) {
+          pendingIces.forEach(function (pendingIce) {
+            tracer.trace('Adding pending ICE to peer connections');
+
+            _this10._addIceCandidateToPeer(pendingIce, peerConnection);
+          });
+        } else {
+          tracer.trace('No pending ICE found for peer', peerId);
         }
+      });
+    }
+  }, {
+    key: "_queueIceCandidate",
+    value: function _queueIceCandidate(iceCandidate, peerId) {
+      if (!this._pendingPeersIce[peerId]) {
+        this._pendingPeersIce[peerId] = [];
+      }
 
-        this._pendingPeersIce[peerId].push(iceCandidate);
-    };
-
-    //#endregion
+      this._pendingPeersIce[peerId].push(iceCandidate);
+    } //#endregion
 
+  }]);
 
-    return TurnWebRtcSessionV2;
+  return TurnWebRtcSessionV2;
 }(_session.TsMediaSession);
+
+exports.TurnWebRtcSessionV2 = TurnWebRtcSessionV2;
 //# sourceMappingURL=session-turn.v2.js.map