mediasfu-shared 1.0.0

package/src/consumers/controlMedia.ts

@@ -0,0 +1,118 @@
+ 
+import { Socket } from "socket.io-client";
+import { CoHostResponsibility, Participant, ShowAlert } from "../types/types";
+
+export interface ControlMediaOptions {
+  participantId: string;
+  participantName: string;
+  type: 'audio' | 'video' | 'screenshare' | 'all';
+  socket: Socket;
+  coHostResponsibility: CoHostResponsibility[];
+  participants: Participant[];
+  member: string;
+  islevel: string;
+  showAlert?: ShowAlert;
+  coHost: string;
+  roomName: string;
+}
+// Export the type definition for the function
+export type ControlMediaType = (options: ControlMediaOptions) => Promise<void>;
+
+/**
+ * Controls the media of a participant in a media session if certain conditions are met.
+ *
+ * @param {ControlMediaOptions} options - The options for controlling media.
+ * @param {string} options.participantId - The ID of the participant to control.
+ * @param {string} options.participantName - The name of the participant to control.
+ * @param {'audio' | 'video' | 'screenshare' | 'all'} options.type - The type of media to control.
+ * @param {Socket} options.socket - The socket instance for communication.
+ * @param {Array<CoHostResponsibility>} options.coHostResponsibility - List of co-host responsibilities.
+ * @param {Array<Participant>} options.participants - List of participants in the session.
+ * @param {string} options.member - The current member attempting to control media.
+ * @param {string} options.islevel - The level of the current member.
+ * @param {Function} [options.showAlert] - Optional function to show alerts.
+ * @param {string} options.coHost - The co-host information.
+ * @param {string} options.roomName - The name of the room.
+ *
+ * @returns {Promise<void>} A promise that resolves when the media control operation is complete.
+ *
+ * @throws Will log an error message if there are issues controlling the media or if participant is not found.
+ *
+ * @example
+ * const options = {
+ *   participantId: '1234',
+ *   participantName: 'John Doe',
+ *   type: 'audio',
+ *   socket: socketInstance,
+ *   coHostResponsibility: [{ name: 'media', value: true }],
+ *   participants: participantList,
+ *   member: 'Admin',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(alert.message),
+ *   coHost: 'CoHostName',
+ *   roomName: 'Room 1',
+ * };
+ * 
+ * controlMedia(options)
+ *   .then(() => {
+ *     console.log('Media control operation completed successfully.');
+ *   })
+ *   .catch((error) => {
+ *     console.error('Error controlling media:', error);
+ *   });
+ */
+
+export async function controlMedia({
+  participantId,
+  participantName,
+  type,
+  socket,
+  coHostResponsibility,
+  participants,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  roomName,
+}: ControlMediaOptions): Promise<void> {
+  try {
+    let mediaValue = false;
+
+    try {
+      mediaValue = coHostResponsibility.find((item) => item.name === "media")?.value ?? false;
+    } catch (error) {
+      console.log("Error retrieving media control value", error);
+    }
+
+    const participant = participants.find((obj) => obj.name === participantName);
+
+    if (!participant) {
+      console.log("Participant not found");
+      return;
+    }
+
+    if (islevel === "2" || (coHost === member && mediaValue === true)) {
+      if (
+        (!participant.muted && participant.islevel !== "2" && type === "audio") ||
+        (participant.islevel !== "2" && type === "video" && participant.videoOn)
+      ) {
+        socket.emit("controlMedia", {
+          participantId,
+          participantName,
+          type,
+          roomName,
+        });
+      }
+    } else {
+      if (showAlert) {
+        showAlert({
+          message: "You are not allowed to control media for other participants.",
+          type: "danger",
+          duration: 3000,
+        });
+      }
+    }
+  } catch (error) {
+    console.log("controlMedia error", error);
+  }
+}

package/src/consumers/createSendTransport.ts

