fix(auth/external API): CONFERENCE_FAILED with login dialog

Delay the CONFERENCE_FAILED event until the user cancels the login
dialog using the 'recoverable' event flag.

react/features/authentication/actions.js

 
 import { appNavigate } from '../app';
 import { checkIfCanJoin, conferenceLeft } from '../base/conference';
+import { connectionFailed } from '../base/connection';
 import { openDialog } from '../base/dialog';
 
 import {
  * }}
  */
 export function cancelLogin() {
-    // FIXME Like cancelWaitForOwner, dispatch conferenceLeft to notify the
-    // external-api.
+    return (dispatch: Dispatch<*>, getState: Function) => {
+        dispatch({ type: CANCEL_LOGIN });
 
-    return {
-        type: CANCEL_LOGIN
+        // XXX The error associated with CONNECTION_FAILED was marked as
+        // recoverable by the authentication feature  and, consequently,
+        // recoverable-aware features such as mobile's external-api did not
+        // deliver the CONFERENCE_FAILED to the SDK clients/consumers (as
+        // a reaction to CONNECTION_FAILED). Since the
+        // app/user is going to navigate to WelcomePage, the SDK
+        // clients/consumers need an event.
+        const { error, passwordRequired }
+            = getState()['features/base/connection'];
+
+        passwordRequired
+            && dispatch(
+                connectionFailed(
+                    passwordRequired,
+                    error && error.name,
+                    error && error.message,
+                    error && error.credentials,
+                    error && error.details,
+                    /* recoverable */ false));
     };
 }
 

react/features/authentication/middleware.js

     case CONNECTION_FAILED: {
         const { error } = action;
 
-        error
-            && error.name === JitsiConnectionErrors.PASSWORD_REQUIRED
-            && store.dispatch(_openLoginDialog());
+        if (error
+                && error.name === JitsiConnectionErrors.PASSWORD_REQUIRED
+                && typeof error.recoverable === 'undefined') {
+            error.recoverable = true;
+            store.dispatch(_openLoginDialog());
+        }
         break;
     }
 

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

  * @param {Object} [credentials] - The invalid credentials that failed
  * the authentication.
  * @param {Object} [details] - The details about the connection failed event.
+ * @param {boolean} [recoverable] - Indicates whether this event is recoverable
+ * or not.
  * @public
  * @returns {{
  *     type: CONNECTION_FAILED,
         error: string,
         message: ?string,
         credentials: ?Object,
-        details: ?Object) {
+        details: ?Object,
+        recoverable: ?boolean) {
     return {
         type: CONNECTION_FAILED,
         connection,
                     : undefined,
             message,
             name: error,
-            details
+            details,
+            recoverable
         }
     };
 }

react/features/base/connection/reducer.js

 /* @flow */
 
 import { SET_ROOM } from '../conference';
-import { assign, set, ReducerRegistry } from '../redux';
+import { JitsiConnectionErrors } from '../lib-jitsi-meet';
+import { assign, ReducerRegistry } from '../redux';
 import { parseURIString } from '../util';
 
 import {
     return assign(state, {
         connecting: undefined,
         connection,
-        error: undefined
+        error: undefined,
+        passwordRequired: undefined
     });
 }
 
     return assign(state, {
         connecting: undefined,
         connection: undefined,
-        error
+        error,
+        passwordRequired:
+            error.name === JitsiConnectionErrors.PASSWORD_REQUIRED
+                ? connection : undefined
     });
 }
 
         { connection }: { connection: Object }) {
     return assign(state, {
         connecting: connection,
-        error: undefined
+        error: undefined,
+        passwordRequired: undefined
     });
 }
 
  * reduction of the specified action.
  */
 function _setRoom(state: Object) {
-    return set(state, 'error', undefined);
+    return assign(state, {
+        error: undefined,
+        passwordRequired: undefined
+    });
 }

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

         break;
 
     case CONNECTION_FAILED:
-        _sendConferenceFailedOnConnectionError(store, action);
+        !action.error.recoverable
+            && _sendConferenceFailedOnConnectionError(store, action);
         break;
 
     case ENTER_PICTURE_IN_PICTURE: