[RN] Add ability to skip the welcome page

Also expose this in the native SDKs.

android/README.md

 This class encapsulates a high level API in the form of an Android `Activity`
 which displays a single `JitsiMeetView`.
 
+#### getWelcomePageDisabled()
+
+See JitsiMeetView.getWelcomePageDisabled.
+
 #### loadURL(url)
 
 See JitsiMeetView.loadURL.
 
+#### setWelcomePageDisabled(disabled)
+
+See JitsiMeetView.setWelcomePageDisabled.
 
 ### JitsiMeetView
 
 
 Returns the `JitsiMeetViewListener` instance attached to the view.
 
+#### getWelcomePageDisabled()
+
+Returns true if the welcome page is disable,d false if not. If the welcome page
+is disabled, a black empty view will be rendered when not in a conference.
+
 #### loadURL(url)
 
 Loads the given URL and joins the room. If `null` is specified, the welcome page
 Sets the given listener (class implementing the `JitsiMeetViewListener`
 interface) on the view.
 
+#### setWelcomePageDisabled(disabled)
+
+Sets if the welcome page should be disabled or not. See `getWelcomePageDisabled`
+for more info.
+
+NOTE: This function must be called before `loadURL` for it to take effect.
+
 #### onBackPressed()
 
 Helper method which should be called from the activity's `onBackPressed` method.

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

      */
     private JitsiMeetView view;
 
+    /**
+     * See {@JitsiMeetView.getWelcomePageDisabled}.
+     */
+    public boolean getWelcomePageDisabled() {
+        return view != null && view.getWelcomePageDisabled();
+    }
+
     /**
      * Loads the given URL and displays the conference. If the specified URL is
      * null, the welcome page is displayed instead.
         view.loadURL(url);
     }
 
+    /**
+     * See {@JitsiMeetView.setWelcomePageDisabled}.
+     */
+    public void setWelcomePageDisabled(boolean disabled) {
+        if (view != null) {
+            view.setWelcomePageDisabled(disabled);
+        }
+    }
+
     /**
      * {@inheritDoc}
      */

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

      */
     private JitsiMeetViewListener listener;
 
+    /**
+     * Indicates if the welcome page should be disabled or not.
+     */
+    private boolean welcomePageDisabled;
+
     /**
      * React Native root view.
      */
         return listener;
     }
 
