A/V moderation

src/main/java/org/jitsi/impl/protocol/xmpp/ChatRoom.java

@@ -19,6 +19,7 @@
 
 import org.jitsi.jicofo.*;
 import org.jitsi.jicofo.xmpp.muc.*;
+import org.jitsi.utils.*;
 import org.jivesoftware.smack.*;
 import org.jivesoftware.smack.packet.*;
 import org.jxmpp.jid.*;
@@ -198,4 +199,40 @@ void join()
      * Get the unique meeting ID associated by this room (set by the MUC service).
      */
     String getMeetingId();
+
+    /**
+     * Whether A/V moderation is enabled.
+     * @param mediaType the media type.
+     * @return whether A/V moderation is enabled.
+     */
+    boolean isAvModerationEnabled(MediaType mediaType);
+
+    /**
+     * Sets new value for A/V moderation.
+     * @param actorJid the jid of the participant performing the operation.
+     * @param mediaType the media type.
+     * @param value the new value.
+     */
+    void setAvModerationEnabled(Jid actorJid, MediaType mediaType, boolean value);
+
+    /**
+     * Returns the actor that performed the last enable/disable action.
+     * @param mediaType the media type.
+     * @return the jid of the actor.
+     */
+    Jid getAvModerationActor(MediaType mediaType);
+
+    /**
+     * Updates the list of members that are allowed to unmute audio or video.
+     * @param whitelists a map with string keys (MediaType.AUDIO or MediaType.VIDEO).
+     */
+    void updateAvModerationWhitelists(Map<String, List<String>> whitelists);
+
+    /**
+     * Checks the whitelists whether the supplied jid is allowed from a moderator to unmute.
+     * @param jid the jid to check.
+     * @param mediaType type of media for which we are checking.
+     * @return <tt>true</tt> if the member is allowed to unmute, false otherwise.
+     */
+    boolean isMemberAllowedToUnmute(Jid jid, MediaType mediaType);
 }

src/main/java/org/jitsi/impl/protocol/xmpp/ChatRoomImpl.java

@@ -21,6 +21,7 @@
 import org.jitsi.jicofo.*;
 import org.jitsi.jicofo.xmpp.*;
 import org.jitsi.jicofo.xmpp.muc.*;
+import org.jitsi.utils.*;
 import org.jitsi.utils.logging2.*;
 
 import org.jivesoftware.smack.*;
@@ -139,6 +140,18 @@ public class ChatRoomImpl
      */
     private String meetingId = null;
 
+    /**
+     * Indicates whether A/V Moderation is enabled for this room.
+     */
+    private Map<MediaType, Boolean> avModerationEnabled = new HashMap<>();
+
+    /**
+     * The actor that last enabled/disabled the moderation.
+     */
+    private Map<MediaType, Jid> avModerationActor = new HashMap<>();
+
+    private Map<String, List<String>> whitelists = new HashMap<>();
+
     /**
      * Creates new instance of <tt>ChatRoomImpl</tt>.
      *
@@ -844,6 +857,57 @@ public void processPresence(Presence presence)
         }
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isAvModerationEnabled(MediaType mediaType)
+    {
+        Boolean value = this.avModerationEnabled.get(mediaType);
+
+        // must be non null and true
+        return value != null && value;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void setAvModerationEnabled(Jid actorJid, MediaType mediaType, boolean value)
+    {
+        this.avModerationEnabled.put(mediaType, value);
+        this.avModerationActor.put(mediaType, actorJid);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public Jid getAvModerationActor(MediaType mediaType)
+    {
+        return this.avModerationActor.get(mediaType);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public void updateAvModerationWhitelists(@NotNull Map<String, List<String>> whitelists)
+    {
+        this.whitelists = whitelists;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isMemberAllowedToUnmute(Jid jid, MediaType mediaType)
+    {
+        if (!this.isAvModerationEnabled(mediaType))
+        {
+            return true;
+        }
+
+        List<String> whitelist = this.whitelists.get(mediaType.toString());
+
+        return whitelist == null ? false : whitelist.contains(jid.toString());
+    }
+
     class MemberListener
         implements ParticipantStatusListener
     {

src/main/java/org/jitsi/jicofo/JitsiMeetConference.java

@@ -23,6 +23,7 @@
 import org.jitsi.jicofo.jibri.*;
 import org.jitsi.jicofo.xmpp.*;
 import org.jitsi.jicofo.xmpp.muc.*;
+import org.jitsi.utils.*;
 import org.jitsi.xmpp.extensions.jibri.*;
 import org.jxmpp.jid.*;
 
@@ -107,6 +108,12 @@ default JibriSipGateway getJibriSipGateway()
      */
     @NotNull IqProcessingResult handleJibriRequest(@NotNull IqRequest<JibriIq> request);
 
