Initial implementation of lobby rooms. (#1138)

* Initial impl of lobby rooms.

* Fixes tests to check the new fulljid added to MUC_MEMBER_JOINED.

* Updates few of the comments, renaming some functions.

* Renames disableLobby ChatRoom option to enableLobby.

* Fixes a comment.

* Moves setMembersOnly method to ChatRoom.

* Fixes counting members, to exclude jicofo.

* Moves setLobbyRoomJid earlier and renames a method.

Rename _maybeEnableDisable to maybeJoinLeaveLobbyRoom.

* Drops using custom roomconfig lobbypassword field and reuse room lock.

* Handles destroying the lobby room.

* Handles clear lobby room on destroy for moderators.

We do not try to leave the lobby room as it is server-side destroyed and we handle that. The only case of leaving a lobby room is when request to join room is being approved.

* Join main room if lobby is disabled while waiting.

* Adds MEMBERS_ONLY_CHANGED conference event.

* fix: Make sure we leave lobby if main room is joined.

* fix: Setting password when joining locked room.

* fix: Fixes case where we enable lobby for already locked room.

* fix: Fixes case where we enable lobby and then lock room.

* fix: Fixes lint.

* ref: Removes shared password for lobby.

This functionality is handled by the lock room password and handled there.
Removes duplication and unnecessary complicated API for lobby room.

* fix: Fixes comments.

JitsiConference.js

     this._e2eeCtx.setKey(key);
 };
 
+/**
+ * Returns <tt>true</tt> if lobby support is enabled in the backend.
+ *
+ * @returns {boolean} whether lobby is supported in the backend.
+ */
+JitsiConference.prototype.isLobbySupported = function() {
+    return Boolean(this.room && this.room.getLobby().isSupported());
+};
+
+/**
+ * Returns <tt>true</tt> if the room has members only enabled.
+ *
+ * @returns {boolean} whether conference room is members only.
+ */
+JitsiConference.prototype.isMembersOnly = function() {
+    return Boolean(this.room && this.room.membersOnlyEnabled);
+};
+
+/**
+ * Enables lobby by moderators
+ *
+ * @returns {Promise} resolves when lobby room is joined or rejects with the error.
+ */
+JitsiConference.prototype.enableLobby = function() {
+    if (this.room && this.isModerator()) {
+        return this.room.getLobby().enable();
+    }
+
+    return Promise.reject(
+        new Error('The conference not started or user is not moderator'));
+};
+
+/**
+ * Disabled lobby by moderators
+ *
+ * @returns {void}
+ */
+JitsiConference.prototype.disableLobby = function() {
+    if (this.room && this.isModerator()) {
+        this.room.getLobby().disable();
+    }
+};
+
+/**
+ * Joins the lobby room with display name and optional email or with a shared password to skip waiting.
+ *
+ * @param {string} displayName Display name should be set to show it to moderators.
+ * @param {string} email Optional email is used to present avatar to the moderator.
+ * @returns {Promise<never>}
+ */
+JitsiConference.prototype.joinLobby = function(displayName, email) {
+    if (this.room) {
+        return this.room.getLobby().join(displayName, email);
+    }
+
+    return Promise.reject(new Error('The conference not started'));
+};
+
+/**
+ * Denies an occupant in the lobby room access to the conference.
+ * @param {string} id The participant id.
+ */
+JitsiConference.prototype.lobbyDenyAccess = function(id) {
+    if (this.room) {
+        this.room.getLobby().denyAccess(id);
+    }
+};
+
+/**
+ * Approves the request to join the conference to a participant waiting in the lobby.
+ *
+ * @param {string} id The participant id.
+ */
+JitsiConference.prototype.lobbyApproveAccess = function(id) {
+    if (this.room) {
+        this.room.getLobby().approveAccess(id);
+    }
+};
+
 /**
  * Setup E2EE for the sending side, if supported.
  * Note that this is only done for the JVB Peer Connecction.

JitsiConferenceErrors.js

  */
 export const NOT_ALLOWED_ERROR = 'conference.connectionError.notAllowed';
 
+/**
+ * Indicates that a connection error is due to not allowed,
+ * occurred when trying to join a conference, only approved members are allowed to join.
+ */
+export const MEMBERS_ONLY_ERROR = 'conference.connectionError.membersOnly';
+
+/**
+ * Indicates that a connection error is due to denied access to the room,
+ * occurred after joining a lobby room and access is denied by the room moderators.
+ */
+export const CONFERENCE_ACCESS_DENIED = 'conference.connectionError.accessDenied';
+
 /**
  * Indicates that focus error happened.
  */

