mediasfu-shared 1.0.0

package/src/consumers/streamSuccessAudioSwitch.ts

@@ -0,0 +1,315 @@
+
+
+import type { Producer, ProducerCodecOptions, ProducerOptions } from 'mediasoup-client/lib/types';
+import { Socket } from "socket.io-client";
+import { PrepopulateUserMediaParameters, PrepopulateUserMediaType, CreateSendTransportParameters, CreateSendTransportType, ConnectSendTransportAudioParameters, ConnectSendTransportAudioType, SleepType } from "../types/types";
+
+export interface StreamSuccessAudioSwitchParameters extends PrepopulateUserMediaParameters, CreateSendTransportParameters, ConnectSendTransportAudioParameters {
+  audioProducer: Producer | null;
+  localAudioProducer?: Producer | null;
+  socket: Socket;
+  localSocket?: Socket;
+  roomName: string;
+  localStream: MediaStream | null;
+  localStreamAudio: MediaStream | null;
+  audioParams: ProducerOptions;
+  audioPaused: boolean;
+  audioAlreadyOn: boolean;
+  transportCreated: boolean;
+  localTransportCreated?: boolean;
+  audioParamse?: ProducerCodecOptions;
+  defAudioID: string;
+  userDefaultAudioInputDevice: string;
+  hostLabel: string;
+  updateMainWindow: boolean;
+  videoAlreadyOn: boolean;
+  islevel: string;
+  lock_screen: boolean;
+  shared: boolean;
+
+  updateAudioProducer: (audioProducer: Producer | null) => void;
+  updateLocalAudioProducer?: (localAudioProducer: Producer | null) => void;
+  updateLocalStream: (localStream: MediaStream | null) => void;
+  updateAudioParams: (audioParams: ProducerOptions) => void;
+  updateDefAudioID: (defAudioID: string) => void;
+  updateUserDefaultAudioInputDevice: (userDefaultAudioInputDevice: string) => void;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+
+  // mediasfu functions
+  sleep: SleepType;
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  createSendTransport: CreateSendTransportType;
+  connectSendTransportAudio: ConnectSendTransportAudioType;
+
+  getUpdatedAllParams: () => StreamSuccessAudioSwitchParameters;
+  [key: string]: any;
+}
+
+export interface StreamSuccessAudioSwitchOptions {
+  stream: MediaStream;
+  parameters: StreamSuccessAudioSwitchParameters;
+}
+
+// Export the type definition for the function
+export type StreamSuccessAudioSwitchType = (options: StreamSuccessAudioSwitchOptions) => Promise<void>;
+
+/**
+ * Handles the switching of the audio stream upon successful stream connection.
+ *
+ * @param {StreamSuccessAudioSwitchOptions} options - The options for the audio stream success switch.
+ * @param {MediaStream} options.stream - The new media stream containing the audio track.
+ * @param {Object} options.parameters - The parameters required for setting up the audio stream.
+ * @param {Producer} options.parameters.audioProducer - The current audio producer.
+ * @param {Producer} options.parameters.localAudioProducer - The local audio producer.
+ * @param {Socket} options.parameters.socket - The socket connection for communication.
+ * @param {Socket} options.parameters.localSocket - The local socket connection for communication.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {MediaStream | null} options.parameters.localStream - The local media stream.
+ * @param {MediaStream | null} options.parameters.localStreamAudio - The local audio stream.
+ * @param {ProducerOptions} options.parameters.audioParams - The audio parameters.
+ * @param {boolean} options.parameters.audioPaused - Indicates if the audio is paused.
+ * @param {boolean} options.parameters.audioAlreadyOn - Indicates if the audio is already on.
+ * @param {boolean} options.parameters.transportCreated - Indicates if the transport is created.
+ * @param {ProducerCodecOptions} options.parameters.audioParamse - Additional audio parameters.
+ * @param {string} options.parameters.defAudioID - The default audio device ID.
+ * @param {string} options.parameters.userDefaultAudioInputDevice - The user default audio input device.
+ * @param {string} options.parameters.hostLabel - The label of the host.
+ * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window should be updated.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+ * @param {string} options.parameters.islevel - The level of the participant.
+ * @param {boolean} options.parameters.lock_screen - Indicates if the screen is locked.
+ * @param {boolean} options.parameters.shared - Indicates if the screen is shared.
+ * @param {Function} options.parameters.updateAudioProducer - Function to update the audio producer.
+ * @param {Function} options.parameters.updateLocalAudioProducer - Function to update the local audio producer.
+ * @param {Function} options.parameters.updateLocalStream - Function to update the local stream.
+ * @param {Function} options.parameters.updateAudioParams - Function to update the audio parameters.
+ * @param {Function} options.parameters.updateDefAudioID - Function to update the default audio device ID.
+ * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user default audio input device.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+ * @param {Function} options.parameters.sleep - Function to pause execution for a specified time.
+ * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {Function} options.parameters.createSendTransport - Function to create a send transport.
+ * @param {Function} options.parameters.connectSendTransportAudio - Function to connect the send transport for audio.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio stream switch is complete.
+ * 
+ * @example
+ * const options = {
+ *   stream: newAudioStream, // MediaStream object containing the new audio track
+ *   parameters: {
+ *     audioProducer: currentAudioProducer,
+ *     localAudioProducer: localAudioProducerInstance,
+ *     localSocket: localSocketInstance, 
+ *     socket: socketInstance,
+ *     roomName: "Room1",
+ *     localStream: null,
+ *     localStreamAudio: null,
+ *     audioParams: audioProducerOptions,
+ *     audioPaused: false,
+ *     audioAlreadyOn: true,
+ *     transportCreated: false,
+ *     audioParamse: additionalAudioParams,
+ *     defAudioID: "default-audio-device-id",
+ *     userDefaultAudioInputDevice: "user-input-device-id",
+ *     hostLabel: "Host",
+ *     islevel: "1",
+ *     videoAlreadyOn: false,
+ *     lock_screen: false,
+ *     shared: false,
+ *     updateAudioProducer: updateAudioProducerFunction,
+ *     updateLocalAudioProducer: updateLocalAudioProducerFunction,
+ *     updateLocalStream: updateLocalStreamFunction,
+ *     updateAudioParams: updateAudioParamsFunction,
+ *     updateDefAudioID: updateDefAudioIDFunction,
+ *     updateUserDefaultAudioInputDevice: updateUserDefaultAudioInputDeviceFunction,
+ *     updateUpdateMainWindow: updateMainWindowFunction,
+ *     sleep: sleepFunction,
+ *     prepopulateUserMedia: prepopulateUserMediaFunction,
+ *     createSendTransport: createSendTransportFunction,
+ *     connectSendTransportAudio: connectSendTransportAudioFunction,
+ *   },
+ * };
+ * 
+ * streamSuccessAudioSwitch(options)
+ *   .then(() => {
+ *     console.log('Audio stream switched successfully');
+ *   })
+ *   .catch(error => {
+ *     console.error('Error switching audio stream:', error);
+ *   });
+ */
+
+export const streamSuccessAudioSwitch = async ({
+  stream,
+  parameters,
+}: StreamSuccessAudioSwitchOptions): Promise<void> => {
+
+  let {
+    audioProducer,
+    localAudioProducer,
+    socket,
+    localSocket,
+    roomName,
+    localStream,
+    localStreamAudio,
+    audioParams,
+    audioPaused,
+    audioAlreadyOn,
+    transportCreated,
+    audioParamse,
+    defAudioID,
+    userDefaultAudioInputDevice,
+    hostLabel,
+    updateMainWindow,
+    videoAlreadyOn,
+    islevel,
+    lock_screen,
+    shared,
+
+    updateAudioProducer,
+    updateLocalAudioProducer,
+    updateLocalStream,
+    updateAudioParams,
+    updateDefAudioID,
+    updateUserDefaultAudioInputDevice,
+    updateUpdateMainWindow,
+
+    //mediasfu functions
+    sleep,
+    prepopulateUserMedia,
+    createSendTransport,
+    connectSendTransportAudio,
+  } = parameters;
+
+  // Get the new default audio device ID
+  let newDefAudioID = stream.getAudioTracks()[0].getSettings().deviceId;
+
+  // Check if the audio device has changed
+  if (newDefAudioID !== defAudioID) {
+    // Close the current audioProducer
+    if (audioProducer) {
+      audioProducer.close();
+      updateAudioProducer(audioProducer);
+    }
+
+    // Emit a pauseProducerMedia event to pause the audio media
+    socket.emit("pauseProducerMedia", {
+      mediaTag: "audio",
+      roomName: roomName,
+      force: true,
+    });
+
+    try {
+      if (localSocket && localSocket.id) {
+        if (localAudioProducer) {
+          localAudioProducer.close();
+          if (updateLocalAudioProducer){
+            updateLocalAudioProducer(localAudioProducer);
+          }
+        }
+        localSocket.emit("pauseProducerMedia", {
+          mediaTag: "audio",
+          roomName: roomName,
+          force: true,
+        });
+      }
+    } catch {
+      // Do nothing
+    }
+
+    // Update the localStreamAudio with the new audio tracks
+    localStreamAudio = stream;
+
+    // If localStream is null, create a new MediaStream with the new audio track
+    if (localStream == null) {
+      localStream = new MediaStream([
+        localStreamAudio.getAudioTracks()[0],
+      ]);
+    } else {
+      // Remove all existing audio tracks from localStream and add the new audio track
+      localStream.getAudioTracks().forEach((track) => {
+        localStream!.removeTrack(track);
+      });
+      localStream.addTrack(localStreamAudio.getAudioTracks()[0]);
+    }
+
+    // Update localStream
+    updateLocalStream(localStream);
+
+    // Get the new default audio device ID from the new audio track
+    const audioTracked = localStream.getAudioTracks()[0];
+    defAudioID = audioTracked.getSettings().deviceId || "";
+    updateDefAudioID(defAudioID);
+
+    // Update userDefaultAudioInputDevice
+    userDefaultAudioInputDevice = defAudioID;
+    updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+
+    // Update audioParams with the new audio track
+    audioParams = {
+      track: localStream.getAudioTracks()[0],
+      ...audioParamse,
+    };
+    updateAudioParams(audioParams);
+
+    // Sleep for 500 milliseconds
+    await sleep({ ms: 500 });
+
+    // Create a new send transport if not created, otherwise, connect the existing transport
+    if (!transportCreated) {
+      try {
+        await createSendTransport({
+          parameters: {
+            ...parameters,
+            audioParams: audioParams,
+          },
+          option: "audio",
+        });
+      } catch (error) {
+        console.error("Error creating send transport:", error);
+      }
+    } else {
+      await connectSendTransportAudio({
+        audioParams,
+        parameters,
+      });
+    }
+
+    // If audio is paused and not already on, pause the audioProducer and emit a pauseProducerMedia event
+    if (audioPaused === true && !audioAlreadyOn) {
+      audioProducer!.pause();
+      updateAudioProducer(audioProducer);
+      socket.emit("pauseProducerMedia", {
+        mediaTag: "audio",
+        roomName: roomName,
+      });
+
+      try {
+        if (localSocket && localSocket.id) {
+          localAudioProducer!.pause();
+          if (updateLocalAudioProducer){
+            updateLocalAudioProducer(localAudioProducer!);
+          }
+          localSocket.emit("pauseProducerMedia", {
+            mediaTag: "audio",
+            roomName: roomName,
+          });
+        }
+      } catch {
+        // Do nothing
+      }
+    }
+  }
+
+  // Update the UI based on the participant's level and screen lock status
+  if (!videoAlreadyOn && islevel === "2") {
+    if (!lock_screen && !shared) {
+      updateMainWindow = true;
+      updateUpdateMainWindow(updateMainWindow);
+      await prepopulateUserMedia({ name: hostLabel, parameters });
+      updateMainWindow = false;
+      updateUpdateMainWindow(updateMainWindow);
+    }
+  }
+};
+

