Merge pull request #3584 from virtuacoplenny/lenny/update-lifecycles-1

Remove some usages of deprecated lifecycle methods

android/sdk/src/main/java/org/jitsi/meet/sdk/JitsiMeetView.java

         // the respective conference again if the first invocation was followed
         // by leaving the conference. However, React and, respectively,
         // appProperties/initialProperties are declarative expressions i.e. one
-        // and the same URL will not trigger componentWillReceiveProps in the
+        // and the same URL will not trigger an automatic re-render in the
         // JavaScript source code. The workaround implemented bellow introduces
         // imperativeness in React Component props by defining a unique value
         // per loadURLObject: invocation.

ios/sdk/src/JitsiMeetView.m

     // conference again if the first invocation was followed by leaving the
     // conference. However, React and, respectively,
     // appProperties/initialProperties are declarative expressions i.e. one and
-    // the same URL will not trigger componentWillReceiveProps in the JavaScript
+    // the same URL will not trigger an automatic re-render in the JavaScript
     // source code. The workaround implemented bellow introduces imperativeness
     // in React Component props by defining a unique value per loadURLObject:
     // invocation.

react/features/always-on-top/AlwaysOnTop.js

         this._hideToolbarAfterTimeout();
     }
 
+    /**
+     * Sets a timeout to hide the toolbar when the toolbar is shown.
+     *
+     * @inheritdoc
+     * @returns {void}
+     */
+    componentDidUpdate(prevProps: *, prevState: State) {
+        if (!prevState.visible && this.state.visible) {
+            this._hideToolbarAfterTimeout();
+        }
+    }
+
     /**
      * Removes all listeners.
      *
         window.removeEventListener('mousemove', this._mouseMove);
     }
 
-    /**
-     * Sets a timeout to hide the toolbar when the toolbar is shown.
-     *
-     * @inheritdoc
-     * @returns {void}
-     */
-    componentWillUpdate(nextProps: *, nextState: State) {
-        if (!this.state.visible && nextState.visible) {
-            this._hideToolbarAfterTimeout();
-        }
-    }
-
     /**
      * Implements React's {@link Component#render()}.
      *

react/features/base/dialog/components/AbstractDialog.js

     }
 
     /**
-     * Implements React's {@link Component#componentWillMount()}. Invoked
+     * Implements React's {@link Component#componentDidMount()}. Invoked
      * immediately before mounting occurs.
      *
      * @inheritdoc
      */
-    componentWillMount() {
+    componentDidMount() {
         this._mounted = true;
     }
 

react/features/base/dialog/components/StatelessDialog.web.js

         this._onDialogDismissed = this._onDialogDismissed.bind(this);
         this._onKeyDown = this._onKeyDown.bind(this);
         this._onSubmit = this._onSubmit.bind(this);
+        this._renderFooter = this._renderFooter.bind(this);
         this._setDialogElement = this._setDialogElement.bind(this);
-
-        this._Footer = this._createFooterConstructor(props);
-    }
-
-    /**
-     * React Component method that executes before the component is updated.
-     *
-     * @inheritdoc
-     * @param {Object} nextProps - The next properties, before the update.
-     * @returns {void}
-     */
-    componentWillUpdate(nextProps) {
-        // If button states have changed, update the Footer constructor function
-        // so buttons of the proper state are rendered.
-        if (nextProps.okDisabled !== this.props.okDisabled
-                || nextProps.cancelDisabled !== this.props.cancelDisabled
-                || nextProps.submitDisabled !== this.props.submitDisabled) {
-            this._Footer = this._createFooterConstructor(nextProps);
-        }
     }
 
     /**
         return (
             <Modal
                 autoFocus = { true }
-                footer = { this._Footer }
+                footer = { this._renderFooter }
                 heading = { titleString || t(titleKey) }
                 i18n = { this.props.i18n }
                 onClose = { this._onDialogDismissed }
         );
     }
 
-    _onCancel: () => Function;
+    _renderFooter: () => React$Node;
 
     /**
-     * Returns a functional component to be used for the modal footer.
+     * Returns a ReactElement to display buttons for closing the modal.
      *
-     * @param {Object} options - The configuration for how the buttons in the
-     * footer should display. Essentially {@code StatelessDialog} props should
-     * be passed in.
+     * @param {Object} propsFromModalFooter - The props passed in from the
+     * {@link ModalFooter} component.
      * @private
      * @returns {ReactElement}
      */
