mediasfu-shared 1.0.1 → 1.0.2

package/src/methods/socketReceive/recordingNotice.ts

@@ -0,0 +1,286 @@
+import type { EventType, UserRecordingParams } from '../../types/types';
+import { SoundPlayer, type SoundPlayerType } from '../utils/SoundPlayer';
+
+export interface RecordingNoticeUserRecordingParamsLike {
+  mainSpecs: {
+    mediaOptions: string;
+    audioOptions: string;
+    videoOptions: string;
+    videoType: string;
+    videoOptimized: boolean;
+    recordingDisplayType: 'video' | 'media' | 'all';
+    addHLS: boolean;
+  };
+  dispSpecs: {
+    nameTags: boolean;
+    backgroundColor: string;
+    nameTagsColor: string;
+    orientationVideo: string;
+  };
+  textSpecs?: {
+    addText?: boolean;
+    customText?: string;
+    customTextPosition?: string;
+    customTextColor?: string;
+  };
+}
+
+export interface RecordingNoticeParameters<
+  TUserRecordingParams extends RecordingNoticeUserRecordingParamsLike = UserRecordingParams,
+  TEventType = EventType,
+> {
+  islevel: string;
+  userRecordingParams: TUserRecordingParams;
+  pauseRecordCount?: number;
+  recordElapsedTime: number;
+  recordStartTime: number;
+  recordStarted: boolean;
+  recordPaused: boolean;
+  canLaunchRecord: boolean;
+  stopLaunchRecord: boolean;
+  recordStopped: boolean;
+  isTimerRunning: boolean;
+  canPauseResume: boolean;
+  eventType: TEventType;
+  updateRecordingProgressTime: (time: string) => void;
+  updateShowRecordButtons: (show: boolean) => void;
+  updateUserRecordingParams: (params: TUserRecordingParams) => void;
+  updateRecordingMediaOptions: (options: string) => void;
+  updateRecordingAudioOptions: (options: string) => void;
+  updateRecordingVideoOptions: (options: string) => void;
+  updateRecordingVideoType: (type: string) => void;
+  updateRecordingVideoOptimized: (optimized: boolean) => void;
+  updateRecordingDisplayType: (type: 'video' | 'media' | 'all') => void;
+  updateRecordingAddHLS: (addHLS: boolean) => void;
+  updateRecordingNameTags: (nameTags: boolean) => void;
+  updateRecordingBackgroundColor: (color: string) => void;
+  updateRecordingNameTagsColor: (color: string) => void;
+  updateRecordingOrientationVideo: (orientation: string) => void;
+  updateRecordingAddText: (addText: boolean) => void;
+  updateRecordingCustomText: (text: string) => void;
+  updateRecordingCustomTextPosition: (position: string) => void;
+  updateRecordingCustomTextColor: (color: string) => void;
+  updatePauseRecordCount: (count: number) => void;
+  updateRecordElapsedTime: (time: number) => void;
+  updateRecordStarted: (started: boolean) => void;
+  updateRecordPaused: (paused: boolean) => void;
+  updateCanLaunchRecord: (canLaunch: boolean) => void;
+  updateStopLaunchRecord: (stop: boolean) => void;
+  updateRecordStopped: (stopped: boolean) => void;
+  updateIsTimerRunning: (running: boolean) => void;
+  updateCanPauseResume: (canPause: boolean) => void;
+  updateRecordStartTime: (startTime: number) => void;
+  updateRecordState: (state: string) => void;
+  [key: string]: any;
+}
+
+export interface RecordingNoticeOptions<
+  TUserRecordingParams extends RecordingNoticeUserRecordingParamsLike = UserRecordingParams,
+  TEventType = EventType,
+> {
+  state: string;
+  userRecordingParam: TUserRecordingParams | null;
+  pauseCount: number;
+  timeDone: number;
+  parameters: RecordingNoticeParameters<TUserRecordingParams, TEventType>;
+  soundPlayer?: SoundPlayerType;
+}
+
+export type RecordingNoticeType<
+  TUserRecordingParams extends RecordingNoticeUserRecordingParamsLike = UserRecordingParams,
+  TEventType = EventType,
+> = (
+  options: RecordingNoticeOptions<TUserRecordingParams, TEventType>,
+) => Promise<void>;
+
+/**
+ * Reconciles recording state updates, user recording settings, and progress UI after a recording socket notice.
+ *
+ * @param {RecordingNoticeOptions} options - Recording state payload and room-level update callbacks.
+ * @returns {Promise<void>} Resolves once recording state, UI flags, and progress text are synchronized.
+ *
+ * @example
+ * ```typescript
+ * await recordingNotice({
+ *   state: 'pause',
+ *   userRecordingParam,
+ *   pauseCount: 2,
+ *   timeDone: 3600,
+ *   parameters,
+ * });
+ * ```
+ */
+export const recordingNotice = async <
+  TUserRecordingParams extends RecordingNoticeUserRecordingParamsLike = UserRecordingParams,
+  TEventType = EventType,
+>({
+  state,
+  userRecordingParam,
+  pauseCount,
+  timeDone,
+  parameters,
+  soundPlayer,
+}: RecordingNoticeOptions<TUserRecordingParams, TEventType>): Promise<void> => {
+  let {
+    islevel,
+    userRecordingParams,
+    pauseRecordCount,
+    recordElapsedTime,
+    recordStartTime,
+    recordStarted,
+    recordPaused,
+    canLaunchRecord,
+    stopLaunchRecord,
+    recordStopped,
+    isTimerRunning,
+    canPauseResume,
+    eventType,
+    updateRecordingProgressTime,
+    updateShowRecordButtons,
+    updateUserRecordingParams,
+    updateRecordingMediaOptions,
+    updateRecordingAudioOptions,
+    updateRecordingVideoOptions,
+    updateRecordingVideoType,
+    updateRecordingVideoOptimized,
+    updateRecordingDisplayType,
+    updateRecordingAddHLS,
+    updateRecordingNameTags,
+    updateRecordingBackgroundColor,
+    updateRecordingNameTagsColor,
+    updateRecordingOrientationVideo,
+    updateRecordingAddText,
+    updateRecordingCustomText,
+    updateRecordingCustomTextPosition,
+    updateRecordingCustomTextColor,
+    updatePauseRecordCount,
+    updateRecordElapsedTime,
+    updateRecordStartTime,
+    updateRecordStarted,
+    updateRecordPaused,
+    updateCanLaunchRecord,
+    updateStopLaunchRecord,
+    updateRecordStopped,
+    updateIsTimerRunning,
+    updateCanPauseResume,
+    updateRecordState,
+  } = parameters;
+
+  const playSound = async (soundUrl: string): Promise<void> => {
+    await (soundPlayer ?? SoundPlayer)({ soundUrl });
+  };
+
+  try {
+    if (islevel !== '2') {
+      if (state === 'pause') {
+        updateRecordStarted(true);
+        updateRecordPaused(true);
+        updateRecordState('yellow');
+        if (eventType !== 'broadcast') {
+          await playSound('https://www.mediasfu.com/sounds/record-paused.mp3');
+        }
+      } else if (state === 'stop') {
+        updateRecordStarted(true);
+        updateRecordStopped(true);
+        updateRecordState('green');
+        if (eventType !== 'broadcast') {
+          await playSound('https://www.mediasfu.com/sounds/record-stopped.mp3');
+        }
+      } else {
+        updateRecordState('red');
+        updateRecordStarted(true);
+        updateRecordPaused(false);
+        if (eventType !== 'broadcast') {
+          await playSound('https://www.mediasfu.com/sounds/record-progress.mp3');
+        }
+      }
+    } else {
+      if (state === 'pause') {
+        updateRecordState('yellow');
+        if (userRecordingParam) {
+          userRecordingParams.mainSpecs = userRecordingParam.mainSpecs;
+          userRecordingParams.dispSpecs = userRecordingParam.dispSpecs;
+          userRecordingParams.textSpecs = userRecordingParam.textSpecs;
+
+          updateUserRecordingParams(userRecordingParams);
+          updateRecordingMediaOptions(userRecordingParams.mainSpecs.mediaOptions);
+          updateRecordingAudioOptions(userRecordingParams.mainSpecs.audioOptions);
+          updateRecordingVideoOptions(userRecordingParams.mainSpecs.videoOptions);
+          updateRecordingVideoType(userRecordingParams.mainSpecs.videoType);
+          updateRecordingVideoOptimized(userRecordingParams.mainSpecs.videoOptimized);
+          updateRecordingDisplayType(userRecordingParams.mainSpecs.recordingDisplayType);
+          updateRecordingAddHLS(userRecordingParams.mainSpecs.addHLS);
+          updateRecordingNameTags(userRecordingParams.dispSpecs.nameTags);
+          updateRecordingBackgroundColor(userRecordingParams.dispSpecs.backgroundColor);
+          updateRecordingNameTagsColor(userRecordingParams.dispSpecs.nameTagsColor);
+          updateRecordingOrientationVideo(userRecordingParams.dispSpecs.orientationVideo);
+          updateRecordingAddText(userRecordingParams.textSpecs?.addText ?? false);
+          updateRecordingCustomText(userRecordingParams.textSpecs?.customText ?? '');
+          updateRecordingCustomTextPosition(
+            userRecordingParams.textSpecs?.customTextPosition ?? '',
+          );
+          updateRecordingCustomTextColor(
+            userRecordingParams.textSpecs?.customTextColor ?? '',
+          );
+
+          pauseRecordCount = pauseCount;
+          updatePauseRecordCount(pauseRecordCount);
+
+          recordElapsedTime = Math.floor(timeDone / 1000);
+          recordStartTime = Math.floor(Date.now() / 1000) - recordElapsedTime;
+          updateRecordStartTime(recordStartTime);
+          updateRecordElapsedTime(recordElapsedTime);
+
+          recordStarted = true;
+          recordPaused = true;
+          canLaunchRecord = false;
+          recordStopped = false;
+
+          updateRecordStarted(recordStarted);
+          updateRecordPaused(recordPaused);
+          updateCanLaunchRecord(canLaunchRecord);
+          updateRecordStopped(recordStopped);
+          updateShowRecordButtons(true);
+
+          isTimerRunning = false;
+          canPauseResume = true;
+
+          updateIsTimerRunning(isTimerRunning);
+          updateCanPauseResume(canPauseResume);
+          updateRecordingProgressTime(formatElapsedTime(recordElapsedTime));
+        }
+        await playSound('https://www.mediasfu.com/sounds/record-paused.mp3');
+      } else if (state === 'stop') {
+        recordStarted = true;
+        recordStopped = true;
+        canLaunchRecord = false;
+        stopLaunchRecord = true;
+
+        updateRecordStarted(recordStarted);
+        updateRecordStopped(recordStopped);
+        updateCanLaunchRecord(canLaunchRecord);
+        updateStopLaunchRecord(stopLaunchRecord);
+        updateShowRecordButtons(false);
+        updateRecordState('green');
+        await playSound('https://www.mediasfu.com/sounds/record-stopped.mp3');
+      } else {
+        updateRecordState('red');
+        updateRecordStarted(true);
+        updateRecordPaused(false);
+        await playSound('https://www.mediasfu.com/sounds/record-progress.mp3');
+      }
+    }
+  } catch (error) {
+    console.log('Error in RecordingNotice: ', error);
+  }
+};
+
+const formatElapsedTime = (recordElapsedTime: number): string => {
+  const hours = Math.floor(recordElapsedTime / 3600);
+  const minutes = Math.floor((recordElapsedTime % 3600) / 60);
+  const seconds = recordElapsedTime % 60;
+
+  return `${padNumber(hours)}:${padNumber(minutes)}:${padNumber(seconds)}`;
+};
+
+const padNumber = (value: number): string => value.toString().padStart(2, '0');

