Muting support

fix Promise in setMuted

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

  */
 const PROPERTY_STATS = 'localRecStats';
 
+/**
+ * Supported recording formats.
+ */
+const RECORDING_FORMATS = new Set([ 'flac', 'wav', 'ogg' ]);
+
 /**
  * Default recording format.
  */
      */
     _state = ControllerState.IDLE;
 
+    /**
+     * Whether or not the audio is muted in the UI. This is stored as internal
+     * state of {@code RecordingController} because we might have recording
+     * sessions that start muted.
+     */
+    _isMuted = false;
+
     /**
      * Current recording format. This will be in effect from the next
      * recording session, i.e., if this value is changed during an on-going
         }
     }
 
+    /**
+     * Mute or unmute audio. When muted, the ongoing local recording should
+     * produce silence.
+     *
+     * @param {boolean} muted - If the audio should be muted.
+     * @returns {void}
+     */
+    setMuted(muted: boolean) {
+        this._isMuted = Boolean(muted);
+
+        if (this._state === ControllerState.RECORDING) {
+            this._adapters[this._currentSessionToken].setMuted(muted);
+        }
+    }
+
     /**
      * Switches the recording format.
      *
      * @returns {void}
      */
     switchFormat(newFormat: string) {
+        if (!RECORDING_FORMATS.has(newFormat)) {
+            logger.log(`Unknown format ${newFormat}. Ignoring...`);
+
+            return;
+        }
         this._format = newFormat;
         logger.log(`Recording format switched to ${newFormat}`);
 
     }
 
     /**
-     * Generates a token that can be used to distinguish each
-     * recording session.
+     * Generates a token that can be used to distinguish each local recording
+     * session.
      *
      * @returns {number}
      */
     _getRandomToken() {
-        return Math.floor(Math.random() * 10000) + 1;
+        return Math.floor(Math.random() * 100000000) + 1;
     }
 
     _doStartRecording: () => void;
                 if (this._onStateChanged) {
                     this._onStateChanged(true);
                 }
