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

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

@@ -1,43 +1,59 @@
-'use strict';
+"use strict";
 
-exports.__esModule = true;
-exports.TurnWebRTCSession = 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.TurnWebRTCSession = void 0;
 
-var _session = require('../session');
+var _session = require("../session");
 
-var _publisher = require('../publisher');
+var _publisher = require("../publisher");
 
-var _stream = require('./stream');
+var _stream = require("./stream");
 
-var _socket = require('socket.io-client');
+var io = _interopRequireWildcard(require("socket.io-client"));
 
-var io = _interopRequireWildcard(_socket);
+var _tsEnvironmentDetect = require("@techsee/techsee-common/lib/helpers/ts-environment-detect");
 
-var _tsEnvironmentDetect = require('@techsee/techsee-common/lib/helpers/ts-environment-detect');
+var _constants = require("./constants");
 
-var _constants = require('./constants');
+var _helper = require("./helper");
 
-var _helper = require('./helper');
+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; }
+
+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); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+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); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+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; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
 var isIE11 = new _tsEnvironmentDetect.TsEnvironmentDetect().isIE11();
 
 var _require = require('kurento-utils'),
     WebRtcPeer = _require.WebRtcPeer; // eslint-disable-line global-require
 
-var tracer = (0, _tracer.getTracer)();
 
+var tracer = (0, _tracer.getTracer)();
 /**
  * WebRTC-specific implementation of TsMediaSession.
  *
@@ -50,427 +66,450 @@ var tracer = (0, _tracer.getTracer)();
  * @see TsMediaSession
  */
 