+    /**
+     * Used for av moderation, when we want to mute all participants that are not moderators.
+     * @param mediaType the media type we want to mute.
+     */
+    void muteAllNonModeratorParticipants(MediaType mediaType);
+
     /**
      * Return {@code true} if the user with the given JID should be allowed to invite jigasi to this conference.
      */

src/main/java/org/jitsi/jicofo/JitsiMeetConferenceImpl.java

@@ -49,6 +49,7 @@
 import java.util.logging.*;
 import java.util.stream.*;
 
+import static org.jitsi.jicofo.JitsiMeetConferenceImpl.MuteResult.*;
 import static org.jitsi.jicofo.xmpp.IqProcessingResult.*;
 
 /**
@@ -2102,7 +2103,8 @@ public MuteResult handleMuteRequest(Jid muterJid, Jid toBeMutedJid, boolean doMu
             return MuteResult.ERROR;
         }
         // Only moderators can mute others
-        if (!muterJid.equals(toBeMutedJid) && !muter.getChatMember().getRole().hasModeratorRights())
+        boolean isMuterModerator = muter.getChatMember().getRole().hasModeratorRights();
+        if (!muterJid.equals(toBeMutedJid) && !isMuterModerator)
         {
             logger.warn("Mute not allowed for non-moderator " + muterJid);
             return MuteResult.NOT_ALLOWED;
@@ -2115,11 +2117,25 @@ public MuteResult handleMuteRequest(Jid muterJid, Jid toBeMutedJid, boolean doMu
             return MuteResult.ERROR;
         }
 
-        // do not allow unmuting other participants even for the moderator
-        if (!doMute && !muterJid.equals(toBeMutedJid))
+        // process unmuting
+        if (!doMute)
         {
-            logger.warn("Unmute now allowed, mutedJid=" + muterJid + ", toBeMutedJid=" + toBeMutedJid);
-            return MuteResult.NOT_ALLOWED;
+            // do not allow unmuting other participants even for the moderator
+            if (!muterJid.equals(toBeMutedJid))
+            {
+                logger.warn("Unmute not allowed, muterJid=" + muterJid + ", toBeMutedJid=" + toBeMutedJid);
+                return MuteResult.NOT_ALLOWED;
+            }
+            else if (this.chatRoom.isAvModerationEnabled(mediaType))
+            {
+                // when A/V moderation is enabled we need to check the whitelists if participant is not moderator
+                if (!isMuterModerator && !this.chatRoom.isMemberAllowedToUnmute(toBeMutedJid, mediaType))
+                {
+                    logger.warn("Unmute not allowed due to av moderation, muterJid=" + muterJid
+                        + ", toBeMutedJid=" + toBeMutedJid);
+                    return MuteResult.NOT_ALLOWED;
+                }
+            }
         }
 
         if (doMute
@@ -2154,6 +2170,69 @@ public MuteResult handleMuteRequest(Jid muterJid, Jid toBeMutedJid, boolean doMu
         return succeeded ? MuteResult.SUCCESS : MuteResult.ERROR;
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public void muteAllNonModeratorParticipants(MediaType mediaType)
+    {
+        for (Participant participant : participants)
+        {
+            muteParticipant(participant, mediaType);
+        }
+    }
+
+    /**
+     * Mutes a participant.
+     * @param participant the participant to mute and is not moderator and hasn't been already muted.
+     * @param mediaType the media type for the operation.
+     */
+    public void muteParticipant(Participant participant, MediaType mediaType)
+    {
+        boolean isMuterModerator = participant.getChatMember().getRole().hasModeratorRights();
+        if (isMuterModerator || participant.isInitialAVModerationApplied(mediaType))
+        {
+            return;
+        }
+
+        Jid muterJid = this.chatRoom.getAvModerationActor(mediaType);
+
+        MuteResult result = handleMuteRequest(muterJid, participant.getMucJid(), true, mediaType);
+        if (result == SUCCESS)
+        {
+            // let's mark that this participant was muted
+            participant.setInitialAVModerationApplied(mediaType);
+
+            IQ muteIq = null;
+            if (mediaType == MediaType.AUDIO)
+            {
+                MuteIq muteStatusUpdate = new MuteIq();
+                muteStatusUpdate.setActor(muterJid);
+                muteStatusUpdate.setType(IQ.Type.set);
+                muteStatusUpdate.setTo(participant.getMucJid());
+
+                muteStatusUpdate.setMute(true);
+
+                muteIq = muteStatusUpdate;
+            }
+            else if (mediaType == MediaType.VIDEO)
+            {
+                MuteVideoIq muteStatusUpdate = new MuteVideoIq();
+                muteStatusUpdate.setActor(muterJid);
+                muteStatusUpdate.setType(IQ.Type.set);
+                muteStatusUpdate.setTo(participant.getMucJid());
+
+                muteStatusUpdate.setMute(true);
+
+                muteIq = muteStatusUpdate;
+            }
+
+            if (muteIq != null)
+            {
+                UtilKt.tryToSendStanza(clientXmppProvider.getXmppConnection(), muteIq);
+            }
+        }
+    }
+
     /**
      * Returns current participants count. A participant is chat member who has
      * some videobridge and media state assigned(not just raw chat room member).

src/main/java/org/jitsi/jicofo/Participant.java

@@ -19,6 +19,7 @@
 
 import org.jetbrains.annotations.*;
 import org.jitsi.impl.protocol.xmpp.*;
+import org.jitsi.utils.*;
 import org.jitsi.xmpp.extensions.colibri.*;
 import org.jitsi.xmpp.extensions.jingle.*;
 
@@ -97,6 +98,11 @@ public static String getEndpointId(ChatRoomMember chatRoomMember)
      */
     private List<String> supportedFeatures = new ArrayList<>();
 
