Switching microphone on the fly: flac and wav support

react/features/local-recording/controller/RecordingController.js

     /**
      * Stopping.
      */
-    STOPPING: Symbol('STOPPING')
+    STOPPING: Symbol('STOPPING'),
+
+    /**
+     * Failed, due to error during starting / stopping process.
+     */
+    FAILED: Symbol('FAILED')
 });
 
 /**
      */
     _isMuted = false;
 
+    /**
+     * The ID of the active microphone.
+     *
+     * @private
+     */
+    _micDeviceId = 'default';
+
     /**
      * Current recording format. This will be in effect from the next
      * recording session, i.e., if this value is changed during an on-going
      * @returns {void}
      */
     constructor() {
-        this._updateStats = this._updateStats.bind(this);
+        this.registerEvents = this.registerEvents.bind(this);
+        this.getParticipantsStats = this.getParticipantsStats.bind(this);
         this._onStartCommand = this._onStartCommand.bind(this);
         this._onStopCommand = this._onStopCommand.bind(this);
         this._onPingCommand = this._onPingCommand.bind(this);
         this._doStartRecording = this._doStartRecording.bind(this);
         this._doStopRecording = this._doStopRecording.bind(this);
-        this.registerEvents = this.registerEvents.bind(this);
-        this.getParticipantsStats = this.getParticipantsStats.bind(this);
+        this._updateStats = this._updateStats.bind(this);
+        this._switchToNewSession = this._switchToNewSession.bind(this);
     }
 
     registerEvents: () => void;
         }
     }
 
+    /**
+     * Changes the current microphone.
+     *
+     * @param {string} micDeviceId - The new microphone device ID.
+     * @returns {void}
+     */
+    setMicDevice(micDeviceId: string) {
+        if (micDeviceId !== this._micDeviceId) {
+            this._micDeviceId = String(micDeviceId);
+
+            if (this._state === ControllerState.RECORDING) {
+                // sessionManager.endSegment(this._currentSessionToken);
+                logger.log('Before switching microphone...');
+                this._adapters[this._currentSessionToken]
+                    .setMicDevice(this._micDeviceId)
+                    .then(() => {
+                        logger.log('Finished switching microphone.');
+
+                        // sessionManager.beginSegment(this._currentSesoken);
+                    })
+                    .catch(() => {
+                        logger.error('Failed to switch microphone');
+                    });
+            }
+            logger.log(`Switch microphone to ${this._micDeviceId}`);
+        }
+    }
+
     /**
      * Mute or unmute audio. When muted, the ongoing local recording should
      * produce silence.
         this._isMuted = Boolean(muted);
 
         if (this._state === ControllerState.RECORDING) {
-            this._adapters[this._currentSessionToken].setMuted(muted);
+            this._adapters[this._currentSessionToken].setMuted(this._isMuted);
         }
     }
 
 
         if (this._state === ControllerState.IDLE) {
             this._changeState(ControllerState.STARTING);
-            this._format = format;
-            this._currentSessionToken = sessionToken;
-            logger.log(this._currentSessionToken);
-            this._adapters[sessionToken]
-                 = this._createRecordingAdapter();
+            this._switchToNewSession(sessionToken, format);
             this._doStartRecording();
         } else if (this._state === ControllerState.RECORDING
             && this._currentSessionToken !== sessionToken) {
             // moderator's, so we need to restart the recording.
             this._changeState(ControllerState.STOPPING);
             this._doStopRecording().then(() => {
-                this._format = format;
-                this._currentSessionToken = sessionToken;
-                this._adapters[sessionToken]
-                    = this._createRecordingAdapter();
+                this._changeState(ControllerState.STARTING);
+                this._switchToNewSession(sessionToken, format);
                 this._doStartRecording();
             });
         }
         if (this._state === ControllerState.STARTING) {
             const delegate = this._adapters[this._currentSessionToken];
 
-            delegate.start()
+            delegate.start(this._micDeviceId)
             .then(() => {
                 this._changeState(ControllerState.RECORDING);
                 logger.log('Local recording engaged.');
 
     }
 
+    _switchToNewSession: (string, string) => void;
+
+    /**
+     * Switches to a new local recording session.
+     *
+     * @param {string} sessionToken - The session Token.
+     * @param {string} format - The recording format for the session.
+     * @returns {void}
+     */
+    _switchToNewSession(sessionToken, format) {
+        this._format = format;
+        this._currentSessionToken = sessionToken;
+        logger.log(`New session: ${this._currentSessionToken}, `
+            + `format: ${this._format}`);
+        this._adapters[sessionToken]
+             = this._createRecordingAdapter();
+        sessionManager.createSession(sessionToken, this._format);
+    }
+
     /**
      * Creates a recording adapter according to the current recording format.
      *

react/features/local-recording/middleware.js

 import { i18next } from '../base/i18n';
 import { SET_AUDIO_MUTED } from '../base/media';
 import { MiddlewareRegistry } from '../base/redux';
+import { SETTINGS_UPDATED } from '../base/settings/actionTypes';
 import { showNotification } from '../notifications';
 
 import { localRecordingEngaged, localRecordingUnengaged } from './actions';
     case SET_AUDIO_MUTED:
         recordingController.setMuted(action.muted);
         break;
-    }
+    case SETTINGS_UPDATED: {
+        const { micDeviceId } = getState()['features/base/settings'];
 
-    // @todo: detect change in features/base/settings micDeviceID
-    // @todo: SET_AUDIO_MUTED, when audio is muted
+        if (micDeviceId) {
+            recordingController.setMicDevice(micDeviceId);
+        }
+        break;
+    }
+    }
 
     return result;
 });

react/features/local-recording/recording/OggAdapter.js

      *
      * @inheritdoc
      */