package/src/methods/socketReceive/roomRecordParams.ts

@@ -0,0 +1,122 @@
+export interface RecordParams {
+  recordingAudioPausesLimit: number;
+  recordingAudioPausesCount: number;
+  recordingAudioSupport: boolean;
+  recordingAudioPeopleLimit: number;
+  recordingAudioParticipantsTimeLimit: number;
+  recordingVideoPausesCount: number;
+  recordingVideoPausesLimit: number;
+  recordingVideoSupport: boolean;
+  recordingVideoPeopleLimit: number;
+  recordingVideoParticipantsTimeLimit: number;
+  recordingAllParticipantsSupport: boolean;
+  recordingVideoParticipantsSupport: boolean;
+  recordingAllParticipantsFullRoomSupport: boolean;
+  recordingVideoParticipantsFullRoomSupport: boolean;
+  recordingPreferredOrientation: string;
+  recordingSupportForOtherOrientation: boolean;
+  recordingMultiFormatsSupport: boolean;
+}
+
+export interface RoomRecordParamsParameters {
+  updateRecordingAudioPausesLimit: (value: number) => void;
+  updateRecordingAudioPausesCount: (value: number) => void;
+  updateRecordingAudioSupport: (value: boolean) => void;
+  updateRecordingAudioPeopleLimit: (value: number) => void;
+  updateRecordingAudioParticipantsTimeLimit: (value: number) => void;
+  updateRecordingVideoPausesCount: (value: number) => void;
+  updateRecordingVideoPausesLimit: (value: number) => void;
+  updateRecordingVideoSupport: (value: boolean) => void;
+  updateRecordingVideoPeopleLimit: (value: number) => void;
+  updateRecordingVideoParticipantsTimeLimit: (value: number) => void;
+  updateRecordingAllParticipantsSupport: (value: boolean) => void;
+  updateRecordingVideoParticipantsSupport: (value: boolean) => void;
+  updateRecordingAllParticipantsFullRoomSupport: (value: boolean) => void;
+  updateRecordingVideoParticipantsFullRoomSupport: (value: boolean) => void;
+  updateRecordingPreferredOrientation: (value: string) => void;
+  updateRecordingSupportForOtherOrientation: (value: boolean) => void;
+  updateRecordingMultiFormatsSupport: (value: boolean) => void;
+  [key: string]: any;
+}
+
+export interface RoomRecordParamsOptions {
+  recordParams: RecordParams;
+  parameters: RoomRecordParamsParameters;
+}
+
+export type RoomRecordParamsType = (
+  options: RoomRecordParamsOptions,
+) => Promise<void>;
+
+/**
+ * Applies room-level recording capability limits and toggles to UI state.
+ *
+ * @param {RoomRecordParamsOptions} options - Recording capability payload and setters.
+ * @returns {Promise<void>} Resolves after all setters are applied.
+ *
+ * @example
+ * ```typescript
+ * await roomRecordParams({
+ *   recordParams,
+ *   parameters: recordingSetters,
+ * });
+ * ```
+ */
+export const roomRecordParams = async ({
+  recordParams,
+  parameters,
+}: RoomRecordParamsOptions): Promise<void> => {
+  const {
+    updateRecordingAudioPausesLimit,
+    updateRecordingAudioPausesCount,
+    updateRecordingAudioSupport,
+    updateRecordingAudioPeopleLimit,
+    updateRecordingAudioParticipantsTimeLimit,
+    updateRecordingVideoPausesCount,
+    updateRecordingVideoPausesLimit,
+    updateRecordingVideoSupport,
+    updateRecordingVideoPeopleLimit,
+    updateRecordingVideoParticipantsTimeLimit,
+    updateRecordingAllParticipantsSupport,
+    updateRecordingVideoParticipantsSupport,
+    updateRecordingAllParticipantsFullRoomSupport,
+    updateRecordingVideoParticipantsFullRoomSupport,
+    updateRecordingPreferredOrientation,
+    updateRecordingSupportForOtherOrientation,
+    updateRecordingMultiFormatsSupport,
+  } = parameters;
+
+  updateRecordingAudioPausesLimit(recordParams.recordingAudioPausesLimit);
+  updateRecordingAudioPausesCount(recordParams.recordingAudioPausesCount);
+  updateRecordingAudioSupport(recordParams.recordingAudioSupport);
+  updateRecordingAudioPeopleLimit(recordParams.recordingAudioPeopleLimit);
+  updateRecordingAudioParticipantsTimeLimit(
+    recordParams.recordingAudioParticipantsTimeLimit,
+  );
+  updateRecordingVideoPausesCount(recordParams.recordingVideoPausesCount);
+  updateRecordingVideoPausesLimit(recordParams.recordingVideoPausesLimit);
+  updateRecordingVideoSupport(recordParams.recordingVideoSupport);
+  updateRecordingVideoPeopleLimit(recordParams.recordingVideoPeopleLimit);
+  updateRecordingVideoParticipantsTimeLimit(
+    recordParams.recordingVideoParticipantsTimeLimit,
+  );
+  updateRecordingAllParticipantsSupport(
+    recordParams.recordingAllParticipantsSupport,
+  );
+  updateRecordingVideoParticipantsSupport(
+    recordParams.recordingVideoParticipantsSupport,
+  );
+  updateRecordingAllParticipantsFullRoomSupport(
+    recordParams.recordingAllParticipantsFullRoomSupport,
+  );
+  updateRecordingVideoParticipantsFullRoomSupport(
+    recordParams.recordingVideoParticipantsFullRoomSupport,
+  );
+  updateRecordingPreferredOrientation(
+    recordParams.recordingPreferredOrientation,
+  );
+  updateRecordingSupportForOtherOrientation(
+    recordParams.recordingSupportForOtherOrientation,
+  );
+  updateRecordingMultiFormatsSupport(recordParams.recordingMultiFormatsSupport);
+};

