mediasfu-shared 1.0.0

package/src/consumers/streamSuccessVideo.ts

@@ -0,0 +1,373 @@
+import type { Device, Producer, ProducerOptions, RtpCodecCapability } from 'mediasoup-client/lib/types';
+import { Socket } from "socket.io-client";
+import { ConnectSendTransportVideoParameters, Participant, ShowAlert, CreateSendTransportParameters, ReorderStreamsParameters, SleepType, CreateSendTransportType, ConnectSendTransportVideoType, ReorderStreamsType, HParamsType, VParamsType } from "../types/types";
+
+export interface StreamSuccessVideoParameters extends CreateSendTransportParameters, ConnectSendTransportVideoParameters, ReorderStreamsParameters {
+  socket: Socket;
+  participants: Participant[];
+  localStream: MediaStream | null;
+  transportCreated: boolean;
+  transportCreatedVideo: boolean;
+  videoAlreadyOn: boolean;
+  videoAction: boolean;
+  videoParams: ProducerOptions;
+  localStreamVideo: MediaStream | null;
+  defVideoID: string;
+  userDefaultVideoInputDevice: string;
+  params: ProducerOptions;
+  videoParamse?: ProducerOptions;
+  islevel: string;
+  member: string;
+  updateMainWindow: boolean;
+  lock_screen: boolean;
+  shared: boolean;
+  shareScreenStarted: boolean;
+  vParams: VParamsType;
+  hParams: HParamsType;
+  allowed: boolean;
+  currentFacingMode: string;
+  device: Device | null;
+  keepBackground: boolean;
+  appliedBackground: boolean;
+  videoProducer: Producer | null;
+
+  // Update functions
+  updateTransportCreatedVideo: (created: boolean) => void;
+  updateVideoAlreadyOn: (videoOn: boolean) => void;
+  updateVideoAction: (videoAction: boolean) => void;
+  updateLocalStream: (stream: MediaStream | null) => void;
+  updateLocalStreamVideo: (stream: MediaStream | null) => void;
+  updateUserDefaultVideoInputDevice: (device: string) => void;
+  updateCurrentFacingMode: (mode: string) => void;
+  updateDefVideoID: (id: string) => void;
+  updateAllowed: (allowed: boolean) => void;
+  updateUpdateMainWindow: (updateMainWindow: boolean) => void;
+  updateParticipants: (participants: Participant[]) => void;
+  updateVideoParams: (params: ProducerOptions) => void;
+  updateIsBackgroundModalVisible: (isVisible: boolean) => void;
+  updateAutoClickBackground: (autoClick: boolean) => void;
+
+  showAlert?: ShowAlert;
+
+  // Media functions
+  createSendTransport: CreateSendTransportType;
+  connectSendTransportVideo: ConnectSendTransportVideoType;
+  reorderStreams: ReorderStreamsType;
+  sleep: SleepType;
+
+  getUpdatedAllParams: () => StreamSuccessVideoParameters;
+  [key: string]: any;
+}
+
+export interface StreamSuccessVideoOptions {
+  stream: MediaStream;
+  parameters: StreamSuccessVideoParameters;
+}
+
+// Export the type definition for the function
+export type StreamSuccessVideoType = (options: StreamSuccessVideoOptions) => Promise<void>;
+
+
+/**
+ * Handles the successful streaming of video by managing the local stream, updating parameters, and handling video transport.
+ *
+ * @param {StreamSuccessVideoOptions} options - The options for streaming the video.
+ * @param {MediaStream} options.stream - The media stream to be used for the video.
+ * @param {Object} options.parameters - The parameters required for streaming the video.
+ * @param {Socket} options.parameters.socket - The socket connection for communication.
+ * @param {Array<Participant>} options.parameters.participants - The list of participants in the room.
+ * @param {MediaStream | null} options.parameters.localStream - The local media stream.
+ * @param {MediaStream | null} options.parameters.localStreamVideo - The local video stream.
+ * @param {boolean} options.parameters.transportCreated - Indicates if the transport has been created.
+ * @param {boolean} options.parameters.transportCreatedVideo - Indicates if the video transport has been created.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is already on.
+ * @param {boolean} options.parameters.videoAction - Indicates the action state of the video.
+ * @param {ProducerOptions} options.parameters.videoParams - The video parameters for the producer.
+ * @param {string} options.parameters.defVideoID - The default video device ID.
+ * @param {string} options.parameters.userDefaultVideoInputDevice - The user default video input device.
+ * @param {string} options.parameters.hostLabel - The label of the host.
+ * @param {string} options.parameters.islevel - The level of the participant.
+ * @param {string} options.parameters.member - The name of the participant.
+ * @param {boolean} options.parameters.updateMainWindow - Indicates if the main window should be updated.
+ * @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.shareScreenStarted - Indicates if screen sharing has started.
+ * @param {VParamsType} options.parameters.vParams - Video parameters.
+ * @param {HParamsType} options.parameters.hParams - Horizontal parameters.
+ * @param {boolean} options.parameters.allowed - Indicates if the action is allowed.
+ * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera.
+ * @param {Device | null} options.parameters.device - The device being used for streaming.
+ * @param {boolean} options.parameters.keepBackground - Indicates if the background should be kept.
+ * @param {boolean} options.parameters.appliedBackground - Indicates if the background has been applied.
+ * @param {Producer | null} options.parameters.videoProducer - The video producer instance.
+ * @param {Function} options.parameters.updateTransportCreatedVideo - Function to update the transport created state for video.
+ * @param {Function} options.parameters.updateVideoAlreadyOn - Function to update the video already on state.
+ * @param {Function} options.parameters.updateVideoAction - Function to update the video action state.
+ * @param {Function} options.parameters.updateLocalStream - Function to update the local stream.
+ * @param {Function} options.parameters.updateLocalStreamVideo - Function to update the local video stream.
+ * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the user default video input device.
+ * @param {Function} options.parameters.updateCurrentFacingMode - Function to update the current facing mode.
+ * @param {Function} options.parameters.updateDefVideoID - Function to update the default video device ID.
+ * @param {Function} options.parameters.updateAllowed - Function to update the allowed state.
+ * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window state.
+ * @param {Function} options.parameters.createSendTransport - Function to create a send transport.
+ * @param {Function} options.parameters.connectSendTransportVideo - Function to connect the send transport for video.
+ * @param {Function} options.parameters.showAlert - Function to display alert messages to the user.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video streaming setup is complete.
+ * 
+ * @throws Will throw an error if there is an issue with streaming the video.
+ * 
+ * @example
+ * ```typescript
+ * await streamSuccessVideo({
+ *   stream: mediaStream,
+ *   parameters: {
+ *     socket,
+ *     participants,
+ *     localStream: null,
+ *     localStreamVideo: null,
+ *     transportCreated: false,
+ *     transportCreatedVideo: false,
+ *     videoAlreadyOn: false,
+ *     videoAction: false,
+ *     videoParams: producerOptions,
+ *     defVideoID: "default-video-id",
+ *     userDefaultVideoInputDevice: "user-device-id",
+ *     hostLabel: "Host",
+ *     islevel: "1",
+ *     member: "Participant1",
+ *     lock_screen: false,
+ *     shared: false,
+ *     shareScreenStarted: false,
+ *     vParams,
+ *     hParams,
+ *     allowed: true,
+ *     currentFacingMode: "user",
+ *     device: mediaDevice,
+ *     updateTransportCreatedVideo,
+ *     updateVideoAlreadyOn,
+ *     updateVideoAction,
+ *     updateLocalStream,
+ *     updateLocalStreamVideo,
+ *     updateUserDefaultVideoInputDevice,
+ *     updateCurrentFacingMode,
+ *     updateDefVideoID,
+ *     updateAllowed,
+ *     updateUpdateMainWindow,
+ *     createSendTransport,
+ *     connectSendTransportVideo,
+ *     showAlert,
+ *   },
+ * });
+ * ```
+ */
+
+
+export const streamSuccessVideo = async ({
+  stream,
+  parameters,
+}: StreamSuccessVideoOptions): Promise<void> => {
+
+  let { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+
+  try {
+    let {
+      socket,
+      participants,
+      localStream,
+      transportCreated,
+      transportCreatedVideo,
+      videoAlreadyOn,
+      videoAction,
+      videoParams,
+      localStreamVideo,
+      defVideoID,
+      userDefaultVideoInputDevice,
+      params,
+      videoParamse,
+      islevel,
+      member,
+      updateMainWindow,
+      lock_screen,
+      shared,
+      shareScreenStarted,
+      vParams,
+      hParams,
+      allowed,
+      currentFacingMode,
+      device,
+
+      keepBackground,
+      appliedBackground,
+      videoProducer,
+
+      updateTransportCreatedVideo,
+      updateVideoAlreadyOn,
+      updateVideoAction,
+      updateLocalStream,
+      updateLocalStreamVideo,
+      updateUserDefaultVideoInputDevice,
+      updateCurrentFacingMode,
+      updateDefVideoID,
+      updateAllowed,
+      updateUpdateMainWindow,
+      updateParticipants,
+      updateVideoParams,
+      updateIsBackgroundModalVisible,
+      updateAutoClickBackground,
+
+      //mediasfu functions
+      createSendTransport,
+      connectSendTransportVideo,
+      showAlert,
+      reorderStreams,
+      sleep,
+    } = parameters;
+
+    localStreamVideo = stream;
+    updateLocalStreamVideo(localStreamVideo);
+
+    if (localStream == null) {
+      localStream = new MediaStream([
+        localStreamVideo.getVideoTracks()[0],
+      ]);
+      updateLocalStream(localStream);
+    } else {
+      // remove all video tracks that are currently in the localStream
+      localStream.getVideoTracks().forEach((track) => {
+        localStream!.removeTrack(track);
+      });
+      // add the new video track to the localStream
+      localStream.addTrack(localStreamVideo.getVideoTracks()[0]);
+      updateLocalStream(localStream);
+    }
+
+    const videoTracked = localStream.getVideoTracks()[0];
+    defVideoID = videoTracked.getSettings().deviceId || '';
+    userDefaultVideoInputDevice = defVideoID;
+    currentFacingMode = videoTracked.getSettings().facingMode || 'user';
+
+    if (defVideoID) {
+      updateDefVideoID(defVideoID);
+    }
+    if (userDefaultVideoInputDevice) {
+      updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);
+    }
+    if (currentFacingMode) {
+      updateCurrentFacingMode(currentFacingMode);
+    }
+
+    allowed = true;
+    updateAllowed(allowed);
+
+    try {
+      if (islevel === "2") {
+        params = shared || shareScreenStarted ? vParams : hParams;
+        videoParamse = { ...params };
+      } else {
+        params = vParams;
+        videoParamse = { ...params };
+      }
+
+      let codec = device?.rtpCapabilities?.codecs?.filter(
+        (codec: RtpCodecCapability) => codec.mimeType.toLowerCase() !== "video/vp9" && codec.kind === "video"
+      ) || [];
+
+      videoParams = {
+        track: localStream.getVideoTracks()[0],
+        ...videoParamse,
+        codec: codec[0],
+      };
+      updateVideoParams(videoParams);
+
+      if (keepBackground && appliedBackground) {
+        videoAlreadyOn = true;
+        updateVideoAlreadyOn(videoAlreadyOn);
+
+        updateAutoClickBackground(true);
+        updateIsBackgroundModalVisible(true);
+        await sleep({ ms: 500 });
+        updateIsBackgroundModalVisible(false);
+        updateAutoClickBackground(false);
+      } else {
+        if (!transportCreated) {
+          try {
+            await createSendTransport({
+              parameters: { ...parameters, videoParams },
+              option: "video",
+            });
+          } catch { /* Handle error */}
+        } else {
+          try {
+            videoProducer!.close();
+            await sleep({ ms: 500 });
+          } catch { /* Handle error */}
+          await connectSendTransportVideo({
+            parameters,
+            videoParams,
+          });
+        }
+      }
+    } catch (error) {
+      showAlert?.({
+        message: (error as Error).message,
+        type: "danger",
+        duration: 3000,
+      });
+    }
+
+    videoAlreadyOn = true;
+    updateVideoAlreadyOn(videoAlreadyOn);
+
+    if (videoAction === true) {
+      videoAction = false;
+      updateVideoAction(videoAction);
+    }
+
+    if (islevel === "2") {
+      updateMainWindow = true;
+      updateUpdateMainWindow(updateMainWindow);
+    }
+
+    //update the participants array to reflect the change
+    participants.forEach((participant) => {
+      if (participant.socketId == socket.id && participant.name == member) {
+        participant.videoOn = true;
+      }
+    });
+    updateParticipants(participants);
+
+    transportCreatedVideo = true;
+    updateTransportCreatedVideo(transportCreatedVideo);
+
+    //reupdate the screen display
+    if (lock_screen) {
+      await reorderStreams({
+        add: true,
+        screenChanged: true,
+        parameters: { ...parameters, videoAlreadyOn },
+      });
+    } else {
+      try {
+        await reorderStreams({
+          add: false,
+          screenChanged: true,
+          parameters: { ...parameters, videoAlreadyOn },
+        });
+      } catch { /* Handle error */}
+    }
+  } catch (error) {
+    try {
+      let { showAlert } = parameters;
+
+      showAlert?.({
+        message: (error as Error).message,
+        type: "danger",
+        duration: 3000,
+      });
+    } catch { /* Handle error */}
+  }
+};
+

