Handle cases when new media devices are added/removed more precisely and more predictable

JitsiConference.js

 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
+var JitsiTrackError = require("./JitsiTrackError");
 var Settings = require("./modules/settings/Settings");
 var ComponentsVersions = require("./modules/version/ComponentsVersions");
 var GlobalOnErrorHandler = require("./modules/util/GlobalOnErrorHandler");
 JitsiConference.prototype.addTrack = function (track) {
     if(track.disposed)
     {
-        throw new Error(JitsiTrackErrors.TRACK_IS_DISPOSED);
+        throw new JitsiTrackError(JitsiTrackErrors.TRACK_IS_DISPOSED);
     }
 
     if (track.isVideoTrack() && this.rtc.getLocalVideoTrack()) {

JitsiTrackError.js

+var JitsiTrackErrors = require("./JitsiTrackErrors");
+
+var TRACK_ERROR_TO_MESSAGE_MAP = {};
+
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.UNSUPPORTED_RESOLUTION]
+    = "Video resolution is not supported: ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED]
+    = "Firefox extension is not installed";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR]
+    = "Failed to install Chrome extension";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED]
+    = "User canceled Chrome's screen sharing prompt";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR]
+    = "Unknown error from Chrome extension";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.GENERAL]
+    = "Generic getUserMedia error";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.PERMISSION_DENIED]
+    = "User denied permission to use device(s): ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.NOT_FOUND]
+    = "Requested device(s) was/were not found: ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CONSTRAINT_FAILED]
+    = "Constraint could not be satisfied: ";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_IS_DISPOSED]
+    = "Track has been already disposed";
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS]
+    = "Track mute/unmute process is currently in progress";
+
+/**
+ * Object representing error that happened to a JitsiTrack. Can represent
+ * various types of errors. For error descriptions (@see JitsiTrackErrors).
+ * @constructor
+ * @extends Error
+ * @param {Object|string} error - error object or error name
+ * @param {Object|string} (options) - getUserMedia constraints object or error
+ *      message
+ */
+function JitsiTrackError(error, options) {
+    if (typeof error === "object" && typeof error.name !== "undefined") {
+        /**
+         * Additional information about original getUserMedia error
+         * and constraints.
+         * @type {{error: Object, constraints: Object }}
+         */
+        this.gum = {
+            error: error,
+            constraints: options
+        };
+
+        switch (error.name) {
+            case "PermissionDeniedError":
+            case "SecurityError":
+                this.name = JitsiTrackErrors.PERMISSION_DENIED;
+                this.message = error.message
+                    || TRACK_ERROR_TO_MESSAGE_MAP[
+                        JitsiTrackErrors.PERMISSION_DENIED]
+                        + Object.keys(options || {}).filter(function (k) {
+                            return !!options[k];
+                        }).join(", ");
+                break;
+            case "NotFoundError":
+                this.name = JitsiTrackErrors.NOT_FOUND;
+                this.message = error.message
+                    || TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.NOT_FOUND]
+                        + Object.keys(options || {}).filter(function (k) {
+                            return !!options[k];
+                        }).join(", ");
+                break;
+            case "ConstraintNotSatisfiedError":
+            case "OverconstrainedError":
+                var constraintName = error.constraintName;
+
+                if (options && options.video
+                    &&
+                    (constraintName === "minWidth" ||
+                        constraintName === "maxWidth" ||
+                        constraintName === "minHeight" ||
+                        constraintName === "maxHeight" ||
+                        constraintName === "width" ||
+                        constraintName === "height")) {
+                    this.name = JitsiTrackErrors.UNSUPPORTED_RESOLUTION;
+                    this.message = error.message ||
+                        TRACK_ERROR_TO_MESSAGE_MAP[
+                            JitsiTrackErrors.UNSUPPORTED_RESOLUTION] +
+                        getResolutionFromFailedConstraint(constraintName,
+                            options);
+                } else {
+                    this.name = JitsiTrackErrors.CONSTRAINT_FAILED;
+                    this.message = error.message ||
+                        TRACK_ERROR_TO_MESSAGE_MAP[
+                            JitsiTrackErrors.CONSTRAINT_FAILED] +
+                        error.constraintName;
+                }
+                break;
+            default:
+                this.name = JitsiTrackErrors.GENERAL;
+                this.message = error.message ||
+                    TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.GENERAL];
+                break;
+        }
+    } else if (typeof error === "string") {
+        if (TRACK_ERROR_TO_MESSAGE_MAP[error]) {
+            this.name = error;
+            this.message = options || TRACK_ERROR_TO_MESSAGE_MAP[error];
+        } else {
+            // this is some generic error that do not fit any of our pre-defined
+            // errors, so don't give it any specific name, just store message
+            this.message = error;
+        }
+    } else {
+        throw new Error("Invalid arguments");
+    }
+
+    this.stack = error.stack || (new Error()).stack;
+}
+
+JitsiTrackError.prototype = Object.create(Error.prototype);
+JitsiTrackError.prototype.constructor = JitsiTrackError;
+
+/**
+ * Gets failed resolution constraint from corresponding object.
+ * @param {string} failedConstraintName
+ * @param {Object} constraints
+ * @returns {string|number}
+ */
+function getResolutionFromFailedConstraint(failedConstraintName, constraints) {
+    if (constraints && constraints.video && constraints.video.mandatory) {
+        if (failedConstraintName === "width") {
+            return constraints.video.mandatory.minWidth;
+        } else if (failedConstraintName === "height") {
+            return constraints.video.mandatory.minHeight;
+        } else {
+            return constraints.video.mandatory[failedConstraintName] || "";
+        }
+    }
+
+    return "";
+}
+
+module.exports = JitsiTrackError;

