mediasfu-shared 1.0.0

package/src/consumers/reorderStreams.ts

@@ -0,0 +1,246 @@
+ 
+import { Participant, Stream, ChangeVidsParameters, ChangeVidsType } from "../types/types";
+
+export interface ReorderStreamsParameters extends ChangeVidsParameters {
+  allVideoStreams: (Stream | Participant)[];
+  participants: Participant[];
+  oldAllStreams: (Stream | Participant)[];
+  screenId?: string;
+  adminVidID?: string;
+  newLimitedStreams: (Stream | Participant)[];
+  newLimitedStreamsIDs: string[];
+  activeSounds: string[];
+  screenShareIDStream?: string;
+  screenShareNameStream?: string;
+  adminIDStream?: string;
+  adminNameStream?: string;
+  updateNewLimitedStreams: (streams: (Stream | Participant)[]) => void;
+  updateNewLimitedStreamsIDs: (ids: string[]) => void;
+  updateActiveSounds: (sounds: string[]) => void;
+  updateScreenShareIDStream: (id: string) => void;
+  updateScreenShareNameStream: (name: string) => void;
+  updateAdminIDStream: (id: string) => void;
+  updateAdminNameStream: (name: string) => void;
+  updateYouYouStream: (streams: (Stream | Participant)[]) => void;
+
+  // mediasfu functions
+  changeVids: ChangeVidsType;
+  getUpdatedAllParams: () => ReorderStreamsParameters;
+  [key: string]: any;
+}
+
+export interface ReorderStreamsOptions {
+  add?: boolean;
+  screenChanged?: boolean;
+  parameters: ReorderStreamsParameters;
+}
+
+
+export type ReorderStreamsType = (options: ReorderStreamsOptions) => Promise<void>;
+
+/**
+ * Reorders the video streams based on the provided options and updates the UI accordingly.
+ *
+ * @param {ReorderStreamsOptions} options - The options for reordering streams.
+ * @param {boolean} [options.add=false] - Whether to add new streams or not.
+ * @param {boolean} [options.screenChanged=false] - Whether the screen has changed or not.
+ * @param {Object} options.parameters - The parameters required for reordering streams.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {Array} options.parameters.allVideoStreams - Array of all video streams.
+ * @param {Array} options.parameters.participants - Array of participants.
+ * @param {Array} options.parameters.oldAllStreams - Array of old streams.
+ * @param {string} options.parameters.screenId - ID of the screen.
+ * @param {string} options.parameters.adminVidID - ID of the admin video.
+ * @param {Array} options.parameters.newLimitedStreams - Array of new limited streams.
+ * @param {Array} options.parameters.newLimitedStreamsIDs - Array of new limited stream IDs.
+ * @param {Array} options.parameters.activeSounds - Array of active sounds.
+ * @param {string} options.parameters.screenShareIDStream - ID of the screen share stream.
+ * @param {string} options.parameters.screenShareNameStream - Name of the screen share stream.
+ * @param {string} options.parameters.adminIDStream - ID of the admin stream.
+ * @param {string} options.parameters.adminNameStream - Name of the admin stream.
+ * @param {Function} options.parameters.updateNewLimitedStreams - Function to update new limited streams.
+ * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update new limited stream IDs.
+ * @param {Function} options.parameters.updateActiveSounds - Function to update active sounds.
+ * @param {Function} options.parameters.updateScreenShareIDStream - Function to update screen share ID stream.
+ * @param {Function} options.parameters.updateScreenShareNameStream - Function to update screen share name stream.
+ * @param {Function} options.parameters.updateAdminIDStream - Function to update admin ID stream.
+ * @param {Function} options.parameters.updateAdminNameStream - Function to update admin name stream.
+ * @param {Function} options.parameters.updateYouYouStream - Function to update YouYou stream.
+ * @param {Function} options.parameters.changeVids - Function to reflect changes on the UI.
+ *
+ * @returns {Promise<void>} A promise that resolves when the reordering is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue updating the streams.
+ *
+ * @example
+ * ```typescript
+ * await reorderStreams({
+ *   add: true,
+ *   screenChanged: false,
+ *   parameters: {
+ *     allVideoStreams: [...],
+ *     participants: [...],
+ *     // additional parameters...
+ *   },
+ * });
+ * ```
+ */
+
+export const reorderStreams = async ({
+  add = false,
+  screenChanged = false,
+  parameters,
+}: ReorderStreamsOptions): Promise<void> => {
+  const { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  let {
+    allVideoStreams,
+    participants,
+    oldAllStreams,
+    screenId,
+    adminVidID,
+    newLimitedStreams,
+    newLimitedStreamsIDs,
+    activeSounds,
+    screenShareIDStream,
+    screenShareNameStream,
+    adminIDStream,
+    adminNameStream,
+    updateNewLimitedStreams,
+    updateNewLimitedStreamsIDs,
+    updateActiveSounds,
+    updateScreenShareIDStream,
+    updateScreenShareNameStream,
+    updateAdminIDStream,
+    updateAdminNameStream,
+    updateYouYouStream,
+
+    //mediasfu functions
+    changeVids,
+  } = parameters;
+
+  // function to reorder streams on the ui
+  if (!add) {
+    newLimitedStreams = [];
+    newLimitedStreamsIDs = [];
+    activeSounds = [];
+  }
+
+  const youyou = allVideoStreams.filter((stream) => stream.producerId === "youyou");
+  const admin = participants.filter((participant) => participant.islevel === "2");
+
+  if (admin.length > 0) {
+    adminVidID = admin[0].videoID;
+  } else {
+    adminVidID = "";
+  }
+
+  if (adminVidID) {
+    const adminStream = allVideoStreams.find((stream) => stream.producerId === adminVidID);
+
+    if (!add) {
+      newLimitedStreams = [...newLimitedStreams, ...youyou];
+      newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+    } else {
+      const youyouStream = newLimitedStreams.find((stream) => stream.producerId === "youyou");
+
+      if (!youyouStream) {
+        newLimitedStreams = [...newLimitedStreams, ...youyou];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+      }
+    }
+
+    if (adminStream) {
+      adminIDStream = adminVidID;
+
+      if (!add) {
+        newLimitedStreams = [...newLimitedStreams, adminStream];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];
+      } else {
+        const adminStreamer = newLimitedStreams.find((stream) => stream.producerId === adminVidID);
+
+        if (!adminStreamer) {
+          newLimitedStreams = [...newLimitedStreams, adminStream];
+          newLimitedStreamsIDs = [...newLimitedStreamsIDs, adminStream.producerId];
+        }
+      }
+    } else {
+      const oldAdminStream = oldAllStreams.find((stream) => stream.producerId === adminVidID);
+
+      if (oldAdminStream) {
+        //add it to the allVideoStream
+
+        adminIDStream = adminVidID;
+        adminNameStream = admin[0].name;
+
+        if (!add) {
+          newLimitedStreams = [...newLimitedStreams, oldAdminStream];
+          newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];
+        } else {
+          const adminStreamer = newLimitedStreams.find((stream) => stream.producerId === adminVidID);
+
+          if (!adminStreamer) {
+            newLimitedStreams = [...newLimitedStreams, oldAdminStream];
+            newLimitedStreamsIDs = [...newLimitedStreamsIDs, oldAdminStream.producerId];
+          }
+        }
+      }
+    }
+
+    const screenParticipant = participants.filter((participant) => participant.ScreenID === screenId);
+
+    if (screenParticipant.length > 0) {
+      const screenParticipantVidID = screenParticipant[0].videoID;
+      const screenParticipantVidID_ = newLimitedStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+
+      if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {
+        screenShareIDStream = screenParticipantVidID;
+        screenShareNameStream = screenParticipant[0].name;
+        const screenParticipantVidID__ = allVideoStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+        newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...screenParticipantVidID__.map((stream) => stream.producerId)];
+      }
+    }
+  } else {
+    if (!add) {
+      newLimitedStreams = [...newLimitedStreams, ...youyou];
+      newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+    } else {
+      const youyouStream = newLimitedStreams.find((stream) => stream.producerId === "youyou");
+
+      if (!youyouStream) {
+        newLimitedStreams = [...newLimitedStreams, ...youyou];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...youyou.map((stream) => stream.producerId)];
+      }
+    }
+
+    const screenParticipant = participants.filter((participant) => participant.ScreenID === screenId);
+
+    if (screenParticipant.length > 0) {
+      const screenParticipantVidID = screenParticipant[0].videoID;
+      const screenParticipantVidID_ = newLimitedStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+
+      if (screenParticipantVidID_?.length < 1 && screenParticipantVidID) {
+        screenShareIDStream = screenParticipantVidID;
+        screenShareNameStream = screenParticipant[0].name;
+        const screenParticipantVidID__ = allVideoStreams.filter((stream) => stream.producerId === screenParticipantVidID);
+        newLimitedStreams = [...newLimitedStreams, ...screenParticipantVidID__];
+        newLimitedStreamsIDs = [...newLimitedStreamsIDs, ...screenParticipantVidID__.map((stream) => stream.producerId)];
+      }
+    }
+  }
+
+  updateNewLimitedStreams(newLimitedStreams);
+  updateNewLimitedStreamsIDs(newLimitedStreamsIDs);
+  updateActiveSounds(activeSounds);
+  updateScreenShareIDStream(screenShareIDStream!);
+  updateScreenShareNameStream(screenShareNameStream!);
+  updateAdminIDStream(adminIDStream!);
+  updateAdminNameStream(adminNameStream!);
+  updateYouYouStream(youyou);
+
+  //reflect the changes on the ui
+  await changeVids({ screenChanged, parameters });
+};
+

package/src/consumers/requestScreenShare.ts

@@ -0,0 +1,103 @@
+import { Socket } from "socket.io-client";
+import { ShowAlert, StartShareScreenType, StartShareScreenParameters } from "../types/types";
+
+export interface RequestScreenShareParameters extends StartShareScreenParameters {
+  socket: Socket;
+  showAlert?: ShowAlert
+  localUIMode: boolean;
+  targetResolution?: string;
+  targetResolutionHost?: string;
+  
+
+  // mediasfu functions
+  startShareScreen: StartShareScreenType;
+  getUpdatedAllParams : () => RequestScreenShareParameters;
+  [key: string]: any;
+}
+
+export interface RequestScreenShareOptions {
+  parameters: RequestScreenShareParameters;
+}
+
+// Export the type definition for the function
+export type RequestScreenShareType = (options: RequestScreenShareOptions) => Promise<void>;
+
+/**
+ * Requests to start screen sharing.
+ *
+ * @param {RequestScreenShareOptions} options - The options for requesting screen share.
+ * @param {Object} options.parameters - The parameters for the screen share request.
+ * @param {Socket} options.parameters.socket - The socket instance to communicate with the server.
+ * @param {Function} [options.parameters.showAlert] - Optional function to show alerts to the user.
+ * @param {boolean} options.parameters.localUIMode - Indicates if the user is in local UI mode.
+ * @param {string} [options.parameters.targetResolution] - The target resolution for screen sharing.
+ * @param {string} [options.parameters.targetResolutionHost] - The target resolution for screen sharing for the host.
+ * @param {Function} options.parameters.startShareScreen - Function to start screen sharing.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen share request is processed.
+ *
+ * @throws {Error} Throws an error if there is an issue during the screen share request process.
+ *
+ * @example
+ * ```typescript
+ * await requestScreenShare({
+ *   parameters: {
+ *     socket: socketInstance,
+ *     localUIMode: false,
+ *     targetResolution: 'fhd',
+ *     startShareScreen: startShareScreenFunction,
+ *     // other parameters...
+ *   },
+ * });
+ * ```
+ */
+
+export async function requestScreenShare({ parameters }: RequestScreenShareOptions): Promise<void> {
+  try {
+    // Destructure parameters
+    let {
+      socket,
+      showAlert,
+      localUIMode,
+      targetResolution = 'hd',
+      targetResolutionHost = 'hd',
+
+      //mediasfu functions
+      startShareScreen,
+    } = parameters;
+
+    let targetWidth = 1280
+    let targetHeight = 720
+
+    if (targetResolution == 'qhd' || targetResolutionHost == 'qhd') {
+      targetWidth = 2560
+      targetHeight = 1440
+    } else if (targetResolution == 'fhd' || targetResolutionHost == 'fhd') {
+      targetWidth = 1920
+      targetHeight = 1080
+    } 
+
+    // Check if the user is in local UI mode
+    if (localUIMode === true) {
+      await startShareScreen({ parameters });
+      return;
+    }
+
+    socket.emit("requestScreenShare", async ({ allowScreenShare }: { allowScreenShare: boolean; }) => {
+      if (!allowScreenShare) {
+        // Send an alert to the user
+        showAlert?.({
+          message: "You are not allowed to share screen",
+          type: "danger",
+          duration: 3000,
+        });
+      } else {
+        await startShareScreen({ parameters: { ...parameters, targetWidth, targetHeight } });
+      }
+    });
+  } catch (error) {
+    // Handle errors during the process of requesting screen share
+    // throw new Error(`Error during requesting screen share: ${error.message}`);
+    console.log("Error during requesting screen share: ", error);
+  }
+}