package/src/consumers/switchUserAudio.ts

@@ -0,0 +1,140 @@
+import { ShowAlert, StreamSuccessAudioSwitchType, RequestPermissionAudioType, StreamSuccessAudioSwitchParameters } from "../types/types";
+
+
+export interface SwitchUserAudioParameters extends StreamSuccessAudioSwitchParameters {
+  mediaDevices: MediaDevices;
+  userDefaultAudioInputDevice: string;
+  prevAudioInputDevice: string;
+  showAlert?: ShowAlert;
+  hasAudioPermission: boolean;
+  updateUserDefaultAudioInputDevice: (deviceId: string) => void;
+
+  // mediasfu functions
+  streamSuccessAudioSwitch: StreamSuccessAudioSwitchType;
+  requestPermissionAudio: RequestPermissionAudioType;
+  checkMediaPermission: boolean;
+
+  [key: string]: any;
+}
+
+export interface SwitchUserAudioOptions {
+  audioPreference: string;
+  parameters: SwitchUserAudioParameters;
+}
+
+// Export the type definition for the function
+export type SwitchUserAudioType = (options: SwitchUserAudioOptions) => Promise<void>;
+
+/**
+ * Switches the user's audio input device based on the provided audio preference.
+ * 
+ * @param {SwitchUserAudioOptions} options - The options for switching the user's audio input device.
+ * @param {string} options.audioPreference - The preferred audio input device ID.
+ * @param {Object} options.parameters - Additional parameters required for switching the audio input device.
+ * @param {MediaDevices} options.parameters.mediaDevices - The media devices interface for accessing user media.
+ * @param {string} options.parameters.prevAudioInputDevice - The previous audio input device ID.
+ * @param {Function} options.parameters.showAlert - Function to show alert messages.
+ * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has granted audio permission.
+ * @param {Function} options.parameters.updateUserDefaultAudioInputDevice - Function to update the user's default audio input device.
+ * @param {Function} options.parameters.streamSuccessAudioSwitch - Function to handle successful audio stream switch.
+ * @param {Function} options.parameters.requestPermissionAudio - Function to request audio permission from the user.
+ * @param {Function} options.parameters.checkMediaPermission - Function to check if media permission is granted.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the audio input device has been successfully switched.
+ * 
+ * @throws Will throw an error if the audio input device cannot be accessed or if there is an unexpected error.
+ * 
+ * @example
+ * ```typescript
+ * await switchUserAudio({
+ *   audioPreference: 'audio-device-id',
+ *   parameters: {
+ *     mediaDevices,
+ *     prevAudioInputDevice: 'prev-audio-device-id',
+ *     showAlert,
+ *     hasAudioPermission,
+ *     updateUserDefaultAudioInputDevice,
+ *     streamSuccessAudioSwitch,
+ *     requestPermissionAudio,
+ *     checkMediaPermission,
+ *   },
+ * });
+ * ```
+ */
+
+
+export async function switchUserAudio({ audioPreference, parameters }: SwitchUserAudioOptions): Promise<void> {
+  const {
+    mediaDevices,
+    prevAudioInputDevice,
+    showAlert,
+    hasAudioPermission,
+    updateUserDefaultAudioInputDevice,
+
+    // Media functions
+    streamSuccessAudioSwitch,
+    requestPermissionAudio,
+    checkMediaPermission,
+  } = parameters;
+
+  try {
+    // Check if audio permission is granted
+    if (!hasAudioPermission) {
+      if (checkMediaPermission) {
+        const statusMic = await requestPermissionAudio();
+        if (statusMic !== "granted") {
+          showAlert?.({
+            message:
+              "Allow access to your microphone or check if your microphone is not being used by another application.",
+            type: "danger",
+            duration: 3000,
+          });
+          return;
+        }
+      }
+    }
+
+    const mediaConstraints: MediaStreamConstraints = {
+      audio: {
+        deviceId: { exact: audioPreference },
+        echoCancellation: false,
+        noiseSuppression: false,
+        autoGainControl: false,
+      },
+      video: false,
+    };
+
+    // Get user media with the defined audio constraints
+    await mediaDevices
+      .getUserMedia(mediaConstraints)
+      .then(async (stream) => {
+        await streamSuccessAudioSwitch({ stream, parameters });
+      })
+      .catch((error) => {
+        console.log("Error switching audio A", error);
+        // Handle errors and revert to the previous audio input device
+        updateUserDefaultAudioInputDevice(prevAudioInputDevice);
+
+
+        showAlert?.({
+          message: "Error switching; the specified microphone could not be accessed.",
+          type: "danger",
+          duration: 3000,
+        });
+
+      });
+  } catch (error) {
+    console.log("Error switching audio", error);
+    // Handle unexpected errors and revert to the previous audio input device
+    updateUserDefaultAudioInputDevice(prevAudioInputDevice);
+
+
+    showAlert?.({
+      message: "Error switching; the specified microphone could not be accessed.",
+      type: "danger",
+      duration: 3000,
+    });
+
+  }
+}
+