feat(notifications) revisit timeouts and make them configurable

conference.js

     maybeOpenFeedbackDialog,
     submitFeedback
 } from './react/features/feedback';
-import { isModerationNotificationDisplayed, showNotification } from './react/features/notifications';
+import {
+    isModerationNotificationDisplayed,
+    showNotification,
+    NOTIFICATION_TIMEOUT_TYPE
+} from './react/features/notifications';
 import { mediaPermissionPromptVisibilityChanged, toggleSlowGUMOverlay } from './react/features/overlay';
 import { suspendDetected } from './react/features/power-monitor';
 import {
         case JitsiConferenceErrors.FOCUS_DISCONNECTED: {
             const [ focus, retrySec ] = params;
 
-            APP.UI.notifyFocusDisconnected(focus, retrySec);
+            APP.store.dispatch(showNotification({
+                descriptionKey: focus,
+                titleKey: retrySec
+            }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
             break;
         }
 
             APP.store.dispatch(showNotification({
                 descriptionKey: 'notify.startSilentDescription',
                 titleKey: 'notify.startSilentTitle'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
         }
 
         // XXX The API will take care of disconnecting from the XMPP
             }
 
             Promise.allSettled(promises)
-                .then(() => APP.UI.notifyInitiallyMuted());
+                .then(() => {
+                    APP.store.dispatch(showNotification({
+                        titleKey: 'notify.mutedTitle',
+                        descriptionKey: 'notify.muted'
+                    }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
+                });
         });
 
         room.on(

config.js

     //    resizeDesktopForPresenter: false
     // },
 
+    // Notification timeouts
+    // notificationTimeouts: {
+    //     short: 2500,
+    //     medium: 5000,
+    //     long: 10000
+    // },
+
     // // Options for the recording limit notification.
     // recordingLimit: {
     //

interface_config.js

      */
     // ANDROID_APP_PACKAGE: 'org.jitsi.meet',
 
-    /**
-     * Override the behavior of some notifications to remain displayed until
-     * explicitly dismissed through a user action. The value is how long, in
-     * milliseconds, those notifications should remain displayed.
-     */
-    // ENFORCE_NOTIFICATION_AUTO_DISMISS_TIMEOUT: 15000,
-
     // List of undocumented settings
     /**
      INDICATOR_FONT_SIZES

modules/UI/UI.js

 import { setColorAlpha } from '../../react/features/base/util';
 import { setDocumentUrl } from '../../react/features/etherpad';
 import { setFilmstripVisible } from '../../react/features/filmstrip';
-import { joinLeaveNotificationsDisabled, setNotificationsEnabled } from '../../react/features/notifications';
+import {
+    joinLeaveNotificationsDisabled,
+    setNotificationsEnabled,
+    showNotification,
+    NOTIFICATION_TIMEOUT_TYPE
+} from '../../react/features/notifications';
 import {
     dockToolbox,
     setToolboxEnabled,
 
     const displayName = user.getDisplayName();
 
-    messageHandler.participantNotification(
-        displayName,
-        '',
-        'connected',
-        'dialOut.statusMessage',
-        { status: UIUtil.escapeHtml(status) });
+    APP.store.dispatch(showNotification({
+        titleKey: `${displayName} connected`,
+        descriptionKey: 'dialOut.statusMessage'
+    }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
 };
 
 /**
     });
 };
 
-/**
- * Notify user that he was automatically muted when joned the conference.
- */
-UI.notifyInitiallyMuted = function() {
-    messageHandler.participantNotification(
-        null,
-        'notify.mutedTitle',
-        'connected',
-        'notify.muted',
-        null);
-};
-
 UI.handleLastNEndpoints = function(leavingIds, enteringIds) {
     VideoLayout.onLastNEndpointsChanged(leavingIds, enteringIds);
 };
     });
 };
 
-UI.notifyFocusDisconnected = function(focus, retrySec) {
-    messageHandler.participantNotification(
-        null, 'notify.focus',
-        'disconnected', 'notify.focusFail',
-        { component: focus,
-            ms: retrySec }
-    );
-};
-
 /**
  * Update list of available physical devices.
  */

modules/UI/util/MessageHandler.js

 /* global APP */
 
 import {
-    NOTIFICATION_TIMEOUT,
+    NOTIFICATION_TIMEOUT_TYPE,
     showErrorNotification,
-    showNotification,
     showWarningNotification
 } from '../../../react/features/notifications';
 
      * showErrorNotification action.
      */
     showError(props) {
-        APP.store.dispatch(showErrorNotification(props));
+        APP.store.dispatch(showErrorNotification(props, NOTIFICATION_TIMEOUT_TYPE.LONG));
     },
 
     /**
      * showWarningNotification action.
      */
     showWarning(props) {
-        APP.store.dispatch(showWarningNotification(props));
-    },
-
-    /**
-     * Displays a notification about participant action.
-     * @param displayName the display name of the participant that is
-     * associated with the notification.
-     * @param displayNameKey the key from the language file for the display
-     * name. Only used if displayName is not provided.
-     * @param cls css class for the notification
-     * @param messageKey the key from the language file for the text of the
-     * message.
-     * @param messageArguments object with the arguments for the message.
-     * @param optional configurations for the notification (e.g. timeout)
-     */
-    participantNotification( // eslint-disable-line max-params
-            displayName,
-            displayNameKey,
-            cls,
-            messageKey,
-            messageArguments,
-            timeout = NOTIFICATION_TIMEOUT) {
-        APP.store.dispatch(showNotification({
-            descriptionArguments: messageArguments,
-            descriptionKey: messageKey,
-            titleKey: displayNameKey,
-            title: displayName
-        },
-        timeout));
+        APP.store.dispatch(showWarningNotification(props, NOTIFICATION_TIMEOUT_TYPE.LONG));
     }
 };
 

react/features/app/actions.js

     toURLString
 } from '../base/util';
 import { isVpaasMeeting } from '../jaas/functions';
