mediasfu-shared 1.0.0

package/src/consumers/compareActiveNames.ts

@@ -0,0 +1,122 @@
+import { TriggerType, TriggerParameters } from '../types/types';
+
+export interface CompareActiveNamesParameters extends TriggerParameters {
+  activeNames: string[];
+  prevActiveNames: string[];
+  updateActiveNames: (activeNames: string[]) => void;
+  updatePrevActiveNames: (prevActiveNames: string[]) => void;
+
+  // mediasfu functions
+  trigger: TriggerType;
+  getUpdatedAllParams: () => CompareActiveNamesParameters;
+  [key: string]: any;
+}
+
+export interface CompareActiveNamesOptions {
+  restart?: boolean;
+  parameters: CompareActiveNamesParameters;
+}
+
+// Export the type definition for the function
+export type CompareActiveNamesType = (options: CompareActiveNamesOptions) => Promise<void>;
+
+/**
+ * Compares the current active names with the previous active names and triggers an action if there are changes.
+ *
+ * @param {CompareActiveNamesOptions} options - The options for comparing active names.
+ * @param {boolean} [options.restart=false] - Whether to restart the comparison.
+ * @param {CompareActiveNamesParameters} options.parameters - The parameters for the comparison.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string[]} options.parameters.activeNames - The current active names.
+ * @param {string[]} options.parameters.prevActiveNames - The previous active names.
+ * @param {Function} options.parameters.updatePrevActiveNames - Function to update the previous active names.
+ * @param {Function} options.parameters.trigger - Function to trigger an action when names change.
+ *
+ * @returns {Promise<void>} A promise that resolves when the comparison is complete.
+ *
+ * @throws Will log an error message if an error occurs during the comparison.
+ * 
+ * @example
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *     activeNames: ['name1', 'name2'],
+ *     prevActiveNames: ['name1'],
+ *     updatePrevActiveNames: updatePrevActiveNamesFunction,
+ *     trigger: triggerFunction,
+ *   },
+ * };
+ * 
+ * compareActiveNames(options)
+ *   .then(() => {
+ *     console.log('Active names compared successfully');
+ *   });
+ */
+
+export async function compareActiveNames({
+  restart = false,
+  parameters,
+}: CompareActiveNamesOptions): Promise<void> {
+  try {
+    const { getUpdatedAllParams } = parameters;
+    parameters = getUpdatedAllParams();
+
+    const {
+      activeNames,
+      prevActiveNames,
+      updatePrevActiveNames,
+
+      //mediasfu functions
+      trigger,
+    } = parameters;
+
+    // Restart the comparison if needed
+    if (restart) {
+      await trigger({ ref_ActiveNames: activeNames, parameters });
+      return;
+    }
+
+    // Array to track changes in activeNames
+    const nameChanged: boolean[] = [];
+
+    // Compare each name in activeNames
+    for (let i = 0; i < activeNames.length; i++) {
+      const currentName = activeNames[i];
+
+      // Check if the name is present in prevActiveNames
+      const hasNameChanged = !prevActiveNames.includes(currentName);
+
+      if (hasNameChanged) {
+        nameChanged.push(true);
+        await trigger({ ref_ActiveNames: activeNames, parameters });
+        break;
+      }
+    }
+
+    // Count the number of `true` in nameChanged
+    const count = nameChanged.filter((value) => value === true).length;
+
+    if (count < 1) {
+      // Check for new names in prevActiveNames
+      for (let i = 0; i < prevActiveNames.length; i++) {
+        const currentName = prevActiveNames[i];
+
+        // Check if the name is present in activeNames
+        const hasNameChanged = !activeNames.includes(currentName);
+
+        // Signal change if the name is new
+        if (hasNameChanged) {
+          await trigger({ ref_ActiveNames: activeNames, parameters });
+          break;
+        }
+      }
+    }
+
+    // Update prevActiveNames with current activeNames
+    updatePrevActiveNames([...activeNames]);
+  } catch (error) {
+    console.log("compareActiveNames error", error);
+    // throw error; (Optional: Keep or remove depending on your error handling strategy)
+  }
+}

package/src/consumers/compareScreenStates.ts

