feat(audio-recording): Handles conference properties sent from jicofo and play notification.

When audio-recording is enabled server-side play the recording audio and visual notification.

conference.js

     conferenceJoinInProgress,
     conferenceJoined,
     conferenceLeft,
+    conferencePropertiesChanged,
     conferenceSubjectChanged,
     conferenceTimestampChanged,
     conferenceUniqueIdSet,
             JitsiConferenceEvents.LOCK_STATE_CHANGED,
             (...args) => APP.store.dispatch(lockStateChanged(room, ...args)));
 
+        room.on(
+            JitsiConferenceEvents.PROPERTIES_CHANGED,
+            properties => APP.store.dispatch(conferencePropertiesChanged(properties)));
+
         room.on(JitsiConferenceEvents.KICKED, (participant, reason, isReplaced) => {
             if (isReplaced) {
                 // this event triggers when the local participant is kicked, `participant`

react/features/base/conference/actionTypes.ts

  */
  export const CONFERENCE_LOCAL_SUBJECT_CHANGED = 'CONFERENCE_LOCAL_SUBJECT_CHANGED';
 
+/**
+ * The type of (redux) action, which indicates conference properties change.
+ *
+ * {
+ *     type: CONFERENCE_PROPERTIES_CHANGED
+ *     properties: {
+*           audio-recording-enabled: boolean,
+ *          visitor-count: number
+ *     }
+ * }
+ */
+ export const CONFERENCE_PROPERTIES_CHANGED = 'CONFERENCE_PROPERTIES_CHANGED';
+
  /**
  * The type of (redux) action, which indicates conference subject changes.
  *

react/features/base/conference/actions.any.ts

     CONFERENCE_JOIN_IN_PROGRESS,
     CONFERENCE_LEFT,
     CONFERENCE_LOCAL_SUBJECT_CHANGED,
+    CONFERENCE_PROPERTIES_CHANGED,
     CONFERENCE_SUBJECT_CHANGED,
     CONFERENCE_TIMESTAMP_CHANGED,
     CONFERENCE_UNIQUE_ID_SET,
         JitsiConferenceEvents.LOCK_STATE_CHANGED,
         (locked: boolean) => dispatch(lockStateChanged(conference, locked)));
 
+    conference.on(
+        JitsiConferenceEvents.PROPERTIES_CHANGED,
+        (properties: Object) => dispatch(conferencePropertiesChanged(properties)));
+
     // Dispatches into features/base/media follow:
 
     conference.on(
     };
 }
 
+/**
+ * Signals that the conference properties have been changed.
+ *
+ * @param {Object} properties - The new properties set.
+ * @returns {{
+ *     type: CONFERENCE_PROPERTIES_CHANGED,
+ *     properties: Object
+ * }}
+ */
+export function conferencePropertiesChanged(properties: object) {
+    return {
+        type: CONFERENCE_PROPERTIES_CHANGED,
+        properties
+    };
+}
+
+
 /**
  * Signals that the conference subject has been changed.
  *

react/features/base/conference/functions.ts

     return conference.isP2PActive();
 }
 
+/**
+ * Returns whether the current conference has audio recording property which is on.
+ *
+ * @param {IStateful} stateful - The redux store, state, or {@code getState} function.
+ * @returns {boolean|null}
+ */
+export function isConferenceAudioRecordingOn(stateful: IStateful): boolean | null {
+    const state = getConferenceState(toState(stateful));
+
+    // @ts-ignore
+    return state.properties?.['audio-recording-enabled'] === 'true';
+}
+
 /**
  * Returns the stored room name.
  *

react/features/base/conference/reducer.ts

 import { CONNECTION_WILL_CONNECT, SET_LOCATION_URL } from '../connection/actionTypes';
 import { JitsiConferenceErrors } from '../lib-jitsi-meet';
 import ReducerRegistry from '../redux/ReducerRegistry';
-import { assign, set } from '../redux/functions';
+import { assign, equals, set } from '../redux/functions';
 
 import {
     AUTH_STATUS_CHANGED,
     CONFERENCE_JOINED,
     CONFERENCE_LEFT,
     CONFERENCE_LOCAL_SUBJECT_CHANGED,
+    CONFERENCE_PROPERTIES_CHANGED,
     CONFERENCE_SUBJECT_CHANGED,
     CONFERENCE_TIMESTAMP_CHANGED,
     CONFERENCE_WILL_JOIN,
     membersOnly: undefined,
     metadata: undefined,
     password: undefined,
-    passwordRequired: undefined
+    passwordRequired: undefined,
+    properties: undefined
 };
 
 export interface IConferenceMetadata {
     password?: string;
     passwordRequired?: IJitsiConference;
     pendingSubjectChange?: string;
+    properties?: object;
     room?: string;
     startAudioMutedPolicy?: boolean;
     startReactionsMuted?: boolean;
         case CONFERENCE_LOCAL_SUBJECT_CHANGED:
             return set(state, 'localSubject', action.localSubject);
 
+        case CONFERENCE_PROPERTIES_CHANGED:
+            return _conferencePropertiesChanged(state, action);
+
         case CONFERENCE_TIMESTAMP_CHANGED:
             return set(state, 'conferenceTimestamp', action.conferenceTimestamp);
 
     return nextState;
 }
 
+/**
+ * Reduces a specific Redux action CONFERENCE_PROPERTIES_CHANGED of the feature
+ * base/conference.
+ *
+ * @param {Object} state - The Redux state of the feature base/conference.
+ * @param {Action} action - The Redux action CONFERENCE_PROPERTIES_CHANGED to reduce.
+ * @private
+ * @returns {Object} The new state of the feature base/conference after the
+ * reduction of the specified action.
+ */
+function _conferencePropertiesChanged(state: IConferenceState, { properties }: { properties: Object; }) {
+    if (!equals(state.properties, properties)) {
+        return assign(state, {
+            properties
+        });
+    }
+
+    return state;
+}
+
 /**
  * Reduces a specific Redux action CONFERENCE_WILL_JOIN of the feature
  * base/conference.

react/features/transcribing/subscriber.ts

 import { batch } from 'react-redux';
 
 import { IStore } from '../app/types';
+import { isConferenceAudioRecordingOn } from '../base/conference/functions';
 import { JitsiRecordingConstants } from '../base/lib-jitsi-meet';
 import StateListenerRegistry from '../base/redux/StateListenerRegistry';
 import { playSound } from '../base/sounds/actions';
     }
 );
 
+/**
+ * Listens for audio-recording-enabled conference property change.
+ */
+StateListenerRegistry.register(
+    /* selector */ isConferenceAudioRecordingOn,
+    /* listener */ (audioRecordingOn, { getState, dispatch }) => {
+        maybeEmitRecordingNotification(dispatch, getState, audioRecordingOn);
+    }
+);
+
 /**
  * Emit a recording started / stopped notification if the transcription started / stopped. Only
  * if there is no recording in progress.

react/features/visitors/actionTypes.ts

-/**
- * The type of (redux) action to update visitors count.
- *
- * {
- *     type: UPDATE_VISITORS_COUNT,
- *     count: number
- * }
- */
-export const UPDATE_VISITORS_COUNT = 'UPDATE_VISITORS_COUNT';
-
 /**
  * The type of (redux) action to update visitors in queue count.
  *

react/features/visitors/actions.ts

     SET_IN_VISITORS_QUEUE,
     SET_VISITORS_SUPPORTED,
     SET_VISITOR_DEMOTE_ACTOR,
-    UPDATE_VISITORS_COUNT,
     UPDATE_VISITORS_IN_QUEUE_COUNT,
     VISITOR_PROMOTION_REQUEST
 } from './actionTypes';
     };
 }
 
-/**
- * Visitors count has been updated.
- *
- * @param {number} count - The new visitors count.
- * @returns {{
- *     type: UPDATE_VISITORS_COUNT,
- * }}
- */
-export function updateVisitorsCount(count: number) {
-    return {
-        type: UPDATE_VISITORS_COUNT,
-        count
-    };
-}
-
 /**
  * Visitors in queue count has been updated.
  *

react/features/visitors/middleware.ts

 import { IStateful } from '../base/app/types';
 import {
     CONFERENCE_JOINED,
-    CONFERENCE_JOIN_IN_PROGRESS,
     ENDPOINT_MESSAGE_RECEIVED,
     UPDATE_CONFERENCE_METADATA
 } from '../base/conference/actionTypes';
     setInVisitorsQueue,
     setVisitorDemoteActor,
     setVisitorsSupported,
-    updateVisitorsCount,
     updateVisitorsInQueueCount
 } from './actions';
 import { JoinMeetingDialog } from './components';
-import { getPromotionRequests, getVisitorsCount, getVisitorsInQueueCount } from './functions';
+import { getPromotionRequests, getVisitorsInQueueCount } from './functions';
 import logger from './logger';
 import { WebsocketClient } from './websocket-client';
 
 MiddlewareRegistry.register(({ dispatch, getState }) => next => action => {
     switch (action.type) {
-    case CONFERENCE_JOIN_IN_PROGRESS: {
-        const { conference } = action;
-
-        conference.on(JitsiConferenceEvents.PROPERTIES_CHANGED, (properties: { 'visitor-count': number; }) => {
-            const visitorCount = Number(properties?.['visitor-count']);
-
-            if (!isNaN(visitorCount) && getVisitorsCount(getState) !== visitorCount) {
-                dispatch(updateVisitorsCount(visitorCount));
-            }
-        });
-        break;
-    }
     case CONFERENCE_JOINED: {
         const { conference } = action;
 

react/features/visitors/reducer.ts

-import { CONFERENCE_WILL_LEAVE } from '../base/conference/actionTypes';
+import { CONFERENCE_PROPERTIES_CHANGED, CONFERENCE_WILL_LEAVE } from '../base/conference/actionTypes';
 import ReducerRegistry from '../base/redux/ReducerRegistry';
 
 import {
     SET_IN_VISITORS_QUEUE,
     SET_VISITORS_SUPPORTED,
     SET_VISITOR_DEMOTE_ACTOR,
-    UPDATE_VISITORS_COUNT,
     UPDATE_VISITORS_IN_QUEUE_COUNT,
     VISITOR_PROMOTION_REQUEST
 } from './actionTypes';
 }
 ReducerRegistry.register<IVisitorsState>('features/visitors', (state = DEFAULT_STATE, action): IVisitorsState => {
     switch (action.type) {
+    case CONFERENCE_PROPERTIES_CHANGED: {
+        const visitorCount = Number(action.properties?.['visitor-count']);
+
+        if (!isNaN(visitorCount) && state.count !== visitorCount) {
+            return {
+                ...state,
+                count: visitorCount
+            };
+        }
+
+        break;
+    }
     case CONFERENCE_WILL_LEAVE: {
         return {
             ...state,
             iAmVisitor: action.isRedirect ? state.iAmVisitor : DEFAULT_STATE.iAmVisitor
         };
     }
-    case UPDATE_VISITORS_COUNT: {
-        if (state.count === action.count) {
-            return state;
-        }
-
-        return {
-            ...state,
-            count: action.count
-        };
-    }
     case UPDATE_VISITORS_IN_QUEUE_COUNT: {
         if (state.count === action.count) {
             return state;