mediasfu-shared 1.0.0

package/src/methods/recording/confirmRecording.ts

@@ -0,0 +1,241 @@
+import type {
+  ShowAlert,
+  MainSpecs,
+  DispSpecs,
+  TextSpecs,
+  EventType,
+  UserRecordingParams,
+} from '../../types/types'
+
+export interface ConfirmRecordingParameters {
+  showAlert?: ShowAlert
+  recordingMediaOptions: string
+  recordingAudioOptions: string
+  recordingVideoOptions: string
+  recordingVideoType: string
+  recordingDisplayType: 'video' | 'media' | 'all'
+  recordingNameTags: boolean
+  recordingBackgroundColor: string
+  recordingNameTagsColor: string
+  recordingOrientationVideo: string
+  recordingAddHLS: boolean
+  recordingAddText: boolean
+  recordingCustomText: string
+  recordingCustomTextPosition: string
+  recordingCustomTextColor: string
+  meetingDisplayType: string
+  recordingVideoParticipantsFullRoomSupport: boolean
+  recordingAllParticipantsSupport: boolean
+  recordingVideoParticipantsSupport: boolean
+  recordingSupportForOtherOrientation: boolean
+  recordingPreferredOrientation: string
+  recordingMultiFormatsSupport: boolean
+  recordingVideoOptimized: boolean
+  recordingAllParticipantsFullRoomSupport: boolean
+  meetingVideoOptimized: boolean
+  eventType: EventType
+  breakOutRoomStarted: boolean
+  breakOutRoomEnded: boolean
+  updateRecordingDisplayType: (value: 'video' | 'media' | 'all') => void
+  updateRecordingVideoOptimized: (value: boolean) => void
+  updateUserRecordingParams: (params: UserRecordingParams) => void
+  updateConfirmedToRecord: (value: boolean) => void
+  getUpdatedAllParams: () => ConfirmRecordingParameters
+  [key: string]: any
+}
+
+export interface ConfirmRecordingOptions {
+  parameters: ConfirmRecordingParameters
+}
+
+export type ConfirmRecordingType = (options: ConfirmRecordingOptions) => Promise<void>
+
+/**
+ * Confirms the recording settings based on the provided parameters and updates the recording state.
+ */
+export const confirmRecording: ConfirmRecordingType = async ({
+  parameters,
+}) => {
+  parameters = parameters.getUpdatedAllParams()
+
+  let {
+    showAlert,
+    recordingMediaOptions,
+    recordingAudioOptions,
+    recordingVideoOptions,
+    recordingVideoType,
+    recordingDisplayType,
+    recordingNameTags,
+    recordingBackgroundColor,
+    recordingNameTagsColor,
+    recordingOrientationVideo,
+    recordingAddHLS,
+    recordingAddText,
+    recordingCustomText,
+    recordingCustomTextPosition,
+    recordingCustomTextColor,
+    meetingDisplayType,
+    recordingVideoParticipantsFullRoomSupport,
+    recordingAllParticipantsSupport,
+    recordingVideoParticipantsSupport,
+    recordingSupportForOtherOrientation,
+    recordingPreferredOrientation,
+    recordingMultiFormatsSupport,
+    recordingVideoOptimized,
+    recordingAllParticipantsFullRoomSupport,
+    meetingVideoOptimized,
+    eventType,
+    breakOutRoomStarted,
+    breakOutRoomEnded,
+    updateRecordingDisplayType,
+    updateRecordingVideoOptimized,
+    updateUserRecordingParams,
+    updateConfirmedToRecord,
+  } = parameters
+
+  if (
+    !recordingVideoParticipantsFullRoomSupport &&
+    recordingVideoOptions === 'all' &&
+    recordingMediaOptions === 'video'
+  ) {
+    if (meetingDisplayType === 'all' && !(breakOutRoomStarted && !breakOutRoomEnded)) {
+      showAlert?.({
+        message:
+          'You are not allowed to record videos of all participants; change the meeting display type to video or video optimized.',
+        type: 'danger',
+        duration: 3000,
+      })
+      return
+    }
+  }
+
+  if (!recordingAllParticipantsSupport && recordingVideoOptions === 'all') {
+    showAlert?.({
+      message: 'You are only allowed to record yourself.',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  if (!recordingVideoParticipantsSupport && recordingDisplayType === 'video') {
+    showAlert?.({
+      message: 'You are not allowed to record other video participants.',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  if (!recordingSupportForOtherOrientation && recordingOrientationVideo === 'all') {
+    showAlert?.({
+      message: 'You are not allowed to record all orientations.',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  if (
+    (recordingPreferredOrientation === 'landscape' && recordingOrientationVideo === 'portrait') ||
+    (recordingPreferredOrientation === 'portrait' && recordingOrientationVideo === 'landscape')
+  ) {
+    if (!recordingSupportForOtherOrientation) {
+      showAlert?.({
+        message: 'You are not allowed to record this orientation.',
+        type: 'danger',
+        duration: 3000,
+      })
+      return
+    }
+  }
+
+  if (!recordingMultiFormatsSupport && recordingVideoType === 'all') {
+    showAlert?.({
+      message: 'You are not allowed to record all formats.',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  if (eventType !== 'broadcast') {
+    if (recordingMediaOptions === 'video') {
+      if (meetingDisplayType === 'media' && recordingDisplayType === 'all') {
+        showAlert?.({
+          message:
+            'Recording display type can be either video, video optimized, or media when meeting display type is media.',
+          type: 'danger',
+          duration: 3000,
+        })
+        updateRecordingDisplayType(meetingDisplayType as 'video' | 'media' | 'all')
+        return
+      }
+
+      if (meetingDisplayType === 'video') {
+        if (recordingDisplayType === 'all' || recordingDisplayType === 'media') {
+          showAlert?.({
+            message:
+              'Recording display type can be either video or video optimized when meeting display type is video.',
+            type: 'danger',
+            duration: 3000,
+          })
+          updateRecordingDisplayType(meetingDisplayType as 'video' | 'media' | 'all')
+          return
+        }
+
+        if (meetingVideoOptimized && !recordingVideoOptimized) {
+          showAlert?.({
+            message:
+              'Recording display type can only be video optimized when meeting display type is video optimized.',
+            type: 'danger',
+            duration: 3000,
+          })
+          updateRecordingVideoOptimized(meetingVideoOptimized)
+          return
+        }
+      }
+    } else {
+      updateRecordingDisplayType('media')
+      updateRecordingVideoOptimized(false)
+    }
+  }
+
+  if (recordingDisplayType === 'all' && !recordingAllParticipantsFullRoomSupport) {
+    showAlert?.({
+      message: 'You can only record all participants with media.',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  const mainSpecs: MainSpecs = {
+    mediaOptions: recordingMediaOptions,
+    audioOptions: recordingAudioOptions,
+    videoOptions: recordingVideoOptions,
+    videoType: recordingVideoType,
+    videoOptimized: recordingVideoOptimized,
+    recordingDisplayType,
+    addHLS: recordingAddHLS,
+  }
+
+  const dispSpecs: DispSpecs = {
+    nameTags: recordingNameTags,
+    backgroundColor: recordingBackgroundColor,
+    nameTagsColor: recordingNameTagsColor,
+    orientationVideo: recordingOrientationVideo,
+  }
+
+  const textSpecs: TextSpecs = {
+    addText: recordingAddText,
+    customText: recordingCustomText,
+    customTextPosition: recordingCustomTextPosition,
+    customTextColor: recordingCustomTextColor,
+  }
+
+  const userRecordingParams = { mainSpecs, dispSpecs, textSpecs }
+
+  updateUserRecordingParams(userRecordingParams)
+  updateConfirmedToRecord(true)
+}

package/src/methods/recording/launchRecording.ts

@@ -0,0 +1,114 @@
+import type { ShowAlert } from '../../types/types'
+
+export interface LaunchRecordingOptions {
+  updateIsRecordingModalVisible: (visible: boolean) => void
+  isRecordingModalVisible: boolean
+  showAlert?: ShowAlert
+  stopLaunchRecord: boolean
+  canLaunchRecord: boolean
+  recordingAudioSupport: boolean
+  recordingVideoSupport: boolean
+  updateCanRecord: (canRecord: boolean) => void
+  updateClearedToRecord: (cleared: boolean) => void
+  recordStarted: boolean
+  recordPaused: boolean
+  localUIMode: boolean
+  [key: string]: any
+}
+
+export type LaunchRecordingType = (options: LaunchRecordingOptions) => void
+
+/**
+ * Launches the recording process based on various conditions and updates the UI accordingly.
+ *
+ * @param {Object} options - The options for launching the recording.
+ * @param {Function} options.updateIsRecordingModalVisible - Function to update the visibility of the recording modal.
+ * @param {boolean} options.isRecordingModalVisible - Indicates if the recording modal is currently visible.
+ * @param {Function} options.showAlert - Function to show an alert message.
+ * @param {boolean} options.stopLaunchRecord - Indicates if the recording launch should be stopped.
+ * @param {boolean} options.canLaunchRecord - Indicates if the recording can be launched.
+ * @param {boolean} options.recordingAudioSupport - Indicates if audio recording is supported.
+ * @param {boolean} options.recordingVideoSupport - Indicates if video recording is supported.
+ * @param {Function} options.updateCanRecord - Function to update the recording capability.
+ * @param {Function} options.updateClearedToRecord - Function to update the cleared-to-record status.
+ * @param {boolean} options.recordStarted - Indicates if the recording has started.
+ * @param {boolean} options.recordPaused - Indicates if the recording is paused.
+ * @param {boolean} options.localUIMode - Indicates if the local UI mode is active.
+ *
+ * @returns {void}
+ *
+ * @example
+ * ```typescript
+ * launchRecording({
+ *   updateIsRecordingModalVisible: (visible) => console.log(`Modal visible: ${visible}`),
+ *   isRecordingModalVisible: false,
+ *   showAlert: (alert) => console.log(alert.message),
+ *   stopLaunchRecord: false,
+ *   canLaunchRecord: true,
+ *   recordingAudioSupport: true,
+ *   recordingVideoSupport: true,
+ *   updateCanRecord: (canRecord) => console.log(`Can record: ${canRecord}`),
+ *   updateClearedToRecord: (cleared) => console.log(`Cleared to record: ${cleared}`),
+ *   recordStarted: false,
+ *   recordPaused: false,
+ *   localUIMode: false,
+ * })
+ * ```
+ */
+export const launchRecording: LaunchRecordingType = ({
+  updateIsRecordingModalVisible,
+  isRecordingModalVisible,
+  showAlert,
+  stopLaunchRecord,
+  canLaunchRecord,
+  recordingAudioSupport,
+  recordingVideoSupport,
+  updateCanRecord,
+  updateClearedToRecord,
+  recordStarted,
+  recordPaused,
+  localUIMode,
+}) => {
+  if (!isRecordingModalVisible && stopLaunchRecord && !localUIMode) {
+    showAlert?.({
+      message: 'Recording has already ended or you are not allowed to record',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  if (!isRecordingModalVisible && canLaunchRecord && !localUIMode) {
+    if (!recordingAudioSupport && !recordingVideoSupport) {
+      showAlert?.({
+        message: 'You are not allowed to record',
+        type: 'danger',
+        duration: 3000,
+      })
+      return
+    }
+
+    updateClearedToRecord(false)
+    updateCanRecord(false)
+  }
+
+  if (!isRecordingModalVisible && recordStarted && !recordPaused) {
+    showAlert?.({
+      message: 'You can only re-configure recording after pausing it',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  if (!isRecordingModalVisible && !recordingAudioSupport && !recordingVideoSupport && !localUIMode) {
+    showAlert?.({
+      message: 'You are not allowed to record',
+      type: 'danger',
+      duration: 3000,
+    })
+    return
+  }
+
+  updateIsRecordingModalVisible(!isRecordingModalVisible)
+}

package/src/methods/recording/recordPauseTimer.ts

@@ -0,0 +1,52 @@
+import type { ShowAlert } from '../../types/types'
+
+export interface RecordPauseTimerOptions {
+  stop?: boolean
+  isTimerRunning: boolean
+  canPauseResume: boolean
+  showAlert?: ShowAlert
+}
+
+export type RecordPauseTimerType = (options: RecordPauseTimerOptions) => boolean
+
+/**
+ * Records the pause timer.
+ *
+ * @param {RecordPauseTimerOptions} options - The options for recording the pause timer.
+ * @param {boolean} options.stop - A flag to stop the timer.
+ * @param {boolean} options.isTimerRunning - Indicates if the timer is running.
+ * @param {boolean} options.canPauseResume - Indicates if the timer can be paused or resumed.
+ * @param {Function} options.showAlert - Function to show alerts.
+ *
+ * @returns {boolean} `true` if the timer can be paused or resumed, otherwise `false`.
+ *
+ * @example
+ * ```typescript
+ * const canPause = recordPauseTimer({
+ *   stop: false,
+ *   isTimerRunning: true,
+ *   canPauseResume: true,
+ *   showAlert: (alert) => console.log(alert.message),
+ * })
+ * ```
+ */
+export const recordPauseTimer: RecordPauseTimerType = ({
+  stop = false,
+  isTimerRunning,
+  canPauseResume,
+  showAlert,
+}) => {
+  if (isTimerRunning && canPauseResume) {
+    return true
+  }
+
+  const message = stop
+    ? 'Can only stop after 15 seconds of starting or pausing or resuming recording'
+    : 'Can only pause or resume after 15 seconds of starting or pausing or resuming recording'
+
+  showAlert?.({
+    message,
+    type: 'danger',
+  })
+  return false
+}

package/src/methods/recording/recordResumeTimer.ts

@@ -0,0 +1,92 @@
+import type { ShowAlert } from '../../types/types'
+import { recordUpdateTimer } from './recordUpdateTimer'
+
+export interface RecordResumeTimerParameters {
+  isTimerRunning: boolean
+  canPauseResume: boolean
+  recordElapsedTime: number
+  recordStartTime: number
+  recordTimerInterval?: NodeJS.Timeout | null
+  showAlert?: ShowAlert
+  recordPaused: boolean
+  recordStopped: boolean
+  roomName: string | null
+  updateRecordStartTime: (time: number) => void
+  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void
+  updateIsTimerRunning: (isRunning: boolean) => void
+  updateCanPauseResume: (canPause: boolean) => void
+  updateRecordElapsedTime: (elapsed: number) => void
+  updateRecordingProgressTime: (formatted: string) => void
+  getUpdatedAllParams: () => RecordResumeTimerParameters
+  [key: string]: any
+}
+
+export interface RecordResumeTimerOptions {
+  parameters: RecordResumeTimerParameters
+}
+
+export type RecordResumeTimerType = (options: RecordResumeTimerOptions) => Promise<boolean>
+
+/**
+ * Resumes the recording timer if it is not already running and can be paused/resumed.
+ */
+export const recordResumeTimer: RecordResumeTimerType = async ({ parameters }) => {
+  const { getUpdatedAllParams } = parameters
+  parameters = getUpdatedAllParams()
+
+  let {
+    isTimerRunning,
+    canPauseResume,
+    recordElapsedTime,
+    recordStartTime,
+    recordTimerInterval,
+    showAlert,
+    updateRecordStartTime,
+    updateRecordTimerInterval,
+    updateIsTimerRunning,
+    updateCanPauseResume,
+  } = parameters
+
+  if (!isTimerRunning && canPauseResume) {
+    recordStartTime = new Date().getTime() - recordElapsedTime * 1000
+    updateRecordStartTime(recordStartTime)
+
+    recordTimerInterval = setInterval(() => {
+      recordUpdateTimer({
+        recordElapsedTime,
+        recordStartTime,
+        updateRecordElapsedTime: parameters.updateRecordElapsedTime,
+        updateRecordingProgressTime: parameters.updateRecordingProgressTime,
+      })
+
+      parameters = getUpdatedAllParams()
+
+      if (
+        parameters.recordPaused ||
+        parameters.recordStopped ||
+        parameters.roomName === '' ||
+        parameters.roomName === null
+      ) {
+        clearInterval(recordTimerInterval!)
+        updateRecordTimerInterval(null)
+        isTimerRunning = false
+        updateIsTimerRunning(isTimerRunning)
+        canPauseResume = false
+        updateCanPauseResume(canPauseResume)
+      }
+    }, 1000)
+
+    updateRecordTimerInterval(recordTimerInterval!)
+    isTimerRunning = true
+    updateIsTimerRunning(isTimerRunning)
+    canPauseResume = false
+    updateCanPauseResume(canPauseResume)
+    return true
+  }
+
+  showAlert?.({
+    type: 'danger',
+    message: 'Can only pause or resume after 15 seconds of starting or pausing or resuming recording',
+  })
+  return false
+}

package/src/methods/recording/recordStartTimer.ts

@@ -0,0 +1,106 @@
+import { recordUpdateTimer } from './recordUpdateTimer'
+
+export interface RecordStartTimerParameters {
+  recordStartTime: number
+  recordTimerInterval?: NodeJS.Timeout | null
+  isTimerRunning: boolean
+  canPauseResume: boolean
+  recordChangeSeconds: number
+  recordPaused: boolean
+  recordStopped: boolean
+  roomName: string | null
+  updateRecordStartTime: (time: number) => void
+  updateRecordTimerInterval: (interval: NodeJS.Timeout | null) => void
+  updateIsTimerRunning: (isRunning: boolean) => void
+  updateCanPauseResume: (canPause: boolean) => void
+  recordElapsedTime: number
+  updateRecordElapsedTime: (elapsed: number) => void
+  updateRecordingProgressTime: (formatted: string) => void
+  getUpdatedAllParams: () => RecordStartTimerParameters
+  [key: string]: any
+}
+
+export interface RecordStartTimerOptions {
+  parameters: RecordStartTimerParameters
+}
+
+export type RecordStartTimerType = (options: RecordStartTimerOptions) => Promise<void>
+
+/**
+ * Starts a recording timer and manages its state.
+ *
+ * @param {RecordStartTimerOptions} options - The options for starting the recording timer.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {number} options.parameters.recordStartTime - The start time of the recording.
+ * @param {number | null} options.parameters.recordTimerInterval - The interval ID for the recording timer.
+ * @param {boolean} options.parameters.isTimerRunning - Flag indicating if the timer is running.
+ * @param {boolean} options.parameters.canPauseResume - Flag indicating if pause/resume actions are enabled.
+ * @param {number} options.parameters.recordChangeSeconds - The time after which pause/resume actions are enabled.
+ * @param {Function} options.parameters.updateRecordStartTime - Function to update the recording start time.
+ * @param {Function} options.parameters.updateRecordTimerInterval - Function to update the recording timer interval.
+ * @param {Function} options.parameters.updateIsTimerRunning - Function to update the timer running state.
+ * @param {Function} options.parameters.updateCanPauseResume - Function to update the pause/resume state.
+ *
+ * @example
+ * ```typescript
+ * await recordStartTimer({ parameters })
+ * ```
+ */
+export const recordStartTimer: RecordStartTimerType = async ({ parameters }) => {
+  const { getUpdatedAllParams } = parameters
+  parameters = getUpdatedAllParams()
+
+  let {
+    recordStartTime,
+    recordTimerInterval,
+    isTimerRunning,
+    canPauseResume,
+    recordChangeSeconds,
+    updateRecordStartTime,
+    updateRecordTimerInterval,
+    updateIsTimerRunning,
+    updateCanPauseResume,
+  } = parameters
+
+  const enablePauseResume = (): void => {
+    canPauseResume = true
+    updateCanPauseResume(canPauseResume)
+  }
+
+  if (!isTimerRunning) {
+    recordStartTime = new Date().getTime()
+    updateRecordStartTime(recordStartTime)
+
+    recordTimerInterval = setInterval(() => {
+      recordUpdateTimer({
+        recordElapsedTime: parameters.recordElapsedTime,
+        recordStartTime,
+        updateRecordElapsedTime: parameters.updateRecordElapsedTime,
+        updateRecordingProgressTime: parameters.updateRecordingProgressTime,
+      })
+
+      parameters = getUpdatedAllParams()
+
+      if (
+        parameters.recordPaused ||
+        parameters.recordStopped ||
+        parameters.roomName === '' ||
+        parameters.roomName === null
+      ) {
+        clearInterval(recordTimerInterval!)
+        updateRecordTimerInterval(null)
+        isTimerRunning = false
+        updateIsTimerRunning(isTimerRunning)
+        canPauseResume = false
+        updateCanPauseResume(canPauseResume)
+      }
+    }, 1000)
+
+    updateRecordTimerInterval(recordTimerInterval)
+    isTimerRunning = true
+    updateIsTimerRunning(isTimerRunning)
+    canPauseResume = false
+    updateCanPauseResume(canPauseResume)
+    setTimeout(enablePauseResume, recordChangeSeconds)
+  }
+}

package/src/methods/recording/recordUpdateTimer.ts

@@ -0,0 +1,49 @@
+export interface RecordUpdateTimerOptions {
+  recordElapsedTime: number
+  recordStartTime: number
+  updateRecordElapsedTime: (elapsedTime: number) => void
+  updateRecordingProgressTime: (formattedTime: string) => void
+}
+
+export type RecordUpdateTimerType = (options: RecordUpdateTimerOptions) => void
+
+/**
+ * Updates the recording timer by calculating the elapsed time since the recording started
+ * and formatting it in HH:MM:SS format.
+ *
+ * @param {RecordUpdateTimerOptions} options - The options object.
+ * @param {number} options.recordElapsedTime - The elapsed recording time in seconds.
+ * @param {number} options.recordStartTime - The timestamp when the recording started.
+ * @param {Function} options.updateRecordElapsedTime - Callback to update the elapsed recording time.
+ * @param {Function} options.updateRecordingProgressTime - Callback to update the formatted recording time.
+ *
+ * @example
+ * ```typescript
+ * recordUpdateTimer({
+ *   recordElapsedTime: 0,
+ *   recordStartTime: Date.now(),
+ *   updateRecordElapsedTime: (elapsedTime) => console.log('Elapsed:', elapsedTime),
+ *   updateRecordingProgressTime: (formatted) => console.log('Progress:', formatted),
+ * })
+ * ```
+ */
+export const recordUpdateTimer: RecordUpdateTimerType = ({
+  recordElapsedTime,
+  recordStartTime,
+  updateRecordElapsedTime,
+  updateRecordingProgressTime,
+}) => {
+  const padNumber = (value: number): string => value.toString().padStart(2, '0')
+
+  const currentTime = new Date().getTime()
+  let elapsedSeconds = recordElapsedTime
+  elapsedSeconds = Math.floor((currentTime - recordStartTime) / 1000)
+  updateRecordElapsedTime(elapsedSeconds)
+
+  const hours = Math.floor(elapsedSeconds / 3600)
+  const minutes = Math.floor((elapsedSeconds % 3600) / 60)
+  const seconds = elapsedSeconds % 60
+  const formattedTime = `${padNumber(hours)}:${padNumber(minutes)}:${padNumber(seconds)}`
+
+  updateRecordingProgressTime(formattedTime)
+}