JitsiConferenceEventManager.js

     this.chatRoomForwarder.forward(XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.NOT_ALLOWED_ERROR);
+    this.chatRoomForwarder.forward(XMPPEvents.ROOM_CONNECT_MEMBERS_ONLY_ERROR,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.MEMBERS_ONLY_ERROR);
 
     this.chatRoomForwarder.forward(XMPPEvents.ROOM_MAX_USERS_ERROR,
         JitsiConferenceEvents.CONFERENCE_FAILED,
     this.chatRoomForwarder.forward(XMPPEvents.MUC_LOCK_CHANGED,
         JitsiConferenceEvents.LOCK_STATE_CHANGED);
 
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_MEMBERS_ONLY_CHANGED,
+        JitsiConferenceEvents.MEMBERS_ONLY_CHANGED);
+
     chatRoom.addListener(XMPPEvents.MUC_MEMBER_JOINED,
         conference.onMemberJoined.bind(conference));
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_LOBBY_MEMBER_JOINED,
+        JitsiConferenceEvents.LOBBY_USER_JOINED);
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_LOBBY_MEMBER_UPDATED,
+        JitsiConferenceEvents.LOBBY_USER_UPDATED);
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_LOBBY_MEMBER_LEFT,
+        JitsiConferenceEvents.LOBBY_USER_LEFT);
     chatRoom.addListener(XMPPEvents.MUC_MEMBER_BOT_TYPE_CHANGED,
         conference._onMemberBotTypeChanged.bind(conference));
     chatRoom.addListener(XMPPEvents.MUC_MEMBER_LEFT,
         conference.onMemberLeft.bind(conference));
     this.chatRoomForwarder.forward(XMPPEvents.MUC_LEFT,
         JitsiConferenceEvents.CONFERENCE_LEFT);
+    this.chatRoomForwarder.forward(XMPPEvents.MUC_DENIED_ACCESS,
+        JitsiConferenceEvents.CONFERENCE_FAILED,
+        JitsiConferenceErrors.CONFERENCE_ACCESS_DENIED);
 
     chatRoom.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
         conference.onDisplayNameChanged.bind(conference));

JitsiConferenceEvents.js

  */
 export const SERVER_REGION_CHANGED = 'conference.server_region_changed';
 
+/**
+ * Indicates that the conference had changed to members only enabled/disabled.
+ * The first argument of this event is a <tt>boolean</tt> which when set to
+ * <tt>true</tt> means that the conference is running in members only mode.
+ * You may need to use Lobby if supported to ask for permissions to enter the conference.
+ */
+export const MEMBERS_ONLY_CHANGED = 'conference.membersOnlyChanged';
+
 /**
  * New text message was received.
  */
  * Event indicates that the bot participant type changed.
  */
 export const BOT_TYPE_CHANGED = 'conference.bot_type_changed';
+
+/**
+ * A new user joined the lobby room.
+ */
+export const LOBBY_USER_JOINED = 'conference.lobby.userJoined';
+
+/**
+ * A user from the lobby room has been update.
+ */
+export const LOBBY_USER_UPDATED = 'conference.lobby.userUpdated';
+
+/**
+ * A user left the lobby room.
+ */
+export const LOBBY_USER_LEFT = 'conference.lobby.userLeft';

modules/xmpp/ChatRoom.js

 import * as MediaType from '../../service/RTC/MediaType';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
+import Lobby from './Lobby';
 import Moderator from './moderator';
 import XmppConnection from './XmppConnection';
 
 // of chaining function calls, allow long function call chains.
 /* eslint-disable newline-per-chained-call */
 
+/**
+ * Array of affiliations that are allowed in members only room.
+ * @type {string[]}
+ */
+const MEMBERS_AFFILIATIONS = [ 'owner', 'admin', 'member' ];
+
 /**
  *
  */
      * @param XMPP
      * @param options
      * @param {boolean} options.disableFocus - when set to {@code false} will
-     * not invite Jicofo into the room. This is intended to be used only by
-     * jitsi-meet-spot.
+     * not invite Jicofo into the room.
+     * @param {boolean} options.disableDiscoInfo - when set to {@code false} will skip disco info.
+     * This is intended to be used only for lobby rooms.
+     * @param {boolean} options.enableLobby - when set to {@code false} will skip creating lobby room.
      */
     constructor(connection, jid, password, XMPP, options) {
         super();
                 connection: this.xmpp.options,
                 conference: this.options
             });
