Comply w/ coding style

react/features/base/conference/actions.js

 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
 import {
-    changeParticipantConnectionStatus,
     dominantSpeakerChanged,
     getLocalParticipant,
+    participantConnectionStatusChanged,
     participantJoined,
     participantLeft,
     participantRoleChanged,
  * @returns {void}
  */
 function _addConferenceListeners(conference, dispatch) {
+    // Dispatches into features/base/conference follow:
+
     conference.on(
             JitsiConferenceEvents.CONFERENCE_FAILED,
             (...args) => dispatch(conferenceFailed(conference, ...args)));
             JitsiConferenceEvents.CONFERENCE_LEFT,
             (...args) => dispatch(conferenceLeft(conference, ...args)));
 
-    conference.on(
-            JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
-            (...args) => dispatch(dominantSpeakerChanged(...args)));
-
-    conference.on(
-        JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
-        (...args) => dispatch(changeParticipantConnectionStatus(...args)));
-
     conference.on(
             JitsiConferenceEvents.LOCK_STATE_CHANGED,
             (...args) => dispatch(_lockStateChanged(conference, ...args)));
 
+    // Dispatches into features/base/tracks follow:
+
     conference.on(
             JitsiConferenceEvents.TRACK_ADDED,
             t => t && !t.isLocal() && dispatch(trackAdded(t)));
             JitsiConferenceEvents.TRACK_REMOVED,
             t => t && !t.isLocal() && dispatch(trackRemoved(t)));
 
+    // Dispatches into features/base/participants follow:
+
+    conference.on(
+            JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
+            (...args) => dispatch(dominantSpeakerChanged(...args)));
+
+    conference.on(
+            JitsiConferenceEvents.PARTICIPANT_CONN_STATUS_CHANGED,
+            (...args) => dispatch(participantConnectionStatusChanged(...args)));
+
     conference.on(
             JitsiConferenceEvents.USER_JOINED,
             (id, user) => dispatch(participantJoined({

react/features/base/participants/actions.js

 } from './actionTypes';
 import { getLocalParticipant } from './functions';
 
-/**
- * Action to update a participant's connection status.
- *
- * @param {string} id - Participant's ID.
- * @param {string} connectionStatus - The new connection status for the
- * participant.
- * @returns {{
- *     type: PARTICIPANT_UPDATED,
- *     participant: {
- *         id: string,
- *         connectionStatus: string
- *     }
- * }}
- */
-export function changeParticipantConnectionStatus(id, connectionStatus) {
-    return {
-        type: PARTICIPANT_UPDATED,
-        participant: {
-            id,
-            connectionStatus
-        }
-    };
-}
-
 /**
  * Create an action for when dominant speaker changes.
  *
     });
 }
 
+/**
+ * Action to update a participant's connection status.
+ *
+ * @param {string} id - Participant's ID.
+ * @param {string} connectionStatus - The new connection status of the
+ * participant.
+ * @returns {{
+ *     type: PARTICIPANT_UPDATED,
+ *     participant: {
+ *         connectionStatus: string,
+ *         id: string
+ *     }
+ * }}
+ */
+export function participantConnectionStatusChanged(id, connectionStatus) {
+    return {
+        type: PARTICIPANT_UPDATED,
+        participant: {
+            connectionStatus,
+            id
+        }
+    };
+}
+
 /**
  * Action to remove a local participant.
  *

react/features/base/participants/components/ParticipantView.native.js

         _avatar: React.PropTypes.string,
 
         /**
-         * The connection status for the participant. Its video will only be
-         * rendered if the connection status is 'active', otherwise the avatar
-         * will be rendered. If undefined, we have no indication, so the same
-         * course of action as 'active' is taken.
+         * The connection status of the participant. Her video will only be
+         * rendered if the connection status is 'active'; otherwise, the avatar
+         * will be rendered. If undefined, 'active' is presumed.
+         *
+         * @private
          */
         _connectionStatus: React.PropTypes.string,
 
         // updated only after videoTrack is rendered.
         const waitForVideoStarted = false;
         const renderVideo
-            = shouldRenderVideoTrack(videoTrack, waitForVideoStarted)
-                && (typeof connectionStatus === 'undefined'
-                    || connectionStatus
-                        === JitsiParticipantConnectionStatus.ACTIVE);
+            = (connectionStatus === JitsiParticipantConnectionStatus.ACTIVE)
+                && shouldRenderVideoTrack(videoTrack, waitForVideoStarted);
 
         // Is the avatar to be rendered?
         const renderAvatar = Boolean(!renderVideo && avatar);
         = getParticipantById(
             state['features/base/participants'],
             participantId);
+    let avatar;
+    let connectionStatus;
+
+    if (participant) {
+        avatar = getAvatarURL(participant);
+        connectionStatus = participant.connectionStatus;
+    }
 
     return {
-        _avatar: participant && getAvatarURL(participant),
-        _connectionStatus: participant && participant.connectionStatus,
+        _avatar: avatar,
+        _connectionStatus:
+            connectionStatus
+                || JitsiParticipantConnectionStatus.ACTIVE,
         _videoTrack:
             getTrackByMediaTypeAndParticipant(
                 state['features/base/tracks'],

react/features/base/participants/reducer.js

         const participant = action.participant; // eslint-disable-line no-shadow
         const {
             avatarURL,
+            connectionStatus,
             dominantSpeaker,
             email,
-            connectionStatus,
             local,
             pinned,
             role
         return {
             avatarID,
             avatarURL,
+            connectionStatus,
             dominantSpeaker: dominantSpeaker || false,
             email,
             id,
-            connectionStatus,
             local: local || false,
             name,
             pinned: pinned || false,