fix(api-devices): Initial device function calls

doc/api.md

     * **jwt**: (optional) [JWT](https://jwt.io/) token.
     * **onload**: (optional) handler for the iframe onload event.
     * **invitees**: (optional) Array of objects containing information about new participants that will be invited in the call.
+    * **devices**: (optional) A map containing information about the initial devices that will be used in the call.
 
 Example:
 
 var api = new JitsiMeetExternalAPI(domain, options);
 ```
 
+You can set the initial media devices for the call:
+
+```javascript
+var domain = "meet.jit.si";
+var options = {
+    ...
+    devices: {
+        'audioInput': '<device_id>',
+        'audioOutput': '<device_id>',
+        'videoInput': '<device_id>'
+    }
+}
+var api = new JitsiMeetExternalAPI(domain, options);
+```
+
 You can overwrite options set in [config.js] and [interface_config.js].
 For example, to enable the filmstrip-only interface mode, you can use:
 

modules/API/external/external_api.js

      * for iframe onload event.
      * @param {Array<Object>} [options.invitees] - Array of objects containing
      * information about new participants that will be invited in the call.
+     * @param {Array<Object>} [options.devices] - Array of objects containing
+     * information about the initial devices that will be used in the call.
      */
     constructor(domain, ...args) {
         super();
             noSSL = false,
             jwt = undefined,
             onload = undefined,
-            invitees
+            invitees,
+            devices
         } = parseArguments(args);
 
         this._parentNode = parentNode;
             interfaceConfigOverwrite,
             jwt,
             noSSL,
-            roomName
+            roomName,
+            devices
         });
         this._createIFrame(height, width, onload);
         this._transport = new Transport({

react/features/base/connection/actions.web.js

 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
+import { configureInitialDevices } from '../devices';
+
 export {
     connectionEstablished,
     connectionFailed,
 
         // XXX For web based version we use conference initialization logic
         // from the old app (at the moment of writing).
-        return APP.conference.init({
-            roomName: room
-        }).catch(error => {
-            APP.API.notifyConferenceLeft(APP.conference.roomName);
-            logger.error(error);
-        });
+        return dispatch(configureInitialDevices()).then(
+            () => APP.conference.init({
+                roomName: room
+            }).catch(error => {
+                APP.API.notifyConferenceLeft(APP.conference.roomName);
+                logger.error(error);
+            }));
     };
 }
 

react/features/base/devices/actions.js

 import JitsiMeetJS from '../lib-jitsi-meet';
+import { updateSettings } from '../settings';
 
 import {
     SET_AUDIO_INPUT_DEVICE,
     SET_VIDEO_INPUT_DEVICE,
     UPDATE_DEVICE_LIST
 } from './actionTypes';
+import { getDevicesFromURL } from './functions';
 
 /**
  * Queries for connected A/V input and output devices and updates the redux
         devices
     };
 }
+
+/**
+ * Configures the initial A/V devices before the conference has started.
+ *
+ * @returns {Function}
+ */
+export function configureInitialDevices() {
+    return (dispatch, getState) => new Promise(resolve => {
+        const devices = getDevicesFromURL(getState());
+
+        if (devices) {
+            dispatch(updateSettings({
+                ...devices
+            }));
+            resolve();
+        }
+    });
+}
+

react/features/base/devices/functions.js

 // @flow
 
+import { parseURLParams } from '../config';
 import JitsiMeetJS from '../lib-jitsi-meet';
 import { updateSettings } from '../settings';
 
                 audioOutputDeviceId: newId
             })));
 }
+
+/**
+ * Converts an array of media devices into an object organized by device kind.
+ *
+ * @param {Array<MediaDeviceInfo>} devices - Available media devices.
+ * @private
+ * @returns {Object} An object with the media devices split by type. The keys
+ * are device type and the values are arrays with devices matching the device
+ * type.
+ */
+export function groupDevicesByKind(devices: Object[]): Object {
+    return {
+        audioInput: devices.filter(device => device.kind === 'audioinput'),
+        audioOutput: devices.filter(device => device.kind === 'audiooutput'),
+        videoInput: devices.filter(device => device.kind === 'videoinput')
+    };
+}
+
+/**
+ * Returns the devices set in the URL.
+ *
+ * @param {Object} state - The redux state.
+ * @returns {Object|undefined}
+ */
+export function getDevicesFromURL(state: Object) {
+    const urlParams
+        = parseURLParams(state['features/base/connection'].locationURL);
+
+    const audioOutputDeviceId = urlParams['devices.audioOutput'];
+    const cameraDeviceId = urlParams['devices.videoInput'];
+    const micDeviceId = urlParams['devices.audioInput'];
+
+    if (!audioOutputDeviceId && !cameraDeviceId && !micDeviceId) {
+        return undefined;
+    }
+
+    const devices = {};
+
+    audioOutputDeviceId && (devices.audioOutputDeviceId = audioOutputDeviceId);
+    cameraDeviceId && (devices.cameraDeviceId = cameraDeviceId);
+    micDeviceId && (devices.micDeviceId = micDeviceId);
+
+    return devices;
+}

react/features/base/devices/reducer.js

     SET_VIDEO_INPUT_DEVICE,
     UPDATE_DEVICE_LIST
 } from './actionTypes';
+import { groupDevicesByKind } from './functions';
 
 import { ReducerRegistry } from '../redux';
 
     (state = DEFAULT_STATE, action) => {
         switch (action.type) {
         case UPDATE_DEVICE_LIST: {
-            const deviceList = _groupDevicesByKind(action.devices);
+            const deviceList = groupDevicesByKind(action.devices);
 
             return {
                 ...deviceList
         }
     });
 
-/**
- * Converts an array of media devices into an object organized by device kind.
- *
- * @param {Array<MediaDeviceInfo>} devices - Available media devices.
- * @private
- * @returns {Object} An object with the media devices split by type. The keys
- * are device type and the values are arrays with devices matching the device
- * type.
- */
-function _groupDevicesByKind(devices) {
-    return {
-        audioInput: devices.filter(device => device.kind === 'audioinput'),
-        audioOutput: devices.filter(device => device.kind === 'audiooutput'),
-        videoInput: devices.filter(device => device.kind === 'videoinput')
-    };
-}

react/features/base/util/uri.js

 
     let { hash } = url;
 
-    for (const configName of [ 'config', 'interfaceConfig' ]) {
+    for (const urlPrefix of [ 'config', 'interfaceConfig', 'devices' ]) {
         const urlParamsArray
             = _objectToURLParamsArray(
-                o[`${configName}Overwrite`]
-                    || o[configName]
-                    || o[`${configName}Override`]);
+                o[`${urlPrefix}Overwrite`]
+                    || o[urlPrefix]
+                    || o[`${urlPrefix}Override`]);
 
         if (urlParamsArray.length) {
             let urlParamsString
-                = `${configName}.${urlParamsArray.join(`&${configName}.`)}`;
+                = `${urlPrefix}.${urlParamsArray.join(`&${urlPrefix}.`)}`;
 
             if (hash.length) {
                 urlParamsString = `&${urlParamsString}`;

react/features/device-selection/functions.js

 // @flow
 import {
     getAudioOutputDeviceId,
+    getAvailableDevices,
+    groupDevicesByKind,
     setAudioInputDevice,
     setAudioOutputDeviceId,
     setVideoInputDevice
  * response.
  * @returns {boolean}
  */
-export function processRequest(dispatch: Dispatch<*>, getState: Function, request: Object, responseCallback: Function) { // eslint-disable-line max-len, max-params
+export function processRequest( // eslint-disable-line max-params
+        dispatch: Dispatch<*>,
+        getState: Function,
+        request: Object,
+        responseCallback: Function) {
     if (request.type === 'devices') {
         const state = getState();
         const settings = state['features/base/settings'];
             });
             break;
         case 'getAvailableDevices':
-            responseCallback(getState()['features/base/devices']);
+            dispatch(getAvailableDevices()).then(
+                devices => responseCallback(groupDevicesByKind(devices)));
+
             break;
         case 'setDevice': {
             const { device } = request;
                 dispatch(setVideoInputDevice(device.id));
                 break;
             default:
-
+                responseCallback(false);
             }
 
             responseCallback(true);