@@ -0,0 +1,312 @@
+import type { Device, Transport, DtlsParameters } from 'mediasoup-client/lib/types';
+import { Socket } from "socket.io-client";
+import {
+  ConnectSendTransportParameters,
+  ConnectSendTransportType,
+} from "../types/types";
+
+export interface CreateSendTransportParameters extends ConnectSendTransportParameters {
+  islevel: string;
+  member: string;
+  socket: Socket;
+  localSocket?: Socket;
+  device: Device | null;
+  producerTransport: Transport | null;
+  localProducerTransport?: Transport | null;
+  transportCreated: boolean;
+  localTransportCreated?: boolean;
+  updateProducerTransport: (producerTransport: Transport | null) => void;
+  updateLocalProducerTransport?: (localTransport: Transport | null) => void;
+  updateTransportCreated: (transportCreated: boolean) => void;
+  updateLocalTransportCreated?: (localTransportCreated: boolean) => void;
+
+  // mediasfu functions
+  connectSendTransport: ConnectSendTransportType;
+  getUpdatedAllParams: () => CreateSendTransportParameters;
+  [key: string]: any;
+}
+
+export interface CreateSendTransportOptions {
+  option: "audio" | "video" | "screen" | "all";
+  parameters: CreateSendTransportParameters;
+}
+
+// Export the type definition for the function
+export type CreateSendTransportType = (options: CreateSendTransportOptions) => Promise<void>;
+
+const createLocalSendTransport = async ({
+  option,
+  parameters,
+}: CreateSendTransportOptions): Promise<void> => {
+  try {
+    let {
+      islevel,
+      member,
+      socket,
+      localSocket,
+      device,
+      localProducerTransport,
+      localTransportCreated,
+      updateLocalProducerTransport,
+      updateLocalTransportCreated,
+
+      connectSendTransport,
+    } = parameters;
+
+
+    if (!localSocket || !localSocket.id || socket.id === localSocket.id) {
+      return;
+    }
+
+    localSocket.emit(
+      "createWebRtcTransport",
+      { consumer: false, islevel },
+      async ({ params }: { params: any }) => {
+        if (params && params.error) {
+          console.error("Error in local createWebRtcTransport:", params.error);
+          return;
+        }
+
+        // Create local send transport
+        localProducerTransport = await device!.createSendTransport(params);
+        if (updateLocalProducerTransport) {
+          updateLocalProducerTransport(localProducerTransport);
+        }
+
+        // Handle local transport events
+        localProducerTransport.on(
+          "connect",
+          async ({ dtlsParameters }: { dtlsParameters: DtlsParameters }, callback: () => void, errback: (error: Error) => void) => {
+            try {
+              localSocket.emit("transport-connect", { dtlsParameters });
+              callback();
+            } catch (error) {
+              errback(error as Error);
+            }
+          }
+        );
+
+        localProducerTransport.on(
+          "produce",
+          async (
+            parameters: { kind: string; rtpParameters: any; appData: any },
+            callback: (response: { id: string }) => void,
+            errback: (error: Error) => void
+          ) => {
+            try {
+              localSocket.emit(
+                "transport-produce",
+                {
+                  kind: parameters.kind,
+                  rtpParameters: parameters.rtpParameters,
+                  appData: parameters.appData,
+                  islevel,
+                  name: member,
+                },
+                ({ id }: { id: string }) => callback({ id })
+              );
+            } catch (error) {
+              errback(error as Error);
+            }
+          }
+        );
+
+        localProducerTransport.on("connectionstatechange", (state: string) => {
+          if (state === "failed") {
+            console.error("Local transport connection failed.");
+            if (localProducerTransport) {
+              localProducerTransport.close();
+            }
+          }
+        });
+
+        // Mark local transport as created
+        localTransportCreated = true;
+        updateLocalTransportCreated?.(localTransportCreated);
+
+        // connect local transport
+        await connectSendTransport({
+          targetOption: "local",
+          option,
+          parameters: { ...parameters, localProducerTransport: localProducerTransport },
+        });
+      }
+    );
+  } catch (error) {
+    console.error("Error creating local send transport:", error);
+  }
+};
+
+/**
+ * Creates a WebRTC send transport and sets up event handlers for the transport.
+ *
+ * Supports both primary and local transports with modular handling.
+ *
+ * @param {CreateSendTransportOptions} options - The options for creating the send transport.
+ * @param {string} options.option - The type of transport to create.
+ * @param {CreateSendTransportParameters} options.parameters - The parameters required for creating the transport.
+ * @param {string} options.parameters.islevel - The level of the transport.
+ * @param {string} options.parameters.member - The member name for the transport.
+ * @param {Socket} options.parameters.socket - The primary socket instance.
+ * @param {Device} options.parameters.device - The device instance.
+ * @param {Transport | null} options.parameters.producerTransport - The primary producer transport object.
+ * @param {boolean} options.parameters.transportCreated - The state of the primary transport creation.
+ * @param {(transport: Transport | null) => void} options.parameters.updateProducerTransport - The function to update the primary transport object.
+ * @param {(state: boolean) => void} options.parameters.updateTransportCreated - The function to update the primary transport creation state.
+ * @param {Function} options.parameters.connectSendTransport - The function to connect the send transport.
+ * @param {Function} options.parameters.getUpdatedAllParams - The function to get updated parameters.
+ * @param {Socket} [options.parameters.localSocket] - The local socket instance.
+ * @param {Transport | null} [options.parameters.localProducerTransport] - The local producer transport object.
+ * @param {boolean} [options.parameters.localTransportCreated] - The state of the local transport creation.
+ * @param {(localTransport: Transport | null) => void} [options.parameters.updateLocalProducerTransport] - The function to update the local transport object.
+ * @param {(state: boolean) => void} [options.parameters.updateLocalTransportCreated] - The function to update the local transport creation state.
+* @returns {Promise<void>} A promise that resolves when the send transport is created and configured.
+ *
+ * @throws Will throw an error if there is an issue creating the send transport.
+ *
+ * @example
+ * const options = {
+ *   option: 'video',
+ *   parameters: {
+ *     islevel: '1',
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     localSocket: localSocketInstance,
+ *     device: deviceInstance,
+ *     producerTransport: null,
+ *     localProducerTransport: null,
+ *     transportCreated: false,
+ *     localTransportCreated: false,
+ *     updateProducerTransport: (transport) => console.log('Primary transport updated:', transport),
+ *     updateLocalProducerTransport: (transport) => console.log('Local transport updated:', transport),
+ *     updateTransportCreated: (state) => console.log('Primary transport created:', state),
+ *     updateLocalTransportCreated: (state) => console.log('Local transport created:', state),
+ *   },
+ * };
+ *
+ * createSendTransport(options)
+ *   .then(() => console.log('Send transport created successfully'))
+ *   .catch((error) => console.error('Error creating send transport:', error));
+ */
+
+export const createSendTransport: CreateSendTransportType = async ({
+  option,
+  parameters,
+}: CreateSendTransportOptions): Promise<void> => {
+  try {
+    // Destructure parameters
+    let {
+      islevel,
+      member,
+      socket,
+      device,
+      producerTransport,
+      transportCreated,
+      updateProducerTransport,
+      updateTransportCreated,
+      connectSendTransport,
+    } = parameters;
+
+    // Get updated device and socket parameters
+    const updatedParams = parameters.getUpdatedAllParams();
+    device = updatedParams.device;
+    socket = updatedParams.socket;
+
+    try {
+      // Handle local transport creation first
+      await createLocalSendTransport({option, parameters});
+    } catch (error) {
+      console.log("Error creating local send transport:", error);
+    }
+
+    // Emit createWebRtcTransport event to the server
+    socket.emit(
+      "createWebRtcTransport",
+      { consumer: false, islevel: islevel },
+      async ({ params }: { params: any }) => {
+        // Check if there is an error in the response
+        if (params && params.error) {
+          console.error("Error in createWebRtcTransport:", params.error);
+          return;
+        }
+
+        // Create a WebRTC send transport
+        producerTransport = await device!.createSendTransport(params);
+        updateProducerTransport(producerTransport);
+
+        // Handle 'connect' event
+        producerTransport.on(
+          "connect",
+          async ({ dtlsParameters }: { dtlsParameters: DtlsParameters }, callback: () => void, errback: (error: Error) => void) => {
+            try {
+              socket.emit("transport-connect", { dtlsParameters });
+              callback();
+            } catch (error) {
+              errback(error as Error);
+            }
+          }
+        );
+
+        // Handle 'produce' event
+        producerTransport.on(
+          "produce",
+          async (
+            parameters: { kind: string; rtpParameters: any; appData: any },
+            callback: (response: { id: string }) => void,
+            errback: (error: Error) => void
+          ) => {
+            try {
+              socket.emit(
+                "transport-produce",
+                {
+                  kind: parameters.kind,
+                  rtpParameters: parameters.rtpParameters,
+                  appData: parameters.appData,
+                  islevel: islevel,
+                  name: member,
+                },
+                async ({ id }: { id: string }) => {
+                  callback({ id });
+                }
+              );
+            } catch (error) {
+              errback(error as Error);
+            }
+          }
+        );
+
+        // Handle 'connectionstatechange' event
+        producerTransport.on("connectionstatechange", async (state: string) => {
+          switch (state) {
+            case "connecting":
+              break;
+            case "connected":
+              break;
+            case "failed":
+              console.log("Transport connection failed.");
+              producerTransport!.close();
+              break;
+            default:
+              break;
+          }
+        });
+
+        // Update transport creation state
+        transportCreated = true;
+        parameters = parameters.getUpdatedAllParams();
+        await connectSendTransport({
+          targetOption: "remote",
+          option,
+          parameters: {
+            ...parameters,
+            producerTransport,
+          },
+        });
+        updateTransportCreated(transportCreated);
+      }
+    );
+
+  } catch (error) {
+    console.log("Error creating send transport:", error);
+  }
+};

