feat: Audio/Video moderation. (#1581)

* feat: Audio/Video moderation.

* squash: Fix docs.

* squash: Adds some warning logs when execution is rejected.

* squash: Changes a field name in the message for adding jid to whitelist.

* squash: Send to participants only message about approval.

Skips sending the whole list.

* squash: Fixes tests.

* squash: Adds more logs.

* feat: Separates enable/disable by media type.

Adds actor to the messages to inform who enabled it.

* squash: Fixes log line.

* squash: Fixes comments.

* squash: Fixes log messages.

* squash: Fixes comments.

JitsiConference.js

 JitsiConference.prototype.setSubject = function(subject) {
     if (this.room && this.isModerator()) {
         this.room.setSubject(subject);
+    } else {
+        logger.warn(`Failed to set subject, ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator'}`);
     }
 };
 
  */
 JitsiConference.prototype.setStartMutedPolicy = function(policy) {
     if (!this.isModerator()) {
+        logger.warn(`Failed to set start muted policy, ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator'}`);
+
         return;
     }
     this.startMutedPolicy = policy;
 JitsiConference.prototype.disableLobby = function() {
     if (this.room && this.isModerator()) {
         this.room.getLobby().disable();
+    } else {
+        logger.warn(`Failed to disable lobby, ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator'}`);
     }
 };
 
         this.room.getLobby().approveAccess(id);
     }
 };
+
+/**
+ * Returns <tt>true</tt> if AV Moderation support is enabled in the backend.
+ *
+ * @returns {boolean} whether AV Moderation is supported in the backend.
+ */
+JitsiConference.prototype.isAVModerationSupported = function() {
+    return Boolean(this.room && this.room.getAVModeration().isSupported());
+};
+
+/**
+ * Enables AV Moderation.
+ * @param {MediaType} mediaType "audio" or "video"
+ */
+JitsiConference.prototype.enableAVModeration = function(mediaType) {
+    if (this.room && this.isModerator()
+        && (mediaType === MediaType.AUDIO || mediaType === MediaType.VIDEO)) {
+        this.room.getAVModeration().enable(true, mediaType);
+    } else {
+        logger.warn(`Failed to enable AV moderation, ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator, '}${
+            this.room && this.isModerator() ? 'wrong media type passed' : ''}`);
+    }
+};
+
+/**
+ * Disables AV Moderation.
+ * @param {MediaType} mediaType "audio" or "video"
+ */
+JitsiConference.prototype.disableAVModeration = function(mediaType) {
+    if (this.room && this.isModerator()
+        && (mediaType === MediaType.AUDIO || mediaType === MediaType.VIDEO)) {
+        this.room.getAVModeration().enable(false, mediaType);
+    } else {
+        logger.warn(`Failed to disable AV moderation, ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator, '}${
+            this.room && this.isModerator() ? 'wrong media type passed' : ''}`);
+    }
+};
+
+/**
+ * Approve participant access to certain media, allows unmuting audio or video.
+ *
+ * @param {MediaType} mediaType "audio" or "video"
+ * @param id the id of the participant.
+ */
+JitsiConference.prototype.avModerationApprove = function(mediaType, id) {
+    if (this.room && this.isModerator()
+        && (mediaType === MediaType.AUDIO || mediaType === MediaType.VIDEO)) {
+
+        const participant = this.getParticipantById(id);
+
+        if (!participant) {
+            return;
+        }
+
+        this.room.getAVModeration().approve(mediaType, participant.getJid());
+    } else {
+        logger.warn(`AV moderation skipped , ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator, '}${
+            this.room && this.isModerator() ? 'wrong media type passed' : ''}`);
+    }
+};

JitsiConferenceEventManager.js

         createdTimestamp => {
             conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_CREATED_TIMESTAMP, createdTimestamp);
         });
+
+    this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_CHANGED,
+        (value, mediaType, actorJid) => {
+            const actorParticipant = conference.getParticipants().find(p => p.getJid() === actorJid);
+
+            conference.eventEmitter.emit(JitsiConferenceEvents.AV_MODERATION_CHANGED, {
+                enabled: value,
+                mediaType,
+                actor: actorParticipant
+            });
+        });
+    this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_PARTICIPANT_APPROVED,
+        (mediaType, jid) => {
+            const participant = conference.getParticipantById(Strophe.getResourceFromJid(jid));
+
+            if (participant) {
+                conference.eventEmitter.emit(JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_APPROVED, {
+                    participant,
+                    mediaType
+                });
+            }
+        });
+    this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_APPROVED,
+        value => conference.eventEmitter.emit(JitsiConferenceEvents.AV_MODERATION_APPROVED, { mediaType: value }));
 };
 
 /**

JitsiConferenceEvents.js

  * A user left the lobby room.
  */
 export const LOBBY_USER_LEFT = 'conference.lobby.userLeft';
