@techsee/techsee-media-service 999.20.0-nodejs.lite.2 → 999.20.1-alpha

package/lib/oldCode/webrtc/stream.js

@@ -0,0 +1,674 @@
+'use strict';
+
+exports.__esModule = true;
+exports.TsWebRTCStream = exports.EVENTS = 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 _stream = require('../stream');
+
+var _session = require('../session');
+
+var _subscriber = require('../subscriber');
+
+var _constants = require('./constants');
+
+var _tsEnvironmentDetect = require('@techsee/techsee-common/lib/helpers/ts-environment-detect');
+
+var _retryWithTimeout = require('@techsee/techsee-common/lib/core/retry-with-timeout');
+
+var _tracer = require('../tracer');
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _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; }
+
+exports.EVENTS = _stream.EVENTS;
+
+
+var TORCH_DELAY = 1500;
+var isIE11 = new _tsEnvironmentDetect.TsEnvironmentDetect().isIE11();
+
+var tracer = (0, _tracer.getTracer)();
+
+/**
+ * WebRTC-specific implementation of TsMediaStream.
+ *
+ * Instances of this class are mostly used internally by TsMediaPublisher
+ * and for subscribers creating.
+ *
+ * @class
+ * @extends TsMediaStream
+ *
+ * @see TsMediaStream
+ */
+
+var TsWebRTCStream = exports.TsWebRTCStream = function (_TsMediaStream) {
+    _inherits(TsWebRTCStream, _TsMediaStream);
+
+    function TsWebRTCStream(session, mediaStream, name, isRemote, videoTrackSettings) {
+        _classCallCheck(this, TsWebRTCStream);
+
+        //In TurnWebRtcSessionV2, we keep connection on instance of stream.
+        var _this = _possibleConstructorReturn(this, _TsMediaStream.call(this, mediaStream.id, session, isRemote, videoTrackSettings));
+
+        _this.peerConnection = null;
+
+        _this._torchDelayTimeOut = null;
+        _this._torchOffTimeOut = null;
+
+        /**
+         * Browser's native media stream
+         *
+         * @public
+         * @member { Object }
+         *
+         * {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaStream MediaStream API}
+         */
+        _this._mediaStream = mediaStream;
+
+        /**
+         * Instance of TsWebRTCSession
+         *
+         * @private
+         * @member { Object }
+         *
+         * @see TsWebRTCSession
+         */
+        _this._session = session;
+
+        _this._name = name;
+
+        if (!_this._name) {
+            if (_this.hasVideo) {
+                if (!_this._session._isMobile) {
+                    _this._name = _constants.DEFAULT_STREAM_NAMES.MOBILE_CLIENT_VIDEO_STREAM;
+                }
+            } else if (_this.hasAudio) {
+                if (_this._session._isMobile) {
+                    _this._name = _this.remote ? _constants.DEFAULT_STREAM_NAMES.DASHBOARD_AUDIO_STREAM : _constants.DEFAULT_STREAM_NAMES.MOBILE_CLIENT_AUDIO_STREAM;
+                } else {
+                    _this._name = _this.remote ? _constants.DEFAULT_STREAM_NAMES.MOBILE_CLIENT_AUDIO_STREAM : _constants.DEFAULT_STREAM_NAMES.DASHBOARD_AUDIO_STREAM;
+                }
+            }
+        }
+
+        if (!_this._name) {
+            _this._name = Math.random().toString();
+        }
+
+        // TODO I think this will never be emitted, as both app/mobile call session.off() before they call session.disconnect(). And we call the destroy elsewhere
+        // TODO Need to make sure that it's always the case, especially for IOS
+        session.on(_session.EVENTS.DISCONNECTED, function () {
+            if (_this.publisher) {
+                _this.publisher.destroy();
+            }
+
+            if (_this.subscriber) {
+                _this.subscriber.destroy();
+            }
+        });
+        return _this;
+    }
+
+    /**
+     * Unique id of the stream
+     *
+     * @member { String }
+     * @type { String }
+     */
+
+
+    TsWebRTCStream.prototype._getPeerConnection = function _getPeerConnection() {
+        // KMS store the peer connection as _pc, TURN store it as _lastPc
+        return this.peerConnection || _.get(this._session, '_lastPc.peerConnection') || _.get(this._session, '_pc.peerConnection');
+    };
+
+    /**
+     * Publish or unpublish audio tracks.
+     *
+     * Used internally by TsMediaPublisher.publishAudio
+     *
+     * @method
+     *
+     * @param { Boolean } publish
+     *
+     * @fires SESSION_EVENTS.STREAM_PROPERTY_CHANGED
+     * @fires STREAM_EVENTS.PROPERTY_CHANGED
+     */
+
+
+    TsWebRTCStream.prototype.publishAudio = function publishAudio(publish) {
+        this._mediaStream.getTracks().forEach(function (track) {
+            if (track.kind === 'audio') {
+                if (track.setEnabled) {
+                    track.setEnabled(publish);
+                } else {
+                    track.enabled = publish;
+                }
+            }
+        });
+
+        this._session.emit(_session.EVENTS.STREAM_PROPERTY_CHANGED, {
+            stream: this,
+            property: 'hasAudio',
+            value: publish
+        });
+
+        this.emit(_stream.EVENTS.PROPERTY_CHANGED, {
+            stream: this,
+            property: 'hasAudio',
+            value: publish
+        });
+    };
+
+    /**
+     * Publish or unpublish video tracks.
+     *
+     * Used internally by TsMediaPublisher.publishVideo
+     *
+     * @method
+     *
+     * @param { Boolean } publish
+     *
+     * @fires SESSION_EVENTS.STREAM_PROPERTY_CHANGED
+     */
+
+
+    TsWebRTCStream.prototype.publishVideo = function publishVideo(publish) {
+        this._mediaStream.getTracks().forEach(function (track) {
+            if (track.kind === 'video') {
+                if (track.setEnabled) {
+                    track.setEnabled(publish);
+                } else {
+                    track.enabled = publish;
+                }
+            }
+        });
+
+        this._session.emit(_session.EVENTS.STREAM_PROPERTY_CHANGED, {
+            stream: this,
+            property: 'hasVideo',
+            value: publish
+        });
+    };
+
+    /**
+     * Subscribe to a remote stream.
+     *
+     * Used internally by TsMediaStream.subscribe
+     *
+     * @method
+     *
+     * @param { TsMediaStream } stream
+     * @param { DOMElement } target
+     * @param { Object } params
+     * @param { String|Number } params.height Subscriber's view height
+     * @param { String|Number } params.width Subscriber's view width
+     * @param { String } params.fitMode Subscriber's view fit mode
+     * @param { String } params.insertMode Subscriber's view insert mode (Is not in use yet)
+     *
+     * @returns { Promise<TsMediaSubscriber> } subsriber instance
+     *
+     * @see TsMediaStream
+     */
+
+
+    TsWebRTCStream.prototype.subscribe = function subscribe(target) {
+        var _this2 = this;
+
+        var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+            height: '100%',
+            width: '100%',
+            fitMode: 'contain',
+            insertMode: 'append'
+        };
+
+        if (!params) {
+            params = target;
+            target = null;
+        }
+
+        var elementHeight = typeof params.height === 'string' ? params.height : params.height + 'px';
+        var elementWidth = typeof params.width === 'string' ? params.width : params.width + 'px';
+
+        var bindVideoStreamToElement = function bindVideoStreamToElement(stream, target) {
+            return new Promise(function (resolve, reject) {
+                var doResolve = function doResolve(videoEl) {
+                    tracer.trace('Video element created successfully');
+                    resolve(videoEl);
+                };
+
+                var videoEl = document.createElement('video');
+                videoEl.muted = true;
+                videoEl.playsInline = true;
+
+                if (isIE11 && window.WebRTCAdapter) {
+                    target.appendChild(videoEl);
+                    window.WebRTCAdapter.bindVideoElement(videoEl);
+                }
+
+                videoEl.srcObject = stream;
+
+                if (!isIE11) {
+                    // Hack to override behavior introduced by Chrome/FF that unmuted video elements can't auto play
+                    videoEl.setAttribute('muted', '');
+                }
+
+                try {
+                    var playRes = videoEl.play();
+                    if (playRes && playRes.then) {
+                        playRes.then(function () {
+                            tracer.trace('Video element play success');
+                        });
+                    }
+
+                    if (playRes && playRes.catch) {
+                        playRes.catch(function (error) {
+                            tracer.trace('Reject while executing play method on video element', error);
+                        });
+                    }
+                } catch (error) {
+                    tracer.trace('Error while executing play method on video element', error);
+                }
+
+                if (isIE11) {
+                    var handleComplete = function handleComplete() {
+                        return videoEl.parentElement.tagName !== 'OBJECT';
+                    };
+
+                    var waitForObjectSettings = { intervalInMs: 30, timeoutInMs: 200 };
+
+                    (0, _retryWithTimeout.repeatWithTimeout)(handleComplete, waitForObjectSettings).then(function () {
+                        //We will wait, until video is played, then we resolve
+                        var isVideoPlaying = function isVideoPlaying() {
+                            return videoEl.videoHeight <= 0 || videoEl.videoWidth <= 0;
+                        };
+                        var waitForVideoSettings = { intervalInMs: 50, timeoutInMs: 10000 };
+                        (0, _retryWithTimeout.repeatWithTimeout)(isVideoPlaying, waitForVideoSettings).then(function () {
+                            return doResolve(videoEl.parentElement);
+                        }).catch(function () {
+                            return reject(new Error('Timeout while waiting for video to play'));
+                        });
+                    });
+                } else {
+                    target.appendChild(videoEl);
+                    doResolve(videoEl);
+                }
+            });
+        };
+
+        return bindVideoStreamToElement(this._mediaStream, target).then(function (videoEl) {
+            _.assign(videoEl.style, {
+                height: elementHeight,
+                width: elementWidth,
+
+                'object-fit': params.fitMode
+            });
+
+            var subscriber = new _subscriber.TsMediaSubscriber({
+                target: target,
+                _session: _this2._session,
+                stream: _this2,
+                _element: videoEl
+            });
+
+            _this2.setupDimensionsListener(videoEl, subscriber);
+
+            _this2.subscriber = subscriber;
+
+            return subscriber;
+        });
+    };
+
+    /**
+     * Unsubscribe from the stream and destroy subscriber's view.
+     *
+     * Used internally by TsMediaSubscriber.destroy.
+     *
+     * @method
+     *
+     * @param { TsMediaSubscriber } subscriber
+     *
+     * @returns { Promise }
+     *
+     * @fires SUBSCRIBER_EVENTS#DESTROYED
+     *
+     * @see TsMediaSubscriber#destroy
+     */
+
+
+    TsWebRTCStream.prototype.destroySubscriber = function destroySubscriber(subscriber) {
+        return new Promise(function (resolve) {
+            var doResolve = function doResolve() {
+                subscriber.emit(_subscriber.EVENTS.DESTROYED);
+                resolve();
+            };
+
+            if (isIE11 && window.WebRTCAdapter) {
+                var videoEl = subscriber._element.firstChild;
+                window.WebRTCAdapter.unBindVideoElement(videoEl);
+                if (videoEl && videoEl.parentNode && videoEl.parentNode.removeChild) {
+                    videoEl.parentNode.removeChild(videoEl);
+                    tracer.trace('Video element removed successfully');
+                } else {
+                    tracer.trace('Video element not removed', videoEl, videoEl.parentNode);
+                }
+                doResolve();
+            } else {
+                subscriber._element.remove();
+                doResolve();
+            }
+        });
+    };
+
+    /* eslint-disable no-unused-vars */
+
+
+    TsWebRTCStream.prototype.getSnapshot = function getSnapshot(tsMediaElement) {
+        var timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+        var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+            _ref$format = _ref.format,
+            format = _ref$format === undefined ? 'image/png' : _ref$format,
+            _ref$quality = _ref.quality,
+            quality = _ref$quality === undefined ? 0.92 : _ref$quality,
+            x = _ref.x,
+            y = _ref.y,
+            w = _ref.w,
+            h = _ref.h;
+
+        var videoElement = tsMediaElement._element;
+        var videoWidth = videoElement.videoWidth,
+            videoHeight = videoElement.videoHeight;
+
+        var crop = !_.isUndefined(x) && !_.isUndefined(y) && !_.isUndefined(w) && !_.isUndefined(h);
+        var resize = !crop && (!_.isUndefined(w) || !_.isUndefined(h));
+
+        if (resize) {
+            if (!h) {
+                h = w * (videoHeight / videoWidth);
+            } else if (!w) {
+                w = h * (videoWidth / videoHeight);
+            }
+        }
+
+        function getImgData() {
+            var canvas = document.createElement('canvas');
+            var ctx = canvas.getContext('2d');
+
+            if (crop) {
+                canvas.width = w;
+                canvas.height = h;
+
+                ctx.drawImage(videoElement, x, y, w, h, 0, 0, w, h);
+            } else if (resize) {
+                canvas.width = w;
+                canvas.height = h;
+
+                ctx.drawImage(videoElement, 0, 0, w, h);
+            } else {
+                canvas.height = videoHeight;
+                canvas.width = videoWidth;
+
+                ctx.drawImage(videoElement, 0, 0);
+            }
+
+            return canvas.toDataURL(format, quality);
+        }
+
+        function getImgDataIE11() {
+            return new Promise(function (resolve) {
+                var canvas = document.createElement('canvas');
+                var ctx = canvas.getContext('2d');
+
+                if (crop || resize) {
+                    canvas.width = w;
+                    canvas.height = h;
+                } else {
+                    canvas.height = videoHeight;
+                    canvas.width = videoWidth;
+                }
+
+                function _drawAndRemove(image) {
+                    if (crop) {
+                        ctx.drawImage(image, x, y, w, h, 0, 0, w, h);
+                    } else if (resize) {
+                        ctx.drawImage(image, 0, 0, w, h);
+                    } else {
+                        ctx.drawImage(image, 0, 0, videoWidth, videoHeight);
+                    }
+
+                    return canvas.toDataURL(format, quality);
+                }
+
+                var base64 = videoElement.getFrame();
+                var image = new Image();
+
+                image.onload = function () {
+                    return resolve(_drawAndRemove(image));
+                };
+                image.setAttribute('src', 'data:image/bmp;base64,' + base64);
+            });
+        }
+
+        return Promise.resolve(isIE11 ? getImgDataIE11() : getImgData()).then(function (imgData) {
+            if (!imgData || imgData.length < 10) {
+                return Promise.reject('Failed to get a snapshot');
+            }
+
+            return imgData;
+        });
+    };
+
+    /**
+     * Get statistics of the media subscription like bytes received.
+     *
+     * Used internally by TsMediaSubscriber.getStats
+     *
+     * @method
+     *
+     * @param { TsMediaSubscriber } subscriber
+     *
+     * @returns { Promise<ToBeDefined> } stats
+     *
+     * @see TsMediaSubscriber#getStats
+     */
+
+
+    TsWebRTCStream.prototype.getStats = function getStats(subscriber) {
+        var _this3 = this;
+
+        return new Promise(function (resolve) {
+            try {
+                var pc = _this3._getPeerConnection();
+
+                if (isIE11 || !pc) {
+                    return resolve();
+                }
+
+                pc.getStats(_this3._mediaStream.getVideoTracks()[0]).then(function (reports) {
+                    var matches = [];
+
+                    reports.forEach(function (report) {
+                        if (_.includes(['inbound-rtp', 'ssrc'], report.type)) {
+                            matches.push(report);
+                        }
+                    });
+
+                    return resolve({
+                        video: _.head(matches)
+                    });
+                });
+            } catch (e) {
+                // when this fails, it's most likely due ot no support for the getStats
+                // functionality, so we don't want to log this as a recurring error
+                resolve();
+            }
+        });
+    };
+
+    /* eslint-enable no-unused-vars */
+
+    TsWebRTCStream.prototype.getFullVideoStats = function getFullVideoStats() {
+        var _this4 = this;
+
+        return new Promise(function (resolve, reject) {
+            try {
+                var pc = _this4._getPeerConnection();
+
+                if (!pc) {
+                    return reject('NO_PEER_CONNECTION');
+                }
+
+                return resolve(pc.getStats(_this4._mediaStream.getVideoTracks()[0]));
+            } catch (e) {
+                reject(e);
+            }
+        });
+    };
+
+    TsWebRTCStream.prototype.turnFlashlight = function turnFlashlight() {
+        var _this5 = this;
+
+        var isTorchOn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+
+        return new Promise(function (resolve, reject) {
+            if (_this5._torchDelayTimeOut) {
+                return reject('No tourch delay');
+            }
+
+            if (!navigator || !navigator.mediaDevices) {
+                return reject('No mediaDevices');
+            }
+
+            var track = _this5._mediaStream.getVideoTracks()[0];
+
+            if (!track) {
+                return reject('No track');
+            }
+            if (_this5._torchOffTimeOut) {
+                clearInterval(_this5._torchOffTimeOut);
+                _this5._torchOffTimeOut = null;
+            }
+
+            _this5._torchDelayTimeOut = setTimeout(function () {
+                var capatibilitiesAfter = {};
+
+                try {
+                    capatibilitiesAfter = track.getCapabilities();
+                } catch (e) {
+                    return reject('No capabilities');
+                }
+
+                if (!capatibilitiesAfter.torch) {
+                    return reject('No tourch capabilities');
+                }
+
+                return track.applyConstraints({
+                    advanced: [{
+                        torch: isTorchOn
+                    }]
+                }).then(function () {
+                    _this5._torchDelayTimeOut = null;
+                    resolve(true);
+                }).catch(function (e) {
+                    _this5._torchDelayTimeOut = null;
+                    console.error(e);
+                    reject('Can\'t turn on the light, please try later!');
+                });
+            }, TORCH_DELAY);
+        });
+    };
+
+    TsWebRTCStream.prototype.setAutoLightOffTimer = function setAutoLightOffTimer(flashlightTimeout) {
+        var _this6 = this;
+
+        return new Promise(function (resolve) {
+            if (!flashlightTimeout) {
+                return reject('No timeout');
+            }
+
+            var track = _this6._mediaStream.getVideoTracks()[0];
+
+            if (!track) {
+                return reject('No track');
+            }
+
+            _this6._torchOffTimeOut = setTimeout(function () {
+
+                if (!track) {
+                    return reject('No track');
+                }
+
+                track.applyConstraints({
+                    advanced: [{
+                        torch: false
+                    }]
+                }).then(function () {
+                    _this6._torchOffTimeOut = null;
+                    resolve();
+                });
+            }, flashlightTimeout);
+        });
+    };
+
+    _createClass(TsWebRTCStream, [{
+        key: 'id',
+        get: function get() {
+            return this._mediaStream.id;
+        }
+
+        /**
+         * Unique name of the stream
+         *
+         * @member { String }
+         * @type { String }
+         */
+
+    }, {
+        key: 'name',
+        get: function get() {
+            return this._name;
+        }
+
+        /**
+         * Whether or not stream has enabled video tracks
+         *
+         * @member { Boolean }
+         * @type { Boolean }
+         */
+
+    }, {
+        key: 'hasVideo',
+        get: function get() {
+            var enabledVideoTracks = this._mediaStream.getVideoTracks().filter(function (track) {
+                return track.enabled;
+            });
+
+            return enabledVideoTracks.length > 0;
+        }
+
+        /**
+         * Whether or not stream has enabled audio tracks
+         *
+         * @member { Boolean }
+         * @type { Boolean }
+         */
+
+    }, {
+        key: 'hasAudio',
+        get: function get() {
+            var enabledAudioTracks = this._mediaStream.getAudioTracks().filter(function (track) {
+                return track.enabled;
+            });
+
+            return enabledAudioTracks.length > 0;
+        }
+    }]);
+
+    return TsWebRTCStream;
+}(_stream.TsMediaStream);
+//# sourceMappingURL=stream.js.map