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

package/lib/LocalStreamManager.js

@@ -1,317 +1,474 @@
 "use strict";
 
-var __assign = undefined && undefined.__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 __assign = void 0 && (void 0).__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 = undefined && undefined.__importDefault || function (mod) {
-    return mod && mod.__esModule ? mod : { "default": mod };
+
+var __importDefault = void 0 && (void 0).__importDefault || function (mod) {
+  return mod && mod.__esModule ? mod : {
+    "default": mod
+  };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalStreamManager = void 0;
+
 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;
 var userMediaPromise = null;
 window.latestDesktopMediaStream = null;
 var desktopMediaPromise = null;
+window.mediaStreamAlreadyReplaced = false;
+window.latestLocalMediaConstraints = null;
 var trace = MediaTracer_1.getMediaTracer('LocalStreamManager');
-var LocalStreamManager = /** @class */function () {
-    function LocalStreamManager(environment) {
-        this._groupedDevices = { video: null, audio: null };
-        this.environment = environment;
-        this.parseMediaErrorThenThrow = this.parseMediaErrorThenThrow.bind(this);
-        this.clearAllStreams = this.clearAllStreams.bind(this);
-    }
-    LocalStreamManager.prototype.getUserMediaStream = function (constraints) {
-        var _this = this;
-        trace.info('getUserMediaStream', constraints);
-        if (userMediaPromise) {
-            return userMediaPromise;
-        }
-        if (window.latestUserMediaStream) {
-            var videoTrack = window.latestUserMediaStream.mediaStream.getVideoTracks();
-            if (videoTrack.length > 0 && videoTrack[0].readyState === 'live') {
-                return bluebird_1.Promise.resolve(__assign({}, window.latestUserMediaStream, { isNew: false }));
-            }
-            this.destroyUserMediaStream();
-        }
-        userMediaPromise = new bluebird_1.Promise(function (resolve, reject) {
-            var catchHandler = function catchHandler(err) {
-                userMediaPromise = null;
-                window.latestUserMediaStream = null;
-                trace.error('getUserMedia error', err);
-                reject(err);
-            };
-            try {
-                _this.getHighestResolutionStream(false, constraints).then(function (streamResult) {
-                    userMediaPromise = null;
-                    window.latestUserMediaStream = streamResult;
-                    resolve(__assign({}, window.latestUserMediaStream, { isNew: true }));
-                }).catch(catchHandler);
-            } catch (err) {
-                catchHandler(err);
-            }
-        });
-        return userMediaPromise;
-    };
-    LocalStreamManager.prototype.getDesktopMediaStream = function (constraints) {
-        var _this = this;
-        if (desktopMediaPromise) {
-            return desktopMediaPromise;
-        }
-        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({}, window.latestDesktopMediaStream, { isNew: false }));
-            }
-            this.destroyDesktopMediaStream().catch(function (error) {
-                trace.error('Error destroying desktop media stream', error);
-            });
-        }
-        desktopMediaPromise = new bluebird_1.Promise(function (resolve, reject) {
-            var mediaCatchHandler = function mediaCatchHandler(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({}, window.latestDesktopMediaStream, { isNew: true }));
-                }).catch(mediaCatchHandler);
-            } catch (err) {
-                mediaCatchHandler(err);
-            }
-        });
-        return desktopMediaPromise;
+
+var LocalStreamManager =
+/** @class */
+function () {
+  function LocalStreamManager(environment) {
+    this._groupedDevices = {
+      video: null,
+      audio: null,
+      camerasCount: 0
     };
-    LocalStreamManager.prototype.destroyUserMediaStream = function () {
-        var streamResult = window.latestUserMediaStream;
-        window.latestUserMediaStream = null;
+    this.environment = environment;
+    this.parseMediaErrorThenThrow = this.parseMediaErrorThenThrow.bind(this);
+    this.clearAllStreams = this.clearAllStreams.bind(this);
+  }
+
+  Object.defineProperty(LocalStreamManager.prototype, "groupedDevices", {
+    get: function get() {
+      return this._groupedDevices;
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  LocalStreamManager.prototype.getUserMediaStream = function (constraints) {
+    var _this = this;
+
+    trace.info('getUserMediaStream', constraints);
+
+    if (userMediaPromise) {
+      return userMediaPromise;
+    }
+
+    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 catchHandler(err) {
         userMediaPromise = null;
-        if (streamResult && streamResult.mediaStream) {
-            streamResult.mediaStream.getTracks().forEach(function (track) {
-                track.stop();
-            });
-        }
-        return bluebird_1.Promise.resolve();
-    };
-    LocalStreamManager.prototype.destroyDesktopMediaStream = function () {
-        var streamResult = window.latestDesktopMediaStream;
-        window.latestDesktopMediaStream = null;
+        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 = 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;
+  };
+
+  LocalStreamManager.prototype.getDesktopMediaStream = function (constraints) {
+    var _this = this;
+
+    if (desktopMediaPromise) {
+      return desktopMediaPromise;
+    }
+
+    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);
+      });
+    }
+
+    desktopMediaPromise = new bluebird_1.Promise(function (resolve, reject) {
+      var mediaCatchHandler = function mediaCatchHandler(err) {
         desktopMediaPromise = null;
-        if (streamResult && streamResult.mediaStream) {
-            streamResult.mediaStream.getTracks().forEach(function (track) {
-                track.stop();
-            });
-        }
-        return bluebird_1.Promise.resolve();
-    };
-    LocalStreamManager.prototype.clearAllStreams = function () {
-        trace.info('LocalStreamManager Clearing all streams');
-        return bluebird_1.Promise.all([this.destroyDesktopMediaStream(), this.destroyUserMediaStream()]).then(function () {
-            return undefined;
+        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;
+  };
+
+  LocalStreamManager.prototype.destroyUserMediaStream = 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();
         });
-    };
-    LocalStreamManager.prototype.getHighestResolutionStream = 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'));
+        trace.info('destroyUserMediaStream - stop all tracks');
+      } catch (e) {
+        trace.info('destroyUserMediaStream - Failed to stop all tracks', e);
+      }
+    }
+
+    return bluebird_1.Promise.resolve();
+  };
+
+  LocalStreamManager.prototype.destroyDesktopMediaStream = 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);
+      }
+    }
+
+    return bluebird_1.Promise.resolve();
+  };
+
+  LocalStreamManager.prototype.clearAllStreams = function () {
+    trace.info('LocalStreamManager Clearing all streams');
+    return bluebird_1.Promise.all([this.destroyDesktopMediaStream(), this.destroyUserMediaStream()]).then(function () {
+      return undefined;
+    });
+  };
+
+  LocalStreamManager.prototype.getHighestResolutionStream = 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 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;
         }
