[RN] Add audio only mode for conferences

The behavior can be triggered with the toggleAudioOnly action, which is
currently fired with a button.

The following aspects of the conference will change when in audio only mode:

- local video is muted
- last N is set to 0 (effectively muting remote video)
- full-screen mode is exited
- audio mode is set to "audio chat" (default output is the earpiece)
- the wake lock is disengaged

One aspect not handled in this patch is disabling the video mute button while in
audio only mode. The user should not be able to turn back video on in that case.

react/features/base/conference/actionTypes.js

  */
 export const LOCK_STATE_CHANGED = Symbol('LOCK_STATE_CHANGED');
 
+/**
+ * The type of the Redux action which sets the audio-only flag for the current
+ * conference.
+ *
+ * {
+ *     type: SET_AUDIO_ONLY,
+ *     audioOnly: boolean
+ * }
+ */
+export const SET_AUDIO_ONLY = Symbol('SET_AUDIO_ONLY');
+
+/**
+ * The type of redux action which signals that video will be muted because the
+ * audio-only mode was enabled / disabled.
+ *
+ * {
+ *     type: _SET_AUDIO_ONLY_VIDEO_MUTED,
+ *     muted: boolean
+ * }
+ *
+ * @protected
+ */
+export const _SET_AUDIO_ONLY_VIDEO_MUTED
+    = Symbol('_SET_AUDIO_ONLY_VIDEO_MUTED');
+
 /**
  * The type of redux action which sets the video channel's lastN (value).
  *
  *     type: SET_LASTN,
  *     lastN: number
  * }
- *
  */
 export const SET_LASTN = Symbol('SET_LASTN');
 

react/features/base/conference/actions.js

 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
+import { setVideoMuted } from '../media';
 import {
     dominantSpeakerChanged,
     getLocalParticipant,
     CONFERENCE_WILL_JOIN,
     CONFERENCE_WILL_LEAVE,
     LOCK_STATE_CHANGED,
+    SET_AUDIO_ONLY,
+    _SET_AUDIO_ONLY_VIDEO_MUTED,
     SET_LASTN,
     SET_PASSWORD,
     SET_ROOM
     };
 }
 
+/**
+ * Sets the audio-only flag for the current JitsiConference.
+ *
+ * @param {boolean} audioOnly - True if the conference should be audio only;
+ * false, otherwise.
+ * @private
+ * @returns {{
+ *     type: SET_AUDIO_ONLY,
+ *     audioOnly: boolean
+ * }}
+ */
+function _setAudioOnly(audioOnly) {
+    return {
+        type: SET_AUDIO_ONLY,
+        audioOnly
+    };
+}
+
+/**
+ * Signals that the app should mute video because it's now in audio-only mode,
+ * or unmute it because it no longer is. If video was already muted, nothing
+ * will happen; otherwise, it will be muted. When audio-only mode is disabled,
+ * the previous state will be restored.
+ *
+ * @param {boolean} muted - True if video should be muted; false, otherwise.
+ * @protected
+ * @returns {Function}
+ */
+export function _setAudioOnlyVideoMuted(muted: boolean) {
+    return (dispatch, getState) => {
+        if (muted) {
+            const { video } = getState()['features/base/media'];
+
+            if (video.muted) {
+                // Video is already muted, do nothing.
+                return;
+            }
+        } else {
+            const { audioOnlyVideoMuted }
+                = getState()['features/base/conference'];
+
+            if (!audioOnlyVideoMuted) {
+                // We didn't mute video, do nothing.
+                return;
+            }
+        }
+
+        // Remember that local video was muted due to the audio-only mode
+        // vs user's choice.
+        dispatch({
+            type: _SET_AUDIO_ONLY_VIDEO_MUTED,
+            muted
+        });
+        dispatch(setVideoMuted(muted));
+    };
+}
+
 /**
  * Sets the video channel's last N (value) of the current conference. A value of
  * undefined shall be used to reset it to the default value.
         room
     };
 }
+
+/**
+ * Toggles the audio-only flag for the current JitsiConference.
+ *
+ * @returns {Function}
+ */
+export function toggleAudioOnly() {
+    return (dispatch: Dispatch<*>, getState: Function) => {
+        const { audioOnly } = getState()['features/base/conference'];
+
+        return dispatch(_setAudioOnly(!audioOnly));
+    };
+}

react/features/base/conference/middleware.js

 import { MiddlewareRegistry } from '../redux';
 import { TRACK_ADDED, TRACK_REMOVED } from '../tracks';
 
-import { createConference } from './actions';
-import { SET_LASTN } from './actionTypes';
+import {
+    createConference,
+    _setAudioOnlyVideoMuted,
+    setLastN
+} from './actions';
+import { SET_AUDIO_ONLY, SET_LASTN } from './actionTypes';
 import {
     _addLocalTracksToConference,
     _handleParticipantError,
     case PIN_PARTICIPANT:
         return _pinParticipant(store, next, action);
 
+    case SET_AUDIO_ONLY:
+        return _setAudioOnly(store, next, action);
+
     case SET_LASTN:
         return _setLastN(store, next, action);
 
     return next(action);
 }
 