package/src/methods/socketReceive/screenProducerId.ts

@@ -0,0 +1,61 @@
+import type { Participant } from '../../types/types';
+
+export interface ScreenProducerIdOptions {
+  producerId: string;
+  screenId: string;
+  membersReceived: boolean;
+  shareScreenStarted: boolean;
+  deferScreenReceived: boolean;
+  participants: Participant[];
+  updateScreenId: (id: string) => void;
+  updateShareScreenStarted: (started: boolean) => void;
+  updateDeferScreenReceived: (received: boolean) => void;
+}
+
+export type ScreenProducerIdType = (options: ScreenProducerIdOptions) => void;
+
+/**
+ * Reconciles a screen-share producer id with current participant state.
+ *
+ * @param {ScreenProducerIdOptions} options - Screen-share identifiers and setters.
+ * @returns {void} Updates screen state synchronously.
+ *
+ * @example
+ * ```typescript
+ * screenProducerId({
+ *   producerId: 'screen-producer',
+ *   screenId: 'host-screen',
+ *   membersReceived: true,
+ *   shareScreenStarted: false,
+ *   deferScreenReceived: false,
+ *   participants,
+ *   updateScreenId: setScreenId,
+ *   updateShareScreenStarted: setShareScreenStarted,
+ *   updateDeferScreenReceived: setDeferScreenReceived,
+ * });
+ * ```
+ */
+export const screenProducerId = ({
+  producerId,
+  screenId,
+  membersReceived,
+  participants,
+  updateScreenId,
+  updateShareScreenStarted,
+  updateDeferScreenReceived,
+}: ScreenProducerIdOptions): void => {
+  const host = participants.find(
+    (participant) =>
+      participant.ScreenID === screenId && participant.ScreenOn === true,
+  );
+
+  if (host && membersReceived) {
+    updateScreenId(producerId);
+    updateShareScreenStarted(true);
+    updateDeferScreenReceived(false);
+    return;
+  }
+
+  updateScreenId(producerId);
+  updateDeferScreenReceived(true);
+};

