feat: central back button registry

react/features/app/components/App.native.js

 import { updateSettings } from '../../base/settings';
 import '../../google-api';
 import '../../mobile/audio-mode';
+import '../../mobile/back-button';
 import '../../mobile/background';
 import '../../mobile/call-integration';
 import '../../mobile/external-api';

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

     View
 } from 'react-native';
 
+import { BackButtonRegistry } from '../../../../mobile/back-button';
+
 import { type StyleType } from '../../../styles';
 
 import styles from './slidingviewstyles';
         };
 
         // Bind event handlers so they are only bound once per instance.
+        this._onHardwareBackPress = this._onHardwareBackPress.bind(this);
         this._onHide = this._onHide.bind(this);
     }
 
      * @inheritdoc
      */
     componentDidMount() {
+        BackButtonRegistry.addListener(this._onHardwareBackPress, true);
+
         this._mounted = true;
         this._setShow(this.props.show);
     }
      * @inheritdoc
      */
     componentWillUnmount() {
+        BackButtonRegistry.removeListener(this._onHardwareBackPress);
+
         this._mounted = false;
     }
 
         return style;
     }
 
+    _onHardwareBackPress: () => boolean;
+
+    /**
+     * Callback to handle the hardware back button.
+     *
+     * @returns {boolean}
+     */
+    _onHardwareBackPress() {
+        const { onHide } = this.props;
+
+        if (typeof onHide === 'function') {
+            return onHide();
+        }
+
+        return false;
+    }
+
     _onHide: () => void;
 
     /**

react/features/chat/components/native/Chat.js

  * the mobile client.
  */
 class Chat extends AbstractChat<Props> {
+    /**
+     * Instantiates a new instance.
+     *
+     * @inheritdoc
+     */
+    constructor(props: Props) {
+        super(props);
+
+        this._onClose = this._onClose.bind(this);
+    }
+
     /**
      * Implements React's {@link Component#render()}.
      *
     render() {
         return (
             <SlidingView
+                onHide = { this._onClose }
                 position = 'bottom'
                 show = { this.props._isOpen } >
                 <KeyboardAvoidingView
                     style = { styles.chatContainer }>
                     <HeaderWithNavigation
                         headerLabelKey = 'chat.title'
-                        onPressBack = { this.props._onToggleChat } />
+                        onPressBack = { this._onClose } />
                     <SafeAreaView style = { styles.backdrop }>
                         <MessageContainer messages = { this.props._messages } />
                         <ChatInputBar onSend = { this.props._onSendMessage } />
             </SlidingView>
         );
     }
+
+    _onClose: () => boolean
+
+    /**
+     * Closes the chat window.
+     *
+     * @returns {boolean}
+     */
+    _onClose() {
+        if (this.props._isOpen) {
+            this.props._onToggleChat();
+
+            return true;
+        }
+
+        return false;
+    }
 }
 
 export default translate(connect(_mapStateToProps, _mapDispatchToProps)(Chat));

react/features/conference/components/native/Conference.js

 // @flow
 
 import React from 'react';
-import { BackHandler, NativeModules, SafeAreaView, StatusBar, View } from 'react-native';
+import { NativeModules, SafeAreaView, StatusBar, View } from 'react-native';
 
 import { appNavigate } from '../../../app';
 import { PIP_ENABLED, getFeatureFlag } from '../../../base/flags';
     TileView
 } from '../../../filmstrip';
 import { LargeVideo } from '../../../large-video';
+import { BackButtonRegistry } from '../../../mobile/back-button';
 import { AddPeopleDialog, CalleeInfoContainer } from '../../../invite';
 import { Captions } from '../../../subtitles';
 import { setToolboxVisible, Toolbox } from '../../../toolbox';
      * @returns {void}
      */
     componentDidMount() {
-        BackHandler.addEventListener('hardwareBackPress', this._onHardwareBackPress);
+        BackButtonRegistry.addListener(this._onHardwareBackPress);
 
         // Show the toolbox if we are the only participant; otherwise, the whole
         // UI looks too unpopulated the LargeVideo visible.
      */
     componentWillUnmount() {
         // Tear handling any hardware button presses for back navigation down.
-        BackHandler.removeEventListener('hardwareBackPress', this._onHardwareBackPress);
+        BackButtonRegistry.removeListener(this._onHardwareBackPress);
     }
 
     /**

react/features/invite/components/add-people-dialog/native/AddPeopleDialog.js

 
         return (
             <SlidingView
+                onHide = { this._onCloseAddPeopleDialog }
                 position = 'bottom'
                 show = { this.props._isVisible } >
                 <HeaderWithNavigation
         this._onTypeQuery('');
     }
 
-    _onCloseAddPeopleDialog: () => void
+    _onCloseAddPeopleDialog: () => boolean
 
     /**
      * Closes the dialog.
      *
-     * @returns {void}
+     * @returns {boolean}
      */
     _onCloseAddPeopleDialog() {
-        this.props.dispatch(setAddPeopleDialogVisible(false));
+        if (this.props._isVisible) {
+            this.props.dispatch(setAddPeopleDialogVisible(false));
+
+            return true;
+        }
+
+        return false;
     }
 
     _onInvite: () => void

react/features/invite/components/dial-in-summary/native/DialInSummary.js

 
         return (
             <SlidingView
+                onHide = { this._onCloseView }
                 position = 'bottom'
                 show = { Boolean(_summaryUrl) } >
                 <View style = { styles.webViewWrapper }>
         );
     }
 
