mediasfu-shared 1.0.0

package/src/consumers/resumeSendTransportAudio.ts

@@ -0,0 +1,143 @@
+import type { Producer } from 'mediasoup-client/lib/types';
+import { PrepopulateUserMediaParameters, PrepopulateUserMediaType } from "../types/types";
+
+export interface ResumeSendTransportAudioParameters extends PrepopulateUserMediaParameters {
+  audioProducer: Producer | null;
+  localAudioProducer?: Producer | null;
+  islevel: string;
+  hostLabel: string;
+  lock_screen: boolean;
+  shared: boolean;
+  videoAlreadyOn: boolean;
+  updateAudioProducer: (audioProducer: Producer | null) => void;
+  updateLocalAudioProducer?: (localAudioProducer: Producer | null) => void;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+
+  // mediasfu functions
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  prepopulateLocalUserMedia?: PrepopulateUserMediaType;
+  [key: string]: any;
+}
+
+export interface ResumeSendTransportAudioOptions {
+  parameters: ResumeSendTransportAudioParameters;
+}
+
+// Export the type definition for the function
+export type ResumeSendTransportAudioType = (options: ResumeSendTransportAudioOptions) => Promise<void>;
+
+const resumeLocalSendTransportAudio = async ({
+  parameters,
+}: ResumeSendTransportAudioOptions): Promise<void> => {
+  try {
+    const {
+      localAudioProducer,
+      updateLocalAudioProducer,
+    } = parameters;
+
+    // Resume local audio producer
+    if (localAudioProducer) {
+      localAudioProducer.resume();
+      updateLocalAudioProducer?.(localAudioProducer);
+    }
+  } catch (error) {
+    console.error("Error resuming local audio send transport:", error);
+    throw error; // Re-throw to propagate the error
+  }
+};
+
+/**
+ * Resumes the send transport for audio and updates the UI and audio producer state accordingly.
+ *
+ * This function supports both a primary and a local audio producer, delegating the local logic to a separate function.
+ *
+ * @param {ResumeSendTransportAudioOptions} options - The options for resuming the send transport.
+ * @param {ResumeSendTransportAudioParameters} options.parameters - The parameters for resuming the send transport.
+ * @param {Producer} options.parameters.audioProducer - The primary audio producer to resume.
+ * @param {Producer} [options.parameters.localAudioProducer] - The local audio producer to resume.
+ * @param {string} options.parameters.islevel - The level of the audio producer.
+ * @param {string} options.parameters.hostLabel - The label for the host.
+ * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+ * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer state.
+ * @param {Function} [options.parameters.updateLocalAudioProducer] - Function to update the local audio producer state.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @returns {Promise<void>} A promise that resolves when the send transport is resumed and the UI is updated.
+ *
+ * @throws {Error} Throws an error if there is an issue during the process of resuming the audio send transport.
+ *
+ * @example
+ * ```typescript
+ * await resumeSendTransportAudio({
+ *   parameters: {
+ *     audioProducer: producer,
+ *     localAudioProducer: localProducer,
+ *     islevel: '1',
+ *     hostLabel: 'Host',
+ *     lock_screen: false,
+ *     shared: false,
+ *     updateAudioProducer: updateProducerFunction,
+ *     updateLocalAudioProducer: updateLocalProducerFunction,
+ *     videoAlreadyOn: false,
+ *     updateUpdateMainWindow: updateWindowFunction,
+ *     prepopulateUserMedia: prepopulateFunction,
+ *     prepopulateLocalUserMedia: prepopulateLocalFunction,
+ *   },
+ * });
+ * ```
+ */
+
+export const resumeSendTransportAudio: ResumeSendTransportAudioType = async ({
+  parameters,
+}: ResumeSendTransportAudioOptions): Promise<void> => {
+  try {
+    const {
+      audioProducer,
+      islevel,
+      hostLabel,
+      lock_screen,
+      shared,
+      updateAudioProducer,
+      videoAlreadyOn,
+      updateUpdateMainWindow,
+
+      //mediasfu functions
+      prepopulateUserMedia,
+    } = parameters;
+
+    // Resume send transport for audio
+    audioProducer!.resume();
+
+    // Update UI for primary producer
+    if (!videoAlreadyOn && islevel === "2") {
+      if (!lock_screen && !shared) {
+        let updatedMainWindow = true;
+        updateUpdateMainWindow(updatedMainWindow);
+        await prepopulateUserMedia({ name: hostLabel, parameters });
+        updatedMainWindow = false;
+        updateUpdateMainWindow(updatedMainWindow);
+      }
+    }
+
+    // Update audio producer state
+    updateAudioProducer(audioProducer);
+
+    // Attempt to handle local audio producer if primary fails
+    try {
+      await resumeLocalSendTransportAudio({ parameters });
+    } catch (localError) {
+      console.error(
+        "local audio send transport resuming failed:",
+        localError
+      );
+    }
+  } catch (error: any) {
+    // Handle errors during the process of resuming the audio send transport
+    throw new Error(
+      `Error during resuming audio send transport: ${error.message}`
+    );
+
+  }
+};