-import { clearNotifications, showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, clearNotifications, showNotification } from '../notifications';
 import { setFatalError } from '../overlay';
 
 import {
             dispatch(showNotification({
                 titleArguments: { appName: getName() },
                 titleKey: 'dialog.thankYou'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.STICKY));
         }
 
         // if Welcome page is enabled redirect to welcome page after 3 sec, if

react/features/av-moderation/middleware.js

 import { MiddlewareRegistry, StateListenerRegistry } from '../base/redux';
 import { playSound, registerSound, unregisterSound } from '../base/sounds';
 import {
+    NOTIFICATION_TIMEOUT_TYPE,
     hideNotification,
     showNotification
 } from '../notifications';
             sticky: true,
             titleKey,
             uid
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.STICKY));
 
         break;
     }
                         sticky: true,
                         customActionNameKey: 'notify.unmute',
                         customActionHandler: () => dispatch(muteLocal(false, MEDIA_TYPE.AUDIO))
-                    }));
+                    }, NOTIFICATION_TIMEOUT_TYPE.STICKY));
                     dispatch(playSound(ASKED_TO_UNMUTE_SOUND_ID));
                 }
             });

react/features/base/conference/middleware.any.js

 } from '../../analytics';
 import { reloadNow } from '../../app/actions';
 import { openDisplayNamePrompt } from '../../display-name';
-import { showErrorNotification } from '../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification } from '../../notifications';
 import { CONNECTION_ESTABLISHED, CONNECTION_FAILED, connectionDisconnected } from '../connection';
 import { validateJwt } from '../jwt';
 import { JitsiConferenceErrors } from '../lib-jitsi-meet';
         dispatch(showErrorNotification({
             description: reason,
             titleKey: 'dialog.sessTerminated'
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
         break;
     }
             dispatch(showErrorNotification({
                 description: 'Restart initiated because of a bridge failure',
                 titleKey: 'dialog.sessionRestarted'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
         }
 
         break;
             descriptionArguments: { msg },
             descriptionKey: msg ? 'dialog.connectErrorWithMsg' : 'dialog.connectError',
             titleKey: 'connection.CONNFAIL'
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
         break;
     }

react/features/base/config/configWhitelist.js

     'maxFullResolutionParticipants',
     'mouseMoveCallbackInterval',
     'notifications',
+    'notificationTimeouts',
     'openSharedDocumentOnJoin',
     'opusMaxAverageBitrate',
     'p2p',

react/features/base/config/interfaceConfigWhitelist.js

     'DISPLAY_WELCOME_PAGE_CONTENT',
     'ENABLE_DIAL_OUT',
     'ENABLE_FEEDBACK_ANIMATION',
-    'ENFORCE_NOTIFICATION_AUTO_DISMISS_TIMEOUT',
     'FILM_STRIP_MAX_HEIGHT',
     'GENERATE_ROOMNAMES_ON_WELCOME_PAGE',
     'HIDE_INVITE_MORE_HEADER',

react/features/base/devices/middleware.js

 
 import UIEvents from '../../../../service/UI/UIEvents';
 import { processExternalDeviceRequest } from '../../device-selection';
-import { showNotification, showWarningNotification } from '../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification, showWarningNotification } from '../../notifications';
 import { replaceAudioTrackById, replaceVideoTrackById, setDeviceStatusWarning } from '../../prejoin/actions';
 import { isPrejoinPageVisible } from '../../prejoin/functions';
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../app';
     }
 };
 
-const WARNING_DISPLAY_TIMER = 4000;
-
 /**
  * A listener for device permissions changed reported from lib-jitsi-meet.
  */
             description: additionalCameraErrorMsg,
             descriptionKey: cameraErrorMsg,
             titleKey
-        }, WARNING_DISPLAY_TIMER));
+        }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
         if (isPrejoinPageVisible(store.getState())) {
             store.dispatch(setDeviceStatusWarning(titleKey));
             description: additionalMicErrorMsg,
             descriptionKey: micErrorMsg,
             titleKey
-        }, WARNING_DISPLAY_TIMER));
+        }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
         if (isPrejoinPageVisible(store.getState())) {
             store.dispatch(setDeviceStatusWarning(titleKey));
                 titleKey,
                 customActionNameKey: 'notify.newDeviceAction',
                 customActionHandler: _useDevice.bind(undefined, store, devicesArray)
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
         }
     });
 }

react/features/base/participants/actions.js

