fix(prejoin): Store prejoin tracks in 'features/base/tracks'

conference.js

 import { suspendDetected } from './react/features/power-monitor';
 import {
     initPrejoin,
-    isPrejoinPageEnabled,
-    isPrejoinPageVisible,
-    replacePrejoinAudioTrack,
-    replacePrejoinVideoTrack
+    isPrejoinPageEnabled
 } from './react/features/prejoin';
 import { createRnnoiseProcessorPromise } from './react/features/rnnoise';
 import { toggleScreenshotCaptureEffect } from './react/features/screenshot-capture';
     useVideoStream(newStream) {
         return new Promise((resolve, reject) => {
             _replaceLocalVideoTrackQueue.enqueue(onFinish => {
-                /**
-                 * When the prejoin page is visible there is no conference object
-                 * created. The prejoin tracks are managed separately,
-                 * so this updates the prejoin video track.
-                 */
-                if (isPrejoinPageVisible(APP.store.getState())) {
-                    return APP.store.dispatch(replacePrejoinVideoTrack(newStream))
-                        .then(resolve)
-                        .catch(reject)
-                        .then(onFinish);
-                }
-
                 APP.store.dispatch(
                 replaceLocalTrack(this.localVideo, newStream, room))
                     .then(() => {
     useAudioStream(newStream) {
         return new Promise((resolve, reject) => {
             _replaceLocalAudioTrackQueue.enqueue(onFinish => {
-                /**
-                 * When the prejoin page is visible there is no conference object
-                 * created. The prejoin tracks are managed separately,
-                 * so this updates the prejoin audio stream.
-                 */
-                if (isPrejoinPageVisible(APP.store.getState())) {
-                    return APP.store.dispatch(replacePrejoinAudioTrack(newStream))
-                        .then(resolve)
-                        .catch(reject)
-                        .then(onFinish);
-                }
-
                 APP.store.dispatch(
                 replaceLocalTrack(this.localAudio, newStream, room))
                     .then(() => {

css/_settings-button.scss

                 cursor: initial;
                 color: #fff;
                 background-color: #a4b8d1;
+
+                &:hover {
+                    background-color: #a4b8d1;
+                }
             }
 
             svg {

react/features/base/media/functions.js

 
 import { VIDEO_MUTISM_AUTHORITY } from './constants';
 
+/**
+ * Determines whether audio is currently muted.
+ *
+ * @param {Function|Object} stateful - The redux store, state, or
+ * {@code getState} function.
+ * @returns {boolean}
+ */
+export function isAudioMuted(stateful: Function | Object) {
+    return Boolean(toState(stateful)['features/base/media'].audio.muted);
+}
+
 /**
  * Determines whether video is currently muted by the audio-only authority.
  *

react/features/base/settings/functions.web.js

  * @returns {void}
  */
 export function getCurrentCameraDeviceId(state: Object) {
-    return state['features/base/settings'].cameraDeviceId;
+    return getDeviceIdByType(state, 'isVideoTrack');
 }
 
 /**
  * @returns {void}
  */
 export function getCurrentMicDeviceId(state: Object) {
-    return state['features/base/settings'].micDeviceId;
+    return getDeviceIdByType(state, 'isAudioTrack');
 }
 
 /**
     return state['features/base/settings'].audioOutputDeviceId;
 }
 
+/**
+ * Returns the deviceId for the corresponding local track type.
+ *
+ * @param {Object} state - The state of the application.
+ * @param {string} isType - Can be 'isVideoTrack' | 'isAudioTrack'.
+ * @returns {string}
+ */
+function getDeviceIdByType(state: Object, isType: string) {
+    const [ deviceId ] = state['features/base/tracks']
+          .map(t => t.jitsiTrack)
+          .filter(t => t && t.isLocal() && t[isType]())
+          .map(t => t.getDeviceId());
+
+    return deviceId || '';
+}
+
 /**
  * Returns the saved display name.
  *

react/features/base/tracks/actions.js

  * @returns {Function}
  */
 export function replaceLocalTrack(oldTrack, newTrack, conference) {
-    return (dispatch, getState) => {
+    return async (dispatch, getState) => {
         conference
 
             // eslint-disable-next-line no-param-reassign
             || (conference = getState()['features/base/conference'].conference);
 
-        return conference.replaceTrack(oldTrack, newTrack)
+        if (conference) {
+            await conference.replaceTrack(oldTrack, newTrack);
+        }
+
+        return dispatch(replaceStoredTracks(oldTrack, newTrack));
+    };
+}
+
+/**
+ * Replaces a stored track with another.
+ *
+ * @param {JitsiLocalTrack|null} oldTrack - The track to dispose.
+ * @param {JitsiLocalTrack|null} newTrack - The track to use instead.
+ * @returns {Function}
+ */
+function replaceStoredTracks(oldTrack, newTrack) {
+    return dispatch => {
+        // We call dispose after doing the replace because dispose will
+        // try and do a new o/a after the track removes itself. Doing it
+        // after means the JitsiLocalTrack.conference is already
+        // cleared, so it won't try and do the o/a.
+        const disposePromise
+              = oldTrack
+                  ? dispatch(_disposeAndRemoveTracks([ oldTrack ]))
+                  : Promise.resolve();
+
+        return disposePromise
             .then(() => {
-                // We call dispose after doing the replace because dispose will
-                // try and do a new o/a after the track removes itself. Doing it
-                // after means the JitsiLocalTrack.conference is already
-                // cleared, so it won't try and do the o/a.
-                const disposePromise
-                    = oldTrack
-                        ? dispatch(_disposeAndRemoveTracks([ oldTrack ]))
-                        : Promise.resolve();
-
-                return disposePromise
-                    .then(() => {
-                        if (newTrack) {
-                            // The mute state of the new track should be
-                            // reflected in the app's mute state. For example,
-                            // if the app is currently muted and changing to a
-                            // new track that is not muted, the app's mute
-                            // state should be falsey. As such, emit a mute
-                            // event here to set up the app to reflect the
-                            // track's mute state. If this is not done, the
-                            // current mute state of the app will be reflected
-                            // on the track, not vice-versa.
-                            const setMuted
-                                = newTrack.isVideoTrack()
-                                    ? setVideoMuted
-                                    : setAudioMuted;
-                            const isMuted = newTrack.isMuted();
-
-                            sendAnalytics(createTrackMutedEvent(
-                                newTrack.getType(),
-                                'track.replaced',
-                                isMuted));
-                            logger.log(`Replace ${newTrack.getType()} track - ${
-                                isMuted ? 'muted' : 'unmuted'}`);
-
-                            return dispatch(setMuted(isMuted));
-                        }
-                    })
-                    .then(() => {
-                        if (newTrack) {
-                            return dispatch(_addTracks([ newTrack ]));
-                        }
-                    });
+                if (newTrack) {
+                    // The mute state of the new track should be
+                    // reflected in the app's mute state. For example,
+                    // if the app is currently muted and changing to a
+                    // new track that is not muted, the app's mute
+                    // state should be falsey. As such, emit a mute
+                    // event here to set up the app to reflect the
+                    // track's mute state. If this is not done, the
+                    // current mute state of the app will be reflected
+                    // on the track, not vice-versa.
+                    const setMuted
+                          = newTrack.isVideoTrack()
+                              ? setVideoMuted
+                              : setAudioMuted;
+                    const isMuted = newTrack.isMuted();
+
+                    sendAnalytics(createTrackMutedEvent(
+                        newTrack.getType(),
+                        'track.replaced',
+                        isMuted));
+                    logger.log(`Replace ${newTrack.getType()} track - ${
+                        isMuted ? 'muted' : 'unmuted'}`);
+
+                    return dispatch(setMuted(isMuted));
+                }
+            })
+            .then(() => {
+                if (newTrack) {
+                    return dispatch(_addTracks([ newTrack ]));
+                }
             });
     };
 }

react/features/base/tracks/functions.js

     return presenterTrack ? MEDIA_TYPE.PRESENTER : MEDIA_TYPE.VIDEO;
 }
 
+/**
+ * Returns the stored local video track.
+ *
+ * @param {Object} state - The redux state.
+ * @returns {Object}
+ */
+export function getLocalJitsiVideoTrack(state) {
+    const track = getLocalVideoTrack(state['features/base/tracks']);
+
+    return track?.jitsiTrack;
+}
+
 /**
  * Returns track of specified media type for specified participant id.
  *

react/features/base/tracks/middleware.js

 
 import UIEvents from '../../../../service/UI/UIEvents';
 import { hideNotification } from '../../notifications';
+import { isPrejoinPageVisible } from '../../prejoin/functions';
+import { getAvailableDevices } from '../devices/actions';
 import {
     CAMERA_FACING_MODE,
     MEDIA_TYPE,
 import { MiddlewareRegistry } from '../redux';
 
 import {
+    TRACK_ADDED,
     TOGGLE_SCREENSHARING,
     TRACK_NO_DATA_FROM_SOURCE,
     TRACK_REMOVED,
  */
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
+    case TRACK_ADDED: {
+        // The devices list needs to be refreshed when no initial video permissions
+        // were granted and a local video track is added by umuting the video.
+        if (action.track.local) {
+            store.dispatch(getAvailableDevices());
+        }
+
+        break;
+    }
     case TRACK_NO_DATA_FROM_SOURCE: {
         const result = next(action);
 
         // anymore, unless it is muted by audioOnly.
         jitsiTrack && (jitsiTrack.videoType !== 'desktop' || isAudioOnly)
             && setTrackMuted(jitsiTrack, muted);
-    } else if (!muted && ensureTrack && typeof APP === 'undefined') {
+    } else if (!muted && ensureTrack && (typeof APP === 'undefined' || isPrejoinPageVisible(store.getState()))) {
         // FIXME: This only runs on mobile now because web has its own way of
         // creating local tracks. Adjust the check once they are unified.
         store.dispatch(createLocalTracksA({ devices: [ mediaType ] }));

react/features/prejoin/actionTypes.js

-/**
- * Action type to add a video track to the store.
- */
-export const ADD_PREJOIN_VIDEO_TRACK = 'ADD_PREJOIN_VIDEO_TRACK';
-
-/**
- * Action type to add an audio track to the store.
- */
-export const ADD_PREJOIN_AUDIO_TRACK = 'ADD_PREJOIN_AUDIO_TRACK';
-
-/**
- * Action type to add a content sharing track to the store.
- */
-export const ADD_PREJOIN_CONTENT_SHARING_TRACK
-    = 'ADD_PREJOIN_CONTENT_SHARING_TRACK';
 
 /**
  * Action type to signal the start of the conference.
  * Action type to set the visibility of the prejoin page.
  */
 export const SET_PREJOIN_PAGE_VISIBILITY = 'SET_PREJOIN_PAGE_VISIBILITY';
-
-/**
- * Action type to mute/unmute the video while on prejoin page.
- */
-export const SET_PREJOIN_VIDEO_DISABLED = 'SET_PREJOIN_VIDEO_DISABLED';
-
-/**
- * Action type to mute/unmute the video while on prejoin page.
- */
-export const SET_PREJOIN_VIDEO_MUTED = 'SET_PREJOIN_VIDEO_MUTED';

react/features/prejoin/actions.js

 import { getRoomName } from '../base/conference';
 import { getDialOutStatusUrl, getDialOutUrl } from '../base/config/functions';
 import { createLocalTrack } from '../base/lib-jitsi-meet';
+import {
+    getLocalAudioTrack,
+    getLocalVideoTrack,
+    trackAdded,
+    replaceLocalTrack
+} from '../base/tracks';
 import { openURLInBrowser } from '../base/util';
 import { executeDialOutRequest, executeDialOutStatusRequest, getDialInfoPageURL } from '../invite/functions';
 import { showErrorNotification } from '../notifications';
 
 import {
-    ADD_PREJOIN_AUDIO_TRACK,
-    ADD_PREJOIN_CONTENT_SHARING_TRACK,
-    ADD_PREJOIN_VIDEO_TRACK,
     PREJOIN_START_CONFERENCE,
     SET_DEVICE_STATUS,
     SET_DIALOUT_COUNTRY,
     SET_DIALOUT_STATUS,
     SET_SKIP_PREJOIN,
     SET_JOIN_BY_PHONE_DIALOG_VISIBLITY,
-    SET_PREJOIN_AUDIO_DISABLED,
-    SET_PREJOIN_AUDIO_MUTED,
     SET_PREJOIN_DEVICE_ERRORS,
-    SET_PREJOIN_PAGE_VISIBILITY,
-    SET_PREJOIN_VIDEO_DISABLED,
-    SET_PREJOIN_VIDEO_MUTED
+    SET_PREJOIN_PAGE_VISIBILITY
 } from './actionTypes';
 import {
     getFullDialOutNumber,
-    getAudioTrack,
     getDialOutConferenceUrl,
     getDialOutCountry,
-    getVideoTrack,
     isJoinByPhoneDialogVisible
 } from './functions';
 import logger from './logger';
  */
 const STATUS_REQ_CAP = 45;
 
-/**
- * Action used to add an audio track to the store.
- *
- * @param {Object} value - The track to be added.
- * @returns {Object}
- */
-export function addPrejoinAudioTrack(value: Object) {
-    return {
-        type: ADD_PREJOIN_AUDIO_TRACK,
-        value
-    };
-}
-
-/**
- * Action used to add a video track to the store.
- *
- * @param {Object} value - The track to be added.
- * @returns {Object}
- */
-export function addPrejoinVideoTrack(value: Object) {
-    return {
-        type: ADD_PREJOIN_VIDEO_TRACK,
-        value
-    };
-}
-
-/**
- * Action used to add a content sharing track to the store.
- *
- * @param {Object} value - The track to be added.
- * @returns {Object}
- */
-export function addPrejoinContentSharingTrack(value: Object) {
-    return {
-        type: ADD_PREJOIN_CONTENT_SHARING_TRACK,
-        value
-    };
-}
-
 /**
  * Polls for status change after dial out.
  * Changes dialog message based on response, closes the dialog if there is an error,
  */
 export function initPrejoin(tracks: Object[], errors: Object) {
     return async function(dispatch: Function) {
-        const audioTrack = tracks.find(t => t.isAudioTrack());
-        const videoTrack = tracks.find(t => t.isVideoTrack());
-
         dispatch(setPrejoinDeviceErrors(errors));
 
-        if (audioTrack) {
-            dispatch(addPrejoinAudioTrack(audioTrack));
-        } else {
-            dispatch(setAudioDisabled());
-        }
 
-        if (videoTrack) {
-            if (videoTrack.videoType === 'desktop') {
-                dispatch(addPrejoinContentSharingTrack(videoTrack));
-                dispatch(setPrejoinVideoDisabled(true));
-            } else {
-                dispatch(addPrejoinVideoTrack(videoTrack));
-            }
-        } else {
-            dispatch(setPrejoinVideoDisabled(true));
-        }
+        tracks.forEach(track => dispatch(trackAdded(track)));
     };
 }
 
  */
 export function joinConferenceWithoutAudio() {
     return async function(dispatch: Function, getState: Function) {
-        const audioTrack = getAudioTrack(getState());
+        const tracks = getState()['features/base/tracks'];
+        const audioTrack = getLocalAudioTrack(tracks)?.jitsiTrack;
 
         if (audioTrack) {
-            await dispatch(replacePrejoinAudioTrack(null));
+            await dispatch(replaceLocalTrack(audioTrack, null));
         }
-        dispatch(setAudioDisabled());
         dispatch(joinConference());
     };
 }
     };
 }
 
-/**
- * Replaces the existing audio track with a new one.
- *
- * @param {Object} track - The new track.
- * @returns {Function}
- */
-export function replacePrejoinAudioTrack(track: Object) {
-    return async (dispatch: Function, getState: Function) => {
-        const oldTrack = getAudioTrack(getState());
-
-        oldTrack && await oldTrack.dispose();
-        dispatch(addPrejoinAudioTrack(track));
-    };
-}
-
 /**
  * Creates a new audio track based on a device id and replaces the current one.
  *
  * @returns {Function}
  */
 export function replaceAudioTrackById(deviceId: string) {
-    return async (dispatch: Function) => {
+    return async (dispatch: Function, getState: Function) => {
         try {
-            const track = await createLocalTrack('audio', deviceId);
+            const tracks = getState()['features/base/tracks'];
+            const newTrack = await createLocalTrack('audio', deviceId);
+            const oldTrack = getLocalAudioTrack(tracks)?.jitsiTrack;
 
-            dispatch(replacePrejoinAudioTrack(track));
+            dispatch(replaceLocalTrack(oldTrack, newTrack));
         } catch (err) {
             dispatch(setDeviceStatusWarning('prejoin.audioTrackError'));
             logger.log('Error replacing audio track', err);
     };
 }
 
-/**
- * Replaces the existing video track with a new one.
- *
- * @param {Object} track - The new track.
- * @returns {Function}
- */
-export function replacePrejoinVideoTrack(track: Object) {
-    return async (dispatch: Function, getState: Function) => {
-        const oldTrack = getVideoTrack(getState());
-
-        oldTrack && await oldTrack.dispose();
-        dispatch(addPrejoinVideoTrack(track));
-    };
-}
-
 /**
  * Creates a new video track based on a device id and replaces the current one.
  *
  * @returns {Function}
  */
 export function replaceVideoTrackById(deviceId: Object) {
-    return async (dispatch: Function) => {
+    return async (dispatch: Function, getState: Function) => {
         try {
-            const track = await createLocalTrack('video', deviceId);
+            const tracks = getState()['features/base/tracks'];
+            const newTrack = await createLocalTrack('video', deviceId);
+            const oldTrack = getLocalVideoTrack(tracks)?.jitsiTrack;
 
-            dispatch(replacePrejoinVideoTrack(track));
+            dispatch(replaceLocalTrack(oldTrack, newTrack));
         } catch (err) {
             dispatch(setDeviceStatusWarning('prejoin.videoTrackError'));
             logger.log('Error replacing video track', err);
     };
 }
 
-
-/**
- * Action used to mark audio muted.
- *
- * @param {boolean} value - True for muted.
- * @returns {Object}
- */
-export function setPrejoinAudioMuted(value: boolean) {
-    return {
-        type: SET_PREJOIN_AUDIO_MUTED,
-        value
-    };
-}
-
-/**
- * Action used to mark video disabled.
- *
- * @param {boolean} value - True for muted.
- * @returns {Object}
- */
-export function setPrejoinVideoDisabled(value: boolean) {
-    return {
-        type: SET_PREJOIN_VIDEO_DISABLED,
-        value
-    };
-}
-
-
-/**
- * Action used to mark video muted.
- *
- * @param {boolean} value - True for muted.
- * @returns {Object}
- */
-export function setPrejoinVideoMuted(value: boolean) {
-    return {
-        type: SET_PREJOIN_VIDEO_MUTED,
-        value
-    };
-}
-
-/**
- * Action used to mark audio as disabled.
- *
- * @returns {Object}
- */
-export function setAudioDisabled() {
-    return {
-        type: SET_PREJOIN_AUDIO_DISABLED
-    };
-}
-
 /**
  * Sets the device status as OK with the corresponding text.
  *

react/features/prejoin/components/Prejoin.js

 import { getRoomName } from '../../base/conference';
 import { translate } from '../../base/i18n';
 import { Icon, IconPhone, IconVolumeOff } from '../../base/icons';
+import { isVideoMutedByUser } from '../../base/media';
 import { ActionButton, InputField, PreMeetingScreen } from '../../base/premeeting';
 import { connect } from '../../base/redux';
 import { getDisplayName, updateSettings } from '../../base/settings';
+import { getLocalJitsiVideoTrack } from '../../base/tracks';
 import {
     joinConference as joinConferenceAction,
     joinConferenceWithoutAudio as joinConferenceWithoutAudioAction,
     setJoinByPhoneDialogVisiblity as setJoinByPhoneDialogVisiblityAction
 } from '../actions';
 import {
-    getActiveVideoTrack,
     isJoinByPhoneButtonVisible,
     isDeviceStatusVisible,
-    isJoinByPhoneDialogVisible,
-    isPrejoinVideoMuted
+    isJoinByPhoneDialogVisible
 } from '../functions';
 
 import JoinByPhoneDialog from './dialogs/JoinByPhoneDialog';
         roomName: getRoomName(state),
         showDialog: isJoinByPhoneDialogVisible(state),
         hasJoinByPhoneButton: isJoinByPhoneButtonVisible(state),
-        showCameraPreview: !isPrejoinVideoMuted(state),
-        videoTrack: getActiveVideoTrack(state)
+        showCameraPreview: !isVideoMutedByUser(state),
+        videoTrack: getLocalJitsiVideoTrack(state)
     };
 }
 

react/features/prejoin/functions.js

 
 import { getRoomName } from '../base/conference';
 import { getDialOutStatusUrl, getDialOutUrl } from '../base/config/functions';
-
-/**
- * Mutes or unmutes a track.
- *
- * @param {Object} track - The track to be configured.
- * @param {boolean} shouldMute - If it should mute or not.
- * @returns {Promise<void>}
- */
-function applyMuteOptionsToTrack(track, shouldMute) {
-    if (track.isMuted() === shouldMute) {
-        return;
-    }
-
-    if (shouldMute) {
-        return track.mute();
-    }
-
-    return track.unmute();
-}
+import { isAudioMuted, isVideoMutedByUser } from '../base/media';
 
 /**
  * Selector for the visibility of the 'join by phone' button.
  * @returns {boolean}
  */
 export function isDeviceStatusVisible(state: Object): boolean {
-    return !((isAudioDisabled(state) && isPrejoinVideoDisabled(state))
-        || (isPrejoinAudioMuted(state) && isPrejoinVideoMuted(state)));
-}
-
-/**
- * Selector for getting the active video/content sharing track.
- *
- * @param {Object} state - The state of the app.
- * @returns {boolean}
- */
-export function getActiveVideoTrack(state: Object): Object {
-    const track = getVideoTrack(state) || getContentSharingTrack(state);
-
-    if (track && track.isActive()) {
-        return track;
-    }
-
-    return null;
-}
-
-/**
- * Returns a list with all the prejoin tracks configured according to
- * user's preferences.
- *
- * @param {Object} state - The state of the app.
- * @returns {Promise<Object[]>}
- */
-export async function getAllPrejoinConfiguredTracks(state: Object): Promise<Object[]> {
-    const tracks = [];
-    const audioTrack = getAudioTrack(state);
-    const videoTrack = getVideoTrack(state);
-    const csTrack = getContentSharingTrack(state);
-
-    if (csTrack) {
-        tracks.push(csTrack);
-    } else if (videoTrack) {
-        await applyMuteOptionsToTrack(videoTrack, isPrejoinVideoMuted(state));
-        tracks.push(videoTrack);
-    }
-
-    if (audioTrack) {
-        await applyMuteOptionsToTrack(audioTrack, isPrejoinAudioMuted(state));
-        isPrejoinAudioMuted(state) && audioTrack.mute();
-        tracks.push(audioTrack);
-    }
-
-    return tracks;
-}
-
-/**
- * Selector for getting the prejoin audio track.
- *
- * @param {Object} state - The state of the app.
- * @returns {Object}
- */
-export function getAudioTrack(state: Object): Object {
-    return state['features/prejoin']?.audioTrack;
-}
-
-/**
- * Selector for getting the prejoin content sharing track.
- *
- * @param {Object} state - The state of the app.
- * @returns {Object}
- */
-export function getContentSharingTrack(state: Object): Object {
-    return state['features/prejoin']?.contentSharingTrack;
+    return !(isAudioMuted(state) && isVideoMutedByUser(state))
+    && !state['features/base/config'].startSilent;
 }
 
 /**
     return `+${country.dialCode}${dialOutNumber}`;
 }
 
-/**
- * Selector for getting the prejoin video track.
- *
- * @param {Object} state - The state of the app.
- * @returns {Object}
- */
-export function getVideoTrack(state: Object): Object {
-    return state['features/prejoin']?.videoTrack;
-}
-
-/**
- * Selector for getting the mute status of the prejoin audio.
- *
- * @param {Object} state - The state of the app.
- * @returns {boolean}
- */
-export function isPrejoinAudioMuted(state: Object): boolean {
-    return state['features/prejoin']?.audioMuted;
-}
-
-/**
- * Selector for getting the mute status of the prejoin video.
- *
- * @param {Object} state - The state of the app.
- * @returns {boolean}
- */
-export function isPrejoinVideoMuted(state: Object): boolean {
-    return state['features/prejoin']?.videoMuted;
-}
-
 /**
  * Selector for getting the error if any while creating streams.
  *
     return state['features/prejoin']?.rawError;
 }
 
-/**
- * Selector for getting state of the prejoin audio.
- *
- * @param {Object} state - The state of the app.
- * @returns {boolean}
- */
-export function isAudioDisabled(state: Object): Object {
-    return state['features/prejoin']?.audioDisabled;
-}
-
-/**
- * Selector for getting state of the prejoin video.
- *
- * @param {Object} state - The state of the app.
- * @returns {boolean}
- */
-export function isPrejoinVideoDisabled(state: Object): Object {
-    return state['features/prejoin']?.videoDisabled;
-}
-
 /**
  * Selector for getting the visiblity state for the 'JoinByPhoneDialog'.
  *

react/features/prejoin/middleware.js

 // @flow
 
-import { SET_AUDIO_MUTED, SET_VIDEO_MUTED } from '../base/media';
 import { MiddlewareRegistry } from '../base/redux';
 import { updateSettings } from '../base/settings';
 
-import {
-    ADD_PREJOIN_AUDIO_TRACK,
-    ADD_PREJOIN_VIDEO_TRACK,
-    PREJOIN_START_CONFERENCE
-} from './actionTypes';
-import { setPrejoinAudioMuted, setPrejoinVideoMuted } from './actions';
-import { getAllPrejoinConfiguredTracks } from './functions';
+import { PREJOIN_START_CONFERENCE } from './actionTypes';
 
 declare var APP: Object;
 
  */
 MiddlewareRegistry.register(store => next => async action => {
     switch (action.type) {
-    case ADD_PREJOIN_AUDIO_TRACK: {
-        const { value: audioTrack } = action;
-
-        if (audioTrack) {
-            store.dispatch(
-                    updateSettings({
-                        micDeviceId: audioTrack.getDeviceId()
-                    }),
-            );
-        }
-
-        break;
-    }
-
-    case ADD_PREJOIN_VIDEO_TRACK: {
-        const { value: videoTrack } = action;
-
-        if (videoTrack) {
-            store.dispatch(
-                    updateSettings({
-                        cameraDeviceId: videoTrack.getDeviceId()
-                    }),
-            );
-        }
-
-        break;
-    }
-
     case PREJOIN_START_CONFERENCE: {
         const { getState, dispatch } = store;
         const state = getState();
         const { userSelectedSkipPrejoin } = state['features/prejoin'];
+        const tracks = state['features/base/tracks'];
 
         userSelectedSkipPrejoin && dispatch(updateSettings({
             userSelectedSkipPrejoin
         }));
 
-
-        const tracks = await getAllPrejoinConfiguredTracks(state);
-
-        APP.conference.prejoinStart(tracks);
+        APP.conference.prejoinStart(tracks.map(t => t.jitsiTrack));
 
         break;
     }
-
-    case SET_AUDIO_MUTED: {
-        store.dispatch(setPrejoinAudioMuted(Boolean(action.muted)));
-        break;
     }
 
-    case SET_VIDEO_MUTED: {
-        store.dispatch(setPrejoinVideoMuted(Boolean(action.muted)));
-        break;
-    }
-
-    }
 
     return next(action);
 });

react/features/prejoin/reducer.js

 import { ReducerRegistry } from '../base/redux';
 
 import {
-    ADD_PREJOIN_AUDIO_TRACK,
-    ADD_PREJOIN_CONTENT_SHARING_TRACK,
-    ADD_PREJOIN_VIDEO_TRACK,
     SET_DEVICE_STATUS,
     SET_DIALOUT_NUMBER,
     SET_DIALOUT_COUNTRY,
     SET_DIALOUT_STATUS,
     SET_JOIN_BY_PHONE_DIALOG_VISIBLITY,
     SET_SKIP_PREJOIN,
-    SET_PREJOIN_AUDIO_DISABLED,
-    SET_PREJOIN_AUDIO_MUTED,
     SET_PREJOIN_DEVICE_ERRORS,
-    SET_PREJOIN_PAGE_VISIBILITY,
-    SET_PREJOIN_VIDEO_DISABLED,
-    SET_PREJOIN_VIDEO_MUTED
+    SET_PREJOIN_PAGE_VISIBILITY
 } from './actionTypes';
 
 const DEFAULT_STATE = {
-    audioDisabled: false,
-    audioMuted: false,
-    audioTrack: null,
-    contentSharingTrack: null,
     country: '',
     deviceStatusText: 'prejoin.configuringDevices',
     deviceStatusType: 'ok',
     rawError: '',
     showPrejoin: true,
     showJoinByPhoneDialog: false,
-    userSelectedSkipPrejoin: false,
-    videoTrack: null,
-    videoDisabled: false,
-    videoMuted: false
+    userSelectedSkipPrejoin: false
 };
 
 /**
 ReducerRegistry.register(
     'features/prejoin', (state = DEFAULT_STATE, action) => {
         switch (action.type) {
-        case ADD_PREJOIN_AUDIO_TRACK: {
-            return {
-                ...state,
-                audioTrack: action.value
-            };
-        }
-
-        case ADD_PREJOIN_CONTENT_SHARING_TRACK: {
-            return {
-                ...state,
-                contentSharingTrack: action.value
-            };
-        }
-
-        case ADD_PREJOIN_VIDEO_TRACK: {
-            return {
-                ...state,
-                videoTrack: action.value
-            };
-        }
 
         case SET_SKIP_PREJOIN: {
             return {
                 showPrejoin: action.value
             };
 
-        case SET_PREJOIN_VIDEO_DISABLED: {
-            return {
-                ...state,
-                videoDisabled: action.value
-            };
-        }
-
-        case SET_PREJOIN_VIDEO_MUTED:
-            return {
-                ...state,
-                videoMuted: action.value
-            };
-
-        case SET_PREJOIN_AUDIO_MUTED:
-            return {
-                ...state,
-                audioMuted: action.value
-            };
-
         case SET_PREJOIN_DEVICE_ERRORS: {
             const status = getStatusFromErrors(action.value);
 
             };
         }
 
-        case SET_PREJOIN_AUDIO_DISABLED: {
-            return {
-                ...state,
-                audioDisabled: true
-            };
-        }
-
         case SET_DIALOUT_NUMBER: {
             return {
                 ...state,

react/features/toolbox/components/AudioMuteButton.js

 import { AbstractAudioMuteButton } from '../../base/toolbox';
 import type { AbstractButtonProps } from '../../base/toolbox';
 import { isLocalTrackMuted } from '../../base/tracks';
-import {
-    isPrejoinAudioMuted,
-    isAudioDisabled,
-    isPrejoinPageVisible
-} from '../../prejoin/functions';
 import { muteLocal } from '../../remote-video-menu/actions';
 
 declare var APP: Object;
  * }}
  */
 function _mapStateToProps(state): Object {
-    let _audioMuted;
-    let _disabled;
-
-    if (isPrejoinPageVisible(state)) {
-        _audioMuted = isPrejoinAudioMuted(state);
-        _disabled = state['features/base/config'].startSilent;
-    } else {
-        const tracks = state['features/base/tracks'];
-
-        _audioMuted = isLocalTrackMuted(tracks, MEDIA_TYPE.AUDIO);
-        _disabled = state['features/base/config'].startSilent || isAudioDisabled(state);
-    }
+    const _audioMuted = isLocalTrackMuted(state['features/base/tracks'], MEDIA_TYPE.AUDIO);
+    const _disabled = state['features/base/config'].startSilent;
 
     return {
         _audioMuted,

react/features/toolbox/components/VideoMuteButton.js

     sendAnalytics
 } from '../../analytics';
 import { setAudioOnly } from '../../base/audio-only';
+import { hasAvailableDevices } from '../../base/devices';
 import { translate } from '../../base/i18n';
 import {
     VIDEO_MUTISM_AUTHORITY,
 import { AbstractVideoMuteButton } from '../../base/toolbox';
 import type { AbstractButtonProps } from '../../base/toolbox';
 import { getLocalVideoType, isLocalVideoTrackMuted } from '../../base/tracks';
-import {
-    isPrejoinPageVisible,
-    isPrejoinVideoDisabled,
-    isPrejoinVideoMuted
-} from '../../prejoin/functions';
 
 declare var APP: Object;
 
 function _mapStateToProps(state): Object {
     const { enabled: audioOnly } = state['features/base/audio-only'];
     const tracks = state['features/base/tracks'];
-    let _videoMuted = isLocalVideoTrackMuted(tracks);
-    let _videoDisabled = false;
-
-    if (isPrejoinPageVisible(state)) {
-        _videoMuted = isPrejoinVideoMuted(state);
-        _videoDisabled = isPrejoinVideoDisabled(state);
-    }
 
     return {
         _audioOnly: Boolean(audioOnly),
-        _videoDisabled,
+        _videoDisabled: !hasAvailableDevices(state, 'videoInput'),
         _videoMediaType: getLocalVideoType(tracks),
-        _videoMuted
+        _videoMuted: isLocalVideoTrackMuted(tracks)
     };
 }
 

react/features/toolbox/components/web/VideoSettingsButton.js

 import JitsiMeetJS from '../../../base/lib-jitsi-meet/_';
 import { connect } from '../../../base/redux';
 import { ToolboxButtonWithIcon } from '../../../base/toolbox';
+import { getLocalJitsiVideoTrack } from '../../../base/tracks';
 import { getMediaPermissionPromptVisibility } from '../../../overlay';
 import { toggleVideoSettings, VideoSettingsPopup } from '../../../settings';
 import { isVideoSettingsButtonDisabled } from '../../functions';
      */
     permissionPromptVisibility: boolean,
 
+    /**
+     * Whether there is a video track or not.
+     */
+    hasVideoTrack: boolean,
+
     /**
      * If the button should be disabled
      */
         };
     }
 
+    /**
+     * Returns true if the settings icon is disabled.
+     *
+     * @returns {boolean}
+     */
+    _isIconDisabled() {
+        const { hasVideoTrack, isDisabled } = this.props;
+
+        return (!this.state.hasPermissions || isDisabled) && !hasVideoTrack;
+    }
+
     /**
      * Updates device permissions.
      *
      * @inheritdoc
      */
     render() {
-        const { isDisabled, onVideoOptionsClick, visible } = this.props;
-        const iconDisabled = !this.state.hasPermissions || isDisabled;
+        const { onVideoOptionsClick, visible } = this.props;
 
         return visible ? (
             <VideoSettingsPopup>
                 <ToolboxButtonWithIcon
                     icon = { IconArrowDown }
-                    iconDisabled = { iconDisabled }
+                    iconDisabled = { this._isIconDisabled() }
                     onIconClick = { onVideoOptionsClick }>
                     <VideoMuteButton />
                 </ToolboxButtonWithIcon>
  */
 function mapStateToProps(state) {
     return {
+        hasVideoTrack: Boolean(getLocalJitsiVideoTrack(state)),
         isDisabled: isVideoSettingsButtonDisabled(state),
         permissionPromptVisibility: getMediaPermissionPromptVisibility(state)
     };

react/features/toolbox/functions.web.js

 // @flow
 
 import { hasAvailableDevices } from '../base/devices';
-import {
-    isAudioDisabled,
-    isPrejoinPageVisible,
-    isPrejoinVideoDisabled
-} from '../prejoin';
 
 declare var interfaceConfig: Object;
 
  * @returns {boolean}
  */
 export function isAudioSettingsButtonDisabled(state: Object) {
-    const devicesMissing = !hasAvailableDevices(state, 'audioInput')
-          && !hasAvailableDevices(state, 'audioOutput');
-
-    return isPrejoinPageVisible(state)
-        ? devicesMissing || isAudioDisabled(state)
-        : devicesMissing;
+    return (!hasAvailableDevices(state, 'audioInput')
+          && !hasAvailableDevices(state, 'audioOutput'))
+          || state['features/base/config'].startSilent;
 }
 
 /**
  * @returns {boolean}
  */
 export function isVideoSettingsButtonDisabled(state: Object) {
-    const devicesMissing = !hasAvailableDevices(state, 'videoInput');
-
-    return isPrejoinPageVisible(state)
-        ? devicesMissing || isPrejoinVideoDisabled(state)
-        : devicesMissing;
+    return !hasAvailableDevices(state, 'videoInput');
 }