+    /**
+     * State whether this participant was
+     */
+    private Map<MediaType, Boolean> initialAVModerationApplied = new HashMap<>();
+
     /**
      * Creates new {@link Participant} for given chat room member.
      *
@@ -498,6 +504,26 @@ JitsiMeetConferenceImpl.BridgeSession terminateBridgeSession()
         return _session;
     }
 
+    /**
+     * Changes the value for the supplied media type.
+     * @param mediaType the media type to change.
+     */
+    public void setInitialAVModerationApplied(MediaType mediaType)
+    {
+        this.initialAVModerationApplied.put(mediaType, true);
+    }
+
+    /**
+     * Checks whether the initial moderation is applied.
+     * @param mediaType the media type to check.
+     * @return tru if it was applied.
+     */
+    public boolean isInitialAVModerationApplied(MediaType mediaType)
+    {
+        Boolean value = this.initialAVModerationApplied.get(mediaType);
+        return value != null && value;
+    }
+
     @Override
     public String toString()
     {

src/main/java/org/jitsi/jicofo/ParticipantChannelAllocator.java

@@ -21,11 +21,11 @@
 import org.jitsi.jicofo.codec.*;
 import org.jitsi.jicofo.xmpp.*;
 import org.jitsi.protocol.xmpp.colibri.exception.*;
+import org.jitsi.utils.*;
 import org.jitsi.xmpp.extensions.colibri.*;
 import org.jitsi.xmpp.extensions.jingle.*;
 import org.jitsi.xmpp.extensions.jingle.JingleUtils;
 import org.jitsi.xmpp.extensions.jitsimeet.*;
-import org.jitsi.jicofo.discovery.*;
 import org.jitsi.protocol.xmpp.*;
 import org.jitsi.protocol.xmpp.util.*;
 import org.jitsi.utils.logging2.*;
@@ -166,6 +166,17 @@ else if (reInvite)
                     participant.getSourcesCopy(),
                     participant.getSourceGroupsCopy());
         }
+
+        // if participant is not av moderated but we need to let's do it
+        if (meetConference.getChatRoom().isAvModerationEnabled(MediaType.AUDIO))
+        {
+            meetConference.muteParticipant(participant, MediaType.AUDIO);
+        }
+
+        if (meetConference.getChatRoom().isAvModerationEnabled(MediaType.VIDEO))
+        {
+            meetConference.muteParticipant(participant, MediaType.VIDEO);
+        }
     }
 
     /**

src/main/kotlin/org/jitsi/jicofo/xmpp/Smack.kt

@@ -31,6 +31,7 @@ import org.jitsi.xmpp.extensions.jingle.JingleIQProvider
 import org.jitsi.xmpp.extensions.jitsimeet.BridgeSessionPacketExtension
 import org.jitsi.xmpp.extensions.jitsimeet.ConferenceIqProvider
 import org.jitsi.xmpp.extensions.jitsimeet.IceStatePacketExtension
+import org.jitsi.xmpp.extensions.jitsimeet.JsonMessageExtension
 import org.jitsi.xmpp.extensions.jitsimeet.LoginUrlIqProvider
 import org.jitsi.xmpp.extensions.jitsimeet.LogoutIqProvider
 import org.jitsi.xmpp.extensions.jitsimeet.RegionPacketExtension
@@ -120,5 +121,10 @@ fun registerXmppExtensions() {
         JingleIQ.NAMESPACE,
         JingleIQProvider()
     )
+    ProviderManager.addExtensionProvider(
+        JsonMessageExtension.ELEMENT_NAME,
+        JsonMessageExtension.NAMESPACE,
+        DefaultPacketExtensionProvider(JsonMessageExtension::class.java)
+    )
     RayoIqProvider().registerRayoIQs()
 }