mediasfu-shared 1.0.0

package/src/consumers/reUpdateInter.ts

@@ -0,0 +1,289 @@
+ 
+import { Participant, Stream, OnScreenChangesType, ReorderStreamsType, ChangeVidsType, OnScreenChangesParameters, ReorderStreamsParameters, ChangeVidsParameters, EventType } from "../types/types";
+export interface ReUpdateInterParameters extends OnScreenChangesParameters, ReorderStreamsParameters, ChangeVidsParameters {
+  screenPageLimit: number;
+  itemPageLimit: number;
+  reorderInterval: number;
+  fastReorderInterval: number;
+  eventType: EventType;
+  participants: Participant[];
+  allVideoStreams: (Participant | Stream)[];
+  shared: boolean;
+  shareScreenStarted: boolean;
+  adminNameStream?: string;
+  screenShareNameStream?: string;
+  updateMainWindow: boolean;
+  sortAudioLoudness: boolean;
+  lastReorderTime: number;
+  newLimitedStreams: (Participant | Stream)[];
+  newLimitedStreamsIDs: string[];
+  oldSoundIds: string[];
+  updateUpdateMainWindow: (value: boolean) => void;
+  updateSortAudioLoudness: (value: boolean) => void;
+  updateLastReorderTime: (value: number) => void;
+  updateNewLimitedStreams: (streams: (Participant | Stream)[]) => void;
+  updateNewLimitedStreamsIDs: (ids: string[]) => void;
+  updateOldSoundIds: (ids: string[]) => void;
+
+  // mediasfu functions
+  onScreenChanges: OnScreenChangesType;
+  reorderStreams: ReorderStreamsType;
+  changeVids: ChangeVidsType;
+
+  getUpdatedAllParams: () => ReUpdateInterParameters;
+  [key: string]: any;
+}
+
+export interface ReUpdateInterOptions {
+  name: string;
+  add?: boolean;
+  force?: boolean;
+  average?: number;
+  parameters: ReUpdateInterParameters;
+}
+
+// Export the type definition for the function
+export type ReUpdateInterType = (options: ReUpdateInterOptions) => Promise<void>;
+
+/**
+ * Updates the interaction state based on the provided options and parameters.
+ * 
+ * @param {ReUpdateInterOptions} options - The options for updating the interaction.
+ * @param {string} options.name - The name of the participant.
+ * @param {boolean} [options.add=false] - Whether to add the participant to the interaction.
+ * @param {boolean} [options.force=false] - Whether to force the update.
+ * @param {number} [options.average=127] - The average value used for determining reorder intervals.
+ * @param {Object} options.parameters - The parameters for updating the interaction.
+ * @param {number} options.parameters.screenPageLimit - The screen page limit.
+ * @param {number} options.parameters.itemPageLimit - The item page limit.
+ * @param {number} options.parameters.reorderInterval - The reorder interval.
+ * @param {number} options.parameters.fastReorderInterval - The fast reorder interval.
+ * @param {string} options.parameters.eventType - The type of event.
+ * @param {Array} options.parameters.participants - The list of participants.
+ * @param {Array} options.parameters.allVideoStreams - The list of all video streams.
+ * @param {boolean} options.parameters.shared - Whether the screen is shared.
+ * @param {boolean} options.parameters.shareScreenStarted - Whether screen sharing has started.
+ * @param {string} options.parameters.adminNameStream - The admin name stream.
+ * @param {string} options.parameters.screenShareNameStream - The screen share name stream.
+ * @param {boolean} options.parameters.updateMainWindow - Whether to update the main window.
+ * @param {boolean} options.parameters.sortAudioLoudness - Whether to sort audio by loudness.
+ * @param {number} options.parameters.lastReorderTime - The last reorder time.
+ * @param {Array} options.parameters.newLimitedStreams - The list of new limited streams.
+ * @param {Array} options.parameters.newLimitedStreamsIDs - The list of new limited stream IDs.
+ * @param {Array} options.parameters.oldSoundIds - The list of old sound IDs.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {Function} options.parameters.updateSortAudioLoudness - Function to update the audio loudness sorting.
+ * @param {Function} options.parameters.updateLastReorderTime - Function to update the last reorder time.
+ * @param {Function} options.parameters.updateNewLimitedStreams - Function to update the new limited streams.
+ * @param {Function} options.parameters.updateNewLimitedStreamsIDs - Function to update the new limited stream IDs.
+ * @param {Function} options.parameters.updateOldSoundIds - Function to update the old sound IDs.
+ * @param {Function} options.parameters.onScreenChanges - Function to handle screen changes.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {Function} options.parameters.changeVids - Function to change videos.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the interaction update is complete.
+ *
+ * @throws {Error} Throws an error if there is an issue during the updating process.
+ *
+ * @example
+ * ```typescript
+ * await reUpdateInter({
+ *   name: 'participant1',
+ *   add: true,
+ *   parameters: {
+ *     screenPageLimit: 4,
+ *     itemPageLimit: 2,
+ *     reorderInterval: 500,
+ *     fastReorderInterval: 200,
+ *     eventType: 'conference',
+ *     participants: [...],
+ *     allVideoStreams: [...],
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     adminNameStream: 'Admin',
+ *     screenShareNameStream: 'Screen Share',
+ *     updateMainWindow: true,
+ *     sortAudioLoudness: false,
+ *     lastReorderTime: Date.now(),
+ *     newLimitedStreams: [],
+ *     newLimitedStreamsIDs: [],
+ *     oldSoundIds: [],
+ *     updateUpdateMainWindow: (value) => { console.log('your logic') },
+ *     updateSortAudioLoudness: (value) => { console.log('your logic') },
+ *     updateLastReorderTime: (value) => { console.log('your logic') },
+ *     updateNewLimitedStreams: (streams) => { console.log('your logic') },
+ *     updateNewLimitedStreamsIDs: (ids) => { console.log('your logic') },
+ *     updateOldSoundIds: (ids) => { console.log('your logic') },
+ *     onScreenChanges: async (options) => { console.log('your logic') },
+ *     reorderStreams: async (options) => { console.log('your logic') },
+ *     changeVids: async (options) => { console.log('your logic') },
+ *   },
+ * });
+ * ```
+ */
+
+
+export async function reUpdateInter({
+  name,
+  add = false,
+  force = false,
+  average = 127,
+  parameters,
+}: ReUpdateInterOptions): Promise<void> {
+  let {
+    screenPageLimit,
+    itemPageLimit,
+    reorderInterval,
+    fastReorderInterval,
+    eventType,
+    participants,
+    allVideoStreams,
+    shared,
+    shareScreenStarted,
+    adminNameStream,
+    screenShareNameStream,
+    updateMainWindow,
+    sortAudioLoudness,
+    lastReorderTime,
+    newLimitedStreams,
+    newLimitedStreamsIDs,
+    oldSoundIds,
+    updateUpdateMainWindow,
+    updateSortAudioLoudness,
+    updateLastReorderTime,
+    updateNewLimitedStreams,
+    updateNewLimitedStreamsIDs,
+    updateOldSoundIds,
+
+    //mediasfu functions
+    onScreenChanges,
+    reorderStreams,
+    changeVids,
+  } = parameters;
+
+  if (eventType === "broadcast" || eventType === "chat") {
+    return;
+  }
+
+  let refLimit = screenPageLimit - 1;
+
+  if (!(shareScreenStarted || shared)) {
+    refLimit = itemPageLimit - 1;
+
+    if (add) {
+      const currentTime = Date.now();
+      if (
+        (currentTime - lastReorderTime >= reorderInterval && average > 128.5) ||
+        (average > 130 && currentTime - lastReorderTime >= fastReorderInterval)
+      ) {
+        lastReorderTime = currentTime;
+        sortAudioLoudness = true;
+        if (eventType === "conference") {
+          await onScreenChanges({ changed: true, parameters });
+        } else {
+          await reorderStreams({ add: false, screenChanged: true, parameters });
+        }
+        sortAudioLoudness = false;
+
+        updateSortAudioLoudness(sortAudioLoudness);
+        updateUpdateMainWindow(updateMainWindow);
+        updateLastReorderTime(lastReorderTime);
+
+        return;
+      }
+    }
+  }
+
+  let videoID: string | null = null;
+  if (shareScreenStarted || shared) {
+    if (add) {
+      const participant = participants.find((p) => p.name === name);
+      videoID = participant?.videoID ?? null;
+
+      if (!videoID) {
+        return;
+      }
+
+      if (!newLimitedStreamsIDs.includes(videoID)) {
+        //first check length of newLimitedStreams to not exceed refLimit, if so remove oldSoundID from newLimitedStreams
+        if (newLimitedStreams.length > refLimit) {
+          let oldoldSounds = [...oldSoundIds];
+          for (let i = 0; i < oldSoundIds.length; i++) {
+            if (newLimitedStreams.length > refLimit) {
+              // remove stream from newLimitedStreams
+              if (newLimitedStreams.length < screenPageLimit) {
+                return;
+              }
+              const currentId = oldSoundIds[i];
+              if (
+                currentId !== screenShareNameStream &&
+                currentId !== adminNameStream
+              ) {
+                newLimitedStreams = newLimitedStreams.filter(
+                  (stream) => stream.producerId !== currentId
+                );
+                newLimitedStreamsIDs = newLimitedStreamsIDs.filter(
+                  (id) => id !== currentId
+                );
+                oldoldSounds = oldoldSounds.filter((id) => id !== currentId);
+              }
+            }
+          }
+          oldSoundIds = [...oldoldSounds];
+        }
+
+        const stream = allVideoStreams.find(
+          (s) => s.producerId === videoID
+        );
+        if (stream && newLimitedStreams.length < screenPageLimit) {
+          newLimitedStreams.push(stream);
+          newLimitedStreamsIDs.push(videoID);
+          if (!oldSoundIds.includes(name)) {
+            oldSoundIds.push(name);
+          }
+          await changeVids({ screenChanged: true, parameters });
+        }
+      }
+    } else {
+      if (!force) {
+        try {
+          // remove stream from newLimitedStreams
+          if (newLimitedStreams.length < screenPageLimit) {
+            return;
+          }
+          newLimitedStreams = newLimitedStreams.filter(
+            (stream) => stream.producerId != videoID
+          );
+          newLimitedStreamsIDs = newLimitedStreamsIDs.filter(
+            (id) => id !== videoID
+          );
+          oldSoundIds = oldSoundIds.filter((id) => id !== name);
+          await changeVids({ parameters });
+        } catch  {
+          // do nothing
+         }
+      } else {
+        const participant = participants.find((p) => p.name === name);
+        if (participant?.muted) {
+          try {
+            newLimitedStreams = newLimitedStreams.filter(
+              (stream) => stream.producerId !== videoID
+            );
+            newLimitedStreamsIDs = newLimitedStreamsIDs.filter(
+              (id) => id !== videoID
+            );
+            oldSoundIds = oldSoundIds.filter((id) => id !== name);
+            await changeVids({ parameters });
+          } catch { 
+            // do nothing
+          }
+        }
+      }
+    }
+
+    updateNewLimitedStreams(newLimitedStreams);
+    updateNewLimitedStreamsIDs(newLimitedStreamsIDs);
+    updateOldSoundIds(oldSoundIds);
+  }
+}
+