@@ -0,0 +1,117 @@
+import { ScreenState, TriggerType, TriggerParameters } from '../types/types';
+
+export interface CompareScreenStatesParameters extends TriggerParameters {
+  recordingDisplayType: 'video' | 'media' | 'all';
+  recordingVideoOptimized: boolean;
+  screenStates: ScreenState[];
+  prevScreenStates: ScreenState[];
+  activeNames: string[];
+
+  // mediasfu functions
+  trigger: TriggerType;
+  getUpdatedAllParams: () => CompareScreenStatesParameters;
+  [key: string]: any;
+}
+
+export interface CompareScreenStatesOptions {
+  restart?: boolean;
+  parameters: CompareScreenStatesParameters;
+}
+
+// Export the type definition for the function
+export type CompareScreenStatesType = (options: CompareScreenStatesOptions) => Promise<void>;
+
+/**
+ * Compares the current screen states with the previous screen states and triggers actions based on changes.
+ *
+ * @param {CompareScreenStatesOptions} options - The options for comparing screen states.
+ * @param {boolean} [options.restart=false] - Whether to restart the comparison process.
+ * @param {CompareScreenStatesParameters} options.parameters - The parameters for the comparison.
+ * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+ * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.
+ * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.
+ * @param {Array<ScreenState>} options.parameters.screenStates - The current screen states.
+ * @param {Array<ScreenState>} options.parameters.prevScreenStates - The previous screen states.
+ * @param {Array<string>} options.parameters.activeNames - The active names in the current context.
+ * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.
+ *
+ * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.
+ *
+ * @throws Will log an error message if an error occurs during the comparison process.
+ * 
+ * @example
+ * const options = {
+ *   restart: false,
+ *   parameters: {
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *     recordingDisplayType: 'video',
+ *     recordingVideoOptimized: true,
+ *     screenStates: [{ key1: 'value1' }, { key2: 'value2' }],
+ *     prevScreenStates: [{ key1: 'value1' }, { key2: 'value2' }],
+ *     activeNames: ['name1', 'name2'],
+ *     trigger: triggerFunction,
+ *   },
+ * };
+ * 
+ * compareScreenStates(options)
+ *   .then(() => {
+ *     console.log('Screen states compared successfully');
+ *   });
+ */
+
+export async function compareScreenStates({
+  restart = false,
+  parameters,
+}: CompareScreenStatesOptions): Promise<void> {
+  try {
+    const { getUpdatedAllParams } = parameters;
+    parameters = getUpdatedAllParams();
+
+    const {
+      recordingDisplayType,
+      recordingVideoOptimized,
+      screenStates,
+      prevScreenStates,
+      activeNames,
+
+      //mediasfu functions
+      trigger,
+    } = parameters;
+
+    // Restart the comparison if needed
+    if (restart) {
+      // Perform necessary actions on restart
+      return;
+    }
+
+    // Compare each key-value pair in the screenStates objects
+    for (let i = 0; i < screenStates.length; i++) {
+      const currentScreenState = screenStates[i];
+      const prevScreenState = prevScreenStates[i];
+
+      // Check if any value has changed
+      const hasChanged = (Object.keys(currentScreenState) as (keyof ScreenState)[]).some(
+        (key) => currentScreenState[key] !== prevScreenState[key]
+      );
+
+      // Signal change if any value has changed
+      if (hasChanged) {
+        // Perform actions or trigger events based on the change
+        if (recordingDisplayType === 'video') {
+          if (recordingVideoOptimized) {
+            await trigger({
+              ref_ActiveNames: activeNames,
+              parameters,
+            });
+            break;
+          }
+        }
+        await trigger({ ref_ActiveNames: activeNames, parameters });
+        break;
+      }
+    }
+  } catch (error) {
+    console.log('compareScreenStates error', error);
+    // Optionally re-throw the error for further handling
+  }
+}

package/src/consumers/connectIps.ts