+    /**
+     * @return - true if the welcome page is disabled, false if not.
+     */
+    public boolean getWelcomePageDisabled() {
+        return welcomePageDisabled;
+    }
+
     /**
      * Internal method to initialize the React Native instance manager. We
      * create a single instance in order to load the JavaScript bundle a single
             props.putString("url", url.toString());
         }
 
+        props.putBoolean("disableWelcomePage", welcomePageDisabled);
+
         // TODO: ReactRootView#setAppProperties is only available on React
         // Native 0.45, so destroy the current root view and create a new one.
         if (reactRootView != null) {
         this.listener = listener;
     }
 
+    /**
+     * Sets if the welcome page should be enabled or not. Must be called before calling loadURL or
+     * it won't take effect.
+     *
+     * @param disabled - set to true for disabling the welcome page, false not to do so.
+     */
+    public void setWelcomePageDisabled(boolean disabled) {
+        welcomePageDisabled = disabled;
+    }
+
     /**
      * Activity lifecycle method which should be called from
      * <tt>Activity.onBackPressed</tt> so we can do the required internal

ios/README.md

 The `JitsiMeetView` class is the entry point to the SDK. It a subclass of
 `UIView` which renders a full conference in the designated area.
 
+#### delegate
+
+Property for getting / setting the delegate (instance of `JitsiMeetViewDelegate`
+in the view.
+
+#### disableWelcomePage
+
+Property for setting the welcome page as disabled (or not). It default to NO, so
+a welcome page would be shown. When the welcome page is set to disabled, an
+empty black view is rendered.
+
+NOTE: This property must be set before calling `loadURL` in order for it to take
+effect.
+
+#### loadURL(url)
+
 ```objc
 [meetView loadURL:[NSURL URLWithString:@"https://meet.jit.si/test123"]];
 ```

ios/sdk/src/JitsiMeetView.h

 @interface JitsiMeetView : UIView
 
 @property (nonatomic, weak, nullable) id<JitsiMeetViewDelegate> delegate;
+@property (nonatomic) BOOL disableWelcomePage;
 
 +    (BOOL)application:(UIApplication *)application
   continueUserActivity:(NSUserActivity *)userActivity

ios/sdk/src/JitsiMeetView.m

  * is null, the welcome page is shown.
  */
 - (void)loadURL:(NSURL *)url {
-    NSDictionary *props = url ? @{ url : url.absoluteString } : nil;
+    NSMutableDictionary *props = [[NSMutableDictionary alloc] init];
+
+    if (url) {
+        [props setObject:url.absoluteString forKey:@"url"];
+    }
+
+    [props setObject:@(self.disableWelcomePage) forKey:@"disableWelcomePage"];
 
     if (rootView == nil) {
         rootView

react/features/app/actionTypes.js

 /**
- * The type of the actions which signals that a specific App will mount (in the
- * terms of React).
+ * The type of (Redux) action which configures if the welcome page should be
+ * disabled or not.
+ *
+ * {
+ *     type: APP_SET_WELCOME_PAGE_DISABLED,
+ *     app: App,
+ *     disabled: boolean
+ * }
+ */
+export const APP_SET_WELCOME_PAGE_DISABLED
+    = Symbol('APP_SET_WELCOME_PAGE_DISABLED');
+
+/**
+ * The type of (Redux) action which signals that a specific App will mount (in
+ * React terms).
  *
  * {
  *     type: APP_WILL_MOUNT,
 export const APP_WILL_MOUNT = Symbol('APP_WILL_MOUNT');
 
 /**
- * The type of the actions which signals that a specific App will unmount (in
- * the terms of React).
+ * The type of (Redux) action which signals that a specific App will unmount (in
+ * React terms).
  *
  * {
  *     type: APP_WILL_UNMOUNT,

react/features/app/actions.js

 import { setConfig } from '../base/config';
 import { loadConfig } from '../base/lib-jitsi-meet';
 
-import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from './actionTypes';
+import {
+    APP_SET_WELCOME_PAGE_DISABLED,
+    APP_WILL_MOUNT,
+    APP_WILL_UNMOUNT
+} from './actionTypes';
 import { _getRouteToRender, _parseURIString } from './functions';
 
 declare var APP: Object;
     _appNavigateToMandatoryLocation(dispatch, getState, location);
 }
 
+/**
+ * Configures the welcome page display for this app.
+ *
+ * @param {App} app - The App being configured.
+ * @param {boolean} disabled - Set to true if the welcome page should be
+ * disabled, false if it shouldn't.
+ * @returns {{
+ *     type: APP_SET_WELCOME_PAGE_DISABLED,
+ *     app: App,
+ *     disabled: boolean
+ * }}
+ */
+export function appSetWelcomePageDisabled(app, disabled) {
+    return {
+        type: APP_SET_WELCOME_PAGE_DISABLED,
+        app,
+        disabled
+    };
+}
+
 /**
  * Signals that a specific App will mount (in the terms of React).
  *

react/features/app/components/AbstractApp.js

      */
     _onRouteEnter(route, ...args) {
         // Notify the route that it is about to be entered.
-        const onEnter = route.onEnter;
+        const onEnter = route && route.onEnter;
 
         if (typeof onEnter === 'function') {
             onEnter(...args);

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

 /* global __DEV__ */
 
+import React from 'react';
 import { Linking } from 'react-native';
 
 import { Platform } from '../../base/react';
 import '../../mobile/wake-lock';
 
 import { AbstractApp } from './AbstractApp';
+import { appSetWelcomePageDisabled } from '../actions';
 
 /**
  * Root application component.
      *
      * @static
      */
-    static propTypes = AbstractApp.propTypes;
+    static propTypes = {
+        ...AbstractApp.propTypes,
+
+        /**
+         * Indicates if the welcome page should be shown when not in a
+         * conference.
+         */
+        disableWelcomePage: React.PropTypes.bool
+    };
 
     /**
      * Initializes a new App instance.
         super.componentWillMount();
 
         Linking.addEventListener('url', this._onLinkingURL);
+
+        // Store the desire to use the welcome page or not in the Redux store.
+        const dispatch = this._getStore().dispatch;
+
+        dispatch(
+            appSetWelcomePageDisabled(
+                this, Boolean(this.props.disableWelcomePage)));
     }
 
     /**

react/features/app/functions.native.js

         = typeof stateOrGetState === 'function'
             ? stateOrGetState()
             : stateOrGetState;
+    const { disableWelcomePage } = state['features/app'];
     const { room } = state['features/base/conference'];
     const component = isRoomValid(room) ? Conference : WelcomePage;
 
+    if (component === WelcomePage && disableWelcomePage) {
+        return null;
+    }
+
     return RouteRegistry.getRouteByComponent(component);
 }
 

react/features/app/reducer.js

 import { ReducerRegistry } from '../base/redux';
 
-import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from './actionTypes';
+import {
+    APP_SET_WELCOME_PAGE_DISABLED,
+    APP_WILL_MOUNT,
+    APP_WILL_UNMOUNT
+} from './actionTypes';
 
 ReducerRegistry.register('features/app', (state = {}, action) => {
     switch (action.type) {
+    case APP_SET_WELCOME_PAGE_DISABLED:
+        if (state.app === action.app) {
+            return {
+                ...state,
+                disableWelcomePage: action.disabled
+            };
+        }
+        break;
     case APP_WILL_MOUNT:
         if (state.app !== action.app) {
             return {

react/index.native.js

  * @extends Component
  */
 class Root extends Component {
+    /**
+     * Root component's property types.
+     *
+     * @static
+     */
+    static propTypes = {
+        /**
+         * Indicates if the welcome page should be shown when not in a
+         * conference.
+         */
+        disableWelcomePage: React.PropTypes.bool,
+
+        /**
+         * The URL, if any, with which the app was launched.
+         */
+        url: React.PropTypes.string
+    };
+
     /**
      * Initializes a new Root instance.
      *
              *
              * @type {string}
              */
-            url: undefined
+            url: this.props.url
         };
 
         // Handle the URL, if any, with which the app was launched.
 
         return (
             <App
+                disableWelcomePage = { this.props.disableWelcomePage }
                 url = { this.state.url } />
         );
     }