mediasfu-shared 1.0.0

package/src/methods/requests/respondToRequests.ts

@@ -0,0 +1,108 @@
+import { Socket } from "socket.io-client";
+import type { Request, RequestResponse } from "../../types/types";
+
+export interface RespondToRequestsOptions {
+  socket: Socket;
+  request: Request;
+  updateRequestList: (newRequestList: Request[]) => void;
+  requestList?: Request[];
+  action: string;
+  roomName: string;
+}
+
+// Export the type definition for the function
+export type RespondToRequestsType = (options: RespondToRequestsOptions) => Promise<void>;
+
+/**
+ * Responds to incoming requests by updating the request list and emitting a response to the server.
+ *
+ * @param {Object} options - The options for responding to requests.
+ * @param {Socket} options.socket - The socket instance used to emit the response.
+ * @param {Request} options.request - The request object containing details of the request.
+ * @param {Function} options.updateRequestList - The function to update the request list.
+ * @param {Request[]} options.requestList - The current list of requests.
+ * @param {string} options.action - The action to be taken on the request.
+ * @param {string} options.roomName - The name of the room to which the response should be emitted.
+ *
+ * @returns {Promise<void>} A promise that resolves when the response has been emitted.
+ * 
+ * @example
+ * ```typescript
+ * respondToRequests({
+ *   socket,
+ *   request: { id: "123", name: "John", icon: "fa-microphone" },
+ *   updateRequestList: setRequestList,
+ *   requestList: currentRequests,
+ *   action: "accept",
+ *   roomName: "mainRoom"
+ * });
+ * ```
+ */
+
+export const respondToRequests = async ({
+  socket,
+  request,
+  updateRequestList,
+  requestList = [],
+  action,
+  roomName,
+}: RespondToRequestsOptions): Promise<void> => {
+  if (!request || typeof request !== "object") {
+    return;
+  }
+
+  if (!updateRequestList) {
+    console.warn("[respondToRequests] Missing updateRequestList handler; aborting emit.");
+    return;
+  }
+
+  const currentList = Array.isArray(requestList) ? requestList : [];
+
+  const requestIdRaw = (request as { id?: string | number }).id;
+  const requestIcon = (request as { icon?: string }).icon;
+  const requestName = (request as { name?: string }).name;
+
+  if (requestIdRaw === undefined || requestIcon === undefined || requestName === undefined) {
+    console.warn("[respondToRequests] Request payload is missing required fields; aborting emit.", request);
+    return;
+  }
+
+  const requestId = String(requestIdRaw);
+
+  if (!requestId || !requestIcon || !requestName) {
+    console.warn("[respondToRequests] Request payload contains empty fields; aborting emit.", request);
+    return;
+  }
+
+  // Filter out the request from the request list
+  const newRequestList = currentList.filter(
+    (request_) =>
+      !(
+        request_ &&
+        request_.id === requestId &&
+        request_.icon === requestIcon &&
+        request_.name === requestName
+      )
+  );
+
+  // Update the request list with the filtered list
+  updateRequestList(newRequestList);
+
+  // Prepare the request response
+  const requestResponse: RequestResponse = {
+    id: requestId,
+    name: requestName,
+    type: requestIcon,
+    action,
+  };
+
+  // Emit the request response to the server
+  const socketReady = socket && typeof (socket as Socket).emit === "function";
+
+  if (!socketReady) {
+    console.warn("[respondToRequests] Socket is not ready; skipping emit.");
+    return;
+  }
+
+  (socket as Socket).emit("updateUserofRequestStatus", { requestResponse, roomName });
+};

package/src/methods/settings/index.ts

@@ -0,0 +1,2 @@
+export { modifySettings } from './modifySettings';
+export type { ModifySettingsOptions, ModifySettingsType } from './modifySettings';

package/src/methods/settings/launchSettings.ts

