feat(visitors): Hide reactions.

react/features/reactions/components/web/RaiseHandContainerButtons.tsx

 import { IReduxState } from '../../../app/types';
 import { isMobileBrowser } from '../../../base/environment/utils';
 import { IProps as AbstractButtonProps } from '../../../base/toolbox/components/AbstractButton';
-import { isReactionsButtonEnabled, isReactionsEnabled } from '../../functions.web';
+import { isReactionsButtonEnabled, shouldDisplayReactionsButtons } from '../../functions.web';
 
 import RaiseHandButton from './RaiseHandButton';
 import ReactionsMenuButton from './ReactionsMenuButton';
 
 const RaiseHandContainerButton = (props: AbstractButtonProps) => {
     const reactionsButtonEnabled = useSelector(isReactionsButtonEnabled);
-    const reactionsEnabled = useSelector(isReactionsEnabled);
+    const _shouldDisplayReactionsButtons = useSelector(shouldDisplayReactionsButtons);
     const isNarrowLayout = useSelector((state: IReduxState) => state['features/base/responsive-ui'].isNarrowLayout);
     const showReactionsAsPartOfRaiseHand
-        = !reactionsButtonEnabled && reactionsEnabled && !isNarrowLayout && !isMobileBrowser();
+        = _shouldDisplayReactionsButtons && !reactionsButtonEnabled && !isNarrowLayout && !isMobileBrowser();
 
     return showReactionsAsPartOfRaiseHand
         ? <ReactionsMenuButton

react/features/reactions/components/web/ReactionsMenuButton.tsx

 import ToolboxButtonWithPopup from '../../../base/toolbox/components/web/ToolboxButtonWithPopup';
 import { toggleReactionsMenuVisibility } from '../../actions.web';
 import { IReactionEmojiProps } from '../../constants';
-import { getReactionsQueue, isReactionsEnabled } from '../../functions.any';
+import { getReactionsQueue } from '../../functions.any';
 import { getReactionsMenuVisibility, isReactionsButtonEnabled } from '../../functions.web';
 import { IReactionsMenuParent } from '../../types';
 
      */
     _reactionsButtonEnabled: boolean;
 
-    /**
-     * Whether or not the reactions are enabled.
-     */
-    _reactionsEnabled: boolean;
-
     /**
      * The button's key.
      */
  */
 function ReactionsMenuButton({
     _reactionsButtonEnabled,
-    _reactionsEnabled,
     _isMobile,
     buttonKey,
     dispatch,
         isOpen && toggleReactionsMenu();
     }, [ isOpen, toggleReactionsMenu ]);
 
-    if (!showRaiseHand && (!_reactionsButtonEnabled || !_reactionsEnabled)) {
+    if (!showRaiseHand && !_reactionsButtonEnabled) {
         return null;
     }
 
 
     return {
         _reactionsButtonEnabled: isReactionsButtonEnabled(state),
-        _reactionsEnabled: isReactionsEnabled(state),
         _isMobile: isMobileBrowser(),
         isOpen: getReactionsMenuVisibility(state),
         isNarrow: isNarrowLayout,

react/features/reactions/functions.any.ts

 import { getFeatureFlag } from '../base/flags/functions';
 import { getLocalParticipant } from '../base/participants/functions';
 import { extractFqnFromPath } from '../dynamic-branding/functions.any';
+import { iAmVisitor } from '../visitors/functions';
 
 import { IReactionEmojiProps, REACTIONS, ReactionThreshold, SOUNDS_THRESHOLDS } from './constants';
 import logger from './logger';
 
     return !disableReactions;
 }
+
+/**
+ * Returns true if the reactions buttons should be displayed anywhere on the page and false otherwise.
+ *
+ * @param {IReduxState} state - The redux state.
+ * @returns {boolean}
+ */
+export function shouldDisplayReactionsButtons(state: IReduxState): boolean {
+    return isReactionsEnabled(state) && !iAmVisitor(state);
+}

react/features/reactions/functions.web.ts

 import { IReduxState } from '../app/types';
 import { getToolbarButtons } from '../base/config/functions.web';
 
-import { isReactionsEnabled } from './functions.any';
+import { shouldDisplayReactionsButtons } from './functions.any';
 
 export * from './functions.any';
 
  * @returns {boolean}
  */
 export function isReactionsButtonEnabled(state: IReduxState) {
-    return Boolean(getToolbarButtons(state).includes('reactions')) && isReactionsEnabled(state);
+    return Boolean(getToolbarButtons(state).includes('reactions')) && shouldDisplayReactionsButtons(state);
 }

react/features/settings/functions.any.ts

         soundsTalkWhileMuted,
         soundsReactions
     } = state['features/base/settings'];
+
     const enableReactions = isReactionsEnabled(state);
     const moderatorMutedSoundsReactions = state['features/base/conference'].startReactionsMuted ?? false;
     const enabledNotifications = getNotificationsMap(stateful);

react/features/toolbox/components/native/OverflowMenu.tsx

     from '../../../breakout-rooms/components/native/BreakoutRoomsButton';
 import SharedDocumentButton from '../../../etherpad/components/SharedDocumentButton.native';
 import ReactionMenu from '../../../reactions/components/native/ReactionMenu';
-import { isReactionsEnabled } from '../../../reactions/functions.any';
+import { shouldDisplayReactionsButtons } from '../../../reactions/functions.any';
 import LiveStreamButton from '../../../recording/components/LiveStream/native/LiveStreamButton';
 import RecordButton from '../../../recording/components/Recording/native/RecordButton';
 import SecurityDialogButton
      */
     _isSpeakerStatsDisabled?: boolean;
 
-    /**
-     * Whether or not the reactions feature is enabled.
-     */
-    _reactionsEnabled: boolean;
-
     /**
      * Whether the recoding button should be enabled or not.
-     */
-    _recordingEnabled: boolean;
+    */
+   _recordingEnabled: boolean;
+
+   /**
+    * Whether or not any reactions buttons should be displayed.
+    */
+   _shouldDisplayReactionsButtons: boolean;
 
     /**
      * The width of the screen.
         const {
             _isBreakoutRoomsSupported,
             _isSpeakerStatsDisabled,
-            _reactionsEnabled,
+            _shouldDisplayReactionsButtons,
             _width,
             dispatch
         } = this.props;
 
         return (
             <BottomSheet
-                renderFooter = { _reactionsEnabled && !toolbarButtons.has('raisehand')
+                renderFooter = { _shouldDisplayReactionsButtons && !toolbarButtons.has('raisehand')
                     ? this._renderReactionMenu
                     : undefined }>
                 <OpenCarmodeButton { ...topButtonProps } />
                 <AudioOnlyButton { ...buttonProps } />
-                {!_reactionsEnabled && !toolbarButtons.has('raisehand') && <RaiseHandButton { ...buttonProps } />}
+                {
+                    !_shouldDisplayReactionsButtons && !toolbarButtons.has('raisehand')
+                        && <RaiseHandButton { ...buttonProps } />
+                }
                 {/* @ts-ignore */}
                 <Divider style = { styles.divider as ViewStyle } />
                 <SecurityDialogButton { ...buttonProps } />
     return {
         _isBreakoutRoomsSupported: conference?.getBreakoutRooms()?.isSupported(),
         _isSpeakerStatsDisabled: isSpeakerStatsDisabled(state),
-        _reactionsEnabled: isReactionsEnabled(state),
+        _shouldDisplayReactionsButtons: shouldDisplayReactionsButtons(state),
         _width: state['features/base/responsive-ui'].clientWidth
     };
 }

