[RN] Fix disconnecting before the connection was established

Keep track of the connection and conference objects so we can leave and / or
disconnect early, before the connection is established or the conference joined.

react/features/base/conference/actionTypes.js

  *
  * {
  *     type: CONFERENCE_WILL_JOIN,
- *     room: string
+ *     room: string,
+ *     conference: JitsiConference
  * }
  */
 export const CONFERENCE_WILL_JOIN = Symbol('CONFERENCE_WILL_JOIN');

react/features/base/conference/actions.js

  *
  * @param {string} room - The room (name) which identifies the conference the
  * local participant will (try to) join.
+ * @param {JitsiConference} conference - The JitsiConference instance the
+ * local participant will (try to) join.
  * @returns {{
  *     type: CONFERENCE_WILL_JOIN,
- *     room: string
+ *     room: string,
+*      conference: JitsiConference
  * }}
  */
-function _conferenceWillJoin(room) {
+function _conferenceWillJoin(room, conference) {
     return {
         type: CONFERENCE_WILL_JOIN,
-        room
+        room,
+        conference
     };
 }
 
             throw new Error('Cannot join conference without room name');
         }
 
-        dispatch(_conferenceWillJoin(room));
-
         const conference
             = connection.initJitsiConference(
 
                 room.toLowerCase(),
                 state['features/base/config']);
 
+        dispatch(_conferenceWillJoin(room, conference));
+
         _addConferenceListeners(conference, dispatch);
 
         _setLocalParticipantData(conference, state);

react/features/base/conference/reducer.js

     CONFERENCE_FAILED,
     CONFERENCE_JOINED,
     CONFERENCE_LEFT,
+    CONFERENCE_WILL_JOIN,
     CONFERENCE_WILL_LEAVE,
     LOCK_STATE_CHANGED,
     SET_AUDIO_ONLY,
     case CONFERENCE_LEFT:
         return _conferenceLeft(state, action);
 
+    case CONFERENCE_WILL_JOIN:
+        return _conferenceWillJoin(state, action);
+
     case CONFERENCE_WILL_LEAVE:
         return _conferenceWillLeave(state, action);
 
             audioOnly: undefined,
             audioOnlyVideoMuted: undefined,
             conference: undefined,
+            joining: undefined,
             leaving: undefined,
 
             /**
              * @type {JitsiConference}
              */
             conference,
+            joining: undefined,
             leaving: undefined,
 
             /**
             audioOnly: undefined,
             audioOnlyVideoMuted: undefined,
             conference: undefined,
+            joining: undefined,
             leaving: undefined,
             locked: undefined,
             password: undefined,
         }));
 }
 
+/**
+ * Reduces a specific Redux action CONFERENCE_WILL_JOIN of the feature
+ * base/conference.
+ *
+ * @param {Object} state - The Redux state of the feature base/conference.
+ * @param {Action} action - The Redux action CONFERENCE_WILL_JOIN to reduce.
+ * @private
+ * @returns {Object} The new state of the feature base/conference after the
+ * reduction of the specified action.
+ */
+function _conferenceWillJoin(state, action) {
+    return set(state, 'joining', action.conference);
+}
+
 /**
  * Reduces a specific Redux action CONFERENCE_WILL_LEAVE of the feature
  * base/conference.

react/features/base/connection/actionTypes.js

  */
 export const CONNECTION_FAILED = Symbol('CONNECTION_FAILED');
 