package/src/methods/socketReceive/startRecords.ts

@@ -0,0 +1,46 @@
+export interface StartRecordsSocketLike {
+  emit: (
+    event: string,
+    payload: { roomName: string; member: string },
+    callback?: (response: { success: boolean }) => void,
+  ) => void;
+}
+
+export interface StartRecordsOptions {
+  roomName: string;
+  member: string;
+  socket: StartRecordsSocketLike;
+}
+
+export type StartRecordsType = (options: StartRecordsOptions) => Promise<void>;
+
+/**
+ * Requests recording startup for the current room.
+ *
+ * @param {StartRecordsOptions} options - Room, member, and socket details.
+ * @returns {Promise<void>} Resolves after the emit request is sent.
+ *
+ * @example
+ * ```typescript
+ * await startRecords({
+ *   roomName: 'RoomA',
+ *   member: 'AdminUser',
+ *   socket,
+ * });
+ * ```
+ */
+export const startRecords = async ({
+  roomName,
+  member,
+  socket,
+}: StartRecordsOptions): Promise<void> => {
+  socket.emit(
+    'startRecordIng',
+    { roomName, member },
+    ({ success }: { success: boolean }) => {
+      if (!success) {
+        // no-op: caller-controlled UX
+      }
+    },
+  );
+};