-        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 = get_1.default(constraints, 'video.videoResolution.constraintType') || 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);
-                }
-            });
+
+        var constraintType = get_1["default"](constraints, 'video.videoResolution.constraintType') || 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);
+          }
         });
-    };
-    LocalStreamManager.prototype.getUserMediaStreamMediaDevice = function (constraints, isDesktopMedia) {
-        var streamPromise = null;
-        if (!isDesktopMedia) {
-            streamPromise = navigator.mediaDevices.getUserMedia(constraints);
-        } else {
-            //@ts-ignore
-            streamPromise = navigator.mediaDevices.getDisplayMedia
-            //@ts-ignore
-            ? navigator.mediaDevices.getDisplayMedia(constraints) : navigator.getDisplayMedia(constraints);
+      }, 0).then(function () {
+        if (!isStreamRequestFulfilled) {
+          if (!lastFailedResult) {
+            lastFailedResult = {
+              errorCode: MediaConstants_1.MediaRequestErrorCode.GeneralError,
+              message: 'Suitable stream cannot be created'
+            };
+          }
+
+          reject(lastFailedResult);
         }
-        return streamPromise;
-    };
-    //@ts-ignore
-    LocalStreamManager.prototype.getStreamPromiseByParsedConstraints = function (constraints, isDesktopMedia) {
-        var _this = this;
-        trace.info('getStreamPromiseByParsedConstraints', constraints);
-        try {
-            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' && get_1.default(constraints, 'video.facingMode') && get_1.default(constraints, 'video.deviceId')) {
-                    var newConstraints = constraints;
-                    trace.info('getStreamPromiseByParsedConstraints - NotReadableError - Failed to get video user media stream with facingMode=environment', err.name);
-                    // @ts-ignore
-                    delete newConstraints.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) {
-                    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);
-            });
-        } catch (e) {
-            this.parseMediaErrorThenThrow(e);
+      });
+    });
+  };
+
+  LocalStreamManager.prototype.getUserMediaStreamMediaDevice = function (constraints, isDesktopMedia) {
+    var 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);
+    }
+
+    return streamPromise;
+  }; // eslint-disable-next-line consistent-return,@typescript-eslint/ban-ts-comment
+  // @ts-ignore
+
+
+  LocalStreamManager.prototype.getStreamPromiseByParsedConstraints = function (constraints, isDesktopMedia) {
+    var _this = this;
+
+    trace.info('getStreamPromiseByParsedConstraints', constraints);
+
+    try {
+      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' && get_1["default"](constraints, 'video.facingMode') && get_1["default"](constraints, 'video.deviceId')) {
+          var newConstraints = constraints;
+          trace.info("getStreamPromiseByParsedConstraints - NotReadableError - Failed to get video user media stream with facingMode=" + 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);
+      });
+    } catch (e) {
+      this.parseMediaErrorThenThrow(e);
+    }
+  };
+
+  LocalStreamManager.prototype.setGroupedDevices = function (groupedDevices) {
+    var _a;
+
+    trace.info('setGroupedDevices', groupedDevices);
+    this._groupedDevices = {
+      video: groupedDevices.video ? (_a = {}, _a[MediaConstants_1.CameraTypes.BACK] = last_1["default"](groupedDevices.video), _a[MediaConstants_1.CameraTypes.FRONT] = first_1["default"](groupedDevices.video), _a) : null,
+      audio: last_1["default"](groupedDevices.audio) || null,
+      camerasCount: groupedDevices.video.length
     };
-    LocalStreamManager.prototype.setGroupedDevices = function (groupedDevices) {
-        trace.info('setGroupedDevices', groupedDevices);
-        this._groupedDevices = { video: groupedDevices.video ? { back: last_1.default(groupedDevices.video), front: first_1.default(groupedDevices.video) } : null,
-            audio: last_1.default(groupedDevices.audio) || null };
+  };
+
+  LocalStreamManager.prototype.getParsedConstraints = 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
+      }
     };
