mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/switch-user-video-alt.service.mjs

@@ -0,0 +1,228 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../methods/stream-methods/click-video.service";
+export class SwitchUserVideoAlt {
+    ClickVideoService;
+    constructor(ClickVideoService) {
+        this.ClickVideoService = ClickVideoService;
+    }
+    /**
+     * Switches the user's video stream based on the provided video preference and other parameters.
+     *
+     * @param {Object} 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 {SwitchUserVideoAltOptions} 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.
+     */
+    async switchUserVideoAlt({ videoPreference, checkoff, parameters, }) {
+        let { getUpdatedAllParams } = parameters;
+        let parameters_ = getUpdatedAllParams();
+        let { audioOnlyRoom, frameRate, vidCons, showAlert, hasCameraPermission, updateVideoSwitching, updateCurrentFacingMode, 
+        // mediasfu functions
+        requestPermissionCamera, streamSuccessVideo, sleep, checkMediaPermission, } = parameters;
+        let { currentFacingMode, prevFacingMode } = 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 this.ClickVideoService.clickVideo({ parameters });
+                updateVideoSwitching(true);
+                await sleep({ ms: 500 });
+                updateVideoSwitching(false);
+            }
+            // Check camera permission
+            if (!hasCameraPermission) {
+                if (checkMediaPermission) {
+                    let 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 navigator.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 navigator.mediaDevices
+                .getUserMedia(mediaConstraints)
+                .then(async (stream) => {
+                await streamSuccessVideo({ stream, parameters });
+            })
+                .catch(async () => {
+                let videoDevicesFront = [];
+                // 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
+                            navigator.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 (error) {
+            // Handle any unexpected errors
+            const videoDevices = await navigator.mediaDevices.enumerateDevices();
+            let videoDevicesFront = [];
+            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,
+                            };
+                        }
+                        navigator.mediaDevices
+                            .getUserMedia(mediaConstraints)
+                            .then(async (stream) => {
+                            await streamSuccessVideo({ stream, parameters });
+                        })
+                            .catch(() => {
+                            // If current video device is the last one in the list, show the error; otherwise, try 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 {
+                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,
+                });
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserVideoAlt, deps: [{ token: i1.ClickVideo }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserVideoAlt, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserVideoAlt, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ClickVideo }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch-user-video-alt.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/switch-user-video-alt.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ClickVideo, ClickVideoParameters } from '../methods/stream-methods/click-video.service';\nimport {\n  ShowAlert,\n  VidCons,\n  RequestPermissionCameraType,\n  StreamSuccessVideoType,\n  SleepType,\n  StreamSuccessVideoParameters,\n} from '../@types/types';\n\nexport interface SwitchUserVideoAltParameters\n  extends StreamSuccessVideoParameters,\n    ClickVideoParameters {\n  audioOnlyRoom: boolean;\n  frameRate: number;\n  vidCons: VidCons;\n  showAlert?: ShowAlert;\n  hasCameraPermission: boolean;\n  updateVideoSwitching: (state: boolean) => void;\n  updateCurrentFacingMode: (mode: string) => void;\n\n  // mediasfu functions\n  requestPermissionCamera: RequestPermissionCameraType;\n  streamSuccessVideo: StreamSuccessVideoType;\n  sleep: SleepType;\n  checkMediaPermission: boolean;\n  getUpdatedAllParams: () => SwitchUserVideoAltParameters;\n\n  [key: string]: any;\n}\n\nexport interface SwitchUserVideoAltOptions {\n  videoPreference: string;\n  checkoff: boolean;\n  parameters: SwitchUserVideoAltParameters;\n}\n\n// Export the type definition for the function\nexport type SwitchUserVideoAltType = (options: SwitchUserVideoAltOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SwitchUserVideoAlt {\n  constructor(private ClickVideoService: ClickVideo) {}\n\n  /**\n   * Switches the user's video stream based on the provided video preference and other parameters.\n   *\n   * @param {Object} options - The options for switching the user's video.\n   * @param {string} options.videoPreference - The preferred video facing mode (e.g., \"user\" or \"environment\").\n   * @param {boolean} options.checkoff - A flag indicating whether to turn off the video before switching.\n   * @param {SwitchUserVideoAltOptions} options.parameters - The parameters required for switching the video.\n   *\n   * @returns {Promise<void>} A promise that resolves when the video switching is complete.\n   *\n   * @throws Will throw an error if there is an issue with switching the video.\n   */\n\n  async switchUserVideoAlt({\n    videoPreference,\n    checkoff,\n    parameters,\n  }: SwitchUserVideoAltOptions): Promise<void> {\n    let { getUpdatedAllParams } = parameters;\n    let parameters_ = getUpdatedAllParams();\n\n    let {\n      audioOnlyRoom,\n      frameRate,\n      vidCons,\n      showAlert,\n      hasCameraPermission,\n      updateVideoSwitching,\n      updateCurrentFacingMode,\n\n      // mediasfu functions\n      requestPermissionCamera,\n      streamSuccessVideo,\n      sleep,\n      checkMediaPermission,\n    } = parameters;\n\n    let { currentFacingMode, prevFacingMode } = parameters_;\n\n    try {\n      // Check if it's an audio-only room\n      if (audioOnlyRoom) {\n        showAlert?.({\n          message: 'You cannot turn on your camera in an audio-only event.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      // If checkoff is not true, trigger a click on the video button to turn off the video\n      if (!checkoff) {\n        await this.ClickVideoService.clickVideo({ parameters });\n        updateVideoSwitching(true);\n        await sleep({ ms: 500 });\n        updateVideoSwitching(false);\n      }\n\n      // Check camera permission\n      if (!hasCameraPermission) {\n        if (checkMediaPermission) {\n          let statusCamera = await requestPermissionCamera();\n\n          if (statusCamera !== 'granted') {\n            showAlert?.({\n              message:\n                'Allow access to your camera or check if your camera is not being used by another application.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n        }\n      }\n\n      // Enumerate video devices\n      const videoDevices = await navigator.mediaDevices.enumerateDevices();\n\n      // Define media constraints based on preferences and options\n      let mediaConstraints: any = {};\n\n      if (vidCons && vidCons.width && vidCons.height) {\n        mediaConstraints = {\n          video: {\n            facingMode: { exact: videoPreference },\n            ...vidCons,\n            frameRate: { ideal: frameRate },\n          },\n          audio: false,\n        };\n      } else {\n        mediaConstraints = {\n          video: {\n            facingMode: { exact: videoPreference },\n            frameRate: { ideal: frameRate },\n          },\n          audio: false,\n        };\n      }\n\n      // Get user media with the defined constraints\n      await navigator.mediaDevices\n        .getUserMedia(mediaConstraints)\n        .then(async (stream: MediaStream) => {\n          await streamSuccessVideo({ stream, parameters });\n        })\n        .catch(async () => {\n          let videoDevicesFront = [];\n\n          // Filter video devices based on the preferred facing mode\n          if (videoPreference === 'user') {\n            videoDevicesFront = videoDevices.filter(\n              (device: MediaDeviceInfo) =>\n                device.label.includes('front') && device.kind === 'videoinput',\n            );\n          } else {\n            videoDevicesFront = videoDevices.filter(\n              (device: MediaDeviceInfo) =>\n                device.label.includes('back') && device.kind === 'videoinput',\n            );\n          }\n\n          if (videoDevicesFront.length > 0) {\n            videoDevicesFront.forEach((device: MediaDeviceInfo) => {\n              if (device.kind === 'videoinput') {\n                let videoDeviceId = device.deviceId;\n\n                // Update media constraints with the specific video device\n                if (vidCons && vidCons.width && vidCons.height) {\n                  mediaConstraints = {\n                    video: {\n                      deviceId: { exact: videoDeviceId },\n                      ...vidCons,\n                      frameRate: { ideal: frameRate },\n                    },\n                    audio: false,\n                  };\n                } else {\n                  mediaConstraints = {\n                    video: {\n                      deviceId: { exact: videoDeviceId },\n                      frameRate: { ideal: frameRate },\n                    },\n                    audio: false,\n                  };\n                }\n\n                // Try to get user media with the new constraints\n                navigator.mediaDevices\n                  .getUserMedia(mediaConstraints)\n                  .then(async (stream: MediaStream) => {\n                    await streamSuccessVideo({ stream, parameters });\n                  })\n                  .catch(() => {\n                    // If the current video device is the last one in the list, show the error; otherwise, try the next device\n                    if (\n                      videoDeviceId === videoDevicesFront[videoDevicesFront.length - 1].deviceId\n                    ) {\n                      currentFacingMode = prevFacingMode;\n                      updateCurrentFacingMode(currentFacingMode);\n\n                      showAlert?.({\n                        message:\n                          'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',\n                        type: 'danger',\n                        duration: 3000,\n                      });\n                    }\n                  });\n              }\n            });\n          } else {\n            // Show error if no compatible video devices are found\n            currentFacingMode = prevFacingMode;\n            updateCurrentFacingMode(currentFacingMode);\n\n            showAlert?.({\n              message:\n                'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',\n              type: 'danger',\n              duration: 3000,\n            });\n          }\n        });\n    } catch (error) {\n      // Handle any unexpected errors\n      const videoDevices = await navigator.mediaDevices.enumerateDevices();\n      let videoDevicesFront = [];\n      if (videoPreference === 'user') {\n        videoDevicesFront = videoDevices.filter(\n          (device: MediaDeviceInfo) =>\n            device.label.includes('front') && device.kind === 'videoinput',\n        );\n      } else {\n        videoDevicesFront = videoDevices.filter(\n          (device: MediaDeviceInfo) =>\n            device.label.includes('back') && device.kind === 'videoinput',\n        );\n      }\n\n      let mediaConstraints: any = {};\n\n      if (videoDevicesFront.length > 0) {\n        videoDevicesFront.forEach((device: MediaDeviceInfo) => {\n          if (device.kind === 'videoinput') {\n            let videoDeviceId = device.deviceId;\n\n            if (vidCons && vidCons.width && vidCons.height) {\n              mediaConstraints = {\n                video: {\n                  deviceId: { exact: videoDeviceId },\n                  ...vidCons,\n                  frameRate: { ideal: frameRate },\n                },\n                audio: false,\n              };\n            } else {\n              mediaConstraints = {\n                video: {\n                  deviceId: { exact: videoDeviceId },\n                  frameRate: { ideal: frameRate },\n                },\n                audio: false,\n              };\n            }\n\n            navigator.mediaDevices\n              .getUserMedia(mediaConstraints)\n              .then(async (stream: MediaStream) => {\n                await streamSuccessVideo({ stream, parameters });\n              })\n              .catch(() => {\n                // If current video device is the last one in the list, show the error; otherwise, try next device\n                if (videoDeviceId === videoDevicesFront[videoDevicesFront.length - 1].deviceId) {\n                  currentFacingMode = prevFacingMode;\n                  updateCurrentFacingMode(currentFacingMode);\n\n                  showAlert?.({\n                    message:\n                      'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',\n                    type: 'danger',\n                    duration: 3000,\n                  });\n                }\n              });\n          }\n        });\n      } else {\n        currentFacingMode = prevFacingMode;\n        updateCurrentFacingMode(currentFacingMode);\n\n        showAlert?.({\n          message:\n            'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',\n          type: 'danger',\n          duration: 3000,\n        });\n      }\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/consumers/switch-user-video.service.mjs

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../methods/stream-methods/click-video.service";
+export class SwitchUserVideo {
+    ClickVideoService;
+    constructor(ClickVideoService) {
+        this.ClickVideoService = ClickVideoService;
+    }
+    /**
+     * 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 {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 switched.
+     *
+     * @throws Will throw an error if switching the video input device fails.
+     */
+    switchUserVideo = async ({ videoPreference, checkoff, parameters, }) => {
+        let { audioOnlyRoom, frameRate, vidCons, prevVideoInputDevice, userDefaultVideoInputDevice, showAlert, 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 this.ClickVideoService.clickVideo({ parameters });
+                await updateVideoSwitching(true);
+                await sleep(500);
+                await updateVideoSwitching(false);
+            }
+            // Check camera permission
+            if (!hasCameraPermission) {
+                if (checkMediaPermission) {
+                    let 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 = {};
+            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 navigator.mediaDevices
+                .getUserMedia(mediaConstraints)
+                .then(async (stream) => {
+                await streamSuccessVideo({ stream, parameters });
+            })
+                .catch(async () => {
+                // Handle errors and revert to the previous video input device
+                userDefaultVideoInputDevice = prevVideoInputDevice;
+                updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);
+                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 (error) {
+            // Handle unexpected errors and revert to the previous video input device
+            userDefaultVideoInputDevice = prevVideoInputDevice;
+            updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);
+            showAlert?.({
+                message: 'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',
+                type: 'danger',
+                duration: 3000,
+            });
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserVideo, deps: [{ token: i1.ClickVideo }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserVideo, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: SwitchUserVideo, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ClickVideo }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch-user-video.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/switch-user-video.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ClickVideo, ClickVideoParameters } from '../methods/stream-methods/click-video.service';\nimport {\n  ShowAlert,\n  VidCons,\n  RequestPermissionCameraType,\n  StreamSuccessVideoType,\n  SleepType,\n  StreamSuccessVideoParameters,\n} from '../@types/types';\n\nexport interface SwitchUserVideoParameters\n  extends StreamSuccessVideoParameters,\n    ClickVideoParameters {\n  audioOnlyRoom: boolean;\n  frameRate: number;\n  vidCons: VidCons;\n  prevVideoInputDevice: string;\n  userDefaultVideoInputDevice: string;\n  showAlert?: ShowAlert;\n  hasCameraPermission: boolean;\n  updateVideoSwitching: (state: boolean) => void;\n  updateUserDefaultVideoInputDevice: (deviceId: string) => void;\n\n  // media functions\n  requestPermissionCamera: RequestPermissionCameraType;\n  streamSuccessVideo: StreamSuccessVideoType;\n  sleep: SleepType;\n  checkMediaPermission: boolean;\n\n  getUpdatedAllParams: () => SwitchUserVideoParameters;\n  [key: string]: any;\n}\n\nexport interface SwitchUserVideoOptions {\n  videoPreference: string;\n  checkoff: boolean;\n  parameters: SwitchUserVideoParameters;\n}\n\n// Export the type definition for the function\nexport type SwitchUserVideoType = (options: SwitchUserVideoOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class SwitchUserVideo {\n  constructor(private ClickVideoService: ClickVideo) {}\n\n  /**\n   * Switches the user's video input device based on the provided options.\n   *\n   * @param {SwitchUserVideoOptions} options - The options for switching the user's video.\n   * @param {string} options.videoPreference - The preferred video input device ID.\n   * @param {boolean} options.checkoff - Flag indicating whether to turn off the video.\n   * @param {Object} options.parameters - Additional parameters required for switching the video.\n   * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the room is audio-only.\n   * @param {number} options.parameters.frameRate - The desired frame rate for the video.\n   * @param {Object} options.parameters.vidCons - Video constraints such as width and height.\n   * @param {string} options.parameters.prevVideoInputDevice - The previous video input device ID.\n   * @param {Function} options.parameters.showAlert - Function to show alerts to the user.\n   * @param {boolean} options.parameters.hasCameraPermission - Indicates if the user has camera permission.\n   * @param {Function} options.parameters.updateVideoSwitching - Function to update video switching state.\n   * @param {Function} options.parameters.updateUserDefaultVideoInputDevice - Function to update the default video input device.\n   * @param {Function} options.parameters.requestPermissionCamera - Function to request camera permission.\n   * @param {Function} options.parameters.streamSuccessVideo - Function to handle successful video stream.\n   * @param {Function} options.parameters.sleep - Function to pause execution for a specified duration.\n   * @param {Function} options.parameters.checkMediaPermission - Function to check media permissions.\n   *\n   * @returns {Promise<void>} A promise that resolves when the video input device has been switched.\n   *\n   * @throws Will throw an error if switching the video input device fails.\n   */\n  switchUserVideo = async ({\n    videoPreference,\n    checkoff,\n    parameters,\n  }: {\n    videoPreference: string;\n    checkoff: boolean;\n    parameters: any;\n  }): Promise<void> => {\n    let {\n      audioOnlyRoom,\n      frameRate,\n      vidCons,\n      prevVideoInputDevice,\n      userDefaultVideoInputDevice,\n      showAlert,\n      hasCameraPermission,\n      updateVideoSwitching,\n      updateUserDefaultVideoInputDevice,\n\n      // mediasfu functions\n      requestPermissionCamera,\n      streamSuccessVideo,\n      sleep,\n      checkMediaPermission,\n    } = parameters;\n\n    try {\n      // Check if it's an audio-only room\n      if (audioOnlyRoom) {\n        showAlert?.({\n          message: 'You cannot turn on your camera in an audio-only event.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      // If checkoff is not true, trigger a click on the video button to turn off the video\n      if (!checkoff) {\n        await this.ClickVideoService.clickVideo({ parameters });\n        await updateVideoSwitching(true);\n        await sleep(500);\n        await updateVideoSwitching(false);\n      }\n\n      // Check camera permission\n      if (!hasCameraPermission) {\n        if (checkMediaPermission) {\n          let statusCamera = await requestPermissionCamera();\n          if (statusCamera !== 'granted') {\n            showAlert?.({\n              message:\n                'Allow access to your camera or check if your camera is not being used by another application.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n        }\n      }\n\n      let mediaConstraints: any = {};\n\n      if (vidCons && vidCons.width && vidCons.height) {\n        mediaConstraints = {\n          video: {\n            deviceId: { exact: videoPreference },\n            ...vidCons,\n            frameRate: { ideal: frameRate },\n          },\n          audio: false,\n        };\n      } else {\n        mediaConstraints = {\n          video: {\n            deviceId: { exact: videoPreference },\n            frameRate: { ideal: frameRate },\n          },\n          audio: false,\n        };\n      }\n\n      // Get user media with the defined constraints\n      await navigator.mediaDevices\n        .getUserMedia(mediaConstraints)\n        .then(async (stream: MediaStream) => {\n          await streamSuccessVideo({ stream, parameters });\n        })\n        .catch(async () => {\n          // Handle errors and revert to the previous video input device\n          userDefaultVideoInputDevice = prevVideoInputDevice;\n          updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);\n\n          showAlert?.({\n            message:\n              'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',\n            type: 'danger',\n            duration: 3000,\n          });\n        });\n    } catch (error) {\n      // Handle unexpected errors and revert to the previous video input device\n      userDefaultVideoInputDevice = prevVideoInputDevice;\n      updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);\n\n      showAlert?.({\n        message:\n          'Error switching; not accessible, might need to turn off your video and turn it back on after switching.',\n        type: 'danger',\n        duration: 3000,\n      });\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/trigger.service.mjs

@@ -0,0 +1,172 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class Trigger {
+    /**
+     * Triggers an update to the screen client based on the provided parameters.
+     *
+     * @param {TriggerOptions} options - The options for triggering the update.
+     * @param {string[]} options.ref_ActiveNames - Reference to the active names.
+     * @param {Parameters} options.parameters - The parameters for the trigger.
+     * @returns {Promise<void>} A promise that resolves when the trigger is complete.
+     *
+     * @throws Will throw an error if the updateScreenClient operation fails.
+     *
+     * @remarks
+     * This function handles various conditions to determine the main screen person,
+     * adjusts the screen states, and emits an update to the screen client via socket.
+     *
+     * @example
+     * ```typescript
+     * await trigger({
+     *   ref_ActiveNames: ["user1", "user2"],
+     *   parameters: {
+     *     socket: socketInstance,
+     *     roomName: "room1",
+     *     screenStates: [{ mainScreenPerson: "user1", mainScreenFilled: true, adminOnMainScreen: false }],
+     *     participants: [{ name: "admin", islevel: "2" }],
+     *     updateDateState: 0,
+     *     lastUpdate: null,
+     *     nForReadjust: 0,
+     *     eventType: "conference",
+     *     shared: false,
+     *     shareScreenStarted: false,
+     *     whiteboardStarted: false,
+     *     whiteboardEnded: false,
+     *     updateUpdateDateState: (date) => {},
+     *     updateLastUpdate: (date) => {},
+     *     updateNForReadjust: (n) => {},
+     *     autoAdjust: async ({ n, parameters }) => [n, 0],
+     *   },
+     * });
+     * ```
+     */
+    async trigger({ ref_ActiveNames, parameters }) {
+        // Function to trigger the updateScreen event
+        try {
+            let { socket, roomName, screenStates, participants, updateDateState, lastUpdate, nForReadjust, eventType, shared, shareScreenStarted, whiteboardStarted, whiteboardEnded, updateUpdateDateState, updateLastUpdate, updateNForReadjust, autoAdjust, } = parameters;
+            let personOnMainScreen = screenStates[0].mainScreenPerson;
+            let adminName = '';
+            const admin = participants.filter((participant) => participant.islevel == '2');
+            if (admin.length > 0) {
+                adminName = admin[0].name || '';
+            }
+            if (personOnMainScreen === 'WhiteboardActive') {
+                personOnMainScreen = adminName;
+            }
+            let mainfilled = screenStates[0].mainScreenFilled;
+            let adminOnMain = screenStates[0].adminOnMainScreen;
+            let nForReadjust_;
+            let val1;
+            let noww = new Date().getTime();
+            // get now in seconds
+            let timestamp = Math.floor(noww / 1000);
+            let eventPass = false;
+            if (eventType === 'conference' && !(shared || shareScreenStarted)) {
+                eventPass = true;
+                personOnMainScreen = adminName;
+                if (!ref_ActiveNames.includes(adminName)) {
+                    ref_ActiveNames.unshift(adminName);
+                }
+            }
+            if ((mainfilled && personOnMainScreen != null && adminOnMain) || eventPass) {
+                if (eventType === 'conference') {
+                    nForReadjust = nForReadjust + 1;
+                    updateNForReadjust(nForReadjust);
+                }
+                if (!ref_ActiveNames.includes(adminName) && whiteboardStarted && !whiteboardEnded) {
+                    ref_ActiveNames.unshift(adminName);
+                }
+                nForReadjust_ = ref_ActiveNames.length;
+                if (nForReadjust_ === 0 && eventType === 'webinar') {
+                    val1 = 0;
+                }
+                else {
+                    const [val11] = await autoAdjust({
+                        n: nForReadjust_,
+                        eventType,
+                        shared,
+                        shareScreenStarted,
+                    });
+                    val1 = val11;
+                }
+                let calc1 = Math.floor((val1 / 12) * 100);
+                let calc2 = 100 - calc1;
+                // check if lastUpdate is not null and at least same seconds
+                if (lastUpdate == null || updateDateState != timestamp) {
+                    let now = new Date();
+                    socket.emit('updateScreenClient', {
+                        roomName,
+                        names: ref_ActiveNames,
+                        mainPercent: calc2,
+                        mainScreenPerson: personOnMainScreen,
+                        viewType: eventType,
+                    }, ({ success, reason }) => {
+                        updateDateState = timestamp;
+                        updateUpdateDateState(updateDateState);
+                        lastUpdate = Math.floor(now.getTime() / 1000);
+                        updateLastUpdate(lastUpdate);
+                        if (success) {
+                            // handle success
+                        }
+                        else {
+                            console.log(reason, 'updateScreenClient failed');
+                        }
+                    });
+                }
+            }
+            else if (mainfilled && personOnMainScreen != null && !adminOnMain) {
+                nForReadjust_ = ref_ActiveNames.length;
+                if (!ref_ActiveNames.includes(adminName)) {
+                    ref_ActiveNames.unshift(adminName);
+                    nForReadjust_ = ref_ActiveNames.length;
+                }
+                const [val11] = await autoAdjust({
+                    n: nForReadjust_,
+                    eventType,
+                    shared,
+                    shareScreenStarted,
+                });
+                val1 = val11;
+                const calc1 = Math.floor((val1 / 12) * 100);
+                const calc2 = 100 - calc1;
+                if (lastUpdate == null || updateDateState != timestamp) {
+                    let now = new Date();
+                    socket.emit('updateScreenClient', {
+                        roomName,
+                        names: ref_ActiveNames,
+                        mainPercent: calc2,
+                        mainScreenPerson: personOnMainScreen,
+                        viewType: eventType,
+                    }, ({ success, reason }) => {
+                        updateDateState = timestamp;
+                        updateUpdateDateState(updateDateState);
+                        lastUpdate = Math.floor(now.getTime() / 1000);
+                        updateLastUpdate(lastUpdate);
+                        if (success) {
+                            // handle success
+                        }
+                        else {
+                            console.log(reason, 'updateScreenClient failed');
+                        }
+                    });
+                }
+            }
+            else {
+                // stop recording
+                console.log('trigger stopRecording');
+            }
+        }
+        catch (error) {
+            console.log('Error triggering updateScreen:', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Trigger, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Trigger, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: Trigger, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trigger.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/trigger.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { Participant, AutoAdjustType, ScreenState, EventType } from '../@types/types';\n\nexport interface TriggerParameters {\n  socket: Socket;\n  roomName: string;\n  screenStates: ScreenState[];\n  participants: Participant[];\n  updateDateState?: number | null;\n  lastUpdate: number | null;\n  nForReadjust: number;\n  eventType: EventType;\n  shared: boolean;\n  shareScreenStarted: boolean;\n  whiteboardStarted: boolean;\n  whiteboardEnded: boolean;\n  updateUpdateDateState: (timestamp: number | null) => void;\n  updateLastUpdate: (lastUpdate: number | null) => void;\n  updateNForReadjust: (nForReadjust: number) => void;\n\n  // mediasfu functions\n  autoAdjust: AutoAdjustType;\n\n  getUpdatedAllParams: () => TriggerParameters;\n  [key: string]: any;\n}\n\nexport interface TriggerOptions {\n  ref_ActiveNames: string[];\n  parameters: TriggerParameters;\n}\n\n// Export the type definition for the function\nexport type TriggerType = (options: TriggerOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class Trigger {\n  /**\n   * Triggers an update to the screen client based on the provided parameters.\n   *\n   * @param {TriggerOptions} options - The options for triggering the update.\n   * @param {string[]} options.ref_ActiveNames - Reference to the active names.\n   * @param {Parameters} options.parameters - The parameters for the trigger.\n   * @returns {Promise<void>} A promise that resolves when the trigger is complete.\n   *\n   * @throws Will throw an error if the updateScreenClient operation fails.\n   *\n   * @remarks\n   * This function handles various conditions to determine the main screen person,\n   * adjusts the screen states, and emits an update to the screen client via socket.\n   *\n   * @example\n   * ```typescript\n   * await trigger({\n   *   ref_ActiveNames: [\"user1\", \"user2\"],\n   *   parameters: {\n   *     socket: socketInstance,\n   *     roomName: \"room1\",\n   *     screenStates: [{ mainScreenPerson: \"user1\", mainScreenFilled: true, adminOnMainScreen: false }],\n   *     participants: [{ name: \"admin\", islevel: \"2\" }],\n   *     updateDateState: 0,\n   *     lastUpdate: null,\n   *     nForReadjust: 0,\n   *     eventType: \"conference\",\n   *     shared: false,\n   *     shareScreenStarted: false,\n   *     whiteboardStarted: false,\n   *     whiteboardEnded: false,\n   *     updateUpdateDateState: (date) => {},\n   *     updateLastUpdate: (date) => {},\n   *     updateNForReadjust: (n) => {},\n   *     autoAdjust: async ({ n, parameters }) => [n, 0],\n   *   },\n   * });\n   * ```\n   */\n  async trigger({ ref_ActiveNames, parameters }: TriggerOptions): Promise<void> {\n    // Function to trigger the updateScreen event\n\n    try {\n      let {\n        socket,\n        roomName,\n        screenStates,\n        participants,\n        updateDateState,\n        lastUpdate,\n        nForReadjust,\n        eventType,\n        shared,\n        shareScreenStarted,\n        whiteboardStarted,\n        whiteboardEnded,\n\n        updateUpdateDateState,\n        updateLastUpdate,\n        updateNForReadjust,\n\n        autoAdjust,\n      } = parameters;\n\n      let personOnMainScreen = screenStates[0].mainScreenPerson;\n\n      let adminName = '';\n      const admin = participants.filter((participant: Participant) => participant.islevel == '2');\n      if (admin.length > 0) {\n        adminName = admin[0].name || '';\n      }\n      if (personOnMainScreen === 'WhiteboardActive') {\n        personOnMainScreen = adminName;\n      }\n\n      let mainfilled = screenStates[0].mainScreenFilled;\n      let adminOnMain = screenStates[0].adminOnMainScreen;\n      let nForReadjust_;\n      let val1;\n\n      let noww = new Date().getTime();\n      // get now in seconds\n      let timestamp = Math.floor(noww / 1000);\n\n      let eventPass = false;\n      if (eventType === 'conference' && !(shared || shareScreenStarted)) {\n        eventPass = true;\n        personOnMainScreen = adminName;\n        if (!ref_ActiveNames.includes(adminName)) {\n          ref_ActiveNames.unshift(adminName);\n        }\n      }\n\n      if ((mainfilled && personOnMainScreen != null && adminOnMain) || eventPass) {\n        if (eventType === 'conference') {\n          nForReadjust = nForReadjust + 1;\n          updateNForReadjust(nForReadjust);\n        }\n\n        if (!ref_ActiveNames.includes(adminName) && whiteboardStarted && !whiteboardEnded) {\n          ref_ActiveNames.unshift(adminName);\n        }\n\n        nForReadjust_ = ref_ActiveNames.length;\n\n        if (nForReadjust_ === 0 && eventType === 'webinar') {\n          val1 = 0;\n        } else {\n          const [val11] = await autoAdjust({\n            n: nForReadjust_,\n            eventType,\n            shared,\n            shareScreenStarted,\n          });\n          val1 = val11;\n        }\n\n        let calc1 = Math.floor((val1 / 12) * 100);\n        let calc2 = 100 - calc1;\n\n        // check if lastUpdate is not null and at least same seconds\n        if (lastUpdate == null || updateDateState != timestamp) {\n          let now = new Date();\n\n          socket.emit(\n            'updateScreenClient',\n            {\n              roomName,\n              names: ref_ActiveNames,\n              mainPercent: calc2,\n              mainScreenPerson: personOnMainScreen,\n              viewType: eventType,\n            },\n            ({ success, reason }: { success: boolean; reason: string }) => {\n              updateDateState = timestamp;\n              updateUpdateDateState(updateDateState);\n              lastUpdate = Math.floor(now.getTime() / 1000);\n              updateLastUpdate(lastUpdate);\n              if (success) {\n                // handle success\n              } else {\n                console.log(reason, 'updateScreenClient failed');\n              }\n            },\n          );\n        }\n      } else if (mainfilled && personOnMainScreen != null && !adminOnMain) {\n        nForReadjust_ = ref_ActiveNames.length;\n\n        if (!ref_ActiveNames.includes(adminName)) {\n          ref_ActiveNames.unshift(adminName);\n          nForReadjust_ = ref_ActiveNames.length;\n        }\n\n        const [val11] = await autoAdjust({\n          n: nForReadjust_,\n          eventType,\n          shared,\n          shareScreenStarted,\n        });\n\n        val1 = val11;\n\n        const calc1 = Math.floor((val1 / 12) * 100);\n        const calc2 = 100 - calc1;\n\n        if (lastUpdate == null || updateDateState != timestamp) {\n          let now = new Date();\n\n          socket.emit(\n            'updateScreenClient',\n            {\n              roomName,\n              names: ref_ActiveNames,\n              mainPercent: calc2,\n              mainScreenPerson: personOnMainScreen,\n              viewType: eventType,\n            },\n            ({ success, reason }: { success: boolean; reason: string }) => {\n              updateDateState = timestamp;\n              updateUpdateDateState(updateDateState);\n              lastUpdate = Math.floor(now.getTime() / 1000);\n              updateLastUpdate(lastUpdate);\n              if (success) {\n                // handle success\n              } else {\n                console.log(reason, 'updateScreenClient failed');\n              }\n            },\n          );\n        }\n      } else {\n        // stop recording\n        console.log('trigger stopRecording');\n      }\n    } catch (error) {\n      console.log('Error triggering updateScreen:', error);\n    }\n  }\n}\n"]}