ref(conference.js): unify "user joined/left" handling on web and RN

Extracts methods which share the common logic. There are still some
leftovers on the web side left which are not used on RN. But this can be
a first step.

conference.js

 import {
     AVATAR_ID_COMMAND,
     AVATAR_URL_COMMAND,
+    EMAIL_COMMAND,
     authStatusChanged,
+    commonUserJoinedHandling,
+    commonUserLeftHandling,
     conferenceFailed,
     conferenceJoined,
     conferenceLeft,
     conferenceWillJoin,
     conferenceWillLeave,
     dataChannelOpened,
-    EMAIL_COMMAND,
     lockStateChanged,
     onStartMutedPolicyChanged,
     p2pStatusChanged,
     getAvatarURLByParticipantId,
     getLocalParticipant,
     getParticipantById,
-    hiddenParticipantJoined,
-    hiddenParticipantLeft,
     localParticipantConnectionStatusChanged,
     localParticipantRoleChanged,
     MAX_DISPLAY_NAME_LENGTH,
     participantConnectionStatusChanged,
-    participantJoined,
-    participantLeft,
     participantPresenceChanged,
     participantRoleChanged,
     participantUpdated
         room.on(JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED,
             user => APP.UI.onUserFeaturesChanged(user));
         room.on(JitsiConferenceEvents.USER_JOINED, (id, user) => {
-            const displayName = user.getDisplayName();
+            // The logic shared between RN and web.
+            commonUserJoinedHandling(APP.store, room, user);
 
             if (user.isHidden()) {
-                APP.store.dispatch(hiddenParticipantJoined(id, displayName));
-
                 return;
             }
 
-            APP.store.dispatch(participantJoined({
-                botType: user.getBotType(),
-                conference: room,
-                id,
-                name: displayName,
-                presence: user.getStatus(),
-                role: user.getRole()
-            }));
+            const displayName = user.getDisplayName();
 
             logger.log(`USER ${id} connnected:`, user);
             APP.API.notifyUserJoined(id, {
         });
 
         room.on(JitsiConferenceEvents.USER_LEFT, (id, user) => {
-            if (user.isHidden()) {
-                APP.store.dispatch(hiddenParticipantLeft(id));
+            // The logic shared between RN and web.
+            commonUserLeftHandling(APP.store, room, user);
 
+            if (user.isHidden()) {
                 return;
             }
 
-            APP.store.dispatch(participantLeft(id, room));
             logger.log(`USER ${id} LEFT:`, user);
             APP.API.notifyUserLeft(id);
             APP.UI.messageHandler.participantNotification(

react/features/base/conference/actions.js

     MAX_DISPLAY_NAME_LENGTH,
     dominantSpeakerChanged,
     participantConnectionStatusChanged,
-    participantJoined,
-    participantLeft,
     participantPresenceChanged,
     participantRoleChanged,
     participantUpdated
 } from './constants';
 import {
     _addLocalTracksToConference,
+    commonUserJoinedHandling,
+    commonUserLeftHandling,
     getCurrentConference,
     sendLocalParticipant
 } from './functions';
 
     conference.on(
         JitsiConferenceEvents.USER_JOINED,
-        (id, user) => !user.isHidden() && dispatch(participantJoined({
-            botType: user.getBotType(),
-            conference,
-            id,
-            name: user.getDisplayName(),
-            presence: user.getStatus(),
-            role: user.getRole()
-        })));
+        (id, user) => commonUserJoinedHandling({ dispatch }, conference, user));
     conference.on(
         JitsiConferenceEvents.USER_LEFT,
-        (id, user) => !user.isHidden()
-            && dispatch(participantLeft(id, conference)));
+        (id, user) => commonUserLeftHandling({ dispatch }, conference, user));
     conference.on(
         JitsiConferenceEvents.USER_ROLE_CHANGED,
         (...args) => dispatch(participantRoleChanged(...args)));

react/features/base/conference/functions.js

 // @flow
 
 import { JitsiTrackErrors } from '../lib-jitsi-meet';
-import { getLocalParticipant } from '../participants';
+import {
+    getLocalParticipant,
+    hiddenParticipantJoined,
+    hiddenParticipantLeft,
+    participantJoined,
+    participantLeft
+} from '../participants';
 import { toState } from '../redux';
 
 import {
     return Promise.all(promises);
 }
 
+/**
+ * Logic shared between web and RN which processes the {@code USER_JOINED}
+ * conference event and dispatches either {@link participantJoined} or
+ * {@link hiddenParticipantJoined}.
+ *
+ * @param {Object} store - The redux store.
+ * @param {JitsiMeetConference} conference - The conference for which the
+ * {@code USER_JOINED} event is being processed.
+ * @param {JitsiParticipant} user - The user who has just joined.
+ * @returns {void}
+ */
+export function commonUserJoinedHandling(
+        { dispatch }: Object,
+        conference: Object,
+        user: Object) {
+    const id = user.getId();
+    const displayName = user.getDisplayName();
+
+    if (user.isHidden()) {
+        dispatch(hiddenParticipantJoined(id, displayName));
+    } else {
+        dispatch(participantJoined({
+            botType: user.getBotType(),
+            conference,
+            id,
+            name: displayName,
+            presence: user.getStatus(),
+            role: user.getRole()
+        }));
+    }
+}
+
+/**
+ * Logic shared between web and RN which processes the {@code USER_LEFT}
+ * conference event and dispatches either {@link participantLeft} or
+ * {@link hiddenParticipantLeft}.
+ *
+ * @param {Object} store - The redux store.
+ * @param {JitsiMeetConference} conference - The conference for which the
+ * {@code USER_LEFT} event is being processed.
+ * @param {JitsiParticipant} user - The user who has just left.
+ * @returns {void}
+ */
+export function commonUserLeftHandling(
+        { dispatch }: Object,
+        conference: Object,
+        user: Object) {
+    const id = user.getId();
+
+    if (user.isHidden()) {
+        dispatch(hiddenParticipantLeft(id));
+    } else {
+        dispatch(participantLeft(id, conference));
+    }
+}
+
 /**
  * Evaluates a specific predicate for each {@link JitsiConference} known to the
  * redux state features/base/conference while it returns {@code true}.