-    LocalStreamManager.prototype.getParsedConstraints = 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_FORNT ? 'user' : 'environment',
-            frameRate: { ideal: 15, max: 30 }
-        };
-        var deviceId = get_1.default(this._groupedDevices, "video." + (cameraType === MediaConstants_1.LocalVideoSourceType.CAMERA_FORNT ? 'front' : 'back') + ".deviceId");
-        if (deviceId) {
-            baseConstraints.video.deviceId = deviceId;
-        }
-        var assignConstraint = function assignConstraint(videoResolution) {
-            var _a = videoResolution.resolution.split('x'),
-                width = _a[0],
-                height = _a[1];
-            var constraintCandidate = assign_1.default({}, baseConstraints);
-            constraintCandidate.video = assign_1.default({}, baseConstraints.video, {
-                width: _constraintByType(width, videoResolution.constraintType),
-                height: _constraintByType(height, videoResolution.constraintType)
-            });
-            constraintCandidates.push(constraintCandidate);
+    var deviceId = 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
         };
-        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;
+      }
+    }
+
+    var assignConstraint = function assignConstraint(videoResolution) {
+      var _a = videoResolution.resolution.split('x'),
+          width = _a[0],
+          height = _a[1];
+
+      var constraintCandidate = assign_1["default"]({}, baseConstraints);
+      constraintCandidate.video = assign_1["default"]({}, baseConstraints.video, {
+        width: _constraintByType(width, videoResolution.constraintType),
+        height: _constraintByType(height, videoResolution.constraintType)
+      });
+      constraintCandidates.push(constraintCandidate);
     };
-    LocalStreamManager.prototype.parseMediaErrorThenThrow = 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 isErrorOfType(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 };
+
+    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;
+  };
+
+  LocalStreamManager.prototype.parseMediaErrorThenThrow = 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 isErrorOfType(errorsArr) {
+      return errorsArr.filter(function (err) {
+        return err === errorName;
+      }).length > 0;
     };
-    return LocalStreamManager;
+
+    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
+    };
+  };
+
+  return LocalStreamManager;
 }();
+
 exports.LocalStreamManager = LocalStreamManager;
+
 function _constraintByType(value, type) {
-    switch (type) {
-        case MediaConstants_1.ConstraintType.MIN:
-            return { min: value };
-        default:
-            return { ideal: value };
-    }
-}
+  switch (type) {
+    case MediaConstants_1.ConstraintType.MIN:
+      return {
+        min: value
+      };
 
-//# sourceMappingURL=LocalStreamManager.js.map
+    default:
+      return {
+        ideal: value
+      };
+  }
+}
 //# sourceMappingURL=LocalStreamManager.js.map