-import { NOTIFICATION_TIMEOUT, showNotification } from '../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification } from '../../notifications';
 import { set } from '../redux';
 
 import {
             titleArguments: {
                 participantDisplayName: getParticipantDisplayName(getState, participant.getId())
             }
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
     };
 }
 
                     getParticipantDisplayName(getState, kicker.getId())
             },
             titleKey: 'notify.kickParticipant'
-        }, NOTIFICATION_TIMEOUT * 2)); // leave more time for this
+        }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
     };
 }
 

react/features/base/participants/middleware.js

 import { approveParticipant } from '../../av-moderation/actions';
 import { toggleE2EE } from '../../e2ee/actions';
 import { MAX_MODE } from '../../e2ee/constants';
-import { NOTIFICATION_TIMEOUT, showNotification } from '../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification } from '../../notifications';
 import { isForceMuted } from '../../participants-pane/functions';
 import { CALLING, INVITED } from '../../presence-status';
 import { RAISE_HAND_SOUND_ID } from '../../reactions/constants';
             raiseHandNotification: true,
             concatText: true,
             ...action
-        }, NOTIFICATION_TIMEOUT * (shouldDisplayAllowAction ? 2 : 1)));
+        }, shouldDisplayAllowAction ? NOTIFICATION_TIMEOUT_TYPE.MEDIUM : NOTIFICATION_TIMEOUT_TYPE.SHORT));
         dispatch(playSound(RAISE_HAND_SOUND_ID));
     }
 }

react/features/base/tracks/actions.js

     createTrackMutedEvent,
     sendAnalytics
 } from '../../analytics';
-import { showErrorNotification, showNotification } from '../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification, showNotification } from '../../notifications';
 import { JitsiTrackErrors, JitsiTrackEvents, createLocalTrack } from '../lib-jitsi-meet';
 import {
     CAMERA_FACING_MODE,
             const notificationAction = await dispatch(showErrorNotification({
                 descriptionKey: 'dialog.cameraNotSendingData',
                 titleKey: 'dialog.cameraNotSendingDataTitle'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
             notificationInfo = {
                 uid: notificationAction.uid
                     const notificationAction = await dispatch(showNotification({
                         descriptionKey: 'dialog.micNotSendingData',
                         titleKey: 'dialog.micNotSendingDataTitle'
-                    }));
+                    }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                     // Set the notification ID so that other parts of the application know that this was
                     // displayed in the context of the current device.
 
                     noDataFromSourceNotificationInfo = { uid: notificationAction.uid };
                 } else {
-                    const timeout = setTimeout(() => dispatch(showNoDataFromSourceVideoError(track)), 5000);
+                    const timeout = setTimeout(() => dispatch(
+                        showNoDataFromSourceVideoError(track)),
+                        NOTIFICATION_TIMEOUT_TYPE.MEDIUM);
 
                     noDataFromSourceNotificationInfo = { timeout };
                 }

react/features/conference/actions.web.js

 
 import { getParticipantDisplayName } from '../base/participants';
 import {
+    NOTIFICATION_TIMEOUT_TYPE,
     NOTIFICATION_TYPE,
     showNotification
 } from '../notifications';
             descriptionArguments: args,
             titleKey: 'dialog.kickTitle',
             titleArguments: args
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.STICKY));
     };
 }

react/features/conference/functions.web.js

 import { isSuboptimalBrowser } from '../base/environment';
 import { translateToHTML } from '../base/i18n';
-import { showWarningNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showWarningNotification } from '../notifications';
 
 export * from './functions.any';
 
                             recommendedBrowserPageLink: `${window.location.origin}/static/recommendedBrowsers.html`
                         }
                     )
-                }
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG
             )
         );
     }

react/features/invite/components/add-people-dialog/AbstractAddPeopleDialog.js

 
 import { createInviteDialogEvent, sendAnalytics } from '../../../analytics';
 import {
-    NOTIFICATION_TIMEOUT,
+    NOTIFICATION_TIMEOUT_TYPE,
     showNotification
 } from '../../../notifications';
 import { invite } from '../../actions';
 
                     if (notificationProps) {
                         dispatch(
-                            showNotification(notificationProps, NOTIFICATION_TIMEOUT));
+                            showNotification(notificationProps, NOTIFICATION_TIMEOUT_TYPE.SHORT));
                     }
                 }
 

react/features/lobby/middleware.js

 import { MiddlewareRegistry, StateListenerRegistry } from '../base/redux';
 import { playSound, registerSound, unregisterSound } from '../base/sounds';
 import { isTestModeEnabled } from '../base/testing';