-    start() {
+    start(micDeviceId) {
         if (!this._initPromise) {
-            this._initPromise = this._initialize();
+            this._initPromise = this._initialize(micDeviceId);
         }
 
         return this._initPromise.then(() =>
      * Initialize the adapter.
      *
      * @private
+     * @param {string} micDeviceId - The current microphone device ID.
      * @returns {Promise}
      */
-    _initialize() {
+    _initialize(micDeviceId) {
         if (this._mediaRecorder) {
             return Promise.resolve();
         }
 
         return new Promise((resolve, error) => {
-            this._getAudioStream(0)
+            this._getAudioStream(micDeviceId)
             .then(stream => {
                 this._stream = stream;
                 this._mediaRecorder = new MediaRecorder(stream);

react/features/local-recording/recording/RecordingAdapter.js

     /**
      * Starts recording.
      *
+     * @param {string} micDeviceId - The microphone to record on.
      * @returns {Promise}
      */
-    start() {
+    start(/* eslint-disable no-unused-vars */
+            micDeviceId/* eslint-enable no-unused-vars */) {
         throw new Error('Not implemented');
     }
 
         throw new Error('Not implemented');
     }
 
+    /**
+     * Changes the current microphone.
+     *
+     * @param {string} micDeviceId - The new microphone device ID.
+     * @returns {Promise}
+     */
+    setMicDevice(/* eslint-disable no-unused-vars */
+            micDeviceId/* eslint-enable no-unused-vars */) {
+        throw new Error('Not implemented');
+    }
+
     /**
      * Helper method for getting an audio {@code MediaStream}. Use this instead
      * of calling browser APIs directly.

react/features/local-recording/recording/WavAdapter.js

      *
      * @inheritdoc
      */
-    start() {
+    start(micDeviceId) {
         if (!this._initPromise) {
-            this._initPromise = this._initialize();
+            this._initPromise = this._initialize(micDeviceId);
         }
 
         return this._initPromise.then(() => {
      * Initialize the adapter.
      *
      * @private
+     * @param {string} micDeviceId - The current microphone device ID.
      * @returns {Promise}
      */
-    _initialize() {
+    _initialize(micDeviceId) {
         if (this._isInitialized) {
             return Promise.resolve();
         }
 
         const p = new Promise((resolve, reject) => {
-            this._getAudioStream(0)
+            this._getAudioStream(micDeviceId)
             .then(stream => {
                 this._stream = stream;
                 this._audioContext = new AudioContext();
                 this._audioProcessingNode.onaudioprocess = e => {
                     const channelLeft = e.inputBuffer.getChannelData(0);
 
-                    // https://developer.mozilla.org/en-US/docs/
-                    // Web/API/AudioBuffer/getChannelData
-                    // the returned value is an Float32Array
+                    // See: https://developer.mozilla.org/en-US/docs/Web/API/
+                    //      AudioBuffer/getChannelData
+                    // The returned value is an Float32Array.
                     this._saveWavPCM(channelLeft);
                 };
                 this._isInitialized = true;

react/features/local-recording/recording/flac/FlacAdapter.js

      *
      * @inheritdoc
      */
-    start() {
+    start(micDeviceId) {
         if (!this._initPromise) {
-            this._initPromise = this._initialize();
+            this._initPromise = this._initialize(micDeviceId);
         }
 
         return this._initPromise.then(() => {
         return Promise.resolve();
     }
 
+    /**
+     * Implements {@link RecordingAdapter#setMicDevice()}.
+     *
+     * @inheritdoc
+     */
+    setMicDevice(micDeviceId) {
+        return this._replaceMic(micDeviceId);
+    }
+
+    /**
+     * Replaces the current microphone MediaStream.
+     *
+     * @param {*} micDeviceId - New microphone ID.
+     * @returns {Promise}
+     */
+    _replaceMic(micDeviceId) {
+        if (this._audioContext && this._audioProcessingNode) {
+            return new Promise((resolve, reject) => {
+                this._getAudioStream(micDeviceId).then(newStream => {
+                    const newSource = this._audioContext
+                        .createMediaStreamSource(newStream);
+
+                    this._audioSource.disconnect();
+                    newSource.connect(this._audioProcessingNode);
+                    this._stream = newStream;
+                    this._audioSource = newSource;
+                    resolve();
+                })
+                .catch(() => {
+                    reject();
+                });
+            });
+        }
+
+        return Promise.resolve();
+    }
+
     /**
      * Initialize the adapter.
      *
      * @private
+     * @param {string} micDeviceId - The current microphone device ID.
      * @returns {Promise}
      */
-    _initialize() {
+    _initialize(micDeviceId) {
         if (this._encoder !== null) {
             return Promise.resolve();
         }
                 } else if (e.data.command === DEBUG) {
                     logger.log(e.data);
                 } else if (e.data.command === WORKER_LIBFLAC_READY) {
-                    logger.debug('libflac is ready.');
+                    logger.log('libflac is ready.');
                     resolve();
                 } else {
                     logger.error(
         });
 
         const callbackInitAudioContext = (resolve, reject) => {
-            this._getAudioStream(0)
+            this._getAudioStream(micDeviceId)
             .then(stream => {
                 this._stream = stream;
                 this._audioContext = new AudioContext();
      * @returns {void}
      */
     _loadWebWorker() {
-        // FIXME: workaround for different file names in development/
+        // FIXME: Workaround for different file names in development/
         // production environments.
         // We cannot import flacEncodeWorker as a webpack module,
         // because it is in a different bundle and should be lazy-loaded

react/features/local-recording/recording/flac/flacEncodeWorker.js

 });
 
 /**
- * Default compression level.
+ * Default FLAC compression level.
  */
 const FLAC_COMPRESSION_LEVEL = 5;