+        if (typeof this.options.enableLobby === 'undefined' || this.options.enableLobby) {
+            this.lobby = new Lobby(this);
+        }
         this.initPresenceMap(options);
         this.lastPresences = {};
         this.phoneNumber = null;
 
     /**
      * Joins the chat room.
-     * @param password
+     * @param {string} password - Password to unlock room on joining.
+     * @param {Object} customJoinPresenceExtensions - Key values object to be used
+     * for the initial presence, they key will be an xmpp node and its text is the value,
+     * and those will be added to the initial <x xmlns='http://jabber.org/protocol/muc'/>
      * @returns {Promise} - resolved when join completes. At the time of this
      * writing it's never rejected.
      */
-    join(password) {
+    join(password, customJoinPresenceExtensions) {
         this.password = password;
 
         return new Promise(resolve => {
             this.options.disableFocus
-                && logger.info('Conference focus disabled');
+                && logger.info(`Conference focus disabled for ${this.roomjid}`);
 
             const preJoin
                 = this.options.disableFocus
                     : this.moderator.allocateConferenceFocus();
 
             preJoin.then(() => {
-                this.sendPresence(true);
+                this.sendPresence(true, customJoinPresenceExtensions);
                 this._removeConnListeners.push(
                     this.connection.addEventListener(
                         XmppConnection.Events.CONN_STATUS_CHANGED,
 
     /**
      *
-     * @param fromJoin
+     * @param fromJoin - Whether this is initial presence to join the room.
+     * @param customJoinPresenceExtensions - Object of key values to be added to the initial presence only.
      */
-    sendPresence(fromJoin) {
+    sendPresence(fromJoin, customJoinPresenceExtensions) {
         const to = this.presMap.to;
 
         if (!this.connection || !this.connection.connected || !to || (!this.joined && !fromJoin)) {
             if (this.password) {
                 pres.c('password').t(this.password).up();
             }
+            if (customJoinPresenceExtensions) {
+                Object.keys(customJoinPresenceExtensions).forEach(key => {
+                    pres.c(key).t(customJoinPresenceExtensions[key]).up();
+                });
+            }
             pres.up();
         }
 
             if (meetingIdValEl.length) {
                 this.setMeetingId(meetingIdValEl.text());
             } else {
-                logger.trace('No meeting ID from backend');
+                logger.warn('No meeting ID from backend');
+            }
+
+            const membersOnly = $(result).find('>query>feature[var="muc_membersonly"]').length === 1;
+
+            const lobbyRoomField
+                = $(result).find('>query>x[type="result"]>field[var="muc#roominfo_lobbyroom"]>value');
+
+            if (this.lobby) {
+                this.lobby.setLobbyRoomJid(lobbyRoomField && lobbyRoomField.length ? lobbyRoomField.text() : undefined);
             }
+
+            if (membersOnly !== this.membersOnlyEnabled) {
+                this.membersOnlyEnabled = membersOnly;
+                this.eventEmitter.emit(XMPPEvents.MUC_MEMBERS_ONLY_CHANGED, membersOnly);
+            }
+
         }, error => {
             GlobalOnErrorHandler.callErrorHandler(error);
             logger.error('Error getting room info: ', error);
     createNonAnonymousRoom() {
         // http://xmpp.org/extensions/xep-0045.html#createroom-reserved
 
+        if (this.options.disableDiscoInfo) {
+            return;
+        }
+
         const getForm = $iq({ type: 'get',
             to: this.roomjid })
             .c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' })
 
                 // Now let's check the disco-info to retrieve the
                 // meeting Id if any
-                this.discoRoomInfo();
+                !this.options.disableDiscoInfo && this.discoRoomInfo();
             }
         } else if (jid === undefined) {
             logger.info('Ignoring member with undefined JID');
                     member.statsID,
                     member.status,
                     member.identity,
-                    member.botType);
+                    member.botType,
+                    member.jid);
 
                 // we are reporting the status with the join
                 // so we do not want a second event about status update
                     XMPPEvents.MUC_ROLE_CHANGED, from, member.role);
             }
 
+            // affiliation changed
+            if (memberOfThis.affiliation !== member.affiliation) {
+                memberOfThis.affiliation = member.affiliation;
+            }
+
             // fire event that botType had changed
             if (memberOfThis.botType !== member.botType) {
                 memberOfThis.botType = member.botType;
         }
 
         // room destroyed ?
-        if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]'
-            + '>destroy').length) {
+        const destroySelect = $(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>destroy');
+
+        if (destroySelect.length) {
             let reason;
             const reasonSelect
                 = $(pres).find(
                 reason = reasonSelect.text();
             }
 
-            this.eventEmitter.emit(XMPPEvents.MUC_DESTROYED, reason);
+            this.eventEmitter.emit(XMPPEvents.MUC_DESTROYED, reason, destroySelect.attr('jid'));
             this.connection.emuc.doLeave(this.roomjid);
 
             return true;
                 actorNick = actorSelect.attr('nick');
             }
 
-            // if no member is found this is the case we had kicked someone
-            // and we are not in the list of members
-            if (membersKeys.find(jid => Strophe.getResourceFromJid(jid) === actorNick)) {
-                // we first fire the kicked so we can show the participant
-                // who kicked, before notifying that participant left
-                // we fire kicked for us and for any participant kicked
-                this.eventEmitter.emit(
-                    XMPPEvents.KICKED,
-                    isSelfPresence,
-                    actorNick,
-                    Strophe.getResourceFromJid(from));
-            }
+            // we first fire the kicked so we can show the participant
+            // who kicked, before notifying that participant left
+            // we fire kicked for us and for any participant kicked
+            this.eventEmitter.emit(
+                XMPPEvents.KICKED,
+                isSelfPresence,
+                actorNick,
+                Strophe.getResourceFromJid(from));
         }
 
-        if (!isSelfPresence) {
-            delete this.members[from];
-            this.onParticipantLeft(from, false);
-        } else if (membersKeys.length > 0) {
+        if (isSelfPresence) {
             // If the status code is 110 this means we're leaving and we would
             // like to remove everyone else from our view, so we trigger the
             // event.
             if (!isKick) {
                 this.eventEmitter.emit(XMPPEvents.MUC_LEFT);
             }
+        } else {
+            delete this.members[from];
+            this.onParticipantLeft(from, false);
         }
     }
 
             }
         }
 
-        if (from === this.roomjid
-                && $(msg).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="104"]').length) {
-            this.discoRoomInfo();
+        if (from === this.roomjid) {
+            let invite;
+
+            if ($(msg).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>status[code="104"]').length) {
+                this.discoRoomInfo();
+            } else if ((invite = $(msg).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>invite'))
+                        && invite.length) {
+                const passwordSelect = $(msg).find('>x[xmlns="http://jabber.org/protocol/muc#user"]>password');
+                let password;
+
+                if (passwordSelect && passwordSelect.length) {
+                    password = passwordSelect.text();
+                }
+
+                this.eventEmitter.emit(XMPPEvents.INVITE_MESSAGE_RECEIVED,
+                    from, invite.attr('from'), txt, password);
+            }
         }
         const jsonMessage = $(msg).find('>json-message').text();
         const parsedJson = this.xmpp.tryParseJSONAndVerify(jsonMessage);
             logger.warn('Maximum users limit for the room has been reached',
                 pres);
             this.eventEmitter.emit(XMPPEvents.ROOM_MAX_USERS_ERROR);
+        } else if ($(pres)
+            .find(
+                '>error[type="auth"]'
+                + '>registration-required['
+                + 'xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"]').length) {
+
+            // let's extract the lobby jid from the custom field
+            const lobbyRoomNode = $(pres).find('>lobbyroom');
+            let lobbyRoomJid;
+
+            if (lobbyRoomNode.length) {
+                lobbyRoomJid = lobbyRoomNode.text();
+            }
+
+            this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_MEMBERS_ONLY_ERROR, lobbyRoomJid);
         } else {
             logger.warn('onPresError ', pres);
             this.eventEmitter.emit(XMPPEvents.ROOM_CONNECT_ERROR);
                         .up()
                         .up();
 
+                    // if members only enabled
+                    if (this.membersOnlyEnabled) {
+                        formsubmit
+                            .c('field', { 'var': 'muc#roomconfig_membersonly' })
+                            .c('value')
+                            .t('true')
+                            .up()
+                            .up();
+                    }
+
                     // Fixes a bug in prosody 0.9.+
                     // https://prosody.im/issues/issue/373
                     formsubmit
 
     /* eslint-enable max-params */
 
+    /**
+     * Turns off or on the members only config for the main room.
+     *
+     * @param {boolean} enabled - Whether to turn it on or off.
+     * @param onSuccess - optional callback.
+     * @param onError - optional callback.
+     */
+    setMembersOnly(enabled, onSuccess, onError) {
+        if (enabled && Object.values(this.members).filter(m => !m.isFocus).length) {
+            let sendGrantMembershipIq = false;
+
+            // first grant membership to all that are in the room
+            const grantMembership = $iq({ to: this.roomjid,
+                type: 'set' })
+                .c('query', { xmlns: 'http://jabber.org/protocol/muc#admin' });
+
+            Object.values(this.members).forEach(m => {
+                if (m.jid && !MEMBERS_AFFILIATIONS.includes(m.affiliation)) {
+                    grantMembership.c('item', {
+                        'affiliation': 'member',
+                        'jid': m.jid }).up();
+                    sendGrantMembershipIq = true;
+                }
+            });
+
+            if (sendGrantMembershipIq) {
+                this.xmpp.connection.sendIQ(grantMembership.up());
+            }
+        }
+
+        const errorCallback = onError ? onError : () => {}; // eslint-disable-line no-empty-function
+
+        this.xmpp.connection.sendIQ(
+            $iq({
+                to: this.roomjid,
+                type: 'get'
+            }).c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' }),
+            res => {
+                if ($(res).find('>query>x[xmlns="jabber:x:data"]>field[var="muc#roomconfig_membersonly"]').length) {
+                    const formToSubmit
+                        = $iq({
+                            to: this.roomjid,
+                            type: 'set'
+                        }).c('query', { xmlns: 'http://jabber.org/protocol/muc#owner' });
+
+                    formToSubmit.c('x', {
+                        xmlns: 'jabber:x:data',
+                        type: 'submit'
+                    });
+                    formToSubmit
+                        .c('field', { 'var': 'FORM_TYPE' })
+                        .c('value')
+                        .t('http://jabber.org/protocol/muc#roomconfig')
+                        .up()
+                        .up();
+                    formToSubmit
+                        .c('field', { 'var': 'muc#roomconfig_membersonly' })
+                        .c('value')
+                        .t(enabled ? 'true' : 'false')
+                        .up()
+                        .up();
+
+                    // if room is locked from other participant or we are locking it
+                    if (this.locked) {
+                        formToSubmit
+                            .c('field',
+                                { 'var': 'muc#roomconfig_passwordprotectedroom' })
+                            .c('value')
+                            .t('1')
+                            .up()
+                            .up();
+                    }
+
+                    this.xmpp.connection.sendIQ(formToSubmit, onSuccess, errorCallback);
+                } else {
+                    errorCallback(new Error('Setting members only room not supported!'));
+                }
+            },
+            errorCallback);
+    }
+
     /**
      * Adds the key to the presence map, overriding any previous value.
      * @param key
         return this.connection.rayo.hangup();
     }
 
+    /**
+     *
+     * @returns {Lobby}
+     */
+    getLobby() {
+        return this.lobby;
+    }
+
     /**
      * Returns the phone number for joining the conference.
      */
         }
     }
 
