Merge pull request #225 from jitsi/improve-device-errors

Improve device errors

JitsiMeetJS.js

                     Statistics.sendLog(JSON.stringify(logObject));
                     Statistics.analytics.sendEvent(
                         "getUserMedia.userCancel.extensionInstall");
+                } else if (JitsiTrackErrors.NOT_FOUND === error.name) {
+                    // logs not found devices with just application log to cs
+                    var logObject = {
+                        id: "usermedia_missing_device",
+                        status: error.gum.devices
+                    };
+                    Statistics.sendLog(JSON.stringify(logObject));
+                    Statistics.analytics.sendEvent(
+                        "getUserMedia.deviceNotFound."
+                            + error.gum.devices.join('.'));
                 } else {
                     // Report gUM failed to the stats
                     Statistics.sendGetUserMediaFailed(error);
+                    Statistics.analytics.sendEvent(
+                        addDeviceTypeToAnalyticsEvent(
+                            "getUserMedia.failed", options) + '.' + error.name,
+                        options);
                 }
 
                 window.connectionTimes["obtainPermissions.end"] =
                     window.performance.now();
 
-
-                Statistics.analytics.sendEvent(
-                    addDeviceTypeToAnalyticsEvent(
-                        "getUserMedia.failed", options) + '.' + error.name,
-                    options);
-
                 return Promise.reject(error);
             }.bind(this));
     },

JitsiTrackError.js

                         JitsiTrackErrors.PERMISSION_DENIED]
                         + (this.gum.devices || []).join(", ");
                 break;
+            case "DevicesNotFoundError":
             case "NotFoundError":
                 this.name = JitsiTrackErrors.NOT_FOUND;
                 this.message = TRACK_ERROR_TO_MESSAGE_MAP[

modules/RTC/RTCUtils.js

     return constraints;
 }
 
-function setAvailableDevices(um, available) {
+/**
+ * Sets the availbale devices based on the options we requested and the
+ * streams we received.
+ * @param um the options we requested to getUserMedia.
+ * @param stream the stream we received from calling getUserMedia.
+ */
+function setAvailableDevices(um, stream) {
+    var audioTracksReceived = stream && !!stream.getAudioTracks().length;
+    var videoTracksReceived = stream && !!stream.getVideoTracks().length;
+
     if (um.indexOf("video") != -1) {
-        devices.video = available;
+        devices.video = videoTracksReceived;
     }
     if (um.indexOf("audio") != -1) {
-        devices.audio = available;
+        devices.audio = audioTracksReceived;
     }
 
     eventEmitter.emit(RTCEvents.AVAILABLE_DEVICES_CHANGED, devices);
  * @param {MediaDeviceInfo[]} devices - list of media devices.
  * @emits RTCEvents.DEVICE_LIST_CHANGED
  */
-function onMediaDevicesListChanged(devices) {
-    currentlyAvailableMediaDevices = devices.slice(0);
+function onMediaDevicesListChanged(devicesReceived) {
+    currentlyAvailableMediaDevices = devicesReceived.slice(0);
     logger.info('list of media devices has changed:', currentlyAvailableMediaDevices);
 
     var videoInputDevices = currentlyAvailableMediaDevices.filter(function (d) {
 
     if (videoInputDevices.length &&
         videoInputDevices.length === videoInputDevicesWithEmptyLabels.length) {
-        setAvailableDevices(['video'], false);
+        devices.video = false;
     }
 
     if (audioInputDevices.length &&
         audioInputDevices.length === audioInputDevicesWithEmptyLabels.length) {
-        setAvailableDevices(['audio'], false);
+        devices.audio = false;
     }
 
-    eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, devices);
+    eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, devicesReceived);
 }
 
 // In case of IE we continue from 'onReady' callback
             this.getUserMedia(constraints,
                 function (stream) {
                     logger.log('onUserMediaSuccess');
-                    setAvailableDevices(um, true);
+                    setAvailableDevices(um, stream);
                     success_callback(stream);
                 },
                 function (error) {
-                    setAvailableDevices(um, false);
+                    setAvailableDevices(um, undefined);
                     logger.warn('Failed to get access to local media. Error ',
                         error, constraints);
 
                                     devices.push("video");
                                 }
 
-                                reject(new JitsiTrackError(
-                                    { name: "UnknownError" },
-                                    getConstraints(options.devices, options),
-                                    devices)
-                                );
+                                // we are missing one of the media we requested
+                                // in order to get the actual error that caused
+                                // this missing media we will call one more time
+                                // getUserMedia so we can obtain the actual
+                                // error (Example usecases are requesting
+                                // audio and video and video device is missing
+                                // or device is denied to be used and chrome is
+                                // set to not ask for permissions)
+                                self.getUserMediaWithConstraints(
+                                    devices,
+                                    function (stream) {
+                                        // we already failed to obtain this
+                                        // media, so we are not supposed in any
+                                        // way to receive success for this call
+                                        // any way we will throw an error to be
+                                        // sure the promise will finish
+                                        reject(new JitsiTrackError(
+                                            { name: "UnknownError" },
+                                            getConstraints(
+                                                options.devices, options),
+                                            devices)
+                                        );
+                                    },
+                                    function (error) {
+                                        // rejects with real error for not
+                                        // obtaining the media
+                                        reject(error);
+                                    },options);
+
                                 return;
                             }
                             if(hasDesktop) {