package/src/methods/socketReceive/stoppedRecording.ts

@@ -0,0 +1,44 @@
+import type { ShowAlert } from '../../types/types';
+
+export interface StoppedRecordingOptions {
+  state: string;
+  reason: string;
+  showAlert?: ShowAlert;
+}
+
+export type StoppedRecordingType = (
+  options: StoppedRecordingOptions,
+) => Promise<void>;
+
+/**
+ * Shows a reasoned alert when the backend reports that recording has stopped.
+ *
+ * @param {StoppedRecordingOptions} options - Recording stop state and alert helper.
+ * @returns {Promise<void>} Resolves after the alert is dispatched.
+ *
+ * @example
+ * ```typescript
+ * await stoppedRecording({
+ *   state: 'stop',
+ *   reason: 'The session ended',
+ *   showAlert,
+ * });
+ * ```
+ */
+export const stoppedRecording = async ({
+  state,
+  reason,
+  showAlert,
+}: StoppedRecordingOptions): Promise<void> => {
+  try {
+    if (state === 'stop') {
+      showAlert?.({
+        message: `The recording has stopped - ${reason}.`,
+        duration: 3000,
+        type: 'danger',
+      });
+    }
+  } catch (error) {
+    console.log('Error in stoppedRecording: ', error);
+  }
+};