+    /**
+     * Clean any listeners or resources, executed on leaving.
+     */
+    clean() {
+        this._removeConnListeners.forEach(remove => remove());
+        this._removeConnListeners = [];
+    }
+
     /**
      * Leaves the room. Closes the jingle session.
      * @returns {Promise} which is resolved if XMPPEvents.MUC_LEFT is received
             const timeout = setTimeout(() => onMucLeft(true), 5000);
             const eventEmitter = this.eventEmitter;
 
-            this._removeConnListeners.forEach(remove => remove());
-            this._removeConnListeners = [];
+            this.clean();
 
             /**
              *

modules/xmpp/ChatRoom.spec.js

                 undefined, // statsID
                 'status-text',
                 undefined,
-                undefined
+                undefined,
+                'fulljid'
             ]);
         });
 
                 undefined, // statsID
                 undefined,
                 undefined,
-                undefined);
+                undefined,
+                'jid=attr');
         });
 
         it('parses identity correctly', () => {
                 undefined, // statsID
                 'status-text',
                 expectedIdentity,
-                undefined
+                undefined,
+                'fulljid'
             ]);
         });
 
                 undefined, // statsID
                 'status-text',
                 undefined,
-                expectedBotType
+                expectedBotType,
+                'fulljid'
             ]);
         });
 

modules/xmpp/Lobby.js

+import { $msg, Strophe } from 'strophe.js';
+import { getLogger } from 'jitsi-meet-logger';
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
+
+const logger = getLogger(__filename);
+
+/**
+ * The command type for updating a lobby participant's e-mail address.
+ *
+ * @type {string}
+ */
+const EMAIL_COMMAND = 'email';
+
+/**
+ * The Lobby room implementation. Setting a room to members only, joining the lobby room
+ * approving or denying access to participants from the lobby room.
+ */
+export default class Lobby {
+
+    /**
+     * Constructs lobby room.
+     *
+     * @param {ChatRoom} room the main room.
+     */
+    constructor(room) {
+        this.xmpp = room.xmpp;
+        this.mainRoom = room;
+
+        const maybeJoinLobbyRoom = this._maybeJoinLobbyRoom.bind(this);
+
+        this.mainRoom.addEventListener(
+            XMPPEvents.LOCAL_ROLE_CHANGED,
+            maybeJoinLobbyRoom);
+
+        this.mainRoom.addEventListener(
+            XMPPEvents.MUC_MEMBERS_ONLY_CHANGED,
+            maybeJoinLobbyRoom);
+
+        this.mainRoom.addEventListener(
+            XMPPEvents.ROOM_CONNECT_MEMBERS_ONLY_ERROR,
+            jid => {
+                this.lobbyRoomJid = jid;
+            });
+    }
+
+    /**
+     * Whether lobby is supported on backend.
+     *
+     * @returns {boolean} whether lobby is supported on backend.
+     */
+    isSupported() {
+        return this.xmpp.lobbySupported;
+    }
+
+    /**
+     * Enables lobby by setting the main room to be members only and joins the lobby chat room.
+     *
+     * @returns {Promise}
+     */
+    enable() {
+        if (!this.isSupported()) {
+            return Promise.reject(new Error('Lobby not supported!'));
+        }
+
+        return new Promise((resolve, reject) => {
+            this.mainRoom.setMembersOnly(true, resolve, reject);
+        });
+    }
+
+    /**
+     * Disable lobby by setting the main room to be non members only and levaes the lobby chat room if joined.
+     *
+     * @returns {void}
+     */
+    disable() {
+        if (!this.isSupported() || !this.mainRoom.isModerator()
+                || !this.lobbyRoom || !this.mainRoom.membersOnlyEnabled) {
+            return;
+        }
+
+        this.mainRoom.setMembersOnly(false);
+    }
+
+    /**
+     * Leaves the lobby room.
+     * @private
+     */
+    _leaveLobbyRoom() {
+        if (this.lobbyRoom) {
+            this.lobbyRoom.leave()
+                .then(() => {
+                    this.lobbyRoom = undefined;
+                    logger.info('Lobby room left!');
+                })
+                .catch(() => {}); // eslint-disable-line no-empty-function
+        }
+    }
+
+    /**
+     * We had received a jid for the lobby room.
+     *
+     * @param jid the lobby room jid to join.
+     */
+    setLobbyRoomJid(jid) {
+        this.lobbyRoomJid = jid;
+    }
+
+    /**
+     * Checks the state of mainRoom, lobbyRoom and current user role to decide whether to join lobby room.
+     * @private
+     */
+    _maybeJoinLobbyRoom() {
+        if (!this.isSupported()) {
+            return;
+        }
+
+        const isModerator = this.mainRoom.joined && this.mainRoom.isModerator();
+
+        if (isModerator && this.mainRoom.membersOnlyEnabled && !this.lobbyRoom) {
+            // join the lobby
+            this.join()
+                .then(() => logger.info('Joined lobby room'))
+                .catch(e => logger.error('Failed joining lobby', e));
+        }
+    }
+
+    /**
+     * Joins a lobby room setting display name and eventually avatar(using the email provided).
+     *
+     * @param {string} username is required.
+     * @param {string} email is optional.
+     * @returns {Promise} resolves once we join the room.
+     */
+    join(displayName, email) {
+        const isModerator = this.mainRoom.joined && this.mainRoom.isModerator();
+
+        if (!this.lobbyRoomJid) {
+            return Promise.reject(new Error('Missing lobbyRoomJid, cannot join lobby room.'));
+        }
+
+        const roomName = Strophe.getNodeFromJid(this.lobbyRoomJid);
+        const customDomain = Strophe.getDomainFromJid(this.lobbyRoomJid);
+
+        this.lobbyRoom = this.xmpp.createRoom(
+            roomName, {
+                customDomain,
+                disableDiscoInfo: true,
+                disableFocus: true,
+                enableLobby: false
+            }
+        );
+
+        if (displayName) {
+            // remove previously set nickname
+            this.lobbyRoom.removeFromPresence('nick');
+            this.lobbyRoom.addToPresence('nick', {
+                attributes: { xmlns: 'http://jabber.org/protocol/nick' },
+                value: displayName
+            });
+        }
+
+        if (isModerator) {
+            this.lobbyRoom.addPresenceListener(EMAIL_COMMAND, (node, from) => {
+                this.mainRoom.eventEmitter.emit(XMPPEvents.MUC_LOBBY_MEMBER_UPDATED, from, { email: node.value });
+            });
+            this.lobbyRoom.addEventListener(
+                XMPPEvents.MUC_MEMBER_JOINED,
+                // eslint-disable-next-line max-params
+                (from, nick, role, isHiddenDomain, statsID, status, identity, botType, jid) => {
+                    // we need to ignore joins on lobby for participants that are already in the main room
+                    if (Object.values(this.mainRoom.members).find(m => m.jid === jid)) {
+                        return;
+                    }
+
+                    // we emit the new event on the main room so we can propagate
+                    // events to the conference
+                    this.mainRoom.eventEmitter.emit(
+                        XMPPEvents.MUC_LOBBY_MEMBER_JOINED,
+                        Strophe.getResourceFromJid(from),
+                        nick,
+                        identity ? identity.avatar : undefined
+                    );
+                });
+            this.lobbyRoom.addEventListener(
+                XMPPEvents.MUC_MEMBER_LEFT, from => {
+                    // we emit the new event on the main room so we can propagate
+                    // events to the conference
+                    this.mainRoom.eventEmitter.emit(
+                        XMPPEvents.MUC_LOBBY_MEMBER_LEFT,
+                        Strophe.getResourceFromJid(from)
+                    );
+                });
+            this.lobbyRoom.addEventListener(
+                XMPPEvents.MUC_DESTROYED,
+                () => {
+                    // let's make sure we emit that all lobby users had left
+                    Object.keys(this.lobbyRoom.members)
+                        .forEach(j => this.mainRoom.eventEmitter.emit(
+                            XMPPEvents.MUC_LOBBY_MEMBER_LEFT, Strophe.getResourceFromJid(j)));
+
+                    this.lobbyRoom = undefined;
+                    logger.info('Lobby room left(destroyed)!');
+                });
+        } else {
+            // this should only be handled by those waiting in lobby
+            this.lobbyRoom.addEventListener(XMPPEvents.KICKED, isSelfPresence => {
+                if (isSelfPresence) {
+                    this.mainRoom.eventEmitter.emit(XMPPEvents.MUC_DENIED_ACCESS);
+
+                    this.lobbyRoom.clean();
+
+                    return;
+                }
+            });
+
+            // As there is still reference of the main room
+            // the invite will be detected and addressed to its eventEmitter, even though we are not in it
+            // the invite message should be received directly to the xmpp conn in general
+            this.mainRoom.addEventListener(
+                XMPPEvents.INVITE_MESSAGE_RECEIVED,
+                (roomJid, from, txt, invitePassword) => {
+                    logger.debug(`Received approval to join ${roomJid} ${from} ${txt}`);
+                    if (roomJid === this.mainRoom.roomjid) {
+                        // we are now allowed let's join and leave lobby
+                        this.mainRoom.join(invitePassword);
+
+                        this._leaveLobbyRoom();
+                    }
+                });
+            this.lobbyRoom.addEventListener(
+                XMPPEvents.MUC_DESTROYED,
+                (reason, jid) => {
+                    // we are receiving the jid of the main room
+                    // means we are invited to join, maybe lobby was disabled
+                    if (jid && jid === this.mainRoom.roomjid) {
+                        this.mainRoom.join();
+
+                        return;
+                    }
+
+                    this.mainRoom.eventEmitter.emit(XMPPEvents.MUC_DESTROYED, reason);
+                });
+
+            // If participant retries joining shared password while waiting in the lobby
+            // and succeeds make sure we leave lobby
+            this.mainRoom.addEventListener(
+                XMPPEvents.MUC_JOINED,
+                () => {
+                    this._leaveLobbyRoom();
+                });
+        }
+
+        return new Promise((resolve, reject) => {
+            this.lobbyRoom.addEventListener(XMPPEvents.MUC_JOINED, () => {
+                resolve();
+
+                // send our email, as we do not handle this on initial presence we need a second one
+                if (email && !isModerator) {
+                    this.lobbyRoom.removeFromPresence(EMAIL_COMMAND);
+                    this.lobbyRoom.addToPresence(EMAIL_COMMAND, { value: email });
+                    this.lobbyRoom.sendPresence();
+                }
+            });
+            this.lobbyRoom.addEventListener(XMPPEvents.ROOM_JOIN_ERROR, reject);
+            this.lobbyRoom.addEventListener(XMPPEvents.ROOM_CONNECT_NOT_ALLOWED_ERROR, reject);
+            this.lobbyRoom.addEventListener(XMPPEvents.ROOM_CONNECT_ERROR, reject);
+
+            this.lobbyRoom.join();
+        });
+
+    }
+
+    /**
+     * Should be possible only for moderators.
+     * @param id
+     */
+    denyAccess(id) {
+        if (!this.isSupported() || !this.mainRoom.isModerator()) {
+            return;
+        }
+
+        const jid = Object.keys(this.lobbyRoom.members)
+            .find(j => Strophe.getResourceFromJid(j) === id);
+
+        if (jid) {
+            this.lobbyRoom.kick(jid);
+        } else {
+            logger.error(`Not found member for ${id} in lobby room.`);
+        }
+    }
+
+    /**
+     * Should be possible only for moderators.
+     * @param id
+     */
+    approveAccess(id) {
+        if (!this.isSupported() || !this.mainRoom.isModerator()) {
+            return;
+        }
+
+        const memberRoomJid = Object.keys(this.lobbyRoom.members)
+            .find(j => Strophe.getResourceFromJid(j) === id);
+
+        if (memberRoomJid) {
+            const jid = this.lobbyRoom.members[memberRoomJid].jid;
+            const msgToSend
+                = $msg({ to: this.mainRoom.roomjid })
+                    .c('x', { xmlns: 'http://jabber.org/protocol/muc#user' })
+                    .c('invite', { to: jid });
+
+            this.xmpp.connection.sendIQ(msgToSend,
+                () => { }, // eslint-disable-line no-empty-function
+                e => {
+                    logger.error(`Error sending invite for ${jid}`, e);
+                });
+        } else {
+            logger.error(`Not found member for ${memberRoomJid} in lobby room.`);
+        }
+    }
+}