+
+/**
+ * The local participant was approved to be able to unmute.
+ * @param {options} event - {
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_APPROVED = 'conference.av_moderation.approved';
+
+/**
+ * AV Moderation was enabled/disabled. The actor is the participant that is currently in the meeting,
+ * or undefined if that participant has left the meeting.
+ *
+ * @param {options} event - {
+ *     {boolean} enabled,
+ *     {MediaType} mediaType,
+ *     {JitsiParticipant} actor
+ * }.
+ */
+export const AV_MODERATION_CHANGED = 'conference.av_moderation.changed';
+
+/**
+ * AV Moderation, report for user being approved to unmute.
+ * @param {options} event - {
+ *     {JitsiParticipant} participant,
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_PARTICIPANT_APPROVED = 'conference.av_moderation.participant.approved';

modules/xmpp/AVModeration.js

+import { getLogger } from 'jitsi-meet-logger';
+import { $msg } from 'strophe.js';
+
+import * as MediaType from '../../service/RTC/MediaType';
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
+
+const logger = getLogger(__filename);
+
+/**
+ * The AVModeration logic.
+ */
+export default class AVModeration {
+
+    /**
+     * Constructs AV moderation room.
+     *
+     * @param {ChatRoom} room the main room.
+     */
+    constructor(room) {
+        this._xmpp = room.xmpp;
+
+        this._mainRoom = room;
+
+        this._momderationEnabledByType = {
+            [MediaType.AUDIO]: false,
+            [MediaType.VIDEO]: false
+        };
+
+        this._whitelistAudio = [];
+        this._whitelistVideo = [];
+
+        this._xmpp.addListener(XMPPEvents.AV_MODERATION_RECEIVED, this._onMessage.bind(this));
+    }
+
+    /**
+     * Whether AV moderation is supported on backend.
+     *
+     * @returns {boolean} whether AV moderation is supported on backend.
+     */
+    isSupported() {
+        return Boolean(this._xmpp.avModerationComponentAddress);
+    }
+
+    /**
+     * Enables or disables AV Moderation by sending a msg with command to the component.
+     */
+    enable(state, mediaType) {
+        if (!this.isSupported() || !this._mainRoom.isModerator()) {
+            logger.error(`Cannot enable:${state} AV moderation supported:${this.isSupported()}, 
+                moderator:${this._mainRoom.isModerator()}`);
+
+            return;
+        }
+
+        if (state === this._momderationEnabledByType[mediaType]) {
+            logger.warn(`Moderation already in state:${state} for mediaType:${mediaType}`);
+
+            return;
+        }
+
+        // send the enable/disable message
+        const msg = $msg({ to: this._xmpp.avModerationComponentAddress });
+
+        msg.c('av_moderation', {
+            enable: state,
+            mediaType
+        }).up();
+
+        this._xmpp.connection.send(msg);
+    }
+
+    /**
+     * Approves that a participant can unmute by sending a msg with its jid to the component.
+     */
+    approve(mediaType, jid) {
+        if (!this.isSupported() || !this._mainRoom.isModerator()) {
+            logger.error(`Cannot approve in AV moderation supported:${this.isSupported()}, 
+                moderator:${this._mainRoom.isModerator()}`);
+
+            return;
+        }
+
+        // send a message to whitelist the jid and approve it to unmute
+        const msg = $msg({ to: this._xmpp.avModerationComponentAddress });
+
+        msg.c('av_moderation', {
+            mediaType,
+            jidToWhitelist: jid }).up();
+
+        this._xmpp.connection.send(msg);
+    }
+
+    /**
+     * Receives av_moderation parsed messages as json.
+     * @param obj the parsed json content of the message to process.
+     * @private
+     */
+    _onMessage(obj) {
+        const newWhitelists = obj.whitelists;
+
+        if (newWhitelists) {
+            const fireEventApprovedJids = (mediaType, oldList, newList) => {
+                newList.filter(x => !oldList.includes(x))
+                    .forEach(jid => this._xmpp.eventEmitter
+                        .emit(XMPPEvents.AV_MODERATION_PARTICIPANT_APPROVED, mediaType, jid));
+            };
+
+            if (newWhitelists[MediaType.AUDIO]) {
+                fireEventApprovedJids(MediaType.AUDIO, this._whitelistAudio, newWhitelists[MediaType.AUDIO]);
+            }
+
+            if (newWhitelists[MediaType.VIDEO]) {
+                fireEventApprovedJids(MediaType.VIDEO, this._whitelistVideo, newWhitelists[MediaType.VIDEO]);
+            }
+        } else if (this._momderationEnabledByType[obj.mediaType] !== obj.enabled) {
+            this._momderationEnabledByType[obj.mediaType] = obj.enabled;
+
+            this._xmpp.eventEmitter.emit(XMPPEvents.AV_MODERATION_CHANGED, obj.enabled, obj.mediaType, obj.actor);
+        } else if (obj.approved) {
+            this._xmpp.eventEmitter.emit(XMPPEvents.AV_MODERATION_APPROVED, obj.mediaType);
+        }
+    }
+}

modules/xmpp/ChatRoom.js

 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import Listenable from '../util/Listenable';
 
+import AVModeration from './AVModeration';
 import Lobby from './Lobby';
 import XmppConnection from './XmppConnection';
 import Moderator from './moderator';
         if (typeof this.options.enableLobby === 'undefined' || this.options.enableLobby) {
             this.lobby = new Lobby(this);
         }