package/src/consumers/signalNewConsumerTransport.ts

@@ -0,0 +1,179 @@
+import { Socket } from "socket.io-client";
+import { ReorderStreamsParameters, ReorderStreamsType, ConnectRecvTransportType,
+   ConnectRecvTransportParameters, CreateWebRTCTransportResponse } from "../types/types";
+import type { Device, DtlsParameters  } from 'mediasoup-client/lib/types';
+
+export interface SignalNewConsumerTransportParameters extends ReorderStreamsParameters, ConnectRecvTransportParameters {
+  device: Device | null;
+  consumingTransports: string[];
+  lock_screen: boolean;
+  updateConsumingTransports: (transports: string[]) => void;
+  connectRecvTransport: ConnectRecvTransportType;
+  reorderStreams: ReorderStreamsType;
+  getUpdatedAllParams: () => SignalNewConsumerTransportParameters;
+  [key: string]: any;
+}
+
+export interface SignalNewConsumerTransportOptions {
+  remoteProducerId: string;
+  islevel: string;
+  nsock: Socket;
+  parameters: SignalNewConsumerTransportParameters;
+}
+
+// Export the type definition for the function
+export type SignalNewConsumerTransportType = (options: SignalNewConsumerTransportOptions) => Promise<string[] | void>;
+
+/**
+ * Signals the creation of a new consumer transport.
+ * 
+ * @param {SignalNewConsumerTransportOptions} options - The options for signaling a new consumer transport.
+ * @param {string} options.remoteProducerId - The ID of the remote producer.
+ * @param {string} options.islevel - Indicates the level of the consumer.
+ * @param {Socket} options.nsock - The socket instance for communication.
+ * @param {SignalNewConsumerTransportParameters} options.parameters - The parameters for the transport.
+ * 
+ * @returns {Promise<string[] | void>} A promise that resolves to an array of consuming transports or void.
+ * 
+ * @throws Will throw an error if the signaling process fails.
+ * 
+ * @example
+ * const options = {
+ *   remoteProducerId: 'producer-id',
+ *   islevel: '1',
+ *   nsock: socketInstance,
+ *   parameters: {
+ *     device: mediaDevice,
+ *     consumingTransports: [],
+ *     lock_screen: false,
+ *     updateConsumingTransports: updateFunction,
+ *     connectRecvTransport: connectFunction,
+ *     reorderStreams: reorderFunction,
+ *     getUpdatedAllParams: getUpdatedParamsFunction,
+ *   },
+ * };
+ * 
+ * signalNewConsumerTransport(options)
+ *   .then(consumingTransports => {
+ *     console.log('Consuming Transports:', consumingTransports);
+ *   })
+ *   .catch(error => {
+ *     console.error('Error signaling new consumer transport:', error);
+ *   });
+ */
+
+export const signalNewConsumerTransport = async ({
+  remoteProducerId,
+  islevel,
+  nsock,
+  parameters,
+}: SignalNewConsumerTransportOptions): Promise<string[] | void> => {
+  try {
+    let {
+      device,
+      consumingTransports,
+      lock_screen,
+      updateConsumingTransports,
+      connectRecvTransport,
+      reorderStreams,
+    } = parameters;
+
+    // Get updated parameters
+    const updatedParams = parameters.getUpdatedAllParams();
+    device = updatedParams.device;
+    consumingTransports = updatedParams.consumingTransports;
+
+    // Check if already consuming
+    if (consumingTransports.includes(remoteProducerId)) {
+      return consumingTransports;
+    }
+
+    // Add remote producer ID to consumingTransports array
+    consumingTransports.push(remoteProducerId);
+    updateConsumingTransports(consumingTransports);
+
+    // Emit createWebRtcTransport event to signal a new consumer
+    nsock.emit(
+      "createWebRtcTransport",
+      { consumer: true, islevel },
+      async ({ params }: { params: CreateWebRTCTransportResponse }) => {
+        if (params.error) {
+          // Handle error
+          return;
+        }
+
+        try {
+          // Create a new receiving transport using the received parameters
+          const consumerTransport = device!.createRecvTransport({ ...params });
+
+          // Handle 'connect' event for the consumer transport
+          consumerTransport.on(
+            "connect",
+            async (
+              { dtlsParameters }: { dtlsParameters: DtlsParameters },
+              callback: () => void,
+              errback: (error: any) => void
+            ) => {
+              try {
+                // Emit transport-recv-connect event to signal connection
+                nsock.emit("transport-recv-connect", {
+                  dtlsParameters,
+                  serverConsumerTransportId: params.id,
+                });
+                callback();
+              } catch (error) {
+                errback(error);
+              }
+            }
+          );
+
+          // Listen for connection state change
+          consumerTransport.on("connectionstatechange", async (state: string) => {
+            switch (state) {
+              case "connecting":
+                // Handle connecting state
+                break;
+
+              case "connected":
+                // Handle connected state
+                break;
+
+              case "failed":
+                // Handle failed state
+                consumerTransport.close();
+
+                // Reorder streams based on conditions
+                if (lock_screen) {
+                  await reorderStreams({ add: true, parameters });
+                } else {
+                  await reorderStreams({ add: false, parameters });
+                }
+                break;
+
+              default:
+                break;
+            }
+          });
+
+          // Connect the receiving transport
+          await connectRecvTransport({
+            consumerTransport,
+            remoteProducerId,
+            serverConsumerTransportId: params.id,
+            nsock,
+            parameters,
+          });
+        } catch (error) {
+          console.log(error, "createRecvTransport error");
+          // Handle error
+          return;
+        }
+      }
+    );
+  } catch (error) {
+    console.log(error, "signalNewConsumerTransport error");
+    // Handle error
+    return;
+  }
+};
+