-    _onCloseView: () => void;
+    _onCloseView: () => boolean;
 
     /**
      * Closes the view.
      *
-     * @returns {void}
+     * @returns {boolean}
      */
     _onCloseView() {
-        this.props.dispatch(hideDialInSummary());
+        if (this.props._summaryUrl) {
+            this.props.dispatch(hideDialInSummary());
+
+            return true;
+        }
+
+        return false;
     }
 
     _onError: () => void;

react/features/mobile/back-button/BackButtonRegistry.js

+// @flow
+
+/**
+ * An registry that dispatches hardware back button events for subscribers with a custom logic.
+ */
+class BackButtonRegistry {
+    _listeners: Array<Function>;
+
+    /**
+     * Instantiates a new instance of the registry.
+     */
+    constructor() {
+        this._listeners = [];
+    }
+
+    /**
+     * Adds a listener to the registry.
+     *
+     * NOTE: Due to the different order of component mounts, we allow a component to register
+     * its listener to the top of the list, so then that will be invoked before other, 'non-top'
+     * listeners. For example a 'non-top' listener can be the one that puts the app into PiP mode,
+     * while a 'top' listener is the one that closes a modal in a conference.
+     *
+     * @param {Function} listener - The listener function.
+     * @param {boolean?} top - If true, the listener will be put on the top (eg for modal-like components).
+     * @returns {void}
+     */
+    addListener(listener: Function, top: boolean = false) {
+        if (top) {
+            this._listeners.splice(0, 0, listener);
+        } else {
+            this._listeners.push(listener);
+        }
+    }
+
+    /**
+     * Removes a listener from the registry.
+     *
+     * @param {Function} listener - The listener to remove.
+     * @returns {void}
+     */
+    removeListener(listener: Function) {
+        this._listeners = this._listeners.filter(f => f !== listener);
+    }
+
+    onHardwareBackPress: () => boolean
+
+    /**
+     * Callback for the back button press event.
+     *
+     * @returns {boolean}
+     */
+    onHardwareBackPress() {
+        for (const listener of this._listeners) {
+            const result = listener();
+
+            if (result === true) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+export default new BackButtonRegistry();

react/features/mobile/back-button/index.js

+// @flow
+
+export { default as BackButtonRegistry } from './BackButtonRegistry';
+
+import './middleware';

react/features/mobile/back-button/middleware.js

+// @flow
+
+import { BackHandler } from 'react-native';
+
+import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../../base/app';
+import { MiddlewareRegistry } from '../../base/redux';
+
+import BackButtonRegistry from './BackButtonRegistry';
+
+// Binding function to the proper instance, so then the event emitter won't replace the
+// underlying instance.
+BackButtonRegistry.onHardwareBackPress = BackButtonRegistry.onHardwareBackPress.bind(BackButtonRegistry);
+
+/**
+ * Middleware that captures App lifetime actions and subscribes to application
+ * state changes. When the application state changes it will fire the action
+ * required to mute or unmute the local video in case the application goes to
+ * the background or comes back from it.
+ *
+ * @param {Store} store - The redux store.
+ * @returns {Function}
+ * @see {@link https://facebook.github.io/react-native/docs/appstate.html}
+ */
+MiddlewareRegistry.register(() => next => action => {
+    switch (action.type) {
+    case APP_WILL_MOUNT:
+        BackHandler.addEventListener('hardwareBackPress', BackButtonRegistry.onHardwareBackPress);
+        break;
+
+    case APP_WILL_UNMOUNT:
+        BackHandler.removeEventListener('hardwareBackPress', BackButtonRegistry.onHardwareBackPress);
+        break;
+    }
+
+    return next(action);
+});

react/features/remote-video-menu/components/native/RemoteVideoMenu.js

 
 import { Avatar } from '../../../base/avatar';
 import { ColorSchemeRegistry } from '../../../base/color-scheme';
-import {
-    BottomSheet
-} from '../../../base/dialog';
+import { BottomSheet, isDialogOpen } from '../../../base/dialog';
 import { getParticipantDisplayName } from '../../../base/participants';
 import { connect } from '../../../base/redux';
 import { StyleType } from '../../../base/styles';
      */
     _bottomSheetStyles: StyleType,
 
+    /**
+     * True if the menu is currently open, false otherwise.
+     */
+    _isOpen: boolean,
+
     /**
      * Display name of the participant retreived from Redux.
      */
     _participantDisplayName: string
 }
 
+// eslint-disable-next-line prefer-const
+let RemoteVideoMenu_;
+
 /**
  * Class to implement a popup menu that opens upon long pressing a thumbnail.
  */
         );
     }
 
