chore(mobile) changes the name for screenShares to remoteScreenShares to better reflect it's content

react/features/base/lastn/middleware.js

 import { SET_FILMSTRIP_ENABLED } from '../../filmstrip/actionTypes';
 import { SELECT_LARGE_VIDEO_PARTICIPANT } from '../../large-video/actionTypes';
 import { APP_STATE_CHANGED } from '../../mobile/background/actionTypes';
-import { SCREEN_SHARE_PARTICIPANTS_UPDATED, SET_TILE_VIEW } from '../../video-layout/actionTypes';
+import { SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED, SET_TILE_VIEW } from '../../video-layout/actionTypes';
 import { SET_AUDIO_ONLY } from '../audio-only/actionTypes';
 import { CONFERENCE_JOINED } from '../conference/actionTypes';
 import {
     case PARTICIPANT_JOINED:
     case PARTICIPANT_KICKED:
     case PARTICIPANT_LEFT:
-    case SCREEN_SHARE_PARTICIPANTS_UPDATED:
+    case SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED:
     case SELECT_LARGE_VIDEO_PARTICIPANT:
     case SET_AUDIO_ONLY:
     case SET_FILMSTRIP_ENABLED:
     if (typeof appState !== 'undefined' && appState !== 'active') {
         lastN = isLocalVideoTrackDesktop(state) ? 1 : 0;
     } else if (audioOnly) {
-        const { screenShares, tileViewEnabled } = state['features/video-layout'];
+        const { remoteScreenShares, tileViewEnabled } = state['features/video-layout'];
         const largeVideoParticipantId = state['features/large-video'].participantId;
         const largeVideoParticipant
             = largeVideoParticipantId ? getParticipantById(state, largeVideoParticipantId) : undefined;
         // view since we make an exception only for screenshare when in audio-only mode. If the user unpins
         // the screenshare, lastN will be set to 0 here. It will be set to 1 if screenshare has been auto pinned.
         if (!tileViewEnabled && largeVideoParticipant && !largeVideoParticipant.local) {
-            lastN = (screenShares || []).includes(largeVideoParticipantId) ? 1 : 0;
+            lastN = (remoteScreenShares || []).includes(largeVideoParticipantId) ? 1 : 0;
         } else {
             lastN = 0;
         }

react/features/base/participants/functions.js

     }
 
     /* Last, check if the participant is sharing their screen and they are on stage. */
-    const screenShares = state['features/video-layout'].screenShares || [];
+    const remoteScreenShares = state['features/video-layout'].remoteScreenShares || [];
     const largeVideoParticipantId = state['features/large-video'].participantId;
     const participantIsInLargeVideoWithScreen
-        = participant.id === largeVideoParticipantId && screenShares.includes(participant.id);
+        = participant.id === largeVideoParticipantId && remoteScreenShares.includes(participant.id);
 
     return participantIsInLargeVideoWithScreen;
 }

react/features/large-video/actions.any.js

         const state = getState();
         const participantId = participant ?? _electParticipantInLargeVideo(state);
         const largeVideo = state['features/large-video'];
-        const screenShares = state['features/video-layout'].screenShares;
+        const remoteScreenShares = state['features/video-layout'].remoteScreenShares;
         let latestScreenshareParticipantId;
 
-        if (screenShares && screenShares.length) {
-            latestScreenshareParticipantId = screenShares[screenShares.length - 1];
+        if (remoteScreenShares && remoteScreenShares.length) {
+            latestScreenshareParticipantId = remoteScreenShares[remoteScreenShares.length - 1];
         }
 
         // When trying to auto pin screenshare, always select the endpoint even though it happens to be

react/features/video-layout/actionTypes.js

 /**
- * The type of the action which sets the list of known participant IDs which
+ * The type of the action which sets the list of known remote participant IDs which
  * have an active screen share.
  *
  * @returns {{
- *     type: SCREEN_SHARE_PARTICIPANTS_UPDATED,
+ *     type: SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
  *     participantIds: Array<string>
  * }}
  */
-export const SCREEN_SHARE_PARTICIPANTS_UPDATED
-    = 'SCREEN_SHARE_PARTICIPANTS_UPDATED';
+export const SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED
+    = 'SCREEN_SHARE_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 {
-    SCREEN_SHARE_PARTICIPANTS_UPDATED,
+    SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
     SET_TILE_VIEW
 } from './actionTypes';
 import { shouldDisplayTileView } from './functions';
 
 /**
- * Creates a (redux) action which signals that the list of known participants
+ * Creates a (redux) action which signals that the list of known remote participants
  * with screen shares has changed.
  *
- * @param {string} participantIds - The participants which currently have active
+ * @param {string} participantIds - The remote participants which currently have active
  * screen share streams.
  * @returns {{
- *     type: SCREEN_SHARE_PARTICIPANTS_UPDATED,
+ *     type: SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
  *     participantId: string
  * }}
  */
-export function setParticipantsWithScreenShare(participantIds: Array<string>) {
+export function setRemoteParticipantsWithScreenShare(participantIds: Array<string>) {
     return {
-        type: SCREEN_SHARE_PARTICIPANTS_UPDATED,
+        type: SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
         participantIds
     };
 }

react/features/video-layout/reducer.js

 import { ReducerRegistry } from '../base/redux';
 
 import {
-    SCREEN_SHARE_PARTICIPANTS_UPDATED,
+    SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED,
     SET_TILE_VIEW
 } from './actionTypes';
 
 const DEFAULT_STATE = {
-    screenShares: [],
+    remoteScreenShares: [],
 
     /**
      * The indicator which determines whether the video layout should display
 
 ReducerRegistry.register(STORE_NAME, (state = DEFAULT_STATE, action) => {
     switch (action.type) {
-    case SCREEN_SHARE_PARTICIPANTS_UPDATED: {
+    case SCREEN_SHARE_REMOTE_PARTICIPANTS_UPDATED: {
         return {
             ...state,
-            screenShares: action.participantIds
+            remoteScreenShares: action.participantIds
         };
     }
 

react/features/video-layout/subscriber.js

 import { isFollowMeActive } from '../follow-me';
 import { selectParticipant } from '../large-video/actions';
 
-import { setParticipantsWithScreenShare } from './actions';
+import { setRemoteParticipantsWithScreenShare } from './actions';
 
 declare var APP: Object;
 declare var interfaceConfig: Object;
             return;
         }
 
-        const oldScreenSharesOrder = store.getState()['features/video-layout'].screenShares || [];
+        const oldScreenSharesOrder = store.getState()['features/video-layout'].remoteScreenShares || [];
         const knownSharingParticipantIds = tracks.reduce((acc, track) => {
             if (track.mediaType === 'video' && track.videoType === 'desktop') {
                 const skipTrack = _getAutoPinSetting() === 'remote-only' && track.local;
 
         if (!equals(oldScreenSharesOrder, newScreenSharesOrder)) {
             store.dispatch(
-                setParticipantsWithScreenShare(newScreenSharesOrder));
+                setRemoteParticipantsWithScreenShare(newScreenSharesOrder));
 
             _updateAutoPinnedParticipant(store);
         }
  */
 function _updateAutoPinnedParticipant({ dispatch, getState }) {
     const state = getState();
-    const screenShares = state['features/video-layout'].screenShares;
+    const remoteScreenShares = state['features/video-layout'].remoteScreenShares;
 
-    if (!screenShares) {
+    if (!remoteScreenShares) {
         return;
     }
 
     const latestScreenshareParticipantId
-        = screenShares[screenShares.length - 1];
+        = remoteScreenShares[remoteScreenShares.length - 1];
 
     const pinned = getPinnedParticipant(getState);