fix(gum) update permissions prompt detection

Fire PERMISSION_PROMPT_IS_SHOWN when none of the devices have a label
Fire a new SLOW_GET_USER_MEDIA event if the timeout for getUserMedia is exceeded

Update JitsiMeetJS.createLocalTracks to include the options for firing the above events
in the provided options argument. Deprecate the firePermissionPromptIsShownEvent flag in
method's signature

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.