refactor(multi-stream) refactor virtual screenshare creation and support plan-b clients (#11445)

* fix(multi-stream) update selector to find ss track by videoType or mediaType

* ref(multi-stream) move fake ss creation logic and support video type changed

* refactor(multi-stream) decouple sending and receiving multiple screenshare streams

* fix(multi-stream) fix receiver constraints with signaling and without multi-stream

* fix(mutli-stream) ensure plan b original SS thumbnail displays avatar

* fix(multi-stream) show fake SS for plan b sender

* refactor(multi-stream) poc for moving SS creation to state listener

* remove reference to fake SS creation

* fix lint errors

* rename to virtual screenshare participants

* fix minor bugs

* rename participant subscriber to specify web support only

conference.js

 } from './react/features/base/conference';
 import {
     getReplaceParticipant,
-    getMultipleVideoSupportFeatureFlag,
-    getSourceNameSignalingFeatureFlag
+    getMultipleVideoSendingSupportFeatureFlag
 } from './react/features/base/config/functions';
 import {
     checkAndNotifyForNewDevice,
     dominantSpeakerChanged,
     getLocalParticipant,
     getNormalizedDisplayName,
-    getScreenshareParticipantByOwnerId,
+    getVirtualScreenshareParticipantByOwnerId,
     localParticipantAudioLevelChanged,
     localParticipantConnectionStatusChanged,
     localParticipantRoleChanged,
 
                 // In the multi-stream mode, add the track to the conference if there is no existing track, replace it
                 // otherwise.
-                if (getMultipleVideoSupportFeatureFlag(state)) {
+                if (getMultipleVideoSendingSupportFeatureFlag(state)) {
                     const trackAction = oldTrack
                         ? replaceLocalTrack(oldTrack, newTrack, room)
                         : addLocalTrack(newTrack);
                     name: formattedDisplayName
                 }));
 
-                if (getSourceNameSignalingFeatureFlag(state)) {
-                    const screenshareParticipantId = getScreenshareParticipantByOwnerId(state, id)?.id;
+                const virtualScreenshareParticipantId = getVirtualScreenshareParticipantByOwnerId(state, id)?.id;
 
-                    if (screenshareParticipantId) {
-                        APP.store.dispatch(
-                            screenshareParticipantDisplayNameChanged(screenshareParticipantId, formattedDisplayName)
-                        );
-                    }
+                if (virtualScreenshareParticipantId) {
+                    APP.store.dispatch(
+                        screenshareParticipantDisplayNameChanged(virtualScreenshareParticipantId, formattedDisplayName)
+                    );
                 }
 
                 APP.API.notifyDisplayNameChanged(id, {

modules/UI/videolayout/LargeVideoManager.js

 import { createScreenSharingIssueEvent, sendAnalytics } from '../../../react/features/analytics';
 import { Avatar } from '../../../react/features/base/avatar';
 import theme from '../../../react/features/base/components/themes/participantsPaneTheme.json';
-import { getSourceNameSignalingFeatureFlag } from '../../../react/features/base/config';
+import {
+    getMultipleVideoSupportFeatureFlag,
+    getSourceNameSignalingFeatureFlag
+} from '../../../react/features/base/config';
 import { i18next } from '../../../react/features/base/i18n';
 import { JitsiTrackEvents } from '../../../react/features/base/lib-jitsi-meet';
 import { VIDEO_TYPE } from '../../../react/features/base/media';
             }
 
             const isAudioOnly = APP.conference.isAudioOnly();
+
+            // Multi-stream is not supported on plan-b endpoints even if its is enabled via config.js. A virtual
+            // screenshare tile is still created when a remote endpoint starts screenshare to keep the behavior
+            // consistent and an avatar is displayed on the original participant thumbnail as long as screenshare is in
+            // progress.
+            const legacyScreenshare = getMultipleVideoSupportFeatureFlag(state)
+                                        && videoType === VIDEO_TYPE.DESKTOP
+                                        && !participant.isVirtualScreenshareParticipant;
+
             const showAvatar
                 = isVideoContainer
-                    && ((isAudioOnly && videoType !== VIDEO_TYPE.DESKTOP) || !isVideoRenderable);
+                    && ((isAudioOnly && videoType !== VIDEO_TYPE.DESKTOP) || !isVideoRenderable || legacyScreenshare);
 
             let promise;
 

modules/UI/videolayout/VideoLayout.js

 } from '../../../react/features/base/participants';
 import {
     getTrackByMediaTypeAndParticipant,
-    getFakeScreenshareParticipantTrack
+    getVirtualScreenshareParticipantTrack
 } from '../../../react/features/base/tracks';
 
 import LargeVideoManager from './LargeVideoManager';
             return VIDEO_TYPE.CAMERA;
         }
 