-    _onCancel: () => void;
+    _onCancel: () => boolean;
 
     /**
      * Callback to hide the {@code RemoteVideoMenu}.
      *
      * @private
-     * @returns {void}
+     * @returns {boolean}
      */
     _onCancel() {
-        this.props.dispatch(hideRemoteVideoMenu());
+        if (this.props._isOpen) {
+            this.props.dispatch(hideRemoteVideoMenu());
+
+            return true;
+        }
+
+        return false;
     }
 }
 
  * @param {Object} state - Redux state.
  * @param {Object} ownProps - Properties of component.
  * @private
- * @returns {{
- *      _bottomSheetStyles: StyleType,
- *      _participantDisplayName: string
- *  }}
+ * @returns {Props}
  */
 function _mapStateToProps(state, ownProps) {
     const { participant } = ownProps;
     return {
         _bottomSheetStyles:
             ColorSchemeRegistry.get(state, 'BottomSheet'),
+        _isOpen: isDialogOpen(state, RemoteVideoMenu_),
         _participantDisplayName: getParticipantDisplayName(
             state, participant.id)
     };
 }
 
-export default connect(_mapStateToProps)(RemoteVideoMenu);
+RemoteVideoMenu_ = connect(_mapStateToProps)(RemoteVideoMenu);
+
+export default RemoteVideoMenu_;

react/features/toolbox/components/native/OverflowMenu.js

 import { Platform } from 'react-native';
 
 import { ColorSchemeRegistry } from '../../../base/color-scheme';
-import { BottomSheet, hideDialog } from '../../../base/dialog';
+import { BottomSheet, hideDialog, isDialogOpen } from '../../../base/dialog';
 import { CHAT_ENABLED, IOS_RECORDING_ENABLED, getFeatureFlag } from '../../../base/flags';
 import { connect } from '../../../base/redux';
 import { StyleType } from '../../../base/styles';
      */
     _chatEnabled: boolean,
 
+    /**
+     * True if the overflow menu is currently visible, false otherwise.
+     */
+    _isOpen: boolean,
+
     /**
      * Whether the recoding button should be enabled or not.
      */
         );
     }
 
-    _onCancel: () => void;
+    _onCancel: () => boolean;
 
     /**
      * Hides this {@code OverflowMenu}.
      *
      * @private
-     * @returns {void}
+     * @returns {boolean}
      */
     _onCancel() {
-        this.props.dispatch(hideDialog(OverflowMenu_));
+        if (this.props._isOpen) {
+            this.props.dispatch(hideDialog(OverflowMenu_));
+
+            return true;
+        }
+
+        return false;
     }
 }
 
  *
  * @param {Object} state - Redux state.
  * @private
- * @returns {{
- *      _bottomSheetStyles: StyleType,
- *      _chatEnabled: boolean,
- *      _recordingEnabled: boolean
- *  }}
+ * @returns {Props}
  */
 function _mapStateToProps(state) {
     return {
         _bottomSheetStyles:
             ColorSchemeRegistry.get(state, 'BottomSheet'),
         _chatEnabled: getFeatureFlag(state, CHAT_ENABLED, true),
+        _isOpen: isDialogOpen(state, OverflowMenu_),
         _recordingEnabled: Platform.OS !== 'ios' || getFeatureFlag(state, IOS_RECORDING_ENABLED)
     };
 }