fix(video):Always show avatar if video is inactive

modules/UI/videolayout/LargeVideoManager.js

             // change the avatar url on large
             this.updateAvatar();
 
-            // If the user's connection is disrupted then the avatar will be
-            // displayed in case we have no video image cached. That is if
-            // there was a user switch (image is lost on stream detach) or if
-            // the video was not rendered, before the connection has failed.
-            const wasUsersImageCached
-                = !isUserSwitch && container.wasVideoRendered;
             const isVideoMuted = !stream || stream.isMuted();
             const participant = getParticipantById(APP.store.getState(), id);
             const connectionStatus = participant?.connectionStatus;
-            const isVideoRenderable
-                = !isVideoMuted
-                    && (APP.conference.isLocalId(id)
-                        || connectionStatus
-                                === JitsiParticipantConnectionStatus.ACTIVE
-                        || wasUsersImageCached);
+            const isVideoRenderable = !isVideoMuted
+                && (APP.conference.isLocalId(id) || connectionStatus === JitsiParticipantConnectionStatus.ACTIVE);
 
             const showAvatar
                 = isVideoContainer

modules/UI/videolayout/RemoteVideo.js

     }
 
     /**
-     * The remote video is considered "playable" once the can play event has been received. It will be allowed to
-     * display video also in {@link JitsiParticipantConnectionStatus.INTERRUPTED} if the video has received the canplay
-     * event and was not muted while not in ACTIVE state. This basically means that there is stalled video image cached
-     * that could be displayed. It's used to show "grey video image" in user's thumbnail when there are connectivity
-     * issues.
+     * The remote video is considered "playable" once the can play event has been received.
      *
      * @inheritdoc
      * @override
      */
     isVideoPlayable() {
         const participant = getParticipantById(APP.store.getState(), this.id);
-        const { connectionStatus, mutedWhileDisconnected } = participant || {};
+        const { connectionStatus } = participant || {};
 
-        return super.isVideoPlayable()
-            && this._canPlayEventReceived
-            && (connectionStatus === JitsiParticipantConnectionStatus.ACTIVE
-                || (connectionStatus === JitsiParticipantConnectionStatus.INTERRUPTED && !mutedWhileDisconnected));
+        return (
+            super.isVideoPlayable()
+                && this._canPlayEventReceived
+                && connectionStatus === JitsiParticipantConnectionStatus.ACTIVE
+        );
     }
 
     /**
      * @param {*} stream
      */
     waitForPlayback(streamElement, stream) {
+        $(streamElement).hide();
+
         const webRtcStream = stream.getOriginalStream();
         const isVideo = stream.isVideoTrack();
 
 
         const listener = () => {
             this._canPlayEventReceived = true;
-            this.VideoLayout.remoteVideoActive(streamElement, this.id);
+
+            logger.info(`${this.id} video is now active`, streamElement);
+            if (streamElement) {
+                $(streamElement).show();
+            }
+
             streamElement.removeEventListener('canplay', listener);
 
             // Refresh to show the video
         // Put new stream element always in front
         streamElement = UIUtils.prependChild(this.container, streamElement);
 
-        $(streamElement).hide();
-
         this.waitForPlayback(streamElement, stream);
         stream.attach(streamElement);
 

modules/UI/videolayout/SmallVideo.js

      */
     computeDisplayModeInput() {
         let isScreenSharing = false;
-        let connectionStatus, mutedWhileDisconnected;
+        let connectionStatus;
         const state = APP.store.getState();
         const participant = getParticipantById(state, this.id);
 
 
             isScreenSharing = typeof track !== 'undefined' && track.videoType === 'desktop';
             connectionStatus = participant.connectionStatus;
-            mutedWhileDisconnected = participant.mutedWhileDisconnected;
         }
 
         return {
             isVideoPlayable: this.isVideoPlayable(),
             hasVideo: Boolean(this.selectVideoElement().length),
             connectionStatus,
-            mutedWhileDisconnected,
             canPlayEventReceived: this._canPlayEventReceived,
             videoStream: Boolean(this.videoStream),
             isScreenSharing,

modules/UI/videolayout/VideoContainer.js

 
         this.$remotePresenceMessage = $('#remotePresenceMessage');
 
-        /**
-         * Indicates whether or not the video stream attached to the video
-         * element has started(which means that there is any image rendered
-         * even if the video is stalled).
-         * @type {boolean}
-         */
-        this.wasVideoRendered = false;
-
         this.$wrapper = $('#largeVideoWrapper');
 
         /**
          * video anyway.
          */
         this.$wrapperParent = this.$wrapper.parent();
-
         this.avatarHeight = $('#dominantSpeakerAvatarContainer').height();
-
-        const onPlayingCallback = function(event) {
+        this.$video[0].onplaying = function(event) {
             if (typeof resizeContainer === 'function') {
                 resizeContainer(event);
             }
-            this.wasVideoRendered = true;
-        }.bind(this);
-
-        this.$video[0].onplaying = onPlayingCallback;
+        };
 
         /**
          * A Set of functions to invoke when the video element resizes.
             return;
         }
 
-        // The stream has changed, so the image will be lost on detach
-        this.wasVideoRendered = false;
-
-
         // detach old stream
         if (this.stream) {
             this.stream.detach(this.$video[0]);

modules/UI/videolayout/VideoLayout.js

-/* global APP, $  */
+/* global APP  */
 
 import Logger from 'jitsi-meet-logger';
 
         remoteVideo.updateView();
     },
 
-    // FIXME: what does this do???
-    remoteVideoActive(videoElement, resourceJid) {
-        logger.info(`${resourceJid} video is now active`, videoElement);
-        if (videoElement) {
-            $(videoElement).show();
-        }
-        this._updateLargeVideoIfDisplayed(resourceJid, true);
-    },
-
     /**
      * On video muted event.
      */

react/features/base/participants/actions.js

 import {
     getLocalParticipant,
     getNormalizedDisplayName,
-    getParticipantDisplayName,
-    figureOutMutedWhileDisconnectedStatus
+    getParticipantDisplayName
 } from './functions';
 
 /**
  * }}
  */
 export function participantConnectionStatusChanged(id, connectionStatus) {
-    return (dispatch, getState) => {
-        dispatch({
-            type: PARTICIPANT_UPDATED,
-            participant: {
-                connectionStatus,
-                id,
-                mutedWhileDisconnected: figureOutMutedWhileDisconnectedStatus(getState(), id, connectionStatus)
-            }
-        });
+    return {
+        type: PARTICIPANT_UPDATED,
+        participant: {
+            connectionStatus,
+            id
+        }
     };
 }
 

react/features/base/participants/functions.js

 import { JitsiParticipantConnectionStatus } from '../lib-jitsi-meet';
 import { MEDIA_TYPE, shouldRenderVideoTrack } from '../media';
 import { toState } from '../redux';
-import { getTrackByMediaTypeAndParticipant, isRemoteTrackMuted } from '../tracks';
+import { getTrackByMediaTypeAndParticipant } from '../tracks';
 import { createDeferred } from '../util';
 
 import {
     return participantIsInLargeVideoWithScreen;
 }
 
-/**
- * Figures out the value of mutedWhileDisconnected status by taking into
- * account remote participant's network connectivity and video muted status.
- * The flag is set to <tt>true</tt> if remote participant's video gets muted
- * during his media connection disruption. This is to prevent black video
- * being render on the thumbnail, because even though once the video has
- * been played the image usually remains on the video element it seems that
- * after longer period of the video element being hidden this image can be
- * lost.
- *
- * @param {Object|Function} stateful - Object or function that can be resolved
- * to the Redux state.
- * @param {string} participantID - The ID of the participant.
- * @param {string} [connectionStatus] - A connection status to be used.
- * @returns {boolean} - The mutedWhileDisconnected value.
- */
-export function figureOutMutedWhileDisconnectedStatus(
-        stateful: Function | Object, participantID: string, connectionStatus: ?string) {
-    const state = toState(stateful);
-    const participant = getParticipantById(state, participantID);
-
-    if (!participant || participant.local) {
-        return undefined;
-    }
-
-    const isActive = (connectionStatus || participant.connectionStatus) === JitsiParticipantConnectionStatus.ACTIVE;
-    const isVideoMuted = isRemoteTrackMuted(state['features/base/tracks'], MEDIA_TYPE.VIDEO, participantID);
-    let mutedWhileDisconnected = participant.mutedWhileDisconnected || false;
-
-    if (!isActive && isVideoMuted) {
-        mutedWhileDisconnected = true;
-    } else if (isActive && !isVideoMuted) {
-        mutedWhileDisconnected = false;
-    }
-
-    return mutedWhileDisconnected;
-}
-
-
 /**
  * Resolves the first loadable avatar URL for a participant.
  *

react/features/base/participants/middleware.js

 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
 import { MiddlewareRegistry, StateListenerRegistry } from '../redux';
 import { playSound, registerSound, unregisterSound } from '../sounds';
-import { getTrackByJitsiTrack, TRACK_ADDED, TRACK_REMOVED, TRACK_UPDATED } from '../tracks';
 
 import {
     DOMINANT_SPEAKER_CHANGED,
     getLocalParticipant,
     getParticipantById,
     getParticipantCount,
-    getParticipantDisplayName,
-    figureOutMutedWhileDisconnectedStatus
+    getParticipantDisplayName
 } from './functions';
 import { PARTICIPANT_JOINED_FILE, PARTICIPANT_LEFT_FILE } from './sounds';
 
     case PARTICIPANT_UPDATED:
         return _participantJoinedOrUpdated(store, next, action);
 
-    case TRACK_ADDED:
-    case TRACK_REMOVED:
-    case TRACK_UPDATED:
-        return _trackChanged(store, next, action);
     }
 
     return next(action);
     dispatch(registerSound(PARTICIPANT_LEFT_SOUND_ID, PARTICIPANT_LEFT_FILE));
 }
 
-/**
- * Notifies the feature base/participants that the action there has been a change in the tracks of the participants.
- *
- * @param {Store} store - The redux store in which the specified {@code action} is being dispatched.
- * @param {Dispatch} next - The redux {@code dispatch} function to dispatch the specified {@code action} in the
- * specified {@code store}.
- * @param {Action} action - The redux action {@code PARTICIPANT_JOINED} or {@code PARTICIPANT_UPDATED} which is being
- * dispatched in the specified {@code store}.
- * @private
- * @returns {Object} The value returned by {@code next(action)}.
- */
-function _trackChanged({ dispatch, getState }, next, action) {
-    const { jitsiTrack } = action.track;
-    let track;
-
-    if (action.type === TRACK_REMOVED) {
-        track = getTrackByJitsiTrack(getState()['features/base/tracks'], jitsiTrack);
-    }
-
-    const result = next(action);
-
-    if (action.type !== TRACK_REMOVED) {
-        track = getTrackByJitsiTrack(getState()['features/base/tracks'], jitsiTrack);
-    }
-
-    if (typeof track === 'undefined' || track.local) {
-        return result;
-    }
-
-    const { participantId } = track;
-    const state = getState();
-    const participant = getParticipantById(state, participantId);
-
-    if (!participant) {
-        return result;
-    }
-
-    const mutedWhileDisconnected = figureOutMutedWhileDisconnectedStatus(state, participantId);
-
-    if (participant.mutedWhileDisconnected !== mutedWhileDisconnected) {
-        dispatch(participantUpdated({
-            id: participantId,
-            mutedWhileDisconnected
-        }));
-    }
-
-    return result;
-}
-
 /**
  * Unregisters sounds related with the participants feature.
  *

react/features/base/participants/reducer.js

         isJigasi,
         loadableAvatarUrl,
         local: local || false,
-        mutedWhileDisconnected: local ? undefined : false,
         name,
         pinned: pinned || false,
         presence,