fix(iframe-api-devices): Misc small issues.

conference.js

      */
     updateAudioIconEnabled() {
         const audioMediaDevices
-            = APP.store.getState()['features/base/devices'].devices.audioInput;
+            = APP.store.getState()['features/base/devices'].availableDevices.audioInput;
         const audioDeviceCount
             = audioMediaDevices ? audioMediaDevices.length : 0;
 
      */
     updateVideoIconEnabled() {
         const videoMediaDevices
-            = APP.store.getState()['features/base/devices'].devices.videoInput;
+            = APP.store.getState()['features/base/devices'].availableDevices.videoInput;
         const videoDeviceCount
             = videoMediaDevices ? videoMediaDevices.length : 0;
 

doc/api.md

 
 ### Controlling the embedded Jitsi Meet Conference
 
-You can control the available devices  with the following methods of `JitsiMeetExternalAPI` instance:
+Device management `JitsiMeetExternalAPI` methods:
 * **getAvailableDevices** - Retrieve a list of available devices.
 
 ```javascript
     ...
 });
 ```
-* **isMultipleAudioInputSupported** - Resolves with true if the device list is available and with false if not.
+* **isMultipleAudioInputSupported** - Resolves with true if multiple audio input is supported and with false if not.
 
 ```javascript
 api.isMultipleAudioInputSupported().then(function(isMultipleAudioInputSupported) {

modules/API/API.js

 
 import { API_ID } from './constants';
 import {
-    processRequest
+    processExternalDeviceRequest
 } from '../../react/features/device-selection/functions';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
     transport.on('request', (request, callback) => {
         const { dispatch, getState } = APP.store;
 
-        if (processRequest(dispatch, getState, request, callback)) {
+        if (processExternalDeviceRequest(dispatch, getState, request, callback)) {
             return true;
         }
 

modules/API/external/external_api.js

     }
 
     /**
-     * Returns Promise that resolves with result an list of available devices.
+     * Returns Promise that resolves with a list of available devices.
      *
      * @returns {Promise}
      */
     }
 
     /**
-     * Returns Promise that resolves with true if the device list is available
+     * Returns Promise that resolves with true if multiple audio input is supported
      * and with false if not.
      *
      * @returns {Promise}
     }
 
     /**
-     * Sets the audio input device to the one with the id that is passed.
+     * Sets the audio input device to the one with the label or id that is
+     * passed.
      *
+     * @param {string} label - The label of the new device.
      * @param {string} deviceId - The id of the new device.
      * @returns {Promise}
      */
-    setAudioInputDevice(deviceId) {
-        return setAudioInputDevice(this._transport, deviceId);
+    setAudioInputDevice(label, deviceId) {
+        return setAudioInputDevice(this._transport, label, deviceId);
     }
 
     /**
-     * Sets the audio output device to the one with the id that is passed.
+     * Sets the audio output device to the one with the label or id that is
+     * passed.
      *
+     * @param {string} label - The label of the new device.
      * @param {string} deviceId - The id of the new device.
      * @returns {Promise}
      */
-    setAudioOutputDevice(deviceId) {
-        return setAudioOutputDevice(this._transport, deviceId);
+    setAudioOutputDevice(label, deviceId) {
+        return setAudioOutputDevice(this._transport, label, deviceId);
     }
 
     /**
-     * Sets the video input device to the one with the id that is passed.
+     * Sets the video input device to the one with the label or id that is
+     * passed.
      *
+     * @param {string} label - The label of the new device.
      * @param {string} deviceId - The id of the new device.
      * @returns {Promise}
      */
-    setVideoInputDevice(deviceId) {
-        return setVideoInputDevice(this._transport, deviceId);
+    setVideoInputDevice(label, deviceId) {
+        return setVideoInputDevice(this._transport, label, deviceId);
     }
 
     /**

modules/API/external/functions.js

         deviceType,
         type: 'devices',
         name: 'isDeviceChangeAvailable'
-    }).catch(e => {
-        logger.error(e);
-
-        return false;
     });
 }
 
     return transport.sendRequest({
         type: 'devices',
         name: 'isDeviceListAvailable'
-    }).catch(e => {
-        logger.error(e);
-
-        return false;
     });
 }
 
 /**
- * Returns Promise that resolves with true if the device list is available
+ * Returns Promise that resolves with true if multiple audio input is supported
  * and with false if not.
  *
  * @param {Transport} transport - The @code{Transport} instance responsible for
     return transport.sendRequest({
         type: 'devices',
         name: 'isMultipleAudioInputSupported'
-    }).catch(e => {
-        logger.error(e);
-
-        return false;
     });
 }
 

react/features/base/devices/actionTypes.js

  * The type of Redux action which will remove all pending device requests.
  *
  * {
- *     type: REMOVE_PENDING_DEVICE_REQUESTS,
- *     request: Object
+ *     type: REMOVE_PENDING_DEVICE_REQUESTS
  * }
  */
 export const REMOVE_PENDING_DEVICE_REQUESTS = 'REMOVE_PENDING_DEVICE_REQUESTS';

react/features/base/devices/functions.js

  * otherwise.
  */
 export function areDeviceLabelsInitialized(state: Object) {
+    // TODO: Replace with something that doesn't use APP when the conference.js logic is reactified.
     if (APP.conference._localTracksInitialized) {
         return true;
     }
 
     for (const type of [ 'audioInput', 'audioOutput', 'videoInput' ]) {
-        if (state['features/base/devices'].devices[type].find(d => Boolean(d.label))) {
+        if ((state['features/base/devices'].availableDevices[type] || []).find(d => Boolean(d.label))) {
             return true;
         }
     }
 
     for (const type of types) {
         const device
-            = state['features/base/devices'].devices[type]
+            = (state['features/base/devices'].availableDevices[type] || [])
                 .find(d => d.label === label);
 
         if (device) {

react/features/base/devices/middleware.js

 /* global APP */
 
 import { CONFERENCE_JOINED } from '../conference';
-import { processRequest } from '../../device-selection';
+import { processExternalDeviceRequest } from '../../device-selection';
 import { MiddlewareRegistry } from '../redux';
 import UIEvents from '../../../../service/UI/UIEvents';
 
     const { pendingRequests } = state['features/base/devices'];
 
     pendingRequests.forEach(request => {
-        processRequest(
+        processExternalDeviceRequest(
             dispatch,
             getState,
             request,

react/features/base/devices/reducer.js

 import { ReducerRegistry } from '../redux';
 
 const DEFAULT_STATE = {
-    devices: {
+    availableDevices: {
         audioInput: [],
         audioOutput: [],
         videoInput: []
 
             return {
                 ...state,
-                devices: deviceList
+                availableDevices: deviceList
             };
         }
 

react/features/device-selection/actions.js

 import { updateSettings } from '../base/settings';
 
 import { SET_DEVICE_SELECTION_POPUP_DATA } from './actionTypes';
-import { getDeviceSelectionDialogProps, processRequest } from './functions';
+import { getDeviceSelectionDialogProps, processExternalDeviceRequest } from './functions';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
         });
 
         transport.on('request',
-            processRequest.bind(undefined, dispatch, getState));
+            processExternalDeviceRequest.bind(undefined, dispatch, getState));
         transport.on('event', event => {
             if (event.type === 'devices-dialog' && event.name === 'close') {
                 popup.close();

react/features/device-selection/functions.js

     const settings = state['features/base/settings'];
 
     return {
-        availableDevices: state['features/base/devices'].devices,
+        availableDevices: state['features/base/devices'].availableDevices,
         disableAudioInputChange:
             !JitsiMeetJS.isMultipleAudioInputSupported(),
         disableDeviceChange:
  * @param {Object} request - The request to be processed.
  * @param {Function} responseCallback - The callback that will send the
  * response.
- * @returns {boolean}
+ * @returns {boolean} - True if the request has been processed and false otherwise.
  */
-export function processRequest( // eslint-disable-line max-params
+export function processExternalDeviceRequest( // eslint-disable-line max-params
         dispatch: Dispatch<any>,
         getState: Function,
         request: Object,
         responseCallback: Function) {
-    if (request.type === 'devices') {
-        const state = getState();
-        const settings = state['features/base/settings'];
-        const { conference } = state['features/base/conference'];
-        let result = true;
-
-        switch (request.name) {
-        case 'isDeviceListAvailable':
-            responseCallback(JitsiMeetJS.mediaDevices.isDeviceListAvailable());
-            break;
-        case 'isDeviceChangeAvailable':
-            responseCallback(
-                JitsiMeetJS.mediaDevices.isDeviceChangeAvailable(
-                    request.deviceType));
-            break;
-        case 'isMultipleAudioInputSupported':
-            responseCallback(JitsiMeetJS.isMultipleAudioInputSupported());
-            break;
-        case 'getCurrentDevices':
-            dispatch(getAvailableDevices()).then(devices => {
-                if (areDeviceLabelsInitialized(state)) {
-                    let audioInput, audioOutput, videoInput;
-                    const audioOutputDeviceId = getAudioOutputDeviceId();
-                    const { cameraDeviceId, micDeviceId } = settings;
-
-                    devices.forEach(device => {
-                        const { deviceId } = device;
-
-                        switch (deviceId) {
-                        case micDeviceId:
-                            audioInput = device;
-                            break;
-                        case audioOutputDeviceId:
-                            audioOutput = device;
-                            break;
-                        case cameraDeviceId:
-                            videoInput = device;
-                            break;
-                        }
-                    });
-
-                    responseCallback({
-                        audioInput,
-                        audioOutput,
-                        videoInput
-                    });
-                } else {
-                    // The labels are not available if the A/V permissions are
-                    // not yet granted.
-                    dispatch(addPendingDeviceRequest({
-                        type: 'devices',
-                        name: 'getCurrentDevices',
-                        responseCallback
-                    }));
-                }
-            });
-
-            break;
-        case 'getAvailableDevices':
-            dispatch(getAvailableDevices()).then(devices => {
-                if (areDeviceLabelsInitialized(state)) {
-                    responseCallback(groupDevicesByKind(devices));
-                } else {
-                    // The labels are not available if the A/V permissions are
-                    // not yet granted.
-                    dispatch(addPendingDeviceRequest({
-                        type: 'devices',
-                        name: 'getAvailableDevices',
-                        responseCallback
-                    }));
-                }
-            });
-
-            break;
-        case 'setDevice': {
-            const { device } = request;
-
-            if (!conference) {
+    if (request.type !== 'devices') {
+        return false;
+    }
+    const state = getState();
+    const settings = state['features/base/settings'];
+    const { conference } = state['features/base/conference'];
+    let result = true;
+
+    switch (request.name) {
+    case 'isDeviceListAvailable':
+        responseCallback(JitsiMeetJS.mediaDevices.isDeviceListAvailable());
+        break;
+    case 'isDeviceChangeAvailable':
+        responseCallback(
+            JitsiMeetJS.mediaDevices.isDeviceChangeAvailable(
+                request.deviceType));
+        break;
+    case 'isMultipleAudioInputSupported':
+        responseCallback(JitsiMeetJS.isMultipleAudioInputSupported());
+        break;
+    case 'getCurrentDevices':
+        dispatch(getAvailableDevices()).then(devices => {
+            if (areDeviceLabelsInitialized(state)) {
+                let audioInput, audioOutput, videoInput;
+                const audioOutputDeviceId = getAudioOutputDeviceId();
+                const { cameraDeviceId, micDeviceId } = settings;
+
+                devices.forEach(device => {
+                    const { deviceId } = device;
+
+                    switch (deviceId) {
+                    case micDeviceId:
+                        audioInput = device;
+                        break;
+                    case audioOutputDeviceId:
+                        audioOutput = device;
+                        break;
+                    case cameraDeviceId:
+                        videoInput = device;
+                        break;
+                    }
+                });
+
+                responseCallback({
+                    audioInput,
+                    audioOutput,
+                    videoInput
+                });
+            } else {
+                // The labels are not available if the A/V permissions are
+                // not yet granted.
                 dispatch(addPendingDeviceRequest({
                     type: 'devices',
-                    name: 'setDevice',
-                    device,
+                    name: 'getCurrentDevices',
                     responseCallback
                 }));
-
-                return true;
             }
+        });
 
-            const { label, id } = device;
-            const deviceId = label ? getDeviceIdByLabel(state, device.label) : id;
-
-            if (deviceId) {
-                switch (device.kind) {
-                case 'audioinput': {
-                    dispatch(setAudioInputDevice(deviceId));
-                    break;
-                }
-                case 'audiooutput':
-                    setAudioOutputDeviceId(deviceId, dispatch);
-                    break;
-                case 'videoinput':
-                    dispatch(setVideoInputDevice(deviceId));
-                    break;
-                default:
-                    result = false;
-                }
+        break;
+    case 'getAvailableDevices':
+        dispatch(getAvailableDevices()).then(devices => {
+            if (areDeviceLabelsInitialized(state)) {
+                responseCallback(groupDevicesByKind(devices));
             } else {
-                result = false;
+                // The labels are not available if the A/V permissions are
+                // not yet granted.
+                dispatch(addPendingDeviceRequest({
+                    type: 'devices',
+                    name: 'getAvailableDevices',
+                    responseCallback
+                }));
             }
+        });
 
-            responseCallback(result);
-            break;
+        break;
+    case 'setDevice': {
+        const { device } = request;
+
+        if (!conference) {
+            dispatch(addPendingDeviceRequest({
+                type: 'devices',
+                name: 'setDevice',
+                device,
+                responseCallback
+            }));
+
+            return true;
         }
-        default:
 
-            return false;
+        const { label, id } = device;
+        const deviceId = label ? getDeviceIdByLabel(state, device.label) : id;
+
+        if (deviceId) {
+            switch (device.kind) {
+            case 'audioinput': {
+                dispatch(setAudioInputDevice(deviceId));
+                break;
+            }
+            case 'audiooutput':
+                setAudioOutputDeviceId(deviceId, dispatch);
+                break;
+            case 'videoinput':
+                dispatch(setVideoInputDevice(deviceId));
+                break;
+            default:
+                result = false;
+            }
+        } else {
+            result = false;
         }
 
-        return true;
+        responseCallback(result);
+        break;
+    }
+    default:
+        return false;
     }
 
-    return false;
+    return true;
 }
+

react/features/device-selection/middleware.js

     if (action.type === UPDATE_DEVICE_LIST) {
         const state = store.getState();
         const { popupDialogData } = state['features/device-selection'];
-        const { devices } = state['features/base/devices'];
+        const { availableDevices } = state['features/base/devices'];
 
         if (popupDialogData) {
             popupDialogData.transport.sendEvent({
                 name: 'deviceListChanged',
-                devices
+                devices: availableDevices
             });
         }
 
         if (typeof APP !== 'undefined') {
-            APP.API.notifyDeviceListChanged(devices);
+            APP.API.notifyDeviceListChanged(availableDevices);
         }
     }
 

react/features/settings/components/web/DeviceSelectionPopup.js

      * @returns {Promise}
      */
     _isDeviceChangeAvailable(deviceType) {
-        return isDeviceChangeAvailable(this._transport, deviceType);
+        return isDeviceChangeAvailable(this._transport, deviceType).catch(() => false);
     }
 
     /**
      * @returns {Promise}
      */
     _isDeviceListAvailable() {
-        return isDeviceListAvailable(this._transport);
+        return isDeviceListAvailable(this._transport).catch(() => false);
     }
 
     /**
-     * Returns Promise that resolves with true if the device list is available
+     * Returns Promise that resolves with true if multiple audio input is supported
      * and with false if not.
      *
      * @returns {Promise}
      */
     _isMultipleAudioInputSupported() {
-        return isMultipleAudioInputSupported(this._transport);
+        return isMultipleAudioInputSupported(this._transport).catch(() => false);
     }
 
     /**