+        this.avModeration = new AVModeration(this);
         this.initPresenceMap(options);
         this.lastPresences = {};
         this.phoneNumber = null;
         return this.lobby;
     }
 
+    /**
+     * @returns {AVModeration}
+     */
+    getAVModeration() {
+        return this.avModeration;
+    }
+
+
     /**
      * Returns the phone number for joining the conference.
      */

modules/xmpp/ChatRoom.spec.js

 
         beforeEach(() => {
             const xmpp = {
-                options: {}
+                options: {},
+                addListener: () => {} // eslint-disable-line no-empty-function
             };
 
             room = new ChatRoom(

modules/xmpp/xmpp.js

     _processDiscoInfoIdentities(identities, features) {
         // check for speakerstats
         identities.forEach(identity => {
+            if (identity.type === 'av_moderation') {
+                this.avModerationComponentAddress = identity.name;
+            }
+
             if (identity.type === 'speakerstats') {
                 this.speakerStatsComponentAddress = identity.name;
             }
             }
         });
 
-        if (this.speakerStatsComponentAddress
+        if (this.avModerationComponentAddress
+            || this.speakerStatsComponentAddress
             || this.conferenceDurationComponentAddress) {
             this.connection.addHandler(this._onPrivateMessage.bind(this), null, 'message', null, null);
         }
      * @private
      */
     _onSystemMessage(msg) {
+        // proceed only if the message has any of the expected information
+        if ($(msg).find('>services').length === 0 && $(msg).find('>query').length === 0) {
+            return;
+        }
+
         this.sendDiscoInfo = false;
 
         const foundIceServers = this.connection.jingle.onReceiveStunAndTurnCredentials(msg);
      * the json object. Otherwise, returns false.
      */
     tryParseJSONAndVerify(jsonString) {
+        // ignore empty strings, like message errors
+        if (!jsonString) {
+            return false;
+        }
+
         try {
             const json = JSON.parse(jsonString);
 
                     + 'structure', 'topic: ', type);
             }
         } catch (e) {
-            logger.error(e);
+            logger.error(`Error parsing json ${jsonString}`, e);
 
             return false;
         }
         const from = msg.getAttribute('from');
 
         if (!(from === this.speakerStatsComponentAddress
-            || from === this.conferenceDurationComponentAddress)) {
+            || from === this.conferenceDurationComponentAddress
+            || from === this.avModerationComponentAddress)) {
             return true;
         }
 
             .text();
         const parsedJson = this.tryParseJSONAndVerify(jsonMessage);
 
-        if (parsedJson
-            && parsedJson[JITSI_MEET_MUC_TYPE] === 'speakerstats'
-            && parsedJson.users) {
-            this.eventEmitter.emit(
-                XMPPEvents.SPEAKER_STATS_RECEIVED, parsedJson.users);
+        if (!parsedJson) {
+            return true;
         }
 
-        if (parsedJson
-            && parsedJson[JITSI_MEET_MUC_TYPE] === 'conference_duration'
-            && parsedJson.created_timestamp) {
-            this.eventEmitter.emit(
-                XMPPEvents.CONFERENCE_TIMESTAMP_RECEIVED, parsedJson.created_timestamp);
+        if (parsedJson[JITSI_MEET_MUC_TYPE] === 'speakerstats' && parsedJson.users) {
+            this.eventEmitter.emit(XMPPEvents.SPEAKER_STATS_RECEIVED, parsedJson.users);
+        } else if (parsedJson[JITSI_MEET_MUC_TYPE] === 'conference_duration' && parsedJson.created_timestamp) {
+            this.eventEmitter.emit(XMPPEvents.CONFERENCE_TIMESTAMP_RECEIVED, parsedJson.created_timestamp);
+        } else if (parsedJson[JITSI_MEET_MUC_TYPE] === 'av_moderation') {
+            this.eventEmitter.emit(XMPPEvents.AV_MODERATION_RECEIVED, parsedJson);
         }
 
         return true;

service/xmpp/XMPPEvents.js

      */
     CONFERENCE_TIMESTAMP_RECEIVED: 'xmpp.conference_timestamp_received',
 
+    /**
+     * Event fired when we receive a message for AV moderation approved for the local participant.
+     */
+    AV_MODERATION_APPROVED: 'xmpp.av_moderation.approved',
+
+    /**
+     * Event fired when we receive a message for AV moderation.
+     */
+    AV_MODERATION_RECEIVED: 'xmpp.av_moderation.received',
+
+    /**
+     * Event fired when the moderation enable/disable changes.
+     */
+    AV_MODERATION_CHANGED: 'xmpp.av_moderation.changed',
+
+    /**
+     * Event fired when we receive message that a new jid was approved.
+     */
+    AV_MODERATION_PARTICIPANT_APPROVED: 'xmpp.av_moderation.participant.approved',
+
     // Designates an event indicating that we should join the conference with
     // audio and/or video muted.
     START_MUTED_FROM_FOCUS: 'xmpp.start_muted_from_focus',