package/src/consumers/socketReceiveMethods/joinConsumeRoom.ts

@@ -0,0 +1,130 @@
+import { joinConRoom } from '../../producers/producerEmits/joinConRoom';
+import type { Device, RtpCapabilities } from 'mediasoup-client/lib/types';
+import { Socket } from 'socket.io-client';
+import { ReceiveAllPipedTransportsParameters, ReceiveAllPipedTransportsType, CreateDeviceClientType } from '../../types/types';
+
+
+export interface JoinConsumeRoomParameters extends ReceiveAllPipedTransportsParameters {
+  roomName: string;
+  islevel: string;
+  member: string;
+  device: Device | null;
+  updateDevice: (device: Device | null) => void;
+
+  // Mediasfu functions
+  receiveAllPipedTransports: ReceiveAllPipedTransportsType;
+  createDeviceClient: CreateDeviceClientType;
+  getUpdatedAllParams: () => JoinConsumeRoomParameters;
+  [key: string]: any;
+}
+export interface JoinConsumeRoomOptions {
+  remote_sock: Socket;
+  apiToken: string;
+  apiUserName: string;
+  parameters: JoinConsumeRoomParameters;
+}
+
+interface JoinConsumeRoomResponse {
+  success: boolean;
+  rtpCapabilities?: RtpCapabilities | null;
+}
+
+// Export the type definition for the function
+export type JoinConsumeRoomType = (options: JoinConsumeRoomOptions) => Promise<JoinConsumeRoomResponse>;
+
+/**
+ * Joins a consumption room by sending a request to the server, handling device setup, and managing piped transports.
+ * 
+ * @function
+ * @async
+ * @param {Object} options - The configuration options.
+ * @param {Socket} options.remote_sock - The remote socket for communication.
+ * @param {string} options.apiToken - The API token for authentication.
+ * @param {string} options.apiUserName - The API username for authentication.
+ * @param {JoinConsumeRoomParameters} options.parameters - Additional parameters including room details and Mediasoup configurations.
+ * @returns {Promise<JoinConsumeRoomResponse>} - An object indicating the success of joining the room and optional RTP capabilities.
+ * @throws {Error} Throws an error if joining the room or setup fails.
+ *
+ * @example
+ * import { joinConsumeRoom } from 'mediasfu-reactjs';
+ * import { io } from 'socket.io-client';
+ * 
+ * const apiToken = 'your-api-token';
+ * const apiUserName = 'your-api-username';
+ * const remote_sock = io("http://localhost:3000");
+ * 
+ * const parameters = {
+ *   roomName: 'room-name',
+ *   islevel: '2',
+ *   member: 'user-id',
+ *   device: null,
+ *   updateDevice: (device) => console.log('Device updated:', device),
+ *   receiveAllPipedTransports: (params) => console.log('Receiving all piped transports:', params),
+ *   createDeviceClient: async (params) => { // Device client setup logic  },
+ *   getUpdatedAllParams: () => console.log('Getting updated parameters'),
+ * };
+ * 
+ * async function init() {
+ *   try {
+ *     const data = await joinConsumeRoom({
+ *       remote_sock,
+ *       apiToken,
+ *       apiUserName,
+ *       parameters,
+ *     });
+ *     console.log('Joined room:', data);
+ *   } catch (error) {
+ *     console.error('Error joining room:', error);
+ *   }
+ * }
+ * init();
+ * // Expected output: { success: true, rtpCapabilities: { ... } }
+ */
+
+
+export const joinConsumeRoom = async ({
+  remote_sock,
+  apiToken,
+  apiUserName,
+  parameters,
+}: JoinConsumeRoomOptions): Promise<JoinConsumeRoomResponse> => {
+  const {
+    roomName,
+    islevel,
+    member,
+    device,
+    updateDevice,
+
+    // Mediasfu functions
+    receiveAllPipedTransports,
+    createDeviceClient,
+  } = parameters;
+
+  try {
+    // Join the consumption room
+    const data: JoinConsumeRoomResponse = await joinConRoom({ socket: remote_sock, roomName, islevel, member, sec: apiToken, apiUserName });
+
+    if (data && data.success) {
+      // Setup media device if not already set
+      if (!device) {
+        if (data.rtpCapabilities) {
+          const device_: Device | null = await createDeviceClient({
+            rtpCapabilities: data.rtpCapabilities,
+          });
+
+          if (device_) {
+            updateDevice(device_);
+          }
+        }
+      }
+
+      // Receive all piped transports
+      await receiveAllPipedTransports({ nsock: remote_sock, parameters });
+    }
+
+    return data;
+  } catch (error) {
+    console.error('Error in joinConsumeRoom:', error);
+    throw new Error('Failed to join the consumption room or set up necessary components.');
+  }
+};