modules/xmpp/xmpp.js

                         if (identity.type === 'conference_duration') {
                             this.conferenceDurationComponentAddress = identity.name;
                         }
+
+                        if (identity.type === 'lobbyrooms') {
+                            this.lobbySupported = true;
+                        }
                     });
 
                     if (this.speakerStatsComponentAddress
      * @returns {Promise} Resolves with an instance of a strophe muc.
      */
     createRoom(roomName, options, onCreateResource) {
-        let roomjid = `${roomName}@${this.options.hosts.muc}/`;
+        let roomjid = `${roomName}@${options.customDomain
+            ? options.customDomain : this.options.hosts.muc}/`;
 
         const mucNickname = onCreateResource
             ? onCreateResource(this.connection.jid, this.authenticatedUser)

service/xmpp/XMPPEvents.js

     // received.
     MESSAGE_RECEIVED: 'xmpp.message_received',
 
+    // Designates an event indicating that an invite XMPP message in the MUC was
+    // received.
+    INVITE_MESSAGE_RECEIVED: 'xmpp.invite_message_received',
+
     // Designates an event indicating that a private XMPP message in the MUC was
     // received.
     PRIVATE_MESSAGE_RECEIVED: 'xmpp.private_message_received',
     // Designates an event indicating that a participant left the XMPP MUC.
     MUC_MEMBER_LEFT: 'xmpp.muc_member_left',
 
+    // Designates an event indicating that a participant joined the lobby XMPP MUC.
+    MUC_LOBBY_MEMBER_JOINED: 'xmpp.muc_lobby_member_joined',
+
+    // Designates an event indicating that a participant in the lobby XMPP MUC has been updated
+    MUC_LOBBY_MEMBER_UPDATED: 'xmpp.muc_lobby_member_updated',
+
+    // Designates an event indicating that a participant left the XMPP MUC.
+    MUC_LOBBY_MEMBER_LEFT: 'xmpp.muc_lobby_member_left',
+
+    // Designates an event indicating that a participant was denied access to a conference from the lobby XMPP MUC.
+    MUC_DENIED_ACCESS: 'xmpp.muc_denied access',
+
     // Designates an event indicating that local participant left the muc
     MUC_LEFT: 'xmpp.muc_left',
 
     // Designates an event indicating that the MUC has been locked or unlocked.
     MUC_LOCK_CHANGED: 'xmpp.muc_lock_changed',
 
+    // Designates an event indicating that the MUC members only config has changed.
+    MUC_MEMBERS_ONLY_CHANGED: 'xmpp.muc_members_only_changed',
+
     // Designates an event indicating that a participant in the XMPP MUC has
     // advertised that they have audio muted (or unmuted).
     PARTICIPANT_AUDIO_MUTED: 'xmpp.audio_muted',
     ROOM_CONNECT_ERROR: 'xmpp.room_connect_error',
     ROOM_CONNECT_NOT_ALLOWED_ERROR: 'xmpp.room_connect_error.not_allowed',
     ROOM_JOIN_ERROR: 'xmpp.room_join_error',
+    ROOM_CONNECT_MEMBERS_ONLY_ERROR: 'xmpp.room_connect_error.members_only',
 
     /**
      * Indicates that max users limit has been reached.