-var TurnWebRTCSession = exports.TurnWebRTCSession = function (_TsMediaSession) {
-    _inherits(TurnWebRTCSession, _TsMediaSession);
-
-    function TurnWebRTCSession(_ref, localStreamFactory) {
-        var credentials = _ref.credentials,
-            isMobile = _ref.isMobile,
-            resolution = _ref.resolution,
-            deviceOpts = _ref.deviceOpts;
-
-        _classCallCheck(this, TurnWebRTCSession);
-
-        var _this = _possibleConstructorReturn(this, _TsMediaSession.call(this));
-
-        tracer.trace('Constructor');
-
-        _this._credentials = credentials;
-        _this._isMobile = isMobile;
-        _this._resolution = resolution;
-        _this._deviceOpts = deviceOpts;
-        _this._incomingIce = [];
-        _this._localStreamFactory = localStreamFactory;
-
-        var iceServers = credentials.ice.map(function (item) {
-            return {
-                urls: item.url,
-                username: item.login,
-                credential: item.password
-            };
-        });
-
-        _this._configuration = {
-            iceServers: iceServers,
-
-            iceTransportPolicy: 'relay'
-        };
-
-        /**
-         * Socket.io connection to the signaling server
-         *
-         * @private
-         * @member { Object }
-         */
-        _this._socket = null;
-
-        /**
-         * RTCPeerConnection to the media server.
-         *
-         * For now kurento-utils is used for connection establishment.
-         *
-         * @private
-         * @member { Object }
-         */
-        _this._pcs = {};
-        return _this;
-    }
+var TurnWebRTCSession = /*#__PURE__*/function (_TsMediaSession) {
+  _inherits(TurnWebRTCSession, _TsMediaSession);
+
+  var _super = _createSuper(TurnWebRTCSession);
+
+  function TurnWebRTCSession(_ref, localStreamFactory) {
+    var _this;
+
+    var credentials = _ref.credentials,
+        isMobile = _ref.isMobile,
+        resolution = _ref.resolution,
+        deviceOpts = _ref.deviceOpts;
+
+    _classCallCheck(this, TurnWebRTCSession);
+
+    _this = _super.call(this);
+    tracer.trace('Constructor');
+    _this._credentials = credentials;
+    _this._isMobile = isMobile;
+    _this._resolution = resolution;
+    _this._deviceOpts = deviceOpts;
+    _this._incomingIce = [];
+    _this._localStreamFactory = localStreamFactory;
+    var iceServers = credentials.ice.map(function (item) {
+      return {
+        urls: item.url,
+        username: item.login,
+        credential: item.password
+      };
+    });
+    _this._configuration = {
+      iceServers: iceServers,
+      iceTransportPolicy: 'relay'
+    };
+    /**
+     * Socket.io connection to the signaling server
+     *
+     * @private
+     * @member { Object }
+     */
 
+    _this._socket = null;
     /**
-     * Id of the session.
+     * RTCPeerConnection to the media server.
      *
-     * @member { String }
+     * For now kurento-utils is used for connection establishment.
      *
-     * @type { String }
+     * @private
+     * @member { Object }
      */
 
-
+    _this._pcs = {};
+    return _this;
+  }
+  /**
+   * Id of the session.
+   *
+   * @member { String }
+   *
+   * @type { String }
+   */
+
+
+  _createClass(TurnWebRTCSession, [{
+    key: "id",
+    get: function get() {
+      return this._credentials.sessionId;
+    }
     /**
      *
      * @member { String }
      *
      * @type { String }
      */
-    TurnWebRTCSession.prototype._connectSocket = function _connectSocket(url) {
-        var _this2 = this;
-
-        return new Promise(function (resolve, reject) {
-            tracer.trace('Connect socket');
-            var 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
-            });
 
-            var done = _.once(function (err) {
-                tracer.trace(err ? 'Error' : 'Connected', err);
-                err ? reject(err) : resolve();
-            });
+  }, {
+    key: "_connectSocket",
+    value: function _connectSocket(url) {
+      var _this2 = this;
+
+      return new Promise(function (resolve, reject) {
+        tracer.trace('Connect socket');
+        var 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
+        });
 
-            //
-            // When connection is established
-            //
-            socket.once('connect', function () {
-                return done();
+        var done = _.once(function (err) {
+          tracer.trace(err ? 'Error' : 'Connected', err);
+          err ? reject(err) : resolve();
+        }); //
+        // When connection is established
+        //
+
+
+        socket.once('connect', function () {
+          return done();
+        }); //
+        // errorOccured is ts-media-client signal
+        //
+
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.ERROR, done); //
+        // And these 2 are socket.io connection failed events
+        //
+
+        socket.on('connect_error', done);
+        socket.on('connect_timeout', done);
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.JOIN_RESPONSE, function (_ref2) {
+          var sdpAnswer = _ref2.sdpAnswer,
+              uid = _ref2.uid,
+              peerId = _ref2.peerId;
+          tracer.trace('SOCKET_EVENTS.INCOMING.JOIN_RESPONSE');
+          var pc = _this2._pcs[peerId];
+
+          if (!pc) {
+            tracer.trace('No peer found');
+            var error = "pc not found. peer=".concat(peerId, " uid=").concat(uid);
+
+            _this2.emit(_session.EVENTS.EXCEPTION, {
+              source: 'JOIN_RESPONSE',
+              error: error
             });
-            //
-            // errorOccured is ts-media-client signal
-            //
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.ERROR, done);
-            //
-            // And these 2 are socket.io connection failed events
-            //
-            socket.on('connect_error', done);
-            socket.on('connect_timeout', done);
 
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.JOIN_RESPONSE, function (_ref2) {
-                var sdpAnswer = _ref2.sdpAnswer,
-                    uid = _ref2.uid,
-                    peerId = _ref2.peerId;
+            return done(error);
+          }
 
-                tracer.trace('SOCKET_EVENTS.INCOMING.JOIN_RESPONSE');
+          pc.processAnswer(sdpAnswer, function (error) {
+            if (error) {
+              _this2.emit(_session.EVENTS.EXCEPTION, {
+                source: 'processAnswer',
+                error: error
+              });
 
-                var pc = _this2._pcs[peerId];
+              return done(error);
+            }
 
-                if (!pc) {
-                    tracer.trace('No peer found');
-                    var error = 'pc not found. peer=' + peerId + ' uid=' + uid;
+            tracer.trace('ANSWER PROCESSED'); // FIXME why don't we have _incomingIce per PC? current assumes we don't have parallel connections, not good
 
-                    _this2.emit(_session.EVENTS.EXCEPTION, { source: 'JOIN_RESPONSE', error: error });
+            _.forEach(_this2._incomingIce, function (candidate) {
+              pc.addIceCandidate(candidate, function (error) {
+                tracer.trace('ICE ADDED AFTER ANSWER');
 
-                    return done(error);
+                if (error) {
+                  _this2.emit(_session.EVENTS.EXCEPTION, {
+                    source: 'JOIN_RESPONSE addIceCandidate',
+                    error: error
+                  });
                 }
+              });
+            });
 
-                pc.processAnswer(sdpAnswer, function (error) {
-                    if (error) {
-                        _this2.emit(_session.EVENTS.EXCEPTION, { source: 'processAnswer', error: error });
-
-                        return done(error);
-                    }
-
-                    tracer.trace('ANSWER PROCESSED');
-
-                    // FIXME why don't we have _incomingIce per PC? current assumes we don't have parallel connections, not good
-                    _.forEach(_this2._incomingIce, function (candidate) {
-                        pc.addIceCandidate(candidate, function (error) {
-                            tracer.trace('ICE ADDED AFTER ANSWER');
-                            if (error) {
-                                _this2.emit(_session.EVENTS.EXCEPTION, { source: 'JOIN_RESPONSE addIceCandidate', error: error });
-                            }
-                        });
-                    });
-
-                    _this2._incomingIce.length = 0;
-                });
+            _this2._incomingIce.length = 0;
+          });
 
-                _this2.emit(_session.EVENTS.CONNECTED);
+          _this2.emit(_session.EVENTS.CONNECTED);
 
-                _this2.publish(_this2.publisher).catch(function (error) {
-                    _this2.emit(_session.EVENTS.EXCEPTION, { source: 'publish', error: error });
-                });
+          _this2.publish(_this2.publisher)["catch"](function (error) {
+            _this2.emit(_session.EVENTS.EXCEPTION, {
+              source: 'publish',
+              error: error
             });
+          });
+        });
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.ICE_CANDIDATE, function (_ref3) {
+          var candidate = _ref3.candidate,
+              peerId = _ref3.peerId;
+          tracer.trace('SOCKET_EVENTS.INCOMING.ICE_CANDIDATE');
+          var pc = _this2._pcs[peerId];
 
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.ICE_CANDIDATE, function (_ref3) {
-                var candidate = _ref3.candidate,
-                    peerId = _ref3.peerId;
+          if (!pc) {
+            tracer.trace('NO PEER FOUND ADD TO ICE QUEUE');
 
-                tracer.trace('SOCKET_EVENTS.INCOMING.ICE_CANDIDATE');
-                var pc = _this2._pcs[peerId];
+            _this2._incomingIce.push(candidate);
 
-                if (!pc) {
-                    tracer.trace('NO PEER FOUND ADD TO ICE QUEUE');
-                    _this2._incomingIce.push(candidate);
+            return;
+          }
 
-                    return;
-                }
+          pc.addIceCandidate(candidate, function (error) {
+            tracer.trace('ICE ADDED AFTER INCOMING');
 
-                pc.addIceCandidate(candidate, function (error) {
-                    tracer.trace('ICE ADDED AFTER INCOMING');
-                    if (error) {
-                        _this2.emit(_session.EVENTS.EXCEPTION, { source: 'ICE_CANDIDATE addIceCandidate', error: error });
-                    }
-                });
+            if (error) {
+              _this2.emit(_session.EVENTS.EXCEPTION, {
+                source: 'ICE_CANDIDATE addIceCandidate',
+                error: error
+              });
+            }
+          });
+        }); // Received by publisher, causing him to emit SDP_OFFER
+
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.SEND_OFFER, function (_ref4) {
+          var uid = _ref4.uid,
+              peerId = _ref4.peerId;
+          tracer.trace('SOCKET_EVENTS.INCOMING.SEND_OFFER');
+
+          _this2._createRTCPeerConnection(peerId).then(function (pc) {
+            tracer.trace('GENERATING OFFER');
+            pc.generateOffer(function (error, offer) {
+              tracer.trace('OFFER GENERATED');
+
+              if (error) {
+                return done(error);
+              }
+
+              socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_OFFER, {
+                uid: uid,
+                peerId: peerId,
+                sessionId: _this2._credentials.sessionId,
+                sdpOffer: offer
+              });
             });
-
-            // Received by publisher, causing him to emit SDP_OFFER
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.SEND_OFFER, function (_ref4) {
-                var uid = _ref4.uid,
-                    peerId = _ref4.peerId;
-
-                tracer.trace('SOCKET_EVENTS.INCOMING.SEND_OFFER');
-
-                _this2._createRTCPeerConnection(peerId).then(function (pc) {
-                    tracer.trace('GENERATING OFFER');
-
-                    pc.generateOffer(function (error, offer) {
-                        tracer.trace('OFFER GENERATED');
-
-                        if (error) {
-                            return done(error);
-                        }
-
-                        socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_OFFER, {
-                            uid: uid,
-                            peerId: peerId,
-                            sessionId: _this2._credentials.sessionId,
-                            sdpOffer: offer
-                        });
-                    });
-                }).catch(function (error) {
-                    _this2.emit(_session.EVENTS.EXCEPTION, { source: '_createRTCPeerConnection', error: error });
-                    if (error && error.name) {
-                        _this2.lastError = error.name;
-                    }
-                });
+          })["catch"](function (error) {
+            _this2.emit(_session.EVENTS.EXCEPTION, {
+              source: '_createRTCPeerConnection',
+              error: error
             });
 
-            // Received by subscriber, causing him to emit SDP_ANSWER
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.SDP_OFFER, function (_ref5) {
-                var sdpOffer = _ref5.sdpOffer,
-                    peerId = _ref5.peerId,
-                    uid = _ref5.uid;
-
-                tracer.trace('SOCKET_EVENTS.INCOMING.SDP_OFFER');
-
-                Promise.resolve().then(function () {
-                    var pc = _this2._pcs[peerId];
-
-                    if (pc) {
-                        tracer.trace('PEER ALREADY EXISTS');
-                        return pc;
-                    }
-
-                    return _this2._createRTCPeerConnection(peerId);
-                }).then(function (pc) {
-                    tracer.trace('PROCESS OFFER');
-                    pc.processOffer(sdpOffer, function (error, sdpAnswer) {
-                        tracer.trace('OFFER PROCESSED');
-                        if (error) {
-                            return done(error);
-                        }
-
-                        socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_ANSWER, {
-                            uid: uid,
-                            peerId: peerId,
-                            sessionId: _this2._credentials.sessionId,
-                            sdpAnswer: sdpAnswer
-                        });
-                    });
-                }).catch(function (error) {
-                    _this2.emit(_session.EVENTS.EXCEPTION, { source: 'response on INCOMING.SDP_OFFER', error: error });
-                    if (error && error.name) {
-                        _this2.lastError = error.name;
-                    }
-                });
-            });
+            if (error && error.name) {
+              _this2.lastError = error.name;
+            }
+          });
+        }); // Received by subscriber, causing him to emit SDP_ANSWER
+
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.SDP_OFFER, function (_ref5) {
+          var sdpOffer = _ref5.sdpOffer,
+              peerId = _ref5.peerId,
+              uid = _ref5.uid;
+          tracer.trace('SOCKET_EVENTS.INCOMING.SDP_OFFER');
+          Promise.resolve().then(function () {
+            var pc = _this2._pcs[peerId];
+
+            if (pc) {
+              tracer.trace('PEER ALREADY EXISTS');
+              return pc;
+            }
 
-            // Received by subscriber after a publisher reconnects to room
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.PUBLISHER_RECONNECT, function () {
-                tracer.trace('SOCKET_EVENTS.INCOMING.PUBLISHER_RECONNECT');
+            return _this2._createRTCPeerConnection(peerId);
+          }).then(function (pc) {
+            tracer.trace('PROCESS OFFER');
+            pc.processOffer(sdpOffer, function (error, sdpAnswer) {
+              tracer.trace('OFFER PROCESSED');
+
+              if (error) {
+                return done(error);
+              }
+
+              socket.emit(_constants.SOCKET_EVENTS.OUTGOING.SDP_ANSWER, {
+                uid: uid,
+                peerId: peerId,
+                sessionId: _this2._credentials.sessionId,
+                sdpAnswer: sdpAnswer
+              });
+            });
+          })["catch"](function (error) {
+            _this2.emit(_session.EVENTS.EXCEPTION, {
+              source: 'response on INCOMING.SDP_OFFER',
+              error: error
+            });
 
-                // Clean up and reconnect with a new peer-connection,
-                // to prevent reconnection issues
+            if (error && error.name) {
+              _this2.lastError = error.name;
+            }
+          });
+        }); // Received by subscriber after a publisher reconnects to room
 
-                _this2._streams.clear();
-                socket.off();
-                _.forEach(_this2._pcs, function (_ref6) {
-                    var peerConnection = _ref6.peerConnection;
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.PUBLISHER_RECONNECT, function () {
+          tracer.trace('SOCKET_EVENTS.INCOMING.PUBLISHER_RECONNECT'); // Clean up and reconnect with a new peer-connection,
+          // to prevent reconnection issues
 
-                    tracer.trace('CLOSING PEER');
-                    peerConnection.close();
-                });
-                _this2._pcs = {};
+          _this2._streams.clear();
 
-                _this2.emit(_session.EVENTS.RECONNECT_TURN_SERVER);
-            });
+          socket.off();
 
-            // Received by publisher after a subscriber's socket has been disconnected
-            socket.on(_constants.SOCKET_EVENTS.INCOMING.PEER_DISCONNECTED, function () {
-                var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-                    peerId = _ref7.peerId;
+          _.forEach(_this2._pcs, function (_ref6) {
+            var peerConnection = _ref6.peerConnection;
+            tracer.trace('CLOSING PEER');
+            peerConnection.close();
+          });
 
-                tracer.trace('SOCKET_EVENTS.INCOMING.PEER_DISCONNECTED');
+          _this2._pcs = {};
 
-                if (peerId && _this2._pcs[peerId]) {
-                    if (_this2._lastPc === _this2._pcs[peerId]) {
-                        _this2._lastPc = null;
-                    }
+          _this2.emit(_session.EVENTS.RECONNECT_TURN_SERVER);
+        }); // Received by publisher after a subscriber's socket has been disconnected
 
-                    if (Object.getOwnPropertyNames(_this2._pcs).length === 1) {
-                        _this2._toggleAllStreams(false);
-                    }
+        socket.on(_constants.SOCKET_EVENTS.INCOMING.PEER_DISCONNECTED, function () {
+          var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+              peerId = _ref7.peerId;
 
-                    _this2._pcs[peerId].peerConnection.close();
+          tracer.trace('SOCKET_EVENTS.INCOMING.PEER_DISCONNECTED');
 
-                    delete _this2._pcs[peerId];
-                }
-            });
+          if (peerId && _this2._pcs[peerId]) {
+            if (_this2._lastPc === _this2._pcs[peerId]) {
+              _this2._lastPc = null;
+            }
 
-            _this2._socket = socket;
-        });
-    };
+            if (Object.getOwnPropertyNames(_this2._pcs).length === 1) {
+              _this2._toggleAllStreams(false);
+            }
 
-    TurnWebRTCSession.prototype._setupConnection = function _setupConnection(pc) {
-        var _this3 = this;
+            _this2._pcs[peerId].peerConnection.close();
 
-        return new Promise(function (resolve) {
-            tracer.trace('_setupConnection');
-            pc.peerConnection.oniceconnectionstatechange = function (e) {
-                tracer.trace('oniceconnectionstatechange', e);
+            delete _this2._pcs[peerId];
+          }
+        });
+        _this2._socket = socket;
+      });
+    }
+  }, {
+    key: "_setupConnection",
+    value: function _setupConnection(pc) {
+      var _this3 = this;
+
+      return new Promise(function (resolve) {
+        tracer.trace('_setupConnection');
+
+        pc.peerConnection.oniceconnectionstatechange = function (e) {
+          tracer.trace('oniceconnectionstatechange', e);
+
+          if (_this3.iceCheckingTimeout) {
+            clearTimeout(_this3.iceCheckingTimeout);
+            _this3.iceCheckingTimeout = null;
+          }
+
+          if (e.target.iceConnectionState === 'failed') {
+            // if this is one of many in the publisher, skip
+            // already attempting a reconnect
+            if (_this3._turnServerReconnectInterval) {
+              return;
+            }
 
-                if (_this3.iceCheckingTimeout) {
-                    clearTimeout(_this3.iceCheckingTimeout);
-                    _this3.iceCheckingTimeout = null;
-                }
+            _this3._turnServerReconnectInterval = setInterval(function () {
+              if (!navigator.onLine) {
+                return;
+              }
 
-                if (e.target.iceConnectionState === 'failed') {
-                    // if this is one of many in the publisher, skip
-
-                    // already attempting a reconnect
-                    if (_this3._turnServerReconnectInterval) {
-                        return;
-                    }
-
-                    _this3._turnServerReconnectInterval = setInterval(function () {
-                        if (!navigator.onLine) {
-                            return;
-                        }
-
-                        clearInterval(_this3._turnServerReconnectInterval);
-                        _this3._turnServerReconnectInterval = null;
-
-                        if (!_this3._socket.connected) {
-                            _this3.disconnected = false;
-                            _this3._socket.connect();
-                        }
-
-                        _this3.emit(_session.EVENTS.RECONNECT_TURN_SERVER);
-                    }, _constants.RECONNECT_TURN_SERVER_INTERVAL);
-                } else if (e.target.iceConnectionState === 'checking') {
-                    _this3.iceCheckingTimeout = setTimeout(function () {
-                        _this3.emit(_session.EVENTS.TURN_SERVER_CONNECTION_FAILED);
-                    }, _constants.FAILED_CONNECTING_TURN_SERVER_INTERVAL);
-                }
-            };
+              clearInterval(_this3._turnServerReconnectInterval);
+              _this3._turnServerReconnectInterval = null;
 
-            pc.peerConnection.onremovestream = function (_ref8) {
-                var stream = _ref8.stream;
+              if (!_this3._socket.connected) {
+                _this3.disconnected = false;
 
-                tracer.trace('onremovestream');
-                _this3._streams.delete(stream.id);
-            };
+                _this3._socket.connect();
+              }
 
-            resolve();
-        });
-    };
+              _this3.emit(_session.EVENTS.RECONNECT_TURN_SERVER);
+            }, _constants.RECONNECT_TURN_SERVER_INTERVAL);
+          } else if (e.target.iceConnectionState === 'checking') {
+            _this3.iceCheckingTimeout = setTimeout(function () {
+              _this3.emit(_session.EVENTS.TURN_SERVER_CONNECTION_FAILED);
+            }, _constants.FAILED_CONNECTING_TURN_SERVER_INTERVAL);
+          }
+        };
 
