@techsee/techsee-media-service 999.17.99-alphasa01 → 999.17.111-alphasa01

package/dist/Live2/LocalStreamManager.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,344 +17,418 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalStreamManager = void 0;
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /*eslint-disable operator-linebreak */
-const assign_1 = __importDefault(require("lodash/assign"));
-const get_1 = __importDefault(require("lodash/get"));
-const last_1 = __importDefault(require("lodash/last"));
-const first_1 = __importDefault(require("lodash/first"));
-const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
-const bluebird_1 = require("bluebird");
-const MediaConstants_1 = require("./MediaConstants");
-const MediaTracer_1 = require("./MediaUtils/MediaTracer");
+var assign_1 = __importDefault(require("lodash/assign"));
+var get_1 = __importDefault(require("lodash/get"));
+var last_1 = __importDefault(require("lodash/last"));
+var first_1 = __importDefault(require("lodash/first"));
+var cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+var bluebird_1 = require("bluebird");
+var MediaConstants_1 = require("./MediaConstants");
+var MediaTracer_1 = require("./MediaUtils/MediaTracer");
 window.latestUserMediaStream = null;
-let userMediaPromise = null;
+var userMediaPromise = null;
 window.latestDesktopMediaStream = null;
-let desktopMediaPromise = null;
+var desktopMediaPromise = null;
 window.mediaStreamAlreadyReplaced = false;
 window.latestLocalMediaConstraints = null;