@@ -0,0 +1,175 @@
+ 
+import { connectSocket } from "../../src/sockets/SocketManager";
+import { newPipeProducer } from "./socketReceiveMethods/newPipeProducer";
+import { producerClosed } from "./socketReceiveMethods/producerClosed";
+import { joinConsumeRoom } from "./socketReceiveMethods/joinConsumeRoom";
+import type { Device } from 'mediasoup-client/lib/types';
+import {
+  ReorderStreamsParameters, ReorderStreamsType, NewPipeProducerParameters, NewPipeProducerType, ProducerClosedType,
+  ProducerClosedParameters, JoinConsumeRoomType, JoinConsumeRoomParameters, ConsumeSocket
+} from '../types/types';
+
+export interface ConnectIpsParameters extends ReorderStreamsParameters, JoinConsumeRoomParameters, ProducerClosedParameters, NewPipeProducerParameters {
+  device: Device | null;
+  roomRecvIPs: string[];
+  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;
+  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;
+
+  // mediasfu functions
+  reorderStreams: ReorderStreamsType;
+  getUpdatedAllParams: () => ConnectIpsParameters;
+  [key: string]: any;
+}
+
+export interface ConnectIpsOptions {
+  consume_sockets: ConsumeSocket[];
+  remIP: string[];
+  apiUserName: string;
+  apiKey?: string;
+  apiToken: string;
+  newProducerMethod?: NewPipeProducerType;
+  closedProducerMethod?: ProducerClosedType;
+  joinConsumeRoomMethod?: JoinConsumeRoomType;
+  parameters: ConnectIpsParameters;
+}
+
+// Export the type definition for the function
+export type ConnectIpsType = (options: ConnectIpsOptions) => Promise<[Record<string, any>[], string[]]>;
+
+/**
+ * Connects to remote IPs and manages socket connections.
+ *
+ * @param {ConnectIpsOptions} options - The options for connecting IPs.
+ * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.
+ * @param {string[]} options.remIP - The list of remote IPs to connect to.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {string} [options.apiKey] - The API key for authentication.
+ * @param {string} [options.apiToken] - The API token for authentication.
+ * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.
+ * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.
+ * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.
+ * @param {ConnectIpsParameters} options.parameters - Additional parameters.
+ * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.
+ * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.
+ * @param {Function} options.parameters.updateConsume_sockets - The function to update the consume sockets.
+ *
+ * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.
+ *
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ * 
+ * @example
+ * const options = {
+ *   consume_sockets: [],
+ *   remIP: ['ip1', 'ip2'],
+ *   apiUserName: 'username',
+ *   apiKey: 'apikey',
+ *   apiToken: 'token',
+ *   parameters: {
+ *     roomRecvIPs: [],
+ *     updateRoomRecvIPs: updateRoomRecvIPsFunction,
+ *     updateConsume_sockets: updateConsumeSocketsFunction,
+ *   },
+ * };
+ * 
+ * connectIps(options)
+ *   .then(([consume_sockets, roomRecvIPs]) => {
+ *     console.log('Connected IPs:', consume_sockets);
+ *     console.log('Room received IPs:', roomRecvIPs);
+ *   });
+ */
+
+export const connectIps = async ({
+  consume_sockets,
+  remIP,
+  apiUserName,
+  apiKey,
+  apiToken,
+
+  // mediasfu methods
+  newProducerMethod = newPipeProducer,
+  closedProducerMethod = producerClosed,
+  joinConsumeRoomMethod = joinConsumeRoom,
+  parameters,
+}: ConnectIpsOptions): Promise<[Record<string, any>[], string[]]> => {
+  try {
+    const { roomRecvIPs, updateRoomRecvIPs, updateConsume_sockets } = parameters;
+
+    if (!consume_sockets || !remIP || !apiUserName || (!apiKey && !apiToken)) {
+      console.log("Missing required parameters", {
+        consume_sockets,
+        remIP,
+        apiUserName,
+        apiToken,
+      });
+      return [consume_sockets, roomRecvIPs];
+    }
+
+    for (const ip of remIP) {
+      try {
+        // Check if the IP is already connected
+        const matching = consume_sockets.find((socketObj) => Object.keys(socketObj)[0] === ip);
+
+        if (matching || !ip) {
+          // Skip if the IP is already connected or invalid
+          continue;
+        }
+
+        // Connect to the remote socket using socket.io-client
+        const remote_sock = await connectSocket({ apiUserName, apiKey, apiToken, link: `https://${ip}.mediasfu.com` });
+
+        if (remote_sock.id) {
+          // Check if the IP is in the roomRecvIPs, if not, add it
+          if (!roomRecvIPs.includes(ip)) {
+            roomRecvIPs.push(ip);
+            updateRoomRecvIPs(roomRecvIPs);
+          }
+
+          // Handle new pipe producer event
+          remote_sock.on("new-pipe-producer", async ({ producerId, islevel }: { producerId: string; islevel: string }) => {
+            if (newProducerMethod) {
+              await newProducerMethod({
+                producerId,
+                islevel,
+                nsock: remote_sock,
+                parameters,
+              });
+            }
+          });
+
+          // Handle producer closed event
+          remote_sock.on("producer-closed", async ({ remoteProducerId }: { remoteProducerId: string }) => {
+            if (closedProducerMethod) {
+              await closedProducerMethod({ remoteProducerId, parameters });
+            }
+          });
+
+          // Handle new consuming room by joining the room
+          if (joinConsumeRoomMethod) {
+            let data = await joinConsumeRoomMethod({
+              remote_sock,
+              apiToken,
+              apiUserName,
+              parameters,
+            });
+            if (!data.rtpCapabilities) {
+              return [consume_sockets, roomRecvIPs];
+            }
+          }
+
+          // Add the remote socket to the consume_sockets array
+          consume_sockets.push({ [ip]: remote_sock });
+          updateConsume_sockets(consume_sockets);
+        }
+      } catch (error) {
+        // Handle the error
+        console.log("connectIps error", error);
+      }
+    }
+
+    return [consume_sockets, roomRecvIPs];
+  } catch (error) {
+    // Handle the error
+    console.log("connectIps error", error);
+    return [consume_sockets, parameters.roomRecvIPs];
+  }
+};