package/src/consumers/disconnectSendTransportAudio.ts

@@ -0,0 +1,170 @@
+import { Socket } from "socket.io-client";
+import { PrepopulateUserMediaType, PrepopulateUserMediaParameters } from "../types/types";
+import type { Producer } from 'mediasoup-client/lib/types';
+
+export interface DisconnectSendTransportAudioParameters extends PrepopulateUserMediaParameters {
+  audioProducer: Producer | null;
+  localAudioProducer?: Producer | null;
+  socket: Socket;
+  localSocket?: Socket;
+  videoAlreadyOn: boolean;
+  islevel: string;
+  lock_screen: boolean;
+  shared: boolean;
+  updateMainWindow: boolean;
+  hostLabel: string;
+  roomName: string;
+  updateAudioProducer: (audioProducer: Producer | null) => void;
+  updateLocalAudioProducer?: (localAudioProducer: Producer | null) => void;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+
+  // mediasfu functions
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  [key: string]: any;
+}
+
+export interface DisconnectSendTransportAudioOptions {
+  parameters: DisconnectSendTransportAudioParameters;
+}
+
+// Export the type definition for the function
+export type DisconnectSendTransportAudioType = (options: DisconnectSendTransportAudioOptions) => Promise<void>;
+
+const disconnectLocalSendTransportAudio = async ({
+  parameters,
+}: DisconnectSendTransportAudioOptions): Promise<void> => {
+  try {
+    const {
+      localAudioProducer,
+      localSocket,
+      roomName,
+      updateLocalAudioProducer,
+    } = parameters;
+
+    if (localSocket && localSocket.id) {
+      // Close the local audio producer and notify the server
+      if (localAudioProducer) {
+        localAudioProducer.close(); // Actual logic: pause instead of close for MediaSFU preference
+        updateLocalAudioProducer?.(null);
+      }
+
+      localSocket.emit("pauseProducerMedia", { mediaTag: "audio", roomName: roomName });
+    } else {
+      return;
+    }
+  } catch (error) {
+    console.log("Error disconnecting local audio send transport:", error);
+    throw error; // Re-throw to propagate the error
+  }
+};
+
+/**
+ * Disconnects the send transport for audio by pausing the audio producer and updating the UI accordingly.
+ *
+ * This function supports both a primary and a local audio producer, delegating local handling to a separate function.
+ *
+ * @param {DisconnectSendTransportAudioOptions} options - The options for disconnecting the send transport for audio.
+ * @param {DisconnectSendTransportAudioParameters} options.parameters - The parameters for disconnecting the send transport for audio.
+ * @param {Producer} options.parameters.audioProducer - The primary audio producer to disconnect.
+ * @param {Producer} [options.parameters.localAudioProducer] - The local audio producer to disconnect.
+ * @param {Socket} options.parameters.socket - The socket instance to use for communication.
+ * @param {Socket} [options.parameters.localSocket] - The local socket instance to use for communication.
+ * @param {boolean} options.parameters.videoAlreadyOn - Flag indicating if video is already on.
+ * @param {string} options.parameters.islevel - The level of the user.
+ * @param {boolean} options.parameters.lock_screen - Flag indicating if the screen is locked.
+ * @param {boolean} options.parameters.shared - Flag indicating if the screen is shared.
+ * @param {boolean} options.parameters.updateMainWindow - Flag to update the main window.
+ * @param {string} options.parameters.hostLabel - The label for the host user.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {function} options.parameters.updateAudioProducer - Function to update the audio producer.
+ * @param {function} [options.parameters.updateLocalAudioProducer] - Function to update the local audio producer (optional).
+ * @param {function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+ * @param {function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {object} options.parameters - The parameters required for disconnecting the send transport for audio.
+ * @returns {Promise<void>} A promise that resolves when the send transport for audio is disconnected.
+ *
+ * @throws Will throw an error if the operation fails.
+ *
+ * @example
+ * const options = {
+ *   parameters: {
+ *     audioProducer: audioProducerInstance,
+ *     localAudioProducer: localAudioProducerInstance,
+ *     socket: socketInstance,
+ *     localSocket: localSocketInstance,
+ *     videoAlreadyOn: false,
+ *     islevel: '1',
+ *     lock_screen: false,
+ *     shared: false,
+ *     updateMainWindow: true,
+ *     hostLabel: 'Host',
+ *     roomName: 'Room 1',
+ *     updateAudioProducer: (producer) => console.log('Updated audio producer:', producer),
+ *     updateLocalAudioProducer: (producer) => console.log('Updated local audio producer:', producer),
+ *     updateUpdateMainWindow: (state) => console.log('Main window state updated:', state),
+ *     prepopulateUserMedia: async ({ name, parameters }) => console.log('Prepopulating user media for', name),
+ *   },
+ * };
+ *
+ * disconnectSendTransportAudio(options)
+ *   .then(() => console.log("Audio send transport disconnected successfully"))
+ *   .catch((error) => console.log("Error disconnecting audio send transport:", error));
+ */
+
+export const disconnectSendTransportAudio: DisconnectSendTransportAudioType = async ({
+  parameters,
+}: DisconnectSendTransportAudioOptions): Promise<void> => {
+  try {
+    // Destructure parameters
+    let {
+      audioProducer,
+      socket,
+      videoAlreadyOn,
+      islevel,
+      lock_screen,
+      shared,
+      updateMainWindow,
+      hostLabel,
+      roomName,
+      updateAudioProducer,
+      updateUpdateMainWindow,
+
+      //mediasfu functions
+      prepopulateUserMedia,
+    } = parameters;
+
+    // Pause the primary audio producer
+    if (audioProducer) {
+      audioProducer.pause(); // Actual logic: pause instead of close for MediaSFU preference
+      updateAudioProducer(audioProducer);
+    }
+
+    // Update the UI
+    if (!videoAlreadyOn && islevel === "2") {
+      if (!lock_screen && !shared) {
+        updateMainWindow = true;
+        updateUpdateMainWindow(updateMainWindow);
+
+        await prepopulateUserMedia({ name: hostLabel, parameters });
+
+        updateMainWindow = false;
+        updateUpdateMainWindow(updateMainWindow);
+      }
+    }
+
+    // Notify the server about pausing audio producer
+    socket.emit("pauseProducerMedia", {
+      mediaTag: "audio",
+      roomName: roomName,
+    });
+
+    // Handle local audio transport
+    try {
+      await disconnectLocalSendTransportAudio({ parameters });
+    } catch (localError) {
+      console.log("Error disconnecting local audio send transport:", localError);
+    }
+  } catch (error) {
+    console.log("Error disconnecting primary audio send transport:", error);
+  }
+};