JitsiTrackErrors.js

-var logger = require("jitsi-meet-logger").getLogger(__filename);
-
+/**
+ * Enumeration with the errors for the JitsiTrack objects.
+ * @type {{string: string}}
+ */
 module.exports = {
     /**
-     * Returns JitsiTrackErrors based on the error object passed by GUM
-     * @param error the error
-     * @param {Array} devices Array with the requested devices
-     */
-    parseError: function (error, devices) {
-        if (typeof error === "object") {
-          var constraintName = error.constraintName;
-          var name;
-          if (constraintName
-                  && (name = error.name)
-                  && (name == "ConstraintNotSatisfiedError"
-                      || name == "OverconstrainedError")
-                  && (constraintName == "minWidth"
-                      || constraintName == "maxWidth"
-                      || constraintName == "minHeight"
-                      || constraintName == "maxHeight"
-                      || constraintName == "width"
-                      || constraintName == "height")
-                  && (devices || []).indexOf("video") !== -1) {
-              return this.UNSUPPORTED_RESOLUTION;
-          }
-          if (error.type === "jitsiError") {
-              return error.errorObject;
-          }
-        }
-        // XXX We're about to lose the details represented by error and devices
-        // (because we're about to generalize them to GENERAL). At the very
-        // least log the details.
-        logger.error('Parsing error into ' + this.GENERAL + ': ' + error);
-        return this.GENERAL;
-    },
+     * An error which indicates that requested video resolution is not supported
+     * by a webcam.
+     */
     UNSUPPORTED_RESOLUTION: "gum.unsupported_resolution",
     /**
-     * An event which indicates that the jidesha extension for Firefox is
+     * An error which indicates that the jidesha extension for Firefox is
      * needed to proceed with screen sharing, and that it is not installed.
      */
     FIREFOX_EXTENSION_NEEDED: "gum.firefox_extension_needed",
+    /**
+     * An error which indicates that the jidesha extension for Chrome is
+     * failed to install.
+     */
     CHROME_EXTENSION_INSTALLATION_ERROR:
         "gum.chrome_extension_installation_error",
+    /**
+     * An error which indicates that user canceled screen sharing window
+     * selection dialog in jidesha extension for Chrome.
+     */
     CHROME_EXTENSION_USER_CANCELED:
         "gum.chrome_extension_user_canceled",
+    /**
+     * Generic error for jidesha extension for Chrome.
+     */
+    CHROME_EXTENSION_GENERIC_ERROR:
+        "gum.chrome_extension_generic_error",
+    /**
+     * Generic getUserMedia error.
+     */
     GENERAL: "gum.general",
+    /**
+     * An error which indicates that user denied permission to share requested
+     * device.
+     */
+    PERMISSION_DENIED: "gum.permission_denied",
+    /**
+     * An error which indicates that requested device was not found.
+     */
+    NOT_FOUND: "gum.not_found",
+    /**
+     * An error which indicates that some of requested constraints in
+     * getUserMedia call were not satisfied.
+     */
+    CONSTRAINT_FAILED: "gum.constraint_failed",
+    /**
+     * An error which indicates that track has been already disposed and cannot
+     * be longer used.
+     */
     TRACK_IS_DISPOSED: "track.track_is_disposed",
+    /**
+     * An error which indicates that track is currently in progress of muting or
+     * unmuting itself.
+     */
     TRACK_MUTE_UNMUTE_IN_PROGRESS: "track.mute_unmute_inprogress"
 };

modules/RTC/JitsiLocalTrack.js

 var RTCBrowserType = require("./RTCBrowserType");
 var JitsiTrackEvents = require('../../JitsiTrackEvents');
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var RTCEvents = require("../../service/RTC/RTCEvents");
 var RTCUtils = require("./RTCUtils");
 var VideoType = require('../../service/RTC/VideoType');
     return new Promise(function (resolve, reject) {
 
         if(this.inMuteOrUnmuteProgress) {
-            reject(new Error(JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
+            reject(new JitsiTrackError(
+                JitsiTrackErrors.TRACK_MUTE_UNMUTE_IN_PROGRESS));
             return;
         }
         this.inMuteOrUnmuteProgress = true;

modules/RTC/RTCUtils.js

 var EventEmitter = require("events");
 var screenObtainer = require("./ScreenObtainer");
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var MediaType = require("../../service/RTC/MediaType");
 var VideoType = require("../../service/RTC/VideoType");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
             });
             logger.error(
                 "failed to obtain " + device + " stream - stop", error);
-            options.errorCallback(JitsiTrackErrors.parseError(error, devices));
+
+            options.errorCallback(error);
         });
 }
 
                     setAvailableDevices(um, false);
                     logger.warn('Failed to get access to local media. Error ',
                         error, constraints);
