Merge pull request #1406 from jitsi/tavram/slowgum

fix(gum) update permissions prompt detection

JitsiMediaDevicesEvents.js

  */
 export const PERMISSION_PROMPT_IS_SHOWN
     = 'mediaDevices.permissionPromptIsShown';
+
+export const SLOW_GET_USER_MEDIA = 'mediaDevices.slowGetUserMedia';

JitsiMeetJS.js

  * The amount of time to wait until firing
  * {@link JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN} event.
  */
-const USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 1000;
+const USER_MEDIA_SLOW_PROMISE_TIMEOUT = 1000;
 
 /**
  * Gets the next lowest desirable resolution to try for a camera. If the given
      * which should be created. should be created or some additional
      * configurations about resolution for example.
      * @param {Array} options.effects optional effects array for the track
+     * @param {boolean} options.firePermissionPromptIsShownEvent - if event
+     * JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN should be fired
+     * @param {boolean} options.fireSlowPromiseEvent - if event
+     * JitsiMediaDevicesEvents.USER_MEDIA_SLOW_PROMISE_TIMEOUT should be fired
      * @param {Array} options.devices the devices that will be requested
      * @param {string} options.resolution resolution constraints
      * @param {string} options.cameraDeviceId
      * will finish the execution. If checkAgain returns false, createLocalTracks
      * will finish the execution with rejected Promise.
      *
-     * @param {boolean} (firePermissionPromptIsShownEvent) - if event
-     * JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN should be fired
+     * @deprecated old firePermissionPromptIsShownEvent
      * @param originalOptions - internal use only, to be able to store the
      * originally requested options.
      * @returns {Promise.<{Array.<JitsiTrack>}, JitsiConferenceError>} A promise
      * that returns an array of created JitsiTracks if resolved, or a
      * JitsiConferenceError if rejected.
      */
-    createLocalTracks(
-            options = {}, firePermissionPromptIsShownEvent, originalOptions) {
+    createLocalTracks(options = {}, oldfirePermissionPromptIsShownEvent, originalOptions) {
         let promiseFulfilled = false;
 
-        if (firePermissionPromptIsShownEvent === true) {
+        const { firePermissionPromptIsShownEvent, fireSlowPromiseEvent, ...restOptions } = options;
+        const firePermissionPrompt = firePermissionPromptIsShownEvent || oldfirePermissionPromptIsShownEvent;
+
+        if (firePermissionPrompt && !RTC.arePermissionsGrantedForAvailableDevices()) {
+            JitsiMediaDevices.emitEvent(
+                JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
+                browser.getName());
+        } else if (fireSlowPromiseEvent) {
             window.setTimeout(() => {
                 if (!promiseFulfilled) {
-                    JitsiMediaDevices.emitEvent(
-                        JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN,
-                        browser.getName());
+                    JitsiMediaDevices.emitEvent(JitsiMediaDevicesEvents.SLOW_GET_USER_MEDIA);
                 }
-            }, USER_MEDIA_PERMISSION_PROMPT_TIMEOUT);
+            }, USER_MEDIA_SLOW_PROMISE_TIMEOUT);
         }
 
         if (!window.connectionTimes) {
         window.connectionTimes['obtainPermissions.start']
             = window.performance.now();
 
-        return RTC.obtainAudioAndVideoPermissions(options)
+        return RTC.obtainAudioAndVideoPermissions(restOptions)
             .then(tracks => {
                 promiseFulfilled = true;
 
                 Statistics.sendAnalytics(
                     createGetUserMediaEvent(
                         'success',
-                        getAnalyticsAttributesFromOptions(options)));
+                        getAnalyticsAttributesFromOptions(restOptions)));
 
                 if (!RTC.options.disableAudioLevels) {
                     for (let i = 0; i < tracks.length; i++) {
 
                 if (error.name === JitsiTrackErrors.UNSUPPORTED_RESOLUTION
                     && !browser.usesNewGumFlow()) {
-                    const oldResolution = options.resolution || '720';
+                    const oldResolution = restOptions.resolution || '720';
                     const newResolution = getLowerResolution(oldResolution);
 
                     if (newResolution !== null) {
-                        options.resolution = newResolution;
+                        restOptions.resolution = newResolution;
 
                         logger.debug(
                             'Retry createLocalTracks with resolution',
                             }));
 
                         return this.createLocalTracks(
-                            options,
-                            undefined,
-                            originalOptions || Object.assign({}, options));
+                            restOptions,
+                            originalOptions || Object.assign({}, restOptions));
                     }
 
                     // We tried everything. If there is a mandatory device id,

modules/RTC/RTC.js

         return RTCUtils.getCurrentlyAvailableMediaDevices();
     }
 
+    /**
+     * Returns whether available devices have permissions granted
+     * @returns {Boolean}
+     */
+    static arePermissionsGrantedForAvailableDevices() {
+        return RTCUtils.arePermissionsGrantedForAvailableDevices();
+    }
+
     /**
      * Returns event data for device to be reported to stats.
      * @returns {MediaDeviceInfo} device.

modules/RTC/RTCUtils.js

                 .then(devices => {
                     updateKnownDevices(devices);
                     callback(devices);
-                }, () => {
+                })
+                .catch(error => {
+                    logger.warn(`Failed to  enumerate devices. ${error}`);
                     updateKnownDevices([]);
                     callback([]);
                 });
         return availableDevices;
     }
 
+    /**
+     * Returns whether available devices have permissions granted
+     * @returns {Boolean}
+     */
+    arePermissionsGrantedForAvailableDevices() {
+        return availableDevices.some(device => Boolean(device.label));
+    }
+
     /**
      * Returns event data for device to be reported to stats.
      * @returns {MediaDeviceInfo} device.