feat(mobile) adds ToggleScreenShare event and action.

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastAction.java

     enum Type {
         SET_AUDIO_MUTED("org.jitsi.meet.SET_AUDIO_MUTED"),
         HANG_UP("org.jitsi.meet.HANG_UP"),
-        SEND_ENDPOINT_TEXT_MESSAGE("org.jitsi.meet.SEND_ENDPOINT_TEXT_MESSAGE");
+        SEND_ENDPOINT_TEXT_MESSAGE("org.jitsi.meet.SEND_ENDPOINT_TEXT_MESSAGE"),
+        TOGGLE_SCREEN_SHARE("org.jitsi.meet.TOGGLE_SCREEN_SHARE");
 
         private final String action;
 

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastEvent.java

         AUDIO_MUTED_CHANGED("org.jitsi.meet.AUDIO_MUTED_CHANGED"),
         PARTICIPANT_JOINED("org.jitsi.meet.PARTICIPANT_JOINED"),
         PARTICIPANT_LEFT("org.jitsi.meet.PARTICIPANT_LEFT"),
-        ENDPOINT_TEXT_MESSAGE_RECEIVED("org.jitsi.meet.ENDPOINT_TEXT_MESSAGE_RECEIVED");
+        ENDPOINT_TEXT_MESSAGE_RECEIVED("org.jitsi.meet.ENDPOINT_TEXT_MESSAGE_RECEIVED"),
+        SCREEN_SHARE_TOGGLED("org.jitsi.meet.SCREEN_SHARE_TOGGLED");
 
         private static final String CONFERENCE_WILL_JOIN_NAME = "CONFERENCE_WILL_JOIN";
         private static final String CONFERENCE_JOINED_NAME = "CONFERENCE_JOINED";
         private static final String PARTICIPANT_JOINED_NAME = "PARTICIPANT_JOINED";
         private static final String PARTICIPANT_LEFT_NAME = "PARTICIPANT_LEFT";
         private static final String ENDPOINT_TEXT_MESSAGE_RECEIVED_NAME = "ENDPOINT_TEXT_MESSAGE_RECEIVED";
+        private static final String SCREEN_SHARE_TOGGLED_NAME= "SCREEN_SHARE_TOGGLED";
 
         private final String action;
 
                     return PARTICIPANT_LEFT;
                 case ENDPOINT_TEXT_MESSAGE_RECEIVED_NAME:
                     return ENDPOINT_TEXT_MESSAGE_RECEIVED;
+                case SCREEN_SHARE_TOGGLED_NAME:
+                    return SCREEN_SHARE_TOGGLED;
             }
 
             return null;

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastIntentHelper.java

         intent.putExtra("message", message);
         return intent;
     }
+
+    public static Intent buildToggleScreenShareIntent() {
+        return new Intent(BroadcastAction.Type.TOGGLE_SCREEN_SHARE.getAction());
+    }
 }

android/sdk/src/main/java/org/jitsi/meet/sdk/BroadcastReceiver.java

         LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(context);
 
         IntentFilter intentFilter = new IntentFilter();
-        intentFilter.addAction(BroadcastAction.Type.SET_AUDIO_MUTED.getAction());
-        intentFilter.addAction(BroadcastAction.Type.HANG_UP.getAction());
-        intentFilter.addAction(BroadcastAction.Type.SEND_ENDPOINT_TEXT_MESSAGE.getAction());
+
+        for (BroadcastAction.Type type : BroadcastAction.Type.values()) {
+            intentFilter.addAction(type.getAction());
+        }
 
         localBroadcastManager.registerReceiver(this, intentFilter);
     }

android/sdk/src/main/java/org/jitsi/meet/sdk/ExternalAPIModule.java

         constants.put("SET_AUDIO_MUTED", BroadcastAction.Type.SET_AUDIO_MUTED.getAction());
         constants.put("HANG_UP", BroadcastAction.Type.HANG_UP.getAction());
         constants.put("SEND_ENDPOINT_TEXT_MESSAGE", BroadcastAction.Type.SEND_ENDPOINT_TEXT_MESSAGE.getAction());
