fix(largeVideo-bg):render canvas only when visible

modules/UI/videolayout/VideoContainer.js

          */
         this._hideBackground = true;
 
+        this._isHidden = false;
+
         /**
          * Flag indicates whether or not the avatar is currently displayed.
          * @type {boolean}
                 FADE_DURATION_MS,
                 1,
                 () => {
+                    this._isHidden = false;
+                    this._updateBackground();
                     resolve();
                 }
             );
         return new Promise(resolve => {
             this.$wrapperParent.fadeTo(FADE_DURATION_MS, 0, () => {
                 this.$wrapperParent.css('visibility', 'hidden');
+                this._isHidden = true;
+                this._updateBackground();
                 resolve();
             });
         });
 
         ReactDOM.render(
             <LargeVideoBackground
-                hidden = { this._hideBackground }
+                hidden = { this._hideBackground || this._isHidden }
                 mirror = {
                     this.stream
                     && this.stream.isLocal()

react/features/large-video/components/LargeVideoBackground.web.js

 
 import React, { Component } from 'react';
 
+import { connect } from '../../base/redux';
+import { shouldDisplayTileView } from '../../video-layout';
+
 /**
  * Constants to describe the dimensions of the video. Landscape videos
  * are wider than they are taller and portrait videos are taller than they
  */
 type Props = {
 
+   /**
+     * Whether or not the layout should change to support tile view mode.
+     *
+     * @protected
+     * @type {boolean}
+     */
+    _shouldDisplayTileView: boolean,
+
     /**
      * Additional CSS class names to add to the root of the component.
      */
      * @returns {void}
      */
     componentDidMount() {
-        if (this.props.videoElement && !this.props.hidden) {
+        const { _shouldDisplayTileView, hidden, videoElement } = this.props;
+
+        if (videoElement && !hidden && !_shouldDisplayTileView) {
             this._updateCanvas();
             this._setUpdateCanvasInterval();
         }
      * @inheritdoc
      */
     componentDidUpdate(prevProps: Props) {
-        if (prevProps.hidden && !this.props.hidden) {
-            this._clearCanvas();
-            this._setUpdateCanvasInterval();
-        }
-
-        if ((!prevProps.hidden && this.props.hidden)
-            || !this.props.videoElement) {
-            this._clearCanvas();
-            this._clearUpdateCanvasInterval();
+        const wasCanvasUpdating = !prevProps.hidden && !prevProps._shouldDisplayTileView && prevProps.videoElement;
+        const shouldCanvasUpdating
+            = !this.props.hidden && !this.props._shouldDisplayTileView && this.props.videoElement;
+
+        if (wasCanvasUpdating !== shouldCanvasUpdating) {
+            if (shouldCanvasUpdating) {
+                this._clearCanvas();
+                this._setUpdateCanvasInterval();
+            } else {
+                this._clearCanvas();
+                this._clearUpdateCanvasInterval();
+            }
         }
     }
 
         }
     }
 }
+
+/**
+ * Maps (parts of) the Redux state to the associated LargeVideoBackground props.
+ *
+ * @param {Object} state - The Redux state.
+ * @private
+ * @returns {{
+ *     _shouldDisplayTileView: boolean
+ * }}
+ */
+function _mapStateToProps(state) {
+    return {
+        _shouldDisplayTileView: shouldDisplayTileView(state)
+    };
+}
+
+
+export default connect(_mapStateToProps)(LargeVideoBackground);
+