mediasfu-shared 1.0.0

package/src/consumers/switchUserVideo.ts

@@ -0,0 +1,201 @@
+import { clickVideo, ClickVideoParameters } from "../methods/stream/clickVideo";
+import { ShowAlert, VidCons, RequestPermissionCameraType, StreamSuccessVideoType, SleepType, StreamSuccessVideoParameters } from "../types/types";
+
+export interface SwitchUserVideoParameters extends StreamSuccessVideoParameters, ClickVideoParameters {
+  audioOnlyRoom: boolean;
+  frameRate: number;
+  vidCons: VidCons;
+  prevVideoInputDevice: string;
+  userDefaultVideoInputDevice: string;
+  showAlert?: ShowAlert;
+  mediaDevices: MediaDevices;
+  hasCameraPermission: boolean;
+  updateVideoSwitching: (state: boolean) => void;
+  updateUserDefaultVideoInputDevice: (deviceId: string) => void;
+
+  // media functions
+  requestPermissionCamera: RequestPermissionCameraType;
+  streamSuccessVideo: StreamSuccessVideoType;
+  sleep: SleepType;
+  checkMediaPermission: boolean;
+  
+  getUpdatedAllParams: () => SwitchUserVideoParameters;
+  [key: string]: any;
+}
+
+export interface SwitchUserVideoOptions {
+  videoPreference: string;
+  checkoff: boolean;
+  parameters: SwitchUserVideoParameters;
+}
+
+// Export the type definition for the function
+export type SwitchUserVideoType = (options: SwitchUserVideoOptions) => Promise<void>;
+
+/**
+ * Switches the user's video input device based on the provided options.
+ *
+ * @param {SwitchUserVideoOptions} options - The options for switching the user's video.
+ * @param {string} options.videoPreference - The preferred video input device ID.
+ * @param {boolean} options.checkoff - Flag indicating whether to turn off the video.
+ * @param {Object} options.parameters - Additional parameters required for switching the video.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the room is audio-only.
+ * @param {number} options.parameters.frameRate - The desired frame rate for the video.
+ * @param {Object} options.parameters.vidCons - Video constraints such as width and height.
+ * @param {string} options.parameters.prevVideoInputDevice - The previous video input device ID.
+ * @param {Function} options.parameters.showAlert - Function to show alerts to the user.
+ * @param {Object} options.parameters.mediaDevices - Media devices object to access user media.
+ * @param {boolean} options.parameters.hasCameraPermission - Indicates if the user has camera permission.
+ * @param {Function} options.parameters.updateVideoSwitching - Function to update video switching state.
+ * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the default video input device.
+ * @param {Function} options.parameters.requestPermissionCamera - Function to request camera permission.
+ * @param {Function} options.parameters.streamSuccessVideo - Function to handle successful video stream.
+ * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.
+ * @param {Function} options.parameters.checkMediaPermission - Function to check media permissions.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video 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 switchUserVideo({
+ *   videoPreference: 'video-device-id',
+ *   checkoff: false,
+ *   parameters: {
+ *     audioOnlyRoom: false,
+ *     frameRate: 30,
+ *     vidCons: { width: 640, height: 480 },
+ *     prevVideoInputDevice: 'prev-video-device-id',
+ *     showAlert: showAlertFunction,
+ *     mediaDevices: navigator.mediaDevices,
+ *     hasCameraPermission: true,
+ *     updateVideoSwitching: updateVideoSwitchingFunction,
+ *     updateUserDefaultVideoInputDevice: updateUserDefaultVideoInputDeviceFunction,
+ *     requestPermissionCamera: requestPermissionCameraFunction,
+ *     streamSuccessVideo: streamSuccessVideoFunction,
+ *     sleep: sleepFunction,
+ *     checkMediaPermission: true,
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *   },
+ * });
+ * ```
+ */
+
+export async function switchUserVideo({
+  videoPreference,
+  checkoff,
+  parameters,
+}: SwitchUserVideoOptions): Promise<void> {
+  const {
+    audioOnlyRoom,
+    frameRate,
+    vidCons,
+    prevVideoInputDevice,
+    showAlert,
+    mediaDevices,
+    hasCameraPermission,
+    updateVideoSwitching,
+    updateUserDefaultVideoInputDevice,
+
+    //mediasfu functions
+    requestPermissionCamera,
+    streamSuccessVideo,
+    sleep,
+    checkMediaPermission,
+  } = parameters;
+
+  try {
+    // Check if it's an audio-only room
+    if (audioOnlyRoom) {
+
+      showAlert?.({
+        message: "You cannot turn on your camera in an audio-only event.",
+        type: "danger",
+        duration: 3000,
+      });
+
+      return;
+    }
+
+    // If checkoff is not true, trigger a click on the video button to turn off the video
+    if (!checkoff) {
+      await clickVideo({ parameters });
+      updateVideoSwitching(true);
+      await sleep({ ms: 500 });
+      updateVideoSwitching(false);
+    }
+
+    // Check camera permission
+    if (!hasCameraPermission) {
+      if (checkMediaPermission) {
+        const statusCamera = await requestPermissionCamera();
+        if (statusCamera !== "granted") {
+
+          showAlert?.({
+            message:
+              "Allow access to your camera or check if your camera is not being used by another application.",
+            type: "danger",
+            duration: 3000,
+          });
+
+          return;
+        }
+      }
+    }
+
+    let mediaConstraints: MediaStreamConstraints;
+
+    if (vidCons && vidCons.width && vidCons.height) {
+      mediaConstraints = {
+        video: {
+          deviceId: { exact: videoPreference },
+          ...vidCons,
+          frameRate: { ideal: frameRate },
+        },
+        audio: false,
+      };
+    } else {
+      mediaConstraints = {
+        video: {
+          deviceId: { exact: videoPreference },
+          frameRate: { ideal: frameRate },
+        },
+        audio: false,
+      };
+    }
+
+    // Get user media with the defined constraints
+    await mediaDevices
+      .getUserMedia(mediaConstraints)
+      .then(async (stream) => {
+        await streamSuccessVideo({ stream, parameters });
+      })
+      .catch(async () => {
+        // Handle errors and revert to the previous video input device
+        updateUserDefaultVideoInputDevice(prevVideoInputDevice);
+
+
+        showAlert?.({
+          message:
+            "Error switching; not accessible, might need to turn off your video and turn it back on after switching.",
+          type: "danger",
+          duration: 3000,
+        });
+
+      });
+  } catch {
+    // Handle unexpected errors and revert to the previous video input device
+    updateUserDefaultVideoInputDevice(prevVideoInputDevice);
+
+
+    showAlert?.({
+      message:
+        "Error switching; not accessible, might need to turn off your video and turn it back on after switching.",
+      type: "danger",
+      duration: 3000,
+    });
+
+  }
+}
+

