ref(external API): emit CONFERENCE_FAILED on CONNECTION_FAILED

It seems that the external API will not send any event to let the sdk
consumer know that the conference has failed if the problem occurs at
the establishing of XMPP connection stage. That's because the config was
loaded successfully, but the conference instance does not exist yet, so
neither base/config nor base/conference will emit any failure.

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

     isRoomValid
 } from '../../base/conference';
 import { LOAD_CONFIG_ERROR } from '../../base/config';
+import { CONNECTION_FAILED } from '../../base/connection';
 import { MiddlewareRegistry } from '../../base/redux';
 import { toURLString } from '../../base/util';
 import { ENTER_PICTURE_IN_PICTURE } from '../picture-in-picture';
         _sendConferenceEvent(store, action);
         break;
 
+    case CONNECTION_FAILED:
+        _sendConferenceFailedOnConnectionError(store, action);
+        break;
+
     case ENTER_PICTURE_IN_PICTURE:
         _sendEvent(store, _getSymbolDescription(action.type), /* data */ {});
         break;
         || _sendEvent(store, _getSymbolDescription(type), data);
 }
 
+/**
+ * Sends {@link CONFERENCE_FAILED} event when the {@link CONNECTION_FAILED}
+ * occurs. Otherwise the external API will not emit such event, because at this
+ * point conference has not been created yet and the base/conference feature
+ * will not emit it.
+ *
+ * @param {Store} store - The redux store.
+ * @param {Action} action - The redux action.
+ * @returns {void}
+ */
+function _sendConferenceFailedOnConnectionError(store, action) {
+    const { locationURL } = store.getState()['features/base/connection'];
+
+    locationURL && _sendEvent(
+        store,
+        _getSymbolDescription(CONFERENCE_FAILED),
+        /* data */ {
+            url: toURLString(locationURL),
+            error: action.error.name
+        });
+}
+
 /**
  * Sends a specific event to the native counterpart of the External API. Native
  * apps may listen to such events via the mechanisms provided by the (native)