package/src/consumers/socketReceiveMethods/newPipeProducer.ts

@@ -0,0 +1,138 @@
+import { Socket } from 'socket.io-client';
+import { signalNewConsumerTransport } from '../signalNewConsumerTransport';
+import { ReorderStreamsParameters, ReorderStreamsType, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters, ConnectRecvTransportType, ShowAlert } from '../../types/types';
+import type { Device } from 'mediasoup-client/lib/types';
+export interface NewPipeProducerParameters extends ReorderStreamsParameters, SignalNewConsumerTransportParameters, ConnectRecvTransportParameters {
+
+  first_round: boolean;
+  shareScreenStarted: boolean;
+  shared: boolean;
+  landScaped: boolean;
+  showAlert?: ShowAlert;
+  isWideScreen: boolean;
+  updateFirst_round: (firstRound: boolean) => void;
+  updateLandScaped: (landScaped: boolean) => void;
+  device: Device | null;
+  consumingTransports: string[];
+  lock_screen: boolean;
+  updateConsumingTransports: (transports: string[]) => void;
+
+  // mediasfu functions
+  connectRecvTransport: ConnectRecvTransportType;
+  reorderStreams: ReorderStreamsType;
+  getUpdatedAllParams: () => NewPipeProducerParameters;
+  [key: string]: any;
+
+}
+
+export interface NewPipeProducerOptions {
+  producerId: string;
+  islevel: string;
+  nsock: Socket;
+  parameters: NewPipeProducerParameters;
+}
+
+// Export the type definition for the function
+export type NewPipeProducerType = (options: NewPipeProducerOptions) => Promise<void>;
+
+
+/**
+ * Handles the creation of a new pipe producer by signaling for a new consumer transport and updating the necessary parameters.
+ *
+ * @function
+ * @async
+ * @param {NewPipeProducerOptions} options - The options for the new pipe producer.
+ * @param {string} options.producerId - The ID of the producer to be consumed.
+ * @param {string} options.islevel - The level status of the participant.
+ * @param {Socket} options.nsock - The socket instance for real-time communication.
+ * @param {NewPipeProducerParameters} options.parameters - Additional parameters required for the producer.
+ * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {boolean} options.parameters.shared - Indicates if sharing is active.
+ * @param {boolean} options.parameters.landScaped - Indicates if the device is in landscape mode.
+ * @param {ShowAlert} options.parameters.showAlert - Function to show alerts to the user.
+ * @param {boolean} options.parameters.isWideScreen - Indicates if the device is a widescreen.
+ * @param {Function} options.parameters.updateFirst_round - Function to update the first round status.
+ * @param {Function} options.parameters.updateLandScaped - Function to update the landscape status.
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ * @throws {Error} Will throw an error if the operation fails to signal the new consumer transport.
+ *
+ * @example
+ * import { newPipeProducer } from 'mediasfu-reactjs';
+ * import { io } from 'socket.io-client';
+ * 
+ * const parameters = {
+ *   shareScreenStarted: true,
+ *   shared: true,
+ *   landScaped: false,
+ *   showAlert: (alert) => console.log(alert.message),
+ *   isWideScreen: false,
+ *   updateFirst_round: (firstRound) => console.log('First round updated:', firstRound),
+ *   updateLandScaped: (landScaped) => console.log('Landscape status updated:', landScaped),
+ * };
+ * 
+ * const producerId = 'producer-123';
+ * const islevel = '2';
+ * const nsock = io("http://localhost:3000");
+ * 
+ * async function init() {
+ *   try {
+ *     await newPipeProducer({
+ *       producerId,
+ *       islevel,
+ *       nsock,
+ *       parameters,
+ *     });
+ *     console.log('New pipe producer created successfully');
+ *   } catch (error) {
+ *     console.error('Error creating new pipe producer:', error);
+ *   }
+ * }
+ * 
+ * init();
+ */
+
+export const newPipeProducer = async ({
+  producerId,
+  islevel,
+  nsock,
+  parameters,
+}: NewPipeProducerOptions): Promise<void> => {
+  const {
+    shareScreenStarted,
+    shared,
+    landScaped,
+    showAlert,
+    isWideScreen,
+    updateFirst_round,
+    updateLandScaped,
+  } = parameters;
+
+  // Signal new consumer transport
+  await signalNewConsumerTransport({
+    remoteProducerId: producerId,
+    islevel,
+    nsock,
+    parameters
+  });
+
+  // Modify first_round and landscape status
+  let updatedFirstRound = false;
+
+  if (shareScreenStarted || shared) {
+    if (!isWideScreen) {
+      if (!landScaped) {
+        if (showAlert) {
+          showAlert({
+            message: 'Please rotate your device to landscape mode for better experience',
+            type: 'success',
+            duration: 3000,
+          });
+        }
+        updateLandScaped(true);
+      }
+    }
+
+    updatedFirstRound = true;
+    updateFirst_round(updatedFirstRound);
+  }
+};