package/src/consumers/switchUserVideoAlt.ts

@@ -0,0 +1,331 @@
+import { clickVideo, ClickVideoParameters } from "../methods/stream/clickVideo";
+import { ShowAlert, VidCons, RequestPermissionCameraType, StreamSuccessVideoType, SleepType, StreamSuccessVideoParameters } from "../types/types";
+
+
+export interface SwitchUserVideoAltParameters extends StreamSuccessVideoParameters, ClickVideoParameters {
+  audioOnlyRoom: boolean;
+  frameRate: number;
+  vidCons: VidCons;
+  showAlert?: ShowAlert;
+  mediaDevices: MediaDevices;
+  hasCameraPermission: boolean;
+  updateVideoSwitching: (state: boolean) => void;
+  updateCurrentFacingMode: (mode: string) => void;
+
+  // mediasfu functions
+  requestPermissionCamera: RequestPermissionCameraType;
+  streamSuccessVideo: StreamSuccessVideoType;
+  sleep: SleepType;
+  checkMediaPermission: boolean;
+  getUpdatedAllParams: () => SwitchUserVideoAltParameters;
+
+  [key: string]: any;
+}
+
+export interface SwitchUserVideoAltOptions {
+  videoPreference: string;
+  checkoff: boolean;
+  parameters: SwitchUserVideoAltParameters;
+}
+
+// Export the type definition for the function
+export type SwitchUserVideoAltType = (options: SwitchUserVideoAltOptions) => Promise<void>;
+
+/**
+ * Switches the user's video stream based on the provided video preference and other parameters.
+ * 
+ * @param {SwitchUserVideoAltOptions} options - The options for switching the user's video.
+ * @param {string} options.videoPreference - The preferred video facing mode (e.g., "user" or "environment").
+ * @param {boolean} options.checkoff - A flag indicating whether to turn off the video before switching.
+ * @param {SwitchUserVideoAltParameters} options.parameters - The parameters required for switching the video.
+ * 
+ * @returns {Promise<void>} A promise that resolves when the video switching is complete.
+ * 
+ * @throws Will throw an error if there is an issue with switching the video.
+ * 
+ * @example
+ * ```typescript
+ * const options = {
+ *   videoPreference: "user",
+ *   checkoff: false,
+ *   parameters: {
+ *     audioOnlyRoom: false,
+ *     frameRate: 30,
+ *     vidCons: { width: 640, height: 480 },
+ *     showAlert: showNotification,
+ *     mediaDevices: navigator.mediaDevices,
+ *     hasCameraPermission: true,
+ *     updateVideoSwitching: updateVideoSwitchingState,
+ *     updateCurrentFacingMode: updateCurrentFacingMode,
+ *     requestPermissionCamera: requestCameraPermission,
+ *     streamSuccessVideo: streamSuccessVideoFunction,
+ *     sleep: sleepFunction,
+ *     checkMediaPermission: true,
+ *     getUpdatedAllParams: getUpdatedAllParamsFunction,
+ *   },
+ * };
+ * 
+ * switchUserVideoAlt(options)
+ *   .then(() => {
+ *     console.log("Video switched successfully");
+ *   })
+ *   .catch((error) => {
+ *     console.error("Error switching video:", error);
+ *   });
+ * ```
+ */
+
+export async function switchUserVideoAlt({
+  videoPreference,
+  checkoff,
+  parameters,
+}: SwitchUserVideoAltOptions): Promise<void> {
+  const updatedParameters = parameters.getUpdatedAllParams();
+
+  const {
+    audioOnlyRoom,
+    frameRate,
+    vidCons,
+    showAlert,
+    mediaDevices,
+    hasCameraPermission,
+    updateVideoSwitching,
+    updateCurrentFacingMode,
+
+    //mediasfu functions
+    requestPermissionCamera,
+    streamSuccessVideo,
+    sleep,
+    checkMediaPermission,
+  } = parameters;
+
+  let { currentFacingMode, prevFacingMode } = updatedParameters;
+
+  try {
+    if (audioOnlyRoom) {
+      showAlert?.({
+        message: "You cannot turn on your camera in an audio-only event.",
+        type: "danger",
+        duration: 3000,
+      });
+      return;
+    }
+
+    // If checkoff is not true, trigger a click on the video button to turn off the video
+    if (!checkoff) {
+      await clickVideo({ parameters });
+      updateVideoSwitching(true);
+      await sleep({ ms: 500 });
+      updateVideoSwitching(false);
+    }
+
+    // Check camera permission
+    if (!hasCameraPermission && checkMediaPermission) {
+      const statusCamera = await requestPermissionCamera();
+      if (statusCamera !== "granted") {
+        showAlert?.({
+          message:
+            "Allow access to your camera or check if your camera is not being used by another application.",
+          type: "danger",
+          duration: 3000,
+        });
+        return;
+      }
+    }
+
+    // Enumerate video devices
+    const videoDevices = await mediaDevices.enumerateDevices();
+
+    // Define media constraints based on preferences and options
+    let mediaConstraints = {};
+
+    if (vidCons && vidCons.width && vidCons.height) {
+      mediaConstraints = {
+        video: {
+          facingMode: { exact: videoPreference },
+          ...vidCons,
+          frameRate: { ideal: frameRate },
+        },
+        audio: false,
+      };
+    } else {
+      mediaConstraints = {
+        video: {
+          facingMode: { exact: videoPreference },
+          frameRate: { ideal: frameRate },
+        },
+        audio: false,
+      };
+    }
+
+    // Get user media with the defined constraints
+    await mediaDevices
+      .getUserMedia(mediaConstraints)
+      .then(async (stream) => {
+        await streamSuccessVideo({ stream, parameters });
+      })
+      .catch(async () => {
+        let videoDevicesFront: MediaDeviceInfo[] = [];
+
+        // Filter video devices based on the preferred facing mode
+        if (videoPreference === "user") {
+          videoDevicesFront = videoDevices.filter(
+            (device) =>
+              device.label.includes("front") && device.kind === "videoinput"
+          );
+        } else {
+          videoDevicesFront = videoDevices.filter(
+            (device) =>
+              device.label.includes("back") && device.kind === "videoinput"
+          );
+        }
+
+        if (videoDevicesFront.length > 0) {
+          videoDevicesFront.forEach((device) => {
+            if (device.kind === "videoinput") {
+              let videoDeviceId = device.deviceId;
+
+              // Update media constraints with the specific video device
+              if (vidCons && vidCons.width && vidCons.height) {
+                mediaConstraints = {
+                  video: {
+                    deviceId: { exact: videoDeviceId },
+                    ...vidCons,
+                    frameRate: { ideal: frameRate },
+                  },
+                  audio: false,
+                };
+              } else {
+                mediaConstraints = {
+                  video: {
+                    deviceId: { exact: videoDeviceId },
+                    frameRate: { ideal: frameRate },
+                  },
+                  audio: false,
+                };
+              }
+
+              // Try to get user media with the new constraints
+              mediaDevices
+                .getUserMedia(mediaConstraints)
+                .then(async (stream) => {
+                  await streamSuccessVideo({ stream, parameters });
+                })
+                .catch(() => {
+                  // If the current video device is the last one in the list, show the error; otherwise, try the next device
+                  if (
+                    videoDeviceId ===
+                    videoDevicesFront[videoDevicesFront.length - 1].deviceId
+                  ) {
+                    currentFacingMode = prevFacingMode;
+                    updateCurrentFacingMode(currentFacingMode);
+
+                    showAlert?.({
+                      message:
+                        "Error switching; not accessible, might need to turn off your video and turn it back on after switching.",
+                      type: "danger",
+                      duration: 3000,
+                    });
+
+                  }
+                });
+            }
+          });
+        } else {
+          // Show error if no compatible video devices are found
+          currentFacingMode = prevFacingMode;
+          updateCurrentFacingMode(currentFacingMode);
+
+
+          showAlert?.({
+            message:
+              "Error switching; not accessible, might need to turn off your video and turn it back on after switching.",
+            type: "danger",
+            duration: 3000,
+          });
+
+        }
+      });
+  } catch {
+    // Handle any unexpected errors
+
+    const videoDevices = await mediaDevices.enumerateDevices();
+    // Handle any unexpected errors
+    let videoDevicesFront: MediaDeviceInfo[] = [];
+    if (videoPreference === "user") {
+      videoDevicesFront = videoDevices.filter(
+        (device) =>
+          device.label.includes("front") && device.kind === "videoinput"
+      );
+    } else {
+      videoDevicesFront = videoDevices.filter(
+        (device) =>
+          device.label.includes("back") && device.kind === "videoinput"
+      );
+    }
+
+    let mediaConstraints = {};
+
+    if (videoDevicesFront.length > 0) {
+      videoDevicesFront.forEach((device) => {
+        if (device.kind === "videoinput") {
+          let videoDeviceId = device.deviceId;
+
+          if (vidCons && vidCons.width && vidCons.height) {
+            mediaConstraints = {
+              video: {
+                deviceId: { exact: videoDeviceId },
+                ...vidCons,
+                frameRate: { ideal: frameRate },
+              },
+              audio: false,
+            };
+          } else {
+            mediaConstraints = {
+              video: {
+                deviceId: { exact: videoDeviceId },
+                frameRate: { ideal: frameRate },
+              },
+              audio: false,
+            };
+          }
+
+          mediaDevices
+            .getUserMedia(mediaConstraints)
+            .then(async (stream) => {
+              await streamSuccessVideo({ stream, parameters });
+            })
+            .catch(() => {
+              if (
+                videoDeviceId ===
+                videoDevicesFront[videoDevicesFront.length - 1].deviceId
+              ) {
+                currentFacingMode = prevFacingMode;
+                updateCurrentFacingMode(currentFacingMode);
+
+                showAlert?.({
+                  message:
+                    "Error switching; not accessible, might need to turn off your video and turn it back on after switching.",
+                  type: "danger",
+                  duration: 3000,
+                });
+
+              }
+            });
+        }
+      });
+    } else {
+      currentFacingMode = prevFacingMode;
+      updateCurrentFacingMode(currentFacingMode);
+
+
+      showAlert?.({
+        message:
+          "Error switching; not accessible, might need to turn off your video and turn it back on after switching.",
+        type: "danger",
+        duration: 3000,
+      });
+
+    }
+  }
+}