-    _createFooterConstructor(options) {
+    _renderFooter(propsFromModalFooter) {
         // Filter out falsy (null) values because {@code ButtonGroup} will error
         // if passed in anything but buttons with valid type props.
         const buttons = [
-            this._renderOKButton(options),
-            this._renderCancelButton(options)
+            this._renderOKButton(),
+            this._renderCancelButton()
         ].filter(Boolean);
 
-        return function Footer(modalFooterProps) {
-            return (
-                <ModalFooter showKeyline = { modalFooterProps.showKeyline } >
-                    {
-
-                        /**
-                         * Atlaskit has this empty span (JustifySim) so...
-                         */
-                    }
-                    <span />
-                    <ButtonGroup>
-                        { buttons }
-                    </ButtonGroup>
-                </ModalFooter>
-            );
-        };
+        return (
+            <ModalFooter showKeyline = { propsFromModalFooter.showKeyline } >
+                {
+
+                    /**
+                     * Atlaskit has this empty span (JustifySim) so...
+                     */
+                }
+                <span />
+                <ButtonGroup>
+                    { buttons }
+                </ButtonGroup>
+            </ModalFooter>
+        );
     }
 
     _onCancel: () => void;
     /**
      * Renders Cancel button.
      *
-     * @param {Object} options - The configuration for the Cancel button.
-     * @param {boolean} options.cancelDisabled - True if the cancel button
-     * should not be rendered.
-     * @param {string} options.cancelTitleKey - The translation key to use as
-     * text on the button.
-     * @param {boolean} options.isModal - True if the cancel button should not
-     * be rendered.
      * @private
      * @returns {ReactElement|null} The Cancel button if enabled and dialog is
      * not modal.
      */
-    _renderCancelButton(options = {}) {
-        if (options.cancelDisabled
-                || options.isModal
-                || options.hideCancelButton) {
+    _renderCancelButton() {
+        if (this.props.cancelDisabled
+            || this.props.isModal
+            || this.props.hideCancelButton) {
             return null;
         }
 
                 key = 'cancel'
                 onClick = { this._onCancel }
                 type = 'button'>
-                { t(options.cancelTitleKey || 'dialog.Cancel') }
+                { t(this.props.cancelTitleKey || 'dialog.Cancel') }
             </Button>
         );
     }
     /**
      * Renders OK button.
      *
-     * @param {Object} options - The configuration for the OK button.
-     * @param {boolean} options.okDisabled - True if the button should display
-     * as disabled and clicking should have no effect.
-     * @param {string} options.okTitleKey - The translation key to use as text
-     * on the button.
-     * @param {boolean} options.submitDisabled - True if the button should not
-     * be rendered.
      * @private
      * @returns {ReactElement|null} The OK button if enabled.
      */
-    _renderOKButton(options = {}) {
-        if (options.submitDisabled) {
+    _renderOKButton() {
+        if (this.props.submitDisabled) {
             return null;
         }
 
                 appearance = 'primary'
                 form = 'modal-dialog-form'
                 id = { OK_BUTTON_ID }
-                isDisabled = { options.okDisabled }
+                isDisabled = { this.props.okDisabled }
                 key = 'submit'
                 onClick = { this._onSubmit }
                 type = 'button'>
-                { t(options.okTitleKey || 'dialog.Ok') }
+                { t(this.props.okTitleKey || 'dialog.Ok') }
             </Button>
         );
     }

react/features/base/label/components/CircularLabel.native.js

         this.state = {
             pulseAnimation: new Animated.Value(0)
         };
+    }
 
-        this._maybeToggleAnimation({}, props);
+    /**
+     * Implements {@code Component#componentDidMount}.
+     *
+     * @inheritdoc
+     */
+    componentDidMount() {
+        this._maybeToggleAnimation({}, this.props);
     }
 
     /**
-     * Implements {@code Component#componentWillReceiveProps}.
+     * Implements {@code Component#componentDidUpdate}.
      *
      * @inheritdoc
      */
-    componentWillReceiveProps(newProps: Props) {
-        this._maybeToggleAnimation(this.props, newProps);
+    componentDidUpdate(prevProps: Props) {
+        this._maybeToggleAnimation(prevProps, this.props);
     }
 
     /**

react/features/base/react/components/native/SideBar.js

 // @flow
 
-import React, { Component, type Node } from 'react';
+import React, { PureComponent, type Node } from 'react';
 import { Animated, TouchableWithoutFeedback, View } from 'react-native';
 
 import styles, { SIDEBAR_WIDTH } from './styles';
 /**
  * A generic animated side bar to be used for left-side, hamburger-style menus.
  */
-export default class SideBar extends Component<Props, State> {
+export default class SideBar extends PureComponent<Props, State> {
+    /**
+     * Implements React's {@link Component#getDerivedStateFromProps()}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props: Props, prevState: State) {
+        return {
+            showOverlay: props.show || prevState.showOverlay
+        };
+    }
+
     /**
      * Initializes a new {@code SideBar} instance.
      *
     }
 
     /**
-     * Implements React's {@link Component#componentWillReceiveProps()}.
+     * Implements React's {@link Component#componentDidUpdate()}.
      *
      * @inheritdoc
      */
-    componentWillReceiveProps({ show }: Props) {
-        (show === this.props.show) || this._setShow(show);
+    componentDidUpdate() {
+        this._setShow(this.props.show);
     }
 
     /**
      * @returns {void}
      */
     _setShow(show) {
-        show && this.setState({ showOverlay: true });
-
         Animated
             .timing(
                 /* value */ this.state.sliderAnimation,

react/features/base/toolbox/components/AbstractButton.js

         return buttonStyles;
     }
 
+    /**
+     * Get the tooltip to display when hovering over the button.
+     *
+     * @private
+     * @returns {string}
+     */
+    _getTooltip() {
+        return this.tooltip || '';
+    }
+
     /**
      * Helper function to be implemented by subclasses, which must return a
      * boolean value indicating if this button is disabled or not.
             iconName: this._getIconName(),
             label: this._getLabel(),
             styles: this._getStyles(),
-            tooltip: this.tooltip
+            tooltip: this._getTooltip()
         };
 
         return (

react/features/deep-linking/components/DeepLinkingMobilePage.web.js

     constructor(props: Props) {
         super(props);
 
+        this.state = {
+            joinURL: generateDeepLinkingURL()
+        };
+
         // Bind event handlers so they are only bound once per instance.
         this._onDownloadApp = this._onDownloadApp.bind(this);
         this._onOpenApp = this._onOpenApp.bind(this);
     }
 
-    /**
-     * Initializes the text and URL of the `Start a conference` / `Join the
-     * conversation` button which takes the user to the mobile app.
-     *
-     * @inheritdoc
-     */
-    componentWillMount() {
-        this.setState({
-            joinURL: generateDeepLinkingURL()
-        });
-    }
-
     /**
      * Implements the Component's componentDidMount method.
      *

react/features/desktop-picker/components/DesktopPicker.js

 // @flow
 
 import Tabs from '@atlaskit/tabs';
-import React, { Component } from 'react';
+import React, { PureComponent } from 'react';
 import { connect } from 'react-redux';
 
 import { Dialog, hideDialog } from '../../base/dialog';
     types: Array<string>
 };
 
+
 /**
  * React component for DesktopPicker.
  *
  * @extends Component
  */
-class DesktopPicker extends Component<Props, State> {
+class DesktopPicker extends PureComponent<Props, State> {
+    /**
+     * Implements React's {@link Component#getDerivedStateFromProps()}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props) {
+        return {
+            types: DesktopPicker._getValidTypes(props.desktopSharingSources)
+        };
+    }
+
+    /**
+     * Extracts only the valid types from the passed {@code types}.
+     *
+     * @param {Array<string>} types - The types to filter.
+     * @private
+     * @returns {Array<string>} The filtered types.
+     */
+    static _getValidTypes(types = []) {
+        return types.filter(
+            type => VALID_TYPES.includes(type));
+    }
+
     _poller = null;
 
     state = {
         this._updateSources = this._updateSources.bind(this);
 
         this.state.types
-            = this._getValidTypes(this.props.desktopSharingSources);
+            = DesktopPicker._getValidTypes(this.props.desktopSharingSources);
     }
 
     /**
         this._startPolling();
     }
 
-    /**
-     * Notifies this mounted React Component that it will receive new props.
-     * Sets a default selected source if one is not already set.
-     *
-     * @inheritdoc
-     * @param {Object} nextProps - The read-only React Component props that this
-     * instance will receive.
-     * @returns {void}
-     */
-    componentWillReceiveProps(nextProps: Props) {
-        const { desktopSharingSources } = nextProps;
-
-        /**
-         * Do only reference check in order to not calculate the types on every
-         * update. This is enough for our use case and we don't need value
-         * checking because if the value is the same we won't change the
-         * reference for the desktopSharingSources array.
-         */
-        if (desktopSharingSources !== this.props.desktopSharingSources) {
-            this.setState({
-                types: this._getValidTypes(desktopSharingSources)
-            });
-        }
-    }
-
     /**
      * Clean up component and DesktopCapturerSource store state.
      *
         return selectedSource;
     }
 
-    /**
-     * Extracts only the valid types from the passed {@code types}.
-     *
-     * @param {Array<string>} types - The types to filter.
-     * @returns {Array<string>} The filtered types.
-     */
-    _getValidTypes(types = []) {
-        return types.filter(
-            type => VALID_TYPES.includes(type));
-    }
-
     _onCloseModal: (?string, string) => void;
 
     /**

react/features/device-selection/components/AudioInputPreview.js

      * @inheritdoc
      * @returns {void}
      */
-    componentWillReceiveProps(nextProps: Props) {
-        if (nextProps.track !== this.props.track) {
-            this._listenForAudioUpdates(nextProps.track);
+    componentDidUpdate(prevProps: Props) {
+        if (prevProps.track !== this.props.track) {
+            this._listenForAudioUpdates(this.props.track);
             this._updateAudioLevel(0);
         }
     }

react/features/device-selection/components/DeviceSelection.js

     }
 
     /**
-     * Checks if audio / video permissions were granted.
+     * Checks if audio / video permissions were granted. Updates audio input and
+     * video input previews.
      *
      * @param {Object} prevProps - Previous props this component received.
      * @param {Object} prevState - Previous state this component had.
                 });
             });
         }
-    }
-
-    /**
-     * Updates audio input and video input previews.
-     *
-     * @inheritdoc
-     * @param {Object} nextProps - The read-only props which this Component will
-     * receive.
-     * @returns {void}
-     */
-    componentWillReceiveProps(nextProps: Object) {
-        const { selectedAudioInputId, selectedVideoInputId } = this.props;
 
-        if (selectedAudioInputId !== nextProps.selectedAudioInputId) {
-            this._createAudioInputTrack(nextProps.selectedAudioInputId);
+        if (prevProps.selectedAudioInputId
+            !== this.props.selectedAudioInputId) {
+            this._createAudioInputTrack(this.props.selectedAudioInputId);
         }
 
-        if (selectedVideoInputId !== nextProps.selectedVideoInputId) {
-            this._createVideoInputTrack(nextProps.selectedVideoInputId);
+        if (prevProps.selectedVideoInputId
+            !== this.props.selectedVideoInputId) {
+            this._createVideoInputTrack(this.props.selectedVideoInputId);
         }
     }
 

react/features/invite/components/InfoDialogButton.web.js

  */
 type State = {
 
+    /**
+     * Cache the conference connection state to derive when transitioning from
+     * not joined to join, in order to auto-show the InfoDialog.
+     */
+    hasConnectedToConference: boolean,
+
     /**
      * Whether or not {@code InfoDialog} should be visible.
      */
  * @extends Component
  */
 class InfoDialogButton extends Component<Props, State> {
+    /**
+     * Implements React's {@link Component#getDerivedStateFromProps()}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props, state) {
+        return {
+            hasConnectedToConference: props._isConferenceJoined,
+            showDialog: (props._toolboxVisible && state.showDialog)
+                || (!state.hasConnectedToConference
+                    && props._isConferenceJoined
+                    && props._participantCount < 2
+                    && props._toolboxVisible
+                    && !props._disableAutoShow)
+        };
+    }
+
     /**
      * Initializes new {@code InfoDialogButton} instance.
      *
         super(props);
 
         this.state = {
+            hasConnectedToConference: props._isConferenceJoined,
             showDialog: false
         };
 
         }
     }
 
-    /**
-     * Update the visibility of the {@code InfoDialog}.
-     *
-     * @inheritdoc
-     */
-    componentWillReceiveProps(nextProps) {
-        // Ensure the dialog is closed when the toolbox becomes hidden.
-        if (this.state.showDialog && !nextProps._toolboxVisible) {
-            this._onDialogClose();
-
-            return;
-        }
-
-        this._maybeAutoShowDialog(nextProps);
-    }
-
     /**
      * Implements React's {@link Component#render()}.
      *
         );
     }
 
-    /**
-     * Invoked to trigger display of the {@code InfoDialog} if certain
-     * conditions are met.
-     *
-     * @param {Object} nextProps - The future properties of this component.
-     * @private
-     * @returns {void}
-     */
-    _maybeAutoShowDialog(nextProps) {
-        if (!this.props._isConferenceJoined
-            && nextProps._isConferenceJoined
-            && nextProps._participantCount < 2
-            && nextProps._toolboxVisible
-            && !nextProps._disableAutoShow) {
-            this.setState({ showDialog: true });
-        }
-    }
-
     _onDialogClose: () => void;
 
     /**

react/features/invite/components/info-dialog/InfoDialog.web.js

 class InfoDialog extends Component<Props, State> {
     _copyElement: ?Object;
 
+    /**
+     * Implements React's {@link Component#getDerivedStateFromProps()}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props, state) {
+        let phoneNumber = state.phoneNumber;
+
+        if (!state.phoneNumber && props.dialIn.numbers) {
+            const { defaultCountry, numbers } = props.dialIn;
+
+            phoneNumber = _getDefaultPhoneNumber(numbers, defaultCountry);
+        }
+
+        return {
+            // Exit edit mode when a password is set locally or remotely.
+            passwordEditEnabled: state.passwordEditEnabled && props._password
+                ? false : state.passwordEditEnabled,
+            phoneNumber
+        };
+    }
+
     /**
      * {@code InfoDialog} component's local state.
      *
         this._setCopyElement = this._setCopyElement.bind(this);
     }
 
-    /**
-     * Implements React's {@link Component#componentWillReceiveProps()}. Invoked
-     * before this mounted component receives new props.
-     *
-     * @inheritdoc
-     * @param {Props} nextProps - New props component will receive.
-     */
-    componentWillReceiveProps(nextProps) {
-        if (!this.props._password && nextProps._password) {
-            this.setState({ passwordEditEnabled: false });
-        }
-
-        if (!this.state.phoneNumber && nextProps.dialIn.numbers) {
-            const { defaultCountry, numbers } = nextProps.dialIn;
-
-            this.setState({
-                phoneNumber:
-                    _getDefaultPhoneNumber(numbers, defaultCountry)
-            });
-        }
-    }
-
     /**
      * Implements React's {@link Component#render()}.
      *

react/features/invite/components/info-dialog/PasswordForm.web.js

  * @extends Component
  */
 class PasswordForm extends Component<Props, State> {
+    /**
+     * Implements React's {@link Component#getDerivedStateFromProps()}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props, state) {
+        return {
+            enteredPassword: props.editEnabled ? state.enteredPassword : ''
+        };
+    }
+
     state = {
         enteredPassword: ''
     };
         this._onPasswordSubmit = this._onPasswordSubmit.bind(this);
     }
 
-    /**
-     * Implements React's {@link Component#componentWillReceiveProps()}. Invoked
-     * before this mounted component receives new props.
-     *
-     * @inheritdoc
-     * @param {Props} nextProps - New props component will receive.
-     */
-    componentWillReceiveProps(nextProps: Props) {
-        if (this.props.editEnabled && !nextProps.editEnabled) {
-            this.setState({ enteredPassword: '' });
-        }
-    }
-
     /**
      * Implements React's {@link Component#render()}.
      *
     }
 }
 
-
 export default translate(PasswordForm);

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

  * @extends Component
  */
 class Labels extends AbstractLabels<Props, State> {
+    /**
+     * Updates the state for whether or not the filmstrip is transitioning to
+     * a displayed state.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props, prevState) {
+        return {
+            filmstripBecomingVisible: !prevState.filmstripBecomingVisible
+                && props._filmstripVisible
+        };
+    }
+
     /**
      * Initializes a new {@code Labels} instance.
      *
         };
     }
 
-    /**
-     * Updates the state for whether or not the filmstrip is being toggled to
-     * display after having being hidden.
-     *
-     * @inheritdoc
-     * @param {Object} nextProps - The read-only props which this Component will
-     * receive.
-     * @returns {void}
-     */
-    componentWillReceiveProps(nextProps) {
-        this.setState({
-            filmstripBecomingVisible: nextProps._filmstripVisible
-                && !this.props._filmstripVisible
-        });
-    }
-
     /**
      * Implements React's {@link Component#render()}.
      *

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

      * Starts or stops the interval to update the image displayed in the canvas.
      *
      * @inheritdoc
-     * @param {Object} nextProps - The read-only React {@code Component} props
-     * with which the new instance is to be initialized.
      */
-    componentWillReceiveProps(nextProps: Props) {
-        if (this.props.hidden && !nextProps.hidden) {
+    componentDidUpdate(prevProps: Props) {
+        if (prevProps.hidden && !this.props.hidden) {
             this._clearCanvas();
             this._setUpdateCanvasInterval();
         }
 
-        if ((!this.props.hidden && nextProps.hidden)
-            || !nextProps.videoElement) {
+        if ((!prevProps.hidden && this.props.hidden)
+            || !this.props.videoElement) {
             this._clearCanvas();
             this._clearUpdateCanvasInterval();
         }

react/features/mobile/audio-mode/components/AudioRoutePickerDialog.js

     state = {
         /**
          * Available audio devices, it will be set in
-         * {@link #componentWillMount()}.
+         * {@link #componentDidMount()}.
          */
         devices: []
     };
      *
      * @inheritdoc
      */
-    componentWillMount() {
+    componentDidMount() {
         AudioMode.getAudioDevices().then(({ devices, selected }) => {
             const audioDevices = [];
 

react/features/recording/components/AbstractRecordingLabel.js

  */
 export default class AbstractRecordingLabel
     extends Component<Props, State> {
+    /**
+     * Implements {@code Component#getDerivedStateFromProps}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props: Props, prevState: State) {
+        return {
+            staleLabel: props._status !== JitsiRecordingConstants.status.OFF
+                && prevState.staleLabel ? false : prevState.staleLabel
+        };
+    }
+
     /**
      * Initializes a new {@code AbstractRecordingLabel} component.
      *
     }
 
     /**
-     * Implements {@code Component#componentWillReceiveProps}.
+     * Implements {@code Component#componentDidUpdate}.
      *
      * @inheritdoc
      */
-    componentWillReceiveProps(newProps: Props) {
-        this._updateStaleStatus(this.props, newProps);
+    componentDidUpdate(prevProps: Props) {
+        this._updateStaleStatus(prevProps, this.props);
     }
 
     /**
                     }
                 }, STALE_TIMEOUT);
             }
-        } else if (this.state.staleLabel) {
-            this.setState({
-                staleLabel: false
-            });
         }
     }
-
 }
 
 /**

react/features/recording/components/LiveStream/AbstractStreamKeyForm.js

     value: string
 };
 
-/**
- * The state of the component.
- */
-type State = {
-
-    /**
-     * The value entered in the field.
-     */
-    value: string
-}
-
 /**
  * An abstract React Component for entering a key for starting a YouTube live
  * stream.
  *
  * @extends Component
  */
-export default class AbstractStreamKeyForm extends Component<Props, State> {
+export default class AbstractStreamKeyForm extends Component<Props> {
     helpURL: string;
 
     /**
     constructor(props: Props) {
         super(props);
 
-        this.state = {
-            value: props.value
-        };
-
         this.helpURL = (typeof interfaceConfig !== 'undefined'
             && interfaceConfig.LIVE_STREAMING_HELP_LINK)
             || LIVE_STREAMING_HELP_LINK;
         this._onInputChange = this._onInputChange.bind(this);
     }
 
-    /**
-     * Implements {@code Component}'s componentWillReceiveProps.
-     *
-     * @inheritdoc
-     */
-    componentWillReceiveProps(newProps: Props) {
-        this.setState({
-            value: newProps.value
-        });
-    }
-
     _onInputChange: Object => void
 
     /**
     _onInputChange(change) {
         const value = typeof change === 'object' ? change.target.value : change;
 
-        this.setState({
-            value
-        });
         this.props.onChange(value);
     }
 }

react/features/recording/components/LiveStream/native/StreamKeyForm.js

                     onChangeText = { this._onInputChange }
                     placeholder = { t('liveStreaming.enterStreamKey') }
                     style = { styles.streamKeyInput }
-                    value = { this.state.value } />
+                    value = { this.props.value } />
                 <TouchableOpacity
                     onPress = { this._onOpenHelp }
                     style = { styles.streamKeyHelp } >

react/features/recording/components/LiveStream/web/LiveStreamButton.js

     iconName = 'icon-public';
     toggledIconName = 'icon-public';
 
-    /**
-     * Constructor of the component.
-     *
-     * @inheritdoc
-     */
-    constructor(props: Props) {
-        super(props);
-
-        this.tooltip = props._liveStreamDisabledTooltipKey;
-    }
-
-    /**
-     * Implements {@code Component}'s componentWillReceiveProps.
-     *
-     * @inheritdoc
-     */
-    componentWillReceiveProps(newProps: Props) {
-        this.tooltip = newProps._liveStreamDisabledTooltipKey;
-    }
-
     /**
      * Helper function to be implemented by subclasses, which returns
      * a React Element to display (a beta tag) at the end of the button.
         );
     }
 
+    /**
+     * Returns the tooltip that should be displayed when the button is disabled.
+     *
+     * @private
+     * @returns {string}
+     */
+    _getTooltip() {
+        return this.props._liveStreamDisabledTooltipKey || '';
+    }
+
     /**
      * Helper function to be implemented by subclasses, which must return a
      * boolean value indicating if this button is disabled or not.

react/features/recording/components/LiveStream/web/StreamKeyForm.js

                     placeholder = { t('liveStreaming.enterStreamKey') }
                     shouldFitContainer = { true }
                     type = 'text'
-                    value = { this.state.value } />
+                    value = { this.props.value } />
                 { this.helpURL
                     ? <div className = 'form-footer'>
                         <a

react/features/recording/components/Recording/web/RecordButton.js

     toggledIconName = 'icon-camera-take-picture';
 
     /**
-     * Constructor of the component.
+     * Returns the tooltip that should be displayed when the button is disabled.
      *
-     * @inheritdoc
+     * @private
+     * @returns {string}
      */
-    constructor(props: Props) {
-        super(props);
-
-        this.tooltip = props._fileRecordingsDisabledTooltipKey;
-    }
-
-    /**
-     * Implements {@code Component}'s componentWillReceiveProps.
-     *
-     * @inheritdoc
-     */
-    componentWillReceiveProps(newProps: Props) {
-        this.tooltip = newProps._fileRecordingsDisabledTooltipKey;
+    _getTooltip() {
+        return this.tooltip || '';
     }
 
     /**

react/features/speaker-stats/components/SpeakerStats.js

 declare var interfaceConfig: Object;
 
 /**
- * The type of the React {@code Component} props of {@link SpeakerStats}
+ * The type of the React {@code Component} props of {@link SpeakerStats}.
  */
 type Props = {
 
 };
 
 /**
- * The type of the React {@code Component} state of {@link SpeakerStats}
+ * The type of the React {@code Component} state of {@link SpeakerStats}.
  */
 type State = {
 
  * @extends Component
  */
 class SpeakerStats extends Component<Props, State> {
-    state = {
-        stats: {}
-    };
-
     _updateInterval: IntervalID;
 
     /**
     constructor(props) {
         super(props);
 
+        this.state = {
+            stats: this.props.conference.getSpeakerStats()
+        };
+
         // Bind event handlers so they are only bound once per instance.
         this._updateStats = this._updateStats.bind(this);
     }
 
     /**
-     * Immediately request for updated speaker stats and begin
-     * polling for speaker stats updates.
+     * Begin polling for speaker stats updates.
      *
      * @inheritdoc
-     * @returns {void}
      */
-    componentWillMount() {
-        this._updateStats();
+    componentDidMount() {
         this._updateInterval = setInterval(this._updateStats, 1000);
     }
 

react/features/toolbox/components/web/Toolbox.js

      *
      * @inheritdoc
      */
-    componentWillReceiveProps(nextProps) {
+    componentDidUpdate(prevProps) {
         // Ensure the dialog is closed when the toolbox becomes hidden.
-        if (this.props._overflowMenuVisible && !nextProps._visible) {
+        if (prevProps._overflowMenuVisible && !this.props._visible) {
             this._onSetOverflowVisible(false);
         }
 
-        if (this.props._overflowMenuVisible
-            && !this.props._dialog
-            && nextProps._dialog) {
+        if (prevProps._overflowMenuVisible
+            && !prevProps._dialog
+            && this.props._dialog) {
             this._onSetOverflowVisible(false);
             this.props.dispatch(setToolbarHovered(false));
         }

react/features/welcome/components/AbstractWelcomePage.js

 export class AbstractWelcomePage extends Component<Props, *> {
     _mounted: ?boolean;
 
+    /**
+     * Implements React's {@link Component#getDerivedStateFromProps()}.
+     *
+     * @inheritdoc
+     */
+    static getDerivedStateFromProps(props: Props, state: Object) {
+        return {
+            room: props._room || state.room
+        };
+    }
+
     /**
      * Save room name into component's local state.
      *
     }
 
     /**
-     * Implements React's {@link Component#componentWillMount()}. Invoked
-     * immediately before mounting occurs.
+     * Implements React's {@link Component#componentDidMount()}. Invoked
+     * immediately after mounting occurs.
      *
      * @inheritdoc
      */
-    componentWillMount() {
+    componentDidMount() {
         this._mounted = true;
     }
 
-    /**
-     * Implements React's {@link Component#componentWillReceiveProps()}. Invoked
-     * before this mounted component receives new props.
-     *
-     * @inheritdoc
-     * @param {Props} nextProps - New props component will receive.
-     */
-    componentWillReceiveProps(nextProps: Props) {
-        this.setState({ room: nextProps._room });
-    }
-
     /**
      * Implements React's {@link Component#componentWillUnmount()}. Invoked
      * immediately before this component is unmounted and destroyed.

react/features/welcome/components/BlankPage.native.js

      * @inheritdoc
      * @returns {void}
      */
-    componentWillMount() {
+    componentDidMount() {
         this.props.dispatch(destroyLocalTracks());
     }
 

react/features/welcome/components/WelcomePage.native.js

     }
 
     /**
-     * Implements React's {@link Component#componentWillMount()}. Invoked
-     * immediately before mounting occurs. Creates a local video track if none
+     * Implements React's {@link Component#componentDidMount()}. Invoked
+     * immediately after mounting occurs. Creates a local video track if none
      * is available and the camera permission was already granted.
      *
      * @inheritdoc
      * @returns {void}
      */
-    componentWillMount() {
-        super.componentWillMount();
+    componentDidMount() {
+        super.componentDidMount();
 
         const { dispatch } = this.props;