+
                     if (failure_callback) {
-                        failure_callback(error, resolution);
+                        failure_callback(new JitsiTrackError(error, constraints));
                     }
                 });
         } catch (e) {
                                 !stream.getVideoTracks().length))
                             {
                                 self.stopMediaStream(stream);
-                                reject(JitsiTrackErrors.parseError(
-                                    new Error("Unable to get the audio and " +
-                                        "video tracks."),
-                                    options.devices));
+
+                                reject(
+                                    new JitsiTrackError({
+                                        name: JitsiTrackErrors.NOT_FOUND
+                                    }),
+                                    getConstraints(options.devices, options)
+                                );
                                 return;
                             }
                             if(hasDesktop) {
                                             desktopStream: desktopStream});
                                     }, function (error) {
                                         self.stopMediaStream(stream);
-                                        reject(
-                                            JitsiTrackErrors.parseError(error,
-                                                options.devices));
+
+                                        reject(error);
+
                                     });
                             } else {
                                 successCallback({audioVideo: stream});
                             }
                         },
                         function (error) {
-                            reject(JitsiTrackErrors.parseError(error,
-                                options.devices));
+                            reject(error);
                         },
                         options);
                 } else if (hasDesktop) {
                         function (stream) {
                             successCallback({desktopStream: stream});
                         }, function (error) {
-                            reject(
-                                JitsiTrackErrors.parseError(error,
-                                    ["desktop"]));
+                            reject(error);
                         });
                 }
             }

modules/RTC/ScreenObtainer.js

 var RTCBrowserType = require("./RTCBrowserType");
 var AdapterJS = require("./adapter.screenshare");
 var JitsiTrackErrors = require("../../JitsiTrackErrors");
+var JitsiTrackError = require("../../JitsiTrackError");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 
 /**
 
         if (RTCBrowserType.isNWJS()) {
             obtainDesktopStream = function (onSuccess, onFailure) {
-                window.JitsiMeetNW.obtainDesktopStream (onSuccess, onFailure);
+                window.JitsiMeetNW.obtainDesktopStream (
+                    onSuccess, function (error, constraints) {
+                        onFailure && onFailure(
+                            new JitsiTrackError(error, constraints));
+                    });
             };
         } else if (RTCBrowserType.isTemasysPluginUsed()) {
             if (!AdapterJS.WebRTCPlugin.plugin.HasScreensharingFeature) {
 
         // Make sure desktopsharing knows that we failed, so that it doesn't get
         // stuck in 'switching' mode.
-        errorCallback({
-            type: "jitsiError",
-            errorObject: JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED
-        });
+        errorCallback(
+            new JitsiTrackError(JitsiTrackErrors.FIREFOX_EXTENSION_NEEDED));
     },
     /**
      * Asks Chrome extension to call chooseDesktopMedia and gets chrome
                         }, 500);
                     },
                     function (arg) {
-                        logger.log("Failed to install the extension from:"
-                            + getWebStoreInstallUrl(self.options), arg);
-                        failCallback({
-                            type: "jitsiError",
-                            errorObject: JitsiTrackErrors
-                                .CHROME_EXTENSION_INSTALLATION_ERROR
-                        });
+                        var msg = "Failed to install the extension from "
+                            + getWebStoreInstallUrl(self.options);
+
+                        logger.log(msg, arg);
+
+                        failCallback(new JitsiTrackError(
+                            JitsiTrackErrors
+                                .CHROME_EXTENSION_INSTALLATION_ERROR,
+                            msg
+                        ));
                     }
                 );
             } catch(e) {
-                logger.log("Failed to install the extension from:"
-                    + self.getWebStoreInstallUrl(this.options), e);
-                failCallback({
-                    type: "jitsiError",
-                    errorObject:
-                        JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR
-                });
+                var msg = "Failed to install the extension from "
+                    + getWebStoreInstallUrl(self.options);
+
+                logger.log(msg, e);
+
+                failCallback(new JitsiTrackError(
+                    JitsiTrackErrors.CHROME_EXTENSION_INSTALLATION_ERROR,
+                    msg
+                ));
             }
         }
     }
         },
         function (response) {
             if (!response) {
-                failCallback(chrome.runtime.lastError);
+                // possibly re-wraping error message to make code consistent
+                var lastError = chrome.runtime.lastError;
+                failCallback(lastError instanceof Error
+                    ? lastError
+                    : new JitsiTrackError(
+                        JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
+                        lastError));
                 return;
             }
             logger.log("Response from extension: ", response);
                 // then the callback is called with an empty streamId.
                 if(response.streamId === "")
                 {
-                    failCallback({
-                        type: "jitsiError",
-                        errorObject:
-                            JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED
-                    });
+                    failCallback(new JitsiTrackError(
+                        JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED));
                     return;
                 }
 
-                failCallback("Extension failed to get the stream");
+                failCallback(new JitsiTrackError(
+                    JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
+                    response.error));
             }
         }
     );