package/src/consumers/connectLocalIps.ts

@@ -0,0 +1,103 @@
+
+import { newPipeProducer } from "./socketReceiveMethods/newPipeProducer";
+import { producerClosed } from "./socketReceiveMethods/producerClosed";
+import {
+  ReorderStreamsParameters, ReorderStreamsType, NewPipeProducerParameters, NewPipeProducerType, ProducerClosedType,
+  ProducerClosedParameters, 
+  ReceiveAllPipedTransportsParameters,
+  ReceiveAllPipedTransportsType} from '../types/types';
+import { Socket } from "socket.io-client";
+
+export interface ConnectLocalIpsParameters extends ReorderStreamsParameters, ProducerClosedParameters, NewPipeProducerParameters,
+ReceiveAllPipedTransportsParameters {
+  socket: Socket;
+
+  // mediasfu functions
+  reorderStreams: ReorderStreamsType;
+  receiveAllPipedTransports: ReceiveAllPipedTransportsType;
+  getUpdatedAllParams: () => ConnectLocalIpsParameters;
+  [key: string]: any;
+}
+
+export interface ConnectLocalIpsOptions {
+  socket: Socket;
+  newProducerMethod?: NewPipeProducerType;
+  closedProducerMethod?: ProducerClosedType;
+  parameters: ConnectLocalIpsParameters;
+}
+
+// Export the type definition for the function
+export type ConnectLocalIpsType = (options: ConnectLocalIpsOptions) => Promise<void>;
+
+/**
+ * Connects to remote IPs and manages socket connections.
+ * 
+ * @param {ConnectLocalIpsOptions} options - The options for connecting IPs.
+ * @param {Socket} options.socket - The socket to connect to.
+ * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.
+ * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.
+ * @param {ConnectLocalIpsParameters} options.parameters - Additional parameters.
+ * @param {Function} options.parameters.reorderStreams - The function to reorder streams.
+ * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+ * @param {Socket} options.parameters.socket - The socket to connect to.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ * 
+ * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+ * 
+ * @example
+ * ```typescript
+ * const options = {
+ *  socket,
+ * newProducerMethod: newPipeProducer,
+ * closedProducerMethod: producerClosed,
+ * parameters: connectLocalIpsParameters,
+ * };
+ * 
+ * connectLocalIps(options)
+ *  .then(() => {
+ *   console.log('Connected to local IPs');
+ * })
+ * .catch(error => {
+ *  console.error('Error connecting to local IPs:', error);
+ * });
+ * ```
+ */ 
+
+export const connectLocalIps = async ({
+  socket,
+
+  // mediasfu methods
+  newProducerMethod = newPipeProducer,
+  closedProducerMethod = producerClosed,
+  parameters,
+}: ConnectLocalIpsOptions): Promise<void> => {
+  try {
+
+    // Connect to the remote socket using socket.io-client
+    // Handle new pipe producer event
+    socket.on("new-producer", async ({ producerId, islevel }: { producerId: string; islevel: string }) => {
+      if (newProducerMethod) {
+        await newProducerMethod({
+          producerId,
+          islevel,
+          nsock: socket,
+          parameters,
+        });
+      }
+    });
+
+    // Handle producer closed event
+    socket.on("producer-closed", async ({ remoteProducerId }: { remoteProducerId: string }) => {
+      if (closedProducerMethod) {
+        await closedProducerMethod({ remoteProducerId, parameters });
+      }
+    });
+
+    await parameters.receiveAllPipedTransports({ nsock: socket, community: true, parameters });
+
+  } catch (error) {
+    // Handle the error
+    console.log("ConnectLocalIps error", error);
+  }
+};

package/src/consumers/connectRecvTransport.ts

