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

package/lib/MediaServiceBase.js

@@ -1,636 +1,974 @@
 "use strict";
 
-var __assign = undefined && undefined.__assign || function () {
-    __assign = Object.assign || function (t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) {
-                if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-            }
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
+var __assign = void 0 && (void 0).__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
 };
-var __importDefault = undefined && undefined.__importDefault || function (mod) {
-    return mod && mod.__esModule ? mod : { "default": mod };
+
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TechseeMediaServiceBase = void 0;
+
 var filter_1 = __importDefault(require("lodash/filter"));
+
 var cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+
 var values_1 = __importDefault(require("lodash/values"));
+
 var debounce_1 = __importDefault(require("lodash/debounce"));
+
 var includes_1 = __importDefault(require("lodash/includes"));
+
 var events_1 = require("events");
+
 var MediaSubscriber_1 = require("./MediaSubscriber");
+
 var LocalStreamManager_1 = require("./LocalStreamManager");
+
 var TechseeMediaStream_1 = require("./TechseeMediaStream");
+
 var SessionTurn_1 = require("./MediaSession/SessionTurn");
+
 var MediaDomUtils_1 = require("./MediaUtils/MediaDomUtils");
+
 var Compatibility_1 = require("./MediaUtils/Compatibility");
+
 var SessionOpentok_1 = require("./MediaSession/SessionOpentok");
+
 var MediaConstants_1 = require("./MediaConstants");
+
 var guards_1 = require("@techsee/techsee-common/lib/core/guards");
+
+var MediaServer_1 = require("./MediaSession/MediaServer");
+
 var MediaTracer_1 = require("./MediaUtils/MediaTracer");
+
+var MediaSessionBase_1 = require("./MediaSession/MediaSessionBase");
+
 var trace = MediaTracer_1.getMediaTracer('MediaServiceBase');
-var traceStatsInfo = debounce_1.default(trace.info, 1000 * 5, { leading: true, maxWait: 1000 * 30 });
+var traceStatsInfo = debounce_1["default"](trace.info, 1000 * 5, {
+  leading: true,
+  maxWait: 1000 * 30
+});
 var privateEvents;
+
 (function (privateEvents) {
-    privateEvents["STREAM_CREATED"] = "STREAM_CREATED";
-    privateEvents["STREAM_DESTROYED"] = "STREAM_DESTROYED";
+  privateEvents["STREAM_CREATED"] = "STREAM_CREATED";
+  privateEvents["STREAM_DESTROYED"] = "STREAM_DESTROYED";
 })(privateEvents || (privateEvents = {}));
-var TechseeMediaServiceBase = /** @class */function () {
-    function TechseeMediaServiceBase(environment, webRtcSupportInfo) {
-        this._subscribers = new Map();
-        this._publishers = new Map();
-        this._publisherPromises = new Map();
-        this._serviceOptions = null;
-        this._autoReconnectEnabled = true;
-        this._initLocalStreamsPromise = null;
-        this._initServicePromise = null;
-        this._registeredStreams = new Map();
-        this._isVoipEnabled = false;
-        this._session = null;
-        trace.info('TechseeMediaServiceBase created');
-        this.bindClassMethods();
-        this._emitter = new events_1.EventEmitter();
-        this._environment = environment;
-        this._deviceSupportFlags = {
-            videoPlayback: false,
-            hasCamera: false,
-            hasMicrophone: false,
-            webRtcSupportInfo: webRtcSupportInfo
-        };
-        this._localStreamsManager = new LocalStreamManager_1.LocalStreamManager(this._environment);
-        this._sessionStreamsManager = {
-            getMediaStreamForRole: this.getStreamForDestinationRole,
-            addRemoteMediaTrack: this.registerRemoteMediaTrack,
-            removeMediaTrack: this.unregisterRemoteMediaTrack
-        };
+
+var TechseeMediaServiceBase =
+/** @class */
+function () {
+  function TechseeMediaServiceBase(environment, webRtcSupportInfo) {
+    this._subscribers = new Map();
+    this._publishers = new Map();
+    this._publisherPromises = new Map();
+    this._serviceOptions = null;
+    this._isIOS_13_orLater = false;
+    this._isIOS_14_orLater = false;
+    this._autoReconnectEnabled = true;
+    this._initLocalStreamsPromise = null;
+    this._initServicePromise = null;
+    this._registeredStreams = new Map();
+    this._isVoipEnabled = false;
+    this._session = null;
+    trace.info('TechseeMediaServiceBase created');
+    this.bindClassMethods();
+    this._emitter = new events_1.EventEmitter();
+    this._environment = environment;
+    this._deviceSupportFlags = {
+      videoPlayback: false,
+      hasCamera: false,
+      hasMicrophone: false,
+      webRtcSupportInfo: webRtcSupportInfo
+    };
+    this._localStreamsManager = new LocalStreamManager_1.LocalStreamManager(this._environment); // TODO: Hack as IOS 13.3 and above sometimes do not return the video/audio device. This
+    // is a hack to work around the issue until Apple resolve it
+
+    this._isIOS_13_orLater = this._environment.isIOS() && (!this._environment.majorVersion() || this._environment.majorVersion() >= 13);
+    this._isIOS_14_orLater = this._environment.isIOS() && (!this._environment.majorVersion() || this._environment.majorVersion() >= 14);
+    trace.info("TechseeMediaServiceBase: isIOS_13_orLater: " + this._isIOS_13_orLater);
+    trace.info("TechseeMediaServiceBase: isIOS_14_orLater: " + this._isIOS_14_orLater);
+    this._sessionStreamsManager = {
+      getMediaStreamForRole: this.getStreamForDestinationRole,
+      addRemoteMediaTrack: this.registerRemoteMediaTrack,
+      removeMediaTrack: this.unregisterRemoteMediaTrack
+    };
+  }
+
+  Object.defineProperty(TechseeMediaServiceBase.prototype, "deviceSupportInfo", {
+    get: function get() {
+      this.serviceInitGuard(false);
+      return cloneDeep_1["default"](this._deviceSupportFlags);
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(TechseeMediaServiceBase.prototype, "isVoipEnabled", {
+    get: function get() {
+      return this._isVoipEnabled;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(TechseeMediaServiceBase.prototype, "isSessionActive", {
+    get: function get() {
+      return this._session !== null;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(TechseeMediaServiceBase.prototype, "isLocalStreamInitialized", {
+    get: function get() {
+      return this._initLocalStreamsPromise !== null;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  /*
+      Initializes media service. Before using anything from this service it should be initialized first.
+      All of serviceOptions should be retrieved from account settings and by evaluating application state.
+      For example, when initializing service, accountSettings is already loaded, and we know if FS session is audio enabled.
+  */
+
+  TechseeMediaServiceBase.prototype.initMediaService = function (serviceOptions) {
+    var _this = this;
+
+    trace.info('TechseeMediaServiceBase.initMediaService', serviceOptions);
+    var warnMessage = 'Multiple initialization does not supposed to happen. Not rejecting, but check the flow for correctness.';
+
+    if (this._initServicePromise || this._serviceOptions) {
+      console.warn(warnMessage);
+      return this._initServicePromise ? this._initServicePromise : Promise.resolve();
     }
-    Object.defineProperty(TechseeMediaServiceBase.prototype, "deviceSupportInfo", {
-        get: function get() {
-            this.serviceInitGuard(false);
-            return cloneDeep_1.default(this._deviceSupportFlags);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TechseeMediaServiceBase.prototype, "isVoipEnabled", {
-        get: function get() {
-            return this._isVoipEnabled;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TechseeMediaServiceBase.prototype, "isSessionActive", {
-        get: function get() {
-            return this._session !== null;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(TechseeMediaServiceBase.prototype, "isLocalStreamInitialized", {
-        get: function get() {
-            return this._initLocalStreamsPromise !== null;
-        },
-        enumerable: true,
-        configurable: true
+
+    this._serviceOptions = cloneDeep_1["default"](serviceOptions);
+    this._initServicePromise = Promise.all([Compatibility_1.isVideoPlaySupportedOnDevice(this._serviceOptions.mediaServiceType).then(function (isSupported) {
+      return _this._deviceSupportFlags.videoPlayback = isSupported;
+    }), (this._isIOS_14_orLater || !this._deviceSupportFlags.webRtcSupportInfo.isWebRTCSupported ? Promise.resolve([]) : Compatibility_1.enumerateMediaDevices())["catch"](function (error) {
+      trace.warn(error);
+      return [];
+    }).then(function (localDevicesList) {
+      var groupedDevices = {
+        video: filter_1["default"](localDevicesList, function (device) {
+          return device.kind.toLowerCase() === 'videoinput';
+        }),
+        audio: filter_1["default"](localDevicesList, function (device) {
+          return device.kind.toLowerCase() === 'audioinput';
+        })
+      };
+
+      _this._localStreamsManager.setGroupedDevices(groupedDevices);
+
+      _this._deviceSupportFlags.hasCamera = _this._isIOS_13_orLater || groupedDevices.video.length > 0;
+      _this._deviceSupportFlags.hasMicrophone = _this._isIOS_13_orLater || groupedDevices.audio.length > 0;
+    })]).then(function () {
+      return undefined;
     });
-    /*
-        Initializes media service. Before using anything from this service it should be initialized first.
-        All of serviceOptions should be retrieved from account settings and by evaluating application state.
-        For example, when initializing service, accountSettings is already loaded, and we know if FS session is audio enabled.
-    */
-    TechseeMediaServiceBase.prototype.initMediaService = function (serviceOptions) {
-        var _this = this;
-        trace.info('TechseeMediaServiceBase.initMediaService', serviceOptions);
-        var warnMessage = 'Multiple initialization does not supposed to happen. Not rejecting, but check the flow for correctness.';
-        if (this._initServicePromise || this._serviceOptions) {
-            console.warn(warnMessage);
-            return this._initServicePromise ? this._initServicePromise : Promise.resolve();
-        }
-        this._serviceOptions = cloneDeep_1.default(serviceOptions);
-        var isOpenTok = this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.OPENTOK;
-        this._initServicePromise = Promise.all([Compatibility_1.isVideoPlaySupportedOnDevice(isOpenTok).then(function (isSupported) {
-            return _this._deviceSupportFlags.videoPlayback = isSupported;
-        }), Compatibility_1.enumerateMediaDevices().catch(function (error) {
-            trace.warn(error);
-            return [];
-        }).then(function (localDevicesList) {
-            var groupedDevices = {
-                video: filter_1.default(localDevicesList, function (device) {
-                    return device.kind.toLowerCase() === 'videoinput';
-                }),
-                audio: filter_1.default(localDevicesList, function (device) {
-                    return device.kind.toLowerCase() === 'audioinput';
-                })
-            };
-            _this._localStreamsManager.setGroupedDevices(groupedDevices);
-            // TODO: Hack as IOS 13.3 and above sometimes do not return the video/audio device. This
-            // is a hack to work around the issue until Apple resolve it
-            var isIOS_13_orLater = _this._environment.isIOS && (!_this._environment.majorVersion() || _this._environment.majorVersion() >= 13);
-            _this._deviceSupportFlags.hasCamera = isIOS_13_orLater || groupedDevices.video.length > 0;
-            _this._deviceSupportFlags.hasMicrophone = isIOS_13_orLater || groupedDevices.audio.length > 0;
-        })]).then(function () {
-            return undefined;
-        });
-        return this._initServicePromise;
-    };
-    //#region Media Streams Management
-    /*
-        The main method to start the initialization of local media streams.
-        This method can be executed many times and it will insure all calls are synced and only relevant stream will be created.
-        DO NOT USE ANY OTHER METHOD THAT FORCES "navigator.getUserMedia" OTHER THAN THIS ONE.
-     */
-    TechseeMediaServiceBase.prototype.initLocalMediaStreams = function () {
-        this.serviceInitGuard();
-        if (!this._initLocalStreamsPromise) {
-            trace.info('initLocalMediaStreams creating media streams');
-            this._initLocalStreamsPromise = this.getLocalMediaImplementation().catch(function (mediaRequestFailResult) {
-                trace.error('initLocalMediaStreams failure: ', mediaRequestFailResult);
-                throw mediaRequestFailResult;
-            });
-        } else {
-            trace.info('initLocalMediaStreams already done or in progress');
-        }
-        return this._initLocalStreamsPromise;
-    };
-    /*
-        Creates an instance of subscriber that will "listen" to the requested stream.
-        Whenever requested stream is available, subscriber will render it.
-     */
-    TechseeMediaServiceBase.prototype.createSubscriber = function (subscriberParams) {
-        if (this._subscribers.has(subscriberParams.container)) {
-            return Promise.reject('Subscriber for provided DIV element already exists');
-        }
-        var subscriber = new MediaSubscriber_1.TechseeMediaSubscriber(subscriberParams);
-        this._subscribers.set(subscriberParams.container, subscriber);
-        var streamForSubscriber = this.getRegisteredStreamByType(subscriber.streamType);
-        if (streamForSubscriber) {
-            trace.info("Stream for " + subscriberParams.streamType + " is ready.");
-            subscriber.renderStream(streamForSubscriber);
-        } else {
-            trace.info("Stream for " + subscriberParams.streamType + " not created yet");
-        }
-        return Promise.resolve(subscriber);
-    };
-    /*
-        Destroys the subscriber for provided HTML DIV container
-     */
-    TechseeMediaServiceBase.prototype.destroySubscriber = function (container) {
-        if (this._subscribers.has(container)) {
-            var subscriber = this._subscribers.get(container);
-            subscriber.dispose();
-        }
-        this._subscribers.delete(container);
-        return Promise.resolve();
-    };
-    TechseeMediaServiceBase.prototype.onStreamDestroyed = function (callback) {
-        this.registerEventCallback(privateEvents.STREAM_DESTROYED, callback);
-    };
-    TechseeMediaServiceBase.prototype.onStreamCreated = function (callback) {
-        this.registerEventCallback(privateEvents.STREAM_CREATED, callback);
-    };
-    //#endregion Media Streams Management
-    //#region Session Management
-    /*
-        Creates instance of WebRTC session which connects to (signaling server), and begins to listen to WebRTC events.
-     */
-    TechseeMediaServiceBase.prototype.connectToSession = function (sessionParams) {
-        var _this = this;
-        this.serviceInitGuard();
-        if (!this._session) {
-            this._session = { params: cloneDeep_1.default(sessionParams) };
-            this._session.connectPromise = new Promise(function (resolve, reject) {
-                var doAsyncReject = function doAsyncReject(error) {
-                    /*
-                        Reject with timeout, to change JS 'execution flow'.
-                        If timeout removed, session is assigned to null, before promise returns, and "catch" will not
-                        work on promise that is returned.
-                    */
-                    setTimeout(function () {
-                        _this._session = null;
-                        reject(error);
-                    });
-                };
-                var sessionHandlers = {
-                    onDisconnectedHandler: _this.onSessionDisconnectHandler
-                };
-                var mediaSessionParams = __assign({}, sessionParams, { peerConnectivityTimeoutSeconds: _this._serviceOptions.peerConnectivityTimeoutSeconds || MediaConstants_1.DEFAULT_PEER_CONNECTIVITY_TIMEOUT_SECONDS });
-                trace.info('connectToSession', sessionParams);
-                if (_this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.TURNSERVER) {
-                    _this._session.instance = new SessionTurn_1.TurnWebRtcSession(mediaSessionParams, sessionHandlers, _this._sessionStreamsManager);
-                } else if (_this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.OPENTOK) {
-                    _this._session.instance = new SessionOpentok_1.OpentokSession(mediaSessionParams, _this._sessionStreamsManager);
-                } else {
-                    var allowedValues = values_1.default(MediaConstants_1.MediaServiceType);
-                    trace.error("mediaServiceType '" + _this._serviceOptions.mediaServiceType + "' is not supported.", { allowedValues: allowedValues });
-                    doAsyncReject(new Error('mediaServiceType is not supported'));
-                }
-                if (_this._session && _this._session.instance) {
-                    _this._session.instance.connect().then(function () {
-                        trace.info('Session is connected');
-                        resolve();
-                    }).catch(function (error) {
-                        trace.error('Failed to connect to session', error);
-                        doAsyncReject(error);
-                    });
-                }
-            });
-        } else {
-            trace.warn('Session connected already. Disconnect before connect to new session again');
-        }
-        //TODO - Alex: Change a structure of this function to be more safe
-        //(when we return, there should not be case when session or promise is null)
-        //To fix, need to return promise immediately, then execute process in setTimeout(fn, 0);
-        return this._session.connectPromise;
-    };
-    /*
-        Disconnects from WebRTC session.
-    */
-    TechseeMediaServiceBase.prototype.disconnectFromSession = function () {
-        return this.disconnectFromSessionInternal(MediaConstants_1.MediaSessionDisconnectReason.ForcedByConsumer);
-    };
-    /*
-        Updates a credentials for turn server
-    */
-    TechseeMediaServiceBase.prototype.updateSessionCredentials = function (credentials) {
-        trace.info('updateSessionCredentials');
-        if (!this.sessionExistsGuard(false)) {
-            return Promise.reject('There no session to update credentials');
-        }
-        this._session.params.credentials = cloneDeep_1.default(credentials);
-        return Promise.resolve();
-    };
-    TechseeMediaServiceBase.prototype.enableVoipDuringSession = function () {
-        if (!this._isVoipEnabled && this.isLocalStreamInitialized) {
-            throw new Error('Voip support cannot be enabled after local stream where initialized');
-        }
-        this._isVoipEnabled = true;
-    };
-    TechseeMediaServiceBase.prototype.disconnectFromSessionInternal = function (reason) {
-        if (!this._session) {
-            return Promise.resolve();
-        }
-        trace.info('Disconnecting from session', reason);
-        var lastSession = this._session;
-        this._session = null;
-        return Promise.all([lastSession.instance.disconnect(), this.clearPublishers()]).then(function () {
-            return undefined;
-        });
-    };
-    TechseeMediaServiceBase.prototype.getStatsForRemoteTrack = function (streamType) {
-        if (!this.sessionExistsGuard(false)) {
-            return Promise.reject(new Error('Media session not started'));
-        }
-        var streamForStats = this.getRegisteredStreamByType(streamType);
-        if (!streamForStats) {
-            return Promise.reject(new Error('Stream for requested type was not found'));
-        }
-        return this._session.instance.getRemoteTrackStats(streamForStats.mediaTrack).then(function (trackStats) {
-            traceStatsInfo("MediaTrackStats for " + streamType + ": " + JSON.stringify(trackStats));
+    return this._initServicePromise;
+  }; //#region Media Streams Management
+
+  /*
+      The main method to start the initialization of local media streams.
+      This method can be executed many times and it will insure all calls are synced and only relevant stream will be created.
+      DO NOT USE ANY OTHER METHOD THAT FORCES "navigator.getUserMedia" OTHER THAN THIS ONE.
+   */
+
+
+  TechseeMediaServiceBase.prototype.initLocalMediaStreams = function () {
+    this.serviceInitGuard();
+    var isDashboardOpentok = this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.OPENTOK && (this._serviceOptions.clientRole === MediaConstants_1.SessionClientRole.AGENT || this._serviceOptions.clientRole === MediaConstants_1.SessionClientRole.OBSERVER); // This hack for IOS 14 force a recreation of stream on seemingly unnecessary occasions (like agent page refresh).
+    // we're not sure why but the stream breaks
+
+    if (!this._initLocalStreamsPromise || this._isIOS_14_orLater && !isDashboardOpentok) {
+      trace.info('initLocalMediaStreams creating media streams');
+      this._initLocalStreamsPromise = this.getLocalMediaImplementation()["catch"](function (mediaRequestFailResult) {
+        trace.error("initLocalMediaStreams failure: " + mediaRequestFailResult);
+        throw mediaRequestFailResult;
+      });
+    } else {
+      trace.info('initLocalMediaStreams already done or in progress');
+    }
+
+    return this._initLocalStreamsPromise;
+  };
+  /*
+      Creates an instance of subscriber that will "listen" to the requested stream.
+      Whenever requested stream is available, subscriber will render it.
+   */
+
+
+  TechseeMediaServiceBase.prototype.createSubscriber = function (subscriberParams) {
+    if (this._subscribers.has(subscriberParams.container)) {
+      return Promise.reject('Subscriber for provided DIV element already exists');
+    }
+
+    var subscriber = new MediaSubscriber_1.TechseeMediaSubscriber(subscriberParams);
+
+    this._subscribers.set(subscriberParams.container, subscriber);
+
+    var streamForSubscriber = this.getRegisteredStreamByType(subscriber.streamType);
+
+    if (streamForSubscriber) {
+      trace.info("Stream for " + subscriberParams.streamType + " is ready.");
+      subscriber.renderStream(streamForSubscriber);
+    } else {
+      trace.info("Stream for " + subscriberParams.streamType + " not created yet");
+    }
+
+    return Promise.resolve(subscriber);
+  };
+  /*
+      Destroys the subscriber for provided HTML DIV container
+   */
+
+
+  TechseeMediaServiceBase.prototype.destroySubscriber = function (container) {
+    if (this._subscribers.has(container)) {
+      var subscriber = this._subscribers.get(container);
+
+      subscriber.dispose();
+    }
+
+    this._subscribers["delete"](container);
+
+    return Promise.resolve();
+  };
+
+  TechseeMediaServiceBase.prototype.onStreamDestroyed = function (callback) {
+    this.registerEventCallback(privateEvents.STREAM_DESTROYED, callback);
+  };
+
+  TechseeMediaServiceBase.prototype.onStreamCreated = function (callback) {
+    this.registerEventCallback(privateEvents.STREAM_CREATED, callback);
+  };
+
+  TechseeMediaServiceBase.prototype.onRecordStarted = function (callback) {
+    if (this._session && this._session.instance) {
+      this._session.instance.registerEventCallback(MediaSessionBase_1.recordingEvents.RECORD_STARTED, callback);
+    }
+  };
+
+  TechseeMediaServiceBase.prototype.onRecordStopped = function (callback) {
+    if (this._session && this._session.instance) {
+      this._session.instance.registerEventCallback(MediaSessionBase_1.recordingEvents.RECORD_STOPPED, callback);
+    }
+  };
+
+  TechseeMediaServiceBase.prototype.onReconnecting = function (callback) {
+    if (this._session && this._session.instance) {
+      this._session.instance.registerEventCallback(MediaSessionBase_1.recordingEvents.RECONNECTING, callback);
+    }
+  };
+
+  TechseeMediaServiceBase.prototype.getSwitchCameraConstraints = function () {
+    var constraints = cloneDeep_1["default"](window.latestLocalMediaConstraints);
+
+    if (!constraints) {
+      throw new Error('getSwitchCameraConstraints: unexpected use case constraints is null.');
+    }
+
+    trace.info('getSwitchCameraConstraints - Start switch camera with constraints:', constraints);
+    var videoSourceType = constraints.video.videoSourceType === MediaConstants_1.LocalVideoSourceType.CAMERA ? MediaConstants_1.LocalVideoSourceType.CAMERA_FRONT : MediaConstants_1.LocalVideoSourceType.CAMERA;
+    trace.info("getSwitchCameraConstraints - switch to videoSourceType: " + videoSourceType);
+    constraints.video.videoSourceType = videoSourceType;
+    return constraints;
+  };
+
+  TechseeMediaServiceBase.prototype.switchCamera = function (revertCameraWhenFailed) {
+    var _this = this;
+
+    trace.info('switchCamera: start');
+    var latestLocalMediaConstraints = cloneDeep_1["default"](window.latestLocalMediaConstraints);
+    var constraints = !revertCameraWhenFailed ? this.getSwitchCameraConstraints() : latestLocalMediaConstraints;
+
+    if (!constraints) {
+      throw new Error('switchCamera - unexpected use case constraints is null.');
+    }
+
+    return this._localStreamsManager.destroyUserMediaStream().then(function () {
+      return _this._localStreamsManager.getUserMediaStream(constraints).then(function (streamResult) {
+        var stream = streamResult.mediaStream;
+        trace.info('switchCamera: new stream: ', stream);
+        return _this.replaceStreamTracks(stream).then(function () {
+          return _this.registerStreamResult(constraints, streamResult, true).then(function () {
             return {
-                trackId: streamForStats.mediaTrack.id,
-                trackStats: trackStats
+              revertCameraWhenFailed: revertCameraWhenFailed,
+              constraints: constraints,
+              streamResult: streamResult
             };
+          });
         });
-    };
-    TechseeMediaServiceBase.prototype.onSessionDisconnectHandler = function (reason) {
-        var _this = this;
-        trace.info('onSessionDisconnectHandler', reason);
-        if (reason !== MediaConstants_1.MediaSessionDisconnectReason.ForcedByConsumer) {
-            var lastParams_1 = this._session && this._session.params ? this._session.params : null;
-            this.disconnectFromSessionInternal(reason).then(function () {
-                var reconnectReasons = [MediaConstants_1.MediaSessionDisconnectReason.InitiatorPeerReconnected, MediaConstants_1.MediaSessionDisconnectReason.SignalingChannelDisconnect, MediaConstants_1.MediaSessionDisconnectReason.PeerConnectionInterrupted, MediaConstants_1.MediaSessionDisconnectReason.PeerConnectionStateChangeTimeout];
-                if (lastParams_1 && includes_1.default(reconnectReasons, reason) && _this._autoReconnectEnabled) {
-                    _this.reconnectToSession(lastParams_1);
-                } else if (!_this._autoReconnectEnabled) {
-                    trace.info('No reconnection- auto reconnect disabled');
-                } else {
-                    trace.info('No params for reconnection to media session');
-                }
-            });
-        } else {
-            trace.info('Ignore Session disconnect event');
-        }
-    };
-    TechseeMediaServiceBase.prototype.setAutoReconnect = function (state) {
-        this._autoReconnectEnabled = state;
-        trace.info('_autoReconnectEnabled:', state);
-        if (this._autoReconnectEnabled && !this.isSessionActive) {
-            var lastParams = this._session && this._session.params ? this._session.params : null;
-            if (lastParams) {
-                trace.info('setAutoReconnect - reconnect to session');
-                this.reconnectToSession(lastParams);
-            }
-        }
-    };
-    TechseeMediaServiceBase.prototype.reconnectToSession = function (lastParams) {
-        trace.info('Reconnecting to media session, sessionParams:', lastParams);
-        this.connectToSession(lastParams).then(function () {
-            trace.info('Media session reconnected');
-        }).catch(function (error) {
-            trace.error('Error while reconnecting to media session', error);
-        });
-    };
-    //#endregion Session Management
-    //#region Utils
-    TechseeMediaServiceBase.prototype.getSnapshotFromKnownStream = function (sourceStream, snapshotOptions) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (sourceStream !== MediaConstants_1.KnownMediaStream.USER_VIDEO_STREAM && sourceStream !== MediaConstants_1.KnownMediaStream.USER_SCREEN_SHARE_STREAM) {
-                trace.error('The requested stream is not video stream, and cannot be used for snapshot');
-                reject(new Error('INCOMPATIBLE_STREAM_FOR_SNAPSHOT'));
-                return;
-            }
-            var snapshotStream = _this.getRegisteredStreamByType(sourceStream);
-            if (!snapshotStream) {
-                trace.error('Cannot make snapshot: The requested stream not exists yet.');
-                reject(new Error('NO_REQUESTED_STREAM'));
-                return;
-            }
-            MediaDomUtils_1.getSnapshotFromMediaStream(snapshotStream.mediaStream, snapshotOptions).then(function (imageData) {
-                var urlComponents = imageData.split(';base64,');
-                var mimeType = urlComponents[0].split(':')[1];
-                var bytes = atob(urlComponents[1]);
-                var buffer = new ArrayBuffer(bytes.length);
-                var rawData = new Uint8Array(buffer);
-                for (var i = 0; i < bytes.length; i++) {
-                    rawData[i] = bytes.charCodeAt(i);
-                }
-                var blob = new Blob([rawData], { type: mimeType });
-                var objectUrl = window.URL.createObjectURL(blob);
-                trace.info('Snapshot created successfully');
-                var result = {
-                    base64img: imageData,
-                    objectUrl: objectUrl,
-                    imageBlob: blob,
-                    mimeType: mimeType
-                };
-                resolve(result);
-            }).catch(function (error) {
-                trace.error('Error creating snapshot', error);
-                reject(error);
-            });
-        });
-    };
-    //Will clean streams, publishers and subscribers, but will not remove event listeners
-    TechseeMediaServiceBase.prototype.clearService = function () {
-        var _this = this;
-        trace.info('MediaService clearing all resources');
-        return this.disconnectFromSessionInternal(MediaConstants_1.MediaSessionDisconnectReason.ForcedByConsumer).then(this.clearSubscribers).then(this.clearRegisteredStreams).then(this._localStreamsManager.clearAllStreams).then(function () {
-            _this._initLocalStreamsPromise = null;
-        }).then(function () {
-            return undefined;
-        });
-    };
-    //Will clear the service and remove all event listeners
-    TechseeMediaServiceBase.prototype.dispose = function () {
-        var _this = this;
-        return this.clearService().catch(function () {
-            return undefined;
-        }).then(function () {
-            _this._emitter.removeAllListeners();
-        });
-    };
-    Object.defineProperty(TechseeMediaServiceBase.prototype, "subscribers", {
-        //#endregion
-        //#region Protected Methods
-        get: function get() {
-            return this._subscribers;
-        },
-        enumerable: true,
-        configurable: true
+      });
+    })["catch"](function (err) {
+      trace.error('switchCamera: Failed to switch camera: ', err);
+
+      if (!revertCameraWhenFailed) {
+        window.latestLocalMediaConstraints = latestLocalMediaConstraints;
+        return _this.switchCamera(true);
+      }
+
+      return Promise.reject('Failed to switch camera.');
     });
-    TechseeMediaServiceBase.prototype.registerLocalMediaStream = function (tsMediaStream) {
-        trace.info('Registering local stream', tsMediaStream.streamType);
-        if (this._registeredStreams.has(tsMediaStream.streamType)) {
-            return Promise.reject(new Error("Stream " + tsMediaStream.streamType + " already registered"));
-        }
-        return this.registerStream(tsMediaStream);
-    };
-    TechseeMediaServiceBase.prototype.getRegisteredStreamByType = function (streamType) {
-        return this._registeredStreams.get(streamType) || null;
-    };
-    TechseeMediaServiceBase.prototype.changeEnableForKnownStream = function (streamType, isPaused) {
-        var streamToChangeState = this.getRegisteredStreamByType(streamType);
-        if (!streamToChangeState) {
-            trace.warn('There no stream found to change enable state', streamType);
+  };
+
+  TechseeMediaServiceBase.prototype.replaceStreamTracks = function (mediaStream) {
+    if (this._session.instance) {
+      return this._session.instance.replaceStreamTracks(mediaStream);
+    }
+
+    return Promise.reject('replaceStreamTracks - session instance is not exists.');
+  };
+
+  TechseeMediaServiceBase.prototype.registerStreamResult = function (constraints, streamResult, switchCamera, addStreamType) {
+    var _this = this;
+
+    var regPromises = [];
+    var isOpentok = this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.OPENTOK;
+
+    if (streamResult.isNew) {
+      trace.info('registerStreamResult: stream result from getUserMediaStream:', streamResult.mediaStream);
+      streamResult.mediaStream.getTracks().forEach(function (mediaTrack) {
+        trace.info('registerStreamResult: stream result from mediaTrack:', mediaTrack);
+        var streamType = addStreamType || (mediaTrack.kind === 'video' ? MediaConstants_1.KnownMediaStream.USER_VIDEO_STREAM : MediaConstants_1.KnownMediaStream.USER_AUDIO_STREAM);
+        var newDedicatedStream = new TechseeMediaStream_1.TechseeMediaStream(mediaTrack, streamType, false);
+
+        if (isOpentok) {
+          regPromises.push(_this.registerStream(newDedicatedStream));
         } else {
-            streamToChangeState.mediaTrack.enabled = !isPaused;
-            if (streamToChangeState.isRemote && streamToChangeState.streamKind === MediaConstants_1.KnownMediaStreamKind.Audio) {
-                this.subscribers.forEach(function (subscriber) {
-                    if (subscriber.streamType === streamType) {
-                        subscriber.muteSound(isPaused);
-                    }
-                });
-            }
-            trace.info('Local stream enable state is changed', { streamType: streamType, isPaused: isPaused });
-        }
-    };
-    TechseeMediaServiceBase.prototype.registerEventCallback = function (event, callback) {
-        this._emitter.on(event, callback);
-    };
-    TechseeMediaServiceBase.prototype.emitEvent = function (event, eventArgs) {
-        var _this = this;
-        setTimeout(function () {
-            _this._emitter.emit(event, eventArgs);
-        });
-    };
-    //#endregion Protected Methods
-    //#region Private Methods
-    TechseeMediaServiceBase.prototype.registerRemoteMediaTrack = function (remoteMediaTrack) {
-        trace.info("Registering remote " + remoteMediaTrack.trackType + " MediaStreamTrack", remoteMediaTrack.mediaTrack);
-        var currentStream = this._registeredStreams.get(remoteMediaTrack.trackType);
-        if (currentStream && !currentStream.isRemote) {
-            return Promise.reject(new Error('Cannot register remote stream with the same type as local stream'));
+          regPromises.push(switchCamera ? _this.registerTrack(newDedicatedStream) : _this.registerLocalMediaStream(newDedicatedStream));
         }
-        var newDedicatedStream = new TechseeMediaStream_1.TechseeMediaStream(remoteMediaTrack.mediaTrack, remoteMediaTrack.trackType, true);
-        return this.registerStream(newDedicatedStream);
-    };
-    TechseeMediaServiceBase.prototype.registerStream = function (mediaStream) {
-        var _this = this;
-        var currentStream = this._registeredStreams.get(mediaStream.streamType);
-        var registerTrack = function registerTrack() {
-            mediaStream.mediaTrack.onended = function () {
-                return _this.unregisterTechseeMediaStream(mediaStream, MediaConstants_1.MediaStreamUnregisterReason.NativeEvent);
-            };
-            _this._registeredStreams.set(mediaStream.streamType, mediaStream);
-            trace.info("TechseeMediaStream registered - " + mediaStream.streamType, TechseeMediaStream_1.TechseeMediaStream);
-            return _this.updateSubscribersWithNewStream(mediaStream).then(function () {
-                var eventArgs = { streamType: mediaStream.streamType };
-                _this.emitEvent(privateEvents.STREAM_CREATED, eventArgs);
-            });
+      });
+    }
+
+    return Promise.all(regPromises);
+  };
+
+  TechseeMediaServiceBase.prototype.disconnectFromMediaSession = function () {
+    if (this._session && this._session.instance) {
+      return this._session.instance.sessionDisconnect();
+    }
+  };
+
+  Object.defineProperty(TechseeMediaServiceBase.prototype, "supportSwitchCameras", {
+    get: function get() {
+      return this._isIOS_13_orLater || this._localStreamsManager.groupedDevices.camerasCount > 1;
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  TechseeMediaServiceBase.prototype._connectToSession = function (sessionParams) {
+    var _this = this;
+
+    this.serviceInitGuard();
+
+    if (!this._session) {
+      this._session = {
+        params: cloneDeep_1["default"](sessionParams)
+      };
+      this._session.connectPromise = new Promise(function (resolve, reject) {
+        var doAsyncReject = function doAsyncReject(error) {
+          /*
+              Reject with timeout, to change JS 'execution flow'.
+              If timeout removed, session is assigned to null, before promise returns, and "catch" will not
+              work on promise that is returned.
+          */
+          setTimeout(function () {
+            _this._session = null;
+            reject(error);
+          });
         };
-        if (currentStream) {
-            return this.unregisterTechseeMediaStream(currentStream, MediaConstants_1.MediaStreamUnregisterReason.ReplacingStream).then(registerTrack);
-        }
-        return registerTrack();
-    };
-    TechseeMediaServiceBase.prototype.unregisterTechseeMediaStream = function (streamToUnregister, reason) {
-        var _this = this;
-        var traceError = function traceError(error) {
-            trace.warn('Unregister TechseeMediaStream error:', error);
+
+        var sessionHandlers = {
+          onDisconnectedHandler: _this.onSessionDisconnectHandler
         };
-        var promises = [];
-        trace.info('Unregister TechseeMediaStream: ', streamToUnregister.streamType);
-        this._subscribers.forEach(function (subscriber) {
-            if (subscriber.streamType === streamToUnregister.streamType) {
-                promises.push(subscriber.stopRendering().catch(traceError));
-            }
-        });
-        if (!streamToUnregister.isRemote) {
-            this._publishers.forEach(function (publisher) {
-                if (publisher.streamTypes.find(function (streamType) {
-                    return streamType === streamToUnregister.streamType;
-                })) {
-                    if (_this._session && _this._session.instance) {
-                        promises.push(_this._session.instance.onMediaStreamDestroyed(publisher.destinationRole).catch(traceError));
-                    }
-                }
-            });
-        }
-        return Promise.all(promises).then(function () {
-            _this._registeredStreams.delete(streamToUnregister.streamType);
-            trace.info('Stream deleted', streamToUnregister.streamType);
-            var eventArgs = { streamType: streamToUnregister.streamType, reason: reason };
-            _this.emitEvent(privateEvents.STREAM_DESTROYED, eventArgs);
-        });
-    };
-    TechseeMediaServiceBase.prototype.unregisterRemoteMediaTrack = function (mediaTrack) {
-        var _this = this;
-        var promises = [];
-        this._registeredStreams.forEach(function (registeredStream) {
-            if (registeredStream.mediaTrack.id === mediaTrack.id) {
-                promises.push(_this.unregisterTechseeMediaStream(registeredStream, MediaConstants_1.MediaStreamUnregisterReason.ClosedRemotely));
-            }
-        });
-        return Promise.all(promises).then(function () {
-            return undefined;
+
+        var mediaSessionParams = __assign(__assign({}, sessionParams), {
+          peerConnectivityTimeoutSeconds: _this._serviceOptions.peerConnectivityTimeoutSeconds || MediaConstants_1.DEFAULT_PEER_CONNECTIVITY_TIMEOUT_SECONDS
         });
-    };
-    TechseeMediaServiceBase.prototype.removePublisher = function (publisher) {
-        this._publishers.delete(publisher.destinationRole);
-        if (this._session && this._session.instance) {
-            trace.info('Removing publisher', publisher.destinationRole);
-            return this._session.instance.onMediaStreamDestroyed(publisher.destinationRole).catch(function (error) {
-                trace.warn('Error while removing publisher', error);
+
+        trace.info('connectToSession', sessionParams);
+        var allowedValues = values_1["default"](MediaConstants_1.MediaServiceType);
+
+        switch (_this._serviceOptions.mediaServiceType) {
+          case MediaConstants_1.MediaServiceType.TURNSERVER:
+            _this._session.instance = new SessionTurn_1.TurnWebRtcSession(mediaSessionParams, sessionHandlers, _this._sessionStreamsManager);
+            break;
+
+          case MediaConstants_1.MediaServiceType.OPENTOK:
+            _this._session.instance = new SessionOpentok_1.OpentokSession(mediaSessionParams, _this._sessionStreamsManager);
+            break;
+
+          case MediaConstants_1.MediaServiceType.MEDIASERVER:
+            _this._session.instance = new MediaServer_1.MediaServerSession(mediaSessionParams, _this._sessionStreamsManager);
+            break;
+
+          default:
+            trace.error("mediaServiceType '" + _this._serviceOptions.mediaServiceType + "' is not supported.", {
+              allowedValues: allowedValues
             });
+            doAsyncReject(new Error('mediaServiceType is not supported'));
         }
-        return Promise.resolve();
-    };
-    TechseeMediaServiceBase.prototype.getStreamForDestinationRole = function (destinationRole) {
-        var _this = this;
-        this.serviceInitGuard();
-        if (this._publishers.has(destinationRole)) {
-            trace.info("Publisher for " + destinationRole + " already exists");
-            return Promise.resolve(this._publishers.get(destinationRole).mediaStream);
+
+        if (_this._session && _this._session.instance) {
+          _this._session.instance.connect().then(function () {
+            trace.info('Session is connected');
+            resolve();
+          })["catch"](function (error) {
+            trace.error('Failed to connect to session', error);
+            doAsyncReject(error);
+          });
         }
-        if (!this._publisherPromises.get(destinationRole)) {
-            trace.info("Creating publisher for " + destinationRole);
-            var publisherPromise = this.initLocalMediaStreams().then(function () {
-                return _this.createMediaPublisher(destinationRole);
-            }).then(function (mediaPublisher) {
-                if (mediaPublisher) {
-                    _this._publishers.set(destinationRole, mediaPublisher);
-                }
-                _this._publisherPromises.delete(destinationRole);
-                return mediaPublisher ? mediaPublisher.mediaStream : null;
-            }).catch(function (ex) {
-                if (ex && ex.message === 'audioStreamFailed') {
-                    _this._isVoipEnabled = false;
-                    return null;
-                }
-                _this._publisherPromises.delete(destinationRole);
-                throw ex;
-            });
-            this._publisherPromises.set(destinationRole, publisherPromise);
+      });
+    } else {
+      trace.warn('Session connected already. Disconnect before connect to new session again');
+    } //TODO - Alex: Change a structure of this function to be more safe
+    //(when we return, there should not be case when session or promise is null)
+    //To fix, need to return promise immediately, then execute process in setTimeout(fn, 0);
+
+
+    return this._session.connectPromise;
+  }; //#endregion Media Streams Management
+  //#region Session Management
+
+  /*
+      Creates instance of WebRTC session which connects to (signaling server), and begins to listen to WebRTC events.
+   */
+
+
+  TechseeMediaServiceBase.prototype.connectToSession = function (sessionParams) {
+    return this._connectToSession(sessionParams);
+  };
+  /*
+      Disconnects from WebRTC session.
+  */
+
+
+  TechseeMediaServiceBase.prototype.disconnectFromSession = function () {
+    return this.disconnectFromSessionInternal(MediaConstants_1.MediaSessionDisconnectReason.ForcedByConsumer);
+  };
+  /*
+      Updates a credentials for turn server
+  */
+
+
+  TechseeMediaServiceBase.prototype.updateSessionCredentials = function (credentials) {
+    trace.info('updateSessionCredentials');
+
+    if (!this.sessionExistsGuard(false)) {
+      return Promise.reject('There no session to update credentials');
+    }
+
+    this._session.params.credentials = cloneDeep_1["default"](credentials);
+    return Promise.resolve();
+  };
+
+  TechseeMediaServiceBase.prototype.enableVoipDuringSession = function () {
+    if (!this._isVoipEnabled && this.isLocalStreamInitialized) {
+      this._initLocalStreamsPromise = null;
+    }
+
+    this._isVoipEnabled = true;
+  };
+
+  TechseeMediaServiceBase.prototype.disconnectFromSessionInternal = function (reason) {
+    if (!this._session) {
+      return Promise.resolve();
+    }
+
+    trace.info('Disconnecting from session', reason);
+    var lastSession = this._session;
+    this._session = null;
+    return Promise.all([lastSession.instance.disconnect(), this.clearPublishers()]).then(function () {
+      return undefined;
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.getStatsForRemoteTrack = function (streamType) {
+    if (!this.sessionExistsGuard(false)) {
+      return Promise.reject(new Error('Media session not started'));
+    }
+
+    var streamForStats = this.getRegisteredStreamByType(streamType);
+
+    if (!streamForStats) {
+      return Promise.reject(new Error('Stream for requested type was not found'));
+    }
+
+    return this._session.instance.getRemoteTrackStats(streamForStats.mediaTrack).then(function (trackStats) {
+      traceStatsInfo("MediaTrackStats for " + streamType + ": " + JSON.stringify(trackStats));
+      return {
+        trackId: streamForStats.mediaTrack.id,
+        trackStats: trackStats
+      };
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.onSessionDisconnectHandler = function (reason) {
+    var _this = this;
+
+    trace.info('onSessionDisconnectHandler', reason);
+
+    if (reason !== MediaConstants_1.MediaSessionDisconnectReason.ForcedByConsumer) {
+      var lastParams_1 = this._session && this._session.params ? this._session.params : null;
+      this.disconnectFromSessionInternal(reason).then(function () {
+        var reconnectReasons = [MediaConstants_1.MediaSessionDisconnectReason.InitiatorPeerReconnected, MediaConstants_1.MediaSessionDisconnectReason.SignalingChannelDisconnect, MediaConstants_1.MediaSessionDisconnectReason.PeerConnectionInterrupted, MediaConstants_1.MediaSessionDisconnectReason.PeerConnectionStateChangeTimeout];
+
+        if (lastParams_1 && includes_1["default"](reconnectReasons, reason) && _this._autoReconnectEnabled) {
+          _this.reconnectToSession(lastParams_1);
+        } else if (!_this._autoReconnectEnabled) {
+          trace.info('No reconnection- auto reconnect disabled');
         } else {
-            trace.info("Create publisher promise for " + destinationRole + " already exists");
+          trace.info('No params for reconnection to media session');
         }
-        return this._publisherPromises.get(destinationRole);
-    };
-    TechseeMediaServiceBase.prototype.updateSubscribersWithNewStream = function (registeredStream) {
-        trace.info("Updating subscribers of " + registeredStream.streamType + " with new stream");
-        if (this._subscribers.size === 0) {
-            trace.warn("No subscribers exists for the " + registeredStream.streamType + ".");
-        } else {
-            trace.info("Total " + this._subscribers.size + " subscribers exists, will check if rerender needed.");
+      });
+    } else {
+      trace.info('Ignore Session disconnect event');
+    }
+  };
+
+  TechseeMediaServiceBase.prototype.setAutoReconnect = function (state) {
+    this._autoReconnectEnabled = state;
+    trace.info('_autoReconnectEnabled:', state);
+
+    if (this._autoReconnectEnabled && !this.isSessionActive) {
+      var lastParams = this._session && this._session.params ? this._session.params : null;
+
+      if (lastParams) {
+        trace.info('setAutoReconnect - reconnect to session');
+        this.reconnectToSession(lastParams);
+      }
+    }
+  };
+
+  TechseeMediaServiceBase.prototype.reconnectToSession = function (lastParams) {
+    trace.info('Reconnecting to media session, sessionParams:', lastParams);
+
+    this._connectToSession(lastParams).then(function () {
+      trace.info('Media session reconnected');
+    })["catch"](function (error) {
+      trace.error('Error while reconnecting to media session', error);
+    });
+  }; //#endregion Session Management
+  //#region Utils
+
+
+  TechseeMediaServiceBase.prototype.getSnapshotFromKnownStream = function (sourceStream, snapshotOptions) {
+    var _this = this;
+
+    return new Promise(function (resolve, reject) {
+      if (sourceStream !== MediaConstants_1.KnownMediaStream.USER_VIDEO_STREAM && sourceStream !== MediaConstants_1.KnownMediaStream.USER_SCREEN_SHARE_STREAM) {
+        trace.error('The requested stream is not video stream, and cannot be used for snapshot');
+        reject(new Error('INCOMPATIBLE_STREAM_FOR_SNAPSHOT'));
+        return;
+      }
+
+      var snapshotStream = _this.getRegisteredStreamByType(sourceStream);
+
+      if (!snapshotStream) {
+        trace.error('Cannot make snapshot: The requested stream not exists yet.');
+        reject(new Error('NO_REQUESTED_STREAM'));
+        return;
+      }
+
+      MediaDomUtils_1.getSnapshotFromMediaStream(snapshotStream.mediaStream, sourceStream, snapshotOptions).then(function (imageData) {
+        var urlComponents = imageData.split(';base64,');
+        var mimeType = urlComponents[0].split(':')[1];
+        var bytes = atob(urlComponents[1]);
+        var buffer = new ArrayBuffer(bytes.length);
+        var rawData = new Uint8Array(buffer);
+
+        for (var i = 0; i < bytes.length; i++) {
+          rawData[i] = bytes.charCodeAt(i);
         }
-        this._subscribers.forEach(function (subscriber) {
-            if (subscriber.streamType === registeredStream.streamType) {
-                trace.info(registeredStream.streamType + " rendering on subscriber");
-                subscriber.renderStream(registeredStream);
-            }
-        });
-        return Promise.resolve();
-    };
-    TechseeMediaServiceBase.prototype.bindClassMethods = function () {
-        this.updateSessionCredentials = this.updateSessionCredentials.bind(this);
-        this.getStreamForDestinationRole = this.getStreamForDestinationRole.bind(this);
-        this.registerRemoteMediaTrack = this.registerRemoteMediaTrack.bind(this);
-        this.unregisterRemoteMediaTrack = this.unregisterRemoteMediaTrack.bind(this);
-        this.createMediaPublisher = this.createMediaPublisher.bind(this);
-        this.updateSubscribersWithNewStream = this.updateSubscribersWithNewStream.bind(this);
-        this.initLocalMediaStreams = this.initLocalMediaStreams.bind(this);
-        this.onSessionDisconnectHandler = this.onSessionDisconnectHandler.bind(this);
-        this.clearService = this.clearService.bind(this);
-        this.clearRegisteredStreams = this.clearRegisteredStreams.bind(this);
-        this.clearPublishers = this.clearPublishers.bind(this);
-        this.clearSubscribers = this.clearSubscribers.bind(this);
-    };
-    //region Cleanup
-    TechseeMediaServiceBase.prototype.clearRegisteredStreams = function () {
-        var _this = this;
-        trace.info('Clearing registered streams');
-        var promises = [];
-        this._registeredStreams.forEach(function (streamToUnregister) {
-            promises.push(_this.unregisterTechseeMediaStream(streamToUnregister, MediaConstants_1.MediaStreamUnregisterReason.ServiceCleanUp));
-        });
-        return Promise.all(promises).then(function () {
-            return undefined;
-        });
-    };
-    TechseeMediaServiceBase.prototype.clearSubscribers = function () {
-        var _this = this;
-        trace.info('Clearing subscribers');
-        var promises = [];
-        this._subscribers.forEach(function (subscriber) {
-            promises.push(_this.destroySubscriber(subscriber.container));
+
+        var blob = new Blob([rawData], {
+          type: mimeType
         });
-        return Promise.all(promises).then(function () {
-            return undefined;
+        var objectUrl = window.URL.createObjectURL(blob);
+        trace.info('Snapshot created successfully');
+        var result = {
+          base64img: imageData,
+          objectUrl: objectUrl,
+          imageBlob: blob,
+          mimeType: mimeType
+        };
+        resolve(result);
+      })["catch"](function (error) {
+        trace.error('Error creating snapshot', error);
+        reject(error);
+      });
+    });
+  }; //Will clean streams, publishers and subscribers, but will not remove event listeners
+
+
+  TechseeMediaServiceBase.prototype.clearService = function () {
+    var _this = this;
+
+    trace.info('MediaService clearing all resources');
+    return this.disconnectFromSessionInternal(MediaConstants_1.MediaSessionDisconnectReason.ForcedByConsumer).then(this.clearSubscribers).then(this.clearRegisteredStreams).then(this._localStreamsManager.clearAllStreams).then(function () {
+      _this._initLocalStreamsPromise = null;
+      _this._isVoipEnabled = false;
+    }).then(function () {
+      return undefined;
+    });
+  }; //Will clear the service and remove all event listeners
+
+
+  TechseeMediaServiceBase.prototype.dispose = function () {
+    var _this = this;
+
+    return this.clearService()["catch"](function () {
+      return undefined;
+    }).then(function () {
+      _this._emitter.removeAllListeners();
+    });
+  };
+
+  Object.defineProperty(TechseeMediaServiceBase.prototype, "subscribers", {
+    //#endregion
+    //#region Protected Methods
+    get: function get() {
+      return this._subscribers;
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  TechseeMediaServiceBase.prototype.registerLocalMediaStream = function (tsMediaStream) {
+    trace.info('Registering local stream', tsMediaStream.streamType);
+
+    if (this._registeredStreams.has(tsMediaStream.streamType)) {
+      return Promise.reject(new Error("Stream " + tsMediaStream.streamType + " already registered"));
+    }
+
+    return this.registerStream(tsMediaStream);
+  };
+
+  TechseeMediaServiceBase.prototype.getRegisteredStreamByType = function (streamType) {
+    return this._registeredStreams.get(streamType) || null;
+  };
+
+  TechseeMediaServiceBase.prototype.changeEnableForKnownStream = function (streamType, isPaused) {
+    var streamToChangeState = this.getRegisteredStreamByType(streamType);
+
+    if (!streamToChangeState) {
+      trace.warn('There no stream found to change enable state', streamType);
+    } else {
+      streamToChangeState.mediaTrack.enabled = !isPaused;
+
+      if (streamToChangeState.isRemote && streamToChangeState.streamKind === MediaConstants_1.KnownMediaStreamKind.Audio) {
+        this.subscribers.forEach(function (subscriber) {
+          if (subscriber.streamType === streamType) {
+            subscriber.muteSound(isPaused);
+          }
         });
+      }
+
+      trace.info('Local stream enable state is changed', {
+        streamType: streamType,
+        isPaused: isPaused
+      });
+    }
+  };
+
+  TechseeMediaServiceBase.prototype.registerEventCallback = function (event, callback) {
+    this._emitter.on(event, callback);
+  };
+
+  TechseeMediaServiceBase.prototype.unregisterEventCallback = function (event, callback) {
+    this._emitter.off(event, callback);
+  };
+
+  TechseeMediaServiceBase.prototype.emitEvent = function (event, eventArgs) {
+    var _this = this;
+
+    setTimeout(function () {
+      _this._emitter.emit(event, eventArgs);
+    });
+  }; //#endregion Protected Methods
+  //#region Private Methods
+
+
+  TechseeMediaServiceBase.prototype.registerRemoteMediaTrack = function (remoteMediaTrack) {
+    trace.info("Registering remote " + remoteMediaTrack.trackType + " MediaStreamTrack", remoteMediaTrack.mediaTrack);
+
+    var currentStream = this._registeredStreams.get(remoteMediaTrack.trackType);
+
+    if (currentStream && !currentStream.isRemote) {
+      return Promise.reject(new Error('Cannot register remote stream with the same type as local stream'));
+    }
+
+    var newDedicatedStream = new TechseeMediaStream_1.TechseeMediaStream(remoteMediaTrack.mediaTrack, remoteMediaTrack.trackType, true);
+    return this.registerStream(newDedicatedStream);
+  };
+
+  TechseeMediaServiceBase.prototype.registerTrack = function (mediaStream) {
+    var _this = this;
+
+    mediaStream.mediaTrack.onended = function () {
+      return _this.unregisterTechseeMediaStream(mediaStream, MediaConstants_1.MediaStreamUnregisterReason.NativeEvent);
     };
-    TechseeMediaServiceBase.prototype.clearPublishers = function () {
-        var _this = this;
-        trace.info('Clearing publishers');
-        var promises = [];
-        this._publishers.forEach(function (publisher) {
-            promises.push(_this.removePublisher(publisher));
-        });
-        return Promise.all(promises).then(function () {
-            return undefined;
-        });
+
+    this._registeredStreams.set(mediaStream.streamType, mediaStream);
+
+    trace.info("TechseeMediaStream registered - " + mediaStream.streamType, TechseeMediaStream_1.TechseeMediaStream);
+    return this.updateSubscribersWithNewStream(mediaStream).then(function () {
+      var eventArgs = {
+        streamType: mediaStream.streamType
+      };
+
+      _this.emitEvent(privateEvents.STREAM_CREATED, eventArgs);
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.registerStream = function (mediaStream) {
+    var _this = this;
+
+    var currentStream = this._registeredStreams.get(mediaStream.streamType);
+
+    if (currentStream) {
+      return this.unregisterTechseeMediaStream(currentStream, MediaConstants_1.MediaStreamUnregisterReason.ReplacingStream).then(function () {
+        return _this.registerTrack(mediaStream);
+      });
+    }
+
+    return this.registerTrack(mediaStream);
+  };
+
+  TechseeMediaServiceBase.prototype.unregisterTechseeMediaStream = function (streamToUnregister, reason) {
+    var _this = this;
+
+    var traceError = function traceError(error) {
+      trace.warn('Unregister TechseeMediaStream error:', error);
     };
-    //#endregion Cleanup
-    //#region Simple Validation Methods
-    TechseeMediaServiceBase.prototype.serviceInitGuard = function (shouldThrow) {
-        if (shouldThrow === void 0) {
-            shouldThrow = true;
+
+    var promises = [];
+    trace.info('Unregister TechseeMediaStream: ', streamToUnregister.streamType);
+
+    this._subscribers.forEach(function (subscriber) {
+      if (subscriber.streamType === streamToUnregister.streamType) {
+        promises.push(subscriber.stopRendering()["catch"](traceError));
+      }
+    });
+
+    if (!streamToUnregister.isRemote) {
+      this._publishers.forEach(function (publisher) {
+        if (publisher.streamTypes.find(function (streamType) {
+          return streamType === streamToUnregister.streamType;
+        })) {
+          if (_this._session && _this._session.instance) {
+            promises.push(_this._session.instance.onMediaStreamDestroyed(publisher.destinationRole)["catch"](traceError));
+          }
         }
-        return guards_1.throwableGuard(!!this._serviceOptions, 'Media service is not initialized', shouldThrow);
-    };
-    TechseeMediaServiceBase.prototype.sessionExistsGuard = function (shouldThrow) {
-        if (shouldThrow === void 0) {
-            shouldThrow = true;
+      });
+    }
+
+    return Promise.all(promises).then(function () {
+      _this._registeredStreams["delete"](streamToUnregister.streamType);
+
+      trace.info('Stream deleted', streamToUnregister.streamType);
+      var eventArgs = {
+        streamType: streamToUnregister.streamType,
+        reason: reason
+      };
+
+      _this.emitEvent(privateEvents.STREAM_DESTROYED, eventArgs);
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.unregisterRemoteMediaTrack = function (mediaTrack) {
+    var _this = this;
+
+    var promises = [];
+
+    this._registeredStreams.forEach(function (registeredStream) {
+      if (registeredStream.mediaTrack.id === mediaTrack.id) {
+        promises.push(_this.unregisterTechseeMediaStream(registeredStream, MediaConstants_1.MediaStreamUnregisterReason.ClosedRemotely));
+      }
+    });
+
+    return Promise.all(promises).then(function () {
+      return undefined;
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.removePublisher = function (publisher) {
+    this._publishers["delete"](publisher.destinationRole);
+
+    if (this._session && this._session.instance) {
+      trace.info('Removing publisher', publisher.destinationRole);
+      return this._session.instance.onMediaStreamDestroyed(publisher.destinationRole)["catch"](function (error) {
+        trace.warn('Error while removing publisher', error);
+      });
+    }
+
+    return Promise.resolve();
+  };
+
+  TechseeMediaServiceBase.prototype.getStreamForDestinationRole = function (destinationRole) {
+    var _this = this;
+
+    this.serviceInitGuard();
+
+    if (this._publishers.has(destinationRole)) {
+      trace.info("Publisher for " + destinationRole + " already exists");
+      return Promise.resolve(this._publishers.get(destinationRole).mediaStream);
+    }
+
+    if (!this._publisherPromises.get(destinationRole)) {
+      trace.info("Creating publisher for " + destinationRole);
+      var publisherPromise = this.initLocalMediaStreams().then(function () {
+        return _this.createMediaPublisher(destinationRole);
+      }).then(function (mediaPublisher) {
+        if (mediaPublisher) {
+          _this._publishers.set(destinationRole, mediaPublisher);
         }
-        return guards_1.throwableGuard(!!this._session, 'There no active session', shouldThrow);
-    };
-    return TechseeMediaServiceBase;
+
+        _this._publisherPromises["delete"](destinationRole);
+
+        return mediaPublisher ? mediaPublisher.mediaStream : null;
+      })["catch"](function (ex) {
+        if (ex && ex.message === 'audioStreamFailed') {
+          _this._isVoipEnabled = false;
+          return null;
+        }
+
+        _this._publisherPromises["delete"](destinationRole);
+
+        throw ex;
+      });
+
+      this._publisherPromises.set(destinationRole, publisherPromise);
+    } else {
+      trace.info("Create publisher promise for " + destinationRole + " already exists");
+    }
+
+    return this._publisherPromises.get(destinationRole);
+  };
+
+  TechseeMediaServiceBase.prototype.updateSubscribersWithNewStream = function (registeredStream) {
+    trace.info("Updating subscribers of " + registeredStream.streamType + " with new stream");
+
+    if (this._subscribers.size === 0) {
+      trace.warn("No subscribers exists for the " + registeredStream.streamType + ".");
+    } else {
+      trace.info("Total " + this._subscribers.size + " subscribers exists, will check if rerender needed.");
+    }
+
+    this._subscribers.forEach(function (subscriber) {
+      if (subscriber.streamType === registeredStream.streamType) {
+        trace.info(registeredStream.streamType + " rendering on subscriber");
+        subscriber.renderStream(registeredStream);
+      }
+    });
+
+    return Promise.resolve();
+  };
+
+  TechseeMediaServiceBase.prototype.bindClassMethods = function () {
+    this.updateSessionCredentials = this.updateSessionCredentials.bind(this);
+    this.getStreamForDestinationRole = this.getStreamForDestinationRole.bind(this);
+    this.registerRemoteMediaTrack = this.registerRemoteMediaTrack.bind(this);
+    this.unregisterRemoteMediaTrack = this.unregisterRemoteMediaTrack.bind(this);
+    this.createMediaPublisher = this.createMediaPublisher.bind(this);
+    this.updateSubscribersWithNewStream = this.updateSubscribersWithNewStream.bind(this);
+    this.initLocalMediaStreams = this.initLocalMediaStreams.bind(this);
+    this.onSessionDisconnectHandler = this.onSessionDisconnectHandler.bind(this);
+    this.clearService = this.clearService.bind(this);
+    this.clearRegisteredStreams = this.clearRegisteredStreams.bind(this);
+    this.clearPublishers = this.clearPublishers.bind(this);
+    this.clearSubscribers = this.clearSubscribers.bind(this);
+    this._connectToSession = this._connectToSession.bind(this);
+    this.disconnectFromMediaSession = this.disconnectFromMediaSession.bind(this);
+  }; //region Cleanup
+
+
+  TechseeMediaServiceBase.prototype.clearRegisteredStreams = function () {
+    var _this = this;
+
+    trace.info('Clearing registered streams');
+    var promises = [];
+
+    this._registeredStreams.forEach(function (streamToUnregister) {
+      promises.push(_this.unregisterTechseeMediaStream(streamToUnregister, MediaConstants_1.MediaStreamUnregisterReason.ServiceCleanUp));
+    });
+
+    return Promise.all(promises).then(function () {
+      return undefined;
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.clearSubscribers = function () {
+    var _this = this;
+
+    trace.info('Clearing subscribers');
+    var promises = [];
+
+    this._subscribers.forEach(function (subscriber) {
+      promises.push(_this.destroySubscriber(subscriber.container));
+    });
+
+    return Promise.all(promises).then(function () {
+      return undefined;
+    });
+  };
+
+  TechseeMediaServiceBase.prototype.clearPublishers = function () {
+    var _this = this;
+
+    trace.info('Clearing publishers');
+    var promises = [];
+
+    this._publishers.forEach(function (publisher) {
+      promises.push(_this.removePublisher(publisher));
+    });
+
+    return Promise.all(promises).then(function () {
+      return undefined;
+    });
+  }; //#endregion Cleanup
+  //#region Simple Validation Methods
+
+
+  TechseeMediaServiceBase.prototype.serviceInitGuard = function (shouldThrow) {
+    if (shouldThrow === void 0) {
+      shouldThrow = true;
+    }
+
+    return guards_1.throwableGuard(!!this._serviceOptions, 'Media service is not initialized', shouldThrow);
+  };
+
+  TechseeMediaServiceBase.prototype.sessionExistsGuard = function (shouldThrow) {
+    if (shouldThrow === void 0) {
+      shouldThrow = true;
+    }
+
+    return guards_1.throwableGuard(!!this._session, 'There no active session', shouldThrow);
+  };
+
+  return TechseeMediaServiceBase;
 }();
-exports.TechseeMediaServiceBase = TechseeMediaServiceBase;
 
-//# sourceMappingURL=MediaServiceBase.js.map
+exports.TechseeMediaServiceBase = TechseeMediaServiceBase;
 //# sourceMappingURL=MediaServiceBase.js.map