package/src/consumers/streamSuccessScreen.ts

@@ -0,0 +1,255 @@
+ 
+
+import { Socket } from "socket.io-client";
+import {
+  SleepType, CreateSendTransportType, ConnectSendTransportScreenType, DisconnectSendTransportScreenType, StopShareScreenType, ReorderStreamsType, PrepopulateUserMediaType, RePortType,
+  ShowAlert, CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters,
+  EventType
+} from "../types/types";
+
+export interface StreamSuccessScreenParameters extends CreateSendTransportParameters, ConnectSendTransportScreenParameters, DisconnectSendTransportScreenParameters, StopShareScreenParameters, ReorderStreamsParameters, PrepopulateUserMediaParameters {
+  socket: Socket;
+  transportCreated: boolean;
+  localStreamScreen: MediaStream | null;
+  screenAlreadyOn: boolean;
+  screenAction: boolean;
+  transportCreatedScreen: boolean;
+  hostLabel: string;
+  eventType: EventType;
+  showAlert?: ShowAlert;
+  annotateScreenStream: boolean;
+  shared: boolean;
+
+  updateTransportCreatedScreen: (transportCreatedScreen: boolean) => void;
+  updateScreenAlreadyOn: (screenAlreadyOn: boolean) => void;
+  updateScreenAction: (screenAction: boolean) => void;
+  updateTransportCreated: (transportCreated: boolean) => void;
+  updateLocalStreamScreen: (localStreamScreen: MediaStream | null) => void;
+  updateShared: (shared: boolean) => void;
+  updateIsScreenboardModalVisible: (isVisible: boolean) => void;
+
+  // mediasfu functions
+  sleep: SleepType;
+  createSendTransport: CreateSendTransportType;
+  connectSendTransportScreen: ConnectSendTransportScreenType;
+  disconnectSendTransportScreen: DisconnectSendTransportScreenType;
+  stopShareScreen: StopShareScreenType;
+  reorderStreams: ReorderStreamsType;
+  prepopulateUserMedia: PrepopulateUserMediaType;
+  rePort: RePortType;
+
+  getUpdatedAllParams: () => StreamSuccessScreenParameters;
+  [key: string]: any;
+}
+
+export interface StreamSuccessScreenOptions {
+  stream: MediaStream;
+  parameters: StreamSuccessScreenParameters;
+}
+
+// Export the type definition for the function
+export type StreamSuccessScreenType = (options: StreamSuccessScreenOptions) => Promise<void>;
+
+/**
+ * Handles the successful initiation of screen sharing.
+ *
+ * @param {StreamSuccessScreenOptions} options - The options for the screen sharing success handler.
+ * @param {MediaStream} options.stream - The media stream to be shared.
+ * @param {Object} options.parameters - The parameters required for screen sharing.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport is already created.
+ * @param {MediaStream | null} options.parameters.localStreamScreen - The local screen media stream.
+ * @param {boolean} options.parameters.screenAlreadyOn - Flag indicating if the screen is already being shared.
+ * @param {boolean} options.parameters.screenAction - Flag indicating if the screen share action is requested.
+ * @param {boolean} options.parameters.transportCreatedScreen - Flag indicating if the screen transport is created.
+ * @param {string} options.parameters.hostLabel - The label of the host.
+ * @param {string} options.parameters.eventType - The type of the event (e.g., conference).
+ * @param {Function} options.parameters.showAlert - Function to show alerts.
+ * @param {boolean} options.parameters.annotateScreenStream - Flag indicating if screen annotation is enabled.
+ * @param {Function} options.parameters.updateTransportCreatedScreen - Function to update the screen transport creation state.
+ * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing state.
+ * @param {Function} options.parameters.updateScreenAction - Function to update the screen action state.
+ * @param {Function} options.parameters.updateTransportCreated - Function to update the transport creation state.
+ * @param {Function} options.parameters.updateLocalStreamScreen - Function to update the local screen stream.
+ * @param {Function} options.parameters.updateShared - Function to update the shared state.
+ * @param {Function} options.parameters.updateIsScreenboardModalVisible - Function to update the screenboard modal visibility.
+ * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.
+ * @param {Function} options.parameters.createSendTransport - Function to create a send transport.
+ * @param {Function} options.parameters.connectSendTransportScreen - Function to connect the send transport for screen sharing.
+ * @param {Function} options.parameters.disconnectSendTransportScreen - Function to disconnect the send transport for screen sharing.
+ * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+ * @param {Function} options.parameters.reorderStreams - Function to reorder streams.
+ * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+ * @param {Function} options.parameters.rePort - Function to reinitialize ports.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen sharing setup is complete.
+ * 
+ * @throws Will throw an error if there is an issue with screen sharing.
+ *  
+ * @example
+ * ```typescript
+ * await streamSuccessScreen({
+ *   stream: mediaStream,
+ *   parameters: {
+ *     socket,
+ *     transportCreated,
+ *     localStreamScreen: null,
+ *     screenAlreadyOn: false,
+ *     screenAction: true,
+ *     transportCreatedScreen: false,
+ *     hostLabel: "Host",
+ *     eventType: "conference",
+ *     showAlert,
+ *     annotateScreenStream: false,
+ *     updateTransportCreatedScreen,
+ *     updateScreenAlreadyOn,
+ *     updateScreenAction,
+ *     updateTransportCreated,
+ *     updateLocalStreamScreen,
+ *     updateShared,
+ *     updateIsScreenboardModalVisible,
+ *     sleep,
+ *     createSendTransport,
+ *     connectSendTransportScreen,
+ *     disconnectSendTransportScreen,
+ *     stopShareScreen,
+ *     reorderStreams,
+ *     prepopulateUserMedia,
+ *     rePort,
+ *   },
+ * });
+ * ```
+ */
+
+export const streamSuccessScreen = async ({
+  stream,
+  parameters,
+}: StreamSuccessScreenOptions): Promise<void> => {
+  let { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  let {
+    socket,
+    transportCreated,
+    localStreamScreen,
+    screenAlreadyOn,
+    screenAction,
+    transportCreatedScreen,
+    hostLabel,
+    eventType,
+    showAlert,
+    annotateScreenStream,
+
+    updateTransportCreatedScreen,
+    updateScreenAlreadyOn,
+    updateScreenAction,
+    updateTransportCreated,
+    updateLocalStreamScreen,
+    updateShared,
+    updateIsScreenboardModalVisible,
+    sleep,
+
+    // mediasfu functions
+    createSendTransport,
+    connectSendTransportScreen,
+    disconnectSendTransportScreen,
+    stopShareScreen,
+    reorderStreams,
+    prepopulateUserMedia,
+    rePort,
+  } = parameters;
+
+  // Share screen on success
+  localStreamScreen = stream;
+  updateLocalStreamScreen(localStreamScreen);
+
+  try {
+    // Create transport if not created else connect transport
+    if (!transportCreated) {
+      await createSendTransport({
+        option: "screen",
+        parameters: { ...parameters, localStreamScreen },
+      });
+    } else {
+      await connectSendTransportScreen({
+        stream: localStreamScreen,
+        parameters: { ...parameters, localStreamScreen },
+      });
+    }
+
+    // Alert the socket that you are sharing the screen
+    socket.emit("startScreenShare");
+  } catch (error: any) {
+    showAlert?.({
+      message: error.message,
+      type: "danger",
+      duration: 3000,
+    });
+  }
+
+  // Re-update the screen display
+  try {
+    updateShared(true);
+    await prepopulateUserMedia({
+      name: hostLabel,
+      parameters: { ...parameters, localStreamScreen, shared: true },
+    });
+  } catch (error) {
+    console.error("Error updating shared screen UI:", error);
+  }
+
+  // Update the screen sharing state
+  screenAlreadyOn = true;
+  updateScreenAlreadyOn(screenAlreadyOn);
+
+  // Reorder streams if required
+  try {
+    if (eventType === "conference") {
+      await reorderStreams({ add: false, screenChanged: true, parameters });
+      await prepopulateUserMedia({ name: hostLabel, parameters });
+    } else {
+      await reorderStreams({ parameters });
+    }
+  } catch {
+    try {
+      await rePort({ parameters });
+    } catch {
+      // console.error("Error reordering streams:", error);
+
+    }
+  }
+
+  // Handle screen share end
+  localStreamScreen.getVideoTracks()[0].onended = async function () {
+    // Supports both manual and automatic screen share end
+    await disconnectSendTransportScreen({ parameters });
+    await stopShareScreen({ parameters });
+  };
+
+  // If user requested to share screen, update the screenAction state
+  if (screenAction === true) {
+    screenAction = false;
+  }
+  updateScreenAction(screenAction);
+
+  // Update the transport created state
+  transportCreatedScreen = true;
+  updateTransportCreatedScreen(transportCreatedScreen);
+  transportCreated = true;
+  updateTransportCreated(transportCreated);
+
+  // Handle screen annotation modal
+  try {
+    if (annotateScreenStream) {
+      annotateScreenStream = false;
+      updateIsScreenboardModalVisible(true);
+      await sleep({ ms: 500 });
+      updateIsScreenboardModalVisible(false);
+    }
+  } catch (error) {
+    console.error("Error handling screen annotation:", error);
+  }
+
+
+};
+