-import { NOTIFICATION_TYPE, showNotification } from '../notifications';
+import {
+    NOTIFICATION_TIMEOUT_TYPE,
+    NOTIFICATION_TYPE,
+    showNotification
+} from '../notifications';
 import { shouldAutoKnock } from '../prejoin/functions';
 
 import { KNOCKING_PARTICIPANT_ARRIVED_OR_UPDATED } from './actionTypes';
 
             conference.on(JitsiConferenceEvents.LOBBY_USER_JOINED, (id, name) => {
                 batch(() => {
-                    dispatch(participantIsKnockingOrUpdated({
-                        id,
-                        name
-                    }));
+                    dispatch(
+                        participantIsKnockingOrUpdated({
+                            id,
+                            name
+                        })
+                    );
                     dispatch(playSound(KNOCKING_PARTICIPANT_SOUND_ID));
                     if (typeof APP !== 'undefined') {
                         APP.API.notifyKnockingParticipant({
             });
 
             conference.on(JitsiConferenceEvents.LOBBY_USER_UPDATED, (id, participant) => {
-                dispatch(participantIsKnockingOrUpdated({
-                    ...participant,
-                    id
-                }));
+                dispatch(
+                    participantIsKnockingOrUpdated({
+                        ...participant,
+                        id
+                    })
+                );
             });
 
             conference.on(JitsiConferenceEvents.LOBBY_USER_LEFT, id => {
                 })
             );
         }
-    });
+    }
+);
 
 /**
  * Function to handle the conference failed event and navigate the user to the lobby screen
     dispatch(hideLobbyScreen());
 
     if (error.name === JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED) {
-        dispatch(showNotification({
-            appearance: NOTIFICATION_TYPE.ERROR,
-            hideErrorSupportLink: true,
-            titleKey: 'lobby.joinRejectedMessage'
-        }));
+        dispatch(
+            showNotification({
+                appearance: NOTIFICATION_TYPE.ERROR,
+                hideErrorSupportLink: true,
+                titleKey: 'lobby.joinRejectedMessage'
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG)
+        );
     }
 
     return next(action);
     if (!disableThirdPartyRequests && updatedParticipant && !updatedParticipant.loadableAvatarUrl) {
         getFirstLoadableAvatarUrl(updatedParticipant, store).then(loadableAvatarUrl => {
             if (loadableAvatarUrl) {
-                dispatch(participantIsKnockingOrUpdated({
-                    loadableAvatarUrl,
-                    id
-                }));
+                dispatch(
+                    participantIsKnockingOrUpdated({
+                        loadableAvatarUrl,
+                        id
+                    })
+                );
             }
         });
     }
         break;
     }
 
-    dispatch(showNotification(notificationProps, isTestModeEnabled(getState()) ? undefined : 5000));
+    dispatch(
+        showNotification(
+            notificationProps,
+            isTestModeEnabled(getState()) ? NOTIFICATION_TIMEOUT_TYPE.STICKY : NOTIFICATION_TIMEOUT_TYPE.MEDIUM
+        )
+    );
 }

react/features/local-recording/middleware.js

 import { SET_AUDIO_MUTED } from '../base/media/actionTypes';
 import { MiddlewareRegistry } from '../base/redux';
 import { SETTINGS_UPDATED } from '../base/settings/actionTypes';
+import { NOTIFICATION_TIMEOUT_TYPE } from '../notifications';
 import { showNotification } from '../notifications/actions';
 
 import { localRecordingEngaged, localRecordingUnengaged } from './actions';
             dispatch(showNotification({
                 titleKey: 'localRecording.localRecording',
                 description: i18next.t(messageKey, messageParams)
-            }, 10000));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
         };
 
         recordingController.onNotify = (messageKey, messageParams) => {
             dispatch(showNotification({
                 titleKey: 'localRecording.localRecording',
                 description: i18next.t(messageKey, messageParams)
-            }, 10000));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
         };
 
         typeof APP === 'object' && typeof APP.keyboardshortcut === 'object'

react/features/no-audio-signal/middleware.js

 import { MiddlewareRegistry } from '../base/redux';
 import { updateSettings } from '../base/settings';
 import { playSound, registerSound, unregisterSound } from '../base/sounds';
-import { hideNotification, showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, hideNotification, showNotification } from '../notifications';
 
 import { setNoAudioSignalNotificationUid } from './actions';
 import DialInLink from './components/DialInLink';
             descriptionKey,
             customActionNameKey,
             customActionHandler
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
         dispatch(playSound(NO_AUDIO_SIGNAL_SOUND_ID));
 

react/features/noise-detection/middleware.js

 import { JitsiConferenceEvents } from '../base/lib-jitsi-meet';
 import { MiddlewareRegistry } from '../base/redux';
 import { playSound, registerSound, unregisterSound } from '../base/sounds';
-import { hideNotification, showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, hideNotification, showNotification } from '../notifications';
 
 import { setNoisyAudioInputNotificationUid } from './actions';
 import { NOISY_AUDIO_INPUT_SOUND_ID } from './constants';
                 const notification = await dispatch(showNotification({
                     titleKey: 'toolbar.noisyAudioInputTitle',
                     descriptionKey: 'toolbar.noisyAudioInputDesc'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
                 dispatch(playSound(NOISY_AUDIO_INPUT_SOUND_ID));
 

react/features/notifications/actions.js

     SHOW_NOTIFICATION
 } from './actionTypes';
 import {
+    NOTIFICATION_TIMEOUT_TYPE,
     NOTIFICATION_TIMEOUT,
     NOTIFICATION_TYPE,
     SILENT_JOIN_THRESHOLD
 } from './constants';
 
+/**
+ * Function that returns notification timeout value based on notification timeout type.
+ *
+ * @param {string} type - Notification type.
+ * @param {Object} notificationTimeouts - Config notification timeouts.
+ * @returns {number}
+ */
+function getNotificationTimeout(type: ?string, notificationTimeouts: ?Object) {
+    if (type === NOTIFICATION_TIMEOUT_TYPE.SHORT) {
+        return notificationTimeouts?.short ?? NOTIFICATION_TIMEOUT.SHORT;
+    } else if (type === NOTIFICATION_TIMEOUT_TYPE.MEDIUM) {
+        return notificationTimeouts?.medium ?? NOTIFICATION_TIMEOUT.MEDIUM;
+    } else if (type === NOTIFICATION_TIMEOUT_TYPE.LONG) {
+        return notificationTimeouts?.long ?? NOTIFICATION_TIMEOUT.LONG;
+    }
+
+    return NOTIFICATION_TIMEOUT.STICKY;
+}
+
 /**
  * Clears (removes) all the notifications.
  *
  * Queues an error notification for display.
  *
  * @param {Object} props - The props needed to show the notification component.
+ * @param {string} type - Notification type.
  * @returns {Object}
  */