package/src/consumers/socketReceiveMethods/producerClosed.ts

@@ -0,0 +1,102 @@
+import { Transport, CloseAndResizeParameters, CloseAndResizeType } from '../../types/types';
+
+export interface ProducerClosedParameters extends CloseAndResizeParameters {
+  consumerTransports: Transport[];
+  screenId?: string;
+  updateConsumerTransports: (transports: Transport[]) => void;
+
+  // mediasfu functions
+  closeAndResize: CloseAndResizeType;
+  getUpdatedAllParams: () => ProducerClosedParameters;
+  [key: string]: any;
+
+}
+
+export interface ProducerClosedOptions {
+  remoteProducerId: string;
+  parameters: ProducerClosedParameters;
+}
+
+// Export the type definition for the function
+export type ProducerClosedType = (options: ProducerClosedOptions) => Promise<void>;
+
+/**
+ * Handles the closure of a producer identified by its remote producer ID.
+ * This function will clean up the consumer transports and resize the video outputs.
+ *
+ * @function
+ * @async
+ * @param {ProducerClosedOptions} options - The options for closing the producer.
+ * @param {string} options.remoteProducerId - The ID of the remote producer to close.
+ * @param {ProducerClosedParameters} options.parameters - Additional parameters for the operation.
+ * @param {Transport[]} options.parameters.consumerTransports - The list of consumer transports associated with the producer.
+ * @param {Function} options.parameters.closeAndResize - Function to handle the closing and resizing of video streams.
+ * @param {string} [options.parameters.screenId] - The ID of the screen producer (if applicable).
+ * @param {Function} options.parameters.updateConsumerTransports - Function to update the state of consumer transports.
+ * @returns {Promise<void>} A promise that resolves when the producer has been successfully closed.
+ * @throws Will throw an error if there is an issue closing the consumer transport or the producer.
+ *
+ * @example
+ * import { producerClosed } from 'mediasfu-reactjs';
+ * 
+ * const options = {
+ *   remoteProducerId: 'producerId',
+ *   parameters: {
+ *     consumerTransports: [], // Array of consumer transports
+ *     closeAndResize: (params) => console.log('Close and resize called', params),
+ *     screenId: 'screenId',
+ *     updateConsumerTransports: (transports) => console.log('Updated transports:', transports),
+ *   },
+ * };
+ * 
+ * producerClosed(options)
+ *   .then(() => {
+ *     console.log('Producer closed successfully');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error closing producer:', error);
+ *   });
+ */
+export const producerClosed = async ({
+  remoteProducerId,
+  parameters,
+}: ProducerClosedOptions): Promise<void> => {
+  let { consumerTransports, closeAndResize, screenId, updateConsumerTransports } = parameters;
+
+  // Handle producer closed
+  const producerToClose = consumerTransports.find(
+    (transportData: any) => transportData.producerId === remoteProducerId
+  );
+
+  if (!producerToClose) {
+    return;
+  }
+
+  // Check if the ID of the producer to close is the same as the screenId
+  let kind: string = producerToClose.consumer.kind;
+
+  if (producerToClose.producerId === screenId) {
+    kind = 'screenshare';
+  }
+
+  try {
+    await producerToClose.consumerTransport.close();
+  } catch (error) {
+    console.error('Error closing consumer transport:', error);
+  }
+
+  try {
+    producerToClose.consumer.close();
+  } catch (error) {
+    console.error('Error closing consumer:', error);
+  }
+
+  // Filter out the closed producer
+  consumerTransports = consumerTransports.filter(
+    (transportData: any) => transportData.producerId !== remoteProducerId
+  );
+  updateConsumerTransports(consumerTransports);
+
+  // Close and resize the videos
+  await closeAndResize({ producerId: remoteProducerId, kind, parameters });
+};