-const trace = (0, MediaTracer_1.getMediaTracer)('LocalStreamManager');
-class LocalStreamManager {
-    environment;
-    _groupedDevices = { video: null, audio: null, camerasCount: 0 };
-    constructor(environment) {
+var trace = (0, MediaTracer_1.getMediaTracer)('LocalStreamManager');
+var LocalStreamManager = /** @class */ (function () {
+    function LocalStreamManager(environment) {
+        Object.defineProperty(this, "environment", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_groupedDevices", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { video: null, audio: null, camerasCount: 0 }
+        });
         this.environment = environment;
         this.parseMediaErrorThenThrow = this.parseMediaErrorThenThrow.bind(this);
         this.clearAllStreams = this.clearAllStreams.bind(this);
     }
-    get groupedDevices() {
-        return this._groupedDevices;
-    }
-    getUserMediaStream(constraints) {
-        trace.info('getUserMediaStream', constraints);
-        if (userMediaPromise) {
-            return userMediaPromise;
-        }
-        if (window.latestUserMediaStream) {
-            const videoTrack = window.latestUserMediaStream.mediaStream.getVideoTracks();
-            if (videoTrack.length > 0 && videoTrack[0].readyState === 'live') {
-                return bluebird_1.Promise.resolve({ ...window.latestUserMediaStream, isNew: false });
+    Object.defineProperty(LocalStreamManager.prototype, "groupedDevices", {
+        get: function () {
+            return this._groupedDevices;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "getUserMediaStream", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (constraints) {
+            var _this = this;
+            trace.info('getUserMediaStream', constraints);
+            if (userMediaPromise) {
+                return userMediaPromise;
             }
-            this.destroyUserMediaStream();
-        }
-        userMediaPromise = new bluebird_1.Promise((resolve, reject) => {
-            const catchHandler = (err) => {
-                userMediaPromise = null;
-                window.latestUserMediaStream = null;
-                trace.error('getUserMedia error', err);
-                reject(err);
-            };
-            try {
-                this.getHighestResolutionStream(false, constraints)
-                    .then((streamResult) => {
+            if (window.latestUserMediaStream) {
+                var videoTrack = window.latestUserMediaStream.mediaStream.getVideoTracks();
+                if (videoTrack.length > 0 && videoTrack[0].readyState === 'live') {
+                    return bluebird_1.Promise.resolve(__assign(__assign({}, window.latestUserMediaStream), { isNew: false }));
+                }
+                this.destroyUserMediaStream();
+            }
+            userMediaPromise = new bluebird_1.Promise(function (resolve, reject) {
+                var catchHandler = function (err) {
                     userMediaPromise = null;
-                    window.latestUserMediaStream = streamResult;
-                    window.latestLocalMediaConstraints = (0, cloneDeep_1.default)(constraints);
-                    window.latestLocalMediaConstraints.audio = (streamResult.constraint &&
-                        streamResult.constraint.audio);
-                    resolve({ ...window.latestUserMediaStream, isNew: true });
-                })
-                    .catch(catchHandler);
+                    window.latestUserMediaStream = null;
+                    trace.error('getUserMedia error', err);
+                    reject(err);
+                };
+                try {
+                    _this.getHighestResolutionStream(false, constraints)
+                        .then(function (streamResult) {
+                        userMediaPromise = null;
+                        window.latestUserMediaStream = streamResult;
+                        window.latestLocalMediaConstraints = (0, cloneDeep_1.default)(constraints);
+                        window.latestLocalMediaConstraints.audio = (streamResult.constraint &&
+                            streamResult.constraint.audio);
+                        resolve(__assign(__assign({}, window.latestUserMediaStream), { isNew: true }));
+                    })
+                        .catch(catchHandler);
+                }
+                catch (err) {
+                    catchHandler(err);
+                }
+            });
+            return userMediaPromise;
+        }
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "getDesktopMediaStream", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (constraints) {
+            var _this = this;
+            if (desktopMediaPromise) {
+                return desktopMediaPromise;
             }
-            catch (err) {
-                catchHandler(err);
+            trace.info('getDesktopMediaStream', constraints);
+            if (window.latestDesktopMediaStream) {
+                var track = window.latestDesktopMediaStream.mediaStream.getVideoTracks();
+                if (track.length > 0 && track[0].readyState === 'live') {
+                    //return Promise.resolve();
+                    return bluebird_1.Promise.resolve(__assign(__assign({}, window.latestDesktopMediaStream), { isNew: false }));
+                }
+                this.destroyDesktopMediaStream().catch(function (error) {
+                    trace.error('Error destroying desktop media stream', error);
+                });
             }
-        });
-        return userMediaPromise;
-    }
-    getDesktopMediaStream(constraints) {
-        if (desktopMediaPromise) {
+            desktopMediaPromise = new bluebird_1.Promise(function (resolve, reject) {
+                var mediaCatchHandler = function (err) {
+                    desktopMediaPromise = null;
+                    window.latestDesktopMediaStream = null;
+                    trace.error('getDisplayMedia error', err);
+                    reject(err);
+                };
+                try {
+                    _this.getHighestResolutionStream(true, { video: constraints, audio: false })
+                        .then(function (streamResult) {
+                        desktopMediaPromise = null;
+                        window.latestDesktopMediaStream = streamResult;
+                        resolve(__assign(__assign({}, window.latestDesktopMediaStream), { isNew: true }));
+                    })
+                        .catch(mediaCatchHandler);
+                }
+                catch (err) {
+                    mediaCatchHandler(err);
+                }
+            });
             return desktopMediaPromise;
         }
-        trace.info('getDesktopMediaStream', constraints);
-        if (window.latestDesktopMediaStream) {
-            const track = window.latestDesktopMediaStream.mediaStream.getVideoTracks();
-            if (track.length > 0 && track[0].readyState === 'live') {
-                //return Promise.resolve();
-                return bluebird_1.Promise.resolve({ ...window.latestDesktopMediaStream, isNew: false });
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "destroyUserMediaStream", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var streamResult = window.latestUserMediaStream;
+            userMediaPromise = null;
+            window.latestUserMediaStream = null;
+            window.latestLocalMediaConstraints = null;
+            window.mediaStreamAlreadyReplaced = false;
+            if (streamResult && streamResult.mediaStream) {
+                try {
+                    streamResult.mediaStream.getTracks().forEach(function (track) {
+                        track.stop();
+                    });
+                    trace.info('destroyUserMediaStream - stop all tracks');
+                }
+                catch (e) {
+                    trace.info('destroyUserMediaStream - Failed to stop all tracks', e);
+                }
             }
-            this.destroyDesktopMediaStream().catch((error) => {
-                trace.error('Error destroying desktop media stream', error);
-            });
+            return bluebird_1.Promise.resolve();
         }
-        desktopMediaPromise = new bluebird_1.Promise((resolve, reject) => {
-            const mediaCatchHandler = (err) => {
-                desktopMediaPromise = null;
-                window.latestDesktopMediaStream = null;
-                trace.error('getDisplayMedia error', err);
-                reject(err);
-            };
-            try {
-                this.getHighestResolutionStream(true, { video: constraints, audio: false })
-                    .then((streamResult) => {
-                    desktopMediaPromise = null;
-                    window.latestDesktopMediaStream = streamResult;
-                    resolve({ ...window.latestDesktopMediaStream, isNew: true });
-                })
-                    .catch(mediaCatchHandler);
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "destroyDesktopMediaStream", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var streamResult = window.latestDesktopMediaStream;
+            window.latestDesktopMediaStream = null;
+            desktopMediaPromise = null;
+            if (streamResult && streamResult.mediaStream) {
+                try {
+                    streamResult.mediaStream.getTracks().forEach(function (track) {
+                        track.stop();
+                    });
+                    trace.info('destroyDesktopMediaStream - stop all tracks');
+                }
+                catch (e) {
+                    trace.info('destroyDesktopMediaStream - Failed to stop all tracks', e);
+                }
             }
-            catch (err) {
-                mediaCatchHandler(err);
+            return bluebird_1.Promise.resolve();
+        }
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "clearAllStreams", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            trace.info('LocalStreamManager Clearing all streams');
+            return bluebird_1.Promise.all([this.destroyDesktopMediaStream(), this.destroyUserMediaStream()]).then(function () { return undefined; });
+        }
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "getHighestResolutionStream", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (isDesktopMedia, constraints) {
+            var _this = this;
+            var constraintsCandidates = this.getParsedConstraints(isDesktopMedia, constraints);
+            trace.info('getHighestResolutionStream - constraintsCandidates:', constraintsCandidates);
+            if (constraintsCandidates.length === 0) {
+                return bluebird_1.Promise.reject(new Error('No constraints to retrieve the stream'));
             }
-        });
-        return desktopMediaPromise;
-    }
-    destroyUserMediaStream() {
-        const streamResult = window.latestUserMediaStream;
-        userMediaPromise = null;
-        window.latestUserMediaStream = null;
-        window.latestLocalMediaConstraints = null;
-        window.mediaStreamAlreadyReplaced = false;
-        if (streamResult && streamResult.mediaStream) {
-            try {
-                streamResult.mediaStream.getTracks().forEach((track) => {
-                    track.stop();
+            return new bluebird_1.Promise(function (resolve, reject) {
+                var lastSuccessfulResult = null;
+                var lastFailedResult = null;
+                var isStreamRequestFulfilled = false;
+                bluebird_1.Promise
+                    .reduce(constraintsCandidates, function (total, candidate) {
+                    if (isStreamRequestFulfilled) {
+                        return;
+                    }
+                    var constraintType = (0, get_1.default)(constraints, 'video.videoResolution.constraintType') ||
+                        (0, get_1.default)(constraints, 'video.videoResolution[0].constraintType');
+                    return _this.getStreamPromiseByParsedConstraints(candidate, isDesktopMedia)
+                        .then(function (stream) {
+                        lastSuccessfulResult = {
+                            mediaStream: stream,
+                            constraint: candidate,
+                            constraintType: constraintType,
+                            isNew: true
+                        };
+                        trace.info('getHighestResolutionStream Success', lastSuccessfulResult);
+                        isStreamRequestFulfilled = true;
+                        resolve(lastSuccessfulResult);
+                    })
+                        .catch(function (failResult) {
+                        lastFailedResult = failResult;
+                        if (lastFailedResult.errorCode === MediaConstants_1.MediaRequestErrorCode.PermissionDenied) {
+                            isStreamRequestFulfilled = true;
+                            reject(lastFailedResult);
+                        }
+                    });
+                }, 0)
+                    .then(function () {
+                    if (!isStreamRequestFulfilled) {
+                        if (!lastFailedResult) {
+                            lastFailedResult = {
+                                errorCode: MediaConstants_1.MediaRequestErrorCode.GeneralError,
+                                message: 'Suitable stream cannot be created'
+                            };
+                        }
+                        reject(lastFailedResult);
+                    }
                 });
-                trace.info('destroyUserMediaStream - stop all tracks');
+            });
+        }
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "getUserMediaStreamMediaDevice", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (constraints, isDesktopMedia) {
+            var streamPromise = null;
+            if (!isDesktopMedia) {
+                streamPromise = navigator.mediaDevices.getUserMedia(constraints);
             }
-            catch (e) {
-                trace.info('destroyUserMediaStream - Failed to stop all tracks', e);
+            else {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                //@ts-ignore
+                streamPromise = navigator.mediaDevices.getDisplayMedia
+                    ? // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        navigator.mediaDevices.getDisplayMedia(constraints)
+                    : // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        navigator.getDisplayMedia(constraints);
             }
+            return streamPromise;
         }
-        return bluebird_1.Promise.resolve();
-    }
-    destroyDesktopMediaStream() {
-        const streamResult = window.latestDesktopMediaStream;
-        window.latestDesktopMediaStream = null;
-        desktopMediaPromise = null;
-        if (streamResult && streamResult.mediaStream) {
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "getStreamPromiseByParsedConstraints", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (constraints, isDesktopMedia) {
+            var _this = this;
+            trace.info('getStreamPromiseByParsedConstraints', constraints);
             try {
-                streamResult.mediaStream.getTracks().forEach((track) => {
-                    track.stop();
+                return this.getUserMediaStreamMediaDevice(constraints, isDesktopMedia).catch(function (err) {
+                    var streamPromise = null;
+                    trace.info('getStreamPromiseByParsedConstraints - get user stream error', err.name);
+                    // Android (Galaxy esp.) have a bug that when using facingMode it might cause NotReadableError. So
+                    // we should try again but without facingMode. The exception to the rule is when we don't have specific
+                    // device to use (like in IOS13 bug, as can be seen in MediaServiceBase.ts), in that case, we might end
+                    // up using the front camera, which is a privacy concern and the preference is to fallback from video
+                    if (err &&
+                        err.name === 'NotReadableError' &&
+                        (0, get_1.default)(constraints, 'video.facingMode') &&
+                        (0, get_1.default)(constraints, 'video.deviceId')) {
+                        var newConstraints = constraints;
+                        trace.info("getStreamPromiseByParsedConstraints - NotReadableError - Failed to get video user media stream with facingMode=".concat((0, get_1.default)(constraints, 'video.facingMode')), err.name);
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        delete newConstraints.video.facingMode;
+                        newConstraints.video.deviceId = {
+                            exact: constraints.video.deviceId
+                        };
+                        streamPromise = _this.getStreamPromiseByParsedConstraints(newConstraints, isDesktopMedia);
+                    }
+                    else if (err && err.name && constraints.audio && !constraints.video) {
+                        trace.info('getStreamPromiseByParsedConstraints - audioStreamFailed - Failed to get audio user media stream', err.name);
+                        return _this.parseMediaErrorThenThrow({ name: 'audioStreamFailed' });
+                    }
+                    else if (err && err.name && constraints.audio) {
+                        var newConstraints = constraints;
+                        trace.info('getStreamPromiseByParsedConstraints - Failed to get video and audio user media stream, try to get video media stream only', err.name);
+                        newConstraints.audio = false;
+                        streamPromise = _this.getStreamPromiseByParsedConstraints(newConstraints, isDesktopMedia);
+                    }
+                    else if (err && !streamPromise) {
+                        trace.info('getStreamPromiseByParsedConstraints - Failed to get video user media stream', err && err.name);
+                        streamPromise = bluebird_1.Promise.reject(err);
+                    }
+                    return streamPromise && streamPromise.catch(_this.parseMediaErrorThenThrow);
                 });
-                trace.info('destroyDesktopMediaStream - stop all tracks');
             }
             catch (e) {
-                trace.info('destroyDesktopMediaStream - Failed to stop all tracks', e);
+                // @ts-ignore
+                return this.parseMediaErrorThenThrow(e);
             }
         }
-        return bluebird_1.Promise.resolve();
-    }
-    clearAllStreams() {
-        trace.info('LocalStreamManager Clearing all streams');
-        return bluebird_1.Promise.all([this.destroyDesktopMediaStream(), this.destroyUserMediaStream()]).then(() => undefined);
-    }
-    getHighestResolutionStream(isDesktopMedia, constraints) {
-        const constraintsCandidates = this.getParsedConstraints(isDesktopMedia, constraints);
-        trace.info('getHighestResolutionStream - constraintsCandidates:', constraintsCandidates);
-        if (constraintsCandidates.length === 0) {
-            return bluebird_1.Promise.reject(new Error('No constraints to retrieve the stream'));
-        }
-        return new bluebird_1.Promise((resolve, reject) => {
-            let lastSuccessfulResult = null;
-            let lastFailedResult = null;
-            let isStreamRequestFulfilled = false;
-            bluebird_1.Promise
-                .reduce(constraintsCandidates, (total, candidate) => {
-                if (isStreamRequestFulfilled) {
-                    return;
-                }
-                const constraintType = (0, get_1.default)(constraints, 'video.videoResolution.constraintType') ||
-                    (0, get_1.default)(constraints, 'video.videoResolution[0].constraintType');
-                return this.getStreamPromiseByParsedConstraints(candidate, isDesktopMedia)
-                    .then((stream) => {
-                    lastSuccessfulResult = {
-                        mediaStream: stream,
-                        constraint: candidate,
-                        constraintType,
-                        isNew: true
-                    };
-                    trace.info('getHighestResolutionStream Success', lastSuccessfulResult);
-                    isStreamRequestFulfilled = true;
-                    resolve(lastSuccessfulResult);
-                })
-                    .catch((failResult) => {
-                    lastFailedResult = failResult;
-                    if (lastFailedResult.errorCode === MediaConstants_1.MediaRequestErrorCode.PermissionDenied) {
-                        isStreamRequestFulfilled = true;
-                        reject(lastFailedResult);
-                    }
-                });
-            }, 0)
-                .then(() => {
-                if (!isStreamRequestFulfilled) {
-                    if (!lastFailedResult) {
-                        lastFailedResult = {
-                            errorCode: MediaConstants_1.MediaRequestErrorCode.GeneralError,
-                            message: 'Suitable stream cannot be created'
-                        };
-                    }
-                    reject(lastFailedResult);
-                }
-            });
-        });
-    }
-    getUserMediaStreamMediaDevice(constraints, isDesktopMedia) {
-        let streamPromise = null;
-        if (!isDesktopMedia) {
-            streamPromise = navigator.mediaDevices.getUserMedia(constraints);
-        }
-        else {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            //@ts-ignore
-            streamPromise = navigator.mediaDevices.getDisplayMedia
-                ? // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    //@ts-ignore
-                    navigator.mediaDevices.getDisplayMedia(constraints)
-                : // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    //@ts-ignore
-                    navigator.getDisplayMedia(constraints);
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "setGroupedDevices", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (groupedDevices) {
+            var _a;
+            trace.info('setGroupedDevices', groupedDevices);
+            this._groupedDevices = {
+                video: groupedDevices.video
+                    ? (_a = {}, _a[MediaConstants_1.CameraTypes.BACK] = (0, last_1.default)(groupedDevices.video), _a[MediaConstants_1.CameraTypes.FRONT] = (0, first_1.default)(groupedDevices.video), _a) : null,
+                audio: (0, last_1.default)(groupedDevices.audio) || null,
+                camerasCount: groupedDevices.video.length
+            };
         }
-        return streamPromise;
-    }
-    getStreamPromiseByParsedConstraints(constraints, isDesktopMedia) {
-        trace.info('getStreamPromiseByParsedConstraints', constraints);
-        try {
-            return this.getUserMediaStreamMediaDevice(constraints, isDesktopMedia).catch((err) => {
-                let streamPromise = null;
-                trace.info('getStreamPromiseByParsedConstraints - get user stream error', err.name);
-                // Android (Galaxy esp.) have a bug that when using facingMode it might cause NotReadableError. So
-                // we should try again but without facingMode. The exception to the rule is when we don't have specific
-                // device to use (like in IOS13 bug, as can be seen in MediaServiceBase.ts), in that case, we might end
-                // up using the front camera, which is a privacy concern and the preference is to fallback from video
-                if (err &&
-                    err.name === 'NotReadableError' &&
-                    (0, get_1.default)(constraints, 'video.facingMode') &&
-                    (0, get_1.default)(constraints, 'video.deviceId')) {
-                    const newConstraints = constraints;
-                    trace.info(`getStreamPromiseByParsedConstraints - NotReadableError - Failed to get video user media stream with facingMode=${(0, get_1.default)(constraints, 'video.facingMode')}`, err.name);
-                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                    // @ts-ignore
-                    delete newConstraints.video.facingMode;
-                    newConstraints.video.deviceId = {
-                        exact: constraints.video.deviceId
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "getParsedConstraints", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (isDesktopMedia, streamConstraints) {
+            var constraintCandidates = [];
+            //TODO - Alex: need to understand which constraints not compatible with screen share
+            if (isDesktopMedia) {
+                return [{ video: true }];
+            }
+            if (!streamConstraints) {
+                return constraintCandidates;
+            }
+            var baseConstraints = {};
+            baseConstraints.audio = typeof streamConstraints.audio === 'boolean' ? streamConstraints.audio : undefined;
+            if (!streamConstraints.video) {
+                return [baseConstraints];
+            }
+            var cameraType = streamConstraints.video !== 'boolean' &&
+                streamConstraints.video.videoSourceType;
+            baseConstraints.video = {
+                facingMode: cameraType && cameraType === MediaConstants_1.LocalVideoSourceType.CAMERA_FRONT ? 'user' : 'environment',
+                frameRate: { ideal: 15, max: 30 }
+            };
+            var deviceId = (0, get_1.default)(this._groupedDevices, "video.".concat(cameraType === MediaConstants_1.LocalVideoSourceType.CAMERA_FRONT ? MediaConstants_1.CameraTypes.FRONT : MediaConstants_1.CameraTypes.BACK, ".deviceId"));
+            if (deviceId) {
+                baseConstraints.video.deviceId = deviceId;
+                if (this._groupedDevices.camerasCount > 1) {
+                    baseConstraints.video.facingMode = {
+                        exact: baseConstraints.video.facingMode
                     };
-                    streamPromise = this.getStreamPromiseByParsedConstraints(newConstraints, isDesktopMedia);
-                }
-                else if (err && err.name && constraints.audio && !constraints.video) {
-                    trace.info('getStreamPromiseByParsedConstraints - audioStreamFailed - Failed to get audio user media stream', err.name);
-                    return this.parseMediaErrorThenThrow({ name: 'audioStreamFailed' });
                 }
-                else if (err && err.name && constraints.audio) {
-                    const newConstraints = constraints;
-                    trace.info('getStreamPromiseByParsedConstraints - Failed to get video and audio user media stream, try to get video media stream only', err.name);
-                    newConstraints.audio = false;
-                    streamPromise = this.getStreamPromiseByParsedConstraints(newConstraints, isDesktopMedia);
-                }
-                else if (err && !streamPromise) {
-                    trace.info('getStreamPromiseByParsedConstraints - Failed to get video user media stream', err && err.name);
-                    streamPromise = bluebird_1.Promise.reject(err);
-                }
-                return streamPromise && streamPromise.catch(this.parseMediaErrorThenThrow);
-            });
-        }
-        catch (e) {
-            // @ts-ignore
-            return this.parseMediaErrorThenThrow(e);
-        }
-    }
-    setGroupedDevices(groupedDevices) {
-        trace.info('setGroupedDevices', groupedDevices);
-        this._groupedDevices = {
-            video: groupedDevices.video
-                ? { [MediaConstants_1.CameraTypes.BACK]: (0, last_1.default)(groupedDevices.video), [MediaConstants_1.CameraTypes.FRONT]: (0, first_1.default)(groupedDevices.video) }
-                : null,
-            audio: (0, last_1.default)(groupedDevices.audio) || null,
-            camerasCount: groupedDevices.video.length
-        };
-    }
-    getParsedConstraints(isDesktopMedia, streamConstraints) {
-        const constraintCandidates = [];
-        //TODO - Alex: need to understand which constraints not compatible with screen share
-        if (isDesktopMedia) {
-            return [{ video: true }];
-        }
-        if (!streamConstraints) {
-            return constraintCandidates;
-        }
-        const baseConstraints = {};
-        baseConstraints.audio = typeof streamConstraints.audio === 'boolean' ? streamConstraints.audio : undefined;
-        if (!streamConstraints.video) {
-            return [baseConstraints];
-        }
-        const cameraType = streamConstraints.video !== 'boolean' &&
-            streamConstraints.video.videoSourceType;
-        baseConstraints.video = {
-            facingMode: cameraType && cameraType === MediaConstants_1.LocalVideoSourceType.CAMERA_FRONT ? 'user' : 'environment',
-            frameRate: { ideal: 15, max: 30 }
-        };
-        const deviceId = (0, get_1.default)(this._groupedDevices, `video.${cameraType === MediaConstants_1.LocalVideoSourceType.CAMERA_FRONT ? MediaConstants_1.CameraTypes.FRONT : MediaConstants_1.CameraTypes.BACK}.deviceId`);
-        if (deviceId) {
-            baseConstraints.video.deviceId = deviceId;
-            if (this._groupedDevices.camerasCount > 1) {
-                baseConstraints.video.facingMode = {
-                    exact: baseConstraints.video.facingMode
-                };
             }
-        }
-        const assignConstraint = (videoResolution) => {
-            const [width, height] = videoResolution.resolution.split('x');
-            const constraintCandidate = (0, assign_1.default)({}, baseConstraints);
-            constraintCandidate.video = (0, assign_1.default)({}, baseConstraints.video, {
-                width: _constraintByType(width, videoResolution.constraintType),
-                height: _constraintByType(height, videoResolution.constraintType)
-            });
-            constraintCandidates.push(constraintCandidate);
-        };
-        if ((baseConstraints.video && typeof streamConstraints.video === 'boolean') ||
-            !(streamConstraints.video.videoResolution instanceof Array)) {
-            const defaultResolution = {
-                resolution: MediaConstants_1.DEFAULT_VIDEO_RESOLUTION,
-                constraintType: MediaConstants_1.DEFAULT_VIDEO_CONSTRAINT_TYPE
+            var assignConstraint = function (videoResolution) {
+                var _a = videoResolution.resolution.split('x'), width = _a[0], height = _a[1];
+                var constraintCandidate = (0, assign_1.default)({}, baseConstraints);
+                constraintCandidate.video = (0, assign_1.default)({}, baseConstraints.video, {
+                    width: _constraintByType(width, videoResolution.constraintType),
+                    height: _constraintByType(height, videoResolution.constraintType)
+                });
+                constraintCandidates.push(constraintCandidate);
             };
-            assignConstraint(defaultResolution);
+            if ((baseConstraints.video && typeof streamConstraints.video === 'boolean') ||
+                !(streamConstraints.video.videoResolution instanceof Array)) {
+                var defaultResolution = {
+                    resolution: MediaConstants_1.DEFAULT_VIDEO_RESOLUTION,
+                    constraintType: MediaConstants_1.DEFAULT_VIDEO_CONSTRAINT_TYPE
+                };
+                assignConstraint(defaultResolution);
+                return constraintCandidates;
+            }
+            streamConstraints.video.videoResolution.forEach(assignConstraint);
             return constraintCandidates;
         }
-        streamConstraints.video.videoResolution.forEach(assignConstraint);
-        return constraintCandidates;
-    }
-    parseMediaErrorThenThrow(error) {
-        if (error && error.errorCode) {
-            throw error;
-        }
-        trace.error('Get media stream error.', error);
-        const errorName = error && error.name ? error.name : '';
-        const permissionErrorNames = ['NotAllowedError', 'PermissionDismissedError', 'PermissionDeniedError'];
-        // const generalError = [
-        //     'NotFoundError',
-        //     'DevicesNotFoundError',
-        //     'NotReadableError',
-        //     'TrackStartError'
-        // ];
-        const constraintsErrors = ['OverconstrainedError', 'ConstraintNotSatisfiedError'];
-        const isErrorOfType = (errorsArr) => errorsArr.filter((err) => err === errorName).length > 0;
-        if (isErrorOfType(permissionErrorNames)) {
-            throw { errorCode: MediaConstants_1.MediaRequestErrorCode.PermissionDenied, message: errorName };
-        }
-        if (isErrorOfType(constraintsErrors)) {
-            throw { errorCode: MediaConstants_1.MediaRequestErrorCode.Overconstrained, message: errorName };
+    });
+    Object.defineProperty(LocalStreamManager.prototype, "parseMediaErrorThenThrow", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (error) {
+            if (error && error.errorCode) {
+                throw error;
+            }
+            trace.error('Get media stream error.', error);
+            var errorName = error && error.name ? error.name : '';
+            var permissionErrorNames = ['NotAllowedError', 'PermissionDismissedError', 'PermissionDeniedError'];
+            // const generalError = [
+            //     'NotFoundError',
+            //     'DevicesNotFoundError',
+            //     'NotReadableError',
+            //     'TrackStartError'
+            // ];
+            var constraintsErrors = ['OverconstrainedError', 'ConstraintNotSatisfiedError'];
+            var isErrorOfType = function (errorsArr) { return errorsArr.filter(function (err) { return err === errorName; }).length > 0; };
+            if (isErrorOfType(permissionErrorNames)) {
+                throw { errorCode: MediaConstants_1.MediaRequestErrorCode.PermissionDenied, message: errorName };
+            }
+            if (isErrorOfType(constraintsErrors)) {
+                throw { errorCode: MediaConstants_1.MediaRequestErrorCode.Overconstrained, message: errorName };
+            }
+            throw { errorCode: MediaConstants_1.MediaRequestErrorCode.GeneralError, message: errorName };
         }
-        throw { errorCode: MediaConstants_1.MediaRequestErrorCode.GeneralError, message: errorName };
-    }
-}
+    });
+    return LocalStreamManager;
+}());
 exports.LocalStreamManager = LocalStreamManager;
 function _constraintByType(value, type) {
     switch (type) {