+/**
+ * Sets the audio-only flag for the current conference. When audio-only is set,
+ * local video is muted and last N is set to 0 to avoid receiving remote video.
+ *
+ * @param {Store} store - The Redux store in which the specified action is being
+ * dispatched.
+ * @param {Dispatch} next - The Redux dispatch function to dispatch the
+ * specified action to the specified store.
+ * @param {Action} action - The Redux action SET_AUDIO_ONLY which is being
+ * dispatched in the specified store.
+ * @private
+ * @returns {Object} The new state that is the result of the reduction of the
+ * specified action.
+ */
+function _setAudioOnly(store, next, action) {
+    const result = next(action);
+
+    const { audioOnly } = action;
+
+    // Set lastN to 0 in case audio-only is desired; leave it as undefined,
+    // otherwise, and the default lastN value will be chosen automatically.
+    store.dispatch(setLastN(audioOnly ? 0 : undefined));
+
+    // Mute local video
+    store.dispatch(_setAudioOnlyVideoMuted(audioOnly));
+
+    return result;
+}
+
 /**
  * Sets the last N (value) of the video channel in the conference.
  *

react/features/base/conference/reducer.js

     CONFERENCE_LEFT,
     CONFERENCE_WILL_LEAVE,
     LOCK_STATE_CHANGED,
+    SET_AUDIO_ONLY,
+    _SET_AUDIO_ONLY_VIDEO_MUTED,
     SET_PASSWORD,
     SET_ROOM
 } from './actionTypes';
     case LOCK_STATE_CHANGED:
         return _lockStateChanged(state, action);
 
+    case SET_AUDIO_ONLY:
+        return _setAudioOnly(state, action);
+
+    case _SET_AUDIO_ONLY_VIDEO_MUTED:
+        return _setAudioOnlyVideoMuted(state, action);
+
     case SET_PASSWORD:
         return _setPassword(state, action);
 
 
     return (
         setStateProperties(state, {
+            audioOnly: undefined,
+            audioOnlyVideoMuted: undefined,
             conference: undefined,
             leaving: undefined,
             locked: undefined,
 
     return (
         setStateProperties(state, {
+            audioOnly: undefined,
+            audioOnlyVideoMuted: undefined,
             conference: undefined,
             leaving: undefined,
             locked: undefined,
     return setStateProperty(state, 'locked', action.locked || undefined);
 }
 
+/**
+ * Reduces a specific Redux action SET_AUDIO_ONLY of the feature
+ * base/conference.
+ *
+ * @param {Object} state - The Redux state of the feature base/conference.
+ * @param {Action} action - The Redux action SET_AUDIO_ONLY to reduce.
+ * @private
+ * @returns {Object} The new state of the feature base/conference after the
+ * reduction of the specified action.
+ */
+function _setAudioOnly(state, action) {
+    return setStateProperty(state, 'audioOnly', action.audioOnly);
+}
+
+/**
+ * Reduces a specific Redux action _SET_AUDIO_ONLY_VIDEO_MUTED of the feature
+ * base/conference.
+ *
+ * @param {Object} state - The Redux state of the feature base/conference.
+ * @param {Action} action - The Redux action SET_AUDIO_ONLY_VIDEO_MUTED to
+ * reduce.
+ * @private
+ * @returns {Object} The new state of the feature base/conference after the
+ * reduction of the specified action.
+ */
+function _setAudioOnlyVideoMuted(state, action) {
+    return setStateProperty(state, 'audioOnlyVideoMuted', action.muted);
+}
+
 /**
  * Reduces a specific Redux action SET_PASSWORD of the feature base/conference.
  *

react/features/mobile/audio-mode/middleware.js

 import {
     CONFERENCE_FAILED,
     CONFERENCE_LEFT,
-    CONFERENCE_WILL_JOIN
+    CONFERENCE_WILL_JOIN,
+    SET_AUDIO_ONLY
 } from '../../base/conference';
 import { MiddlewareRegistry } from '../../base/redux';
 
 MiddlewareRegistry.register(store => next => action => {
     const AudioMode = NativeModules.AudioMode;
 
-    // The react-native module AudioMode is implemented on iOS at the time of
-    // this writing.
     if (AudioMode) {
         let mode;
 
             break;
 
         case CONFERENCE_WILL_JOIN: {
-            const conference = store.getState()['features/base/conference'];
+            const { audioOnly } = store.getState()['features/base/conference'];
 
+            mode = audioOnly ? AudioMode.AUDIO_CALL : AudioMode.VIDEO_CALL;
+            break;
+        }
+
+        case SET_AUDIO_ONLY:
             mode
-                = conference.audioOnly
+                = action.audioOnly
                     ? AudioMode.AUDIO_CALL
                     : AudioMode.VIDEO_CALL;
             break;
-        }
 
         default:
             mode = null;

react/features/mobile/background/actions.js

         // for last N will be chosen automatically.
         const { audioOnly } = getState()['features/base/conference'];
 
-        if (!audioOnly) {
-            dispatch(setLastN(muted ? 0 : undefined));
+        if (audioOnly) {
+            return;
         }
 
+        dispatch(setLastN(muted ? 0 : undefined));
+
         if (muted) {
             const { video } = getState()['features/base/media'];
 

react/features/mobile/full-screen/middleware.js

 import {
     CONFERENCE_FAILED,
     CONFERENCE_LEFT,
-    CONFERENCE_WILL_JOIN
+    CONFERENCE_WILL_JOIN,
+    SET_AUDIO_ONLY
 } from '../../base/conference';
 import { Platform } from '../../base/react';
 import { MiddlewareRegistry } from '../../base/redux';
     case CONFERENCE_LEFT:
         fullScreen = false;
         break;
+
+    case SET_AUDIO_ONLY:
+        fullScreen = !action.audioOnly;
+        break;
     }
 
     if (fullScreen !== null) {

react/features/mobile/wake-lock/middleware.js

 import {
     CONFERENCE_FAILED,
     CONFERENCE_JOINED,
-    CONFERENCE_LEFT
+    CONFERENCE_LEFT,
+    SET_AUDIO_ONLY
 } from '../../base/conference';
 import { MiddlewareRegistry } from '../../base/redux';
 
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
     case CONFERENCE_JOINED: {
-        const state = store.getState()['features/base/conference'];
+        const { audioOnly } = store.getState()['features/base/conference'];
 
-        // TODO(saghul): Implement audio-only mode.
-        if (!state.audioOnly) {
-            _setWakeLock(true);
-        }
+        _setWakeLock(!audioOnly);
         break;
     }
 
     case CONFERENCE_LEFT:
         _setWakeLock(false);
         break;
+
+    case SET_AUDIO_ONLY:
+        _setWakeLock(!action.audioOnly);
+        break;
     }
 
     return next(action);

react/features/toolbox/components/Toolbox.native.js

 import { View } from 'react-native';
 import { connect } from 'react-redux';
 
+import { toggleAudioOnly } from '../../base/conference';
 import { MEDIA_TYPE, toggleCameraFacingMode } from '../../base/media';
 import { Container } from '../../base/react';
 import { ColorPalette } from '../../base/styles';
         _onHangup: React.PropTypes.func,
 
         /**
-         * Handler for room locking.
+         * Sets the lock i.e. password protection of the conference/room.
          */
         _onRoomLock: React.PropTypes.func,
 
         _onToggleAudio: React.PropTypes.func,
 
         /**
-         * Handler for toggling camera facing mode.
+         * Toggles the audio-only flag of the conference.
+         */
+        _onToggleAudioOnly: React.PropTypes.func,
+
+        /**
+         * Switches between the front/user-facing and back/environment-facing
+         * cameras.
          */
         _onToggleCameraFacingMode: React.PropTypes.func,
 
                     onClick = { this.props._onRoomLock }
                     style = { style }
                     underlayColor = { underlayColor } />
