ref: one place for setting max recv frame height

Moves the logic from all different places into single state
listener to combine all inputs into a single output.

react/features/conference/middleware.js

 import {
     CONFERENCE_JOINED,
     KICKED_OUT,
-    VIDEO_QUALITY_LEVELS,
     conferenceLeft,
-    getCurrentConference,
-    setPreferredVideoQuality
+    getCurrentConference
 } from '../base/conference';
 import { hideDialog, isDialogOpen } from '../base/dialog';
 import { setActiveModalId } from '../base/modal';
         dispatch(setToolboxEnabled(!reducedUI));
         dispatch(setFilmstripEnabled(!reducedUI));
 
-        dispatch(
-            setPreferredVideoQuality(
-                reducedUI
-                    ? VIDEO_QUALITY_LEVELS.LOW
-                    : VIDEO_QUALITY_LEVELS.HIGH));
-
         break;
     }
 

react/features/filmstrip/actionTypes.js

  *
  * {
  *     type: SET_TILE_VIEW_DIMENSIONS,
- *     dimensions: Object
+ *     dimensions: {
+ *         gridDimensions: {
+ *             columns: number,
+ *             height: number,
+ *             visibleRows: number,
+ *             width: number
+ *         },
+ *         thumbnailSize: {
+ *             height: number,
+ *             width: number
+ *         },
+ *         filmstripWidth: number
+ *     }
  * }
  */
 export const SET_TILE_VIEW_DIMENSIONS = 'SET_TILE_VIEW_DIMENSIONS';

react/features/filmstrip/actions.native.js

 import {
     SET_FILMSTRIP_ENABLED,
     SET_FILMSTRIP_HOVERED,
-    SET_FILMSTRIP_VISIBLE
+    SET_FILMSTRIP_VISIBLE,
+    SET_TILE_VIEW_DIMENSIONS
 } from './actionTypes';
 
 /**
         visible
     };
 }
+
+/**
+ * Sets the dimensions of the tile view grid. The action is only partially implemented on native as not all
+ * of the values are currently used. Check the description of {@link SET_TILE_VIEW_DIMENSIONS} for the full set
+ * of properties.
+ *
+ * @param {Object} dimensions - The tile view dimensions.
+ * @param {Object} thumbnailSize - The size of an individual video thumbnail.
+ * @param {number} thumbnailSize.height - The height of an individual video thumbnail.
+ * @param {number} thumbnailSize.width - The width of an individual video thumbnail.
+ * @returns {{
+ *     type: SET_TILE_VIEW_DIMENSIONS,
+ *     dimensions: Object
+ * }}
+ */
+export function setTileViewDimensions({ thumbnailSize }: Object) {
+    return {
+        type: SET_TILE_VIEW_DIMENSIONS,
+        dimensions: {
+            thumbnailSize
+        }
+    };
+}

react/features/filmstrip/components/native/TileView.js

 } from 'react-native';
 import type { Dispatch } from 'redux';
 
-import {
-    getNearestReceiverVideoQualityLevel,
-    setMaxReceiverVideoQuality
-} from '../../../base/conference';
 import { connect } from '../../../base/redux';
 import { ASPECT_RATIO_NARROW } from '../../../base/responsive-ui/constants';
+import { setTileViewDimensions } from '../../actions';
 
 import Thumbnail from './Thumbnail';
 import styles from './styles';
      * @returns {void}
      */
     _updateReceiverQuality() {
-        const { height } = this._getTileDimensions();
-        const qualityLevel = getNearestReceiverVideoQualityLevel(height);
+        const { height, width } = this._getTileDimensions();
 
-        this.props.dispatch(setMaxReceiverVideoQuality(qualityLevel));
+        this.props.dispatch(setTileViewDimensions({
+            thumbnailSize: {
+                height,
+                width
+            }
+        }));
     }
 }
 

react/features/filmstrip/middleware.web.js

 // @flow
 
 import Filmstrip from '../../../modules/UI/videolayout/Filmstrip';
-import { getNearestReceiverVideoQualityLevel, setMaxReceiverVideoQuality } from '../base/conference';
 import { MiddlewareRegistry } from '../base/redux';
 import { CLIENT_RESIZED } from '../base/responsive-ui';
 import {
 
         if (shouldDisplayTileView(state)) {
             const { width, height } = state['features/filmstrip'].tileViewDimensions.thumbnailSize;
-            const qualityLevel = getNearestReceiverVideoQualityLevel(height);
-
-            store.dispatch(setMaxReceiverVideoQuality(qualityLevel));
 
             // Once the thumbnails are reactified this should be moved there too.
             Filmstrip.resizeThumbnailsForTileView(width, height, true);

react/features/video-layout/subscriber.js

 
 import debounce from 'lodash/debounce';
 
-import {
-    VIDEO_QUALITY_LEVELS,
-    setMaxReceiverVideoQuality
-} from '../base/conference';
 import {
     getPinnedParticipant,
     pinParticipant
         dispatch(selectParticipant());
 
         if (!displayTileView) {
-            dispatch(setMaxReceiverVideoQuality(VIDEO_QUALITY_LEVELS.HIGH));
-
             if (_getAutoPinSetting()) {
                 _updateAutoPinnedParticipant(store);
             }

react/features/video-quality/middleware.js

 // @flow
 
-import { CONFERENCE_JOINED } from '../base/conference/actionTypes';
-import { setPreferredVideoQuality } from '../base/conference/actions';
-import { MiddlewareRegistry } from '../base/redux';
+import {
+    CONFERENCE_JOINED,
+    VIDEO_QUALITY_LEVELS,
+    getNearestReceiverVideoQualityLevel,
+    setMaxReceiverVideoQuality,
+    setPreferredVideoQuality
+} from '../base/conference';
+import { MiddlewareRegistry, StateListenerRegistry } from '../base/redux';
+import { shouldDisplayTileView } from '../video-layout';
 
 import logger from './logger';
 
 
     return result;
 });
+
+/**
+ * Implements a state listener in order to calculate max receiver video quality.
+ */
+StateListenerRegistry.register(
+    /* selector */ state => {
+        const { reducedUI } = state['features/base/responsive-ui'];
+        const _shouldDisplayTileView = shouldDisplayTileView(state);
+        const thumbnailSize = state['features/filmstrip']?.tileViewDimensions?.thumbnailSize;
+
+        return {
+            displayTileView: _shouldDisplayTileView,
+            reducedUI,
+            thumbnailHeight: thumbnailSize?.height
+        };
+    },
+    /* listener */ ({ displayTileView, reducedUI, thumbnailHeight }, { dispatch, getState }) => {
+        const { maxReceiverVideoQuality } = getState()['features/base/conference'];
+        let newMaxRecvVideoQuality = VIDEO_QUALITY_LEVELS.HIGH;
+
+        if (reducedUI) {
+            newMaxRecvVideoQuality = VIDEO_QUALITY_LEVELS.LOW;
+        } else if (displayTileView && !Number.isNaN(thumbnailHeight)) {
+            newMaxRecvVideoQuality = getNearestReceiverVideoQualityLevel(thumbnailHeight);
+        }
+
+        if (maxReceiverVideoQuality !== newMaxRecvVideoQuality) {
+            dispatch(setMaxReceiverVideoQuality(newMaxRecvVideoQuality));
+        }
+    }, {
+        deepEquals: true
+    });