-        if (getSourceNameSignalingFeatureFlag(state) && participant?.isFakeScreenShareParticipant) {
+        if (getSourceNameSignalingFeatureFlag(state) && participant?.isVirtualScreenshareParticipant) {
             return VIDEO_TYPE.DESKTOP;
         }
 
 
         let videoTrack;
 
-        if (getSourceNameSignalingFeatureFlag(state) && participant?.isFakeScreenShareParticipant) {
-            videoTrack = getFakeScreenshareParticipantTrack(tracks, id);
+        if (getSourceNameSignalingFeatureFlag(state) && participant?.isVirtualScreenshareParticipant) {
+            videoTrack = getVirtualScreenshareParticipantTrack(tracks, id);
         } else {
             videoTrack = getTrackByMediaTypeAndParticipant(tracks, MEDIA_TYPE.VIDEO, id);
         }

react/features/base/conference/middleware.web.js

 import { setScreenAudioShareState, setScreenshareAudioTrack } from '../../screen-share';
 import { AudioMixerEffect } from '../../stream-effects/audio-mixer/AudioMixerEffect';
 import { setAudioOnly } from '../audio-only';
-import { getMultipleVideoSupportFeatureFlag } from '../config/functions.any';
+import { getMultipleVideoSendingSupportFeatureFlag } from '../config/functions.any';
 import { JitsiConferenceErrors, JitsiTrackErrors } from '../lib-jitsi-meet';
 import { MEDIA_TYPE, setScreenshareMuted, VIDEO_TYPE } from '../media';
 import { MiddlewareRegistry } from '../redux';
         break;
     }
     case TOGGLE_SCREENSHARING: {
-        getMultipleVideoSupportFeatureFlag(getState()) && _toggleScreenSharing(action, store);
+        getMultipleVideoSendingSupportFeatureFlag(getState()) && _toggleScreenSharing(action, store);
 
         break;
     }

react/features/base/config/functions.any.js

 }
 
 /**
- * Selector used to get the sendMultipleVideoStreams feature flag.
+ * Selector for determining if receiving multiple stream support is enabled.
  *
  * @param {Object} state - The global state.
  * @returns {boolean}
  */
 export function getMultipleVideoSupportFeatureFlag(state: Object) {
     return getFeatureFlag(state, FEATURE_FLAGS.MULTIPLE_VIDEO_STREAMS_SUPPORT)
-        && getSourceNameSignalingFeatureFlag(state)
-        && isUnifiedPlanEnabled(state);
+        && getSourceNameSignalingFeatureFlag(state);
+}
+
+/**
+ * Selector for determining if sending multiple stream support is enabled.
+ *
+ * @param {Object} state - The global state.
+ * @returns {boolean}
+ */
+export function getMultipleVideoSendingSupportFeatureFlag(state: Object) {
+    return getMultipleVideoSupportFeatureFlag(state) && isUnifiedPlanEnabled(state);
 }
 
 /**

react/features/base/lastn/middleware.js

 import { SELECT_LARGE_VIDEO_PARTICIPANT } from '../../large-video/actionTypes';
 import { APP_STATE_CHANGED } from '../../mobile/background/actionTypes';
 import {
-    FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
     SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
-    SET_TILE_VIEW
+    SET_TILE_VIEW,
+    VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED
 } from '../../video-layout/actionTypes';
 import { SET_AUDIO_ONLY } from '../audio-only/actionTypes';
 import { CONFERENCE_JOINED } from '../conference/actionTypes';
     switch (action.type) {
     case APP_STATE_CHANGED:
     case CONFERENCE_JOINED:
-    case FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED:
     case PARTICIPANT_JOINED:
     case PARTICIPANT_KICKED:
     case PARTICIPANT_LEFT:
     case SET_AUDIO_ONLY:
     case SET_FILMSTRIP_ENABLED:
     case SET_TILE_VIEW:
+    case VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED:
         _updateLastN(store);
         break;
     }

react/features/base/media/middleware.js

 import { isScreenMediaShared } from '../../screen-share/functions';
 import { SET_AUDIO_ONLY, setAudioOnly } from '../audio-only';
 import { isRoomValid, SET_ROOM } from '../conference';
-import { getMultipleVideoSupportFeatureFlag } from '../config';
+import { getMultipleVideoSendingSupportFeatureFlag } from '../config';
 import { getLocalParticipant } from '../participants';
 import { MiddlewareRegistry } from '../redux';
 import { getPropertyValue } from '../settings';
 
     // Make sure we mute both the desktop and video tracks.
     dispatch(setVideoMuted(audioOnly, MEDIA_TYPE.VIDEO, VIDEO_MUTISM_AUTHORITY.AUDIO_ONLY, ensureVideoTrack));
-    if (getMultipleVideoSupportFeatureFlag(state)) {
+    if (getMultipleVideoSendingSupportFeatureFlag(state)) {
         dispatch(setScreenshareMuted(audioOnly, MEDIA_TYPE.SCREENSHARE, SCREENSHARE_MUTISM_AUTHORITY.AUDIO_ONLY));
     } else if (navigator.product !== 'ReactNative') {
         dispatch(setVideoMuted(audioOnly, MEDIA_TYPE.PRESENTER, VIDEO_MUTISM_AUTHORITY.AUDIO_ONLY, ensureVideoTrack));

react/features/base/participants/actions.js

 } from './constants';
 import {
     getLocalParticipant,
+    getVirtualScreenshareParticipantOwnerId,
     getNormalizedDisplayName,
     getParticipantDisplayName,
     getParticipantById
     };
 }
 
+/**
+ * Action to create a virtual screenshare participant.
+ *
+ * @param {(string)} sourceName - JitsiTrack instance.
+ * @param {(boolean)} local - JitsiTrack instance.
+ * @returns {Function}
+ */
+export function createVirtualScreenshareParticipant(sourceName, local) {
+    return (dispatch, getState) => {
+        const state = getState();
+        const ownerId = getVirtualScreenshareParticipantOwnerId(sourceName);
+        const owner = getParticipantById(state, ownerId);
+        const ownerName = owner.name;
+
+        if (!ownerName) {
+            logger.error(`Failed to create a screenshare participant for sourceName: ${sourceName}`);
+
+            return;
+        }
+
+        dispatch(participantJoined({
+            conference: state['features/base/conference'].conference,
+            id: sourceName,
+            isVirtualScreenshareParticipant: true,
+            isLocalScreenShare: local,
+            name: ownerName
+        }));
+    };
+}
+
 /**
  * Action to signal that a participant had been kicked.
  *

react/features/base/participants/functions.js

 import { i18next } from '../../base/i18n';
 import { isStageFilmstripAvailable } from '../../filmstrip/functions';
 import { GRAVATAR_BASE_URL, isCORSAvatarURL } from '../avatar';
-import { getSourceNameSignalingFeatureFlag } from '../config';
+import { getMultipleVideoSupportFeatureFlag, getSourceNameSignalingFeatureFlag } from '../config';
 import { JitsiParticipantConnectionStatus } from '../lib-jitsi-meet';
 import { MEDIA_TYPE, shouldRenderVideoTrack } from '../media';
 import { toState } from '../redux';
-import { getTrackByMediaTypeAndParticipant } from '../tracks';
+import { getScreenShareTrack, getTrackByMediaTypeAndParticipant } from '../tracks';
 import { createDeferred } from '../util';
 
-import {
-    JIGASI_PARTICIPANT_ICON,
-    MAX_DISPLAY_NAME_LENGTH,
-    PARTICIPANT_ROLE
-} from './constants';
+import { JIGASI_PARTICIPANT_ICON, MAX_DISPLAY_NAME_LENGTH, PARTICIPANT_ROLE } from './constants';
 import { preloadImage } from './preloadImage';
 
-
 /**
  * Temp structures for avatar urls to be checked/preloaded.
  */
  * @param {string} id - The owner ID of the screenshare participant to retrieve.
  * @returns {(Participant|undefined)}
  */