react/features/toolbox/components/native/Toolbox.tsx

 import Platform from '../../../base/react/Platform.native';
 import ChatButton from '../../../chat/components/native/ChatButton';
 import ReactionsMenuButton from '../../../reactions/components/native/ReactionsMenuButton';
-import { isReactionsEnabled } from '../../../reactions/functions.any';
+import { shouldDisplayReactionsButtons } from '../../../reactions/functions.any';
 import TileViewButton from '../../../video-layout/components/TileViewButton';
 import { iAmVisitor } from '../../../visitors/functions';
 import { getMovableButtons, isToolboxVisible } from '../../functions.native';
     _iAmVisitor: boolean;
 
     /**
-     * Whether or not the reactions feature is enabled.
+     * Whether or not any reactions buttons should be visible.
      */
-    _reactionsEnabled: boolean;
+    _shouldDisplayReactionsButtons: boolean;
 
     /**
      * The color-schemed stylesheet of the feature.
  * @returns {React$Element}.
  */
 function Toolbox(props: IProps) {
-    const { _endConferenceSupported, _reactionsEnabled, _styles, _visible, _iAmVisitor, _width } = props;
+    const { _endConferenceSupported, _shouldDisplayReactionsButtons, _styles, _visible, _iAmVisitor, _width } = props;
 
     if (!_visible) {
         return null;
                 }
                 {!_iAmVisitor && additionalButtons.has('screensharing')
                     && <ScreenSharingButton styles = { buttonStylesBorderless } />}
-                {additionalButtons.has('raisehand') && (_reactionsEnabled && !_iAmVisitor
+                {additionalButtons.has('raisehand') && (_shouldDisplayReactionsButtons
                     ? <ReactionsMenuButton
                         styles = { buttonStylesBorderless }
                         toggledStyles = { backgroundToggledStyle } />
         _visible: isToolboxVisible(state),
         _iAmVisitor: iAmVisitor(state),
         _width: state['features/base/responsive-ui'].clientWidth,
-        _reactionsEnabled: isReactionsEnabled(state)
+        _shouldDisplayReactionsButtons: shouldDisplayReactionsButtons(state)
     };
 }
 

react/features/toolbox/components/web/Toolbox.tsx

 import { translate } from '../../../base/i18n/functions';
 import { isLocalParticipantModerator } from '../../../base/participants/functions';
 import ContextMenu from '../../../base/ui/components/web/ContextMenu';
-import { isReactionsButtonEnabled, isReactionsEnabled } from '../../../reactions/functions.web';
+import { isReactionsButtonEnabled, shouldDisplayReactionsButtons } from '../../../reactions/functions.web';
 import { iAmVisitor } from '../../../visitors/functions';
 import {
     setHangupMenuVisible,
     _reactionsButtonEnabled: boolean;
 
     /**
-     * Whether or not reactions feature is enabled.
+     * Whether the toolbox should be shifted up or not.
      */
-    _reactionsEnabled: boolean;
+    _shiftUp: boolean;
 
     /**
-     * Whether the toolbox should be shifted up or not.
+     * Whether any reactions buttons should be displayed or not.
      */
-    _shiftUp: boolean;
+    _shouldDisplayReactionsButtons: boolean;
 
     /**
      * The enabled buttons.
     _overflowDrawer,
     _overflowMenuVisible,
     _reactionsButtonEnabled,
-    _reactionsEnabled,
     _shiftUp,
+    _shouldDisplayReactionsButtons,
     _toolbarButtons,
     _visible,
     dispatch,
 
         const { mainMenuButtons, overflowMenuButtons } = getVisibleButtons();
         const raiseHandInOverflowMenu = overflowMenuButtons.some(({ key }) => key === 'raisehand');
-        const showReactionsInOverflowMenu
-            = (_reactionsEnabled && !_reactionsButtonEnabled
-                && (raiseHandInOverflowMenu || _isNarrowLayout || _isMobile))
-            || overflowMenuButtons.some(({ key }) => key === 'reactions');
+        const showReactionsInOverflowMenu = _shouldDisplayReactionsButtons
+            && (
+                (!_reactionsButtonEnabled && (raiseHandInOverflowMenu || _isNarrowLayout || _isMobile))
+                    || overflowMenuButtons.some(({ key }) => key === 'reactions')
+            );
         const showRaiseHandInReactionsMenu = showReactionsInOverflowMenu && raiseHandInOverflowMenu;
 
         return (
     } = state['features/toolbox'];
     const { clientWidth } = state['features/base/responsive-ui'];
     let toolbarButtons = ownProps.toolbarButtons || getToolbarButtons(state);
-    const _reactionsEnabled = isReactionsEnabled(state);
 
     if (iAmVisitor(state)) {
         toolbarButtons = VISITORS_MODE_BUTTONS.filter(e => toolbarButtons.indexOf(e) > -1);
         _overflowMenuVisible: overflowMenuVisible,
         _overflowDrawer: overflowDrawer,
         _reactionsButtonEnabled: isReactionsButtonEnabled(state),
-        _reactionsEnabled,
         _shiftUp: state['features/toolbox'].shiftUp,
+        _shouldDisplayReactionsButtons: shouldDisplayReactionsButtons(state),
         _toolbarButtons: toolbarButtons,
         _visible: isToolboxVisible(state)
     };

react/features/toolbox/hooks.web.ts

 import { addReactionToBuffer } from '../reactions/actions.any';
 import { toggleReactionsMenuVisibility } from '../reactions/actions.web';
 import { REACTIONS } from '../reactions/constants';
-import { isReactionsEnabled } from '../reactions/functions.any';
+import { shouldDisplayReactionsButtons } from '../reactions/functions.any';
 import { startScreenShareFlow } from '../screen-share/actions.web';
 import { isScreenVideoShared } from '../screen-share/functions';
 import SpeakerStats from '../speaker-stats/components/web/SpeakerStats';
 export const useKeyboardShortcuts = (toolbarButtons: Array<string>) => {
     const dispatch = useDispatch();
     const _isSpeakerStatsDisabled = useSelector(isSpeakerStatsDisabled);
+    const _shouldDisplayReactionsButtons = useSelector(shouldDisplayReactionsButtons);
     const _toolbarButtons = useSelector((state: IReduxState) => toolbarButtons || getToolbarButtons(state));
     const chatOpen = useSelector((state: IReduxState) => state['features/chat'].isOpen);
     const desktopSharingButtonDisabled = useSelector(isDesktopShareButtonDisabled);
     const gifsEnabled = useSelector(isGifEnabled);
     const participantsPaneOpen = useSelector(getParticipantsPaneOpen);
     const raisedHand = useSelector((state: IReduxState) => hasRaisedHand(getLocalParticipant(state)));
-    const reactionsEnabled = useSelector(isReactionsEnabled);
     const screenSharing = useSelector(isScreenVideoShared);
     const tileViewEnabled = useSelector(shouldDisplayTileView);
 
             }
         });
 
-        if (reactionsEnabled) {
+        // If the buttons for sending reactions are not displayed we should disable the shortcuts too.
+        if (_shouldDisplayReactionsButtons) {
             const REACTION_SHORTCUTS = Object.keys(REACTIONS).map(key => {
                 const onShortcutSendReaction = () => {
                     dispatch(addReactionToBuffer(key));
             [ 'A', 'C', 'D', 'P', 'R', 'S', 'W', 'T', 'G' ].forEach(letter =>
                 dispatch(unregisterShortcut(letter)));
 
-            if (reactionsEnabled) {
+            if (_shouldDisplayReactionsButtons) {
                 Object.keys(REACTIONS).map(key => REACTIONS[key].shortcutChar)
                     .forEach(letter =>
                         dispatch(unregisterShortcut(letter, true)));
             }
         };
     }, [
+        _shouldDisplayReactionsButtons,
         chatOpen,
         desktopSharingButtonDisabled,
         desktopSharingEnabled,

resources/prosody-plugins/mod_measure_message_count.lua

     local occupant, room = event.occupant, event.room;
     local session = event.origin;
 
-    if session.jitsi_meet_tenant_mismatch then
+    if session and session.jitsi_meet_tenant_mismatch then
         room.jitsi_meet_tenant_mismatch = true;
     end
 end);