+        constants.put("TOGGLE_SCREEN_SHARE", BroadcastAction.Type.TOGGLE_SCREEN_SHARE.getAction());
 
         return constants;
     }

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetActivity.java

 
     private void registerForBroadcastMessages() {
         IntentFilter intentFilter = new IntentFilter();
-        intentFilter.addAction(BroadcastEvent.Type.CONFERENCE_JOINED.getAction());
-        intentFilter.addAction(BroadcastEvent.Type.CONFERENCE_WILL_JOIN.getAction());
-        intentFilter.addAction(BroadcastEvent.Type.CONFERENCE_TERMINATED.getAction());
-        intentFilter.addAction(BroadcastEvent.Type.PARTICIPANT_JOINED.getAction());
-        intentFilter.addAction(BroadcastEvent.Type.PARTICIPANT_LEFT.getAction());
-        intentFilter.addAction(BroadcastEvent.Type.ENDPOINT_TEXT_MESSAGE_RECEIVED.getAction());
+
+        for (BroadcastEvent.Type type : BroadcastEvent.Type.values()) {
+            intentFilter.addAction(type.getAction());
+        }
 
         LocalBroadcastManager.getInstance(this).registerReceiver(broadcastReceiver, intentFilter);
     }

ios/app/src/ViewController.m

   NSLog(@"%@%@", @"Audio muted changed: ", data[@"muted"]);
 }
 
-- (void)endpointTextMessageReceived:(NSDictionary *)data; {
+- (void)endpointTextMessageReceived:(NSDictionary *)data {
   NSLog(@"%@%@", @"Endpoint text message received: ", data);
 }
 
+- (void)screenShareToggled:(NSDictionary *)data {
+  NSLog(@"%@%@", @"Screen share toggled: ", data);
+}
+
 #pragma mark - Helpers
 
 - (void)terminate {

ios/sdk/src/ExternalAPI.h

 - (void)sendHangUp;
 - (void)sendSetAudioMuted: (BOOL)muted;
 - (void)sendEndpointTextMessage:(NSString*)to :(NSString*)message;
+- (void)toggleScreenShare;
 
 @end

ios/sdk/src/ExternalAPI.m

 static NSString * const hangUpAction = @"org.jitsi.meet.HANG_UP";
 static NSString * const setAudioMutedAction = @"org.jitsi.meet.SET_AUDIO_MUTED";
 static NSString * const sendEndpointTextMessageAction = @"org.jitsi.meet.SEND_ENDPOINT_TEXT_MESSAGE";
+static NSString * const toggleScreenShareAction = @"org.jitsi.meet.TOGGLE_SCREEN_SHARE";
 
 @implementation ExternalAPI
 
     return @{
         @"HANG_UP": hangUpAction,
         @"SET_AUDIO_MUTED" : setAudioMutedAction,
-        @"SEND_ENDPOINT_TEXT_MESSAGE": sendEndpointTextMessageAction
+        @"SEND_ENDPOINT_TEXT_MESSAGE": sendEndpointTextMessageAction,
+        @"TOGGLE_SCREEN_SHARE": toggleScreenShareAction
     };
 };
 
 }
 
 - (NSArray<NSString *> *)supportedEvents {
-    return @[ hangUpAction, setAudioMutedAction, sendEndpointTextMessageAction ];
+    return @[ hangUpAction, setAudioMutedAction, sendEndpointTextMessageAction, toggleScreenShareAction ];
 }
 
 /**
     [self sendEventWithName:sendEndpointTextMessageAction body:data];
 }
 
+- (void)toggleScreenShare {
+    [self sendEventWithName:toggleScreenShareAction body:nil];
+}
+
 @end

ios/sdk/src/JitsiMeetView.h

 
 - (void)sendEndpointTextMessage:(NSString*)to :(NSString*)message;
 
+- (void)toggleScreenShare;
+
 @end

ios/sdk/src/JitsiMeetView.m

     [externalAPI sendEndpointTextMessage:to :message];
 }
 
+- (void)toggleScreenShare {
+    ExternalAPI *externalAPI = [[JitsiMeet sharedInstance] getExternalAPI];
+    [externalAPI toggleScreenShare];
+}
+
 #pragma mark Private methods
 
 /**

ios/sdk/src/JitsiMeetViewDelegate.h

  */
 - (void)endpointTextMessageReceived:(NSDictionary *)data;
 
+/**
+ * Called when a participant toggled shared screen.
+ *
+ * The `data` dictionary contains a `participantId` key with the id of the participant  and a 'sharing' key with boolean value.
+ */
+- (void)screenShareToggled:(NSDictionary *)data;
+
 @end

react/features/app/reducers.native.js

 import '../mobile/audio-mode/reducer';
 import '../mobile/background/reducer';
 import '../mobile/call-integration/reducer';
+import '../mobile/external-api/reducer';
 import '../mobile/full-screen/reducer';
 import '../mobile/incoming-call/reducer';
 import '../mobile/watchos/reducer';

react/features/mobile/external-api/actionTypes.js

+/**
+ * The type of the action which sets the list of known participant IDs which
+ * have an active screen share.
+ *
+ * @returns {{
+    *     type: SCREEN_SHARE_PARTICIPANTS_UPDATED,
+    *     participantIds: Array<string>
+    * }}
+    */
+export const SCREEN_SHARE_PARTICIPANTS_UPDATED
+    = 'SCREEN_SHARE_PARTICIPANTS_UPDATED';