-export function showErrorNotification(props: Object) {
+export function showErrorNotification(props: Object, type: ?string) {
     return showNotification({
         ...props,
         appearance: NOTIFICATION_TYPE.ERROR
-    });
+    }, type);
 }
 
 /**
  * Queues a notification for display.
  *
  * @param {Object} props - The props needed to show the notification component.
- * @param {number} timeout - How long the notification should display before
- * automatically being hidden.
+ * @param {string} type - Notification type.
  * @returns {Function}
  */
-export function showNotification(props: Object = {}, timeout: ?number) {
+export function showNotification(props: Object = {}, type: ?string) {
     return function(dispatch: Function, getState: Function) {
-        const { notifications } = getState()['features/base/config'];
+        const { notifications, notificationTimeouts } = getState()['features/base/config'];
         const enabledFlag = getFeatureFlag(getState(), NOTIFICATIONS_ENABLED, true);
 
         const shouldDisplay = enabledFlag
             return dispatch({
                 type: SHOW_NOTIFICATION,
                 props,
-                timeout,
+                timeout: getNotificationTimeout(type, notificationTimeouts),
                 uid: props.uid || window.Date.now().toString()
             });
         }
  * Queues a warning notification for display.
  *
  * @param {Object} props - The props needed to show the notification component.
- * @param {number} timeout - How long the notification should display before
- * automatically being hidden.
+ * @param {string} type - Notification type.
  * @returns {Object}
  */
-export function showWarningNotification(props: Object, timeout: ?number) {
+export function showWarningNotification(props: Object, type: ?string) {
+
     return showNotification({
         ...props,
         appearance: NOTIFICATION_TYPE.WARNING
-    }, timeout);
+    }, type);
 }
 
 /**
 
     if (notificationProps) {
         dispatch(
-            showNotification(notificationProps, NOTIFICATION_TIMEOUT));
+            showNotification(notificationProps, NOTIFICATION_TIMEOUT_TYPE.SHORT));
     }
 
     joinedParticipantsNames = [];

react/features/notifications/components/web/NotificationsContainer.js

 
 import Notification from './Notification';
 
-declare var interfaceConfig: Object;
-
 type Props = {
 
     /**
      */
     _notifications: Array<Object>,
 
-    /**
-     * The length, in milliseconds, to use as a default timeout for all
-     * dismissible timeouts that do not have a timeout specified.
-     */
-    autoDismissTimeout: number,
-
     /**
      * JSS classes object.
      */
      * @returns {void}
      */
     _updateTimeouts() {
-        const { _notifications, autoDismissTimeout } = this.props;
+        const { _notifications } = this.props;
 
         for (const notification of _notifications) {
-            if ((notification.timeout || typeof autoDismissTimeout === 'number')
+            if (notification.timeout
                     && notification.props.isDismissAllowed !== false
                     && !this._timeouts.has(notification.uid)) {
                 const {
-                    timeout = autoDismissTimeout,
+                    timeout,
                     uid
                 } = notification;
                 const timerID = setTimeout(() => {
     return {
         _iAmSipGateway: Boolean(iAmSipGateway),
         _isChatOpen: isChatOpen,
-        _notifications: _visible ? notifications : [],
-        autoDismissTimeout: interfaceConfig.ENFORCE_NOTIFICATION_AUTO_DISMISS_TIMEOUT
+        _notifications: _visible ? notifications : []
     };
 }
 

react/features/notifications/constants.js

 /**
  * The standard time when auto-disappearing notifications should disappear.
  */
-export const NOTIFICATION_TIMEOUT = 2500;
+export const NOTIFICATION_TIMEOUT = {
+    SHORT: 2500,
+    MEDIUM: 5000,
+    LONG: 10000,
+    STICKY: false
+};
+
+/**
+ * Notification timeout type.
+ */
+export const NOTIFICATION_TIMEOUT_TYPE = {
+    SHORT: 'short',
+    MEDIUM: 'medium',
+    LONG: 'long',
+    STICKY: 'sticky'
+};
 
 /**
  * The set of possible notification types.

react/features/notifications/middleware.js

     showNotification,
     showParticipantJoinedNotification
 } from './actions';
-import { NOTIFICATION_TIMEOUT } from './constants';
+import { NOTIFICATION_TIMEOUT_TYPE } from './constants';
 import { joinLeaveNotificationsDisabled } from './functions';
 
 declare var interfaceConfig: Object;
                 action.participant.id
             );
 
-            if (typeof interfaceConfig === 'object'
-                && participant
-                && !participant.local
-                && !action.participant.isReplaced) {
+            if (participant && !participant.local && !action.participant.isReplaced) {
                 store.dispatch(showNotification({
                     descriptionKey: 'notify.disconnected',
                     titleKey: 'notify.somebody',
                     title: participant.name
-                }, NOTIFICATION_TIMEOUT));
+                }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
             }
         }
 
             store.dispatch(showNotification({
                 titleKey: 'notify.moderator'
             },
-            NOTIFICATION_TIMEOUT));
+            NOTIFICATION_TIMEOUT_TYPE.SHORT));
         }
 
         return next(action);

react/features/old-client-notification/middleware.js

 
 import { APP_WILL_MOUNT } from '../base/app';
 import { MiddlewareRegistry } from '../base/redux';
-import { showErrorNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification } from '../notifications';
 
 import { OldElectronAPPNotificationDescription } from './components';
 import { isOldJitsiMeetElectronApp } from './functions';
         dispatch(showErrorNotification({
             titleKey: 'notify.OldElectronAPPTitle',
             description: <OldElectronAPPNotificationDescription />
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
     }
 
     return next(action);

react/features/polls/subscriber.js

 import { JitsiConferenceEvents } from '../base/lib-jitsi-meet';
 import { StateListenerRegistry } from '../base/redux';
 import {
-    NOTIFICATION_TIMEOUT,
+    NOTIFICATION_TIMEOUT_TYPE,
     NOTIFICATION_TYPE,
     showNotification
 } from '../notifications';
                         appearance: NOTIFICATION_TYPE.NORMAL,
                         titleKey: 'polls.notification.title',
                         descriptionKey: 'polls.notification.description'
-                    }, NOTIFICATION_TIMEOUT));
+                    }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
                     break;
 
                 }

react/features/prejoin/actions.js

 } from '../base/tracks';
 import { openURLInBrowser } from '../base/util';
 import { executeDialOutRequest, executeDialOutStatusRequest, getDialInfoPageURL } from '../invite/functions';
-import { showErrorNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification } from '../notifications';
 
 import {
     PREJOIN_JOINING_IN_PROGRESS,
             case DIAL_OUT_STATUS.DISCONNECTED: {
                 dispatch(showErrorNotification({
                     titleKey: 'prejoin.errorDialOutDisconnected'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                 return onFail();
             }
             case DIAL_OUT_STATUS.FAILED: {
                 dispatch(showErrorNotification({
                     titleKey: 'prejoin.errorDialOutFailed'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                 return onFail();
             }
         } catch (err) {
             dispatch(showErrorNotification({
                 titleKey: 'prejoin.errorDialOutStatus'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
             logger.error('Error getting dial out status', err);
             onFail();
         }
                 }
             }
 
-            dispatch(showErrorNotification(notification));
+            dispatch(showErrorNotification(notification, NOTIFICATION_TIMEOUT_TYPE.LONG));
             logger.error('Error dialing out', err);
             onFail();
         }

react/features/reactions/middleware.js

 import { SETTINGS_UPDATED, updateSettings } from '../base/settings';
 import { playSound, registerSound, unregisterSound } from '../base/sounds';
 import { getDisabledSounds } from '../base/sounds/functions.any';
-import { NOTIFICATION_TIMEOUT, showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification } from '../notifications';
 
 import {
     ADD_REACTION_BUFFER,
             customActionHandler: () => dispatch(updateSettings({
                 soundsReactions: false
             }))
-        }, NOTIFICATION_TIMEOUT));
+        }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
         break;
     }
     }

react/features/recording/actions.any.js

 import { copyText } from '../base/util/helpers';
 import { getVpaasTenant, isVpaasMeeting } from '../jaas/functions';
 import {
-    NOTIFICATION_TIMEOUT,
+    NOTIFICATION_TIMEOUT_TYPE,
     hideNotification,
     showErrorNotification,
     showNotification,
         const notification = await dispatch(showNotification({
             isDismissAllowed: false,
             ...dialogProps
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
         if (notification) {
             dispatch(_setPendingRecordingNotificationUid(notification.uid, streamType));
  * @returns {showErrorNotification}
  */
 export function showRecordingError(props: Object) {
-    return showErrorNotification(props);
+    return showErrorNotification(props, NOTIFICATION_TIMEOUT_TYPE.LONG);
 }
 
 /**
         titleKey: 'dialog.recording'
     };
 
-    return showNotification(dialogProps, NOTIFICATION_TIMEOUT);
+    return showNotification(dialogProps, NOTIFICATION_TIMEOUT_TYPE.SHORT);
 }
 
 /**
                 } catch (err) {
                     dispatch(showErrorNotification({
                         titleKey: 'recording.errorFetchingLink'
-                    }));
+                    }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
                     return logger.error('Could not fetch recording link', err);
                 }
             }
         }
 
-        dispatch(showNotification(dialogProps, NOTIFICATION_TIMEOUT));
+        dispatch(showNotification(dialogProps, NOTIFICATION_TIMEOUT_TYPE.SHORT));
     };
 }
 

react/features/recording/actions.native.js

 // @flow
 
 import JitsiMeetJS from '../base/lib-jitsi-meet';
-import { showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification } from '../notifications';
 
 export * from './actions.any';
 
             descriptionKey,
             titleKey,
             maxLines: 2
-        }, 10000));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
     };
 }

react/features/recording/actions.web.js

 import React from 'react';
 
 import JitsiMeetJS from '../base/lib-jitsi-meet';
-import { showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification } from '../notifications';
 
 import { RecordingLimitNotificationDescription } from './components';
 
     return showNotification({
         description: <RecordingLimitNotificationDescription isLiveStreaming = { isLiveStreaming } />,
         titleKey: isLiveStreaming ? 'dialog.liveStreaming' : 'dialog.recording'
-    }, 10000);
+    }, NOTIFICATION_TIMEOUT_TYPE.LONG);
 }

react/features/recording/components/Recording/AbstractStartRecordingDialog.js

     getNewAccessToken,
     updateDropboxToken
 } from '../../../dropbox';
-import { showErrorNotification } from '../../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification } from '../../../notifications';
 import { toggleRequestingSubtitles } from '../../../subtitles';
 import { setSelectedRecordingService } from '../../actions';
 import { RECORDING_TYPES } from '../../constants';
             } else {
                 dispatch(showErrorNotification({
                     titleKey: 'dialog.noDropboxToken'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                 return;
             }

react/features/remote-control/actions.js

 import { JitsiConferenceEvents } from '../base/lib-jitsi-meet';
 import { getParticipantDisplayName, getPinnedParticipant, pinParticipant } from '../base/participants';
 import { getLocalVideoTrack } from '../base/tracks';
-import { showNotification } from '../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showNotification } from '../notifications';
 
 import {
     CAPTURE_EVENTS,
                 descriptionArguments: { user: getParticipantDisplayName(state, participantId) },
                 descriptionKey,
                 titleKey: 'dialog.remoteControlTitle'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
             if (permissionGranted) {
                 // the remote control permissions has been granted
         dispatch(showNotification({
             descriptionKey: 'dialog.remoteControlStopMessage',
             titleKey: 'dialog.remoteControlTitle'
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
     };
 }
 
             dispatch(showNotification({
                 descriptionKey: 'dialog.remoteControlStopMessage',
                 titleKey: 'dialog.remoteControlTitle'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
         }
     };
 }
                 dispatch(showNotification({
                     descriptionKey: 'dialog.startRemoteControlErrorMessage',
                     titleKey: 'dialog.remoteControlTitle'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                 dispatch(stopReceiver(true));
             });

react/features/room-lock/middleware.js

 import { JitsiConferenceErrors } from '../base/lib-jitsi-meet';
 import { MiddlewareRegistry } from '../base/redux';
 import {
-    NOTIFICATION_TIMEOUT,
+    NOTIFICATION_TIMEOUT_TYPE,
     showNotification
 } from '../notifications';
 
             store.dispatch(
                 showNotification({
                     titleKey: 'notify.passwordSetRemotely'
-                }, NOTIFICATION_TIMEOUT));
+                }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
         } else if (previousLockedState === LOCKED_REMOTELY && !currentLockedState) {
             store.dispatch(
                 showNotification({
                     titleKey: 'notify.passwordRemovedRemotely'
-                }, NOTIFICATION_TIMEOUT));
+                }, NOTIFICATION_TIMEOUT_TYPE.SHORT));
         }
 
         return result;

react/features/shared-video/components/web/AbstractVideoManager.js

 import { MEDIA_TYPE } from '../../../base/media';
 import { getLocalParticipant } from '../../../base/participants';
 import { isLocalTrackMuted } from '../../../base/tracks';
+import { NOTIFICATION_TIMEOUT_TYPE } from '../../../notifications';
 import { showWarningNotification } from '../../../notifications/actions';
 import { dockToolbox } from '../../../toolbox/actions.web';
 import { muteLocal } from '../../../video-menu/actions.any';
         _displayWarning: () => {
             dispatch(showWarningNotification({
                 titleKey: 'dialog.shareVideoLinkError'
-            }));
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG));
         },
         _dockToolbox: value => {
             dispatch(dockToolbox(value));

react/features/stream-effects/virtual-background/index.js

 // @flow
 
+import { NOTIFICATION_TIMEOUT_TYPE } from '../../notifications';
 import { showWarningNotification } from '../../notifications/actions';
 import { timeout } from '../../virtual-background/functions';
 import logger from '../../virtual-background/logger';
                 logger.error('Failed to download tflite model!');
                 dispatch(showWarningNotification({
                     titleKey: 'virtualBackground.backgroundEffectError'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
             } else {
                 logger.error('Looks like WebAssembly is disabled or not supported on this browser');
                 dispatch(showWarningNotification({
                     titleKey: 'virtualBackground.webAssemblyWarning',
                     description: 'WebAssembly disabled or not supported by this browser'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
             }
 
             return;

react/features/talk-while-muted/middleware.js

 import { MiddlewareRegistry } from '../base/redux';
 import { playSound, registerSound, unregisterSound } from '../base/sounds';
 import {
+    NOTIFICATION_TIMEOUT_TYPE,
     hideNotification,
     showNotification
 } from '../notifications';
                     titleKey: 'toolbar.talkWhileMutedPopup',
                     customActionNameKey: forceMuted ? 'notify.raiseHandAction' : 'notify.unmute',
                     customActionHandler: () => dispatch(forceMuted ? raiseHand(true) : setAudioMuted(false))
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                 const { soundsTalkWhileMuted } = getState()['features/base/settings'];
 

react/features/transcribing/actions.js

 // @flow
 
 import {
-    NOTIFICATION_TIMEOUT,
+    NOTIFICATION_TIMEOUT_TYPE,
     hideNotification,
     showErrorNotification,
     showNotification
             descriptionKey: 'transcribing.pending',
             isDismissAllowed: false,
             titleKey: 'dialog.transcribing'
-        }));
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
         if (notification) {
             dispatch(setPendingTranscribingNotificationUid(notification.uid));
     return showNotification({
         descriptionKey: 'transcribing.off',
         titleKey: 'dialog.transcribing'
-    }, NOTIFICATION_TIMEOUT);
+    }, NOTIFICATION_TIMEOUT_TYPE.SHORT);
 }
 
 
     return showErrorNotification({
         descriptionKey: 'transcribing.error',
         titleKey: 'transcribing.failedToStart'
-    });
+    }, NOTIFICATION_TIMEOUT_TYPE.LONG);
 }

react/features/videosipgw/middleware.js

 } from '../base/lib-jitsi-meet';
 import { MiddlewareRegistry } from '../base/redux';
 import {
+    NOTIFICATION_TIMEOUT_TYPE,
     showErrorNotification,
     showNotification,
     showWarningNotification
                     dispatch(showErrorNotification({
                         descriptionKey: 'videoSIPGW.errorInvite',
                         titleKey: 'videoSIPGW.errorInviteTitle'
-                    }));
+                    }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                     return;
                 }
                     dispatch(showWarningNotification({
                         titleKey: 'videoSIPGW.errorAlreadyInvited',
                         titleArguments: { displayName }
-                    }));
+                    }, NOTIFICATION_TIMEOUT_TYPE.LONG));
 
                     return;
                 }
             titleArguments: {
                 displayName: event.displayName
             }
-        }, 2000);
+        }, NOTIFICATION_TIMEOUT_TYPE.SHORT);
     }
     case JitsiSIPVideoGWStatus.STATE_FAILED: {
         return showErrorNotification({
                 displayName: event.displayName
             },
             descriptionKey: 'videoSIPGW.errorInviteFailed'
-        });
+        }, NOTIFICATION_TIMEOUT_TYPE.LONG);
     }
     case JitsiSIPVideoGWStatus.STATE_OFF: {
         if (event.failureReason === JitsiSIPVideoGWStatus.STATUS_BUSY) {
             return showErrorNotification({
                 descriptionKey: 'videoSIPGW.busy',
                 titleKey: 'videoSIPGW.busyTitle'
-            });
+            }, NOTIFICATION_TIMEOUT_TYPE.LONG);
         } else if (event.failureReason) {
             logger.error(`Unknown sip videogw error ${event.newState} ${
                 event.failureReason}`);

react/features/virtual-background/components/VirtualBackgroundDialog.js

 import { updateSettings } from '../../base/settings';
 import { Tooltip } from '../../base/tooltip';
 import { getLocalVideoTrack } from '../../base/tracks';
-import { showErrorNotification } from '../../notifications';
+import { NOTIFICATION_TIMEOUT_TYPE, showErrorNotification } from '../../notifications';
 import { toggleBackgroundEffect, virtualBackgroundTrackChanged } from '../actions';
 import { IMAGES, BACKGROUNDS_LIMIT, VIRTUAL_BACKGROUND_TYPE, type Image } from '../constants';
 import { toDataURL } from '../functions';
             if (!isCancelled) {
                 dispatch(showErrorNotification({
                     titleKey: 'virtualBackground.desktopShareError'
-                }));
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG));
                 logger.error('Could not create desktop share as a virtual background!');
             }
 

react/features/virtual-background/components/VirtualBackgroundPreview.js

 import { connect, equals } from '../../base/redux';
 import { getCurrentCameraDeviceId } from '../../base/settings';
 import { createLocalTracksF } from '../../base/tracks/functions';
+import { NOTIFICATION_TIMEOUT_TYPE } from '../../notifications';
 import { showWarningNotification } from '../../notifications/actions';
 import { toggleBackgroundEffect } from '../actions';
 import { VIRTUAL_BACKGROUND_TYPE } from '../constants';
                 showWarningNotification({
                     titleKey: 'virtualBackground.backgroundEffectError',
                     description: 'Failed to access camera device.'
-                })
+                }, NOTIFICATION_TIMEOUT_TYPE.LONG)
             );
             logger.error('Failed to access camera device. Error on apply background effect.');