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

package/lib/oldCode/service.js

@@ -1,88 +1,99 @@
-'use strict';
+"use strict";
 
-exports.__esModule = true;
-exports.TsMediaService = exports.EVENTS = 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.TsMediaService = exports.EVENTS = void 0;
 
-var _tsEnvironmentDetect = require('@techsee/techsee-common/lib/helpers/ts-environment-detect');
+var _tsEnvironmentDetect = require("@techsee/techsee-common/lib/helpers/ts-environment-detect");
 
-var _eventEmitter = require('./event-emitter');
+var _eventEmitter = require("./event-emitter");
 
-var _session = require('./session');
+var _session = require("./session");
 
-var _session2 = require('./opentok/session');
+var _session2 = require("./opentok/session");
 
-var _session3 = require('./webrtc/session');
+var _session3 = require("./webrtc/session");
 
-var _helper = require('./webrtc/helper');
+var _helper = require("./webrtc/helper");
 
-var _constants = require('./constants');
+var _constants = require("./constants");
 
-var _constants2 = require('./webrtc/constants');
+var _constants2 = require("./webrtc/constants");
 
-var _tracer = require('./tracer');
+var _tracer = require("./tracer");
 
 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); }
+
+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 tracer = (0, _tracer.getTracer)();
 var environmentDetect = new _tsEnvironmentDetect.TsEnvironmentDetect();
 var isIE11 = environmentDetect.isIE11();
 
 if (isIE11) {
-    require('./webrtc/webrtc-ie-shim.js');
+  require('./webrtc/webrtc-ie-shim.js');
 } else if (!(environmentDetect.isChrome() && environmentDetect.majorVersion() < 49)) {
-    require('webrtc-adapter/src/js/adapter_core'); // eslint-disable-line global-require
+  require('webrtc-adapter/src/js/adapter_core'); // eslint-disable-line global-require
+
 }
 
 function _isOTDefined() {
-    try {
-        return !!OT;
-    } catch (e) {
-        return false;
-    }
+  try {
+    return !!OT;
+  } catch (e) {
+    return false;
+  }
 }
 
 function _waitForOT() {
-    if (_isOTDefined()) {
-        return Promise.resolve();
+  if (_isOTDefined()) {
+    return Promise.resolve();
+  }
+
+  var isDefined = false;
+  return Promise.reduce(new Array(_constants.WAIT_FOR_OPENTOK_INITIALIZATION_MAX_ATTEMPTS), function () {
+    if (isDefined || _isOTDefined()) {
+      isDefined = true;
+      return Promise.resolve();
     }
 
-    var isDefined = false;
-
-    return Promise.reduce(new Array(_constants.WAIT_FOR_OPENTOK_INITIALIZATION_MAX_ATTEMPTS), function () {
-        if (isDefined || _isOTDefined()) {
-            isDefined = true;
-
-            return Promise.resolve();
-        }
-
-        return Promise.delay(_constants.WAIT_FOR_OPENTOK_INITIALIZATION_INTERVAL);
-    }, 0).then(function () {
-        return isDefined || Promise.reject('OT is undefined');
-    });
+    return Promise.delay(_constants.WAIT_FOR_OPENTOK_INITIALIZATION_INTERVAL);
+  }, 0).then(function () {
+    return isDefined || Promise.reject('OT is undefined');
+  });
 }
-
 /**
  * @enum SERVICE_EVENTS
  */
+
+
 var SERVICE_EVENTS = {
-    SESSION_CREATED: 'SESSION_CREATED',
-    EXCEPTION: 'EXCEPTION'
+  SESSION_CREATED: 'SESSION_CREATED',
+  EXCEPTION: 'EXCEPTION'
 };
-
 exports.EVENTS = SERVICE_EVENTS;
-
-
 var sessions = [];
 var latestLocalStream = null;
 var userMediaPromise = null;
-
 /**
  * The top of hierarchy and the entry point of the TsMedia Service.
  *
@@ -91,90 +102,102 @@ var userMediaPromise = null;
  * @extends EventEmitter
  */
 
-var TsMediaServiceFacade = function (_EventEmitter) {
-    _inherits(TsMediaServiceFacade, _EventEmitter);
+var TsMediaServiceFacade = /*#__PURE__*/function (_EventEmitter) {
+  _inherits(TsMediaServiceFacade, _EventEmitter);
 
-    function TsMediaServiceFacade() {
-        _classCallCheck(this, TsMediaServiceFacade);
+  var _super = _createSuper(TsMediaServiceFacade);
 
-        var _this = _possibleConstructorReturn(this, _EventEmitter.call(this));
+  function TsMediaServiceFacade() {
+    var _this;
 
-        _this.createLocalMediaStream = _this.createLocalMediaStream.bind(_this);
-        _this.destroyLocalMediaStream = _this.destroyLocalMediaStream.bind(_this);
-        return _this;
-    }
-
-    /**
-     * All created sessoins
-     *
-     * @member { Object }
-     * @memberof TsMediaService
-     * @type { Array<TsMediaSession> }
-     */
+    _classCallCheck(this, TsMediaServiceFacade);
 
+    _this = _super.call(this);
+    _this.createLocalMediaStream = _this.createLocalMediaStream.bind(_assertThisInitialized(_this));
+    _this.destroyLocalMediaStream = _this.destroyLocalMediaStream.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  /**
+   * All created sessoins
+   *
+   * @member { Object }
+   * @memberof TsMediaService
+   * @type { Array<TsMediaSession> }
+   */
 
-    TsMediaServiceFacade.prototype.createLocalMediaStream = function createLocalMediaStream(constraints) {
-        tracer.trace('createLocalMediaStream');
-        if (userMediaPromise) {
-            return userMediaPromise;
-        }
-
-        if (latestLocalStream) {
-            var videoTrack = latestLocalStream.getVideoTracks();
-            if (videoTrack.length > 0 && videoTrack[0].readyState === 'live') {
-                return Promise.resolve(latestLocalStream);
-            } else {
-                this.destroyLocalMediaStream();
-            }
-        }
 
-        userMediaPromise = new Promise(function (resolve, reject) {
-            try {
-                tracer.trace('createLocalMediaStream inside promise');
-
-                navigator.mediaDevices.getUserMedia(constraints).then(function (stream) {
-                    latestLocalStream = stream;
-                    userMediaPromise = null;
-                    resolve(stream);
-                }).catch(function (err) {
-                    userMediaPromise = null;
-                    reject(err);
-                });
-            } catch (e) {
-                userMediaPromise = null;
-                reject(e);
-            }
-        });
+  _createClass(TsMediaServiceFacade, [{
+    key: "sessions",
+    get: function get() {
+      return sessions;
+    }
+  }, {
+    key: "createLocalMediaStream",
+    value: function createLocalMediaStream(constraints) {
+      tracer.trace('createLocalMediaStream');
 
+      if (userMediaPromise) {
         return userMediaPromise;
-    };
-
-    TsMediaServiceFacade.prototype.destroyLocalMediaStream = function destroyLocalMediaStream() {
-        tracer.trace('Destroy local streams');
-        if (latestLocalStream) {
-            latestLocalStream.getTracks().forEach(function (track) {
-                track.stop();
-            });
-        }
-
-        latestLocalStream = null;
-    };
+      }
 
-    TsMediaServiceFacade.prototype.toggleMicrophone = function toggleMicrophone() {
-        var enableMic = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (latestLocalStream) {
+        var videoTrack = latestLocalStream.getVideoTracks();
 
-        if (!latestLocalStream) {
-            return Promise.resolve();
+        if (videoTrack.length > 0 && videoTrack[0].readyState === 'live') {
+          return Promise.resolve(latestLocalStream);
+        } else {
+          this.destroyLocalMediaStream();
         }
-
-        var audioTracks = latestLocalStream.getAudioTracks();
-        if (audioTracks.length > 0) {
-            audioTracks[0].enabled = enableMic;
+      }
+
+      userMediaPromise = new Promise(function (resolve, reject) {
+        try {
+          tracer.trace('createLocalMediaStream inside promise');
+          navigator.mediaDevices.getUserMedia(constraints).then(function (stream) {
+            latestLocalStream = stream;
+            userMediaPromise = null;
+            resolve(stream);
+          })["catch"](function (err) {
+            userMediaPromise = null;
+            reject(err);
+          });
+        } catch (e) {
+          userMediaPromise = null;
+          reject(e);
         }
+      });
+      return userMediaPromise;
+    }
+  }, {
+    key: "destroyLocalMediaStream",
+    value: function destroyLocalMediaStream() {
+      tracer.trace('Destroy local streams');
+
+      if (latestLocalStream) {
+        latestLocalStream.getTracks().forEach(function (track) {
+          track.stop();
+        });
+      }
+
+      latestLocalStream = null;
+    }
+  }, {
+    key: "toggleMicrophone",
+    value: function toggleMicrophone() {
+      var enableMic = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
+      if (!latestLocalStream) {
         return Promise.resolve();
-    };
+      }
 
+      var audioTracks = latestLocalStream.getAudioTracks();
+
+      if (audioTracks.length > 0) {
+        audioTracks[0].enabled = enableMic;
+      }
+
+      return Promise.resolve();
+    }
     /**
      * Enumerate available media devices
      *
@@ -185,27 +208,27 @@ var TsMediaServiceFacade = function (_EventEmitter) {
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo | MediaDeviceInfo documentation}
      */
 
+  }, {
+    key: "getDevices",
+    value: function getDevices() {
+      if (typeof OT !== 'undefined' && OT && OT.getDevices) {
+        return new Promise(function (resolve, reject) {
+          OT.getDevices(function (error, devices) {
+            if (error) {
+              return reject(error);
+            }
 
-    TsMediaServiceFacade.prototype.getDevices = function getDevices() {
-        if (typeof OT !== 'undefined' && OT && OT.getDevices) {
-            return new Promise(function (resolve, reject) {
-                OT.getDevices(function (error, devices) {
-                    if (error) {
-                        return reject(error);
-                    }
-
-                    return resolve(devices);
-                });
-            });
-        }
-
-        if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
-            return navigator.mediaDevices.enumerateDevices();
-        }
+            return resolve(devices);
+          });
+        });
+      }
 
-        return Promise.reject('getDevices is not supported');
-    };
+      if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
+        return navigator.mediaDevices.enumerateDevices();
+      }
 
+      return Promise.reject('getDevices is not supported');
+    }
     /**
      * Verifies camera access
      *
@@ -216,27 +239,28 @@ var TsMediaServiceFacade = function (_EventEmitter) {
      * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo | MediaDeviceInfo documentation}
      */
 
-
-    TsMediaServiceFacade.prototype.verifyCameraAccess = function verifyCameraAccess(deviceOpts) {
-        return (0, _helper.getHighestResolutionStream)(deviceOpts);
-    };
-
-    TsMediaServiceFacade.prototype.isVideoPlaySupportedOnDevice = function isVideoPlaySupportedOnDevice() {
-        if (!isIE11) {
-            return Promise.resolve(true);
-        }
-
-        if (!!window.WebRTCAdapter) {
-            return Promise.resolve(true);
-        }
-
-        if (window.OT && window.OTPlugin && window.OTPlugin.isInstalled && window.OTPlugin.isInstalled()) {
-            return Promise.resolve(true);
-        }
-
-        return Promise.resolve(false);
-    };
-
+  }, {
+    key: "verifyCameraAccess",
+    value: function verifyCameraAccess(deviceOpts) {
+      return (0, _helper.getHighestResolutionStream)(deviceOpts);
+    }
+  }, {
+    key: "isVideoPlaySupportedOnDevice",
+    value: function isVideoPlaySupportedOnDevice() {
+      if (!isIE11) {
+        return Promise.resolve(true);
+      }
+
+      if (!!window.WebRTCAdapter) {
+        return Promise.resolve(true);
+      }
+
+      if (window.OT && window.OTPlugin && window.OTPlugin.isInstalled && window.OTPlugin.isInstalled()) {
+        return Promise.resolve(true);
+      }
+
+      return Promise.resolve(false);
+    }
     /**
      * Init WebRTC or OpenTok session depends on required type.
      *
@@ -257,139 +281,137 @@ var TsMediaServiceFacade = function (_EventEmitter) {
      * @returns { Promise<TsMediaSession> }
      */
 
-
-    TsMediaServiceFacade.prototype.initSession = function initSession() {
-        var _this2 = this;
-
-        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
-            isMobile: false,
-            resolution: '640x480'
-        },
-            mediaServiceType = _ref.mediaServiceType,
-            isMobile = _ref.isMobile,
-            resolution = _ref.resolution,
-            credentials = _ref.credentials,
-            deviceOpts = _ref.deviceOpts,
-            isLoopback = _ref.isLoopback;
-
-        return Promise.resolve().then(function () {
-            if (mediaServiceType === _constants.MEDIA_SERVICE_TYPES.MEDIASERVER) {
-                //
-                // KMS CONNECTION
-                //
-                return Promise.resolve().then(function () {
-                    var sessionOptions = {
-                        isMobile: isMobile,
-                        resolution: resolution,
-
-                        credentials: credentials.tsMediaServer,
-                        deviceOpts: deviceOpts || { audio: true, video: true }
-                    };
-
-                    return new _session3.KMSWebRTCSession(sessionOptions);
-                });
-            } else if (mediaServiceType === _constants.MEDIA_SERVICE_TYPES.TURNSERVER || isLoopback) {
-                //
-                // TURN-based connection or loopback (no connection)
-                //
-                return Promise.resolve().then(function () {
-                    var creds = null;
-
-                    if (!isLoopback) {
-                        creds = mediaServiceType === _constants.MEDIA_SERVICE_TYPES.TURNSERVER ? credentials.turnServer : credentials.opentok;
-                    }
-
-                    var sessionOptions = {
-                        isMobile: isMobile,
-                        resolution: resolution,
-                        credentials: creds,
-                        deviceOpts: deviceOpts || { audio: true, video: true }
-                    };
-
-                    if (isLoopback) {
-                        return new _session3.LoopbackWebRTCSession(sessionOptions);
-                    } else if (isMobile) {
-                        return new _session3.TurnWebRTCSession(sessionOptions, _this2.createLocalMediaStream);
-                    } else {
-                        return _this2.getTurnMediaSessionV2(sessionOptions).then(function (mediaSession) {
-                            _this2.subscribeTurnSessionEvents(mediaSession);
-
-                            return mediaSession;
-                        });
-                    }
-                });
+  }, {
+    key: "initSession",
+    value: function initSession() {
+      var _this2 = this;
+
+      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        isMobile: false,
+        resolution: '640x480'
+      },
+          mediaServiceType = _ref.mediaServiceType,
+          isMobile = _ref.isMobile,
+          resolution = _ref.resolution,
+          credentials = _ref.credentials,
+          deviceOpts = _ref.deviceOpts,
+          isLoopback = _ref.isLoopback;
+
+      return Promise.resolve().then(function () {
+        if (mediaServiceType === _constants.MEDIA_SERVICE_TYPES.MEDIASERVER) {
+          //
+          // KMS CONNECTION
+          //
+          return Promise.resolve().then(function () {
+            var sessionOptions = {
+              isMobile: isMobile,
+              resolution: resolution,
+              credentials: credentials.tsMediaServer,
+              deviceOpts: deviceOpts || {
+                audio: true,
+                video: true
+              }
+            };
+            return new _session3.KMSWebRTCSession(sessionOptions);
+          });
+        } else if (mediaServiceType === _constants.MEDIA_SERVICE_TYPES.TURNSERVER || isLoopback) {
+          //
+          // TURN-based connection or loopback (no connection)
+          //
+          return Promise.resolve().then(function () {
+            var creds = null;
+
+            if (!isLoopback) {
+              creds = mediaServiceType === _constants.MEDIA_SERVICE_TYPES.TURNSERVER ? credentials.turnServer : credentials.opentok;
             }
 
-            //
-            // OT CONNECTION (default mediaServiceType)
-            //
-            return Promise.resolve().then(function () {
-                return _waitForOT();
-            }).then(function () {
-                var sessionOptions = {
-                    isMobile: isMobile,
-                    resolution: resolution,
-
-                    credentials: credentials.opentok
-                };
-
-                return new _session2.TsOpenTokSession(sessionOptions);
-            });
-        }).then(function (session) {
-            _this2.emit(SERVICE_EVENTS.SESSION_CREATED, session);
-
-            sessions.push(session);
-
-            return session;
-        });
-    };
-
-    TsMediaServiceFacade.prototype.getTurnMediaSessionV2 = function getTurnMediaSessionV2(sessionOptions) {
-        var _this3 = this;
+            var sessionOptions = {
+              isMobile: isMobile,
+              resolution: resolution,
+              credentials: creds,
+              deviceOpts: deviceOpts || {
+                audio: true,
+                video: true
+              }
+            };
 
-        return (0, _helper.getMediaConstraints)({
-            resolution: sessionOptions.resolution,
-            deviceOpts: sessionOptions.deviceOpts
-        }).then(function (constraints) {
-            var clientType = sessionOptions.isMobile ? _constants2.CLIENT_TYPES.INITIATOR : _constants2.CLIENT_TYPES.GUEST;
+            if (isLoopback) {
+              return new _session3.LoopbackWebRTCSession(sessionOptions);
+            } else if (isMobile) {
+              return new _session3.TurnWebRTCSession(sessionOptions, _this2.createLocalMediaStream);
+            } else {
+              return _this2.getTurnMediaSessionV2(sessionOptions).then(function (mediaSession) {
+                _this2.subscribeTurnSessionEvents(mediaSession);
 
-            // streaming from dashboard is not supported and we
-            // don't want to access the camera without a reason
-            if (clientType === _constants2.CLIENT_TYPES.GUEST) {
-                delete constraints.video;
+                return mediaSession;
+              });
             }
+          });
+        } //
+        // OT CONNECTION (default mediaServiceType)
+        //
 
-            var sessionParams = {
-                constraints: constraints,
-                clientType: clientType,
-                credentials: sessionOptions.credentials,
-                streamFactory: _this3.createLocalMediaStream
-            };
 
-            return new _session3.TurnWebRtcSessionV2(sessionParams);
+        return Promise.resolve().then(function () {
+          return _waitForOT();
+        }).then(function () {
+          var sessionOptions = {
+            isMobile: isMobile,
+            resolution: resolution,
+            credentials: credentials.opentok
+          };
+          return new _session2.TsOpenTokSession(sessionOptions);
         });
-    };
+      }).then(function (session) {
+        _this2.emit(SERVICE_EVENTS.SESSION_CREATED, session);
 
-    TsMediaServiceFacade.prototype.subscribeTurnSessionEvents = function subscribeTurnSessionEvents(mediaSession) {
-        var _this4 = this;
+        sessions.push(session);
+        return session;
+      });
+    }
+  }, {
+    key: "getTurnMediaSessionV2",
+    value: function getTurnMediaSessionV2(sessionOptions) {
+      var _this3 = this;
+
+      return (0, _helper.getMediaConstraints)({
+        resolution: sessionOptions.resolution,
+        deviceOpts: sessionOptions.deviceOpts
+      }).then(function (constraints) {
+        var clientType = sessionOptions.isMobile ? _constants2.CLIENT_TYPES.INITIATOR : _constants2.CLIENT_TYPES.GUEST; // streaming from dashboard is not supported and we
+        // don't want to access the camera without a reason
+
+        if (clientType === _constants2.CLIENT_TYPES.GUEST) {
+          delete constraints.video;
+        }
 
-        var disconnectHandler = function disconnectHandler() {
-            _this4.destroyLocalMediaStream();
-            mediaSession.off(_session.SESSION_EVENTS.DISCONNECTED, disconnectHandler);
+        var sessionParams = {
+          constraints: constraints,
+          clientType: clientType,
+          credentials: sessionOptions.credentials,
+          streamFactory: _this3.createLocalMediaStream
         };
+        return new _session3.TurnWebRtcSessionV2(sessionParams);
+      });
+    }
+  }, {
+    key: "subscribeTurnSessionEvents",
+    value: function subscribeTurnSessionEvents(mediaSession) {
+      var _this4 = this;
 
-        mediaSession.on(_session.SESSION_EVENTS.DISCONNECTED, disconnectHandler);
-    };
+      var disconnectHandler = function disconnectHandler() {
+        _this4.destroyLocalMediaStream();
 
-    _createClass(TsMediaServiceFacade, [{
-        key: 'sessions',
-        get: function get() {
-            return sessions;
-        }
-    }]);
+        mediaSession.off(_session.SESSION_EVENTS.DISCONNECTED, disconnectHandler);
+      };
+
+      mediaSession.on(_session.SESSION_EVENTS.DISCONNECTED, disconnectHandler);
+    }
+  }]);
 
-    return TsMediaServiceFacade;
+  return TsMediaServiceFacade;
 }(_eventEmitter.EventEmitter);
 
-var TsMediaService = exports.TsMediaService = new TsMediaServiceFacade();
+var TsMediaService = new TsMediaServiceFacade();
+exports.TsMediaService = TsMediaService;
 //# sourceMappingURL=service.js.map