fix(remote-control) Fix caps lock key name (#14821)

- this was causing a crash on the controlled meeting instance

conference.js

@@ -4,7 +4,6 @@ import { jitsiLocalStorage } from '@jitsi/js-utils';
 import Logger from '@jitsi/logger';
 
 import { ENDPOINT_TEXT_MESSAGE_NAME } from './modules/API/constants';
-import { AUDIO_ONLY_SCREEN_SHARE_NO_TRACK } from './modules/UI/UIErrors';
 import mediaDeviceHelper from './modules/devices/mediaDeviceHelper';
 import Recorder from './modules/recorder/Recorder';
 import { createTaskQueue } from './modules/util/helpers';
@@ -17,7 +16,6 @@ import {
 import { sendAnalytics } from './react/features/analytics/functions';
 import {
     maybeRedirectToWelcomePage,
-    redirectToStaticPage,
     reloadWithStoredParams
 } from './react/features/app/actions';
 import { showModeratedNotification } from './react/features/av-moderation/actions';
@@ -77,7 +75,6 @@ import {
     JitsiConferenceEvents,
     JitsiE2ePingEvents,
     JitsiMediaDevicesEvents,
-    JitsiTrackErrors,
     JitsiTrackEvents,
     browser
 } from './react/features/base/lib-jitsi-meet';
@@ -118,8 +115,11 @@ import {
 import { updateSettings } from './react/features/base/settings/actions';
 import {
     addLocalTrack,
+    createInitialAVTracks,
     destroyLocalTracks,
+    displayErrorsForCreateInitialLocalTracks,
     replaceLocalTrack,
+    setGUMPendingStateOnFailedTracks,
     toggleScreensharing as toggleScreensharingA,
     trackAdded,
     trackRemoved
@@ -276,12 +276,6 @@ class ConferenceConnector {
 
         switch (err) {
 
-        case JitsiConferenceErrors.NOT_ALLOWED_ERROR: {
-            // let's show some auth not allowed page
-            APP.store.dispatch(redirectToStaticPage('static/authError.html'));
-            break;
-        }
-
         case JitsiConferenceErrors.RESERVATION_ERROR: {
             const [ code, msg ] = params;
 
@@ -391,27 +385,6 @@ function disconnect() {
     return APP.connection.disconnect().then(onDisconnected, onDisconnected);
 }
 
-/**
- * Sets the GUM pending state for the tracks that have failed.
- *
- * NOTE: Some of the track that we will be setting to GUM pending state NONE may not have failed but they may have
- * been requested. This won't be a problem because their current GUM pending state will be NONE anyway.
- * @param {JitsiLocalTrack} tracks - The tracks that have been created.
- * @returns {void}
- */
-function setGUMPendingStateOnFailedTracks(tracks) {
-    const tracksTypes = tracks.map(track => {
-        if (track.getVideoType() === VIDEO_TYPE.DESKTOP) {
-            return MEDIA_TYPE.SCREENSHARE;
-        }
-
-        return track.getType();
-    });
-    const nonPendingTracks = [ MEDIA_TYPE.AUDIO, MEDIA_TYPE.VIDEO ].filter(type => !tracksTypes.includes(type));
-
-    APP.store.dispatch(gumPending(nonPendingTracks, IGUMPendingState.NONE));
-}
-
 export default {
     /**
      * Flag used to delay modification of the muted status of local media tracks
@@ -510,57 +483,12 @@ export default {
                     return [];
                 });
         } else if (requestedAudio || requestedVideo) {
-            APP.store.dispatch(gumPending(initialDevices, IGUMPendingState.PENDING_UNMUTE));
-            tryCreateLocalTracks = createLocalTracksF({
+            tryCreateLocalTracks = APP.store.dispatch(createInitialAVTracks({
                 devices: initialDevices,
                 timeout,
                 firePermissionPromptIsShownEvent: true
-            })
-            .catch(async error => {
-                if (error.name === JitsiTrackErrors.TIMEOUT && !browser.isElectron()) {
-                    errors.audioAndVideoError = error;
-
-                    return [];
-                }
-
-                // Retry with separate gUM calls.
-                const gUMPromises = [];
-                const tracks = [];
-
-                if (requestedAudio) {
-                    gUMPromises.push(createLocalTracksF(audioOptions));
-                }
-
-                if (requestedVideo) {
-                    gUMPromises.push(createLocalTracksF({
-                        devices: [ MEDIA_TYPE.VIDEO ],
-                        timeout,
-                        firePermissionPromptIsShownEvent: true
-                    }));
-                }
-
-                const results = await Promise.allSettled(gUMPromises);
-                let errorMsg;
-
-                results.forEach((result, idx) => {
-                    if (result.status === 'fulfilled') {
-                        tracks.push(result.value[0]);
-                    } else {
-                        errorMsg = result.reason;
-                        const isAudio = idx === 0;
-
-                        logger.error(`${isAudio ? 'Audio' : 'Video'} track creation failed with error ${errorMsg}`);
-                        if (isAudio) {
-                            errors.audioOnlyError = errorMsg;
-                        } else {
-                            errors.videoOnlyError = errorMsg;
-                        }
-                    }
-                });
-
-                if (errors.audioOnlyError && errors.videoOnlyError) {
-                    errors.audioAndVideoError = errorMsg;
-                }
+            })).then(({ tracks, errors: pErrors }) => {
+                Object.assign(errors, pErrors);
 
                 return tracks;
             });
@@ -581,42 +509,6 @@ export default {
         };
     },
 
-    /**
-     * Displays error notifications according to the state carried by {@code errors} object returned
-     * by {@link createInitialLocalTracks}.
-     * @param {Object} errors - the errors (if any) returned by {@link createInitialLocalTracks}.
-     *
-     * @returns {void}
-     * @private
-     */
-    _displayErrorsForCreateInitialLocalTracks(errors) {
-        const {
-            audioAndVideoError,
-            audioOnlyError,
-            screenSharingError,
-            videoOnlyError
-        } = errors;
-
-        // FIXME If there will be microphone error it will cover any screensharing dialog, but it's still better than in
-        // the reverse order where the screensharing dialog will sometimes be closing the microphone alert
-        // ($.prompt.close(); is called). Need to figure out dialogs chaining to fix that.
-        if (screenSharingError) {
-            this._handleScreenSharingError(screenSharingError);
-        }
-        if (audioAndVideoError || audioOnlyError) {
-            if (audioOnlyError || videoOnlyError) {
-                // If both requests for 'audio' + 'video' and 'audio' only failed, we assume that there are some
-                // problems with user's microphone and show corresponding dialog.
-                APP.store.dispatch(notifyMicError(audioOnlyError));
-                APP.store.dispatch(notifyCameraError(videoOnlyError));
-            } else {
-                // If request for 'audio' + 'video' failed, but request for 'audio' only was OK, we assume that we had
-                // problems with camera and show corresponding dialog.
-                APP.store.dispatch(notifyCameraError(audioAndVideoError));
-            }
-        }
-    },
-
     startConference(tracks) {
         tracks.forEach(track => {
             if ((track.isAudioTrack() && this.isLocalAudioMuted())
@@ -732,11 +624,11 @@ export default {
 
             logger.debug('Prejoin screen no longer displayed at the time when tracks were created');
 
-            this._displayErrorsForCreateInitialLocalTracks(errors);
+            APP.store.dispatch(displayErrorsForCreateInitialLocalTracks(errors));
 
             const tracks = handleInitialTracks(initialOptions, localTracks);
 
-            setGUMPendingStateOnFailedTracks(tracks);
+            setGUMPendingStateOnFailedTracks(tracks, APP.store.dispatch);
 
             return this._setLocalAudioVideoStreams(tracks);
         }
@@ -745,7 +637,7 @@ export default {
 
         return Promise.all([
             tryCreateLocalTracks.then(tr => {
-                this._displayErrorsForCreateInitialLocalTracks(errors);
+                APP.store.dispatch(displayErrorsForCreateInitialLocalTracks(errors));
 
                 return tr;
             }).then(tr => {
@@ -753,7 +645,7 @@ export default {
 
                 const filteredTracks = handleInitialTracks(initialOptions, tr);
 
-                setGUMPendingStateOnFailedTracks(filteredTracks);
+                setGUMPendingStateOnFailedTracks(filteredTracks, APP.store.dispatch);
 
                 return filteredTracks;
             }),
@@ -1234,7 +1126,7 @@ export default {
         const { tryCreateLocalTracks, errors } = this.createInitialLocalTracks(options);
         const localTracks = await tryCreateLocalTracks;
 
-        this._displayErrorsForCreateInitialLocalTracks(errors);
+        APP.store.dispatch(displayErrorsForCreateInitialLocalTracks(errors));
         localTracks.forEach(track => {
             if ((track.isAudioTrack() && this.isLocalAudioMuted())
                 || (track.isVideoTrack() && this.isLocalVideoMuted())) {
@@ -1574,50 +1466,6 @@ export default {
         });
     },
 
-    /**
-     * Handles {@link JitsiTrackError} returned by the lib-jitsi-meet when
-     * trying to create screensharing track. It will either do nothing if
-     * the dialog was canceled on user's request or display an error if
-     * screensharing couldn't be started.
-     * @param {JitsiTrackError} error - The error returned by
-     * {@link _createDesktopTrack} Promise.
-     * @private
-     */
-    _handleScreenSharingError(error) {
-        if (error.name === JitsiTrackErrors.SCREENSHARING_USER_CANCELED) {
-            return;
-        }
-
-        logger.error('failed to share local desktop', error);
-
-        // Handling:
-        // JitsiTrackErrors.CONSTRAINT_FAILED
-        // JitsiTrackErrors.PERMISSION_DENIED
-        // JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR
-        // and any other
-        let descriptionKey;
-        let titleKey;
-
-        if (error.name === JitsiTrackErrors.PERMISSION_DENIED) {
-            descriptionKey = 'dialog.screenSharingPermissionDeniedError';
-            titleKey = 'dialog.screenSharingFailedTitle';
-        } else if (error.name === JitsiTrackErrors.CONSTRAINT_FAILED) {
-            descriptionKey = 'dialog.cameraConstraintFailedError';
-            titleKey = 'deviceError.cameraError';
-        } else if (error.name === JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR) {
-            descriptionKey = 'dialog.screenSharingFailed';
-            titleKey = 'dialog.screenSharingFailedTitle';
-        } else if (error === AUDIO_ONLY_SCREEN_SHARE_NO_TRACK) {
-            descriptionKey = 'notify.screenShareNoAudio';
-            titleKey = 'notify.screenShareNoAudioTitle';
-        }
-
-        APP.store.dispatch(showErrorNotification({
-            descriptionKey,
-            titleKey
-        }, NOTIFICATION_TIMEOUT_TYPE.LONG));
-    },
-
     /**
      * Setup interaction between conference and UI.
      */

lang/main.json

@@ -319,6 +319,7 @@
         "embedMeeting": "Embed meeting",
         "enterDisplayName": "Enter your name",
         "error": "Error",
+        "errorRoomCreationRestriction": "You tried to join too quickly, please come back in a bit.",
         "gracefulShutdown": "Our service is currently down for maintenance. Please try again later.",
         "grantModeratorDialog": "Are you sure you want to grant moderator rights to {{participantName}}?",
         "grantModeratorTitle": "Grant moderator rights",
@@ -1483,6 +1484,10 @@
         "notification": {
             "demoteDescription": "Sent here by {{actor}}, raise your hand to participate",
             "description": "To participate raise your hand",
+            "noMainParticipantsDescription": "A participant needs to start the meeting. Please try again in a bit.",
+            "noMainParticipantsTitle": "This meeting hasn’t started yet.",
+            "noVisitorLobby": "You cannot join while there is a lobby enabled for the meeting.",
+            "notAllowedPromotion": "A participant needs to allow your request first.",
             "title": "You are a visitor in the meeting"
         }
     },

package-lock.json

@@ -61,7 +61,7 @@
         "js-md5": "0.6.1",
         "js-sha512": "0.8.0",
         "jwt-decode": "2.2.0",
-        "lib-jitsi-meet": "https://github.com/jitsi/lib-jitsi-meet/releases/download/v1813.0.0+09993fc8/lib-jitsi-meet.tgz",
+        "lib-jitsi-meet": "https://github.com/jitsi/lib-jitsi-meet#release-7952",
         "lodash": "4.17.21",
         "moment": "2.29.4",
         "moment-duration-format": "2.2.2",
@@ -12866,8 +12866,7 @@
     },
     "node_modules/lib-jitsi-meet": {
       "version": "0.0.0",
-      "resolved": "https://github.com/jitsi/lib-jitsi-meet/releases/download/v1813.0.0+09993fc8/lib-jitsi-meet.tgz",
-      "integrity": "sha512-b2qDjrDHEeaxxGbQW4OWUKDQyLvWMDZtv85CJ0zqk1ZPr+Ea3OvQP329GPfKA/0Sjm//k+bKiNFH99WDvoSbrg==",
+      "resolved": "git+ssh://git@github.com/jitsi/lib-jitsi-meet.git#c892e8b3398b7c0bdae0ae96da40d4b74b990742",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -29374,8 +29373,8 @@
       }
     },
     "lib-jitsi-meet": {
-      "version": "https://github.com/jitsi/lib-jitsi-meet/releases/download/v1813.0.0+09993fc8/lib-jitsi-meet.tgz",
-      "integrity": "sha512-b2qDjrDHEeaxxGbQW4OWUKDQyLvWMDZtv85CJ0zqk1ZPr+Ea3OvQP329GPfKA/0Sjm//k+bKiNFH99WDvoSbrg==",
+      "version": "git+ssh://git@github.com/jitsi/lib-jitsi-meet.git#c892e8b3398b7c0bdae0ae96da40d4b74b990742",
+      "from": "lib-jitsi-meet@https://github.com/jitsi/lib-jitsi-meet#release-7952",
       "requires": {
         "@jitsi/js-utils": "2.2.1",
         "@jitsi/logger": "2.0.2",

package.json

@@ -67,7 +67,7 @@
     "js-md5": "0.6.1",
     "js-sha512": "0.8.0",
     "jwt-decode": "2.2.0",
-    "lib-jitsi-meet": "https://github.com/jitsi/lib-jitsi-meet/releases/download/v1813.0.0+09993fc8/lib-jitsi-meet.tgz",
+    "lib-jitsi-meet": "https://github.com/jitsi/lib-jitsi-meet#release-7952",
     "lodash": "4.17.21",
     "moment": "2.29.4",
     "moment-duration-format": "2.2.2",

react/features/analytics/AnalyticsEvents.ts

@@ -331,15 +331,17 @@ export function createNetworkInfoEvent({ isOnline, networkType, details }:
 /**
  * Creates a "not allowed error" event.
  *
+ * @param {string} type - The type of the error.
  * @param {string} reason - The reason for the error.
  * @returns {Object} The event in a format suitable for sending via
  * sendAnalytics.
  */
-export function createNotAllowedErrorEvent(reason: string) {
+export function createNotAllowedErrorEvent(type: string, reason: string) {
     return {
         action: 'not.allowed.error',
         attributes: {
-            reason
+            reason,
+            type
         }
     };
 }

react/features/app/actions.native.ts

@@ -151,7 +151,7 @@ export function appNavigate(uri?: string, options: IReloadNowOptions = {}) {
         }
 
         dispatch(setLocationURL(locationURL));
-        dispatch(setConfig(config, locationURL));
+        dispatch(setConfig(config));
         dispatch(setRoom(room));
 
         if (!room) {

react/features/app/actions.web.ts

@@ -74,7 +74,7 @@ export function appNavigate(uri?: string) {
         const config = await loadConfig();
 
         dispatch(setLocationURL(locationURL));
-        dispatch(setConfig(config, locationURL));
+        dispatch(setConfig(config));
         dispatch(setRoom(room));
     };
 }

react/features/authentication/functions.any.ts

@@ -72,8 +72,7 @@ export const _getTokenAuthState = (
         // @ts-ignore
         state['config.startWithVideoMuted'] = true;
     }
-
-    const params = parseURLParams(locationURL, true);
+    const params = parseURLParams(locationURL);
 
     for (const key of Object.keys(params)) {
         // we allow only config and interfaceConfig overrides in the state

react/features/base/conference/actions.any.ts

@@ -10,14 +10,12 @@ import { JITSI_CONNECTION_CONFERENCE_KEY } from '../connection/constants';
 import { hasAvailableDevices } from '../devices/functions.any';
 import { JitsiConferenceEvents, JitsiE2ePingEvents } from '../lib-jitsi-meet';
 import {
-    gumPending,
     setAudioMuted,
     setAudioUnmutePermissions,
     setVideoMuted,
     setVideoUnmutePermissions
 } from '../media/actions';
-import { MEDIA_TYPE, VIDEO_MUTISM_AUTHORITY } from '../media/constants';
-import { IGUMPendingState } from '../media/types';
+import { MEDIA_TYPE, MediaType } from '../media/constants';
 import {
     dominantSpeakerChanged,
     participantKicked,
@@ -72,6 +70,7 @@ import {
     SET_START_REACTIONS_MUTED,
     UPDATE_CONFERENCE_METADATA
 } from './actionTypes';
+import { setupVisitorStartupMedia } from './actions';
 import {
     AVATAR_URL_COMMAND,
     EMAIL_COMMAND,
@@ -985,12 +984,12 @@ export function setStartMutedPolicy(
  * @param {string} subject - The new subject.
  * @returns {void}
  */
-export function setSubject(subject: string | undefined) {
+export function setSubject(subject: string) {
     return (dispatch: IStore['dispatch'], getState: IStore['getState']) => {
         const { conference } = getState()['features/base/conference'];
 
         if (conference) {
-            conference.setSubject(subject || '');
+            conference.setSubject(subject);
         } else {
             dispatch({
                 type: SET_PENDING_SUBJECT_CHANGE,
@@ -1009,7 +1008,7 @@ export function setSubject(subject: string | undefined) {
  *     localSubject: string
  * }}
  */
-export function setLocalSubject(localSubject: string | undefined) {
+export function setLocalSubject(localSubject: string) {
     return {
         type: CONFERENCE_LOCAL_SUBJECT_CHANGED,
         localSubject
@@ -1060,47 +1059,37 @@ export function redirect(vnode: string, focusJid: string, username: string) {
             .then(() => dispatch(conferenceWillInit()))
             .then(() => dispatch(connect()))
             .then(() => {
-                // Clear the gum pending state in case we have set it to pending since we are starting the
-                // conference without tracks.
-                dispatch(gumPending([ MEDIA_TYPE.AUDIO, MEDIA_TYPE.VIDEO ], IGUMPendingState.NONE));
+                const media: Array<MediaType> = [];
 
-                // FIXME: Workaround for the web version. To be removed once we get rid of conference.js
-                if (typeof APP !== 'undefined') {
-                    if (!vnode) {
-                        const state = getState();
-                        const { enableMediaOnPromote = {} } = state['features/base/config'].visitors ?? {};
-                        const { audio = false, video = false } = enableMediaOnPromote;
+                if (!vnode) {
+                    const state = getState();
+                    const { enableMediaOnPromote = {} } = state['features/base/config'].visitors ?? {};
+                    const { audio = false, video = false } = enableMediaOnPromote;
 
-                        if (audio) {
-                            const { available, muted, unmuteBlocked } = state['features/base/media'].audio;
-                            const { startSilent } = state['features/base/config'];
+                    if (audio) {
+                        const { available, muted, unmuteBlocked } = state['features/base/media'].audio;
+                        const { startSilent } = state['features/base/config'];
 
-                            // do not unmute the user if he was muted before (on the prejoin, the config
-                            // or URL param, etc.)
-                            if (!unmuteBlocked && !muted && !startSilent && available) {
-                                dispatch(setAudioMuted(false, true));
-
-                                // // FIXME: The old conference logic still relies on this event being emitted.
-                                typeof APP === 'undefined' || APP.conference.muteAudio(false);
-                            }
-                        }
-
-                        if (video) {
-                            const { muted, unmuteBlocked } = state['features/base/media'].video;
-
-                            // do not unmute the user if he was muted before (on the prejoin, the config, URL param or
-                            // audo only, etc)
-                            if (!unmuteBlocked && !muted && hasAvailableDevices(state, 'videoInput')) {
-                                dispatch(setVideoMuted(false, VIDEO_MUTISM_AUTHORITY.USER, true));
-
-                                // // FIXME: The old conference logic still relies on this event being emitted.
-                                typeof APP === 'undefined' || APP.conference.muteVideo(false, false);
-                            }
+                        // do not unmute the user if he was muted before (on the prejoin, the config
+                        // or URL param, etc.)
+                        if (!unmuteBlocked && !muted && !startSilent && available) {
+                            media.push(MEDIA_TYPE.AUDIO);
                         }
                     }
 
-                    APP.conference.startConference([]);
+                    if (video) {
+                        const { muted, unmuteBlocked } = state['features/base/media'].video;
+
+                        // do not unmute the user if he was muted before (on the prejoin, the config, URL param or
+                        // audo only, etc)
+                        if (!unmuteBlocked && !muted && hasAvailableDevices(state, 'videoInput')) {
+                            media.push(MEDIA_TYPE.VIDEO);
+                        }
+                    }
                 }
+
+                dispatch(setupVisitorStartupMedia(media));
             });
     };
 }
+

react/features/base/conference/actions.native.ts

@@ -0,0 +1,29 @@
+import { IStore } from '../../app/types';
+import { setAudioMuted, setVideoMuted } from '../media/actions';
+import { MEDIA_TYPE, MediaType, VIDEO_MUTISM_AUTHORITY } from '../media/constants';
+
+export * from './actions.any';
+
+/**
+ * Starts audio and/or video for the visitor.
+ *
+ * @param {Array<MediaType>} mediaTypes - The media types that need to be started.
+ * @returns {Function}
+ */
+export function setupVisitorStartupMedia(mediaTypes: Array<MediaType>) {
+    return (dispatch: IStore['dispatch']) => {
+        if (!mediaTypes || !Array.isArray(mediaTypes)) {
+            return;
+        }
+
+        mediaTypes.forEach(mediaType => {
+            switch (mediaType) {
+            case MEDIA_TYPE.AUDIO:
+                dispatch(setAudioMuted(false, true));
+                break;
+            case MEDIA_TYPE.VIDEO:
+                dispatch(setVideoMuted(false, VIDEO_MUTISM_AUTHORITY.USER, true));
+            }
+        });
+    };
+}

react/features/base/conference/actions.web.ts

@@ -0,0 +1,31 @@
+import { IStore } from '../../app/types';
+import { gumPending } from '../media/actions';
+import { MEDIA_TYPE, MediaType } from '../media/constants';
+import { IGUMPendingState } from '../media/types';
+import { createAndAddInitialAVTracks } from '../tracks/actions.web';
+
+export * from './actions.any';
+
+/**
+ * Starts audio and/or video for the visitor.
+ *
+ * @param {Array<MediaType>} media - The media types that need to be started.
+ * @returns {Function}
+ */
+export function setupVisitorStartupMedia(media: Array<MediaType>) {
+    return (dispatch: IStore['dispatch']) => {
+        // Clear the gum pending state in case we have set it to pending since we are starting the
+        // conference without tracks.
+        dispatch(gumPending([ MEDIA_TYPE.AUDIO, MEDIA_TYPE.VIDEO ], IGUMPendingState.NONE));
+
+        if (media && Array.isArray(media) && media.length > 0) {
+            dispatch(createAndAddInitialAVTracks(media));
+        }
+
+        // FIXME: The name of the function doesn't fit the startConference execution but another PR will removes
+        // this and calls startConference based on the connection status. This will stay here temporary.
+        if (typeof APP !== 'undefined') {
+            APP.conference.startConference([]);
+        }
+    };
+}

react/features/base/conference/functions.ts

@@ -185,18 +185,12 @@ export function forEachConference(
 export function getConferenceName(stateful: IStateful): string {
     const state = toState(stateful);
     const { callee } = state['features/base/jwt'];
-    const {
-        callDisplayName,
-        localSubject: configLocalSubject,
-        subject: configSubject
-    } = state['features/base/config'];
+    const { callDisplayName } = state['features/base/config'];
     const { localSubject, pendingSubjectChange, room, subject } = getConferenceState(state);
 
-    return (pendingSubjectChange
-        || configSubject
+    return (localSubject
+        || pendingSubjectChange
         || subject
-        || configLocalSubject
-        || localSubject
         || callDisplayName
         || callee?.name
         || (room && safeStartCase(safeDecodeURIComponent(room)))) ?? '';

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

@@ -220,9 +220,30 @@ function _conferenceFailed({ dispatch, getState }: IStore, next: Function, actio
         break;
     }
     case JitsiConferenceErrors.NOT_ALLOWED_ERROR: {
-        const [ msg ] = error.params;
+        const [ type, msg ] = error.params;
+
+        let descriptionKey;
+        let titleKey = 'dialog.tokenAuthFailed';
+
+        if (type === JitsiConferenceErrors.AUTH_ERROR_TYPES.NO_MAIN_PARTICIPANTS) {
+            descriptionKey = 'visitors.notification.noMainParticipantsDescription';
+            titleKey = 'visitors.notification.noMainParticipantsTitle';
+        } else if (type === JitsiConferenceErrors.AUTH_ERROR_TYPES.NO_VISITORS_LOBBY) {
+            descriptionKey = 'visitors.notification.noVisitorLobby';
+        } else if (type === JitsiConferenceErrors.AUTH_ERROR_TYPES.PROMOTION_NOT_ALLOWED) {
+            descriptionKey = 'visitors.notification.notAllowedPromotion';
+        } else if (type === JitsiConferenceErrors.AUTH_ERROR_TYPES.ROOM_CREATION_RESTRICTION) {
+            descriptionKey = 'dialog.errorRoomCreationRestriction';
+        }
+
+        APP.store.dispatch(showErrorNotification({
+            descriptionKey,
+            hideErrorSupportLink: true,
+            titleKey
+        }, NOTIFICATION_TIMEOUT_TYPE.STICKY));
+
+        sendAnalytics(createNotAllowedErrorEvent(type, msg));
 
-        sendAnalytics(createNotAllowedErrorEvent(msg));
         break;
     }
     case JitsiConferenceErrors.OFFER_ANSWER_FAILED:

react/features/base/conference/reducer.ts

@@ -3,6 +3,8 @@ import { AnyAction } from 'redux';
 import { FaceLandmarks } from '../../face-landmarks/types';
 import { LOCKED_LOCALLY, LOCKED_REMOTELY } from '../../room-lock/constants';
 import { ISpeakerStats } from '../../speaker-stats/reducer';
+import { SET_CONFIG } from '../config/actionTypes';
+import { IConfig } from '../config/configType';
 import { CONNECTION_WILL_CONNECT, SET_LOCATION_URL } from '../connection/actionTypes';
 import { JitsiConferenceErrors } from '../lib-jitsi-meet';
 import ReducerRegistry from '../redux/ReducerRegistry';
@@ -268,11 +270,33 @@ ReducerRegistry.register<IConferenceState>('features/base/conference',
                 ...state,
                 metadata: action.metadata
             };
+
+        case SET_CONFIG:
+            return _setConfig(state, action);
         }
 
         return state;
     });
 
+/**
+ * Processes subject and local subject of the conference based on the new config.
+ *
+ * @param {Object} state - The Redux state of feature base/conference.
+ * @param {Action} action - The Redux action SET_CONFIG to reduce.
+ * @private
+ * @returns {Object} The new state after the reduction of the specified action.
+ */
+function _setConfig(state: IConferenceState, { config }: { config: IConfig; }) {
+    const { localSubject, subject } = config;
+
+    return {
+        ...state,
+        localSubject,
+        pendingSubjectChange: subject,
+        subject: undefined
+    };
+}
+
 /**
  * Reduces a specific Redux action AUTH_STATUS_CHANGED of the feature
  * base/conference.
@@ -596,10 +620,7 @@ function _setRoom(state: IConferenceState, action: AnyAction) {
      */
     return assign(state, {
         error: undefined,
-        localSubject: undefined,
-        pendingSubjectChange: undefined,
-        room,
-        subject: undefined
+        room
     });
 }
 

react/features/base/config/actions.ts

@@ -96,51 +96,53 @@ export function overwriteConfig(config: Object) {
  *
  * @param {Object} config - The configuration to be represented by the feature
  * base/config.
- * @param {URL} locationURL - The URL of the location which necessitated the
- * loading of a configuration.
  * @returns {Function}
  */
-export function setConfig(config: IConfig = {}, locationURL: URL | undefined) {
-    // Now that the loading of the config was successful override the values
-    // with the parameters passed in the hash part of the location URI.
-    // TODO We're still in the middle ground between old Web with config,
-    // and interfaceConfig used via global variables and new
-    // Web and mobile reading the respective values from the redux store.
-    // Only the config will be overridden on React Native, as the other
-    // globals will be undefined here. It's intentional - we do not care to
-    // override those configs yet.
-    locationURL
-        && setConfigFromURLParams(
+export function setConfig(config: IConfig = {}) {
+    return (dispatch: IStore['dispatch'], getState: IStore['getState']) => {
+        const { locationURL } = getState()['features/base/connection'];
 
-            // On Web the config also comes from the window.config global,
-            // but it is resolved in the loadConfig procedure.
-            config,
-            window.interfaceConfig,
-            locationURL);
+        // Now that the loading of the config was successful override the values
+        // with the parameters passed in the hash part of the location URI.
+        // TODO We're still in the middle ground between old Web with config,
+        // and interfaceConfig used via global variables and new
+        // Web and mobile reading the respective values from the redux store.
+        // Only the config will be overridden on React Native, as the other
+        // globals will be undefined here. It's intentional - we do not care to
+        // override those configs yet.
+        locationURL
+            && setConfigFromURLParams(
 
-    let { bosh } = config;
+                // On Web the config also comes from the window.config global,
+                // but it is resolved in the loadConfig procedure.
+                config,
+                window.interfaceConfig,
+                locationURL);
 
-    if (bosh) {
-        // Normalize the BOSH URL.
-        if (bosh.startsWith('//')) {
-            // By default our config.js doesn't include the protocol.
-            bosh = `${locationURL?.protocol}${bosh}`;
-        } else if (bosh.startsWith('/')) {
-            // Handle relative URLs, which won't work on mobile.
-            const {
-                protocol,
-                host,
-                contextRoot
-            } = parseURIString(locationURL?.href);
+        let { bosh } = config;
 
-            bosh = `${protocol}//${host}${contextRoot || '/'}${bosh.substr(1)}`;
+        if (bosh) {
+            // Normalize the BOSH URL.
+            if (bosh.startsWith('//')) {
+                // By default our config.js doesn't include the protocol.
+                bosh = `${locationURL?.protocol}${bosh}`;
+            } else if (bosh.startsWith('/')) {
+                // Handle relative URLs, which won't work on mobile.
+                const {
+                    protocol,
+                    host,
+                    contextRoot
+                } = parseURIString(locationURL?.href);
+
+                bosh = `${protocol}//${host}${contextRoot || '/'}${bosh.substr(1)}`;
+            }
+            config.bosh = bosh;
         }
-        config.bosh = bosh;
-    }
 
-    return {
-        type: SET_CONFIG,
-        config
+        dispatch({
+            type: SET_CONFIG,
+            config
+        });
     };
 }
 

react/features/base/responsive-ui/actions.ts

@@ -35,6 +35,10 @@ const REDUCED_UI_THRESHOLD = 300;
  */
 export function clientResized(clientWidth: number, clientHeight: number) {
     return (dispatch: IStore['dispatch'], getState: IStore['getState']) => {
+        if (!clientWidth && !clientHeight) {
+            return;
+        }
+
         let availableWidth = clientWidth;
 
         if (navigator.product !== 'ReactNative') {

react/features/base/responsive-ui/middleware.web.ts

@@ -1,5 +1,6 @@
 import { IStore } from '../../app/types';
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT } from '../app/actionTypes';
+import { CONFERENCE_JOINED } from '../conference/actionTypes';
 import MiddlewareRegistry from '../redux/MiddlewareRegistry';
 
 import { clientResized } from './actions';
@@ -27,6 +28,19 @@ MiddlewareRegistry.register(store => next => action => {
         _appWillMount(store);
         break;
 
+    case CONFERENCE_JOINED: {
+        const { clientHeight = 0, clientWidth = 0 } = store.getState()['features/base/responsive-ui'];
+
+        if (!clientHeight && !clientWidth) {
+            const {
+                innerHeight,
+                innerWidth
+            } = window;
+
+            store.dispatch(clientResized(innerWidth, innerHeight));
+        }
+        break;
+    }
     }
 
     return result;

react/features/base/tracks/actions.web.ts

@@ -4,7 +4,7 @@ import { IReduxState, IStore } from '../../app/types';
 import { showModeratedNotification } from '../../av-moderation/actions';
 import { shouldShowModeratedNotification } from '../../av-moderation/functions';
 import { setNoiseSuppressionEnabled } from '../../noise-suppression/actions';
-import { showNotification } from '../../notifications/actions';
+import { showErrorNotification, showNotification } from '../../notifications/actions';
 import { NOTIFICATION_TIMEOUT_TYPE } from '../../notifications/constants';
 import { stopReceiver } from '../../remote-control/actions';
 import { setScreenAudioShareState, setScreenshareAudioTrack } from '../../screen-share/actions';
@@ -13,10 +13,12 @@ import { toggleScreenshotCaptureSummary } from '../../screenshot-capture/actions
 import { isScreenshotCaptureEnabled } from '../../screenshot-capture/functions';
 import { AudioMixerEffect } from '../../stream-effects/audio-mixer/AudioMixerEffect';
 import { getCurrentConference } from '../conference/functions';
+import { notifyCameraError, notifyMicError } from '../devices/actions.web';
 import { openDialog } from '../dialog/actions';
-import { JitsiTrackErrors, JitsiTrackEvents } from '../lib-jitsi-meet';
-import { setScreenshareMuted } from '../media/actions';
-import { MEDIA_TYPE, VIDEO_TYPE } from '../media/constants';
+import { JitsiTrackErrors, JitsiTrackEvents, browser } from '../lib-jitsi-meet';
+import { gumPending, setScreenshareMuted } from '../media/actions';
+import { MEDIA_TYPE, MediaType, VIDEO_TYPE } from '../media/constants';
+import { IGUMPendingState } from '../media/types';
 
 import {
     addLocalTrack,
@@ -31,7 +33,8 @@ import {
     getLocalVideoTrack,
     isToggleCameraEnabled
 } from './functions';
-import { IShareOptions, IToggleScreenSharingOptions } from './types';
+import logger from './logger';
+import { ICreateInitialTracksOptions, IInitialTracksErrors, IShareOptions, IToggleScreenSharingOptions } from './types';
 
 export * from './actions.any';
 
@@ -74,33 +77,6 @@ export function toggleScreensharing(
  * @param {Object} store - The redux store.
  * @returns {void}
  */
-function _handleScreensharingError(
-        error: Error | AUDIO_ONLY_SCREEN_SHARE_NO_TRACK,
-        { dispatch }: IStore): void {
-    if (error.name === JitsiTrackErrors.SCREENSHARING_USER_CANCELED) {
-        return;
-    }
-    let descriptionKey, titleKey;
-
-    if (error.name === JitsiTrackErrors.PERMISSION_DENIED) {
-        descriptionKey = 'dialog.screenSharingPermissionDeniedError';
-        titleKey = 'dialog.screenSharingFailedTitle';
-    } else if (error.name === JitsiTrackErrors.CONSTRAINT_FAILED) {
-        descriptionKey = 'dialog.cameraConstraintFailedError';
-        titleKey = 'deviceError.cameraError';
-    } else if (error.name === JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR) {
-        descriptionKey = 'dialog.screenSharingFailed';
-        titleKey = 'dialog.screenSharingFailedTitle';
-    } else if (error === AUDIO_ONLY_SCREEN_SHARE_NO_TRACK) {
-        descriptionKey = 'notify.screenShareNoAudio';
-        titleKey = 'notify.screenShareNoAudioTitle';
-    }
-
-    dispatch(showNotification({
-        titleKey,
-        descriptionKey
-    }, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
-}
 
 
 /**
@@ -128,7 +104,6 @@ async function _maybeApplyAudioMixerEffect(desktopAudioTrack: any, state: IRedux
     }
 }
 
-
 /**
  * Toggles screen sharing.
  *
@@ -182,7 +157,7 @@ async function _toggleScreenSharing(
             try {
                 tracks = await createLocalTracksF(options) as any[];
             } catch (error) {
-                _handleScreensharingError(error as any, store);
+                dispatch(handleScreenSharingError(error, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
                 throw error;
             }
@@ -196,7 +171,7 @@ async function _toggleScreenSharing(
             desktopVideoTrack.dispose();
 
             if (!desktopAudioTrack) {
-                _handleScreensharingError(AUDIO_ONLY_SCREEN_SHARE_NO_TRACK, store);
+                dispatch(handleScreenSharingError(AUDIO_ONLY_SCREEN_SHARE_NO_TRACK, NOTIFICATION_TIMEOUT_TYPE.MEDIUM));
 
                 throw new Error(AUDIO_ONLY_SCREEN_SHARE_NO_TRACK);
             }
@@ -317,3 +292,224 @@ export function openAllowToggleCameraDialog(onAllow: Function, initiatorId: stri
         initiatorId
     });
 }
+
+/**
+ * Sets the GUM pending state for the tracks that have failed.
+ *
+ * NOTE: Some of the track that we will be setting to GUM pending state NONE may not have failed but they may have
+ * been requested. This won't be a problem because their current GUM pending state will be NONE anyway.
+ *
+ * @param {JitsiLocalTrack} tracks - The tracks that have been created.
+ * @param {Function} dispatch - The redux dispatch function.
+ * @returns {void}
+ */
+export function setGUMPendingStateOnFailedTracks(tracks: Array<any>, dispatch: IStore['dispatch']) {
+    const tracksTypes = tracks.map(track => {
+        if (track.getVideoType() === VIDEO_TYPE.DESKTOP) {
+            return MEDIA_TYPE.SCREENSHARE;
+        }
+
+        return track.getType();
+    });
+    const nonPendingTracks = [ MEDIA_TYPE.AUDIO, MEDIA_TYPE.VIDEO ].filter(type => !tracksTypes.includes(type));
+
+    dispatch(gumPending(nonPendingTracks, IGUMPendingState.NONE));
+}
+
+/**
+ * Creates and adds to the conference the initial audio/video tracks.
+ *
+ * @param {Array<MediaType>} devices - Array with devices (audio/video) that will be used.
+ * @returns {Function}
+ */
+export function createAndAddInitialAVTracks(devices: Array<MediaType>) {
+    return async (dispatch: IStore['dispatch']) => {
+        dispatch(gumPending(devices, IGUMPendingState.PENDING_UNMUTE));
+
+        const { tracks, errors } = await dispatch(createInitialAVTracks({ devices }));
+
+        setGUMPendingStateOnFailedTracks(tracks, dispatch);
+        dispatch(displayErrorsForCreateInitialLocalTracks(errors));
+
+        await Promise.allSettled(tracks.map((track: any) => {
+            const legacyConferenceObject = APP.conference;
+
+            if (track.isAudioTrack()) {
+                return legacyConferenceObject.useAudioStream(track);
+            }
+            if (track.isVideoTrack()) {
+                return legacyConferenceObject.useVideoStream(track);
+            }
+
+            return Promise.resolve();
+        }));
+
+        dispatch(gumPending(devices, IGUMPendingState.NONE));
+    };
+}
+
+/**
+ * Creates the initial audio/video tracks.
+ *
+ * @param {ICreateInitialTracksOptions} options - Options for creating the audio/video tracks.
+ * @returns {Function}
+ */
+export function createInitialAVTracks(options: ICreateInitialTracksOptions) {
+    return (dispatch: IStore['dispatch'], _getState: IStore['getState']) => {
+        const {
+            devices,
+            timeout,
+            firePermissionPromptIsShownEvent
+        } = options;
+
+        dispatch(gumPending(devices, IGUMPendingState.PENDING_UNMUTE));
+
+        return createLocalTracksF(options).then(tracks => {
+            return {
+                errors: {} as IInitialTracksErrors,
+                tracks
+            };
+        })
+        .catch(async error => {
+            const errors = {} as IInitialTracksErrors;
+
+            if (error.name === JitsiTrackErrors.TIMEOUT && !browser.isElectron()) {
+                if (devices.includes(MEDIA_TYPE.AUDIO)) {
+                    errors.audioOnlyError = error;
+                }
+
+                if (devices.includes(MEDIA_TYPE.VIDEO)) {
+                    errors.videoOnlyError = error;
+                }
+
+                if (errors.audioOnlyError && errors.videoOnlyError) {
+                    errors.audioAndVideoError = error;
+                }
+
+                return {
+                    errors,
+                    tracks: []
+                };
+            }
+
+            // Retry with separate gUM calls.
+            const gUMPromises = [];
+            const tracks: any[] | PromiseLike<any[]> = [];
+
+            if (devices.includes(MEDIA_TYPE.AUDIO)) {
+                gUMPromises.push(createLocalTracksF({
+                    devices: [ MEDIA_TYPE.AUDIO ],
+                    timeout,
+                    firePermissionPromptIsShownEvent
+                }));
+            }
+
+            if (devices.includes(MEDIA_TYPE.VIDEO)) {
+                gUMPromises.push(createLocalTracksF({
+                    devices: [ MEDIA_TYPE.VIDEO ],
+                    timeout,
+                    firePermissionPromptIsShownEvent
+                }));
+            }
+
+            const results = await Promise.allSettled(gUMPromises);
+            let errorMsg;
+
+            results.forEach((result, idx) => {
+                if (result.status === 'fulfilled') {
+                    tracks.push(result.value[0]);
+                } else {
+                    errorMsg = result.reason;
+                    const isAudio = idx === 0;
+
+                    logger.error(`${isAudio ? 'Audio' : 'Video'} track creation failed with error ${errorMsg}`);
+                    if (isAudio) {
+                        errors.audioOnlyError = errorMsg;
+                    } else {
+                        errors.videoOnlyError = errorMsg;
+                    }
+                }
+            });
+
+            if (errors.audioOnlyError && errors.videoOnlyError) {
+                errors.audioAndVideoError = errorMsg;
+            }
+
+            return {
+                tracks,
+                errors
+            };
+        });
+    };
+}
+
+/**
+ * Displays error notifications according to the state carried by the passed {@code errors} object.
+ *
+ * @param {InitialTracksErrors} errors - The errors (if any).
+ * @returns {Function}
+ * @private
+ */
+export function displayErrorsForCreateInitialLocalTracks(errors: IInitialTracksErrors) {
+    return (dispatch: IStore['dispatch']) => {
+        const {
+            audioOnlyError,
+            screenSharingError,
+            videoOnlyError
+        } = errors;
+
+        if (screenSharingError) {
+            dispatch(handleScreenSharingError(screenSharingError, NOTIFICATION_TIMEOUT_TYPE.LONG));
+        }
+        if (audioOnlyError || videoOnlyError) {
+            if (audioOnlyError) {
+                dispatch(notifyMicError(audioOnlyError));
+            }
+
+            if (videoOnlyError) {
+                dispatch(notifyCameraError(videoOnlyError));
+            }
+        }
+    };
+}
+
+/**
+ * Displays a UI notification for screensharing failure based on the error passed.
+ *
+ * @private
+ * @param {Error | AUDIO_ONLY_SCREEN_SHARE_NO_TRACK} error - The error.
+ * @param {NOTIFICATION_TIMEOUT_TYPE} timeout - The time for showing the notification.
+ * @returns {Function}
+ */
+export function handleScreenSharingError(
+        error: Error | AUDIO_ONLY_SCREEN_SHARE_NO_TRACK,
+        timeout: NOTIFICATION_TIMEOUT_TYPE) {
+    return (dispatch: IStore['dispatch']) => {
+        logger.error('failed to share local desktop', error);
+
+        let descriptionKey;
+        let titleKey;
+
+        if (error.name === JitsiTrackErrors.PERMISSION_DENIED) {
+            descriptionKey = 'dialog.screenSharingPermissionDeniedError';
+            titleKey = 'dialog.screenSharingFailedTitle';
+        } else if (error.name === JitsiTrackErrors.CONSTRAINT_FAILED) {
+            descriptionKey = 'dialog.cameraConstraintFailedError';
+            titleKey = 'deviceError.cameraError';
+        } else if (error.name === JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR) {
+            descriptionKey = 'dialog.screenSharingFailed';
+            titleKey = 'dialog.screenSharingFailedTitle';
+        } else if (error === AUDIO_ONLY_SCREEN_SHARE_NO_TRACK) {
+            descriptionKey = 'notify.screenShareNoAudio';
+            titleKey = 'notify.screenShareNoAudioTitle';
+        } else { // safeguard for not showing notification with empty text. This will also include
+            // error.name === JitsiTrackErrors.SCREENSHARING_USER_CANCELED
+            return;
+        }
+
+        dispatch(showErrorNotification({
+            descriptionKey,
+            titleKey
+        }, timeout));
+    };
+}

react/features/base/tracks/types.ts

@@ -72,3 +72,16 @@ export interface IShareOptions {
     desktopSharingSources?: string[];
     desktopStream?: any;
 }
+
+export interface ICreateInitialTracksOptions {
+    devices: Array<MediaType>;
+    firePermissionPromptIsShownEvent?: boolean;
+    timeout?: number;
+}
+
+export interface IInitialTracksErrors {
+    audioAndVideoError?: Error;
+    audioOnlyError: Error;
+    screenSharingError: Error;
+    videoOnlyError: Error;
+}

react/features/chat/middleware.ts

@@ -116,7 +116,7 @@ MiddlewareRegistry.register(store => next => action => {
         const state = store.getState();
 
         if (!isReactionsEnabled(state)) {
-            return;
+            return next(action);
         }
 
         const { participant, data } = action;

react/features/notifications/constants.ts

@@ -11,12 +11,12 @@ export const NOTIFICATION_TIMEOUT = {
 /**
  * Notification timeout type.
  */
-export const NOTIFICATION_TIMEOUT_TYPE = {
-    SHORT: 'short',
-    MEDIUM: 'medium',
-    LONG: 'long',
-    STICKY: 'sticky'
-};
+export enum NOTIFICATION_TIMEOUT_TYPE {
+    LONG = 'long',
+    MEDIUM = 'medium',
+    SHORT = 'short',
+    STICKY = 'sticky'
+}
 
 /**
  * The set of possible notification types.

react/features/prejoin/components/web/PrejoinApp.tsx

@@ -50,9 +50,6 @@ export default class PrejoinApp extends BaseApp<Props> {
             ? store.getState()['features/base/settings']
             : { startWithAudioMuted: undefined,
                 startWithVideoMuted: undefined };
-        const { locationURL } = store
-            ? store.getState()['features/base/connection']
-            : { locationURL: undefined };
 
         dispatch?.(setConfig({
             prejoinConfig: {
@@ -60,7 +57,7 @@ export default class PrejoinApp extends BaseApp<Props> {
             },
             startWithAudioMuted,
             startWithVideoMuted
-        }, locationURL));
+        }));
 
         await dispatch?.(setupInitialDevices());
         const { tryCreateLocalTracks, errors } = createPrejoinTracks();

react/features/remote-control/keycodes.ts

@@ -40,7 +40,7 @@ export const KEYS = {
     ALT: 'alt',
     CONTROL: 'control',
     SHIFT: 'shift',
-    CAPS_LOCK: 'caps_lock', // not supported by robotjs
+    CAPS_LOCK: 'capslock',
     SPACE: 'space',
     PRINTSCREEN: 'printscreen',
     INSERT: 'insert',

resources/prosody-plugins/mod_fmuc.lua

@@ -63,7 +63,8 @@ module:hook('muc-occupant-pre-join', function (event)
 
     if host == local_domain then
         if room._main_room_lobby_enabled then
-            origin.send(st.error_reply(stanza, 'cancel', 'not-allowed', 'Visitors not allowed while lobby is on!'));
+            origin.send(st.error_reply(stanza, 'cancel', 'not-allowed', 'Visitors not allowed while lobby is on!')
+                :tag('no-visitors-lobby', { xmlns = 'jitsi:visitors' }));
             return true;
         else
             occupant.role = 'visitor';

resources/prosody-plugins/mod_system_chat_message.lua

@@ -1,8 +1,8 @@
--- Module which can be used as an http endpoint to send system chat messages to meeting participants. The provided token
+-- Module which can be used as an http endpoint to send system private chat messages to meeting participants. The provided token
 --- in the request is verified whether it has the right to do so. This module should be loaded under the virtual host.
 -- Copyright (C) 2024-present 8x8, Inc.
 
--- curl https://{host}/send-system-message  -d '{"message": "testmessage", "to": "{connection_jid}", "room": "{room_jid}"}' -H "content-type: application/json" -H "authorization: Bearer {token}"
+-- curl https://{host}/send-system-chat-message  -d '{"message": "testmessage", "connectionJIDs": ["{connection_jid}"], "room": "{room_jid}"}' -H "content-type: application/json" -H "authorization: Bearer {token}"
 
 local util = module:require "util";
 local token_util = module:require "token/util".new(module);
@@ -60,11 +60,11 @@ function handle_send_system_message (event)
 
     local displayName = payload["displayName"];
     local message = payload["message"];
-    local to = payload["to"];
+    local connectionJIDs = payload["connectionJIDs"];
     local payload_room = payload["room"];
 
-    if not message or not to or not payload_room then
-        module:log("error", "One of [message, to, room] was not provided");
+    if not message or not connectionJIDs or not payload_room then
+        module:log("error", "One of [message, connectionJIDs, room] was not provided");
         return { status_code = 400; }
     end
 
@@ -99,15 +99,17 @@ function handle_send_system_message (event)
         message = message,
     };
 
-    local stanza = st.message({
-        from = room.jid,
-        to = to
-    })
-    :tag('json-message', { xmlns = 'http://jitsi.org/jitmeet' })
-    :text(json.encode(data))
-    :up();
+    for _, to in ipairs(connectionJIDs) do
+        local stanza = st.message({
+            from = room.jid,
+            to = to
+        })
+        :tag('json-message', { xmlns = 'http://jitsi.org/jitmeet' })
+        :text(json.encode(data))
+        :up();
 
-    room:route_stanza(stanza);
+        room:route_stanza(stanza);
+    end
 
     return { status_code = 200 };
 end

resources/prosody-plugins/mod_visitors_component.lua

@@ -311,7 +311,7 @@ process_host_module(muc_domain_prefix..'.'..muc_domain_base, function(host_modul
     -- if visitor mode is started, then you are not allowed to join without request/response exchange of iqs -> deny access
     -- check list of allowed jids for the room
     host_module:hook('muc-occupant-pre-join', function (event)
-        local room, stanza, occupant, origin = event.room, event.stanza, event.occupant, event.origin;
+        local room, stanza, occupant, session = event.room, event.stanza, event.occupant, event.origin;
 
         if is_healthcheck_room(room.jid) or is_admin(occupant.bare_jid) then
             return;
@@ -341,8 +341,19 @@ process_host_module(muc_domain_prefix..'.'..muc_domain_base, function(host_modul
                 return;
             end
             module:log('error', 'Visitor needs to be allowed by a moderator %s', stanza.attr.from);
-            origin.send(st.error_reply(stanza, 'cancel', 'not-allowed', 'Visitor needs to be allowed by a moderator'));
+            session.send(st.error_reply(stanza, 'cancel', 'not-allowed', 'Visitor needs to be allowed by a moderator')
+                :tag('promotion-not-allowed', { xmlns = 'jitsi:visitors' }));
             return true;
+        elseif is_vpaas(room) then
+            -- special case for vpaas where if someone with a visitor token tries to join a room, where
+            -- there are no visitors yet, we deny access
+            if session.jitsi_meet_context_user and session.jitsi_meet_context_user.role == 'visitor' then
+                session.log('warn', 'Deny user join as visitor in the main meeting, not approved');
+                session.send(st.error_reply(
+                    stanza, 'cancel', 'not-allowed', 'Visitor tried to join the main room without approval')
+                        :tag('no-main-participants', { xmlns = 'jitsi:visitors' }));
+                return true;
+            end
         end
 
     end, 7); -- after muc_meeting_id, the logic for not joining before jicofo

static/authError.html

@@ -1,15 +0,0 @@
-<html>
-<head>
-    <!--#include virtual="/base.html" -->
-    <link rel="stylesheet" href="css/all.css"/>
-    <!--#include virtual="/title.html" -->
-</head>
-<body>
-    <div class="redirectPageMessage">
-        Sorry! You are not allowed to be here :(
-        <div class="forbidden-msg">
-            <p>You might be missing the JWT or using an incompatible one.</p>
-        </div>
-    </div>
-</body>
-</html>