@techsee/techsee-media-service 999.20.0-nodejs20 → 999.20.2-alpha

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

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