+/**
+ * The type of (redux) action which signals that a connection will connect.
+ *
+ * {
+ *     type: CONNECTION_WILL_CONNECT,
+ *     connection: JitsiConnection
+ * }
+ */
+export const CONNECTION_WILL_CONNECT = Symbol('CONNECTION_WILL_CONNECT');
+
 /**
  * The type of (redux) action which sets the location URL of the application,
  * connection, conference, etc.

react/features/base/connection/actions.native.js

     CONNECTION_DISCONNECTED,
     CONNECTION_ESTABLISHED,
     CONNECTION_FAILED,
+    CONNECTION_WILL_CONNECT,
     SET_LOCATION_URL
 } from './actionTypes';
 
                 jwt && issuer && issuer !== 'anonymous' ? jwt : undefined,
                 options);
 
+        dispatch(_connectionWillConnect(connection));
+
         connection.addEventListener(
             JitsiConnectionEvents.CONNECTION_DISCONNECTED,
             _onConnectionDisconnected);
     };
 }
 
+/**
+ * Create an action for when a connection will connect.
+ *
+ * @param {JitsiConnection} connection - The JitsiConnection which will connect.
+ * @private
+ * @returns {{
+ *     type: CONNECTION_WILL_CONNECT,
+ *     connection: JitsiConnection
+ * }}
+ */
+function _connectionWillConnect(connection) {
+    return {
+        type: CONNECTION_WILL_CONNECT,
+        connection
+    };
+}
+
 /**
  * Create an action for when the signaling connection has been established.
  *
 export function disconnect() {
     return (dispatch: Dispatch<*>, getState: Function) => {
         const state = getState();
-        const { conference } = state['features/base/conference'];
-        const { connection } = state['features/base/connection'];
+        const { conference, joining } = state['features/base/conference'];
+        const { connection, connecting } = state['features/base/connection'];
+
+        // The conference we are joining or have already joined.
+        const _conference = joining || conference;
+
+        // The connection we are connecting or have already connected.
+        const _connection = connecting || connection;
 
+        // Promise which completes when the conference has been left and the
+        // connection has been disconnected.
         let promise;
 
         // Leave the conference.
-        if (conference) {
+        if (_conference) {
             // In a fashion similar to JitsiConference's CONFERENCE_LEFT event
             // (and the respective Redux action) which is fired after the
             // conference has been left, notify the application about the
             // intention to leave the conference.
-            dispatch(conferenceWillLeave(conference));
+            dispatch(conferenceWillLeave(_conference));
 
-            promise = conference.leave();
+            promise = _conference.leave();
         } else {
             promise = Promise.resolve();
         }
 
         // Disconnect the connection.
-        if (connection) {
-            promise = promise.then(() => connection.disconnect());
+        if (_connection) {
+            promise = promise.then(() => _connection.disconnect());
         }
 
         return promise;

react/features/base/connection/reducer.js

 import {
     CONNECTION_DISCONNECTED,
     CONNECTION_ESTABLISHED,
+    CONNECTION_FAILED,
+    CONNECTION_WILL_CONNECT,
     SET_LOCATION_URL
 } from './actionTypes';
 
         case CONNECTION_ESTABLISHED:
             return _connectionEstablished(state, action);
 
+        case CONNECTION_FAILED:
+            return _connectionFailed(state, action);
+
+        case CONNECTION_WILL_CONNECT:
+            return _connectionWillConnect(state, action);
+
         case SET_LOCATION_URL:
             return _setLocationURL(state, action);
         }
 function _connectionEstablished(
         state: Object,
         { connection }: { connection: Object }) {
-    return set(state, 'connection', connection);
+    return assign(state, {
+        connecting: undefined,
+        connection
+    });
+}
+
+/* eslint-disable no-unused-vars */
+
+/**
+ * Reduces a specific Redux action CONNECTION_FAILED of the feature
+ * base/connection.
+ *
+ * @param {Object} state - The Redux state of the feature base/connection.
+ * @param {Action} action - The Redux action CONNECTION_FAILED to reduce.
+ * @private
+ * @returns {Object} The new state of the feature base/connection after the
+ * reduction of the specified action.
+ */
+function _connectionFailed(state: Object, action: Object) {
+    return set(state, 'connecting', undefined);
+}
+
+/* eslint-enable no-unused-vars */
+
+/**
+ * Reduces a specific Redux action CONNECTION_WILL_CONNECT of the feature
+ * base/connection.
+ *
+ * @param {Object} state - The Redux state of the feature base/connection.
+ * @param {Action} action - The Redux action CONNECTION_WILL_CONNECT to reduce.
+ * @private
+ * @returns {Object} The new state of the feature base/connection after the
+ * reduction of the specified action.
+ */
+function _connectionWillConnect(state: Object, action: Object) {
+    return set(state, 'connecting', action.connection);
 }
 
 /**