ref(external API): emit CONFERENCE_WILL_JOIN on SET_ROOM

Make the external API emit CONFERENCE_WILL_JOIN early on SET_ROOM action
which occurs before the XMPP connection is created. At this point we
know that config has loaded and if there's a valid conference room to
be joined. We were thinking of doing that even on CONFIG_WILL_LOAD,
but that seemed to be to risky at this point.

react/features/mobile/external-api/middleware.js

     CONFERENCE_LEFT,
     CONFERENCE_WILL_JOIN,
     CONFERENCE_WILL_LEAVE,
-    JITSI_CONFERENCE_URL_KEY
+    JITSI_CONFERENCE_URL_KEY,
+    SET_ROOM,
+    isRoomValid
 } from '../../base/conference';
 import { LOAD_CONFIG_ERROR } from '../../base/config';
 import { MiddlewareRegistry } from '../../base/redux';
         });
         break;
     }
+
+    case SET_ROOM:
+        _maybeTriggerEarlyConferenceWillJoin(store, action);
+        break;
     }
 
     return result;
     return description;
 }
 
+/**
+ * If {@link SET_ROOM} action happens for a valid conference room this method
+ * will emit an early {@link CONFERENCE_WILL_JOIN} event to let the external API
+ * know that a conference is being joined. Before that happens a connection must
+ * be created and only then base/conference feature would emit
+ * {@link CONFERENCE_WILL_JOIN}. That is fine for the Jitsi Meet app, because
+ * that's the a conference instance gets created, but it's too late for
+ * the external API to learn that. The latter {@link CONFERENCE_WILL_JOIN} is
+ * swallowed in {@link _swallowEvent}.
+ *
+ * @param {Store} store - The redux store.
+ * @param {Action} action - The redux action.
+ * @returns {void}
+ */
+function _maybeTriggerEarlyConferenceWillJoin(store, action) {
+    const { locationURL } = store.getState()['features/base/connection'];
+    const { room } = action;
+
+    isRoomValid(room) && locationURL && _sendEvent(
+        store,
+        _getSymbolDescription(CONFERENCE_WILL_JOIN),
+        /* data */ {
+            url: toURLString(locationURL)
+        });
+}
+
 /**
  * Sends an event to the native counterpart of the External API for a specific
  * conference-related redux action.
     switch (action.type) {
     case CONFERENCE_LEFT:
         return _swallowConferenceLeft(store, action, data);
+    case CONFERENCE_WILL_JOIN:
+        // CONFERENCE_WILL_JOIN is dispatched to the external API on SET_ROOM,
+        // before the connection is created, so we need to swallow the original
+        // one emitted by base/conference.
+        return true;
 
     default:
         return false;