+                <ToolbarButton
+                    iconName = 'star'
+                    iconStyle = { iconStyle }
+                    onClick = { this.props._onToggleAudioOnly }
+                    style = { style }
+                    underlayColor = { underlayColor } />
             </View>
         );
 
  * @param {Function} dispatch - Redux action dispatcher.
  * @returns {{
  *     _onRoomLock: Function,
+ *     _onToggleAudioOnly: Function,
  *     _onToggleCameraFacingMode: Function,
  * }}
  * @private
         ...abstractMapDispatchToProps(dispatch),
 
         /**
-         * Dispatches an action to set the lock i.e. password protection of the
-         * conference/room.
+         * Sets the lock i.e. password protection of the conference/room.
          *
          * @private
-         * @returns {Object} - Dispatched action.
+         * @returns {Object} Dispatched action.
          * @type {Function}
          */
         _onRoomLock() {
         },
 
         /**
-         * Switches between the front/user-facing and rear/environment-facing
+         * Toggles the audio-only flag of the conference.
+         *
+         * @private
+         * @returns {Object} Dispatched action.
+         * @type {Function}
+         */
+        _onToggleAudioOnly() {
+            return dispatch(toggleAudioOnly());
+        },
+
+        /**
+         * Switches between the front/user-facing and back/environment-facing
          * cameras.
          *
          * @private
-         * @returns {Object} - Dispatched action.
+         * @returns {Object} Dispatched action.
          * @type {Function}
          */
         _onToggleCameraFacingMode() {