@techsee/techsee-media-service 0.6.0 → 0.6.1-alpha.1

package/lib/MediaServiceBase.js

@@ -0,0 +1,591 @@
+"use strict";
+
+var __importDefault = undefined && undefined.__importDefault || function (mod) {
+    return mod && mod.__esModule ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 events_1 = require("events");
+var MediaSubscriber_1 = require("./MediaSubscriber");
+var LocalStreamManager_1 = require("./LocalStreamManager");
+var TechseeMediaStream_1 = require("./TechseeMediaStream");
+var SessionTurn_v3_1 = require("./Session/SessionTurn.v3");
+var MediaDomUtils_1 = require("./Utils/MediaDomUtils");
+var Compatibility_1 = require("./Utils/Compatibility");
+var SessionOpentok_v3_1 = require("./Session/SessionOpentok.v3");
+var MediaConstants_1 = require("./MediaConstants");
+var guards_1 = require("@techsee/techsee-common/lib/core/guards");
+var MediaTracer_1 = require("./Utils/MediaTracer");
+var trace = MediaTracer_1.getMediaTracer('MediaServiceBase');
+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 || (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._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
+        };
+    }
+    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
+    });
+    /*
+        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._deviceSupportFlags.hasCamera = groupedDevices.video.length > 0;
+            _this._deviceSupportFlags.hasMicrophone = 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
+                };
+                trace.info('connectToSession', sessionParams);
+                if (_this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.TURNSERVER) {
+                    _this._session.instance = new SessionTurn_v3_1.TurnWebRtcSessionV3(sessionParams, sessionHandlers, _this._sessionStreamsManager);
+                } else if (_this._serviceOptions.mediaServiceType === MediaConstants_1.MediaServiceType.OPENTOK) {
+                    _this._session.instance = new SessionOpentok_v3_1.OpentokSessionV3(sessionParams, _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 () {
+        if (!this._session) {
+            return Promise.resolve();
+        }
+        var lastSession = this._session;
+        this._session = null;
+        trace.info('Disconnecting from session');
+        return Promise.all([lastSession.instance.disconnect(), this.clearPublishers()]).then(function () {
+            return undefined;
+        });
+    };
+    /*
+        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.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.disconnectFromSession().then(function () {
+                if (lastParams_1 && reason === MediaConstants_1.MediaSessionDisconnectReason.UserPeerReconnected) {
+                    trace.info('Reconnecting to media session, sessionParams:', lastParams_1);
+                    _this.connectToSession(lastParams_1).then(function () {
+                        trace.info('Media session reconnected');
+                    }).catch(function (error) {
+                        trace.error('Error while reconnecting to media session');
+                    });
+                }
+            });
+        } else {
+            trace.info('Ignore Session disconnect event');
+        }
+    };
+    //#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.disconnectFromSession().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
+    });
+    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.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.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);
+            });
+        };
+        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 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;
+        });
+    };
+    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);
+                }
+                _this._publisherPromises.delete(destinationRole);
+                return mediaPublisher ? mediaPublisher.mediaStream : null;
+            }).catch(function (ex) {
+                _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);
+    };
+    //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
+//# sourceMappingURL=MediaServiceBase.js.map