package/src/consumers/resumePauseAudioStreams.ts

@@ -0,0 +1,174 @@
+import { Participant, Stream, ProcessConsumerTransportsAudioType, ProcessConsumerTransportsAudioParameters, Transport, BreakoutParticipant, EventType } from '../types/types';
+
+export interface ResumePauseAudioStreamsParameters extends ProcessConsumerTransportsAudioParameters {
+  breakoutRooms: BreakoutParticipant[][];
+  ref_participants: Participant[];
+  allAudioStreams: (Stream | Participant)[];
+  participants: Participant[];
+  islevel: string;
+  eventType: EventType;
+  consumerTransports: Transport[];
+  limitedBreakRoom: BreakoutParticipant[];
+  hostNewRoom: number;
+  member: string;
+  updateLimitedBreakRoom: (limitedBreakRoom: BreakoutParticipant[]) => void;
+
+  // mediasfu functions
+  processConsumerTransportsAudio: ProcessConsumerTransportsAudioType;
+  getUpdatedAllParams: () => ResumePauseAudioStreamsParameters;
+  [key: string]: any;
+}
+
+export interface ResumePauseAudioStreamsOptions {
+  breakRoom?: number;
+  inBreakRoom?: boolean;
+  parameters: ResumePauseAudioStreamsParameters;
+}
+
+// Export the type definition for the function
+export type ResumePauseAudioStreamsType = (
+  options: ResumePauseAudioStreamsOptions
+) => Promise<void>;
+
+/**
+ * Resumes or pauses audio streams based on the provided options.
+ *
+ * @param {ResumePauseAudioStreamsOptions} options - The options for resuming or pausing audio streams.
+ * @param {number} [options.breakRoom=-1] - The ID of the break room.
+ * @param {boolean} [options.inBreakRoom=false] - Indicates if the participant is in a break room.
+ * @param {ResumePauseAudioStreamsParameters} options.parameters - The parameters required for processing audio streams.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio streams have been processed.
+ *
+ * @throws Will log an error message if there is an issue processing the audio streams.
+ *
+ * @example
+ * ```typescript
+ * await resumePauseAudioStreams({
+ *   breakRoom: 1,
+ *   inBreakRoom: true,
+ *   parameters: {
+ *     // ...parameters here
+ *   },
+ * });
+ * ```
+ */
+
+export const resumePauseAudioStreams = async ({
+  breakRoom = -1,
+  inBreakRoom = false,
+  parameters,
+}: ResumePauseAudioStreamsOptions): Promise<void> => {
+  const { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  const {
+    breakoutRooms,
+    ref_participants,
+    allAudioStreams,
+    participants,
+    islevel,
+    eventType,
+    consumerTransports,
+    hostNewRoom,
+    member,
+    updateLimitedBreakRoom,
+    processConsumerTransportsAudio,
+  } = parameters;
+
+  let room: BreakoutParticipant[] = [];
+  let currentStreams: (Stream | Participant)[] = [];
+  // Determine the room based on breakout status
+  if (inBreakRoom && breakRoom !== -1) {
+    room = breakoutRooms[breakRoom];
+  } else {
+    room = ref_participants
+    .filter((participant) =>
+      !breakoutRooms
+        .flat()
+        .map((obj) => obj.name)
+        .includes(participant!.name)
+    )
+    .map(({ name, breakRoom }) => ({ name, breakRoom }));
+  
+  }
+
+  updateLimitedBreakRoom(room);
+
+  try {
+    let addHostAudio = false;
+
+    if (islevel !== "2" && eventType === "conference") {
+      const roomMember = breakoutRooms.find((r) =>
+        r.find((p) => p.name === member)
+      );
+      let memberBreakRoom = -1;
+      if (roomMember) {
+        memberBreakRoom = breakoutRooms.indexOf(roomMember);
+      }
+
+      if (
+        (inBreakRoom && breakRoom !== hostNewRoom) ||
+        (!inBreakRoom && hostNewRoom !== -1 && hostNewRoom !== memberBreakRoom)
+      ) {
+        const host = participants.find((obj) => obj.islevel === "2");
+        // Remove the host from the room
+        room = room.filter((participant) => participant.name !== host?.name);
+      } else {
+        if (
+          (inBreakRoom && breakRoom === hostNewRoom) ||
+          (!inBreakRoom && hostNewRoom === -1) ||
+          (!inBreakRoom &&
+            hostNewRoom === memberBreakRoom &&
+            memberBreakRoom !== -1)
+        ) {
+          addHostAudio = true;
+        }
+      }
+    }
+
+    for (let participant of room) {
+      let streams = allAudioStreams.filter((stream) => {
+        if (
+          (Object.prototype.hasOwnProperty.call(stream, "producerId") && stream.producerId) ||
+          (Object.prototype.hasOwnProperty.call(stream, "audioID") && stream.audioID)
+        ) {
+          let producerId = stream.producerId || stream.audioID;
+          let matchingParticipant = ref_participants.find(
+            (obj) => obj.audioID == producerId
+        );
+          return (
+            matchingParticipant && matchingParticipant.name == participant.name
+          );
+        }
+        // Return false if the stream doesn't meet the criteria
+        return false;
+      });
+
+      currentStreams.push(...streams);
+    }
+
+    // If webinar, add the host audio stream if it is not in the currentStreams
+    if (islevel !== "2" && (eventType === "webinar" || addHostAudio)) {
+      const host = participants.find((obj) => obj.islevel === "2");
+      const hostStream = allAudioStreams.find(
+        (obj) => obj.producerId === host?.audioID
+      );
+      if (hostStream && !currentStreams.includes(hostStream)) {
+        currentStreams.push(hostStream);
+        if (!room.map((obj) => obj.name).includes(host?.name ?? "")) {
+          room.push({ name: host?.name || "", breakRoom: -1 });
+        }
+        updateLimitedBreakRoom(room);
+      }
+    }
+
+    await processConsumerTransportsAudio({
+      consumerTransports,
+      lStreams: currentStreams,
+      parameters,
+    });
+  } catch (error) {
+    console.log('Error in resumePauseAudioStreams:', error);
+  }
+};

package/src/consumers/resumePauseStreams.ts

@@ -0,0 +1,110 @@
+import { Participant, Transport, Stream } from "../types/types";
+
+export interface ResumePauseStreamsParameters {
+  participants: Participant[];
+  dispActiveNames: string[];
+  remoteScreenStream: Stream[];
+  consumerTransports: Transport[];
+  screenId?: string;
+  islevel: string;
+
+  // mediasfu functions
+  getUpdatedAllParams: () => ResumePauseStreamsParameters;
+  [key: string]: any;
+}
+
+export interface ResumePauseStreamsOptions {
+  parameters: ResumePauseStreamsParameters;
+}
+
+// Export the type definition for the function
+export type ResumePauseStreamsType = (options: ResumePauseStreamsOptions) => Promise<void>;
+
+/**
+ * Resumes or pauses streams based on the provided parameters.
+ *
+ * @param {ResumePauseStreamsOptions} options - The options for resuming or pausing streams.
+ * @param {Object} options.parameters - The parameters for the function.
+ * @param {Array} options.parameters.participants - The list of participants.
+ * @param {Array} options.parameters.dispActiveNames - The list of active display names.
+ * @param {Array} options.parameters.consumerTransports - The list of consumer transports.
+ * @param {string} [options.parameters.screenId] - The screen producer ID.
+ * @param {string} options.parameters.islevel - The level of the user.
+ *
+ * @returns {Promise<void>} A promise that resolves when the streams have been resumed or paused.
+ *
+ * @throws Will throw an error if there is an issue during the process of resuming or pausing streams.
+ *
+ * @example
+ * ```typescript
+ * await resumePauseStreams({
+ *   parameters: {
+ *     participants: participantArray,
+ *     dispActiveNames: ['user1', 'user2'],
+ *     consumerTransports: transportArray,
+ *     screenId: 'screen-123',
+ *     islevel: '1',
+ *   },
+ * });
+ * ```
+ */
+
+export async function resumePauseStreams({
+  parameters,
+}: ResumePauseStreamsOptions): Promise<void> {
+  try {
+    // Destructure parameters
+    const { participants, dispActiveNames, consumerTransports, screenId, islevel } = parameters;
+
+    // Get the videoID of the host (islevel=2)
+    const host = participants.find((obj) => obj.islevel === "2");
+    const hostVideoID = host ? host.videoID : null;
+
+    // Get videoIDs of participants in dispActiveNames and screenproducerId
+    const videosIDs = dispActiveNames.map((name) => {
+      const participant = participants.find((obj) => obj.name === name);
+      return participant ? participant.videoID : null;
+    });
+
+    // Add screenproducerId to allVideoIDs if it's not null or empty
+    if (screenId) {
+      videosIDs.push(screenId);
+    }
+
+    // Add hostVideoID to allVideoIDs if it's not null or empty (only if the user is not the host)
+    if (islevel !== "2" && hostVideoID) {
+      videosIDs.push(hostVideoID);
+    }
+
+    // Remove null or empty videoIDs
+    const allVideoIDs = videosIDs.filter(
+      (videoID): videoID is string => videoID !== null && videoID !== ""
+    );
+
+    if (allVideoIDs.length > 0) {
+      // Get consumer transports with producerId in allVideoIDs
+      const consumerTransportsToResume = consumerTransports.filter(
+        (transport) =>
+          allVideoIDs.includes(transport.producerId) &&
+          transport.consumer.kind !== "audio"
+      );
+
+      // Resume all consumerTransportsToResume
+      for (const transport of consumerTransportsToResume) {
+         transport.socket_.emit(
+          "consumer-resume",
+          { serverConsumerId: transport.serverConsumerTransportId },
+          async ({ resumed }: { resumed: boolean }) => {
+            if (resumed) {
+               transport.consumer.resume();
+            }
+          }
+        );
+      }
+    }
+  } catch (error) {
+    console.log("Error during resuming or pausing streams: ", error);
+    // Handle errors during the process of resuming or pausing streams
+  }
+}
+