-    TurnWebRTCSession.prototype._getPeerType = function _getPeerType(constraints, isMobile) {
-        if (isMobile || constraints.audio) {
-            return _constants.PEER_CONNECTION_TYPES.SEND_RECV;
-        }
+        pc.peerConnection.onremovestream = function (_ref8) {
+          var stream = _ref8.stream;
+          tracer.trace('onremovestream');
 
-        return _constants.PEER_CONNECTION_TYPES.RECV_ONLY;
-    };
+          _this3._streams["delete"](stream.id);
+        };
 
-    TurnWebRTCSession.prototype._connectRTCPeer = function _connectRTCPeer(_ref9) {
-        var _this4 = this;
+        resolve();
+      });
+    }
+  }, {
+    key: "_getPeerType",
+    value: function _getPeerType(constraints, isMobile) {
+      if (isMobile || constraints.audio) {
+        return _constants.PEER_CONNECTION_TYPES.SEND_RECV;
+      }
+
+      return _constants.PEER_CONNECTION_TYPES.RECV_ONLY;
+    }
+  }, {
+    key: "_connectRTCPeer",
+    value: function _connectRTCPeer(_ref9) {
+      var _this4 = this;
+
+      var constraints = _ref9.constraints,
+          configuration = _ref9.configuration,
+          sessionId = _ref9.sessionId,
+          isMobile = _ref9.isMobile,
+          peerId = _ref9.peerId;
+      return new Promise(function (resolve, reject) {
+        tracer.trace('_connectRTCPeer');
+
+        var done = _.once(function (err, pc) {
+          tracer.trace(err ? 'Error' : 'Peer Connected', err);
+          err ? reject(err) : resolve(pc);
+        });
 
-        var constraints = _ref9.constraints,
-            configuration = _ref9.configuration,
-            sessionId = _ref9.sessionId,
-            isMobile = _ref9.isMobile,
-            peerId = _ref9.peerId;
+        var setupWebRtcPeer = function setupWebRtcPeer(stream) {
+          tracer.trace('setupWebRtcPeer');
 
-        return new Promise(function (resolve, reject) {
-            tracer.trace('_connectRTCPeer');
+          var peerConnectionType = _this4._getPeerType(constraints, isMobile);
 
-            var done = _.once(function (err, pc) {
-                tracer.trace(err ? 'Error' : 'Peer Connected', err);
-                err ? reject(err) : resolve(pc);
-            });
-            var setupWebRtcPeer = function setupWebRtcPeer(stream) {
-                tracer.trace('setupWebRtcPeer');
-                var peerConnectionType = _this4._getPeerType(constraints, isMobile);
-                var peerConfig = {
-                    configuration: configuration,
-                    videoStream: isMobile ? stream : undefined,
-                    mediaConstraints: constraints,
-                    onicecandidate: function onicecandidate(candidate) {
-                        tracer.trace('onicecandidate', candidate);
-                        _this4._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.ICE_CANDIDATE, {
-                            sessionId: sessionId,
-                            peerId: peerId,
-                            candidate: candidate,
-                            clientType: isMobile ? _constants.CLIENT_TYPES.PUBLISHER : _constants.CLIENT_TYPES.SUBSCRIBER
-                        });
-                    }
-                };
-
-                var pc = WebRtcPeer[peerConnectionType](peerConfig, function (error) {
-                    if (error) {
-                        return done(error);
-                    }
-
-                    _this4._setupConnection(pc).then(function () {
-                        return done(null, pc);
-                    }).catch(done);
-                });
-
-                _this4._pcs[peerId] = pc;
-                _this4._lastPc = pc;
-            };
-
-            _this4._localStreamFactory(constraints).then(function (localStream) {
-                setupWebRtcPeer(localStream);
-            }).catch(function () {
-                setupWebRtcPeer(undefined);
-            });
-        });
-    };
+          var peerConfig = {
+            configuration: configuration,
+            videoStream: isMobile ? stream : undefined,
+            mediaConstraints: constraints,
+            onicecandidate: function onicecandidate(candidate) {
+              tracer.trace('onicecandidate', candidate);
 
-    TurnWebRTCSession.prototype._setTrackStateTo = function _setTrackStateTo(state) {
-        tracer.trace('_setTrackStateTo');
-        return function (track) {
-            if (track.setEnabled) {
-                track.setEnabled(state);
-            } else {
-                track.enabled = state;
+              _this4._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.ICE_CANDIDATE, {
+                sessionId: sessionId,
+                peerId: peerId,
+                candidate: candidate,
+                clientType: isMobile ? _constants.CLIENT_TYPES.PUBLISHER : _constants.CLIENT_TYPES.SUBSCRIBER
+              });
+            }
+          };
+          var pc = WebRtcPeer[peerConnectionType](peerConfig, function (error) {
+            if (error) {
+              return done(error);
             }
+
+            _this4._setupConnection(pc).then(function () {
+              return done(null, pc);
+            })["catch"](done);
+          });
+          _this4._pcs[peerId] = pc;
+          _this4._lastPc = pc;
         };
-    };
 
+        _this4._localStreamFactory(constraints).then(function (localStream) {
+          setupWebRtcPeer(localStream);
+        })["catch"](function () {
+          setupWebRtcPeer(undefined);
+        });
+      });
+    }
+  }, {
+    key: "_setTrackStateTo",
+    value: function _setTrackStateTo(state) {
+      tracer.trace('_setTrackStateTo');
+      return function (track) {
+        if (track.setEnabled) {
+          track.setEnabled(state);
+        } else {
+          track.enabled = state;
+        }
+      };
+    }
     /**
      * Establish socket and peer connection to the media server.
      *
@@ -480,110 +519,116 @@ var TurnWebRTCSession = exports.TurnWebRTCSession = function (_TsMediaSession) {
      * @fires SESSION_EVENTS#CONNECTED
      */
 
-
-    TurnWebRTCSession.prototype.connect = function connect() {
-        var _this5 = this;
-
-        tracer.trace('connect');
-        return this._connectSocket(this._credentials.url).then(function () {
-            tracer.trace('Socket connected getting constraints');
-            return (0, _helper.getMediaConstraints)({
-                resolution: _this5._resolution,
-                deviceOpts: _this5._deviceOpts
-            });
-        }).then(function (constraints) {
-            tracer.trace('connect - constraints', constraints);
-
-            // streaming from dashboard is not supported and we
-            // don't want to access the camera without a reason
-            if (!_this5._isMobile && constraints.video) {
-                tracer.trace('connect - deleting video for non mobile');
-                delete constraints.video;
-            }
-
-            _this5._constraints = constraints;
-
-            var clientType = _this5._isMobile ? _constants.CLIENT_TYPES.PUBLISHER : _constants.CLIENT_TYPES.SUBSCRIBER;
-
-            tracer.trace('connect - emitting joinRoom', {
-                clientType: clientType,
-                sessionId: _this5._credentials.sessionId
-            });
-            _this5._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.JOIN_ROOM, {
-                clientType: clientType,
-                sessionId: _this5._credentials.sessionId
-            });
-        }).catch(function (error) {
-            tracer.trace('connect error', error);
-            _this5.emit(_session.EVENTS.EXCEPTION, { source: 'connect', error: error });
-            throw error;
+  }, {
+    key: "connect",
+    value: function connect() {
+      var _this5 = this;
+
+      tracer.trace('connect');
+      return this._connectSocket(this._credentials.url).then(function () {
+        tracer.trace('Socket connected getting constraints');
+        return (0, _helper.getMediaConstraints)({
+          resolution: _this5._resolution,
+          deviceOpts: _this5._deviceOpts
         });
-    };
-
-    TurnWebRTCSession.prototype._createRTCPeerConnection = function _createRTCPeerConnection(peerId) {
-        var _this6 = this;
-
-        tracer.trace('_createRTCPeerConnection');
-        return this._connectRTCPeer({
-            constraints: this._constraints,
-            configuration: this._configuration,
-            sessionId: this._credentials.sessionId,
-            isMobile: this._isMobile,
-            peerId: peerId
-        }).then(function (pc) {
-            tracer.trace('peer connection created');
-
-            if (_this6._isMobile) {
-                pc.peerConnection.getLocalStreams().forEach(function (stream) {
-                    if (!_this6.publisher) {
-                        stream.getTracks().forEach(_this6._setTrackStateTo(false));
-                    }
-                });
-            }
+      }).then(function (constraints) {
+        tracer.trace('connect - constraints', constraints); // streaming from dashboard is not supported and we
+        // don't want to access the camera without a reason
 
-            pc.peerConnection.onaddstream = function (_ref10) {
-                var stream = _ref10.stream;
-
-                tracer.trace('peer connection onaddstream', stream);
-                var tsStream = new _stream.TsWebRTCStream(_this6, stream);
+        if (!_this5._isMobile && constraints.video) {
+          tracer.trace('connect - deleting video for non mobile');
+          delete constraints.video;
+        }
 
-                _this6.emit(_session.EVENTS.STREAM_CREATED, tsStream);
-            };
+        _this5._constraints = constraints;
+        var clientType = _this5._isMobile ? _constants.CLIENT_TYPES.PUBLISHER : _constants.CLIENT_TYPES.SUBSCRIBER;
+        tracer.trace('connect - emitting joinRoom', {
+          clientType: clientType,
+          sessionId: _this5._credentials.sessionId
+        });
 
-            return pc;
+        _this5._socket.emit(_constants.SOCKET_EVENTS.OUTGOING.JOIN_ROOM, {
+          clientType: clientType,
+          sessionId: _this5._credentials.sessionId
         });
-    };
+      })["catch"](function (error) {
+        tracer.trace('connect error', error);
 
-    TurnWebRTCSession.prototype._toggleAllStreams = function _toggleAllStreams(state) {
-        var _this7 = this;
+        _this5.emit(_session.EVENTS.EXCEPTION, {
+          source: 'connect',
+          error: error
+        });
 
-        if (this._isMobile) {
-            _.forEach(this._pcs, function (pc) {
-                pc.peerConnection.getLocalStreams().forEach(function (stream) {
-                    stream.getTracks().forEach(_this7._setTrackStateTo(state));
-                });
-            });
+        throw error;
+      });
+    }
+  }, {
+    key: "_createRTCPeerConnection",
+    value: function _createRTCPeerConnection(peerId) {
+      var _this6 = this;
+
+      tracer.trace('_createRTCPeerConnection');
+      return this._connectRTCPeer({
+        constraints: this._constraints,
+        configuration: this._configuration,
+        sessionId: this._credentials.sessionId,
+        isMobile: this._isMobile,
+        peerId: peerId
+      }).then(function (pc) {
+        tracer.trace('peer connection created');
+
+        if (_this6._isMobile) {
+          pc.peerConnection.getLocalStreams().forEach(function (stream) {
+            if (!_this6.publisher) {
+              stream.getTracks().forEach(_this6._setTrackStateTo(false));
+            }
+          });
         }
-    };
 
-    TurnWebRTCSession.prototype._stopStream = function _stopStream(pc) {
-        if (this._isMobile) {
-            pc.peerConnection.getLocalStreams().forEach(function (stream) {
-                stream.getTracks().forEach(function (track) {
-                    return track.stop();
-                });
-            });
-        }
-    };
+        pc.peerConnection.onaddstream = function (_ref10) {
+          var stream = _ref10.stream;
+          tracer.trace('peer connection onaddstream', stream);
+          var tsStream = new _stream.TsWebRTCStream(_this6, stream);
 
-    TurnWebRTCSession.prototype._stopAllStreams = function _stopAllStreams() {
-        var _this8 = this;
+          _this6.emit(_session.EVENTS.STREAM_CREATED, tsStream);
+        };
+
+        return pc;
+      });
+    }
+  }, {
+    key: "_toggleAllStreams",
+    value: function _toggleAllStreams(state) {
+      var _this7 = this;
 
+      if (this._isMobile) {
         _.forEach(this._pcs, function (pc) {
-            return _this8._stopStream(pc);
+          pc.peerConnection.getLocalStreams().forEach(function (stream) {
+            stream.getTracks().forEach(_this7._setTrackStateTo(state));
+          });
         });
-    };
-
+      }
+    }
+  }, {
+    key: "_stopStream",
+    value: function _stopStream(pc) {
+      if (this._isMobile) {
+        pc.peerConnection.getLocalStreams().forEach(function (stream) {
+          stream.getTracks().forEach(function (track) {
+            return track.stop();
+          });
+        });
+      }
+    }
+  }, {
+    key: "_stopAllStreams",
+    value: function _stopAllStreams() {
+      var _this8 = this;
+
+      _.forEach(this._pcs, function (pc) {
+        return _this8._stopStream(pc);
+      });
+    }
     /**
      * Close all media streams, disconnect RTCPeerConnection and socket.io
      *
@@ -593,63 +638,75 @@ var TurnWebRTCSession = exports.TurnWebRTCSession = function (_TsMediaSession) {
      * @fires SESSION_EVENTS#DISCONNECTED
      */
 
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      var _this9 = this;
 
-    TurnWebRTCSession.prototype.disconnect = function disconnect() {
-        var _this9 = this;
+      tracer.trace('disconnect');
+      return Promise.resolve().then(function () {
+        if (_this9.destroyed) {
+          return null;
+        }
 
-        tracer.trace('disconnect');
-        return Promise.resolve().then(function () {
-            if (_this9.destroyed) {
-                return null;
-            }
+        _this9._stopAllStreams();
 
-            _this9._stopAllStreams();
+        _.forEach(_this9._pcs, function (_ref11) {
+          var peerConnection = _ref11.peerConnection;
+          return peerConnection.close();
+        });
 
-            _.forEach(_this9._pcs, function (_ref11) {
-                var peerConnection = _ref11.peerConnection;
-                return peerConnection.close();
-            });
-            _this9._pcs = {};
-            _this9._socket.disconnect();
+        _this9._pcs = {};
 
-            var event = { reason: 'disconnected' };
+        _this9._socket.disconnect();
 
-            _this9.emit(_session.EVENTS.DISCONNECTED, event);
+        var event = {
+          reason: 'disconnected'
+        };
 
-            return event;
-        });
-    };
+        _this9.emit(_session.EVENTS.DISCONNECTED, event);
 
-    TurnWebRTCSession.prototype._waitForPublishingApproval = function _waitForPublishingApproval(caller, cb) {
-        tracer.trace('_waitForPublishingApproval');
-        try {
-            var pc = _.get(caller, '_lastPc.peerConnection');
+        return event;
+      });
+    }
+  }, {
+    key: "_waitForPublishingApproval",
+    value: function _waitForPublishingApproval(caller, cb) {
+      tracer.trace('_waitForPublishingApproval');
 
-            if (!pc) {
-                throw new Error('No peer connection for publishing');
-            }
+      try {
+        var pc = _.get(caller, '_lastPc.peerConnection');
 
-            //
-            // Get media streams that were created on session initialization
-            //
-            var mediaStream = pc.getLocalStreams()[0];
+        if (!pc) {
+          throw new Error('No peer connection for publishing');
+        } //
+        // Get media streams that were created on session initialization
+        //
 
-            if (mediaStream) {
-                return cb(null, mediaStream);
-            }
 
-            if (caller.lastError === 'NotAllowedError') {
-                return cb({ code: 1500, name: 'NotAllowedError' });
-            } else if (caller.lastError === 'PermissionDismissedError') {
-                return cb({ code: 8, name: 'PermissionDismissedError' });
-            }
+        var mediaStream = pc.getLocalStreams()[0];
 
-            setTimeout(caller._waitForPublishingApproval, _constants.PUBLISH_APPROVAL_CHECK_INTERVAL, caller, cb);
-        } catch (err) {
-            return cb(err);
+        if (mediaStream) {
+          return cb(null, mediaStream);
+        }
+
+        if (caller.lastError === 'NotAllowedError') {
+          return cb({
+            code: 1500,
+            name: 'NotAllowedError'
+          });
+        } else if (caller.lastError === 'PermissionDismissedError') {
+          return cb({
+            code: 8,
+            name: 'PermissionDismissedError'
+          });
         }
-    };
 
+        setTimeout(caller._waitForPublishingApproval, _constants.PUBLISH_APPROVAL_CHECK_INTERVAL, caller, cb);
+      } catch (err) {
+        return cb(err);
+      }
+    }
     /**
      * Create new TsMediaPublisher instance
      *
@@ -670,63 +727,55 @@ var TurnWebRTCSession = exports.TurnWebRTCSession = function (_TsMediaSession) {
      * @see TsMediaPublisher
      */
 
+  }, {
+    key: "createPublisher",
+    value: function createPublisher(target, params) {
+      var _this10 = this;
 
-    TurnWebRTCSession.prototype.createPublisher = function createPublisher(target, params) {
-        var _this10 = this;
-
-        if (!params) {
-            params = target;
-            target = null;
-        }
-
-        tracer.trace('createPublisher');
-
-        return (this._lastPc ? Promise.resolve() : Promise.delay(_constants.WAIT_FOR_PC_INTERVAL)).then(function () {
-            return new Promise(function (resolve, reject) {
-                _this10._waitForPublishingApproval(_this10, function (err, mediaStream) {
-                    if (err) {
-                        return reject(err);
-                    }
-
-                    return resolve(mediaStream);
-                });
-            });
-        }).then(function (mediaStream) {
-            //
-            // Get tracks that are related to the publisher (audio or video)
-            //
-            var tracks = _this10._lastPc.peerConnection.getLocalStreams().reduce(function (result, mediaStream) {
-                mediaStream.getTracks().filter(function (track) {
-                    return track.kind === 'video' && params.videoDevice || track.kind === 'audio' && params.audioDevice;
-                }).forEach(function (track) {
-                    return result.push(track);
-                });
-
-                return result;
-            }, []);
-
-            var tsstream = new _stream.TsWebRTCStream(_this10, mediaStream, params.name);
-
-            tsstream.remote = false;
-
-            var publisher = new _publisher.TsMediaPublisher(_this10, {
-                stream: tsstream,
-                tracks: tracks,
-                videoParams: params.videoParams,
-
-                videoHeight: tsstream.videoDimensions.height,
-                videoWidth: tsstream.videoDimensions.width,
-
-                _target: target
-            });
+      if (!params) {
+        params = target;
+        target = null;
+      }
 
-            tsstream.publisher = publisher;
-            _this10.publisher = publisher;
+      tracer.trace('createPublisher');
+      return (this._lastPc ? Promise.resolve() : Promise.delay(_constants.WAIT_FOR_PC_INTERVAL)).then(function () {
+        return new Promise(function (resolve, reject) {
+          _this10._waitForPublishingApproval(_this10, function (err, mediaStream) {
+            if (err) {
+              return reject(err);
+            }
 
-            return publisher;
+            return resolve(mediaStream);
+          });
         });
-    };
-
+      }).then(function (mediaStream) {
+        //
+        // Get tracks that are related to the publisher (audio or video)
+        //
+        var tracks = _this10._lastPc.peerConnection.getLocalStreams().reduce(function (result, mediaStream) {
+          mediaStream.getTracks().filter(function (track) {
+            return track.kind === 'video' && params.videoDevice || track.kind === 'audio' && params.audioDevice;
+          }).forEach(function (track) {
+            return result.push(track);
+          });
+          return result;
+        }, []);
+
+        var tsstream = new _stream.TsWebRTCStream(_this10, mediaStream, params.name);
+        tsstream.remote = false;
+        var publisher = new _publisher.TsMediaPublisher(_this10, {
+          stream: tsstream,
+          tracks: tracks,
+          videoParams: params.videoParams,
+          videoHeight: tsstream.videoDimensions.height,
+          videoWidth: tsstream.videoDimensions.width,
+          _target: target
+        });
+        tsstream.publisher = publisher;
+        _this10.publisher = publisher;
+        return publisher;
+      });
+    }
     /**
      * Publish stream from previously create TsMediaPublisher instance.
      *
@@ -745,94 +794,96 @@ var TurnWebRTCSession = exports.TurnWebRTCSession = function (_TsMediaSession) {
      * @see TsMediaPublisher#publish
      */
 
+  }, {
+    key: "publish",
+    value: function publish(publisher) {
+      var _this11 = this;
 
-    TurnWebRTCSession.prototype.publish = function publish(publisher) {
-        var _this11 = this;
+      tracer.trace('publish');
+      return Promise.resolve().then(function () {
+        if (!publisher) {
+          return;
+        }
 
-        tracer.trace('publish');
-        return Promise.resolve().then(function () {
-            if (!publisher) {
-                return;
-            }
+        publisher.emit(_publisher.EVENTS.STREAM_CREATED, publisher.stream);
 
-            publisher.emit(_publisher.EVENTS.STREAM_CREATED, publisher.stream);
-            _this11.emit(_session.EVENTS.STREAM_PROPERTY_CHANGED, {
-                stream: publisher.stream,
-                property: 'hasVideo',
-                value: publisher.stream.hasVideo
-            });
-            _this11.emit(_session.EVENTS.STREAM_PROPERTY_CHANGED, {
-                stream: publisher.stream,
-                property: 'hasAudio',
-                value: publisher.stream.hasAudio
-            });
+        _this11.emit(_session.EVENTS.STREAM_PROPERTY_CHANGED, {
+          stream: publisher.stream,
+          property: 'hasVideo',
+          value: publisher.stream.hasVideo
+        });
 
-            if (_this11.publisher._element) {
-                return;
-            }
+        _this11.emit(_session.EVENTS.STREAM_PROPERTY_CHANGED, {
+          stream: publisher.stream,
+          property: 'hasAudio',
+          value: publisher.stream.hasAudio
+        });
 
-            if (publisher._target) {
-                //
-                // New video element where publishing video stream will be rendered
-                //
-                var video = document.createElement('video');
+        if (_this11.publisher._element) {
+          return;
+        }
 
-                //Currently this code is used only in mobile, so when publishing, then we always need only video track
-                //to set to video element. Otherwise, when VOIP enabled, technician side will hear himself through this video element.
-                var videoTracks = publisher.stream._mediaStream.getVideoTracks();
+        if (publisher._target) {
+          //
+          // New video element where publishing video stream will be rendered
+          //
+          var video = document.createElement('video'); //Currently this code is used only in mobile, so when publishing, then we always need only video track
+          //to set to video element. Otherwise, when VOIP enabled, technician side will hear himself through this video element.
 
-                if (!isIE11) {
-                    video.srcObject = new MediaStream(videoTracks);
-                }
+          var videoTracks = publisher.stream._mediaStream.getVideoTracks();
 
-                video.playsInline = true;
-                video.autoplay = true;
+          if (!isIE11) {
+            video.srcObject = new MediaStream(videoTracks);
+          }
 
-                if (_this11._isMobile) {
-                    video.muted = true;
-                }
+          video.playsInline = true;
+          video.autoplay = true;
 
-                if (isIE11) {
-                    publisher._target.appendChild(video);
-                    publisher._element = attachMediaStream(video, publisher.stream._mediaStream);
-                }
+          if (_this11._isMobile) {
+            video.muted = true;
+          }
 
-                var params = _.assign({}, {
-                    fitMode: 'contain',
-                    insertMode: 'append',
-                    mirror: false,
-                    resolution: '480x640',
-                    width: '100%',
-                    height: '100%'
-                }, publisher.videoParams);
-
-                var elementHeight = typeof params.height === 'string' ? params.height : params.height + 'px';
-                var elementWidth = typeof params.width === 'string' ? params.width : params.width + 'px';
-
-                _.assign((isIE11 ? publisher._element : video).style, {
-                    height: elementHeight,
-                    width: elementWidth,
-
-                    position: 'relative',
-                    'object-fit': params.fitMode
-                });
-
-                if (!isIE11) {
-                    publisher._target.appendChild(video);
-                    publisher._element = video;
-                }
+          if (isIE11) {
+            publisher._target.appendChild(video);
 
-                publisher.stream.setupDimensionsListener(video);
-            }
+            publisher._element = attachMediaStream(video, publisher.stream._mediaStream);
+          }
+
+          var params = _.assign({}, {
+            fitMode: 'contain',
+            insertMode: 'append',
+            mirror: false,
+            resolution: '480x640',
+            width: '100%',
+            height: '100%'
+          }, publisher.videoParams);
+
+          var elementHeight = typeof params.height === 'string' ? params.height : params.height + 'px';
+          var elementWidth = typeof params.width === 'string' ? params.width : params.width + 'px';
+
+          _.assign((isIE11 ? publisher._element : video).style, {
+            height: elementHeight,
+            width: elementWidth,
+            position: 'relative',
+            'object-fit': params.fitMode
+          });
+
+          if (!isIE11) {
+            publisher._target.appendChild(video);
+
+            publisher._element = video;
+          }
+
+          publisher.stream.setupDimensionsListener(video);
+        } //
+        // Enable (unpause) all media tracks related to publisher.
+        // They are sending data to the server from this moment.
+        //
 
-            //
-            // Enable (unpause) all media tracks related to publisher.
-            // They are sending data to the server from this moment.
-            //
-            _this11._toggleAllStreams(true);
-        });
-    };
 
+        _this11._toggleAllStreams(true);
+      });
+    }
     /**
      * Unpublish stream and destroy publisher's view.
      *
@@ -849,32 +900,28 @@ var TurnWebRTCSession = exports.TurnWebRTCSession = function (_TsMediaSession) {
      * @see TsMediaPublisher#destroy
      */
 
+  }, {
+    key: "destroyPublisher",
+    value: function destroyPublisher(publisher) {
+      var _this12 = this;
 
-    TurnWebRTCSession.prototype.destroyPublisher = function destroyPublisher(publisher) {
-        var _this12 = this;
-
-        tracer.trace('destroyPublisher');
-        return new Promise(function (resolve) {
-            _this12._toggleAllStreams(false);
-
-            if (publisher._element) {
-                publisher._element.remove();
-            }
-
-            _this12.publisher = null;
-            publisher.emit(_publisher.EVENTS.DESTROYED);
+      tracer.trace('destroyPublisher');
+      return new Promise(function (resolve) {
+        _this12._toggleAllStreams(false);
 
-            return resolve();
-        });
-    };
-
-    _createClass(TurnWebRTCSession, [{
-        key: 'id',
-        get: function get() {
-            return this._credentials.sessionId;
+        if (publisher._element) {
+          publisher._element.remove();
         }
-    }]);
 
-    return TurnWebRTCSession;
+        _this12.publisher = null;
+        publisher.emit(_publisher.EVENTS.DESTROYED);
+        return resolve();
+      });
+    }
+  }]);
+
+  return TurnWebRTCSession;
 }(_session.TsMediaSession);
+
+exports.TurnWebRTCSession = TurnWebRTCSession;
 //# sourceMappingURL=session-turn.js.map