@@ -0,0 +1,158 @@
+import { Socket } from "socket.io-client";
+import { ConsumerResumeType, ConsumerResumeParameters, Transport as TransportType } from "../types/types";
+import type { Consumer, Device, Transport } from "mediasoup-client/lib/types";
+interface Params {
+  id: string;
+  producerId: string;
+  kind: string;
+  rtpParameters: any;
+  serverConsumerId: string;
+  error?: string;
+}
+
+export interface ConnectRecvTransportParameters extends ConsumerResumeParameters {
+  device: Device | null;
+  consumerTransports: TransportType[];
+  updateConsumerTransports: (transports: TransportType[]) => void;
+
+  // mediasfu functions
+  consumerResume: ConsumerResumeType;
+  getUpdatedAllParams: () => ConnectRecvTransportParameters;
+  [key: string]: any; // Extendable for additional parameters
+}
+export interface ConnectRecvTransportOptions {
+  consumerTransport: Transport;
+  remoteProducerId: string;
+  serverConsumerTransportId: string;
+  nsock: Socket;
+  parameters: ConnectRecvTransportParameters;
+}
+
+// Export the type definition for the function
+export type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;
+
+/**
+ * Connects the receiving transport to consume media from a remote producer.
+ *
+ * @param {ConnectRecvTransportOptions} options - The options for connecting the receiving transport.
+ * @param {Transport} options.consumerTransport - The transport used for consuming media.
+ * @param {string} options.remoteProducerId - The ID of the remote producer.
+ * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+ * @param {Socket} options.nsock - The socket used for communication.
+ * @param {ConnectRecvTransportParameters} options.parameters - The parameters for the connection.
+ *
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ *
+ * @throws Will throw an error if the connection or consumption fails.
+ *
+ * @example
+ * ```typescript
+ * const options = {
+ *   consumerTransport,
+ *   remoteProducerId: 'producer-id',
+ *   serverConsumerTransportId: 'transport-id',
+ *   nsock: socket,
+ *   parameters: connectRecvTransportOptions,
+ * };
+ * 
+ * connectRecvTransport(options)
+ *   .then(() => {
+ *     console.log('Transport connected and consuming media');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error connecting transport:', error);
+ *   });
+ * ```
+ */
+
+export const connectRecvTransport = async ({
+  consumerTransport,
+  remoteProducerId,
+  serverConsumerTransportId,
+  nsock,
+  parameters,
+}: ConnectRecvTransportOptions): Promise<void> => {
+  parameters = parameters.getUpdatedAllParams();
+
+  const {
+    device,
+    consumerTransports,
+    updateConsumerTransports,
+    consumerResume,
+  } = parameters;
+
+  try {
+    // Emit 'consume' event to signal consumption initiation
+    nsock.emit(
+      "consume",
+      {
+        rtpCapabilities: device!.rtpCapabilities,
+        remoteProducerId,
+        serverConsumerTransportId,
+      },
+      async ({ params }: { params: Params }) => {
+        if (params.error) {
+          // Handle error
+          console.log("consume error", params.error);
+          return;
+        }
+
+        try {
+          // Consume media using received parameters
+          const consumer: Consumer = await consumerTransport.consume({
+            id: params.id,
+            producerId: params.producerId,
+            kind: params.kind as "audio" | "video",
+            rtpParameters: params.rtpParameters,
+          });
+
+          // Update consumerTransports array with the new consumer
+          consumerTransports.push({
+            consumerTransport,
+            serverConsumerTransportId: params.id,
+            producerId: remoteProducerId,
+            consumer,
+            socket_: nsock,
+          });
+
+          updateConsumerTransports(consumerTransports);
+
+          // Extract track from the consumer
+          const { track } = consumer;
+
+          // Emit 'consumer-resume' event to signal consumer resumption
+          nsock.emit(
+            "consumer-resume",
+            { serverConsumerId: params.serverConsumerId },
+            async ({ resumed }: { resumed: boolean }) => {
+              if (resumed) {
+                // Consumer resumed and ready to be used
+                try {
+                  await consumerResume({
+                    track,
+                    kind: params.kind,
+                    remoteProducerId,
+                    params,
+                    parameters,
+                    nsock,
+                    consumer,
+                  });
+                } catch (error) {
+                  // Handle error
+                  console.log("consumerResume error", error);
+                }
+              }
+            }
+          );
+        } catch (error) {
+          // Handle error
+          console.log("consume error", error);
+          return;
+        }
+      }
+    );
+  } catch (error) {
+    // Handle error
+    console.log("connectRecvTransport error", error);
+  }
+};