[RN] Add conference connecting overlay

lang/main.json

         },
         "title": "Chat"
     },
+    "connectingOverlay": {
+        "joiningRoom": "Connecting you to your meeting..."
+    },
     "connection": {
         "ATTACHED": "Attached",
         "AUTHENTICATING": "Authenticating",

react/features/app/actions.js

         }
 
         location.protocol || (location.protocol = 'https:');
+        const { contextRoot, host, room } = location;
         const locationURL = new URL(location.toString());
 
-        dispatch(configWillLoad(locationURL));
+        dispatch(configWillLoad(locationURL, room));
 
         let protocol = location.protocol.toLowerCase();
-        const { contextRoot, host, room } = location;
 
         // The React Native app supports an app-specific scheme which is sure to not
         // be supported by fetch.

react/features/base/app/components/BaseApp.js

     render() {
         const { route: { component }, store } = this.state;
 
-        if (store && component) {
+        if (store) {
             return (
                 <I18nextProvider i18n = { i18next }>
                     <Provider store = { store }>
      * @protected
      */
     _createMainElement(component, props) {
-        return React.createElement(component, props || {});
+        return component ? React.createElement(component, props || {}) : null;
     }
 
     /**

react/features/base/color-scheme/defaultScheme.js

     'LargeVideo': {
         background: ColorPalette.black
     },
+    'LoadConfigOverlay': {
+        background: ColorPalette.black,
+        text: ColorPalette.white
+    },
     'Thumbnail': {
         activeParticipantHighlight: ColorPalette.blue,
         activeParticipantTint: ColorPalette.black,

react/features/base/config/actionTypes.js

  *
  * {
  *     type: CONFIG_WILL_LOAD,
- *     locationURL: URL
+ *     locationURL: URL,
+ *     room: string
  * }
  */
 export const CONFIG_WILL_LOAD = 'CONFIG_WILL_LOAD';

react/features/base/config/actions.js

  *
  * @param {URL} locationURL - The URL of the location which necessitated the
  * loading of a configuration.
+ * @param {string} room - The name of the room (conference) for which we're loading the config for.
  * @returns {{
  *     type: CONFIG_WILL_LOAD,
- *     locationURL: URL
+ *     locationURL: URL,
+ *     room: string
  * }}
  */
-export function configWillLoad(locationURL: URL) {
+export function configWillLoad(locationURL: URL, room: string) {
     return {
         type: CONFIG_WILL_LOAD,
-        locationURL
+        locationURL,
+        room
     };
 }
 

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

 
 type Props = {
 
+    /**
+     * The color of the spinner.
+     */
+    color: ?string,
+
     /**
      * Prop to set the size of the indicator. This is the same as the
      * prop of the native component.
      * @returns {ReactElement}
      */
     render() {
+        const { color = ColorPalette.white } = this.props;
         let { size = 'large' } = this.props;
 
         if (size === 'medium') {
 
         const props = {
             animating: true,
-            color: ColorPalette.white,
+            color,
             ...this.props,
             size
         };
         return (
             <ActivityIndicator
                 animating = { true }
-                color = { ColorPalette.white }
                 { ...props }
                 size = { size } />
         );

react/features/overlay/actionTypes.js

     = 'MEDIA_PERMISSION_PROMPT_VISIBILITY_CHANGED';
 
 /**
- * The type of the Redux action which signals that a suspend was detected.
+ * Adjust the state of the fatal error which shows/hides the reload screen. See
+ * action methods's description for more info about each of the fields.
  *
  * {
- *     type: SUSPEND_DETECTED
+ *     type: SET_FATAL_ERROR,
+ *     fatalError: ?Object
  * }
  * @public
  */
-export const SUSPEND_DETECTED = 'SUSPEND_DETECTED';
+export const SET_FATAL_ERROR = 'SET_FATAL_ERROR';
 
 /**
- * Adjust the state of the fatal error which shows/hides the reload screen. See
- * action methods's description for more info about each of the fields.
+ * The type of the Redux action which signals that a suspend was detected.
  *
  * {
- *     type: SET_FATAL_ERROR,
- *     fatalError: ?Object
+ *     type: SUSPEND_DETECTED
  * }
  * @public
  */
-export const SET_FATAL_ERROR = 'SET_FATAL_ERROR';
+export const SUSPEND_DETECTED = 'SUSPEND_DETECTED';

react/features/overlay/components/native/LoadConfigOverlay.js

+// @flow
+
+import React, { Component } from 'react';
+import { SafeAreaView, Text } from 'react-native';
+
+import { ColorSchemeRegistry } from '../../../base/color-scheme';
+import { translate } from '../../../base/i18n';
+import { LoadingIndicator } from '../../../base/react';
+import { connect } from '../../../base/redux';
+import { StyleType } from '../../../base/styles';
+
+import OverlayFrame from './OverlayFrame';
+import styles from './styles';
+
+type Props = {
+
+    /**
+     * The color schemed style of the component.
+     */
+    _styles: StyleType,
+
+    /**
+     * The Function to be invoked to translate i18n keys.
+     */
+    t: Function
+};
+
+/**
+ * Implements an overlay to tell the user that there is an operation in progress in the background during connect
+ * so then the app doesn't seem hung.
+ */
+class LoadConfigOverlay extends Component<Props> {
+    /**
+     * Determines whether this overlay needs to be rendered (according to a
+     * specific redux state). Called by {@link OverlayContainer}.
+     *
+     * @param {Object} state - The redux state.
+     * @returns {boolean} - If this overlay needs to be rendered, {@code true};
+     * {@code false}, otherwise.
+     */
+    static needsRender(state: Object) {
+        return Boolean(state['features/overlay'].loadConfigOverlayVisible);
+    }
+
+    /**
+     * Implements React's {@link Component#render()}.
+     *
+     * @inheritdoc
+     * @returns {ReactElement}
+     */
+    render() {
+        const { _styles } = this.props;
+
+        return (
+            <OverlayFrame>
+                <SafeAreaView
+                    style = { [
+                        styles.loadingOverlayWrapper,
+                        _styles.loadingOverlayWrapper
+                    ] }>
+                    <LoadingIndicator
+                        color = { _styles.indicatorColor }
+                        size = 'large'
+                        style = { styles.connectIndicator } />
+                    <Text
+                        style = { [
+                            styles.loadingOverlayText,
+                            _styles.loadingOverlayText
+                        ] }>
+                        { this.props.t('connectingOverlay.joiningRoom') }
+                    </Text>
+                </SafeAreaView>
+            </OverlayFrame>
+        );
+    }
+}
+
+/**
+ * Maps part of the Redux state to the props of this component.
+ *
+ * @param {Object} state - The Redux state.
+ * @returns {{
+ *     _styles: StyleType
+ * }}
+ */
+function _mapStateToProps(state) {
+    return {
+        _styles: ColorSchemeRegistry.get(state, 'LoadConfigOverlay')
+    };
+}
+
+export default translate(connect(_mapStateToProps)(LoadConfigOverlay));

react/features/overlay/components/native/OverlayFrame.js

 import React, { Component, type Node } from 'react';
 import { SafeAreaView, View } from 'react-native';
 
-import { overlayFrame as styles } from './styles';
+import styles from './styles';
 
 /**
  * The type of the React {@code Component} props of {@code OverlayFrame}.

react/features/overlay/components/native/index.js

 // @flow
 
+export { default as LoadConfigOverlay } from './LoadConfigOverlay';
 export { default as OverlayFrame } from './OverlayFrame';
 export { default as PageReloadOverlay } from './PageReloadOverlay';

react/features/overlay/components/native/styles.js

 
 import { StyleSheet } from 'react-native';
 
-import { ColorPalette } from '../../../base/styles';
+import { ColorSchemeRegistry, schemeColor } from '../../../base/color-scheme';
+import { BoxModel, ColorPalette } from '../../../base/styles';
 
 /**
- * The React {@code Component} styles of {@code OverlayFrame}.
+ * The React {@code Component} styles of the overlay feature.
  */
-export const overlayFrame = createStyleSheet({
+export default {
+    connectIndicator: {
+        margin: BoxModel.margin
+    },
+
     /**
      * Style for a backdrop overlay covering the screen the the overlay is
      * rendered.
         backgroundColor: ColorPalette.black
     },
 
+    loadingOverlayText: {
+        color: ColorPalette.white
+    },
+
+    loadingOverlayWrapper: {
+        alignItems: 'center',
+        flex: 1,
+        flexDirection: 'column',
+        justifyContent: 'center'
+    },
+
     safeContainer: {
         flex: 1
     }
+};
+
+/**
+ * Color schemed styles for all the component based on the abstract dialog.
+ */
+ColorSchemeRegistry.register('LoadConfigOverlay', {
+    indicatorColor: schemeColor('text'),
+
+    loadingOverlayText: {
+        color: schemeColor('text')
+    },
+
+    loadingOverlayWrapper: {
+        backgroundColor: schemeColor('background')
+    }
 });

react/features/overlay/functions.js

 // @flow
 
-import {
-    PageReloadFilmstripOnlyOverlay,
-    PageReloadOverlay,
-    SuspendedFilmstripOnlyOverlay,
-    SuspendedOverlay,
-    UserMediaPermissionsFilmstripOnlyOverlay,
-    UserMediaPermissionsOverlay
-} from './components';
-
-declare var interfaceConfig: Object;
-
-/**
- * Returns the list of available overlays that might be rendered.
- *
- * @private
- * @returns {Array<?React$ComponentType<*>>}
- */
-function _getOverlays() {
-    const filmstripOnly
-        = typeof interfaceConfig === 'object' && interfaceConfig.filmStripOnly;
-    let overlays;
-
-    if (filmstripOnly) {
-        overlays = [
-            PageReloadFilmstripOnlyOverlay,
-            SuspendedFilmstripOnlyOverlay,
-            UserMediaPermissionsFilmstripOnlyOverlay
-        ];
-    } else {
-        overlays = [
-            PageReloadOverlay
-        ];
-    }
-
-    // Mobile only has a PageReloadOverlay.
-    if (navigator.product !== 'ReactNative') {
-        overlays.push(...[
-            SuspendedOverlay,
-            UserMediaPermissionsOverlay
-        ]);
-    }
-
-    return overlays;
-}
+import { getOverlays } from './overlays';
 
 /**
  * Returns the overlay to be currently rendered.
  * @returns {?React$ComponentType<*>}
  */
 export function getOverlayToRender(state: Object) {
-    for (const overlay of _getOverlays()) {
+    for (const overlay of getOverlays()) {
         // react-i18n / react-redux wrap components and thus we cannot access
         // the wrapped component's static methods directly.
         const component = overlay.WrappedComponent || overlay;

react/features/overlay/overlays.native.js

+// @flow
+
+import {
+    LoadConfigOverlay,
+    PageReloadOverlay
+} from './components/native';
+
+/**
+ * Returns the list of available platform specific overlays.
+ *
+ * @returns {Array<React$Element>}
+ */
+export function getOverlays(): Array<React$Element<*>> {
+    return [
+        LoadConfigOverlay,
+        PageReloadOverlay
+    ];
+}

react/features/overlay/overlays.web.js

+// @flow
+
+import {
+    PageReloadFilmstripOnlyOverlay,
+    PageReloadOverlay,
+    SuspendedFilmstripOnlyOverlay,
+    SuspendedOverlay,
+    UserMediaPermissionsFilmstripOnlyOverlay,
+    UserMediaPermissionsOverlay
+} from './components/web';
+
+declare var interfaceConfig: Object;
+
+/**
+ * Returns the list of available platform specific overlays.
+ *
+ * @returns {Array<Object>}
+ */
+export function getOverlays(): Array<Object> {
+    const overlays = [
+        SuspendedOverlay,
+        UserMediaPermissionsOverlay
+    ];
+
+    const filmstripOnly
+            = typeof interfaceConfig === 'object' && interfaceConfig.filmStripOnly;
+
+    if (filmstripOnly) {
+        overlays.push(
+            PageReloadFilmstripOnlyOverlay,
+            SuspendedFilmstripOnlyOverlay,
+            UserMediaPermissionsFilmstripOnlyOverlay);
+    } else {
+        overlays.push(PageReloadOverlay);
+    }
+
+    return overlays;
+}

react/features/overlay/reducer.js

 // @flow
 
+import { CONFIG_WILL_LOAD, LOAD_CONFIG_ERROR, SET_CONFIG } from '../base/config';
 import { assign, ReducerRegistry, set } from '../base/redux';
 
 import {
  */
 ReducerRegistry.register('features/overlay', (state = { }, action) => {
     switch (action.type) {
+    case CONFIG_WILL_LOAD:
+        return _setShowLoadConfigOverlay(state, Boolean(action.room));
+
+    case LOAD_CONFIG_ERROR:
+    case SET_CONFIG:
+        return _setShowLoadConfigOverlay(false);
+
     case MEDIA_PERMISSION_PROMPT_VISIBILITY_CHANGED:
         return _mediaPermissionPromptVisibilityChanged(state, action);
 
 }
 
 /**
- * Reduces a specific redux action SUSPEND_DETECTED of the feature overlay.
+ * Sets the {@code LoadConfigOverlay} overlay visible or not.
  *
  * @param {Object} state - The redux state of the feature overlay.
- * @private
+ * @param {boolean} show - Whether to show or not the overlay.
  * @returns {Object} The new state of the feature overlay after the reduction of
  * the specified action.
  */
-function _suspendDetected(state) {
-    return set(state, 'suspendDetected', true);
+function _setShowLoadConfigOverlay(state, show) {
+    return set(state, 'loadConfigOverlayVisible', show);
 }
 
 /**
 function _setFatalError(state, { fatalError }) {
     return set(state, 'fatalError', fatalError);
 }
+
+/**
+ * Reduces a specific redux action SUSPEND_DETECTED of the feature overlay.
+ *
+ * @param {Object} state - The redux state of the feature overlay.
+ * @private
+ * @returns {Object} The new state of the feature overlay after the reduction of
+ * the specified action.
+ */
+function _suspendDetected(state) {
+    return set(state, 'suspendDetected', true);
+}