snapshot of https://github.com/jitsi/jitsi-meet.git @ fd1749dd28f4138aa80234fc7f311b19aaffa0e7 (2026-09-15)

react/features/recording/reducer.ts

@@ -0,0 +1,209 @@
+import ReducerRegistry from '../base/redux/ReducerRegistry';
+
+import {
+    CLEAR_RECORDING_SESSIONS,
+    MARK_CONSENT_REQUESTED,
+    RECORDING_SESSION_UPDATED,
+    SET_LOCAL_RECORDING_RUNNING,
+    SET_MEETING_HIGHLIGHT_BUTTON_STATE,
+    SET_PENDING_RECORDING_NOTIFICATION_UID,
+    SET_SELECTED_RECORDING_SERVICE,
+    SET_START_RECORDING_INTENT,
+    SET_START_RECORDING_NOTIFICATION_SHOWN,
+    SET_STOP_RECORDING_INTENT,
+    SET_STREAM_KEY
+} from './actionTypes';
+
+const DEFAULT_STATE = {
+    consentRequested: new Set(),
+    disableHighlightMeetingMoment: false,
+    pendingNotificationUids: {},
+    selectedRecordingService: '',
+    sessionDatas: []
+};
+
+export interface ISessionData {
+    error?: Error;
+    id?: string;
+    initiator?: { getId: Function; };
+    liveStreamViewURL?: string;
+    mode?: string;
+    status?: string;
+    terminator?: { getId: Function; };
+    timestamp?: number;
+}
+
+/**
+ * Tracks the user's intent when starting recording with or without transcription.
+ * Set synchronously before any async operations begin to coordinate sound/notification timing.
+ */
+export interface IStartRecordingIntent {
+    recording: boolean;
+    transcription: boolean;
+}
+
+/**
+ * Tracks what is being stopped (recording and/or transcription). Mirrors
+ * IStartRecordingIntent. Used by maybeNotifyRecordingStop to coordinate the
+ * off-sound/notification across the recording and transcription stop events.
+ */
+export interface IStopRecordingIntent {
+    recording: boolean;
+    transcription: boolean;
+}
+
+export interface IRecordingState {
+    consentRequested: Set<any>;
+    disableHighlightMeetingMoment: boolean;
+    localRecordingRunning?: boolean;
+    pendingNotificationUids: {
+        [key: string]: string | undefined;
+    };
+    selectedRecordingService: string;
+    sessionDatas: Array<ISessionData>;
+    startRecordingIntent?: IStartRecordingIntent | null;
+    stopRecordingIntent?: IStopRecordingIntent | null;
+    streamKey?: string;
+    wasStartRecordingSuggested?: boolean;
+}
+
+/**
+ * Props for the RecordingConsentDialog component.
+ */
+export interface IRecordingConsentDialogProps {
+    audioWasMuted?: boolean;
+    videoWasMuted?: boolean;
+}
+
+/**
+ * The name of the Redux store this feature stores its state in.
+ */
+const STORE_NAME = 'features/recording';
+
+/**
+ * Reduces the Redux actions of the feature features/recording.
+ */
+ReducerRegistry.register<IRecordingState>(STORE_NAME,
+    (state = DEFAULT_STATE, action): IRecordingState => {
+        switch (action.type) {
+
+        case CLEAR_RECORDING_SESSIONS:
+            return {
+                ...state,
+                sessionDatas: [],
+                startRecordingIntent: null,
+                stopRecordingIntent: null
+            };
+
+        case MARK_CONSENT_REQUESTED:
+            return {
+                ...state,
+                consentRequested: new Set([
+                    ...state.consentRequested,
+                    action.sessionId
+                ])
+            };
+
+        case RECORDING_SESSION_UPDATED:
+            return {
+                ...state,
+                sessionDatas:
+                    _updateSessionDatas(state.sessionDatas, action.sessionData)
+            };
+
+        case SET_PENDING_RECORDING_NOTIFICATION_UID: {
+            const pendingNotificationUids = {
+                ...state.pendingNotificationUids
+            };
+
+            pendingNotificationUids[action.streamType] = action.uid;
+
+            return {
+                ...state,
+                pendingNotificationUids
+            };
+        }
+
+        case SET_SELECTED_RECORDING_SERVICE: {
+            return {
+                ...state,
+                selectedRecordingService: action.selectedRecordingService
+            };
+        }
+
+        case SET_STREAM_KEY:
+            return {
+                ...state,
+                streamKey: action.streamKey
+            };
+
+        case SET_MEETING_HIGHLIGHT_BUTTON_STATE:
+            return {
+                ...state,
+                disableHighlightMeetingMoment: action.disabled
+            };
+
+        case SET_START_RECORDING_INTENT:
+            return {
+                ...state,
+                startRecordingIntent: action.intent
+            };
+
+        case SET_STOP_RECORDING_INTENT:
+            return {
+                ...state,
+                stopRecordingIntent: action.intent
+            };
+
+        case SET_START_RECORDING_NOTIFICATION_SHOWN:
+            return {
+                ...state,
+                wasStartRecordingSuggested: true
+            };
+
+        case SET_LOCAL_RECORDING_RUNNING:
+            return {
+                ...state,
+                localRecordingRunning: action.running
+            };
+
+        default:
+            return state;
+        }
+    });
+
+/**
+ * Updates the known information on recording sessions.
+ *
+ * @param {Array} sessionDatas - The current sessions in the redux store.
+ * @param {Object} newSessionData - The updated session data.
+ * @private
+ * @returns {Array} The session data with the updated session data added.
+ */
+function _updateSessionDatas(sessionDatas: ISessionData[], newSessionData: ISessionData) {
+    const hasExistingSessionData = sessionDatas.find(
+        sessionData => sessionData.id === newSessionData.id);
+    let newSessionDatas;
+
+    if (hasExistingSessionData) {
+        newSessionDatas = sessionDatas.map(sessionData => {
+            if (sessionData.id === newSessionData.id) {
+                return {
+                    ...newSessionData
+                };
+            }
+
+            // Nothing to update for this session data so pass it back in.
+            return sessionData;
+        });
+    } else {
+        // If the session data is not present, then there is nothing to update
+        // and instead it needs to be added to the known session data.
+        newSessionDatas = [
+            ...sessionDatas,
+            { ...newSessionData }
+        ];
+    }
+
+    return newSessionDatas;
+}