+
+                delegate.setMuted(this._isMuted);
                 this._updateStats();
             })
             .catch(err => {

react/features/local-recording/middleware.js

 import { CONFERENCE_JOINED } from '../base/conference';
 import { toggleDialog } from '../base/dialog';
 import { i18next } from '../base/i18n';
+import { SET_AUDIO_MUTED } from '../base/media';
 import { MiddlewareRegistry } from '../base/redux';
 import { showNotification } from '../notifications';
 
     switch (action.type) {
     case CONFERENCE_JOINED: {
         const { conference } = getState()['features/base/conference'];
+        const { localRecording } = getState()['features/base/config'];
+
+        if (localRecording && localRecording.format) {
+            recordingController.switchFormat(localRecording.format);
+        }
 
         recordingController.registerEvents(conference);
         break;
     }
     case APP_WILL_MOUNT:
+
         // realize the delegates on recordingController, allowing the UI to
         // react to state changes in recordingController.
         recordingController.onStateChanged = isEngaged => {
         recordingController.onNotify = null;
         recordingController.onWarning = null;
         break;
+    case SET_AUDIO_MUTED:
+        recordingController.setMuted(action.muted);
+        break;
     }
 
     // @todo: detect change in features/base/settings micDeviceID

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

         }
     }
 
+    /**
+     * Implements {@link RecordingAdapter#setMuted()}.
+     *
+     * @inheritdoc
+     */
+    setMuted(muted) {
+        const shouldEnable = !muted;
+
+        if (!this._stream) {
+            return Promise.resolve();
+        }
+
+        const track = this._stream.getAudioTracks()[0];
+
+        if (!track) {
+            logger.error('Cannot mute/unmute. Track not found!');
+
+            return Promise.resolve();
+        }
+
+        if (track.enabled !== shouldEnable) {
+            track.enabled = shouldEnable;
+            logger.log(muted ? 'Mute' : 'Unmute');
+        }
+
+        return Promise.resolve();
+    }
+
     /**
      * Initialize the adapter.
      *
         return new Promise((resolve, error) => {
             this._getAudioStream(0)
             .then(stream => {
+                this._stream = stream;
                 this._mediaRecorder = new MediaRecorder(stream);
                 this._mediaRecorder.ondataavailable
                     = e => this._saveMediaData(e.data);

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

     }
 
     /**
-     * Helper method for getting an audio MediaStream. Use this instead of
-     * calling browser APIs directly.
+     * Mutes or unmutes the current recording.
+     *
+     * @param {boolean} muted - Whether to mute or to unmute.
+     * @returns {Promise}
+     */
+    setMuted(/* eslint-disable no-unused-vars */
+            muted/* 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.
      *
      * @protected
      * @param {number} micDeviceId - The ID of the current audio device.
             const mediaStream = result[0].stream;
 
             if (mediaStream === undefined) {
-                throw new Error('Failed to get MediaStream.');
+                throw new Error('Failed to create local track.');
             }
 
             return mediaStream;

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

 }
 
 /**
- * Obtains a timestamp of now.
- * Used in filenames.
+ * Obtains a timestamp of now. Used in filenames.
  *
  * @returns {string}
  */

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

  */
 export class WavAdapter extends RecordingAdapter {
 
+    /**
+     * The current {@code MediaStream} instance.
+     */
+    _stream = null;
+
     /**
      * {@code AudioContext} instance.
      */
             this._initPromise = this._initialize();
         }
 
-        return new Promise(
-            (resolve, /* eslint-disable */_reject/* eslint-enable */) => {
-                this._wavBuffers = [];
-                this._wavLength = 0;
-                this._wavBuffers.push(this._createWavHeader());
+        return this._initPromise.then(() => {
+            this._wavBuffers = [];
+            this._wavLength = 0;
+            this._wavBuffers.push(this._createWavHeader());
 
-                this._audioSource.connect(this._audioProcessingNode);
-                this._audioProcessingNode
-                    .connect(this._audioContext.destination);
-                resolve();
-            });
+            this._audioSource.connect(this._audioProcessingNode);
+            this._audioProcessingNode
+                .connect(this._audioContext.destination);
+        });
     }
 
     /**
         }
     }
 
+    /**
+     * Implements {@link RecordingAdapter#setMuted()}.
+     *
+     * @inheritdoc
+     */
+    setMuted(muted) {
+        const shouldEnable = !muted;
+
+        if (!this._stream) {
+            return Promise.resolve();
+        }
+
+        const track = this._stream.getAudioTracks()[0];
+
+        if (!track) {
+            logger.error('Cannot mute/unmute. Track not found!');
+
+            return Promise.resolve();
+        }
+
+        if (track.enabled !== shouldEnable) {
+            track.enabled = shouldEnable;
+            logger.log(muted ? 'Mute' : 'Unmute');
+        }
+
+        return Promise.resolve();
+    }
+
     /**
      * Creates a WAVE file header.
      *
         const p = new Promise((resolve, reject) => {
             this._getAudioStream(0)
             .then(stream => {
+                this._stream = stream;
                 this._audioContext = new AudioContext();
                 this._audioSource
                     = this._audioContext.createMediaStreamSource(stream);
      * @returns {void}
      */
     _saveWavPCM(data) {
-        // need to copy the Float32Array,
-        // unlike passing to WebWorker,
-        // this data is passed by reference,
-        // so we need to copy it, otherwise the
-        // audio file will be just repeating the last
-        // segment.
+        // Need to copy the Float32Array:
+        // unlike passing to WebWorker, this data is passed by reference,
+        // so we need to copy it, otherwise the resulting audio file will be
+        // just repeating the last segment.
         this._wavBuffers.push(new Float32Array(data));
         this._wavLength += data.length;
     }

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

     _audioContext = null;
     _audioProcessingNode = null;
     _audioSource = null;
+    _stream = null;
 
     /**
      * Resolve function of the promise returned by {@code stop()}.
         }
     }
 
+    /**
+     * Implements {@link RecordingAdapter#setMuted()}.
+     *
+     * @inheritdoc
+     */
+    setMuted(muted) {
+        const shouldEnable = !muted;
+
+        if (!this._stream) {
+            return Promise.resolve();
+        }
+
+        const track = this._stream.getAudioTracks()[0];
+
+        if (!track) {
+            logger.error('Cannot mute/unmute. Track not found!');
+
+            return Promise.resolve();
+        }
+
+        if (track.enabled !== shouldEnable) {
+            track.enabled = shouldEnable;
+            logger.log(muted ? 'Mute' : 'Unmute');
+        }
+
+        return Promise.resolve();
+    }
+
     /**
      * Initialize the adapter.
      *
         const callbackInitAudioContext = (resolve, reject) => {
             this._getAudioStream(0)
             .then(stream => {
+                this._stream = stream;
                 this._audioContext = new AudioContext();
                 this._audioSource
                     = this._audioContext.createMediaStreamSource(stream);
             });
         };
 
-        // FIXME: because Promise constructor immediately executes the executor
+        // Because Promise constructor immediately executes the executor
         // function. This is undesirable, we want callbackInitAudioContext to be
         // executed only **after** promiseInitWorker is resolved.
         return promiseInitWorker