@@ -0,0 +1,25 @@
+export interface LaunchSettingsOptions {
+  updateIsSettingsModalVisible: (isVisible: boolean) => void
+  isSettingsModalVisible: boolean
+}
+
+export type LaunchSettingsType = (options: LaunchSettingsOptions) => void
+
+/**
+ * Toggles the visibility state of the settings modal.
+ *
+ * @param {LaunchSettingsOptions} options - The options for launching settings.
+ * @param {Function} options.updateIsSettingsModalVisible - Function to update the visibility state of the settings modal.
+ * @param {boolean} options.isSettingsModalVisible - Current visibility state of the settings modal.
+ *
+ * @example
+ * ```typescript
+ * launchSettings({
+ *   isSettingsModalVisible: false,
+ *   updateIsSettingsModalVisible: (visible) => setSettingsModalVisible(visible),
+ * })
+ * ```
+ */
+export const launchSettings: LaunchSettingsType = ({ updateIsSettingsModalVisible, isSettingsModalVisible }) => {
+  updateIsSettingsModalVisible(!isSettingsModalVisible)
+}

package/src/methods/settings/modifySettings.ts

@@ -0,0 +1,99 @@
+import { Socket } from 'socket.io-client';
+import type { ShowAlert } from '../../types/types';
+
+export interface ModifySettingsOptions {
+  showAlert?: ShowAlert;
+  roomName: string;
+  audioSet: string;
+  videoSet: string;
+  screenshareSet: string;
+  chatSet: string;
+  socket: Socket;
+  updateAudioSetting: (audioSet: string) => void;
+  updateVideoSetting: (videoSet: string) => void;
+  updateScreenshareSetting: (screenshareSet: string) => void;
+  updateChatSetting: (chatSet: string) => void;
+  updateIsSettingsModalVisible: (isVisible: boolean) => void;
+}
+
+// Export the type definition for the function
+export type ModifySettingsType = (options: ModifySettingsOptions) => Promise<void>;
+
+/**
+ * Modifies the settings for a given room and updates the state accordingly.
+ *
+ * @param {ModifySettingsOptions} options - The options for modifying settings.
+ * @returns {Promise<void>} A promise that resolves when the settings have been modified.
+ *
+ * @throws Will show an alert if any setting is set to "approval" in demo mode (room name starts with "d").
+ *
+ * @example
+ * ```typescript
+ * modifySettings({
+ *   roomName: "d123",
+ *   audioSet: "allow",
+ *   videoSet: "allow",
+ *   screenshareSet: "deny",
+ *   chatSet: "allow",
+ *   socket: mySocketInstance,
+ *   updateAudioSetting: setAudioSetting,
+ *   updateVideoSetting: setVideoSetting,
+ *   updateScreenshareSetting: setScreenshareSetting,
+ *   updateChatSetting: setChatSetting,
+ *   updateIsSettingsModalVisible: setIsSettingsModalVisible,
+ *   showAlert: (options) => alertUser(options),
+ * });
+ * ```
+ */
+export async function modifySettings({
+  showAlert,
+  roomName,
+  audioSet,
+  videoSet,
+  screenshareSet,
+  chatSet,
+  socket,
+  updateAudioSetting,
+  updateVideoSetting,
+  updateScreenshareSetting,
+  updateChatSetting,
+  updateIsSettingsModalVisible,
+}: ModifySettingsOptions): Promise<void> {
+  if (roomName.toLowerCase().startsWith('d')) {
+    // none should be approval
+    if (
+      audioSet === 'approval' ||
+      videoSet === 'approval' ||
+      screenshareSet === 'approval' ||
+      chatSet === 'approval'
+    ) {
+      showAlert?.({
+        message: 'You cannot set approval for demo mode.',
+        type: 'danger',
+        duration: 3000,
+      });
+
+      return;
+    }
+  }
+
+  // Check and update state variables based on the provided logic
+  if (audioSet) {
+    updateAudioSetting(audioSet);
+  }
+  if (videoSet) {
+    updateVideoSetting(videoSet);
+  }
+  if (screenshareSet) {
+    updateScreenshareSetting(screenshareSet);
+  }
+  if (chatSet) {
+    updateChatSetting(chatSet);
+  }
+
+  const settings = [audioSet, videoSet, screenshareSet, chatSet];
+  socket.emit('updateSettingsForRequests', { settings, roomName });
+
+  // Close modal
+  updateIsSettingsModalVisible(false);
+}

package/src/methods/stream/clickVideo.ts

