mediasfu-angular 1.0.0 → 1.0.2

package/dist/esm2022/lib/methods/stream-methods/click-audio.service.mjs

@@ -1,5 +1,102 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Handles the click event for toggling audio in a media session.
+ *
+ * @param {ClickAudioOptions} options - The parameters required for handling the audio click event.
+ * @param {Object} options.parameters - The parameters for toggling audio.
+ * @param {boolean} options.parameters.checkMediaPermission - Flag indicating whether to check media permission.
+ * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has audio permission.
+ * @param {boolean} options.parameters.audioPaused - Flag indicating if audio is paused.
+ * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if audio is already turned on.
+ * @param {boolean} options.parameters.audioOnlyRoom - Flag indicating if the room is audio-only.
+ * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.
+ * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Flag indicating if recording is stopped.
+ * @param {string} options.parameters.recordingMediaOptions - Media options for recording (e.g., "video", "audio").
+ * @param {string} options.parameters.islevel - User's level in the application.
+ * @param {boolean} options.parameters.youAreCoHost - Flag indicating if the user is a co-host.
+ * @param {boolean} options.parameters.adminRestrictSetting - Flag indicating if admin restrictions are set.
+ * @param {string | null} options.parameters.audioRequestState - Current state of the audio request.
+ * @param {number} options.parameters.audioRequestTime - Timestamp of the audio request.
+ * @param {string} options.parameters.member - Current member's name.
+ * @param {Socket} options.parameters.socket - The socket instance for communication.
+ * @param {string} options.parameters.roomName - The name of the room.
+ * @param {string} options.parameters.userDefaultAudioInputDevice - The default audio input device for the user.
+ * @param {boolean} options.parameters.micAction - Flag indicating if the microphone action is in progress.
+ * @param {MediaStream | null} options.parameters.localStream - The user's local media stream.
+ * @param {string} options.parameters.audioSetting - Current audio setting.
+ * @param {string} options.parameters.videoSetting - Current video setting.
+ * @param {string} options.parameters.screenshareSetting - Current screenshare setting.
+ * @param {string} options.parameters.chatSetting - Current chat setting.
+ * @param {number} options.parameters.updateRequestIntervalSeconds - Interval for updating request states.
+ * @param {Participant[]} options.parameters.participants - List of participants in the room.
+ * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport has been created.
+ * @param {boolean} options.parameters.transportCreatedAudio - Flag indicating if audio transport has been created.
+ *
+ * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.
+ *
+ * @remarks
+ * This function performs the following actions:
+ * - If the event is audio-only, it shows an alert and exits.
+ * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.
+ * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.
+ * - It updates various states and emits socket events as necessary.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickAudioOptions = {
+ *   parameters: {
+ *     checkMediaPermission: true,
+ *     hasAudioPermission: false,
+ *     audioPaused: false,
+ *     audioAlreadyOn: false,
+ *     audioOnlyRoom: false,
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordPaused: false,
+ *     recordStopped: false,
+ *     recordingMediaOptions: 'audio',
+ *     islevel: '1',
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     audioRequestState: null,
+ *     audioRequestTime: 0,
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     roomName: 'exampleRoom',
+ *     userDefaultAudioInputDevice: 'default',
+ *     micAction: false,
+ *     localStream: null,
+ *     audioSetting: 'enabled',
+ *     videoSetting: 'disabled',
+ *     screenshareSetting: 'disabled',
+ *     chatSetting: 'enabled',
+ *     updateRequestIntervalSeconds: 30,
+ *     participants: [],
+ *     transportCreated: false,
+ *     transportCreatedAudio: false,
+ *     updateAudioAlreadyOn: (status) => console.log(status),
+ *     updateAudioRequestState: (state) => console.log(state),
+ *     updateAudioPaused: (status) => console.log(status),
+ *     updateLocalStream: (stream) => console.log(stream),
+ *     updateParticipants: (participants) => console.log(participants),
+ *     updateTransportCreated: (status) => console.log(status),
+ *     updateTransportCreatedAudio: (status) => console.log(status),
+ *     updateMicAction: (action) => console.log(action),
+ *     checkPermission: async () => 'granted',
+ *     streamSuccessAudio: async () => console.log('Audio streaming success'),
+ *     disconnectSendTransportAudio: async () => console.log('Audio transport disconnected'),
+ *     requestPermissionAudio: async () => 'granted',
+ *     resumeSendTransportAudio: async () => console.log('Audio transport resumed'),
+ *   },
+ * };
+ *
+ * const clickAudioService = new ClickAudio();
+ * await clickAudioService.clickAudio(options);
+ * ```
+ */
 export class ClickAudio {
     /**
      * Handles the click event for toggling audio in a media session.
@@ -175,4 +272,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-audio.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-audio.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  CheckPermissionType,\n  DisconnectSendTransportAudioParameters,\n  DisconnectSendTransportAudioType,\n  Participant,\n  RequestPermissionAudioType,\n  ResumeSendTransportAudioParameters,\n  ResumeSendTransportAudioType,\n  ShowAlert,\n  StreamSuccessAudioParameters,\n  StreamSuccessAudioType,\n} from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\n/* eslint-disable eqeqeq */\nexport interface ClickAudioParameters\n  extends DisconnectSendTransportAudioParameters,\n    ResumeSendTransportAudioParameters,\n    StreamSuccessAudioParameters {\n  checkMediaPermission: boolean;\n  hasAudioPermission: boolean;\n  audioPaused: boolean;\n  audioAlreadyOn: boolean;\n  audioOnlyRoom: boolean;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  recordingMediaOptions: string;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  audioRequestState: string | null;\n  audioRequestTime: number;\n  member: string;\n  socket: Socket;\n  roomName: string;\n  userDefaultAudioInputDevice: string;\n  micAction: boolean;\n  localStream: MediaStream | null;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  updateRequestIntervalSeconds: number;\n  participants: Participant[];\n  transportCreated: boolean;\n  transportCreatedAudio: boolean;\n\n  updateAudioAlreadyOn: (status: boolean) => void;\n  updateAudioRequestState: (state: string | null) => void;\n  updateAudioPaused: (status: boolean) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateTransportCreated: (status: boolean) => void;\n  updateTransportCreatedAudio: (status: boolean) => void;\n  updateMicAction: (action: boolean) => void;\n  showAlert?: ShowAlert;\n\n  // mediasfu functions\n  checkPermission: CheckPermissionType;\n  streamSuccessAudio: StreamSuccessAudioType;\n  disconnectSendTransportAudio: DisconnectSendTransportAudioType;\n  requestPermissionAudio: RequestPermissionAudioType;\n  resumeSendTransportAudio: ResumeSendTransportAudioType;\n\n  getUpdatedAllParams: () => ClickAudioParameters;\n  [key: string]: any;\n}\n\nexport interface ClickAudioOptions {\n  parameters: ClickAudioParameters;\n}\n\n// Export the type definition for the function\nexport type ClickAudioType = (options: ClickAudioOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickAudio {\n  /**\n   * Handles the click event for toggling audio in a media session.\n   *\n   * @param {ClickAudioOptions} parameters - The parameters required for handling the audio click event.\n   * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.\n   *\n   * The function performs the following actions:\n   * - If the event is audio-only, it shows an alert and exits.\n   * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.\n   * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.\n   * - It updates various states and emits socket events as necessary.\n   *\n   * The function makes use of several helper functions and state update functions passed in through the parameters.\n   */\n\n  async clickAudio({ parameters }: ClickAudioOptions): Promise<void> {\n    let {\n      checkMediaPermission,\n      hasAudioPermission,\n      audioPaused,\n      audioAlreadyOn,\n      audioOnlyRoom,\n      recordStarted,\n      recordResumed,\n      recordPaused,\n      recordStopped,\n      recordingMediaOptions,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      audioRequestState,\n      audioRequestTime,\n      member,\n      socket,\n      roomName,\n      userDefaultAudioInputDevice,\n      micAction,\n      localStream,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateRequestIntervalSeconds,\n      participants,\n      showAlert,\n      transportCreated,\n      transportCreatedAudio,\n\n      updateAudioAlreadyOn,\n      updateAudioRequestState,\n      updateAudioPaused,\n      updateLocalStream,\n      updateParticipants,\n      updateTransportCreated,\n      updateTransportCreatedAudio,\n      updateMicAction,\n\n      checkPermission,\n      streamSuccessAudio,\n      requestPermissionAudio,\n      resumeSendTransportAudio,\n      disconnectSendTransportAudio,\n    } = parameters;\n\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      return;\n    }\n\n    if (audioAlreadyOn) {\n      if (islevel === '2' && (recordStarted || recordResumed)) {\n        if (!(recordPaused || recordStopped)) {\n          if (recordingMediaOptions === 'audio') {\n            showAlert?.({\n              message:\n                'You cannot turn off your audio while recording, please pause or stop recording first.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n        }\n      }\n\n      audioAlreadyOn = false;\n      updateAudioAlreadyOn(audioAlreadyOn);\n      if (localStream) {\n        localStream.getAudioTracks()[0].enabled = false;\n      }\n      updateLocalStream(localStream);\n      await disconnectSendTransportAudio({ parameters }); //disconnect function here actuall calls audioProducer.pause() instead of close() as in mediasfu\n      audioPaused = true;\n      updateAudioPaused(audioPaused);\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot turn on your microphone. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      let response = 2;\n      if (!micAction && islevel !== '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'audioSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      switch (response) {\n        case 1: {\n          if (audioRequestState === 'pending') {\n            showAlert?.({\n              message: 'A request is pending. Please wait for the host to respond.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n\n          showAlert?.({\n            message: 'Request sent to host.',\n            type: 'success',\n            duration: 3000,\n          });\n\n          audioRequestState = 'pending';\n          updateAudioRequestState(audioRequestState);\n          //create a request and add to the request list and send to host\n\n          const userRequest = {\n            id: socket.id,\n            name: member,\n            icon: 'fa-microphone',\n          };\n          socket.emit('participantRequest', { userRequest, roomName });\n          break;\n        }\n\n        case 2:\n          if (\n            audioRequestState === 'rejected' &&\n            Date.now() - audioRequestTime < updateRequestIntervalSeconds * 1000\n          ) {\n            showAlert?.({\n              message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n          break;\n\n        case 0:\n          //allow\n\n          if (audioPaused) {\n            if (localStream) {\n              localStream.getAudioTracks()[0].enabled = true;\n            }\n            updateAudioAlreadyOn(true);\n            await resumeSendTransportAudio({ parameters });\n            socket.emit('resumeProducerAudio', { mediaTag: 'audio', roomName });\n\n            updateLocalStream(localStream);\n            updateAudioAlreadyOn(audioAlreadyOn);\n\n            if (micAction == true) {\n              micAction = false;\n              updateMicAction(micAction);\n            }\n\n            participants.forEach((participant) => {\n              if (participant['socketId'] === socket.id && participant.name === member) {\n                participant.muted = false;\n              }\n            });\n            updateParticipants(participants);\n\n            transportCreated = true;\n            updateTransportCreated(transportCreated);\n\n            transportCreatedAudio = true;\n            updateTransportCreatedAudio(transportCreatedAudio);\n          } else {\n            if (!hasAudioPermission && checkMediaPermission) {\n              const statusMic = await requestPermissionAudio();\n              if (statusMic !== 'granted') {\n                showAlert?.({\n                  message:\n                    'Allow access to your microphone or check if your microphone is not being used by another application.',\n                  type: 'danger',\n                  duration: 3000,\n                });\n                return;\n              }\n            }\n\n            const mediaConstraints = userDefaultAudioInputDevice\n              ? { audio: { deviceId: userDefaultAudioInputDevice }, video: false }\n              : { audio: true, video: false };\n\n            try {\n              const stream = await navigator.mediaDevices.getUserMedia(mediaConstraints);\n              await streamSuccessAudio({ stream, parameters });\n            } catch (error) {\n              console.error(error);\n              showAlert?.({\n                message:\n                  'Allow access to your microphone or check if your microphone is not being used by another application.',\n                type: 'danger',\n                duration: 3000,\n              });\n            }\n          }\n          break;\n\n        default:\n      }\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-audio.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-audio.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  CheckPermissionType,\n  DisconnectSendTransportAudioParameters,\n  DisconnectSendTransportAudioType,\n  Participant,\n  RequestPermissionAudioType,\n  ResumeSendTransportAudioParameters,\n  ResumeSendTransportAudioType,\n  ShowAlert,\n  StreamSuccessAudioParameters,\n  StreamSuccessAudioType,\n} from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\n/* eslint-disable eqeqeq */\nexport interface ClickAudioParameters\n  extends DisconnectSendTransportAudioParameters,\n    ResumeSendTransportAudioParameters,\n    StreamSuccessAudioParameters {\n  checkMediaPermission: boolean;\n  hasAudioPermission: boolean;\n  audioPaused: boolean;\n  audioAlreadyOn: boolean;\n  audioOnlyRoom: boolean;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  recordingMediaOptions: string;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  audioRequestState: string | null;\n  audioRequestTime: number;\n  member: string;\n  socket: Socket;\n  roomName: string;\n  userDefaultAudioInputDevice: string;\n  micAction: boolean;\n  localStream: MediaStream | null;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  updateRequestIntervalSeconds: number;\n  participants: Participant[];\n  transportCreated: boolean;\n  transportCreatedAudio: boolean;\n\n  updateAudioAlreadyOn: (status: boolean) => void;\n  updateAudioRequestState: (state: string | null) => void;\n  updateAudioPaused: (status: boolean) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateTransportCreated: (status: boolean) => void;\n  updateTransportCreatedAudio: (status: boolean) => void;\n  updateMicAction: (action: boolean) => void;\n  showAlert?: ShowAlert;\n\n  // mediasfu functions\n  checkPermission: CheckPermissionType;\n  streamSuccessAudio: StreamSuccessAudioType;\n  disconnectSendTransportAudio: DisconnectSendTransportAudioType;\n  requestPermissionAudio: RequestPermissionAudioType;\n  resumeSendTransportAudio: ResumeSendTransportAudioType;\n\n  getUpdatedAllParams: () => ClickAudioParameters;\n  [key: string]: any;\n}\n\nexport interface ClickAudioOptions {\n  parameters: ClickAudioParameters;\n}\n\n// Export the type definition for the function\nexport type ClickAudioType = (options: ClickAudioOptions) => Promise<void>;\n\n/**\n * Handles the click event for toggling audio in a media session.\n *\n * @param {ClickAudioOptions} options - The parameters required for handling the audio click event.\n * @param {Object} options.parameters - The parameters for toggling audio.\n * @param {boolean} options.parameters.checkMediaPermission - Flag indicating whether to check media permission.\n * @param {boolean} options.parameters.hasAudioPermission - Flag indicating if the user has audio permission.\n * @param {boolean} options.parameters.audioPaused - Flag indicating if audio is paused.\n * @param {boolean} options.parameters.audioAlreadyOn - Flag indicating if audio is already turned on.\n * @param {boolean} options.parameters.audioOnlyRoom - Flag indicating if the room is audio-only.\n * @param {boolean} options.parameters.recordStarted - Flag indicating if recording has started.\n * @param {boolean} options.parameters.recordResumed - Flag indicating if recording has resumed.\n * @param {boolean} options.parameters.recordPaused - Flag indicating if recording is paused.\n * @param {boolean} options.parameters.recordStopped - Flag indicating if recording is stopped.\n * @param {string} options.parameters.recordingMediaOptions - Media options for recording (e.g., \"video\", \"audio\").\n * @param {string} options.parameters.islevel - User's level in the application.\n * @param {boolean} options.parameters.youAreCoHost - Flag indicating if the user is a co-host.\n * @param {boolean} options.parameters.adminRestrictSetting - Flag indicating if admin restrictions are set.\n * @param {string | null} options.parameters.audioRequestState - Current state of the audio request.\n * @param {number} options.parameters.audioRequestTime - Timestamp of the audio request.\n * @param {string} options.parameters.member - Current member's name.\n * @param {Socket} options.parameters.socket - The socket instance for communication.\n * @param {string} options.parameters.roomName - The name of the room.\n * @param {string} options.parameters.userDefaultAudioInputDevice - The default audio input device for the user.\n * @param {boolean} options.parameters.micAction - Flag indicating if the microphone action is in progress.\n * @param {MediaStream | null} options.parameters.localStream - The user's local media stream.\n * @param {string} options.parameters.audioSetting - Current audio setting.\n * @param {string} options.parameters.videoSetting - Current video setting.\n * @param {string} options.parameters.screenshareSetting - Current screenshare setting.\n * @param {string} options.parameters.chatSetting - Current chat setting.\n * @param {number} options.parameters.updateRequestIntervalSeconds - Interval for updating request states.\n * @param {Participant[]} options.parameters.participants - List of participants in the room.\n * @param {boolean} options.parameters.transportCreated - Flag indicating if the transport has been created.\n * @param {boolean} options.parameters.transportCreatedAudio - Flag indicating if audio transport has been created.\n *\n * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.\n *\n * @remarks\n * This function performs the following actions:\n * - If the event is audio-only, it shows an alert and exits.\n * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.\n * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.\n * - It updates various states and emits socket events as necessary.\n *\n * @example\n * ```typescript\n * const options: ClickAudioOptions = {\n *   parameters: {\n *     checkMediaPermission: true,\n *     hasAudioPermission: false,\n *     audioPaused: false,\n *     audioAlreadyOn: false,\n *     audioOnlyRoom: false,\n *     recordStarted: false,\n *     recordResumed: false,\n *     recordPaused: false,\n *     recordStopped: false,\n *     recordingMediaOptions: 'audio',\n *     islevel: '1',\n *     youAreCoHost: false,\n *     adminRestrictSetting: false,\n *     audioRequestState: null,\n *     audioRequestTime: 0,\n *     member: 'John Doe',\n *     socket: socketInstance,\n *     roomName: 'exampleRoom',\n *     userDefaultAudioInputDevice: 'default',\n *     micAction: false,\n *     localStream: null,\n *     audioSetting: 'enabled',\n *     videoSetting: 'disabled',\n *     screenshareSetting: 'disabled',\n *     chatSetting: 'enabled',\n *     updateRequestIntervalSeconds: 30,\n *     participants: [],\n *     transportCreated: false,\n *     transportCreatedAudio: false,\n *     updateAudioAlreadyOn: (status) => console.log(status),\n *     updateAudioRequestState: (state) => console.log(state),\n *     updateAudioPaused: (status) => console.log(status),\n *     updateLocalStream: (stream) => console.log(stream),\n *     updateParticipants: (participants) => console.log(participants),\n *     updateTransportCreated: (status) => console.log(status),\n *     updateTransportCreatedAudio: (status) => console.log(status),\n *     updateMicAction: (action) => console.log(action),\n *     checkPermission: async () => 'granted',\n *     streamSuccessAudio: async () => console.log('Audio streaming success'),\n *     disconnectSendTransportAudio: async () => console.log('Audio transport disconnected'),\n *     requestPermissionAudio: async () => 'granted',\n *     resumeSendTransportAudio: async () => console.log('Audio transport resumed'),\n *   },\n * };\n *\n * const clickAudioService = new ClickAudio();\n * await clickAudioService.clickAudio(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickAudio {\n  /**\n   * Handles the click event for toggling audio in a media session.\n   *\n   * @param {ClickAudioOptions} parameters - The parameters required for handling the audio click event.\n   * @returns {Promise<void>} A promise that resolves when the audio click event has been handled.\n   *\n   * The function performs the following actions:\n   * - If the event is audio-only, it shows an alert and exits.\n   * - If the audio is already on, it handles the logic for turning it off, including checking recording states and permissions.\n   * - If the audio is off, it checks for admin restrictions, user permissions, and handles the logic for turning the audio on.\n   * - It updates various states and emits socket events as necessary.\n   *\n   * The function makes use of several helper functions and state update functions passed in through the parameters.\n   */\n\n  async clickAudio({ parameters }: ClickAudioOptions): Promise<void> {\n    let {\n      checkMediaPermission,\n      hasAudioPermission,\n      audioPaused,\n      audioAlreadyOn,\n      audioOnlyRoom,\n      recordStarted,\n      recordResumed,\n      recordPaused,\n      recordStopped,\n      recordingMediaOptions,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      audioRequestState,\n      audioRequestTime,\n      member,\n      socket,\n      roomName,\n      userDefaultAudioInputDevice,\n      micAction,\n      localStream,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateRequestIntervalSeconds,\n      participants,\n      showAlert,\n      transportCreated,\n      transportCreatedAudio,\n\n      updateAudioAlreadyOn,\n      updateAudioRequestState,\n      updateAudioPaused,\n      updateLocalStream,\n      updateParticipants,\n      updateTransportCreated,\n      updateTransportCreatedAudio,\n      updateMicAction,\n\n      checkPermission,\n      streamSuccessAudio,\n      requestPermissionAudio,\n      resumeSendTransportAudio,\n      disconnectSendTransportAudio,\n    } = parameters;\n\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      return;\n    }\n\n    if (audioAlreadyOn) {\n      if (islevel === '2' && (recordStarted || recordResumed)) {\n        if (!(recordPaused || recordStopped)) {\n          if (recordingMediaOptions === 'audio') {\n            showAlert?.({\n              message:\n                'You cannot turn off your audio while recording, please pause or stop recording first.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n        }\n      }\n\n      audioAlreadyOn = false;\n      updateAudioAlreadyOn(audioAlreadyOn);\n      if (localStream) {\n        localStream.getAudioTracks()[0].enabled = false;\n      }\n      updateLocalStream(localStream);\n      await disconnectSendTransportAudio({ parameters }); //disconnect function here actuall calls audioProducer.pause() instead of close() as in mediasfu\n      audioPaused = true;\n      updateAudioPaused(audioPaused);\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot turn on your microphone. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      let response = 2;\n      if (!micAction && islevel !== '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'audioSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      switch (response) {\n        case 1: {\n          if (audioRequestState === 'pending') {\n            showAlert?.({\n              message: 'A request is pending. Please wait for the host to respond.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n\n          showAlert?.({\n            message: 'Request sent to host.',\n            type: 'success',\n            duration: 3000,\n          });\n\n          audioRequestState = 'pending';\n          updateAudioRequestState(audioRequestState);\n          //create a request and add to the request list and send to host\n\n          const userRequest = {\n            id: socket.id,\n            name: member,\n            icon: 'fa-microphone',\n          };\n          socket.emit('participantRequest', { userRequest, roomName });\n          break;\n        }\n\n        case 2:\n          if (\n            audioRequestState === 'rejected' &&\n            Date.now() - audioRequestTime < updateRequestIntervalSeconds * 1000\n          ) {\n            showAlert?.({\n              message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n          break;\n\n        case 0:\n          //allow\n\n          if (audioPaused) {\n            if (localStream) {\n              localStream.getAudioTracks()[0].enabled = true;\n            }\n            updateAudioAlreadyOn(true);\n            await resumeSendTransportAudio({ parameters });\n            socket.emit('resumeProducerAudio', { mediaTag: 'audio', roomName });\n\n            updateLocalStream(localStream);\n            updateAudioAlreadyOn(audioAlreadyOn);\n\n            if (micAction == true) {\n              micAction = false;\n              updateMicAction(micAction);\n            }\n\n            participants.forEach((participant) => {\n              if (participant['socketId'] === socket.id && participant.name === member) {\n                participant.muted = false;\n              }\n            });\n            updateParticipants(participants);\n\n            transportCreated = true;\n            updateTransportCreated(transportCreated);\n\n            transportCreatedAudio = true;\n            updateTransportCreatedAudio(transportCreatedAudio);\n          } else {\n            if (!hasAudioPermission && checkMediaPermission) {\n              const statusMic = await requestPermissionAudio();\n              if (statusMic !== 'granted') {\n                showAlert?.({\n                  message:\n                    'Allow access to your microphone or check if your microphone is not being used by another application.',\n                  type: 'danger',\n                  duration: 3000,\n                });\n                return;\n              }\n            }\n\n            const mediaConstraints = userDefaultAudioInputDevice\n              ? { audio: { deviceId: userDefaultAudioInputDevice }, video: false }\n              : { audio: true, video: false };\n\n            try {\n              const stream = await navigator.mediaDevices.getUserMedia(mediaConstraints);\n              await streamSuccessAudio({ stream, parameters });\n            } catch (error) {\n              console.error(error);\n              showAlert?.({\n                message:\n                  'Allow access to your microphone or check if your microphone is not being used by another application.',\n                type: 'danger',\n                duration: 3000,\n              });\n            }\n          }\n          break;\n\n        default:\n      }\n    }\n  }\n}\n"]}

package/dist/esm2022/lib/methods/stream-methods/click-chat.service.mjs

@@ -1,5 +1,36 @@
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Toggles the visibility of the chat modal based on the current state and event settings.
+ *
+ * @param {ClickChatOptions} options - The options for the clickChat function.
+ * @param {boolean} options.isMessagesModalVisible - Indicates if the messages modal is currently visible.
+ * @param {Function} options.updateIsMessagesModalVisible - Function to update the visibility state of the messages modal.
+ * @param {string} options.chatSetting - The chat setting for the event, which can be "allow" or other values.
+ * @param {string} options.islevel - The participant's level, where "2" indicates a level that allows chat.
+ * @param {Function} [options.showAlert] - Optional function to show an alert message.
+ *
+ * @returns {Promise<void>} A promise that resolves when the operation is complete.
+ *
+ * @remarks
+ * This function checks the current visibility state of the messages modal. If it is already visible, it will hide the modal.
+ * If it is not visible, it checks the chat settings and the participant's level to determine whether to show an alert
+ * indicating that chat is disabled or to display the chat modal.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickChatOptions = {
+ *   isMessagesModalVisible: false,
+ *   updateIsMessagesModalVisible: (visible) => console.log(`Modal is now ${visible ? 'visible' : 'hidden'}`),
+ *   chatSetting: 'allow',
+ *   islevel: '1',
+ *   showAlert: (alert) => console.log(`Alert: ${alert.message}`),
+ * };
+ *
+ * const clickChatService = new ClickChat();
+ * await clickChatService.clickChat(options);
+ * ```
+ */
 export class ClickChat {
     /**
      * Toggles the visibility of the chat modal based on the current state and event settings.
@@ -41,4 +72,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/methods/stream-methods/click-screen-share.service.mjs

@@ -1,6 +1,74 @@
 // screen-share.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Handles the action for the screen button, including starting and stopping screen sharing.
+ *
+ * @param {ClickScreenShareOptions} options - Options for handling the screen button action.
+ * @param {Object} options.parameters - The parameters required for the screen share action.
+ * @param {Function} options.parameters.showAlert - Function to show alert messages.
+ * @param {string} options.parameters.roomName - The name of the room where the screen share is taking place.
+ * @param {string} options.parameters.member - The member initiating the screen share.
+ * @param {Socket} options.parameters.socket - The socket connection used for communication.
+ * @param {string} options.parameters.islevel - The participant's level.
+ * @param {boolean} options.parameters.youAreCoHost - Indicates if the user is a co-host.
+ * @param {boolean} options.parameters.adminRestrictSetting - Indicates if there are restrictions set by the admin.
+ * @param {string} options.parameters.audioSetting - Current audio setting.
+ * @param {string} options.parameters.videoSetting - Current video setting.
+ * @param {string} options.parameters.screenshareSetting - Current screen share setting.
+ * @param {string} options.parameters.chatSetting - Current chat setting.
+ * @param {boolean} options.parameters.screenAction - Indicates if a screen action is currently taking place.
+ * @param {boolean} options.parameters.screenAlreadyOn - Indicates if screen sharing is currently active.
+ * @param {string | null} options.parameters.screenRequestState - State of the screen share request.
+ * @param {number} options.parameters.screenRequestTime - Timestamp of when the screen share request was made.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the room is audio-only.
+ * @param {number} options.parameters.updateRequestIntervalSeconds - Interval time for updating request state.
+ * @param {Function} options.parameters.updateScreenRequestState - Function to update the screen request state.
+ * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing status.
+ * @param {Function} options.parameters.checkPermission - Function to check permissions for screen sharing.
+ * @param {Function} options.parameters.checkScreenShare - Function to check and initiate screen sharing.
+ * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.
+ *
+ * @returns {Promise<void>} A promise that resolves when the screen share action has been handled.
+ *
+ * @remarks
+ * This function checks the current status of screen sharing and handles the logic for starting or stopping screen sharing.
+ * It validates permissions and room settings before allowing screen sharing to be activated or deactivated.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickScreenShareOptions = {
+ *   parameters: {
+ *     showAlert: (alert) => console.log(alert.message),
+ *     roomName: 'myRoom',
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     islevel: '1',
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     audioSetting: 'on',
+ *     videoSetting: 'on',
+ *     screenshareSetting: 'off',
+ *     chatSetting: 'allow',
+ *     screenAction: false,
+ *     screenAlreadyOn: false,
+ *     screenRequestState: null,
+ *     screenRequestTime: 0,
+ *     audioOnlyRoom: false,
+ *     updateRequestIntervalSeconds: 30,
+ *     updateScreenRequestState: (state) => console.log(`Screen request state: ${state}`),
+ *     updateScreenAlreadyOn: (status) => console.log(`Screen already on: ${status}`),
+ *     checkPermission: checkPermissionFunction,
+ *     checkScreenShare: checkScreenShareFunction,
+ *     stopShareScreen: stopShareScreenFunction,
+ *     getUpdatedAllParams: () => parameters,
+ *   },
+ * };
+ *
+ * const clickScreenShareService = new ClickScreenShare();
+ * await clickScreenShareService.clickScreenShare(options);
+ * ```
+ */
 export class ClickScreenShare {
     /**
      * Handles the action for the screen button, including starting and stopping screen sharing.
@@ -107,4 +175,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-screen-share.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-screen-share.service.ts"],"names":[],"mappings":"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","sourcesContent":["// screen-share.service.ts\nimport { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  CheckPermissionType,\n  CheckScreenShareParameters,\n  CheckScreenShareType,\n  ShowAlert,\n  StopShareScreenParameters,\n  StopShareScreenType,\n} from '../../@types/types';\n\nexport interface ClickScreenShareParameters\n  extends CheckScreenShareParameters,\n    StopShareScreenParameters {\n  showAlert?: ShowAlert;\n  roomName: string;\n  member: string;\n  socket: Socket;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  screenAction: boolean;\n  screenAlreadyOn: boolean;\n  screenRequestState: string | null;\n  screenRequestTime: number;\n  audioOnlyRoom: boolean;\n  updateRequestIntervalSeconds: number;\n  updateScreenRequestState: (state: string | null) => void;\n  updateScreenAlreadyOn: (status: boolean) => void;\n\n  // mediasfu functions\n  checkPermission: CheckPermissionType;\n  checkScreenShare: CheckScreenShareType;\n  stopShareScreen: StopShareScreenType;\n\n  getUpdatedAllParams: () => ClickScreenShareParameters;\n  [key: string]: any;\n}\n\nexport interface ClickScreenShareOptions {\n  parameters: ClickScreenShareParameters;\n}\n\n// Export the type definition for the function\nexport type ClickScreenShareType = (options: ClickScreenShareOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickScreenShare {\n  /**\n   * Handles the action for the screen button, including starting and stopping screen sharing.\n   *\n   * @param {ClickScreenShareParams} options - Options for handling the screen button action.\n   * @returns {Promise<void>}\n   */\n  clickScreenShare = async ({ parameters }: ClickScreenShareOptions): Promise<void> => {\n    parameters = { ...parameters, ...parameters.getUpdatedAllParams() };\n    let {\n      showAlert,\n      roomName,\n      member,\n      socket,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      screenAction,\n      screenAlreadyOn,\n      screenRequestState,\n      screenRequestTime,\n      audioOnlyRoom,\n      updateRequestIntervalSeconds,\n      updateScreenRequestState,\n      updateScreenAlreadyOn,\n      checkPermission,\n      checkScreenShare,\n      stopShareScreen,\n    } = parameters;\n\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      return;\n    }\n\n    if (roomName.startsWith('d')) {\n      showAlert?.({\n        message: 'You cannot start screen share in a demo room.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    if (screenAlreadyOn) {\n      screenAlreadyOn = false;\n      updateScreenAlreadyOn(screenAlreadyOn);\n      await stopShareScreen({ parameters });\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot start screen share. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      let response = 2;\n      if (!screenAction && islevel != '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'screenshareSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      switch (response) {\n        case 0:\n          checkScreenShare({ parameters });\n          break;\n        case 1: {\n          if (screenRequestState === 'pending') {\n            showAlert?.({\n              message: 'A request is already pending. Please wait for the host to respond.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n\n          if (\n            screenRequestState === 'rejected' &&\n            Date.now() - screenRequestTime < updateRequestIntervalSeconds\n          ) {\n            showAlert?.({\n              message: 'You cannot send another request at this time.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n\n          showAlert?.({\n            message: 'Your request has been sent to the host.',\n            type: 'success',\n            duration: 3000,\n          });\n\n          screenRequestState = 'pending';\n          updateScreenRequestState(screenRequestState);\n\n          let userRequest = { id: socket.id, name: member, icon: 'fa-desktop' };\n          socket.emit('participantRequest', { userRequest, roomName });\n          break;\n        }\n        case 2:\n          showAlert?.({\n            message: 'You are not allowed to start screen share.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          break;\n        default:\n      }\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-screen-share.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-screen-share.service.ts"],"names":[],"mappings":"AAAA,0BAA0B;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAkD3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AAKH,MAAM,OAAO,gBAAgB;IAC3B;;;;;OAKG;IACH,gBAAgB,GAAG,KAAK,EAAE,EAAE,UAAU,EAA2B,EAAiB,EAAE;QAClF,UAAU,GAAG,EAAE,GAAG,UAAU,EAAE,GAAG,UAAU,CAAC,mBAAmB,EAAE,EAAE,CAAC;QACpE,IAAI,EACF,SAAS,EACT,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,YAAY,EACZ,oBAAoB,EACpB,YAAY,EACZ,YAAY,EACZ,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,aAAa,EACb,4BAA4B,EAC5B,wBAAwB,EACxB,qBAAqB,EACrB,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,GAAG,UAAU,CAAC;QAEf,IAAI,aAAa,EAAE,CAAC;YAClB,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,wDAAwD;gBACjE,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC7B,SAAS,EAAE,CAAC;gBACV,OAAO,EAAE,+CAA+C;gBACxD,IAAI,EAAE,QAAQ;gBACd,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,IAAI,eAAe,EAAE,CAAC;YACpB,eAAe,GAAG,KAAK,CAAC;YACxB,qBAAqB,CAAC,eAAe,CAAC,CAAC;YACvC,MAAM,eAAe,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,IAAI,oBAAoB,EAAE,CAAC;gBACzB,SAAS,EAAE,CAAC;oBACV,OAAO,EAAE,uDAAuD;oBAChE,IAAI,EAAE,QAAQ;oBACd,QAAQ,EAAE,IAAI;iBACf,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;YAED,IAAI,QAAQ,GAAG,CAAC,CAAC;YACjB,IAAI,CAAC,YAAY,IAAI,OAAO,IAAI,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;gBACrD,QAAQ,GAAG,MAAM,eAAe,CAAC;oBAC/B,cAAc,EAAE,oBAAoB;oBACpC,YAAY;oBACZ,YAAY;oBACZ,kBAAkB;oBAClB,WAAW;iBACZ,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,QAAQ,GAAG,CAAC,CAAC;YACf,CAAC;YAED,QAAQ,QAAQ,EAAE,CAAC;gBACjB,KAAK,CAAC;oBACJ,gBAAgB,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;oBACjC,MAAM;gBACR,KAAK,CAAC,CAAC,CAAC,CAAC;oBACP,IAAI,kBAAkB,KAAK,SAAS,EAAE,CAAC;wBACrC,SAAS,EAAE,CAAC;4BACV,OAAO,EAAE,oEAAoE;4BAC7E,IAAI,EAAE,QAAQ;4BACd,QAAQ,EAAE,IAAI;yBACf,CAAC,CAAC;wBACH,OAAO;oBACT,CAAC;oBAED,IACE,kBAAkB,KAAK,UAAU;wBACjC,IAAI,CAAC,GAAG,EAAE,GAAG,iBAAiB,GAAG,4BAA4B,EAC7D,CAAC;wBACD,SAAS,EAAE,CAAC;4BACV,OAAO,EAAE,+CAA+C;4BACxD,IAAI,EAAE,QAAQ;4BACd,QAAQ,EAAE,IAAI;yBACf,CAAC,CAAC;wBAEH,OAAO;oBACT,CAAC;oBAED,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,yCAAyC;wBAClD,IAAI,EAAE,SAAS;wBACf,QAAQ,EAAE,IAAI;qBACf,CAAC,CAAC;oBAEH,kBAAkB,GAAG,SAAS,CAAC;oBAC/B,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;oBAE7C,IAAI,WAAW,GAAG,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;oBACtE,MAAM,CAAC,IAAI,CAAC,oBAAoB,EAAE,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC;oBAC7D,MAAM;gBACR,CAAC;gBACD,KAAK,CAAC;oBACJ,SAAS,EAAE,CAAC;wBACV,OAAO,EAAE,4CAA4C;wBACrD,IAAI,EAAE,QAAQ;wBACd,QAAQ,EAAE,IAAI;qBACf,CAAC,CAAC;oBAEH,MAAM;gBACR,QAAQ;YACV,CAAC;QACH,CAAC;IACH,CAAC,CAAC;uGAlIS,gBAAgB;2GAAhB,gBAAgB,cAFf,MAAM;;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["// screen-share.service.ts\nimport { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  CheckPermissionType,\n  CheckScreenShareParameters,\n  CheckScreenShareType,\n  ShowAlert,\n  StopShareScreenParameters,\n  StopShareScreenType,\n} from '../../@types/types';\n\nexport interface ClickScreenShareParameters\n  extends CheckScreenShareParameters,\n    StopShareScreenParameters {\n  showAlert?: ShowAlert;\n  roomName: string;\n  member: string;\n  socket: Socket;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  screenAction: boolean;\n  screenAlreadyOn: boolean;\n  screenRequestState: string | null;\n  screenRequestTime: number;\n  audioOnlyRoom: boolean;\n  updateRequestIntervalSeconds: number;\n  updateScreenRequestState: (state: string | null) => void;\n  updateScreenAlreadyOn: (status: boolean) => void;\n\n  // mediasfu functions\n  checkPermission: CheckPermissionType;\n  checkScreenShare: CheckScreenShareType;\n  stopShareScreen: StopShareScreenType;\n\n  getUpdatedAllParams: () => ClickScreenShareParameters;\n  [key: string]: any;\n}\n\nexport interface ClickScreenShareOptions {\n  parameters: ClickScreenShareParameters;\n}\n\n// Export the type definition for the function\nexport type ClickScreenShareType = (options: ClickScreenShareOptions) => Promise<void>;\n\n/**\n * Handles the action for the screen button, including starting and stopping screen sharing.\n *\n * @param {ClickScreenShareOptions} options - Options for handling the screen button action.\n * @param {Object} options.parameters - The parameters required for the screen share action.\n * @param {Function} options.parameters.showAlert - Function to show alert messages.\n * @param {string} options.parameters.roomName - The name of the room where the screen share is taking place.\n * @param {string} options.parameters.member - The member initiating the screen share.\n * @param {Socket} options.parameters.socket - The socket connection used for communication.\n * @param {string} options.parameters.islevel - The participant's level.\n * @param {boolean} options.parameters.youAreCoHost - Indicates if the user is a co-host.\n * @param {boolean} options.parameters.adminRestrictSetting - Indicates if there are restrictions set by the admin.\n * @param {string} options.parameters.audioSetting - Current audio setting.\n * @param {string} options.parameters.videoSetting - Current video setting.\n * @param {string} options.parameters.screenshareSetting - Current screen share setting.\n * @param {string} options.parameters.chatSetting - Current chat setting.\n * @param {boolean} options.parameters.screenAction - Indicates if a screen action is currently taking place.\n * @param {boolean} options.parameters.screenAlreadyOn - Indicates if screen sharing is currently active.\n * @param {string | null} options.parameters.screenRequestState - State of the screen share request.\n * @param {number} options.parameters.screenRequestTime - Timestamp of when the screen share request was made.\n * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the room is audio-only.\n * @param {number} options.parameters.updateRequestIntervalSeconds - Interval time for updating request state.\n * @param {Function} options.parameters.updateScreenRequestState - Function to update the screen request state.\n * @param {Function} options.parameters.updateScreenAlreadyOn - Function to update the screen sharing status.\n * @param {Function} options.parameters.checkPermission - Function to check permissions for screen sharing.\n * @param {Function} options.parameters.checkScreenShare - Function to check and initiate screen sharing.\n * @param {Function} options.parameters.stopShareScreen - Function to stop screen sharing.\n *\n * @returns {Promise<void>} A promise that resolves when the screen share action has been handled.\n *\n * @remarks\n * This function checks the current status of screen sharing and handles the logic for starting or stopping screen sharing.\n * It validates permissions and room settings before allowing screen sharing to be activated or deactivated.\n *\n * @example\n * ```typescript\n * const options: ClickScreenShareOptions = {\n *   parameters: {\n *     showAlert: (alert) => console.log(alert.message),\n *     roomName: 'myRoom',\n *     member: 'John Doe',\n *     socket: socketInstance,\n *     islevel: '1',\n *     youAreCoHost: false,\n *     adminRestrictSetting: false,\n *     audioSetting: 'on',\n *     videoSetting: 'on',\n *     screenshareSetting: 'off',\n *     chatSetting: 'allow',\n *     screenAction: false,\n *     screenAlreadyOn: false,\n *     screenRequestState: null,\n *     screenRequestTime: 0,\n *     audioOnlyRoom: false,\n *     updateRequestIntervalSeconds: 30,\n *     updateScreenRequestState: (state) => console.log(`Screen request state: ${state}`),\n *     updateScreenAlreadyOn: (status) => console.log(`Screen already on: ${status}`),\n *     checkPermission: checkPermissionFunction,\n *     checkScreenShare: checkScreenShareFunction,\n *     stopShareScreen: stopShareScreenFunction,\n *     getUpdatedAllParams: () => parameters,\n *   },\n * };\n *\n * const clickScreenShareService = new ClickScreenShare();\n * await clickScreenShareService.clickScreenShare(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickScreenShare {\n  /**\n   * Handles the action for the screen button, including starting and stopping screen sharing.\n   *\n   * @param {ClickScreenShareParams} options - Options for handling the screen button action.\n   * @returns {Promise<void>}\n   */\n  clickScreenShare = async ({ parameters }: ClickScreenShareOptions): Promise<void> => {\n    parameters = { ...parameters, ...parameters.getUpdatedAllParams() };\n    let {\n      showAlert,\n      roomName,\n      member,\n      socket,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      screenAction,\n      screenAlreadyOn,\n      screenRequestState,\n      screenRequestTime,\n      audioOnlyRoom,\n      updateRequestIntervalSeconds,\n      updateScreenRequestState,\n      updateScreenAlreadyOn,\n      checkPermission,\n      checkScreenShare,\n      stopShareScreen,\n    } = parameters;\n\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      return;\n    }\n\n    if (roomName.startsWith('d')) {\n      showAlert?.({\n        message: 'You cannot start screen share in a demo room.',\n        type: 'danger',\n        duration: 3000,\n      });\n      return;\n    }\n\n    if (screenAlreadyOn) {\n      screenAlreadyOn = false;\n      updateScreenAlreadyOn(screenAlreadyOn);\n      await stopShareScreen({ parameters });\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot start screen share. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n        return;\n      }\n\n      let response = 2;\n      if (!screenAction && islevel != '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'screenshareSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      switch (response) {\n        case 0:\n          checkScreenShare({ parameters });\n          break;\n        case 1: {\n          if (screenRequestState === 'pending') {\n            showAlert?.({\n              message: 'A request is already pending. Please wait for the host to respond.',\n              type: 'danger',\n              duration: 3000,\n            });\n            return;\n          }\n\n          if (\n            screenRequestState === 'rejected' &&\n            Date.now() - screenRequestTime < updateRequestIntervalSeconds\n          ) {\n            showAlert?.({\n              message: 'You cannot send another request at this time.',\n              type: 'danger',\n              duration: 3000,\n            });\n\n            return;\n          }\n\n          showAlert?.({\n            message: 'Your request has been sent to the host.',\n            type: 'success',\n            duration: 3000,\n          });\n\n          screenRequestState = 'pending';\n          updateScreenRequestState(screenRequestState);\n\n          let userRequest = { id: socket.id, name: member, icon: 'fa-desktop' };\n          socket.emit('participantRequest', { userRequest, roomName });\n          break;\n        }\n        case 2:\n          showAlert?.({\n            message: 'You are not allowed to start screen share.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          break;\n        default:\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/methods/stream-methods/click-video.service.mjs

@@ -1,6 +1,94 @@
 // click-video.service.ts
 import { Injectable } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Handles the click event to toggle the participant's video on/off and manages video permission requests.
+ *
+ * @param {ClickVideoOptions} options - The options for handling the video click event.
+ * @param {ClickVideoParameters} options.parameters - The parameters required for the video action.
+ * @param {boolean} options.parameters.checkMediaPermission - Indicates if media permission needs to be checked.
+ * @param {boolean} options.parameters.hasCameraPermission - Indicates if camera permission has been granted.
+ * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently active.
+ * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the current room is audio-only.
+ * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.
+ * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.
+ * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.
+ * @param {boolean} options.parameters.recordStopped - Indicates if recording is stopped.
+ * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., "video", "audio").
+ * @param {string} options.parameters.islevel - The participant's level.
+ * @param {boolean} options.parameters.youAreCoHost - Indicates if the user is a co-host.
+ * @param {boolean} options.parameters.adminRestrictSetting - Indicates if there are admin restrictions on video.
+ * @param {string | null} options.parameters.videoRequestState - State of the video request.
+ * @param {number} options.parameters.videoRequestTime - Timestamp of the video request.
+ * @param {string} options.parameters.member - The participant's name.
+ * @param {Socket} options.parameters.socket - The socket connection used for communication.
+ * @param {string} options.parameters.roomName - The name of the room where the video is being toggled.
+ * @param {string} options.parameters.userDefaultVideoInputDevice - The default video input device.
+ * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera.
+ * @param {VidCons} options.parameters.vidCons - Video constraints for the stream.
+ * @param {number} options.parameters.frameRate - Desired frame rate for the video.
+ * @param {boolean} options.parameters.videoAction - Indicates if a video action is currently taking place.
+ * @param {MediaStream | null} options.parameters.localStream - The local media stream.
+ * @param {string} options.parameters.audioSetting - The current audio setting.
+ * @param {string} options.parameters.videoSetting - The current video setting.
+ * @param {string} options.parameters.screenshareSetting - The current screenshare setting.
+ * @param {string} options.parameters.chatSetting - The current chat setting.
+ * @param {number} options.parameters.updateRequestIntervalSeconds - Interval time for updating request state.
+ *
+ * @returns {Promise<void>} A promise that resolves when the video action has been handled.
+ *
+ * @remarks
+ * This function checks the current status of the video and handles the logic for starting or stopping the video stream.
+ * It validates permissions and room settings before allowing the video to be activated or deactivated.
+ *
+ * @example
+ * ```typescript
+ * const options: ClickVideoOptions = {
+ *   parameters: {
+ *     checkMediaPermission: true,
+ *     hasCameraPermission: false,
+ *     videoAlreadyOn: false,
+ *     audioOnlyRoom: false,
+ *     recordStarted: false,
+ *     recordResumed: false,
+ *     recordPaused: false,
+ *     recordStopped: false,
+ *     recordingMediaOptions: 'video',
+ *     islevel: '1',
+ *     youAreCoHost: false,
+ *     adminRestrictSetting: false,
+ *     videoRequestState: null,
+ *     videoRequestTime: 0,
+ *     member: 'John Doe',
+ *     socket: socketInstance,
+ *     roomName: 'myRoom',
+ *     userDefaultVideoInputDevice: '',
+ *     currentFacingMode: 'user',
+ *     vidCons: { width: 1280, height: 720 },
+ *     frameRate: 30,
+ *     videoAction: false,
+ *     localStream: null,
+ *     audioSetting: 'on',
+ *     videoSetting: 'on',
+ *     screenshareSetting: 'off',
+ *     chatSetting: 'allow',
+ *     updateRequestIntervalSeconds: 30,
+ *     showAlert: (alert) => console.log(alert.message),
+ *     updateVideoAlreadyOn: (status) => console.log(`Video already on: ${status}`),
+ *     updateVideoRequestState: (state) => console.log(`Video request state: ${state}`),
+ *     updateLocalStream: (stream) => console.log('Local stream updated'),
+ *     streamSuccessVideo: streamSuccessFunction,
+ *     disconnectSendTransportVideo: disconnectFunction,
+ *     requestPermissionCamera: requestPermissionFunction,
+ *     checkPermission: checkPermissionFunction,
+ *     getUpdatedAllParams: () => parameters,
+ *   },
+ * };
+ *
+ * const clickVideoService = new ClickVideo();
+ * await clickVideoService.clickVideo(options);
+ * ```
+ */
 export class ClickVideo {
     /**
      * Handles the click event to toggle the participant's video on/off and manages video permission requests.
@@ -180,4 +268,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     providedIn: 'root',
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-video.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-video.service.ts"],"names":[],"mappings":"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","sourcesContent":["// click-video.service.ts\nimport { Injectable } from '@angular/core';\nimport {\n  CheckPermissionType,\n  DisconnectSendTransportVideoParameters,\n  DisconnectSendTransportVideoType,\n  RequestPermissionCameraType,\n  ShowAlert,\n  StreamSuccessVideoParameters,\n  StreamSuccessVideoType,\n  VidCons,\n} from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\nexport interface ClickVideoParameters\n  extends DisconnectSendTransportVideoParameters,\n    StreamSuccessVideoParameters {\n  checkMediaPermission: boolean;\n  hasCameraPermission: boolean;\n  videoAlreadyOn: boolean;\n  audioOnlyRoom: boolean;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  recordingMediaOptions: string;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  videoRequestState: string | null;\n  videoRequestTime: number;\n  member: string;\n  socket: Socket;\n  roomName: string;\n  userDefaultVideoInputDevice: string;\n  currentFacingMode: string;\n  vidCons: VidCons;\n  frameRate: number;\n  videoAction: boolean;\n  localStream: MediaStream | null;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  updateRequestIntervalSeconds: number;\n\n  showAlert?: ShowAlert;\n  updateVideoAlreadyOn: (value: boolean) => void;\n  updateVideoRequestState: (state: string) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n\n  streamSuccessVideo: StreamSuccessVideoType;\n  disconnectSendTransportVideo: DisconnectSendTransportVideoType;\n  requestPermissionCamera: RequestPermissionCameraType;\n  checkPermission: CheckPermissionType;\n\n  getUpdatedAllParams: () => ClickVideoParameters;\n  [key: string]: any;\n}\n\nexport interface ClickVideoOptions {\n  parameters: ClickVideoParameters;\n}\n\n// Export the type definition for the function\nexport type ClickVideoType = (options: ClickVideoOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickVideo {\n  /**\n   * Handles the click event to toggle the participant's video on/off and manages video permission requests.\n   *\n   * @param {ClickVideoParams} options - The function parameters.\n   * @returns {Promise<void>}\n   */\n\n  clickVideo = async ({ parameters }: ClickVideoOptions): Promise<void> => {\n    let {\n      checkMediaPermission,\n      hasCameraPermission,\n      videoAlreadyOn,\n      audioOnlyRoom,\n      recordStarted,\n      recordResumed,\n      recordPaused,\n      recordStopped,\n      recordingMediaOptions,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      videoRequestState,\n      videoRequestTime,\n      member,\n      socket,\n      roomName,\n      userDefaultVideoInputDevice,\n      currentFacingMode,\n      vidCons,\n      frameRate,\n      videoAction,\n      localStream,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateRequestIntervalSeconds,\n      streamSuccessVideo,\n      showAlert,\n      updateVideoAlreadyOn,\n      updateVideoRequestState,\n      updateLocalStream,\n      disconnectSendTransportVideo,\n      requestPermissionCamera,\n      checkPermission,\n    } = parameters;\n\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 (videoAlreadyOn) {\n      if (islevel === '2' && (recordStarted || recordResumed)) {\n        if (!(recordPaused || recordStopped) && recordingMediaOptions === 'video') {\n          showAlert?.({\n            message:\n              'You cannot turn off your camera while recording video, please pause or stop recording first.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n      }\n\n      videoAlreadyOn = false;\n      updateVideoAlreadyOn(videoAlreadyOn);\n      if (localStream) {\n        localStream.getVideoTracks()[0].enabled = false;\n      }\n      updateLocalStream(localStream);\n      await disconnectSendTransportVideo({ parameters });\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot turn on your camera. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      let response = 2;\n\n      if (!videoAction && islevel !== '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'videoSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      if (response === 1) {\n        if (videoRequestState === 'pending') {\n          showAlert?.({\n            message: 'A request is pending. Please wait for the host to respond.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n\n        if (\n          videoRequestState === 'rejected' &&\n          Date.now() - videoRequestTime < updateRequestIntervalSeconds\n        ) {\n          showAlert?.({\n            message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n\n        showAlert?.({\n          message: 'Request sent to host.',\n          type: 'success',\n          duration: 3000,\n        });\n\n        videoRequestState = 'pending';\n        updateVideoRequestState(videoRequestState);\n\n        let userRequest = { id: socket.id, name: member, icon: 'fa-video' };\n        socket.emit('participantRequest', { userRequest, roomName });\n      } else if (response === 2) {\n        showAlert?.({\n          message: 'You cannot turn on your camera. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n      } else {\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 = {};\n        let altMediaConstraints = {};\n        if (userDefaultVideoInputDevice) {\n          if (vidCons && vidCons.width && vidCons.height) {\n            mediaConstraints = {\n              video: {\n                deviceId: userDefaultVideoInputDevice,\n                facingMode: currentFacingMode,\n                ...vidCons,\n                frameRate: { ideal: frameRate },\n              },\n              audio: false,\n            };\n            altMediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n          } else {\n            mediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n            altMediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };\n          }\n        } else {\n          if (vidCons && vidCons.width && vidCons.height) {\n            mediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n            altMediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n          } else {\n            mediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };\n          }\n        }\n\n        await navigator.mediaDevices\n          .getUserMedia(mediaConstraints)\n          .then(async (stream: MediaStream) => {\n            await streamSuccessVideo({ stream, parameters });\n          })\n          .catch(async () => {\n            await navigator.mediaDevices\n              .getUserMedia(altMediaConstraints)\n              .then(async (stream: MediaStream) => {\n                await streamSuccessVideo({ stream, parameters });\n              })\n              .catch(() => {\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          });\n      }\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"click-video.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/methods/stream-methods/click-video.service.ts"],"names":[],"mappings":"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","sourcesContent":["// click-video.service.ts\nimport { Injectable } from '@angular/core';\nimport {\n  CheckPermissionType,\n  DisconnectSendTransportVideoParameters,\n  DisconnectSendTransportVideoType,\n  RequestPermissionCameraType,\n  ShowAlert,\n  StreamSuccessVideoParameters,\n  StreamSuccessVideoType,\n  VidCons,\n} from '../../@types/types';\nimport { Socket } from 'socket.io-client';\n\nexport interface ClickVideoParameters\n  extends DisconnectSendTransportVideoParameters,\n    StreamSuccessVideoParameters {\n  checkMediaPermission: boolean;\n  hasCameraPermission: boolean;\n  videoAlreadyOn: boolean;\n  audioOnlyRoom: boolean;\n  recordStarted: boolean;\n  recordResumed: boolean;\n  recordPaused: boolean;\n  recordStopped: boolean;\n  recordingMediaOptions: string;\n  islevel: string;\n  youAreCoHost: boolean;\n  adminRestrictSetting: boolean;\n  videoRequestState: string | null;\n  videoRequestTime: number;\n  member: string;\n  socket: Socket;\n  roomName: string;\n  userDefaultVideoInputDevice: string;\n  currentFacingMode: string;\n  vidCons: VidCons;\n  frameRate: number;\n  videoAction: boolean;\n  localStream: MediaStream | null;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n  updateRequestIntervalSeconds: number;\n\n  showAlert?: ShowAlert;\n  updateVideoAlreadyOn: (value: boolean) => void;\n  updateVideoRequestState: (state: string) => void;\n  updateLocalStream: (stream: MediaStream | null) => void;\n\n  streamSuccessVideo: StreamSuccessVideoType;\n  disconnectSendTransportVideo: DisconnectSendTransportVideoType;\n  requestPermissionCamera: RequestPermissionCameraType;\n  checkPermission: CheckPermissionType;\n\n  getUpdatedAllParams: () => ClickVideoParameters;\n  [key: string]: any;\n}\n\nexport interface ClickVideoOptions {\n  parameters: ClickVideoParameters;\n}\n\n// Export the type definition for the function\nexport type ClickVideoType = (options: ClickVideoOptions) => Promise<void>;\n\n/**\n * Handles the click event to toggle the participant's video on/off and manages video permission requests.\n *\n * @param {ClickVideoOptions} options - The options for handling the video click event.\n * @param {ClickVideoParameters} options.parameters - The parameters required for the video action.\n * @param {boolean} options.parameters.checkMediaPermission - Indicates if media permission needs to be checked.\n * @param {boolean} options.parameters.hasCameraPermission - Indicates if camera permission has been granted.\n * @param {boolean} options.parameters.videoAlreadyOn - Indicates if the video is currently active.\n * @param {boolean} options.parameters.audioOnlyRoom - Indicates if the current room is audio-only.\n * @param {boolean} options.parameters.recordStarted - Indicates if recording has started.\n * @param {boolean} options.parameters.recordResumed - Indicates if recording has resumed.\n * @param {boolean} options.parameters.recordPaused - Indicates if recording is paused.\n * @param {boolean} options.parameters.recordStopped - Indicates if recording is stopped.\n * @param {string} options.parameters.recordingMediaOptions - The media options for recording (e.g., \"video\", \"audio\").\n * @param {string} options.parameters.islevel - The participant's level.\n * @param {boolean} options.parameters.youAreCoHost - Indicates if the user is a co-host.\n * @param {boolean} options.parameters.adminRestrictSetting - Indicates if there are admin restrictions on video.\n * @param {string | null} options.parameters.videoRequestState - State of the video request.\n * @param {number} options.parameters.videoRequestTime - Timestamp of the video request.\n * @param {string} options.parameters.member - The participant's name.\n * @param {Socket} options.parameters.socket - The socket connection used for communication.\n * @param {string} options.parameters.roomName - The name of the room where the video is being toggled.\n * @param {string} options.parameters.userDefaultVideoInputDevice - The default video input device.\n * @param {string} options.parameters.currentFacingMode - The current facing mode of the camera.\n * @param {VidCons} options.parameters.vidCons - Video constraints for the stream.\n * @param {number} options.parameters.frameRate - Desired frame rate for the video.\n * @param {boolean} options.parameters.videoAction - Indicates if a video action is currently taking place.\n * @param {MediaStream | null} options.parameters.localStream - The local media stream.\n * @param {string} options.parameters.audioSetting - The current audio setting.\n * @param {string} options.parameters.videoSetting - The current video setting.\n * @param {string} options.parameters.screenshareSetting - The current screenshare setting.\n * @param {string} options.parameters.chatSetting - The current chat setting.\n * @param {number} options.parameters.updateRequestIntervalSeconds - Interval time for updating request state.\n *\n * @returns {Promise<void>} A promise that resolves when the video action has been handled.\n *\n * @remarks\n * This function checks the current status of the video and handles the logic for starting or stopping the video stream.\n * It validates permissions and room settings before allowing the video to be activated or deactivated.\n *\n * @example\n * ```typescript\n * const options: ClickVideoOptions = {\n *   parameters: {\n *     checkMediaPermission: true,\n *     hasCameraPermission: false,\n *     videoAlreadyOn: false,\n *     audioOnlyRoom: false,\n *     recordStarted: false,\n *     recordResumed: false,\n *     recordPaused: false,\n *     recordStopped: false,\n *     recordingMediaOptions: 'video',\n *     islevel: '1',\n *     youAreCoHost: false,\n *     adminRestrictSetting: false,\n *     videoRequestState: null,\n *     videoRequestTime: 0,\n *     member: 'John Doe',\n *     socket: socketInstance,\n *     roomName: 'myRoom',\n *     userDefaultVideoInputDevice: '',\n *     currentFacingMode: 'user',\n *     vidCons: { width: 1280, height: 720 },\n *     frameRate: 30,\n *     videoAction: false,\n *     localStream: null,\n *     audioSetting: 'on',\n *     videoSetting: 'on',\n *     screenshareSetting: 'off',\n *     chatSetting: 'allow',\n *     updateRequestIntervalSeconds: 30,\n *     showAlert: (alert) => console.log(alert.message),\n *     updateVideoAlreadyOn: (status) => console.log(`Video already on: ${status}`),\n *     updateVideoRequestState: (state) => console.log(`Video request state: ${state}`),\n *     updateLocalStream: (stream) => console.log('Local stream updated'),\n *     streamSuccessVideo: streamSuccessFunction,\n *     disconnectSendTransportVideo: disconnectFunction,\n *     requestPermissionCamera: requestPermissionFunction,\n *     checkPermission: checkPermissionFunction,\n *     getUpdatedAllParams: () => parameters,\n *   },\n * };\n *\n * const clickVideoService = new ClickVideo();\n * await clickVideoService.clickVideo(options);\n * ```\n */\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ClickVideo {\n  /**\n   * Handles the click event to toggle the participant's video on/off and manages video permission requests.\n   *\n   * @param {ClickVideoParams} options - The function parameters.\n   * @returns {Promise<void>}\n   */\n\n  clickVideo = async ({ parameters }: ClickVideoOptions): Promise<void> => {\n    let {\n      checkMediaPermission,\n      hasCameraPermission,\n      videoAlreadyOn,\n      audioOnlyRoom,\n      recordStarted,\n      recordResumed,\n      recordPaused,\n      recordStopped,\n      recordingMediaOptions,\n      islevel,\n      youAreCoHost,\n      adminRestrictSetting,\n      videoRequestState,\n      videoRequestTime,\n      member,\n      socket,\n      roomName,\n      userDefaultVideoInputDevice,\n      currentFacingMode,\n      vidCons,\n      frameRate,\n      videoAction,\n      localStream,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateRequestIntervalSeconds,\n      streamSuccessVideo,\n      showAlert,\n      updateVideoAlreadyOn,\n      updateVideoRequestState,\n      updateLocalStream,\n      disconnectSendTransportVideo,\n      requestPermissionCamera,\n      checkPermission,\n    } = parameters;\n\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 (videoAlreadyOn) {\n      if (islevel === '2' && (recordStarted || recordResumed)) {\n        if (!(recordPaused || recordStopped) && recordingMediaOptions === 'video') {\n          showAlert?.({\n            message:\n              'You cannot turn off your camera while recording video, please pause or stop recording first.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n      }\n\n      videoAlreadyOn = false;\n      updateVideoAlreadyOn(videoAlreadyOn);\n      if (localStream) {\n        localStream.getVideoTracks()[0].enabled = false;\n      }\n      updateLocalStream(localStream);\n      await disconnectSendTransportVideo({ parameters });\n    } else {\n      if (adminRestrictSetting) {\n        showAlert?.({\n          message: 'You cannot turn on your camera. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n\n        return;\n      }\n\n      let response = 2;\n\n      if (!videoAction && islevel !== '2' && !youAreCoHost) {\n        response = await checkPermission({\n          permissionType: 'videoSetting',\n          audioSetting,\n          videoSetting,\n          screenshareSetting,\n          chatSetting,\n        });\n      } else {\n        response = 0;\n      }\n\n      if (response === 1) {\n        if (videoRequestState === 'pending') {\n          showAlert?.({\n            message: 'A request is pending. Please wait for the host to respond.',\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n\n        if (\n          videoRequestState === 'rejected' &&\n          Date.now() - videoRequestTime < updateRequestIntervalSeconds\n        ) {\n          showAlert?.({\n            message: `A request was rejected. Please wait for ${updateRequestIntervalSeconds} seconds before sending another request.`,\n            type: 'danger',\n            duration: 3000,\n          });\n\n          return;\n        }\n\n        showAlert?.({\n          message: 'Request sent to host.',\n          type: 'success',\n          duration: 3000,\n        });\n\n        videoRequestState = 'pending';\n        updateVideoRequestState(videoRequestState);\n\n        let userRequest = { id: socket.id, name: member, icon: 'fa-video' };\n        socket.emit('participantRequest', { userRequest, roomName });\n      } else if (response === 2) {\n        showAlert?.({\n          message: 'You cannot turn on your camera. Access denied by host.',\n          type: 'danger',\n          duration: 3000,\n        });\n      } else {\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 = {};\n        let altMediaConstraints = {};\n        if (userDefaultVideoInputDevice) {\n          if (vidCons && vidCons.width && vidCons.height) {\n            mediaConstraints = {\n              video: {\n                deviceId: userDefaultVideoInputDevice,\n                facingMode: currentFacingMode,\n                ...vidCons,\n                frameRate: { ideal: frameRate },\n              },\n              audio: false,\n            };\n            altMediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n          } else {\n            mediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n            altMediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };\n          }\n        } else {\n          if (vidCons && vidCons.width && vidCons.height) {\n            mediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n            altMediaConstraints = {\n              video: { ...vidCons, frameRate: { ideal: frameRate } },\n              audio: false,\n            };\n          } else {\n            mediaConstraints = { video: { frameRate: { ideal: frameRate } }, audio: false };\n          }\n        }\n\n        await navigator.mediaDevices\n          .getUserMedia(mediaConstraints)\n          .then(async (stream: MediaStream) => {\n            await streamSuccessVideo({ stream, parameters });\n          })\n          .catch(async () => {\n            await navigator.mediaDevices\n              .getUserMedia(altMediaConstraints)\n              .then(async (stream: MediaStream) => {\n                await streamSuccessVideo({ stream, parameters });\n              })\n              .catch(() => {\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          });\n      }\n    }\n  };\n}\n"]}