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

package/lib/MediaSession/SessionOpentok.js

@@ -1,381 +1,529 @@
 "use strict";
 
-var __extends = undefined && undefined.__extends || function () {
-    var _extendStatics = function extendStatics(d, b) {
-        _extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function (d, b) {
-            d.__proto__ = b;
-        } || function (d, b) {
-            for (var p in b) {
-                if (b.hasOwnProperty(p)) d[p] = b[p];
-            }
-        };
-        return _extendStatics(d, b);
-    };
-    return function (d, b) {
-        _extendStatics(d, b);
-        function __() {
-            this.constructor = d;
-        }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+var __extends = void 0 && (void 0).__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      }
     };
+
+    return _extendStatics(d, b);
+  };
+
+  return function (d, b) {
+    _extendStatics(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
 }();
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OpentokSession = void 0;
+
 var MediaConstants_1 = require("../MediaConstants");
+
 var guards_1 = require("@techsee/techsee-common/lib/core/guards");
+
 var MediaSessionBase_1 = require("./MediaSessionBase");
+
 var MediaTracer_1 = require("../MediaUtils/MediaTracer");
-var trace = MediaTracer_1.getMediaTracer('OpentokSession');
-//Currently this version supports subscribing only. Publishing will be implemented as needed.
-var OpentokSession = /** @class */function (_super) {
-    __extends(OpentokSession, _super);
-    function OpentokSession(sessionParams, streamFactory) {
-        var _this = _super.call(this, sessionParams, streamFactory) || this;
-        _this._session = null;
-        _this._credentials = sessionParams.credentials;
-        _this.connect = _this.connect.bind(_this);
-        _this.disconnect = _this.disconnect.bind(_this);
-        _this.onMediaStreamDestroyed = _this.onMediaStreamDestroyed.bind(_this);
-        _this.onMediaStreamRenewed = _this.onMediaStreamRenewed.bind(_this);
-        _this.createStreamForPublishing = _this.createStreamForPublishing.bind(_this);
-        _this.createMediaPublisher = _this.createMediaPublisher.bind(_this);
-        _this.connectionCreatedHandler = _this.connectionCreatedHandler.bind(_this);
-        _this.connectionDestroyedHandler = _this.connectionDestroyedHandler.bind(_this);
-        _this.streamCreatedHandler = _this.streamCreatedHandler.bind(_this);
-        _this.streamDestroyedHandler = _this.streamDestroyedHandler.bind(_this);
-        return _this;
+
+var trace = MediaTracer_1.getMediaTracer('OpentokSession'); //Currently this version supports subscribing only. Publishing will be implemented as needed.
+
+var OpentokSession =
+/** @class */
+function (_super) {
+  __extends(OpentokSession, _super);
+
+  function OpentokSession(sessionParams, streamFactory) {
+    var _this = _super.call(this, sessionParams, streamFactory) || this;
+
+    _this._lastStreamEvents = [];
+    _this._session = null;
+    _this._credentials = sessionParams.credentials;
+    _this.connect = _this.connect.bind(_this);
+    _this.disconnect = _this.disconnect.bind(_this);
+    _this.onMediaStreamDestroyed = _this.onMediaStreamDestroyed.bind(_this);
+    _this.onMediaStreamRenewed = _this.onMediaStreamRenewed.bind(_this);
+    _this.createStreamForPublishing = _this.createStreamForPublishing.bind(_this);
+    _this.createMediaPublisher = _this.createMediaPublisher.bind(_this);
+    _this.connectionCreatedHandler = _this.connectionCreatedHandler.bind(_this);
+    _this.connectionDestroyedHandler = _this.connectionDestroyedHandler.bind(_this);
+    _this.streamCreatedHandler = _this.streamCreatedHandler.bind(_this);
+    _this.streamDestroyedHandler = _this.streamDestroyedHandler.bind(_this);
+    return _this;
+  }
+
+  Object.defineProperty(OpentokSession.prototype, "id", {
+    get: function get() {
+      return this._session && this._session.sessionId ? this._session.sessionId : '';
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(OpentokSession.prototype, "ownPeerId", {
+    get: function get() {
+      return this._session && this._session.connection ? this._session.connection.connectionId : '';
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  OpentokSession.prototype.sessionDisconnect = function () {
+    if (this._session) {
+      this._session.disconnect();
+    }
+  };
+
+  OpentokSession.prototype.connect = function () {
+    var _this = this;
+
+    trace.info('Connect to session', this._credentials);
+
+    if (this._session) {
+      trace.error('Session already exists');
+      return Promise.reject('Cannot connect to session while another session is active');
     }
-    Object.defineProperty(OpentokSession.prototype, "id", {
-        get: function get() {
-            return this._session && this._session.sessionId ? this._session.sessionId : '';
-        },
-        enumerable: true,
-        configurable: true
+
+    return new Promise(function (resolve, reject) {
+      var handleError = function handleError(error) {
+        _this._session && _this._session.off();
+        _this._session = null;
+        trace.error('handleConnect error:', error);
+        reject(error);
+      };
+
+      var _a = _this._sessionParams.credentials,
+          apiKey = _a.apiKey,
+          sessionId = _a.sessionId;
+      _this._session = window.OTSESSION = window.OT.initSession(apiKey, sessionId);
+      _this._lastStreamEvents = [];
+
+      _this._session.on('connectionCreated', _this.connectionCreatedHandler);
+
+      _this._session.on('connectionDestroyed', _this.connectionDestroyedHandler);
+
+      _this._session.on('streamCreated', _this.streamCreatedHandler);
+
+      _this._session.on('streamDestroyed', _this.streamDestroyedHandler);
+
+      _this._session.on('archiveStarted', function (event) {
+        trace.info('archiveStarted event', event);
+
+        _this.emitEvent(MediaSessionBase_1.recordingEvents.RECORD_STARTED, event);
+      });
+
+      _this._session.on('archiveStopped', function (event) {
+        trace.info('archiveStopped event', event);
+
+        _this.emitEvent(MediaSessionBase_1.recordingEvents.RECORD_STOPPED, event);
+      });
+
+      var connectHandler = function connectHandler(error) {
+        if (error) {
+          handleError(error);
+          return;
+        }
+
+        resolve();
+      };
+
+      _this._session.connect(_this._credentials.token, connectHandler);
+    });
+  };
+
+  OpentokSession.prototype.disconnect = function () {
+    var _this = this;
+
+    return new Promise(function (resolve) {
+      trace.info('Disconnecting from session');
+      var currentSession = _this._session;
+      _this._session = null;
+
+      _this._peerConnections.forEach(function (peerConnection) {
+        _this.destroyPeerConnection(peerConnection);
+      });
+
+      if (!currentSession) {
+        trace.info('No active session - resolving');
+        resolve();
+        return;
+      }
+
+      currentSession.off();
+      currentSession.disconnect();
+      _this._lastStreamEvents = [];
+      trace.info('Disconnection from session completed');
+      resolve();
+    });
+  };
+
+  OpentokSession.prototype.onMediaStreamDestroyed = function (clientRole) {
+    var _this = this;
+
+    var promises = [];
+
+    this._peerConnections.forEach(function (peerConnection) {
+      if (peerConnection.peerRole === clientRole) {
+        promises.push(_this.destroyPublisherOnPeerConnection(peerConnection));
+      }
     });
-    Object.defineProperty(OpentokSession.prototype, "ownPeerId", {
-        get: function get() {
-            return this._session && this._session.connection ? this._session.connection.connectionId : '';
-        },
-        enumerable: true,
-        configurable: true
+
+    return Promise.all(promises).then(function () {
+      return undefined;
     });
-    OpentokSession.prototype.connect = function () {
-        var _this = this;
-        trace.info('Connect to session', this._credentials);
-        if (this._session) {
-            trace.error('Session already exists');
-            return Promise.reject('Cannot connect to session while another session is active');
+  };
+
+  OpentokSession.prototype.onMediaStreamRenewed = function (clientRole, mediaStream) {
+    //TODO - Alex: need to implement adding new tracks to peer connection and forcing negotiation (in OT API)
+    return Promise.resolve();
+  };
+
+  OpentokSession.prototype.replaceStreamTracks = function (mediaStream) {
+    return Promise.reject(new Error('Not implemented'));
+  };
+
+  OpentokSession.prototype.getRemoteTrackStats = function (mediaTrack) {
+    var _this = this;
+
+    return new Promise(function (resolve, reject) {
+      var peerConnectionOfTrack = _this.getPeerConnectionByMediaTrack(mediaTrack);
+
+      if (!peerConnectionOfTrack || !peerConnectionOfTrack.subscriber) {
+        reject(new Error('Cannot find peer or subscriber for getting stats'));
+        return;
+      } //https://tokbox.com/developer/sdks/js/reference/Subscriber.html#getStats
+
+
+      peerConnectionOfTrack.subscriber.getStats(function (error, stats) {
+        if (error) {
+          trace.warn('Error getting stats', error);
+          resolve({
+            trackId: mediaTrack.id,
+            trackStats: {}
+          });
+          return;
         }
-        return new Promise(function (resolve, reject) {
-            var handleError = function handleError(error) {
-                _this._session && _this._session.off();
-                _this._session = null;
-                trace.error('handleConnect error:', error);
-                reject(error);
-            };
-            var _a = _this._sessionParams.credentials,
-                apiKey = _a.apiKey,
-                sessionId = _a.sessionId;
-            _this._session = window.OTSESSION = window.OT.initSession(apiKey, sessionId);
-            _this._session.on('connectionCreated', _this.connectionCreatedHandler);
-            _this._session.on('connectionDestroyed', _this.connectionDestroyedHandler);
-            _this._session.on('streamCreated', _this.streamCreatedHandler);
-            _this._session.on('streamDestroyed', _this.streamDestroyedHandler);
-            var connectHandler = function connectHandler(error) {
-                if (error) {
-                    handleError(error);
-                    return;
-                }
-                resolve();
-            };
-            _this._session.connect(_this._credentials.token, connectHandler);
-        });
-    };
-    OpentokSession.prototype.disconnect = function () {
-        var _this = this;
-        return new Promise(function (resolve) {
-            trace.info('Disconnecting from session');
-            var currentSession = _this._session;
-            _this._session = null;
-            _this._peerConnections.forEach(function (peerConnection) {
-                _this.destroyPeerConnection(peerConnection);
-            });
-            if (!currentSession) {
-                trace.info('No active session - resolving');
-                resolve();
-                return;
-            }
-            currentSession.off();
-            currentSession.disconnect();
-            resolve();
-        });
-    };
-    OpentokSession.prototype.onMediaStreamDestroyed = function (clientRole) {
-        var _this = this;
-        var promises = [];
-        this._peerConnections.forEach(function (peerConnection) {
-            if (peerConnection.peerRole === clientRole) {
-                promises.push(_this.destroyPublisherOnPeerConnection(peerConnection));
-            }
-        });
-        return Promise.all(promises).then(function () {
-            return undefined;
+
+        resolve({
+          trackId: mediaTrack.id,
+          trackStats: stats
         });
-    };
-    OpentokSession.prototype.onMediaStreamRenewed = function (clientRole, mediaStream) {
-        //TODO - Alex: need to implement adding new tracks to peer connection and forcing negotiation (in OT API)
-        return Promise.resolve();
-    };
-    OpentokSession.prototype.getRemoteTrackStats = function (mediaTrack) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var peerConnectionOfTrack = _this.getPeerConnectionByMediaTrack(mediaTrack);
-            if (!peerConnectionOfTrack || !peerConnectionOfTrack.subscriber) {
-                reject(new Error('Cannot find peer or subscriber for getting stats'));
-            }
-            //https://tokbox.com/developer/sdks/js/reference/Subscriber.html#getStats
-            peerConnectionOfTrack.subscriber.getStats(function (error, stats) {
+      });
+    });
+  }; //#region OpenTok Events Handlers
+
+
+  OpentokSession.prototype.connectionCreatedHandler = function (event) {
+    var _this = this;
+
+    trace.info('connectionCreatedHandler', event);
+    var connection = event.connection;
+
+    if (!this.sessionExistsGuard(false) || !connection) {
+      return;
+    }
+
+    var destinationRole = JSON.parse(connection.data).clientRole;
+    this.createStreamForPublishing(destinationRole, connection.connectionId === this.ownPeerId).then(function (streams) {
+      var peerConnection = {
+        peerId: connection.connectionId,
+        peerRole: destinationRole,
+        peerType: _this._sessionParams.clientType === MediaConstants_1.SessionClientType.INITIATOR ? MediaConstants_1.SessionClientType.GUEST : MediaConstants_1.SessionClientType.INITIATOR,
+        connection: connection,
+        publisher: null,
+        subscriber: null,
+        remoteMediaTracks: [],
+        localStream: streams,
+        connectionTimoutPrt: null
+      };
+
+      if (connection.connectionId !== _this.ownPeerId || !streams.videoSource && !streams.audioSource) {
+        trace.info('Peer connection without publisher was created', peerConnection);
+        return peerConnection;
+      }
+
+      return _this.createMediaPublisher(streams).then(function (publisher) {
+        peerConnection.publisher = publisher;
+        trace.info('Peer connection with publisher was created', peerConnection);
+        return peerConnection;
+      });
+    }).then(function (peerConnection) {
+      _this._peerConnections.set(peerConnection.peerId, peerConnection);
+
+      if (connection.connectionId === _this.ownPeerId) {
+        trace.info('Before subscribe the event streams');
+        /*
+            When publisher connect after others participants,
+             make sure the publisher will not loose their stream to subscribe
+         */
+
+        return _this._lastStreamEvents.reduce(function (promiseChain, streamEvent) {
+          return promiseChain.then(function () {
+            return _this.streamCreatedHandler(streamEvent);
+          });
+        }, Promise.resolve()).then(function () {
+          if (peerConnection.publisher) {
+            return new Promise(function (resolve, reject) {
+              trace.info('Starting publish to peerConnection.publisher');
+
+              _this._session.publish(peerConnection.publisher, function (error) {
                 if (error) {
-                    trace.warn('Error getting stats', error);
-                    resolve({ trackId: mediaTrack.id, trackStats: {} });
-                    return;
+                  trace.error("Publish to peerConnection error " + error);
+                  return reject(error);
                 }
-                resolve({ trackId: mediaTrack.id, trackStats: stats });
-            });
-        });
-    };
-    //#region OpenTok Events Handlers
-    OpentokSession.prototype.connectionCreatedHandler = function (event) {
-        var _this = this;
-        trace.info('connectionCreatedHandler', event);
-        var connection = event.connection;
-        if (!this.sessionExistsGuard(false) || !connection) {
-            return;
-        }
-        //In case we got our own connection, we have nothing to do with it
-        if (connection.connectionId === this.ownPeerId) {
-            return;
-        }
-        var destinationRole = this.calculateDestinationRole();
-        this.createStreamForPublishing(destinationRole).then(function (streams) {
-            var peerConnection = {
-                peerId: connection.connectionId,
-                peerRole: destinationRole,
-                peerType: _this._sessionParams.clientType === MediaConstants_1.SessionClientType.INITIATOR ? MediaConstants_1.SessionClientType.GUEST : MediaConstants_1.SessionClientType.INITIATOR,
-                connection: connection,
-                publisher: null,
-                subscriber: null,
-                remoteMediaTracks: [],
-                localStream: streams,
-                connectionTimoutPrt: null
-            };
-            if (!streams.videoSource && !streams.audioSource) {
-                trace.info('Peer connection without publisher was created', peerConnection);
-                return peerConnection;
-            }
-            var streamName = destinationRole === MediaConstants_1.SessionClientRole.USER ? MediaConstants_1.KnownMediaStream.AGENT_AUDIO_STREAM : MediaConstants_1.KnownMediaStream.USER_VIDEO_STREAM;
-            return _this.createMediaPublisher(streams, streamName).then(function (publisher) {
-                peerConnection.publisher = publisher;
-                trace.info('Peer connection with publisher was created', peerConnection);
-                return peerConnection;
+
+                trace.info('Publish to peerConnection success');
+                return resolve();
+              });
             });
-        }).then(function (peerConnection) {
-            _this._peerConnections.set(peerConnection.peerId, peerConnection);
-            if (peerConnection.publisher) {
-                return new Promise(function (resolve, reject) {
-                    trace.info('Starting publish to peerConnection.publisher');
-                    _this._session.publish(peerConnection.publisher, function (error) {
-                        if (error) {
-                            trace.error('Publish to peerConnection error', error);
-                            return reject(error);
-                        }
-                        trace.info('Publish to peerConnection success');
-                        return resolve();
-                    });
-                });
-            }
-            return Promise.resolve();
-        }).catch(function (error) {
-            //Need to handle fail cases during reliability
-            trace.error('Error handling new peer connection', error);
+          }
+
+          return Promise.resolve();
         });
+      }
+    })["catch"](function (error) {
+      //Need to handle fail cases during reliability
+      trace.error("Error handling new peer connection: " + error);
+    });
+  };
+
+  OpentokSession.prototype.connectionDestroyedHandler = function (event) {
+    trace.info('connectionDestroyedHandler', event);
+    var connection = event.connection;
+
+    if (!this.sessionExistsGuard(false) || !connection) {
+      return;
+    }
+
+    if (this._peerConnections.has(connection.connectionId)) {
+      this.destroyPeerConnection(this._peerConnections.get(connection.connectionId));
+    }
+  };
+
+  OpentokSession.prototype.streamCreatedHandler = function (event) {
+    trace.info('streamCreatedHandler', event.stream);
+    var stream = event.stream;
+    var connection = (stream || {
+      connection: null
+    }).connection;
+
+    if (!this.sessionExistsGuard(false) || !stream || connection.connectionId === this.ownPeerId) {
+      return;
+    }
+
+    if (!this._peerConnections.has(connection.connectionId)) {
+      trace.warn('Unexpected case, connection should exist on this stage');
+
+      this._lastStreamEvents.push(event);
+
+      return;
+    }
+
+    var peerConnection = this._peerConnections.get(connection.connectionId);
+
+    trace.info('Subscribing the stream');
+    this.createMediaSubscriber(stream).then(function (subscriber) {
+      peerConnection.subscriber = subscriber;
+    });
+  };
+
+  OpentokSession.prototype.streamDestroyedHandler = function (event) {
+    trace.info('streamDestroyedHandler', event);
+    var stream = event.stream;
+
+    if (!this.sessionExistsGuard(false) || !stream) {
+      return;
+    }
+
+    var peerConnection = this._peerConnections.get(stream.connection.connectionId);
+
+    if (!peerConnection) {
+      trace.warn('Peer connection for remote stream not found');
+      return;
+    }
+
+    this.destroySubscriberOnPeerConnection(peerConnection)["catch"](function () {
+      return trace.warn('Error destroying subscriber on stream destroy');
+    });
+  }; //#endregion
+  //#region PeerConnection
+
+
+  OpentokSession.prototype.destroyPeerConnection = function (peerConnection) {
+    this._peerConnections["delete"](peerConnection.peerId);
+
+    this.destroyPublisherOnPeerConnection(peerConnection)["catch"](function () {
+      return trace.warn('Error destroying publisher on peer destroy');
+    });
+    this.destroySubscriberOnPeerConnection(peerConnection)["catch"](function () {
+      return trace.warn('Error destroying subscriber on peer destroy');
+    });
+  }; //#endregion
+  //#region Publisher
+
+
+  OpentokSession.prototype.createStreamForPublishing = function (destinationRole, shouldCreateStream) {
+    var _this = this;
+
+    trace.info('createStreamForPublishing');
+    var stream = {
+      videoSource: null,
+      audioSource: null
     };
-    OpentokSession.prototype.connectionDestroyedHandler = function (event) {
-        trace.info('connectionDestroyedHandler', event);
-        var connection = event.connection;
-        if (!this.sessionExistsGuard(false) || !connection) {
-            return;
-        }
-        if (this._peerConnections.has(connection.connectionId)) {
-            this.destroyPeerConnection(this._peerConnections.get(connection.connectionId));
-        }
-    };
-    OpentokSession.prototype.streamCreatedHandler = function (event) {
-        var _this = this;
-        trace.info('streamCreatedHandler', event.stream);
-        var stream = event.stream;
-        var connection = (stream || { connection: null }).connection;
-        if (!this.sessionExistsGuard(false) || !stream) {
-            return;
-        }
-        if (!this._peerConnections.has(connection.connectionId)) {
-            trace.warn('Unexpected case, connection should exist on this stage');
-            return;
-        }
-        var peerConnection = this._peerConnections.get(connection.connectionId);
-        trace.info('Subscribing the stream');
-        this.createMediaSubscriber(stream).then(function (subcriber) {
-            peerConnection.subscriber = subcriber;
-            peerConnection.subscriber.on('videoElementCreated', function (args) {
-                var element = args.element;
-                var otMediaStream = element.srcObject;
-                if (!otMediaStream) {
-                    trace.warn('MediaStream not found in OT video element');
-                    return;
-                }
-                trace.info('Registering remote media tracks', peerConnection.subscriber, otMediaStream);
-                otMediaStream.getTracks().forEach(function (mediaTrack) {
-                    _this.addRemoteTrackToPeer(peerConnection, mediaTrack);
-                });
-                _this.registerPeersRemoteTracks(peerConnection);
-            });
+
+    if (!shouldCreateStream) {
+      trace.info("createStreamForPublishing - destinationRole: " + destinationRole + " not supposed to create a stream");
+      return Promise.resolve(stream);
+    }
+
+    return this._sessionStreamsManager.getMediaStreamForRole(destinationRole).then(function (mediaStream) {
+      if (mediaStream) {
+        trace.info('Media stream found for publishing', mediaStream);
+        mediaStream.getTracks().forEach(function (track) {
+          if (track.kind === 'video') {
+            stream.videoSource = track;
+          } else if (track.kind === 'audio') {
+            stream.audioSource = track;
+          }
         });
+      } else if (_this._sessionParams.clientRole === MediaConstants_1.SessionClientRole.USER) {
+        trace.warn('No local media was found for publishing to destinationRole:', destinationRole);
+      }
+
+      return stream;
+    });
+  };
+
+  OpentokSession.prototype.createMediaPublisher = function (stream) {
+    var otParams = {
+      videoSource: stream.videoSource ? stream.videoSource : false,
+      audioSource: stream.audioSource ? stream.audioSource : false,
+      publishAudio: !!stream.audioSource,
+      publishVideo: !!stream.videoSource,
+      showControls: false,
+      insertDefaultUI: false
     };
-    OpentokSession.prototype.streamDestroyedHandler = function (event) {
-        trace.info('streamDestroyedHandler', event);
-        var stream = event.stream;
-        if (!this.sessionExistsGuard(false) || !stream) {
-            return;
-        }
-        var peerConnection = this._peerConnections.get(stream.connection.connectionId);
-        if (!peerConnection) {
-            trace.warn('Peer connection for remote stream not found');
-            return;
+    return new Promise(function (resolve, reject) {
+      var otPublisher = window.OT.initPublisher(undefined, otParams, function (error) {
+        if (error) {
+          reject(error);
+          return;
         }
-        this.destroySubscriberOnPeerConnection(peerConnection).catch(function () {
-            return undefined;
-        });
-    };
-    //#endregion
-    //#region PeerConnection
-    OpentokSession.prototype.destroyPeerConnection = function (peerConnection) {
-        this._peerConnections.delete(peerConnection.peerId);
-        this.destroyPublisherOnPeerConnection(peerConnection).catch(function () {
-            return undefined;
-        });
-        this.destroySubscriberOnPeerConnection(peerConnection).catch(function () {
-            return undefined;
-        });
-    };
-    //#endregion
-    //#region Publisher
-    OpentokSession.prototype.createStreamForPublishing = function (destinationRole) {
-        var _this = this;
-        trace.info('createStreamForPublishing');
-        return this._sessionStreamsManager.getMediaStreamForRole(destinationRole).then(function (mediaStream) {
-            var stream = { videoSource: null, audioSource: null };
-            if (mediaStream) {
-                trace.info('Media stream found for publishing', mediaStream);
-                mediaStream.getTracks().forEach(function (track) {
-                    if (track.kind === 'video') {
-                        stream.videoSource = track;
-                    } else if (track.kind === 'audio') {
-                        stream.audioSource = track;
-                    }
-                });
-            } else if (_this._sessionParams.clientRole === MediaConstants_1.SessionClientRole.USER) {
-                trace.warn('No local media was found for publishing to destinationRole:', destinationRole);
-            }
-            return stream;
+
+        otPublisher.on('streamDestroyed', function (event) {
+          trace.info('Publisher stream destroyed', event); //We preventing the default, in order to prevent stop the stream by OT.
+          //We managing streams by ourselves and if we allow OT to close the stream, it cannot be reused.
+
+          event.preventDefault();
         });
-    };
-    OpentokSession.prototype.createMediaPublisher = function (stream, streamName) {
-        var otParams = {
-            videoSource: stream.videoSource ? stream.videoSource : false,
-            audioSource: stream.audioSource ? stream.audioSource : false,
-            publishAudio: !!stream.audioSource,
-            publishVideo: !!stream.videoSource,
-            showControls: false,
-            name: streamName
-        };
-        return new Promise(function (resolve, reject) {
-            var otPublisher = window.OT.initPublisher(undefined, otParams, function (error) {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                otPublisher.on('streamDestroyed', function (event) {
-                    trace.info('Publisher stream destroyed', event);
-                    //We preventing the default, in order to prevent stop the stream by OT.
-                    //We managing streams by ourselves and if we allow OT to close the stream, it cannot be reused.
-                    event.preventDefault();
-                });
-                otPublisher.on('videoElementCreated', function (event) {
-                    document.getElementById(otPublisher.id).style.display = 'none';
-                    event.element.muted = true;
-                });
-                resolve(otPublisher);
-            });
+        otPublisher.on('videoElementCreated', function (event) {
+          event.element.muted = true;
         });
-    };
-    OpentokSession.prototype.destroyPublisherOnPeerConnection = function (peerConnection) {
-        if (this.sessionExistsGuard(false) && peerConnection.publisher) {
-            this._session.unpublish(peerConnection.publisher);
-        }
-        peerConnection.publisher = null;
-        peerConnection.localStream = null;
-        return Promise.resolve();
-    };
-    //#endregion
-    //#region Subscriber
-    OpentokSession.prototype.createMediaSubscriber = function (remoteStream) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            if (!_this.sessionExistsGuard(false)) {
-                reject('Session not exists');
-                return;
-            }
-            var subscriber = _this._session.subscribe(remoteStream, null, null, function (err) {
-                if (err) {
-                    trace.warn('Error creating subscriber', err);
-                    reject(err);
-                    return;
-                }
-                subscriber.on('videoElementCreated', function (event) {
-                    document.getElementById(subscriber.id).style.display = 'none';
-                    event.element.muted = true;
-                });
-                resolve(subscriber);
-            });
+        otPublisher.on('streamCreated', function (event) {
+          trace.info('publisher stream created', event, otPublisher.stream.hasAudio);
         });
-    };
-    OpentokSession.prototype.destroySubscriberOnPeerConnection = function (peerConnection) {
-        if (this.sessionExistsGuard(false) && peerConnection.subscriber) {
-            this._session.unsubscribe(peerConnection.subscriber);
+        resolve(otPublisher);
+      });
+    });
+  };
+
+  OpentokSession.prototype.destroyPublisherOnPeerConnection = function (peerConnection) {
+    if (this.sessionExistsGuard(false) && peerConnection.publisher) {
+      this._session.unpublish(peerConnection.publisher);
+    }
+
+    peerConnection.publisher = null;
+    peerConnection.localStream = null;
+    return Promise.resolve();
+  }; //#endregion
+  //#region Subscriber
+
+
+  OpentokSession.prototype.createMediaSubscriber = function (remoteStream) {
+    var _this = this;
+
+    return new Promise(function (resolve, reject) {
+      if (!_this.sessionExistsGuard(false)) {
+        reject('Session not exists');
+        return;
+      }
+
+      var subscriber = _this._session.subscribe(remoteStream, null, {
+        insertDefaultUI: false
+      }, function (err) {
+        if (err) {
+          trace.warn('Error creating subscriber', err);
+          reject(err);
+          return;
         }
-        return this.unregisterPeersRemoteMediaTracks(peerConnection).catch(function () {
-            return trace.warn('Error removing remote streams from peerConnection');
-        }).then(function () {
-            peerConnection.subscriber = null;
+
+        subscriber.on('videoElementCreated', function (event) {
+          var element = event.element;
+
+          var peerConnection = _this._peerConnections.get(remoteStream.connection.connectionId);
+
+          var otMediaStream = element.srcObject;
+          peerConnection.subscriber = subscriber;
+
+          if (!otMediaStream) {
+            trace.warn('MediaStream not found in OT video element');
+            return;
+          }
+
+          trace.info('Registering remote media tracks', peerConnection.subscriber, otMediaStream);
+          otMediaStream.getTracks().forEach(function (mediaTrack) {
+            _this.addRemoteTrackToPeer(peerConnection, mediaTrack);
+          });
+
+          _this.registerPeersRemoteTracks(peerConnection);
         });
-    };
-    //#endregion
-    OpentokSession.prototype.calculateDestinationRole = function () {
-        if (this._sessionParams.clientRole === MediaConstants_1.SessionClientRole.USER) {
-            var isAgentConnected = false;
-            return !isAgentConnected ? MediaConstants_1.SessionClientRole.AGENT : MediaConstants_1.SessionClientRole.OBSERVER;
-        }
-        return MediaConstants_1.SessionClientRole.USER;
-    };
-    OpentokSession.prototype.sessionExistsGuard = function (shouldThrow) {
-        if (shouldThrow === void 0) {
-            shouldThrow = true;
-        }
-        var connected = !!(this._session && this._session.connection && this._session.connection.connectionId);
-        return guards_1.throwableGuard(connected, 'There no OpenTok session exists', shouldThrow);
-    };
-    return OpentokSession;
+        resolve(subscriber);
+      });
+    });
+  };
+
+  OpentokSession.prototype.destroySubscriberOnPeerConnection = function (peerConnection) {
+    if (this.sessionExistsGuard(false) && peerConnection.subscriber) {
+      this._session.unsubscribe(peerConnection.subscriber);
+    }
+
+    peerConnection.subscriber = null;
+    return Promise.resolve();
+    /**
+     REMARK- opentok provide the same media track id for all participates.
+     when we unregister the media track we check by the id which is the same for all.
+     **/
+    // return this.unregisterPeersRemoteMediaTracks(peerConnection)
+    //     .catch(() => trace.warn('Error removing remote streams from peerConnection'))
+    //     .then(() => {
+    //         peerConnection.subscriber = null;
+    //     });
+  }; //#endregion
+
+
+  OpentokSession.prototype.sessionExistsGuard = function (shouldThrow) {
+    if (shouldThrow === void 0) {
+      shouldThrow = true;
+    }
+
+    var connected = !!(this._session && this._session.connection && this._session.connection.connectionId);
+    return guards_1.throwableGuard(connected, 'There no OpenTok session exists', shouldThrow);
+  };
+
+  return OpentokSession;
 }(MediaSessionBase_1.MediaSessionBase);
-exports.OpentokSession = OpentokSession;
 
-//# sourceMappingURL=SessionOpentok.js.map
+exports.OpentokSession = OpentokSession;
 //# sourceMappingURL=SessionOpentok.js.map