@@ -0,0 +1,337 @@
+import { Socket } from "socket.io-client";
+import { CheckPermissionType, DisconnectSendTransportVideoParameters, DisconnectSendTransportVideoType, RequestPermissionCameraType, ShowAlert, StreamSuccessVideoParameters, StreamSuccessVideoType, VidCons } from "../../types/types";
+
+export interface ClickVideoParameters extends DisconnectSendTransportVideoParameters, StreamSuccessVideoParameters {
+  checkMediaPermission: boolean;
+  hasCameraPermission: boolean;
+  videoAlreadyOn: boolean;
+  audioOnlyRoom: boolean;
+  recordStarted: boolean;
+  recordResumed: boolean;
+  recordPaused: boolean;
+  recordStopped: boolean;
+  recordingMediaOptions: string;
+  islevel: string;
+  youAreCoHost: boolean;
+  adminRestrictSetting: boolean;
+  videoRequestState: string | null;
+  videoRequestTime: number;
+  member: string;
+  socket: Socket;
+  roomName: string;
+  userDefaultVideoInputDevice: string;
+  currentFacingMode: string;
+  vidCons: VidCons;
+  frameRate: number;
+  videoAction: boolean;
+  localStream: MediaStream | null;
+  audioSetting: string;
+  videoSetting: string;
+  screenshareSetting: string;
+  chatSetting: string;
+  updateRequestIntervalSeconds: number;
+
+  showAlert?: ShowAlert;
+  updateVideoAlreadyOn: (value: boolean) => void;
+  updateVideoRequestState: (state: string) => void;
+  updateLocalStream: (stream: MediaStream | null) => void;
+  mediaDevices: MediaDevices;
+
+  streamSuccessVideo: StreamSuccessVideoType;
+  disconnectSendTransportVideo: DisconnectSendTransportVideoType;
+  requestPermissionCamera: RequestPermissionCameraType;
+  checkPermission: CheckPermissionType;
+
+  getUpdatedAllParams: () => ClickVideoParameters;
+  [key: string]: any;
+
+}
+
+export interface ClickVideoOptions {
+  parameters: ClickVideoParameters;
+}
+
+// Export the type definition for the function
+export type ClickVideoType = (options: ClickVideoOptions) => Promise<void>;
+
+/**
+ * Handles the click event to toggle the participant's video on/off and manages video permission requests.
+ *
+ * @param {ClickVideoOptions} options - The function parameters.
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```typescript
+ * clickVideo({
+ *   parameters: {
+ *     checkMediaPermission: true,
+ *     hasCameraPermission: false,
+ *     videoAlreadyOn: false,
+ *     audioOnlyRoom: false,
+ *     recordStarted: true,
+ *     recordResumed: false,
+ *     recordPaused: true,
+ *     recordStopped: false,
+ *     recordingMediaOptions: "video",
+ *     islevel: "1",
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     videoRequestState: null,
+ *     videoRequestTime: Date.now(),
+ *     member: "John Doe",
+ *     socket: socketInstance,
+ *     roomName: "room123",
+ *     userDefaultVideoInputDevice: "default",
+ *     currentFacingMode: "user",
+ *     vidCons: { width: 1280, height: 720 },
+ *     frameRate: 30,
+ *     videoAction: false,
+ *     localStream: null,
+ *     audioSetting: "allow",
+ *     videoSetting: "allow",
+ *     screenshareSetting: "allow",
+ *     chatSetting: "allow",
+ *     updateRequestIntervalSeconds: 60,
+ *     showAlert: showAlertFunction,
+ *     updateVideoAlreadyOn: setVideoAlreadyOn,
+ *     updateVideoRequestState: setVideoRequestState,
+ *     updateLocalStream: setLocalStream,
+ *     mediaDevices: navigator.mediaDevices,
+ *     streamSuccessVideo: streamSuccessVideoFunction,
+ *     disconnectSendTransportVideo: disconnectVideoTransportFunction,
+ *     requestPermissionCamera: requestCameraPermissionFunction,
+ *     checkPermission: checkPermissionFunction,
+ *     getUpdatedAllParams: getUpdatedParamsFunction
+ *   }
+ * });
+ * ```
+ */
+
+export const clickVideo = async ({ parameters }: ClickVideoOptions): Promise<void> => {
+  let {
+    checkMediaPermission,
+    hasCameraPermission,
+    videoAlreadyOn,
+    audioOnlyRoom,
+    recordStarted,
+    recordResumed,
+    recordPaused,
+    recordStopped,
+    recordingMediaOptions,
+    islevel,
+    youAreCoHost,
+    adminRestrictSetting,
+    videoRequestState,
+    videoRequestTime,
+    member,
+    socket,
+    roomName,
+    userDefaultVideoInputDevice,
+    currentFacingMode,
+    vidCons,
+    frameRate,
+    videoAction,
+    localStream,
+    audioSetting,
+    videoSetting,
+    screenshareSetting,
+    chatSetting,
+    updateRequestIntervalSeconds,
+    streamSuccessVideo,
+    showAlert,
+    updateVideoAlreadyOn,
+    updateVideoRequestState,
+    updateLocalStream,
+    mediaDevices,
+    disconnectSendTransportVideo,
+    requestPermissionCamera,
+    checkPermission,
+  } = parameters;
+
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: "You cannot turn on your camera in an audio-only event.",
+      type: "danger",
+      duration: 3000,
+    });
+    return;
+  }
+
+  if (videoAlreadyOn) {
+    if (islevel === "2" && (recordStarted || recordResumed)) {
+      if (!(recordPaused || recordStopped)) {
+        if (recordingMediaOptions === "video") {
+          showAlert?.({
+            message: "You cannot turn off your camera while recording video, please pause or stop recording first.",
+            type: "danger",
+            duration: 3000,
+          });
+          return;
+        }
+      }
+    }
+
+    videoAlreadyOn = false;
+    updateVideoAlreadyOn(videoAlreadyOn);
+    localStream!.getVideoTracks()[0].enabled = false;
+    updateLocalStream(localStream);
+    await disconnectSendTransportVideo({ parameters });
+  } else {
+    if (adminRestrictSetting) {
+      showAlert?.({
+        message: "You cannot turn on your camera. Access denied by host.",
+        duration: 3000,
+        type: "danger",
+      });
+      return;
+    }
+
+    let response = 2;
+
+    if (!videoAction && islevel !== "2" && !youAreCoHost) {
+      response = await checkPermission({
+        permissionType: "videoSetting",
+        audioSetting, videoSetting, screenshareSetting, chatSetting,
+      });
+    } else {
+      response = 0;
+    }
+
+    if (response == 1) {
+      //approval
+      //check if request is pending or not
+      if (videoRequestState === "pending") {
+        showAlert?.({
+          message: "A request is pending. Please wait for the host to respond.",
+          type: "danger",
+          duration: 3000,
+        });
+        return;
+      }
+      // check if rejected and current time is less than videoRequestTime
+      if (videoRequestState === "rejected" && Date.now() - videoRequestTime < updateRequestIntervalSeconds) {
+        showAlert?.({
+          message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,
+          type: "danger",
+          duration: 3000,
+        });
+        return;
+      }
+
+      // send request to host
+      showAlert?.({
+        message: "Request sent to host.",
+        type: "success",
+        duration: 3000,
+      });
+      videoRequestState = "pending";
+      updateVideoRequestState(videoRequestState);
+
+      const userRequest = { id: socket.id, name: member, icon: "fa-video" };
+      await socket.emit("participantRequest", { userRequest, roomName });
+    } else if (response === 2) {
+      //if video permission is set to deny then show alert
+      showAlert?.({
+        message: "You cannot turn on your camera. Access denied by host.",
+        type: "danger",
+        duration: 3000,
+      });
+    } else {
+      //if video permission is set to allow then turn on video
+
+      //first check if permission is granted
+      if (!hasCameraPermission) {
+        if (checkMediaPermission) {
+          const statusCamera = await requestPermissionCamera();
+          if (statusCamera !== "granted") {
+            showAlert?.({
+              message: "Allow access to your camera or check if your camera is not being used by another application.",
+              type: "danger",
+              duration: 3000,
+            });
+            return;
+          }
+        }
+      }
+
+      let mediaConstraints = {};
+      let altMediaConstraints = {};
+      if (userDefaultVideoInputDevice) {
+        if (vidCons && vidCons.width && vidCons.height) {
+          mediaConstraints = {
+            video: {
+              deviceId: userDefaultVideoInputDevice,
+              facingMode: currentFacingMode,
+              ...vidCons,
+              frameRate: { ideal: frameRate },
+            },
+            audio: false,
+          };
+          altMediaConstraints = {
+            video: { ...vidCons, frameRate: { ideal: frameRate } },
+            audio: false,
+          };
+        } else {
+          mediaConstraints = {
+            video: { ...vidCons, frameRate: { ideal: frameRate } },
+            audio: false,
+          };
+          altMediaConstraints = {
+            video: { frameRate: { ideal: frameRate } },
+            audio: false,
+          };
+        }
+      } else {
+        if (vidCons && vidCons.width && vidCons.height) {
+          mediaConstraints = {
+            video: { ...vidCons, frameRate: { ideal: frameRate } },
+            audio: false,
+          };
+          altMediaConstraints = {
+            video: { ...vidCons, frameRate: { ideal: frameRate } },
+            audio: false,
+          };
+        } else {
+          mediaConstraints = {
+            video: { frameRate: { ideal: frameRate } },
+            audio: false,
+          };
+        }
+      }
+
+      await mediaDevices
+        .getUserMedia(mediaConstraints)
+        .then(async (stream) => {
+          await streamSuccessVideo({ stream, parameters });
+        })
+        .catch(async () => {
+          await mediaDevices
+            .getUserMedia(altMediaConstraints)
+            .then(async (stream) => {
+              await streamSuccessVideo({ stream, parameters });
+            })
+            .catch(async() => {
+              //remove frameRate from constraints
+              altMediaConstraints = {
+                video: { ...vidCons },
+                audio: false,
+              };
+              await mediaDevices
+              .getUserMedia(altMediaConstraints)
+              .then(async (stream) => {
+                await streamSuccessVideo({ stream, parameters });
+              }).catch(() => {
+
+              showAlert?.({
+                message:
+                  "Allow access to your camera or check if your camera is not being used by another application.",
+                type: "danger",
+                duration: 3000,
+              });
+
+            });
+          });
+        });
+    }
+  }
+};