-export function getScreenshareParticipantByOwnerId(stateful: Object | Function, id: string) {
-    const track = getTrackByMediaTypeAndParticipant(
-        toState(stateful)['features/base/tracks'], MEDIA_TYPE.SCREENSHARE, id
-    );
+export function getVirtualScreenshareParticipantByOwnerId(stateful: Object | Function, id: string) {
+    const state = toState(stateful);
+
+    if (getMultipleVideoSupportFeatureFlag(state)) {
+        const track = getScreenShareTrack(state['features/base/tracks'], id);
+
+        return getParticipantById(stateful, track?.jitsiTrack.getSourceName());
+    }
 
-    return getParticipantById(stateful, track?.jitsiTrack.getSourceName());
+    return;
 }
 
 /**
         local,
         remote,
         fakeParticipants,
-        sortedRemoteFakeScreenShareParticipants
+        sortedRemoteVirtualScreenshareParticipants
     } = state['features/base/participants'];
 
     if (getSourceNameSignalingFeatureFlag(state)) {
-        return remote.size - fakeParticipants.size - sortedRemoteFakeScreenShareParticipants.size + (local ? 1 : 0);
+        return remote.size - fakeParticipants.size - sortedRemoteVirtualScreenshareParticipants.size + (local ? 1 : 0);
     }
 
     return remote.size - fakeParticipants.size + (local ? 1 : 0);
 }
 
 /**
- * Returns participant ID of the owner of a fake screenshare participant.
+ * Returns participant ID of the owner of a virtual screenshare participant.
  *
- * @param {string} id - The ID of the fake screenshare participant.
+ * @param {string} id - The ID of the virtual screenshare participant.
  * @private
  * @returns {(string|undefined)}
  */
-export function getFakeScreenShareParticipantOwnerId(id: string) {
+export function getVirtualScreenshareParticipantOwnerId(id: string) {
     return id.split('-')[0];
 }
 
     const state = toState(stateful)['features/base/participants'];
 
     if (getSourceNameSignalingFeatureFlag(state)) {
-        return state.remote.size - state.sortedRemoteFakeScreenShareParticipants.size;
+        return state.remote.size - state.sortedRemoteVirtualScreenshareParticipants.size;
     }
 
     return state.remote.size;
     } = toState(stateful)['features/base/config'];
 
     if (participant) {
-        if (participant.isFakeScreenShareParticipant) {
+        if (participant.isVirtualScreenshareParticipant) {
             return getScreenshareParticipantDisplayName(stateful, id);
         }
 
  * @returns {string}
  */
 export function getScreenshareParticipantDisplayName(stateful: Object | Function, id: string) {
-    const owner = getParticipantById(stateful, getFakeScreenShareParticipantOwnerId(id));
+    const owner = getParticipantById(stateful, getVirtualScreenshareParticipantOwnerId(id));
     const name = owner.name;
 
     return i18next.t('screenshareDisplayName', { name });

react/features/base/participants/middleware.js

     isLocalParticipantModerator
 } from './functions';
 import { PARTICIPANT_JOINED_FILE, PARTICIPANT_LEFT_FILE } from './sounds';
+import './subscriber';
 
 declare var APP: Object;
 
     }
 
     case PARTICIPANT_JOINED: {
-        const { isFakeScreenShareParticipant } = action.participant;
+        const { isVirtualScreenshareParticipant } = action.participant;
 
-        // Do not play sounds when a fake participant tile is created for screenshare.
-        !isFakeScreenShareParticipant && _maybePlaySounds(store, action);
+        // Do not play sounds when a virtual participant tile is created for screenshare.
+        !isVirtualScreenshareParticipant && _maybePlaySounds(store, action);
 
         return _participantJoinedOrUpdated(store, next, action);
     }
 
     case PARTICIPANT_LEFT: {
-        const { isFakeScreenShareParticipant } = action.participant;
+        const { isVirtualScreenshareParticipant } = action.participant;
 
         // Do not play sounds when a tile for screenshare is removed.
-        !isFakeScreenShareParticipant && _maybePlaySounds(store, action);
+        !isVirtualScreenshareParticipant && _maybePlaySounds(store, action);
 
         break;
     }

react/features/base/participants/reducer.js

     pinnedParticipant: undefined,
     raisedHandsQueue: [],
     remote: new Map(),
-    sortedRemoteFakeScreenShareParticipants: new Map(),
+    sortedRemoteVirtualScreenshareParticipants: new Map(),
     sortedRemoteParticipants: new Map(),
     sortedRemoteScreenshares: new Map(),
     speakersList: new Map()
     case SCREENSHARE_PARTICIPANT_NAME_CHANGED: {
         const { id, name } = action;
 
-        if (state.sortedRemoteFakeScreenShareParticipants.has(id)) {
-            state.sortedRemoteFakeScreenShareParticipants.delete(id);
+        if (state.sortedRemoteVirtualScreenshareParticipants.has(id)) {
+            state.sortedRemoteVirtualScreenshareParticipants.delete(id);
 
-            const sortedRemoteFakeScreenShareParticipants = [ ...state.sortedRemoteFakeScreenShareParticipants ];
+            const sortedRemoteVirtualScreenshareParticipants = [ ...state.sortedRemoteVirtualScreenshareParticipants ];
 
-            sortedRemoteFakeScreenShareParticipants.push([ id, name ]);
-            sortedRemoteFakeScreenShareParticipants.sort((a, b) => a[1].localeCompare(b[1]));
+            sortedRemoteVirtualScreenshareParticipants.push([ id, name ]);
+            sortedRemoteVirtualScreenshareParticipants.sort((a, b) => a[1].localeCompare(b[1]));
 
-            state.sortedRemoteFakeScreenShareParticipants = new Map(sortedRemoteFakeScreenShareParticipants);
+            state.sortedRemoteVirtualScreenshareParticipants = new Map(sortedRemoteVirtualScreenshareParticipants);
         }
 
         return { ...state };
 
     case PARTICIPANT_JOINED: {
         const participant = _participantJoined(action);
-        const { id, isFakeParticipant, isFakeScreenShareParticipant, isLocalScreenShare, name, pinned } = participant;
+        const {
+            id,
+            isFakeParticipant,
+            isLocalScreenShare,
+            isVirtualScreenshareParticipant,
+            name,
+            pinned
+        } = participant;
         const { pinnedParticipant, dominantSpeaker } = state;
 
         if (pinned) {
         // The sort order of participants is preserved since Map remembers the original insertion order of the keys.
         state.sortedRemoteParticipants = new Map(sortedRemoteParticipants);
 
-        if (isFakeScreenShareParticipant) {
-            const sortedRemoteFakeScreenShareParticipants = [ ...state.sortedRemoteFakeScreenShareParticipants ];
+        if (isVirtualScreenshareParticipant) {
+            const sortedRemoteVirtualScreenshareParticipants = [ ...state.sortedRemoteVirtualScreenshareParticipants ];
 
-            sortedRemoteFakeScreenShareParticipants.push([ id, name ]);
-            sortedRemoteFakeScreenShareParticipants.sort((a, b) => a[1].localeCompare(b[1]));
+            sortedRemoteVirtualScreenshareParticipants.push([ id, name ]);
+            sortedRemoteVirtualScreenshareParticipants.sort((a, b) => a[1].localeCompare(b[1]));
 
-            state.sortedRemoteFakeScreenShareParticipants = new Map(sortedRemoteFakeScreenShareParticipants);
+            state.sortedRemoteVirtualScreenshareParticipants = new Map(sortedRemoteVirtualScreenshareParticipants);
         }
         if (isFakeParticipant) {
             state.fakeParticipants.set(id, participant);
         const { conference, id } = action.participant;
         const {
             fakeParticipants,
-            sortedRemoteFakeScreenShareParticipants,
+            sortedRemoteVirtualScreenshareParticipants,
             remote,
             local,
             localScreenShare,
             fakeParticipants.delete(id);
         }
 
-        if (sortedRemoteFakeScreenShareParticipants.has(id)) {
-            sortedRemoteFakeScreenShareParticipants.delete(id);
-            state.sortedRemoteFakeScreenShareParticipants = new Map(sortedRemoteFakeScreenShareParticipants);
+        if (sortedRemoteVirtualScreenshareParticipants.has(id)) {
+            sortedRemoteVirtualScreenshareParticipants.delete(id);
+            state.sortedRemoteVirtualScreenshareParticipants = new Map(sortedRemoteVirtualScreenshareParticipants);
         }
 
         return { ...state };
         dominantSpeaker,
         email,
         isFakeParticipant,
-        isFakeScreenShareParticipant,
+        isVirtualScreenshareParticipant,
         isLocalScreenShare,
         isReplacing,
         isJigasi,
         email,
         id,
         isFakeParticipant,
-        isFakeScreenShareParticipant,
+        isVirtualScreenshareParticipant,
         isLocalScreenShare,
         isReplacing,
         isJigasi,

react/features/base/participants/subscriber.web.js

+// @flow
+
+import _ from 'lodash';
+
+import { getCurrentConference } from '../conference';
+import { getMultipleVideoSupportFeatureFlag } from '../config';
+import { StateListenerRegistry } from '../redux';
+
+import { createVirtualScreenshareParticipant, participantLeft } from './actions';
+
+StateListenerRegistry.register(
+    /* selector */ state => state['features/base/tracks'],
+    /* listener */(tracks, store) => _updateScreenshareParticipants(store)
+);
+
+/**
+ * Handles creating and removing virtual screenshare participants.
+ *
+ * @param {*} store - The redux store.
+ * @returns {void}
+ */
+function _updateScreenshareParticipants({ getState, dispatch }) {
+    const state = getState();
+
+    if (!getMultipleVideoSupportFeatureFlag(state)) {
+        return;
+    }
+
+    const conference = getCurrentConference(state);
+    const tracks = state['features/base/tracks'];
+    const { sortedRemoteVirtualScreenshareParticipants, localScreenShare } = state['features/base/participants'];
+    const previousScreenshareSourceNames = [ ...sortedRemoteVirtualScreenshareParticipants.keys() ];
+
+    let newLocalSceenshareSourceName;
+
+    const currentScreenshareSourceNames = tracks.reduce((acc, track) => {
+        if (track.videoType === 'desktop' && !track.jitsiTrack.isMuted()) {
+            const sourceName = track.jitsiTrack.getSourceName();
+
+            if (track.local) {
+                newLocalSceenshareSourceName = sourceName;
+            } else {
+                acc.push(sourceName);
+            }
+        }
+
+        return acc;
+    }, []);
+
+    if (!localScreenShare && newLocalSceenshareSourceName) {
+        dispatch(createVirtualScreenshareParticipant(newLocalSceenshareSourceName, true));
+    }
+
+    if (localScreenShare && !newLocalSceenshareSourceName) {
+        dispatch(participantLeft(localScreenShare.id, conference));
+    }
+
+    const removedScreenshareSourceNames = _.difference(previousScreenshareSourceNames, currentScreenshareSourceNames);
+    const addedScreenshareSourceNames = _.difference(currentScreenshareSourceNames, previousScreenshareSourceNames);
+
+    if (removedScreenshareSourceNames.length) {
+        removedScreenshareSourceNames.forEach(id => dispatch(participantLeft(id, conference)));
+    }
+
+    if (addedScreenshareSourceNames.length) {
+        addedScreenshareSourceNames.forEach(id => dispatch(createVirtualScreenshareParticipant(id, false)));
+
+    }
+}

react/features/base/tracks/actionTypes.ts

  */
 export const TRACK_UPDATED = 'TRACK_UPDATED';
 
-/**
- * The type of redux action dispatched when a screenshare track's muted property were updated.
- *
- * {
- *     type: SCREENSHARE_TRACK_MUTED_UPDATED,
- *     track: Track,
- *     muted: Boolean
- *  
- * }
- */
- export const SCREENSHARE_TRACK_MUTED_UPDATED = 'SCREENSHARE_TRACK_MUTED_UPDATED';
-
 /**
  * The type of redux action dispatched when a local track starts being created
  * via a WebRTC {@code getUserMedia} call. The action's payload includes an

react/features/base/tracks/actions.js

 } from '../../analytics';
 import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification, showNotification } from '../../notifications';
 import { getCurrentConference } from '../conference';
-import { getMultipleVideoSupportFeatureFlag, getSourceNameSignalingFeatureFlag } from '../config';
+import { getMultipleVideoSendingSupportFeatureFlag } from '../config';
 import { JitsiTrackErrors, JitsiTrackEvents } from '../lib-jitsi-meet';
 import { createLocalTrack } from '../lib-jitsi-meet/functions';
 import {
 import { updateSettings } from '../settings';
 
 import {
-    SCREENSHARE_TRACK_MUTED_UPDATED,
     SET_NO_SRC_DATA_NOTIFICATION_UID,
     TOGGLE_SCREENSHARING,
     TRACK_ADDED,
         }
 
         const setMuted = newTrack.isVideoTrack()
-            ? getMultipleVideoSupportFeatureFlag(getState())
+            ? getMultipleVideoSendingSupportFeatureFlag(getState())
             && newTrack.getVideoType() === VIDEO_TYPE.DESKTOP
                 ? setScreenshareMuted
                 : setVideoMuted
             // 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()
-                ? getMultipleVideoSupportFeatureFlag(getState()) && newTrack.getVideoType() === VIDEO_TYPE.DESKTOP
+                ? getMultipleVideoSendingSupportFeatureFlag(getState())
+                    && newTrack.getVideoType() === VIDEO_TYPE.DESKTOP
                     ? setScreenshareMuted
                     : setVideoMuted
                 : setAudioMuted;
     return async (dispatch, getState) => {
         track.on(
             JitsiTrackEvents.TRACK_MUTE_CHANGED,
-        () => {
-            if (getSourceNameSignalingFeatureFlag(getState()) && track.getVideoType() === VIDEO_TYPE.DESKTOP) {
-                dispatch(screenshareTrackMutedChanged(track));
-            }
-            dispatch(trackMutedChanged(track));
-        });
+            () => dispatch(trackMutedChanged(track)));
         track.on(
             JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED,
             type => dispatch(trackVideoTypeChanged(track, type)));
 
         // participantId
         const local = track.isLocal();
-        const mediaType = getMultipleVideoSupportFeatureFlag(getState()) && track.getVideoType() === VIDEO_TYPE.DESKTOP
+        const mediaType = getMultipleVideoSendingSupportFeatureFlag(getState())
+            && track.getVideoType() === VIDEO_TYPE.DESKTOP
             ? MEDIA_TYPE.SCREENSHARE
             : track.getType();
         let isReceivingData, noDataFromSourceNotificationInfo, participantId;
     };
 }
 
-/**
- * Create an action for when a screenshare track's muted state has been signaled to be changed.
- *
- * @param {(JitsiLocalTrack|JitsiRemoteTrack)} track - JitsiTrack instance.
- * @returns {{
- *     type: TRACK_UPDATED,
- *     track: Track,
- *     muted: boolean
- * }}
- */
-export function screenshareTrackMutedChanged(track) {
-    return {
-        type: SCREENSHARE_TRACK_MUTED_UPDATED,
-        track: { jitsiTrack: track },
-        muted: track.isMuted()
-    };
-}
-
 /**
  * Create an action for when a track's muted state change action has failed. This could happen because of
  * {@code getUserMedia} errors during unmute or replace track errors at the peerconnection level.

react/features/base/tracks/functions.js

 /* global APP */
 
-import { getMultipleVideoSupportFeatureFlag } from '../config/functions.any';
+import {
+    getMultipleVideoSendingSupportFeatureFlag,
+    getMultipleVideoSupportFeatureFlag
+} from '../config/functions.any';
 import { isMobileBrowser } from '../environment/utils';
 import JitsiMeetJS, { JitsiTrackErrors, browser } from '../lib-jitsi-meet';
 import { MEDIA_TYPE, VIDEO_TYPE, setAudioMuted } from '../media';
-import { getFakeScreenShareParticipantOwnerId } from '../participants';
+import { getVirtualScreenshareParticipantOwnerId } from '../participants';
 import { toState } from '../redux';
 import {
     getUserSelectedCameraDeviceId,
         return;
     }
 
-    let participantId;
-    let mediaType;
-
-    if (participant?.isFakeScreenShareParticipant) {
-        participantId = getFakeScreenShareParticipantOwnerId(participant.id);
-        mediaType = MEDIA_TYPE.SCREENSHARE;
-    } else {
-        participantId = participant.id;
-        mediaType = MEDIA_TYPE.VIDEO;
+    if (participant?.isVirtualScreenshareParticipant) {
+        return getVirtualScreenshareParticipantTrack(tracks, participant.id);
     }
 
-    return getTrackByMediaTypeAndParticipant(tracks, mediaType, participantId);
+    return getTrackByMediaTypeAndParticipant(tracks, MEDIA_TYPE.VIDEO, participant.id);
 }
 
 /**
 }
 
 /**
- * Returns track of given fakeScreenshareParticipantId.
+ * Returns screenshare track of given virtualScreenshareParticipantId.
  *
  * @param {Track[]} tracks - List of all tracks.
- * @param {string} fakeScreenshareParticipantId - Fake Screenshare Participant ID.
+ * @param {string} virtualScreenshareParticipantId - Virtual Screenshare Participant ID.
  * @returns {(Track|undefined)}
  */
-export function getFakeScreenshareParticipantTrack(tracks, fakeScreenshareParticipantId) {
-    const participantId = getFakeScreenShareParticipantOwnerId(fakeScreenshareParticipantId);
+export function getVirtualScreenshareParticipantTrack(tracks, virtualScreenshareParticipantId) {
+    const ownderId = getVirtualScreenshareParticipantOwnerId(virtualScreenshareParticipantId);
 
-    return getTrackByMediaTypeAndParticipant(tracks, MEDIA_TYPE.SCREENSHARE, participantId);
+    return getScreenShareTrack(tracks, ownderId);
+}
+
+/**
+ * Returns track source names of given screen share participant ids.
+ *
+ * @param {Object} state - The entire redux state.
+ * @param {string[]} screenShareParticipantIds - Participant ID.
+ * @returns {(string[])}
+ */
+export function getRemoteScreenSharesSourceNames(state, screenShareParticipantIds = []) {
+    const tracks = state['features/base/tracks'];
+
+    return getMultipleVideoSupportFeatureFlag(state)
+        ? screenShareParticipantIds
+        : screenShareParticipantIds.reduce((acc, id) => {
+            const sourceName = getScreenShareTrack(tracks, id)?.jitsiTrack.getSourceName();
+
+            if (sourceName) {
+                acc.push(sourceName);
+            }
+
+            return acc;
+        }, []);
+}
+
+/**
+ * Returns screenshare track of given owner ID.
+ *
+ * @param {Track[]} tracks - List of all tracks.
+ * @param {string} ownerId - Screenshare track owner ID.
+ * @returns {(Track|undefined)}
+ */
+export function getScreenShareTrack(tracks, ownerId) {
+    return tracks.find(
+        t => Boolean(t.jitsiTrack)
+        && t.participantId === ownerId
+        && (t.mediaType === MEDIA_TYPE.SCREENSHARE || t.videoType === VIDEO_TYPE.DESKTOP)
+    );
 }
 
 /**
     // browser's 'Stop sharing' button, the local stream is stopped before the inactive stream handler is fired.
     // We still need to proceed here and remove the track from the peerconnection.
     if (track.isMuted() === muted
-        && !(track.getVideoType() === VIDEO_TYPE.DESKTOP && getMultipleVideoSupportFeatureFlag(state))) {
+        && !(track.getVideoType() === VIDEO_TYPE.DESKTOP && getMultipleVideoSendingSupportFeatureFlag(state))) {
         return Promise.resolve();
     }
 

react/features/base/tracks/middleware.js

 import { hideNotification, isModerationNotificationDisplayed } from '../../notifications';
 import { isPrejoinPageVisible } from '../../prejoin/functions';
 import { getCurrentConference } from '../conference/functions';
-import { getMultipleVideoSupportFeatureFlag, getSourceNameSignalingFeatureFlag } from '../config';
+import { getMultipleVideoSendingSupportFeatureFlag } from '../config';
 import { getAvailableDevices } from '../devices/actions';
 import {
     CAMERA_FACING_MODE,
     setScreenshareMuted,
     SCREENSHARE_MUTISM_AUTHORITY
 } from '../media';
-import { participantLeft, participantJoined, getParticipantById } from '../participants';
 import { MiddlewareRegistry, StateListenerRegistry } from '../redux';
 
 import {
-    SCREENSHARE_TRACK_MUTED_UPDATED,
     TOGGLE_SCREENSHARING,
     TRACK_ADDED,
     TRACK_MUTE_UNMUTE_FAILED,
     isUserInteractionRequiredForUnmute,
     setTrackMuted
 } from './functions';
-import logger from './logger';
 
 import './subscriber';
 
 MiddlewareRegistry.register(store => next => action => {
     switch (action.type) {
     case TRACK_ADDED: {
-        const state = store.getState();
-        const { jitsiTrack, local } = action.track;
+        const { local } = action.track;
 
         // 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.
             store.dispatch(getAvailableDevices());
         }
 
-        // Call next before the creation of a fake screenshare participant to ensure a video track is available when
-        // the participant is auto pinned.
-        const result = next(action);
-
-        // The TRACK_ADDED action is dispatched when a presenter starts a screenshare. Do not create a local fake
-        // screenshare participant when multiple stream is not enabled.
-        const skipCreateFakeScreenShareParticipant = local && !getMultipleVideoSupportFeatureFlag(state);
-
-        if (getSourceNameSignalingFeatureFlag(state)
-            && jitsiTrack.getVideoType() === VIDEO_TYPE.DESKTOP
-            && !jitsiTrack.isMuted()
-            && !skipCreateFakeScreenShareParticipant
-        ) {
-            createFakeScreenShareParticipant(store, action);
-        }
-
-        return result;
+        break;
     }
     case TRACK_NO_DATA_FROM_SOURCE: {
         const result = next(action);
         return result;
     }
 
-    case SCREENSHARE_TRACK_MUTED_UPDATED: {
-        const state = store.getState();
-
-        if (!getSourceNameSignalingFeatureFlag(state)) {
-            return;
-        }
-
-        const { track, muted } = action;
-
-        if (muted) {
-            const conference = getCurrentConference(state);
-            const participantId = track?.jitsiTrack.getSourceName();
-
-            store.dispatch(participantLeft(participantId, conference));
-        }
-
-        if (!muted) {
-            createFakeScreenShareParticipant(store, action);
-        }
-
-        break;
-    }
-
     case TRACK_REMOVED: {
-        const state = store.getState();
-
-        if (getSourceNameSignalingFeatureFlag(state) && action.track.jitsiTrack.videoType === VIDEO_TYPE.DESKTOP) {
-            const conference = getCurrentConference(state);
-            const participantId = action.track.jitsiTrack.getSourceName();
-
-            store.dispatch(participantLeft(participantId, conference));
-        }
-
         _removeNoDataFromSourceNotification(store, action.track);
         break;
     }
 
             const { enabled, audioOnly, ignoreDidHaveVideo } = action;
 
-            if (!getMultipleVideoSupportFeatureFlag(store.getState())) {
+            if (!getMultipleVideoSendingSupportFeatureFlag(store.getState())) {
                 APP.UI.emitEvent(UIEvents.TOGGLE_SCREENSHARING,
                     {
                         enabled,
 
         if (typeof APP !== 'undefined') {
             if (isVideoTrack && jitsiTrack.getVideoType() === VIDEO_TYPE.DESKTOP
-                && getMultipleVideoSupportFeatureFlag(store.getState())) {
+                && getMultipleVideoSendingSupportFeatureFlag(store.getState())) {
                 store.dispatch(setScreenshareMuted(!muted));
             } else if (isVideoTrack) {
                 APP.conference.setVideoMuteStatus();
         const { jitsiTrack } = action.track;
 
         if (typeof APP !== 'undefined'
-            && getMultipleVideoSupportFeatureFlag(store.getState())
+            && getMultipleVideoSendingSupportFeatureFlag(store.getState())
             && jitsiTrack.getVideoType() === VIDEO_TYPE.DESKTOP) {
             store.dispatch(toggleScreensharing(false));
         }
                 } else if (jitsiTrack.isLocal() && !(jitsiTrack.getVideoType() === VIDEO_TYPE.DESKTOP)) {
                     APP.conference.setVideoMuteStatus();
                 } else if (jitsiTrack.isLocal() && muted && jitsiTrack.getVideoType() === VIDEO_TYPE.DESKTOP) {
-                    !getMultipleVideoSupportFeatureFlag(state)
+                    !getMultipleVideoSendingSupportFeatureFlag(state)
                         && store.dispatch(toggleScreensharing(false, false, true));
                 } else {
                     APP.UI.setVideoMuted(participantID);
     }
 }
 
-/**
- * Creates a fake participant for screen share using the track's source name as the participant id.
- *
- * @param {Store} store - The redux store in which the specified action is dispatched.
- * @param {Action} action - The redux action dispatched in the specified store.
- * @private
- * @returns {void}
- */
-function createFakeScreenShareParticipant({ dispatch, getState }, { track }) {
-    const state = getState();
-    const participantId = track.jitsiTrack?.getParticipantId?.();
-    const participant = getParticipantById(state, participantId);
-
-    if (participant.name) {
-        dispatch(participantJoined({
-            conference: state['features/base/conference'].conference,
-            id: track.jitsiTrack.getSourceName(),
-            isFakeScreenShareParticipant: true,
-            isLocalScreenShare: track?.jitsiTrack.isLocal(),
-            name: participant.name
-        }));
-    } else {
-        logger.error(`Failed to create a screenshare participant for participantId: ${participantId}`);
-    }
-}
-
 /**
  * Gets the local track associated with a specific {@code MEDIA_TYPE} in a
  * specific redux store.
     const state = getState();
 
     if (mediaType === MEDIA_TYPE.SCREENSHARE
-        && getMultipleVideoSupportFeatureFlag(state)
+        && getMultipleVideoSendingSupportFeatureFlag(state)
         && !muted) {
         return;
     }
 
         // Screenshare cannot be unmuted using the video mute button unless it is muted by audioOnly in the legacy
         // screensharing mode.
-        if (jitsiTrack
-            && (jitsiTrack.videoType !== 'desktop' || isAudioOnly || getMultipleVideoSupportFeatureFlag(state))) {
+        if (jitsiTrack && (
+            jitsiTrack.videoType !== 'desktop' || isAudioOnly || getMultipleVideoSendingSupportFeatureFlag(state))
+        ) {
             setTrackMuted(jitsiTrack, muted, state).catch(() => dispatch(trackMuteUnmuteFailed(localTrack, muted)));
         }
     } else if (!muted && ensureTrack && (typeof APP === 'undefined' || isPrejoinPageVisible(state))) {

react/features/connection-indicator/components/web/ConnectionIndicator.js

 import { Popover } from '../../../base/popover';
 import { connect } from '../../../base/redux';
 import {
-    getFakeScreenshareParticipantTrack,
+    getVirtualScreenshareParticipantTrack,
     getTrackByMediaTypeAndParticipant } from '../../../base/tracks';
 import {
     isParticipantConnectionStatusInactive,
 
     let firstVideoTrack;
 
-    if (sourceNameSignalingEnabled && participant?.isFakeScreenShareParticipant) {
-        firstVideoTrack = getFakeScreenshareParticipantTrack(tracks, participantId);
+    if (sourceNameSignalingEnabled && participant?.isVirtualScreenshareParticipant) {
+        firstVideoTrack = getVirtualScreenshareParticipantTrack(tracks, participantId);
     } else {
         firstVideoTrack = getTrackByMediaTypeAndParticipant(tracks, MEDIA_TYPE.VIDEO, participantId);
     }

react/features/connection-indicator/components/web/ConnectionIndicatorContent.js

      * Whether or not the displays stats are for screen share. This prop is behind the sourceNameSignaling feature
      * flag.
      */
-    _isFakeScreenShareParticipant: Boolean,
+    _isVirtualScreenshareParticipant: Boolean,
 
     /**
      * Whether or not the displays stats are for local video.
                 e2eRtt = { e2eRtt }
                 enableSaveLogs = { this.props._enableSaveLogs }
                 framerate = { framerate }
-                isFakeScreenShareParticipant = { this.props._isFakeScreenShareParticipant }
                 isLocalVideo = { this.props._isLocalVideo }
+                isVirtualScreenshareParticipant = { this.props._isVirtualScreenshareParticipant }
                 maxEnabledResolution = { maxEnabledResolution }
                 onSaveLogs = { this.props._onSaveLogs }
                 onShowMore = { this._onToggleShowMore }
         _disableShowMoreStats: state['features/base/config'].disableShowMoreStats,
         _isConnectionStatusInactive,
         _isConnectionStatusInterrupted,
-        _isFakeScreenShareParticipant: sourceNameSignalingEnabled && participant?.isFakeScreenShareParticipant,
+        _isVirtualScreenshareParticipant: sourceNameSignalingEnabled && participant?.isVirtualScreenshareParticipant,
         _isLocalVideo: participant?.local,
         _region: participant?.region
     };

react/features/connection-stats/components/ConnectionStatsTable.js

     /**
      * Whether or not the statistics are for screen share.
      */
-    isFakeScreenShareParticipant: boolean,
+    isVirtualScreenshareParticipant: boolean,
 
     /**
      * The send-side max enabled resolution (aka the highest layer that is not
             classes,
             disableShowMoreStats,
             enableSaveLogs,
-            isFakeScreenShareParticipant,
+            isVirtualScreenshareParticipant,
             isLocalVideo
         } = this.props;
         const className = clsx(classes.connectionStatsTable, { [classes.mobile]: isMobileBrowser() });
 
-        if (isFakeScreenShareParticipant) {
+        if (isVirtualScreenshareParticipant) {
             return this._renderScreenShareStatus();
         }
 

react/features/filmstrip/components/web/Thumbnail.js

 
 import { createScreenSharingIssueEvent, sendAnalytics } from '../../../analytics';
 import { Avatar } from '../../../base/avatar';
-import { getSourceNameSignalingFeatureFlag } from '../../../base/config';
+import { getMultipleVideoSupportFeatureFlag, getSourceNameSignalingFeatureFlag } from '../../../base/config';
 import { isMobileBrowser } from '../../../base/environment/utils';
 import { JitsiTrackEvents } from '../../../base/lib-jitsi-meet';
 import { MEDIA_TYPE, VideoTrack } from '../../../base/media';
     getLocalAudioTrack,
     getLocalVideoTrack,
     getTrackByMediaTypeAndParticipant,
-    getFakeScreenshareParticipantTrack,
+    getVirtualScreenshareParticipantTrack,
     updateLastTrackVideoMediaEvent,
     trackStreamingStatusChanged
 } from '../../../base/tracks';
     showGridInVerticalView
 } from '../../functions';
 
-import FakeScreenShareParticipant from './FakeScreenShareParticipant';
 import ThumbnailAudioIndicator from './ThumbnailAudioIndicator';
 import ThumbnailBottomIndicators from './ThumbnailBottomIndicators';
 import ThumbnailTopIndicators from './ThumbnailTopIndicators';
+import VirtualScreenshareParticipant from './VirtualScreenshareParticipant';
 
 
 declare var interfaceConfig: Object;
     _isCurrentlyOnLargeVideo: boolean,
 
     /**
-     * Indicates whether the participant is a fake screen share participant. This prop is behind the
+     * Indicates whether the participant is a virtual screen share participant. This prop is behind the
      * sourceNameSignaling feature flag.
      */
-    _isFakeScreenShareParticipant: boolean,
+    _isVirtualScreenshareParticipant: boolean,
 
     /**
      * Whether we are currently running in a mobile browser.
         const {
             _disableTileEnlargement,
             _height,
-            _isFakeScreenShareParticipant,
+            _isVirtualScreenshareParticipant,
             _isHidden,
             _isScreenSharing,
             _participant,
             || _disableTileEnlargement
             || _isScreenSharing;
 
-        if (canPlayEventReceived || _participant.local || _isFakeScreenShareParticipant) {
+        if (canPlayEventReceived || _participant.local || _isVirtualScreenshareParticipant) {
             videoStyles = {
                 objectFit: doNotStretchVideo ? 'contain' : 'cover'
             };
      * @returns {ReactElement}
      */
     render() {
-        const { _participant, _isFakeScreenShareParticipant } = this.props;
+        const { _participant, _isVirtualScreenshareParticipant } = this.props;
 
         if (!_participant) {
             return null;
             return this._renderFakeParticipant();
         }
 
-        if (_isFakeScreenShareParticipant) {
+        if (_isVirtualScreenshareParticipant) {
             const { isHovered } = this.state;
             const { _videoTrack, _isMobile, classes, _thumbnailType } = this.props;
 
             return (
-                <FakeScreenShareParticipant
+                <VirtualScreenshareParticipant
                     classes = { classes }
                     containerClassName = { this._getContainerClassName() }
                     isHovered = { isHovered }
 
     let _videoTrack;
 
-    if (sourceNameSignalingEnabled && participant?.isFakeScreenShareParticipant) {
-        _videoTrack = getFakeScreenshareParticipantTrack(tracks, id);
+    if (sourceNameSignalingEnabled && participant?.isVirtualScreenshareParticipant) {
+        _videoTrack = getVirtualScreenshareParticipantTrack(tracks, id);
     } else {
         _videoTrack = isLocal
             ? getLocalVideoTrack(tracks) : getTrackByMediaTypeAndParticipant(tracks, MEDIA_TYPE.VIDEO, participantID);
     const activeParticipants = getActiveParticipantsIds(state);
     const tileType = getThumbnailTypeFromLayout(_currentLayout, stageFilmstrip);
 
-
     switch (tileType) {
     case THUMBNAIL_TYPE.VERTICAL:
     case THUMBNAIL_TYPE.HORIZONTAL: {
 
     return {
         _audioTrack,
+        _currentLayout,
         _defaultLocalDisplayName: defaultLocalDisplayName,
         _disableLocalVideoFlip: Boolean(disableLocalVideoFlip),
         _disableTileEnlargement: Boolean(disableTileEnlargement),
         _isAudioOnly: Boolean(state['features/base/audio-only'].enabled),
         _isCurrentlyOnLargeVideo: state['features/large-video']?.participantId === id,
         _isDominantSpeakerDisabled: interfaceConfig.DISABLE_DOMINANT_SPEAKER_INDICATOR,
-        _isFakeScreenShareParticipant: sourceNameSignalingEnabled && participant?.isFakeScreenShareParticipant,
         _isMobile,
         _isMobilePortrait,
         _isScreenSharing: _videoTrack?.videoType === 'desktop',
         _isTestModeEnabled: isTestModeEnabled(state),
         _isVideoPlayable: id && isVideoPlayable(state, id),
+        _isVirtualScreenshareParticipant: sourceNameSignalingEnabled && participant?.isVirtualScreenshareParticipant,
         _localFlipX: Boolean(localFlipX),
+        _multipleVideoSupport: getMultipleVideoSupportFeatureFlag(state),
         _participant: participant,
         _raisedHand: hasRaisedHand(participant),
         _stageFilmstripLayout: isStageFilmstripAvailable(state),

react/features/filmstrip/components/web/ThumbnailTopIndicators.js

     isHovered: boolean,
 
     /**
-     * Whether or not the thumbnail is a fake screen share participant.
+     * Whether or not the thumbnail is a virtual screen share participant.
      */
-    isFakeScreenShareParticipant: boolean,
+    isVirtualScreenshareParticipant: boolean,
 
     /**
      * Whether or not the indicators are for the local participant.
 const ThumbnailTopIndicators = ({
     hidePopover,
     indicatorsClassName,
-    isFakeScreenShareParticipant,
+    isVirtualScreenshareParticipant,
     isHovered,
     local,
     participantId,
     const sourceNameSignalingEnabled = useSelector(getSourceNameSignalingFeatureFlag);
     const showConnectionIndicator = isHovered || !_connectionIndicatorAutoHideEnabled;
 
-    if (sourceNameSignalingEnabled && isFakeScreenShareParticipant) {
+    if (sourceNameSignalingEnabled && isVirtualScreenshareParticipant) {
         return (
             <div className = { styles.container }>
                 {!_connectionIndicatorDisabled

react/features/filmstrip/components/web/FakeScreenShareParticipant.js → react/features/filmstrip/components/web/VirtualScreenshareParticipant.js

     onTouchStart: Function,
 
     /**
-     * The ID of the fake screen share participant.
+     * The ID of the virtual screen share participant.
      */
     participantId: string,
 
     videoTrack: Object
 }
 
-const FakeScreenShareParticipant = ({
+const VirtualScreenshareParticipant = ({
     classes,
     containerClassName,
     isHovered,
                 ) }>
                 <ThumbnailTopIndicators
                     currentLayout = { currentLayout }
-                    isFakeScreenShareParticipant = { true }
                     isHovered = { isHovered }
+                    isVirtualScreenshareParticipant = { true }
                     participantId = { participantId }
                     thumbnailType = { thumbnailType } />
             </div>
         </span>);
 };
 
-export default FakeScreenShareParticipant;
+export default VirtualScreenshareParticipant;

react/features/filmstrip/functions.any.js

 // @flow
 
 import { getSourceNameSignalingFeatureFlag } from '../base/config';
-import { getFakeScreenShareParticipantOwnerId } from '../base/participants';
+import { getVirtualScreenshareParticipantOwnerId } from '../base/participants';
 
 import { setRemoteParticipants } from './actions';
 import { isReorderingEnabled } from './functions';
     const state = store.getState();
     let reorderedParticipants = [];
 
-    const { sortedRemoteFakeScreenShareParticipants } = state['features/base/participants'];
+    const { sortedRemoteVirtualScreenshareParticipants } = state['features/base/participants'];
 
-    if (!isReorderingEnabled(state) && !sortedRemoteFakeScreenShareParticipants.size) {
+    if (!isReorderingEnabled(state) && !sortedRemoteVirtualScreenshareParticipants.size) {
         if (participantId) {
             const { remoteParticipants } = state['features/filmstrip'];
 
     } = state['features/base/participants'];
     const remoteParticipants = new Map(sortedRemoteParticipants);
     const screenShares = new Map(sortedRemoteScreenshares);
-    const screenShareParticipants = sortedRemoteFakeScreenShareParticipants
-        ? [ ...sortedRemoteFakeScreenShareParticipants.keys() ] : [];
+    const screenShareParticipants = sortedRemoteVirtualScreenshareParticipants
+        ? [ ...sortedRemoteVirtualScreenshareParticipants.keys() ] : [];
     const sharedVideos = fakeParticipants ? Array.from(fakeParticipants.keys()) : [];
     const speakers = new Map(speakersList);
 
     if (getSourceNameSignalingFeatureFlag(state)) {
         for (const screenshare of screenShareParticipants) {
-            const ownerId = getFakeScreenShareParticipantOwnerId(screenshare);
+            const ownerId = getVirtualScreenshareParticipantOwnerId(screenshare);
 
             remoteParticipants.delete(ownerId);
             remoteParticipants.delete(screenshare);
     if (getSourceNameSignalingFeatureFlag(state)) {
         // Always update the order of the thumnails.
         const participantsWithScreenShare = screenShareParticipants.reduce((acc, screenshare) => {
-            const ownerId = getFakeScreenShareParticipantOwnerId(screenshare);
+            const ownerId = getVirtualScreenshareParticipantOwnerId(screenshare);
 
             acc.push(ownerId);
             acc.push(screenshare);

react/features/filmstrip/functions.web.js

         isActiveParticipant,
         isAudioOnly,
         isCurrentlyOnLargeVideo,
-        isFakeScreenShareParticipant,
+        isVirtualScreenshareParticipant,
         isScreenSharing,
         canPlayEventReceived,
         isRemoteParticipant,
+        multipleVideoSupport,
         stageParticipantsVisible,
         stageFilmstrip,
         tileViewActive
     } = input;
     const adjustedIsVideoPlayable = input.isVideoPlayable && (!isRemoteParticipant || canPlayEventReceived);
 
-    if (isFakeScreenShareParticipant) {
-        return DISPLAY_VIDEO;
+    if (multipleVideoSupport) {
+        // Display video for virtual screen share participants in all layouts.
+        if (isVirtualScreenshareParticipant) {
+            return DISPLAY_VIDEO;
+        }
+
+        // Multi-stream is not supported on plan-b endpoints even if its is enabled via config.js. A virtual
+        // screenshare tile is still created when a remote endpoint starts screenshare to keep the behavior consistent
+        // and an avatar is displayed on the original participant thumbnail as long as screenshare is in progress.
+        if (isScreenSharing) {
+            return DISPLAY_AVATAR;
+        }
     }
 
     if (!tileViewActive && ((isScreenSharing && isRemoteParticipant)
         _isActiveParticipant,
         _isAudioOnly,
         _isCurrentlyOnLargeVideo,
-        _isFakeScreenShareParticipant,
+        _isVirtualScreenshareParticipant,
         _isScreenSharing,
         _isVideoPlayable,
+        _multipleVideoSupport,
         _participant,
         _stageParticipantsVisible,
         _videoTrack,
         videoStream: Boolean(_videoTrack),
         isRemoteParticipant: !_participant?.isFakeParticipant && !_participant?.local,
         isScreenSharing: _isScreenSharing,
-        isFakeScreenShareParticipant: _isFakeScreenShareParticipant,
+        isVirtualScreenshareParticipant: _isVirtualScreenshareParticipant,
+        multipleVideoSupport: _multipleVideoSupport,
         stageParticipantsVisible: _stageParticipantsVisible,
         stageFilmstrip,
         videoStreamMuted: _videoTrack ? _videoTrack.muted : 'no stream'

react/features/filmstrip/subscriber.any.js

  * Listens for changes to the remote screenshare participants to recompute the reordered list of the remote endpoints.
  */
 StateListenerRegistry.register(
-    /* selector */ state => state['features/base/participants'].sortedRemoteFakeScreenShareParticipants,
-    /* listener */ (sortedRemoteFakeScreenShareParticipants, store) => updateRemoteParticipants(store));
+    /* selector */ state => state['features/base/participants'].sortedRemoteVirtualScreenshareParticipants,
+    /* listener */ (sortedRemoteVirtualScreenshareParticipants, store) => updateRemoteParticipants(store));
 
 /**
  * Listens for changes to the dominant speaker to recompute the reordered list of the remote endpoints.

react/features/notifications/middleware.js

         const { participant: p } = action;
         const { conference } = state['features/base/conference'];
 
-        // Do not display notifications for the fake screenshare tiles.
+        // Do not display notifications for the virtual screenshare tiles.
         if (conference
             && !p.local
-            && !p.isFakeScreenShareParticipant
+            && !p.isVirtualScreenshareParticipant
             && !joinLeaveNotificationsDisabled()
             && !p.isReplacing) {
             dispatch(showParticipantJoinedNotification(
                 action.participant.id
             );
 
-            // Do not display notifications for the fake screenshare tiles.
+            // Do not display notifications for the virtual screenshare tiles.
             if (participant
                 && !participant.local
-                && !participant.isFakeScreenShareParticipant
+                && !participant.isVirtualScreenshareParticipant
                 && !action.participant.isReplaced) {
                 dispatch(showParticipantLeftNotification(
                     getParticipantDisplayName(state, participant.id)

react/features/screen-share/actions.js

 // @flow
 
-import { getMultipleVideoSupportFeatureFlag } from '../base/config/functions.any';
+import { getMultipleVideoSendingSupportFeatureFlag } from '../base/config/functions.any';
 import { openDialog } from '../base/dialog/actions';
 import { browser } from '../base/lib-jitsi-meet';
 import { shouldHideShareAudioHelper } from '../base/settings';
         // available for audio screen sharing, namely full window audio.
         // If we're already sharing audio, toggle off.
         if (shouldHideShareAudioHelper(state) || browser.isElectron() || audioOnlySharing) {
-            if (getMultipleVideoSupportFeatureFlag(state)) {
+            if (getMultipleVideoSendingSupportFeatureFlag(state)) {
                 dispatch(toggleScreensharing(!audioOnlySharing, true));
 
                 return;

react/features/video-layout/actionTypes.ts

     = 'SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED';
 
 /**
- * The type of the action which sets the list of known remote fake screen share participant IDs.
+ * The type of the action which sets the list of known remote virtual screen share participant IDs.
  *
  * @returns {{
- *     type: FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
+ *     type: VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED,
  *     participantIds: Array<string>
  * }}
  */
-export const FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED = 'FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED';
+export const VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED = 'VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED';
 
 /**
  * The type of the action which enables or disables the feature for showing

react/features/video-layout/actions.js

 import type { Dispatch } from 'redux';
 
 import {
-    FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
     SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
-    SET_TILE_VIEW
+    SET_TILE_VIEW,
+    VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED
 } from './actionTypes';
 import { shouldDisplayTileView } from './functions';
 
 }
 
 /**
- * Creates a (redux) action which signals that the list of known remote fake screen share participant ids has changed.
+ * Creates a (redux) action which signals that the list of known remote virtual screen share participant ids has
+ * changed.
  *
- * @param {string} participantIds - The remote fake screen share participants.
+ * @param {string} participantIds - The remote virtual screen share participants.
  * @returns {{
- *     type: FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
+ *     type: VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED,
  *     participantIds: Array<string>
  * }}
  */
-export function fakeScreenshareParticipantsUpdated(participantIds: Array<string>) {
+export function virtualScreenshareParticipantsUpdated(participantIds: Array<string>) {
     return {
-        type: FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
+        type: VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED,
         participantIds
     };
 }

react/features/video-layout/reducer.js

 import { ReducerRegistry } from '../base/redux';
 
 import {
-    FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
     SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
-    SET_TILE_VIEW
+    SET_TILE_VIEW,
+    VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED
 } from './actionTypes';
 
 const DEFAULT_STATE = {
 
 ReducerRegistry.register(STORE_NAME, (state = DEFAULT_STATE, action) => {
     switch (action.type) {
-    case FAKE_SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED:
-    case SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED: {
+    case SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED:
+    case VIRTUAL_SCREENSHARE_REMOTE_PARTICIPANTS_UPDATED: {
         return {
             ...state,
             remoteScreenShares: action.participantIds

react/features/video-layout/subscriber.js

 
 import debounce from 'lodash/debounce';
 
-import { getSourceNameSignalingFeatureFlag } from '../base/config';
+import { getMultipleVideoSupportFeatureFlag } from '../base/config';
 import { StateListenerRegistry, equals } from '../base/redux';
 import { isFollowMeActive } from '../follow-me';
 
-import { setRemoteParticipantsWithScreenShare, fakeScreenshareParticipantsUpdated } from './actions';
+import { setRemoteParticipantsWithScreenShare, virtualScreenshareParticipantsUpdated } from './actions';
 import { getAutoPinSetting, updateAutoPinnedParticipant } from './functions';
 
 StateListenerRegistry.register(
-    /* selector */ state => state['features/base/participants'].sortedRemoteFakeScreenShareParticipants,
-    /* listener */ (sortedRemoteFakeScreenShareParticipants, store) => {
-        if (!getAutoPinSetting() || isFollowMeActive(store) || !getSourceNameSignalingFeatureFlag(store.getState())) {
+    /* selector */ state => state['features/base/participants'].sortedRemoteVirtualScreenshareParticipants,
+    /* listener */ (sortedRemoteVirtualScreenshareParticipants, store) => {
+        if (!getAutoPinSetting() || isFollowMeActive(store) || !getMultipleVideoSupportFeatureFlag(store.getState())) {
             return;
         }
 
         const oldScreenSharesOrder = store.getState()['features/video-layout'].remoteScreenShares || [];
-        const knownSharingParticipantIds = [ ...sortedRemoteFakeScreenShareParticipants.keys() ];
+        const knownSharingParticipantIds = [ ...sortedRemoteVirtualScreenshareParticipants.keys() ];
 
         // Filter out any participants which are no longer screen sharing
         // by looping through the known sharing participants and removing any
         });
 
         if (!equals(oldScreenSharesOrder, newScreenSharesOrder)) {
-            store.dispatch(fakeScreenshareParticipantsUpdated(newScreenSharesOrder));
+            store.dispatch(virtualScreenshareParticipantsUpdated(newScreenSharesOrder));
 
             updateAutoPinnedParticipant(oldScreenSharesOrder, store);
         }
         // possible to have screen sharing participant that has already left in the remoteScreenShares array.
         // This can lead to rendering a thumbnails for already left participants since the remoteScreenShares
         // array is used for building the ordered list of remote participants.
-        if (!getAutoPinSetting() || isFollowMeActive(store) || getSourceNameSignalingFeatureFlag(store.getState())) {
+        if (!getAutoPinSetting() || isFollowMeActive(store) || getMultipleVideoSupportFeatureFlag(store.getState())) {
             return;
         }
 

react/features/video-quality/subscriber.js

 import { MEDIA_TYPE } from '../base/media';
 import { getLocalParticipant, getParticipantCount } from '../base/participants';
 import { StateListenerRegistry } from '../base/redux';
-import { getTrackSourceNameByMediaTypeAndParticipant } from '../base/tracks';
+import { getRemoteScreenSharesSourceNames, getTrackSourceNameByMediaTypeAndParticipant } from '../base/tracks';
 import { reportError } from '../base/util';
 import { getActiveParticipantsIds } from '../filmstrip/functions.web';
 import {
     let receiverConstraints;
 
     if (sourceNameSignaling) {
+        const remoteScreenSharesSourceNames = getRemoteScreenSharesSourceNames(state, remoteScreenShares);
+
         receiverConstraints = {
             constraints: {},
             defaultConstraints: { 'maxHeight': VIDEO_QUALITY_LEVELS.NONE },
             visibleRemoteParticipants.forEach(participantId => {
                 let sourceName;
 
-                if (remoteScreenShares.includes(participantId)) {
+                if (remoteScreenSharesSourceNames.includes(participantId)) {
                     sourceName = participantId;
                 } else {
                     sourceName = getTrackSourceNameByMediaTypeAndParticipant(tracks, MEDIA_TYPE.VIDEO, participantId);
         }
 
         if (localParticipantId !== largeVideoParticipantId) {
-            if (remoteScreenShares.includes(largeVideoParticipantId)) {
+            if (remoteScreenSharesSourceNames.includes(largeVideoParticipantId)) {
                 largeVideoSourceName = largeVideoParticipantId;
             } else {
                 largeVideoSourceName = getTrackSourceNameByMediaTypeAndParticipant(
-                    tracks, MEDIA_TYPE.VIDEO,
-                    largeVideoParticipantId
+                    tracks, MEDIA_TYPE.VIDEO, largeVideoParticipantId
                 );
             }
         }
             });
 
             // Prioritize screenshare in tile view.
-            if (remoteScreenShares?.length) {
-                receiverConstraints.selectedSources = remoteScreenShares;
+            if (remoteScreenSharesSourceNames?.length) {
+                receiverConstraints.selectedSources = remoteScreenSharesSourceNames;
             }
 
         // Stage view.
             }
         }
 
-        if (remoteScreenShares?.length) {
-            remoteScreenShares.forEach(sourceName => {
+        if (remoteScreenSharesSourceNames?.length) {
+            remoteScreenSharesSourceNames.forEach(sourceName => {
                 receiverConstraints.constraints[sourceName] = { 'maxHeight': VIDEO_QUALITY_LEVELS.ULTRA };
             });
         }