package/src/consumers/readjust.ts

@@ -0,0 +1,170 @@
+
+ 
+import { PrepopulateUserMediaType, PrepopulateUserMediaParameters, EventType } from '../types/types';
+export interface ReadjustParameters extends PrepopulateUserMediaParameters {
+  eventType: EventType;
+  shareScreenStarted: boolean;
+  shared: boolean;
+  mainHeightWidth: number;
+  prevMainHeightWidth: number;
+  hostLabel: string;
+  first_round: boolean;
+  lock_screen: boolean;
+  updateMainHeightWidth: (value: number) => void;
+
+  // mediasfu functions
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  getUpdatedAllParams: () => ReadjustParameters;
+  [key: string]: any;
+}
+
+export interface ReadjustOptions {
+  n: number;
+  state: number;
+  parameters: ReadjustParameters;
+}
+
+// Export the type definition for the function
+export type ReadjustType = (options: ReadjustOptions) => Promise<void>;
+
+/**
+ * Adjusts the layout parameters based on the provided options.
+ *
+ * @param {ReadjustOptions} options - The options for readjusting the layout.
+ * @param {number} options.n - The number of participants or elements.
+ * @param {number} options.state - The current state of the layout.
+ * @param {object} options.parameters - The parameters for the layout adjustment.
+ * @param {function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.eventType - The type of event (e.g., "broadcast", "chat", "conference").
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.parameters.shared - Indicates if content is being shared.
+ * @param {number} options.parameters.mainHeightWidth - The main height and width value.
+ * @param {number} options.parameters.prevMainHeightWidth - The previous main height and width value.
+ * @param {string} options.parameters.hostLabel - The label for the host.
+ * @param {boolean} options.parameters.first_round - Indicates if it is the first round.
+ * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+ * @param {function} options.parameters.updateMainHeightWidth - Function to update the main height and width.
+ * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @returns {Promise<void>} A promise that resolves when the layout adjustment is complete.
+ * @throws {Error} Throws an error if there is an issue updating the grid sizes.
+ *
+ * @example
+ * ```typescript
+ * await readjust({
+ *   n: 5,
+ *   state: 1,
+ *   parameters: {
+ *     eventType: 'conference',
+ *     shareScreenStarted: false,
+ *     shared: false,
+ *     mainHeightWidth: 100,
+ *     prevMainHeightWidth: 80,
+ *     hostLabel: 'Host Name',
+ *     first_round: false,
+ *     lock_screen: false,
+ *     updateMainHeightWidth: updateMainHeightWidthFunction,
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *   },
+ * });
+ * ```
+ */
+
+export async function readjust({ n, state, parameters }: ReadjustOptions): Promise<void> {
+  let { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  try {
+    // Destructure parameters
+    let {
+      eventType,
+      shareScreenStarted,
+      shared,
+      mainHeightWidth,
+      prevMainHeightWidth,
+      hostLabel,
+      first_round,
+      lock_screen,
+      updateMainHeightWidth,
+      prepopulateUserMedia,
+    } = parameters;
+
+    if (state === 0) {
+      prevMainHeightWidth = mainHeightWidth;
+    }
+
+    let val1 = 6;
+    let val2 = 12 - val1;
+    let cal1 = Math.floor((val1 / 12) * 100);
+    let cal2 = 100 - cal1;
+
+    if (eventType === "broadcast") {
+      val1 = 0;
+      val2 = 12 - val1;
+
+      if (n === 0) {
+        val1 = 0;
+        val2 = 12 - val1;
+      }
+    } else if (
+      eventType === "chat" ||
+      (eventType === "conference" && !(shareScreenStarted || shared))
+    ) {
+      val1 = 12;
+      val2 = 12 - val1;
+    } else {
+      if (shareScreenStarted || shared) {
+        val2 = 10;
+        val1 = 12 - val2;
+      } else {
+        if (n === 0) {
+          val1 = 1;
+          val2 = 12 - val1;
+        } else if (n >= 1 && n < 4) {
+          val1 = 4;
+          val2 = 12 - val1;
+        } else if (n >= 4 && n < 6) {
+          val1 = 6;
+          val2 = 12 - val1;
+        } else if (n >= 6 && n < 9) {
+          val1 = 6;
+          val2 = 12 - val1;
+        } else if (n >= 9 && n < 12) {
+          val1 = 6;
+          val2 = 12 - val1;
+        } else if (n >= 12 && n < 20) {
+          val1 = 8;
+          val2 = 12 - val1;
+        } else if (n >= 20 && n < 50) {
+          val1 = 8;
+          val2 = 12 - val1;
+        } else {
+          val1 = 10;
+          val2 = 12 - val1;
+        }
+      }
+    }
+
+    if (state === 0) {
+      mainHeightWidth = val2;
+    }
+
+    cal1 = Math.floor((val1 / 12) * 100);
+    cal2 = 100 - cal1;
+
+    updateMainHeightWidth(cal2);
+
+    if (prevMainHeightWidth !== mainHeightWidth) {
+      if (!lock_screen && !shared) {
+        await prepopulateUserMedia({ name: hostLabel, parameters });
+      } else if (!first_round) {
+        await prepopulateUserMedia({ name: hostLabel, parameters });
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.log("Error updating grid sizes:", error.message);
+    } else {
+      console.log("Error updating grid sizes:", error);
+    }
+  }
+}

package/src/consumers/receiveAllPipedTransports.ts

@@ -0,0 +1,77 @@
+
+import { Socket } from "socket.io-client";
+import { GetPipedProducersAltType, GetPipedProducersAltParameters } from "../types/types";
+
+export interface ReceiveAllPipedTransportsParameters extends GetPipedProducersAltParameters {
+  roomName: string;
+  member: string;
+
+  // mediasfu functions
+  getPipedProducersAlt: GetPipedProducersAltType;
+  [key: string]: any;
+}
+
+export interface ReceiveAllPipedTransportsOptions {
+  nsock: Socket;
+  community?: boolean;
+  parameters: ReceiveAllPipedTransportsParameters;
+}
+
+// Export the type definition for the function
+export type ReceiveAllPipedTransportsType = (options: ReceiveAllPipedTransportsOptions) => Promise<void>;
+
+/**
+ * Receives all piped transports by emitting an event to the server and processing the response.
+ *
+ * @param {ReceiveAllPipedTransportsOptions} options - The options for receiving all piped transports.
+ * @param {Socket} options.nsock - The socket instance used for communication.
+ * @param {boolean} options.community - Whether the room is a community edition room.
+ * @param {ReceiveAllPipedTransportsParameters} options.parameters - The parameters for the operation.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {string} options.parameters.member - The member identifier.
+ * @param {Function} options.parameters.getPipedProducersAlt - The function to get piped producers for a given level.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @throws Will log an error message if the operation fails.
+ *
+ * @example
+ * ```typescript
+ * await receiveAllPipedTransports({
+ *   nsock: socketInstance,
+ *   community: false,
+ *   parameters: {
+ *     roomName: 'Room1',
+ *     member: 'Member1',
+ *     getPipedProducersAlt: getPipedProducersAltFunction,
+ *   },
+ * });
+ * ```
+ */
+
+export const receiveAllPipedTransports = async ({ nsock, community=false, parameters }: ReceiveAllPipedTransportsOptions): Promise<void> => {
+  try {
+    // Destructure parameters
+    const { roomName, member, getPipedProducersAlt } = parameters;
+    const emitName = community ? "createReceiveAllTransports" : "createReceiveAllTransportsPiped";
+    const emitData = community ? { islevel:'0' } : { roomName, member };
+    // Emit createReceiveAllTransportsPiped event to the server
+    await nsock.emit(
+      emitName,
+      emitData,
+      async ({ producersExist }: { producersExist: boolean }) => {
+        // Array of options representing different levels
+        const options = ["0", "1", "2"];
+
+        // If producers exist, loop through each level and get producers
+        if (producersExist) {
+          for (const islevel of options) {
+            await getPipedProducersAlt({ nsock, community, islevel, parameters });
+          }
+        }
+      }
+    );
+  } catch (error) {
+    console.log("receiveAllPipedTransports error", error);
+  }
+};

package/src/consumers/receiveRoomMessages.ts

@@ -0,0 +1,55 @@
+import { Socket } from "socket.io-client";
+import { Message } from "../types/types";
+export interface ReceiveRoomMessagesOptions {
+  socket: Socket;
+  roomName: string;
+  updateMessages: (messages: Message[]) => void;
+}
+
+// Export the type definition for the function
+export type ReceiveRoomMessagesType = (options: ReceiveRoomMessagesOptions) => Promise<void>;
+
+/**
+ * Retrieves messages from a specified room and updates the message state.
+ *
+ * @param {ReceiveRoomMessagesOptions} options - The options for receiving room messages.
+ * @param {Socket} options.socket - The socket instance used for communication.
+ * @param {string} options.roomName - The name of the room from which to retrieve messages.
+ * @param {Function} options.updateMessages - Function to update the state with retrieved messages.
+ *
+ * @returns {Promise<void>} A promise that resolves when the messages have been retrieved and updated.
+ *
+ * @throws Will log an error message if there is an issue retrieving the messages.
+ *
+ * @example
+ * ```typescript
+ * await receiveRoomMessages({
+ *   socket: socketInstance,
+ *   roomName: 'Room1',
+ *   updateMessages: (messages) => console.log(messages),
+ * });
+ * ```
+ */
+
+
+export async function receiveRoomMessages({ 
+  socket,
+  roomName,
+  updateMessages,
+}: ReceiveRoomMessagesOptions): Promise<void> {
+
+  try {
+    // Retrieve messages from the server
+    socket.emit("getMessage", { roomName }, async ({ messages_ }: { messages_: Message[]; }) => {
+      updateMessages(messages_);
+    });
+  } catch (error) {
+    // Handle errors if any
+    if (error instanceof Error) {
+      console.log("Error tuning messages:", error.message);
+    } else {
+      console.log("Error tuning messages:", error);
+    }
+  }
+}
+