react/features/mobile/external-api/actions.js

+// @flow
+
+import { SCREEN_SHARE_PARTICIPANTS_UPDATED } from './actionTypes';
+
+/**
+ * Creates a (redux) action which signals that the list of known participants
+ * with screen shares has changed.
+ *
+ * @param {string} participantIds - The participants which currently have active
+ * screen share streams.
+ * @returns {{
+    *     type: SCREEN_SHARE_PARTICIPANTS_UPDATED,
+    *     participantId: string
+    * }}
+    */
+export function setParticipantsWithScreenShare(participantIds: Array<string>) {
+    return {
+        type: SCREEN_SHARE_PARTICIPANTS_UPDATED,
+        participantIds
+    };
+}

react/features/mobile/external-api/middleware.js

 // @flow
 
+import debounce from 'lodash/debounce';
 import { NativeEventEmitter, NativeModules } from 'react-native';
 
 import { ENDPOINT_TEXT_MESSAGE_NAME } from '../../../../modules/API/constants';
 import { JitsiConferenceEvents } from '../../base/lib-jitsi-meet';
 import { SET_AUDIO_MUTED } from '../../base/media/actionTypes';
 import { PARTICIPANT_JOINED, PARTICIPANT_LEFT } from '../../base/participants';
-import { MiddlewareRegistry } from '../../base/redux';
+import { MiddlewareRegistry, StateListenerRegistry } from '../../base/redux';
+import { toggleScreensharing } from '../../base/tracks';
 import { muteLocal } from '../../remote-video-menu/actions';
 import { ENTER_PICTURE_IN_PICTURE } from '../picture-in-picture';
 
+import { setParticipantsWithScreenShare } from './actions';
 import { sendEvent } from './functions';
 import logger from './logger';
 
  */
 const ENDPOINT_TEXT_MESSAGE_RECEIVED = 'ENDPOINT_TEXT_MESSAGE_RECEIVED';
 
+/**
+ * Event which will be emitted on the native side to indicate a participant togggles
+ * the screen share.
+ */
+const SCREEN_SHARE_TOGGLED = 'SCREEN_SHARE_TOGGLED';
+
 const { ExternalAPI } = NativeModules;
 const eventEmitter = new NativeEventEmitter(ExternalAPI);
 
     return result;
 });
 
+/**
+ * Listen for changes to the known media tracks and look
+ * for updates to screen shares for emitting native events.
+ * The listener is debounced to avoid state thrashing that might occur,
+ * especially when switching in or out of p2p.
+ */
+StateListenerRegistry.register(
+    /* selector */ state => state['features/base/tracks'],
+    /* listener */ debounce((tracks, store) => {
+        const oldScreenShares = store.getState()['features/mobile/external-api'].screenShares || [];
+        const newScreenShares = tracks
+            .filter(track => track.mediaType === 'video' && track.videoType === 'desktop')
+            .map(track => track.participantId);
+
+        oldScreenShares.forEach(participantId => {
+            if (!newScreenShares.includes(participantId)) {
+                sendEvent(
+                    store,
+                    SCREEN_SHARE_TOGGLED,
+                    /* data */ {
+                        participantId,
+                        sharing: false
+                    });
+            }
+        });
+
+        newScreenShares.forEach(participantId => {
+            if (!oldScreenShares.includes(participantId)) {
+                sendEvent(
+                    store,
+                    SCREEN_SHARE_TOGGLED,
+                    /* data */ {
+                        participantId,
+                        sharing: true
+                    });
+            }
+        });
+
+        store.dispatch(setParticipantsWithScreenShare(newScreenShares));
+
+    }, 100));
+
 /**
  * Registers for events sent from the native side via NativeEventEmitter.
  *
             logger.warn('Cannot send endpointMessage', error);
         }
     });
+
+    eventEmitter.addListener(ExternalAPI.TOGGLE_SCREEN_SHARE, () => {
+        dispatch(toggleScreensharing());
+    });
 }
 
 /**

react/features/mobile/external-api/reducer.js

+// @flow
+
+import { ReducerRegistry } from '../../base/redux';
+
+import { SCREEN_SHARE_PARTICIPANTS_UPDATED } from './actionTypes';
+
+const DEFAULT_STATE = {
+    screenShares: []
+};
+
+ReducerRegistry.register('features/mobile/external-api', (state = DEFAULT_STATE, action) => {
+    switch (action.type) {
+    case SCREEN_SHARE_PARTICIPANTS_UPDATED: {
+        return {
+            ...state,
+            screenShares: action.participantIds
+        };
+    }
+    }
+
+    return state;
+});