fix(lobby): Inconsistent state after deny and then approve.

react/features/base/conference/reducer.ts

@@ -165,6 +165,7 @@ export interface IConferenceState {
     followMeRecorderEnabled?: boolean;
     joining?: IJitsiConference;
     leaving?: IJitsiConference;
+    lobbyError?: boolean;
     lobbyWaitingForHost?: boolean;
     localSubject?: string;
     locked?: string;
@@ -363,13 +364,24 @@ function _conferenceFailed(state: IConferenceState, { conference, error }: {
     let membersOnly;
     let passwordRequired;
     let lobbyWaitingForHost;
+    let lobbyError;
 
     switch (error.name) {
     case JitsiConferenceErrors.AUTHENTICATION_REQUIRED:
         authRequired = conference;
         break;
 
+    /**
+     * Access denied while waiting in the lobby.
+     * A conference error when we tried to join into a room with no display name when lobby is enabled in the room.
+     */
     case JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED:
+    case JitsiConferenceErrors.DISPLAY_NAME_REQUIRED: {
+        lobbyError = true;
+
+        break;
+    }
+
     case JitsiConferenceErrors.MEMBERS_ONLY_ERROR: {
         membersOnly = conference;
 
@@ -393,6 +405,7 @@ function _conferenceFailed(state: IConferenceState, { conference, error }: {
         error,
         joining: undefined,
         leaving: undefined,
+        lobbyError,
         lobbyWaitingForHost,
 
         /**
@@ -450,6 +463,7 @@ function _conferenceJoined(state: IConferenceState, { conference }: { conference
         membersOnly: undefined,
         leaving: undefined,
 
+        lobbyError: undefined,
         lobbyWaitingForHost: undefined,
 
         /**

react/features/lobby/actions.any.ts

@@ -209,6 +209,8 @@ export function startKnocking() {
         logger.info(`Lobby starting knocking (membersOnly = ${membersOnly})`);
 
         if (!membersOnly) {
+            // let's hide the notification (the case with denied access and retrying)
+            dispatch(hideNotification(LOBBY_NOTIFICATION_ID));
 
             // no membersOnly, this means we got lobby screen shown as someone
             // tried to join a conference that has lobby enabled without setting display name

react/features/lobby/middleware.ts

@@ -43,6 +43,7 @@ import {
 import { INotificationProps } from '../notifications/types';
 import { open as openParticipantsPane } from '../participants-pane/actions';
 import { getParticipantsPaneOpen } from '../participants-pane/functions';
+import { PREJOIN_JOINING_IN_PROGRESS } from '../prejoin/actionTypes';
 import {
     isPrejoinEnabledInConfig,
     isPrejoinPageVisible,
@@ -108,6 +109,14 @@ MiddlewareRegistry.register(store => next => action => {
 
         return result;
     }
+    case PREJOIN_JOINING_IN_PROGRESS: {
+        if (action.value) {
+            // let's hide the notification (the case with denied access and retrying) when prejoin is enabled
+            store.dispatch(hideNotification(LOBBY_NOTIFICATION_ID));
+        }
+
+        break;
+    }
     }
 
     return next(action);
@@ -270,9 +279,8 @@ function _handleLobbyNotification(store: IStore) {
 function _conferenceFailed({ dispatch, getState }: IStore, next: Function, action: AnyAction) {
     const { error } = action;
     const state = getState();
-    const { membersOnly } = state['features/base/conference'];
+    const { lobbyError, membersOnly } = state['features/base/conference'];
     const nonFirstFailure = Boolean(membersOnly);
-    const { isDisplayNameRequiredError } = state['features/lobby'];
 
     if (error.name === JitsiConferenceErrors.MEMBERS_ONLY_ERROR) {
         if (typeof error.recoverable === 'undefined') {
@@ -288,7 +296,7 @@ function _conferenceFailed({ dispatch, getState }: IStore, next: Function, actio
 
         // if there was an error about display name and pre-join is not enabled
         if (shouldAutoKnock(state)
-                || (isDisplayNameRequiredError && !isPrejoinEnabledInConfig(state))
+                || (lobbyError && !isPrejoinEnabledInConfig(state))
                 || lobbyWaitingForHost) {
             dispatch(startKnocking());
         }
@@ -315,17 +323,23 @@ function _conferenceFailed({ dispatch, getState }: IStore, next: Function, actio
         return result;
     }
 
-    dispatch(hideLobbyScreen());
+    // if both are available pre-join is with priority (the case when pre-join is enabled)
+    if (isPrejoinPageVisible(state)) {
+        dispatch(hideLobbyScreen());
+    }
 
     if (error.name === JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED) {
         dispatch(
             showNotification({
                 appearance: NOTIFICATION_TYPE.ERROR,
                 hideErrorSupportLink: true,
                 titleKey: 'lobby.joinRejectedTitle',
+                uid: LOBBY_NOTIFICATION_ID,
                 descriptionKey: 'lobby.joinRejectedMessage'
-            }, NOTIFICATION_TIMEOUT_TYPE.LONG)
+            }, NOTIFICATION_TIMEOUT_TYPE.STICKY)
         );
+    } else {
+        dispatch(hideLobbyScreen());
     }
 
     return next(action);

react/features/lobby/reducer.ts

@@ -69,6 +69,7 @@ ReducerRegistry.register<ILobbyState>('features/lobby', (state = DEFAULT_STATE,
     case CONFERENCE_LEFT:
         return {
             ...state,
+            isDisplayNameRequiredError: false,
             knocking: false,
             passwordJoinFailed: false
         };

react/features/notifications/middleware.ts

@@ -77,6 +77,22 @@ const getNotifications = (state: IReduxState) => {
     return _visible ? notifications : [];
 };
 
+/**
+ * Check whether we need to clear notifications.
+ *
+ * @param {Object} state - Global state.
+ * @returns {boolean} - True if we need to clear any notification.
+ */
+const shouldClearNotifications = (state: IReduxState): boolean => {
+    // in case of lobby error, access is denied, the conference is cleared, but we still
+    // want to show the notification
+    if (state['features/base/conference'].lobbyError) {
+        return false;
+    }
+
+    return !getCurrentConference(state);
+};
+
 /**
  * Middleware that captures actions to display notifications.
  *
@@ -201,9 +217,9 @@ MiddlewareRegistry.register(store => next => action => {
  * conference, where we need to clean up the notifications.
  */
 StateListenerRegistry.register(
-    /* selector */ state => getCurrentConference(state),
-    /* listener */ (conference, { dispatch }) => {
-        if (!conference) {
+    /* selector */ state => shouldClearNotifications(state),
+    /* listener */ (clear, { dispatch }) => {
+        if (clear) {
             dispatch(clearNotifications());
         }
     }