package/src/methods/stream/index.ts

@@ -0,0 +1,3 @@
+export * from './switchAudio'
+export * from './switchVideo'
+export * from './switchVideoAlt'

package/src/methods/stream/switchAudio.ts

@@ -0,0 +1,73 @@
+import type { SwitchUserAudioType, SwitchUserAudioParameters } from '../../types/types';
+
+export interface SwitchAudioParameters extends SwitchUserAudioParameters {
+  defAudioID: string
+  userDefaultAudioInputDevice: string
+  prevAudioInputDevice: string
+  updateUserDefaultAudioInputDevice: (deviceId: string) => void
+  updatePrevAudioInputDevice: (deviceId: string) => void
+
+  // mediasfu functions
+  switchUserAudio: SwitchUserAudioType
+
+  getUpdatedAllParams: () => SwitchAudioParameters
+  [key: string]: any
+}
+
+export interface SwitchAudioOptions {
+  audioPreference: string
+  parameters: SwitchAudioParameters
+}
+
+// Export the type definition for the function
+export type SwitchAudioType = (options: SwitchAudioOptions) => Promise<void>
+
+/**
+ * Switches the audio input device based on user preference.
+ *
+ * @param {SwitchAudioOptions} options - The function parameters.
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ```typescript
+ * switchAudio({
+ *   audioPreference: "newAudioDeviceID",
+ *   parameters: {
+ *     defAudioID: "defaultAudioDeviceID",
+ *     userDefaultAudioInputDevice: "currentAudioDeviceID",
+ *     prevAudioInputDevice: "previousAudioDeviceID",
+ *     updateUserDefaultAudioInputDevice: (deviceId) => setUserDefaultAudio(deviceId),
+ *     updatePrevAudioInputDevice: (deviceId) => setPrevAudioDevice(deviceId),
+ *     switchUserAudio: switchUserAudioFunction,
+ *     getUpdatedAllParams: getUpdatedParamsFunction
+ *   }
+ * });
+ * ```
+ */
+
+export const switchAudio = async ({
+  audioPreference,
+  parameters
+}: SwitchAudioOptions): Promise<void> => {
+  let {
+    defAudioID,
+    userDefaultAudioInputDevice,
+    prevAudioInputDevice,
+    updateUserDefaultAudioInputDevice,
+    updatePrevAudioInputDevice,
+
+    //mediasfu functions
+    switchUserAudio
+  } = parameters
+
+  if (audioPreference !== defAudioID) {
+    prevAudioInputDevice = userDefaultAudioInputDevice
+    updatePrevAudioInputDevice(prevAudioInputDevice)
+    userDefaultAudioInputDevice = audioPreference
+    updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice)
+
+    if (defAudioID) {
+      await switchUserAudio({ audioPreference, parameters })
+    }
+  }
+}