feat(remote-menu):option for disable mute and kick

config.js

     //    downloadAppsUrl: 'https://docs.example.com/our-apps.html'
     // },
 
+    // Options related to the remote participant menu.
+    // remoteVideoMenu: {
+    //     // If set to true the 'Kick out' button will be disabled.
+    //     disableKick: true
+    // },
+
+    // If set to true all muting operations of remote participants will be disabled.
+    // disableRemoteMute: true,
+
     // List of undocumented settings used in jitsi-meet
     /**
      _immediateReloadThreshold

react/features/base/config/configWhitelist.js

     'disableLocalVideoFlip',
     'disableNS',
     'disableRemoteControl',
+    'disableRemoteMute',
     'disableRtx',
     'disableSuspendVideo',
     'disableThirdPartyRequests',
     'pcStatsInterval',
     'preferH264',
     'requireDisplayName',
+    'remoteVideoMenu',
     'resolution',
     'startAudioMuted',
     'startAudioOnly',

react/features/base/config/reducer.js

     p2p: {
         disableH264: false,
         preferH264: true
-    }
+    },
+
+    remoteVideoMenu: {}
 };
 
 ReducerRegistry.register('features/base/config', (state = _getInitialState(), action) => {

react/features/remote-video-menu/components/native/RemoteVideoMenu.js

      */
     _bottomSheetStyles: StyleType,
 
+    /**
+     * Whether or not to display the kick button.
+     */
+    _disableKick: boolean,
+
+    /**
+     * Whether or not to display the remote mute buttons.
+     */
+    _disableRemoteMute: boolean,
+
     /**
      * True if the menu is currently open, false otherwise.
      */
      * @inheritdoc
      */
     render() {
-        const { participant } = this.props;
+        const { _disableKick, _disableRemoteMute, participant } = this.props;
         const buttonProps = {
             afterClick: this._onCancel,
             showLabel: true,
             styles: this.props._bottomSheetStyles.buttons
         };
 
+        const buttons = [];
+
+        if (!_disableRemoteMute) {
+            buttons.push(<MuteButton { ...buttonProps } />);
+        }
+
+        if (!_disableKick) {
+            buttons.push(<KickButton { ...buttonProps } />);
+        }
+
+        buttons.push(<PinButton { ...buttonProps } />);
+        buttons.push(<PrivateMessageButton { ...buttonProps } />);
+
         return (
             <BottomSheet onCancel = { this._onCancel }>
                 <View style = { styles.participantNameContainer }>
                         { this.props._participantDisplayName }
                     </Text>
                 </View>
-                <MuteButton { ...buttonProps } />
-                <KickButton { ...buttonProps } />
-                <PinButton { ...buttonProps } />
-                <PrivateMessageButton { ...buttonProps } />
+                { buttons }
             </BottomSheet>
         );
     }
  */
 function _mapStateToProps(state, ownProps) {
     const { participant } = ownProps;
+    const { remoteVideoMenu = {}, disableRemoteMute } = state['features/base/config'];
+    const { disableKick } = remoteVideoMenu;
 
     return {
-        _bottomSheetStyles:
-            ColorSchemeRegistry.get(state, 'BottomSheet'),
+        _bottomSheetStyles: ColorSchemeRegistry.get(state, 'BottomSheet'),
+        _disableKick: Boolean(disableKick),
+        _disableRemoteMute: Boolean(disableRemoteMute),
         _isOpen: isDialogOpen(state, RemoteVideoMenu_),
-        _participantDisplayName: getParticipantDisplayName(
-            state, participant.id)
+        _participantDisplayName: getParticipantDisplayName(state, participant.id)
     };
 }
 

react/features/remote-video-menu/components/web/RemoteVideoMenuTriggerButton.js

  */
 type Props = {
 
+    /**
+     * Whether or not to display the kick button.
+     */
+    _disableKick: boolean,
+
+    /**
+     * Whether or not to display the remote mute buttons.
+     */
+    _disableRemoteMute: Boolean,
+
     /**
      * Whether or not the participant is a conference moderator.
      */
      */
     _renderRemoteVideoMenu() {
         const {
+            _disableKick,
+            _disableRemoteMute,
             _isModerator,
             initialVolumeValue,
             isAudioMuted,
         const buttons = [];
 
         if (_isModerator) {
-            buttons.push(
-                <MuteButton
-                    isAudioMuted = { isAudioMuted }
-                    key = 'mute'
-                    participantID = { participantID } />
-            );
-            buttons.push(
-                <MuteEveryoneElseButton
-                    key = 'mute-others'
-                    participantID = { participantID } />
-            );
-            buttons.push(
-                <KickButton
-                    key = 'kick'
-                    participantID = { participantID } />
-            );
+            if (!_disableRemoteMute) {
+                buttons.push(
+                    <MuteButton
+                        isAudioMuted = { isAudioMuted }
+                        key = 'mute'
+                        participantID = { participantID } />
+                );
+                buttons.push(
+                    <MuteEveryoneElseButton
+                        key = 'mute-others'
+                        participantID = { participantID } />
+                );
+            }
+
+            if (!_disableKick) {
+                buttons.push(
+                    <KickButton
+                        key = 'kick'
+                        participantID = { participantID } />
+                );
+            }
         }
 
         if (remoteControlState) {
  */
 function _mapStateToProps(state) {
     const participant = getLocalParticipant(state);
+    const { remoteVideoMenu = {}, disableRemoteMute } = state['features/base/config'];
+    const { disableKick } = remoteVideoMenu;
 
     return {
-        _isModerator: Boolean(participant?.role === PARTICIPANT_ROLE.MODERATOR)
+        _isModerator: Boolean(participant?.role === PARTICIPANT_ROLE.MODERATOR),
+        _disableKick: Boolean(disableKick),
+        _disableRemoteMute: Boolean(disableRemoteMute)
     };
 }
 

react/features/toolbox/components/web/MuteEveryoneButton.js

     const localParticipant = getLocalParticipant(state);
     const isModerator = localParticipant.role === PARTICIPANT_ROLE.MODERATOR;
     const { visible } = ownProps;
+    const { disableRemoteMute } = state['features/base/config'];
 
     return {
         isModerator,
         localParticipantId: localParticipant.id,
-        visible: visible && isModerator
+        visible: visible && isModerator && !disableRemoteMute
     };
 }