mediasfu-angular 1.0.0

package/dist/esm2022/lib/producers/socket-receive-methods/producer-media-resumed.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ProducerMediaResumed {
+    /**
+     * Resumes media for a specific participant in a meeting.
+     *
+     * @param {ProducerMediaResumedOptions} options - The options for resuming media.
+     * @param {string} options.name - The name of the participant whose media is to be resumed.
+     * @param {Object} options.parameters - The parameters related to the meeting and participants.
+     * @param {string} options.parameters.meetingDisplayType - The type of meeting display.
+     * @param {Array} options.parameters.participants - The list of participants in the meeting.
+     * @param {boolean} options.parameters.shared - Indicates if the screen is being shared.
+     * @param {boolean} options.parameters.shareScreenStarted - Indicates if screen sharing has started.
+     * @param {boolean} options.parameters.mainScreenFilled - Indicates if the main screen is filled.
+     * @param {string} options.parameters.hostLabel - The label of the host.
+     * @param {Function} options.parameters.updateUpdateMainWindow - Function to update the main window.
+     * @param {Function} options.parameters.reorderStreams - Function to reorder the streams.
+     * @param {Function} options.parameters.prepopulateUserMedia - Function to prepopulate user media.
+     *
+     * @returns {Promise<void>} A promise that resolves when the media has been resumed.
+     */
+    producerMediaResumed = async ({ name, parameters, }) => {
+        parameters = parameters.getUpdatedAllParams();
+        let { meetingDisplayType, participants, shared, shareScreenStarted, updateMainWindow, mainScreenFilled, hostLabel, updateUpdateMainWindow, reorderStreams, prepopulateUserMedia, } = parameters;
+        // Update to resume the audio only of a participant
+        // name is the name of the participant
+        // kind is the kind of media (always audio)
+        // Operations to update UI to optimize interest levels
+        const participant = participants.find((obj) => obj.name == name);
+        if (!mainScreenFilled && participant?.islevel == '2') {
+            updateMainWindow = true;
+            updateUpdateMainWindow(updateMainWindow);
+            await prepopulateUserMedia({ name: hostLabel, parameters });
+            updateMainWindow = false;
+            updateUpdateMainWindow(updateMainWindow);
+        }
+        let checker;
+        if (meetingDisplayType == 'media') {
+            checker = participant?.videoID != null && participant.videoID !== '';
+            if (!checker && !(shareScreenStarted || shared)) {
+                await reorderStreams({ add: false, screenChanged: true, parameters });
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaResumed, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaResumed, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ProducerMediaResumed, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/producers/socket-receive-methods/re-initiate-recording.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ReInitiateRecording {
+    /**
+     * Re-initiates recording based on specific conditions.
+     * @async
+     * @function
+     * @param {ReInitiateRecordingOptions} options - The options for re-initiating recording.
+     * @param {string} options.roomName - The name of the room to re-initiate recording.
+     * @param {string} options.member - The member re-initiating the recording.
+     * @param {Socket} options.socket - The socket instance for communication.
+     * @param {boolean} options.adminRestrictSetting - Indicates whether the admin restrict setting is enabled.
+     * @returns {Promise<void>} A promise that resolves when the recording is re-initiated.
+     */
+    reInitiateRecording = async ({ roomName, member, socket, adminRestrictSetting, }) => {
+        if (!adminRestrictSetting) {
+            await new Promise((resolve, reject) => {
+                socket.emit('startRecordIng', { roomName, member }, ({ success }) => {
+                    if (success) {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error('Failed to re-initiate recording.'));
+                    }
+                });
+            });
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReInitiateRecording, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReInitiateRecording, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReInitiateRecording, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmUtaW5pdGlhdGUtcmVjb3JkaW5nLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tZWRpYXNmdS1hbmd1bGFyL3NyYy9saWIvcHJvZHVjZXJzL3NvY2tldC1yZWNlaXZlLW1ldGhvZHMvcmUtaW5pdGlhdGUtcmVjb3JkaW5nLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFnQjNDLE1BQU0sT0FBTyxtQkFBbUI7SUFDOUI7Ozs7Ozs7Ozs7T0FVRztJQUVILG1CQUFtQixHQUFHLEtBQUssRUFBRSxFQUMzQixRQUFRLEVBQ1IsTUFBTSxFQUNOLE1BQU0sRUFDTixvQkFBb0IsR0FDTyxFQUFpQixFQUFFO1FBQzlDLElBQUksQ0FBQyxvQkFBb0IsRUFBRSxDQUFDO1lBQzFCLE1BQU0sSUFBSSxPQUFPLENBQU8sQ0FBQyxPQUFPLEVBQUUsTUFBTSxFQUFFLEVBQUU7Z0JBQzFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQyxFQUFFLE9BQU8sRUFBd0IsRUFBRSxFQUFFO29CQUN4RixJQUFJLE9BQU8sRUFBRSxDQUFDO3dCQUNaLE9BQU8sRUFBRSxDQUFDO29CQUNaLENBQUM7eUJBQU0sQ0FBQzt3QkFDTixNQUFNLENBQUMsSUFBSSxLQUFLLENBQUMsa0NBQWtDLENBQUMsQ0FBQyxDQUFDO29CQUN4RCxDQUFDO2dCQUNILENBQUMsQ0FBQyxDQUFDO1lBQ0wsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO0lBQ0gsQ0FBQyxDQUFDO3VHQTlCUyxtQkFBbUI7MkdBQW5CLG1CQUFtQixjQUZsQixNQUFNOzsyRkFFUCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU29ja2V0IH0gZnJvbSAnc29ja2V0LmlvLWNsaWVudCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVJbml0aWF0ZVJlY29yZGluZ09wdGlvbnMge1xuICByb29tTmFtZTogc3RyaW5nO1xuICBtZW1iZXI6IHN0cmluZztcbiAgc29ja2V0OiBTb2NrZXQ7XG4gIGFkbWluUmVzdHJpY3RTZXR0aW5nOiBib29sZWFuO1xufVxuXG4vLyBFeHBvcnQgdGhlIHR5cGUgZGVmaW5pdGlvbiBmb3IgdGhlIGZ1bmN0aW9uXG5leHBvcnQgdHlwZSBSZUluaXRpYXRlUmVjb3JkaW5nVHlwZSA9IChvcHRpb25zOiBSZUluaXRpYXRlUmVjb3JkaW5nT3B0aW9ucykgPT4gUHJvbWlzZTx2b2lkPjtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIFJlSW5pdGlhdGVSZWNvcmRpbmcge1xuICAvKipcbiAgICogUmUtaW5pdGlhdGVzIHJlY29yZGluZyBiYXNlZCBvbiBzcGVjaWZpYyBjb25kaXRpb25zLlxuICAgKiBAYXN5bmNcbiAgICogQGZ1bmN0aW9uXG4gICAqIEBwYXJhbSB7UmVJbml0aWF0ZVJlY29yZGluZ09wdGlvbnN9IG9wdGlvbnMgLSBUaGUgb3B0aW9ucyBmb3IgcmUtaW5pdGlhdGluZyByZWNvcmRpbmcuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBvcHRpb25zLnJvb21OYW1lIC0gVGhlIG5hbWUgb2YgdGhlIHJvb20gdG8gcmUtaW5pdGlhdGUgcmVjb3JkaW5nLlxuICAgKiBAcGFyYW0ge3N0cmluZ30gb3B0aW9ucy5tZW1iZXIgLSBUaGUgbWVtYmVyIHJlLWluaXRpYXRpbmcgdGhlIHJlY29yZGluZy5cbiAgICogQHBhcmFtIHtTb2NrZXR9IG9wdGlvbnMuc29ja2V0IC0gVGhlIHNvY2tldCBpbnN0YW5jZSBmb3IgY29tbXVuaWNhdGlvbi5cbiAgICogQHBhcmFtIHtib29sZWFufSBvcHRpb25zLmFkbWluUmVzdHJpY3RTZXR0aW5nIC0gSW5kaWNhdGVzIHdoZXRoZXIgdGhlIGFkbWluIHJlc3RyaWN0IHNldHRpbmcgaXMgZW5hYmxlZC5cbiAgICogQHJldHVybnMge1Byb21pc2U8dm9pZD59IEEgcHJvbWlzZSB0aGF0IHJlc29sdmVzIHdoZW4gdGhlIHJlY29yZGluZyBpcyByZS1pbml0aWF0ZWQuXG4gICAqL1xuXG4gIHJlSW5pdGlhdGVSZWNvcmRpbmcgPSBhc3luYyAoe1xuICAgIHJvb21OYW1lLFxuICAgIG1lbWJlcixcbiAgICBzb2NrZXQsXG4gICAgYWRtaW5SZXN0cmljdFNldHRpbmcsXG4gIH06IFJlSW5pdGlhdGVSZWNvcmRpbmdPcHRpb25zKTogUHJvbWlzZTx2b2lkPiA9PiB7XG4gICAgaWYgKCFhZG1pblJlc3RyaWN0U2V0dGluZykge1xuICAgICAgYXdhaXQgbmV3IFByb21pc2U8dm9pZD4oKHJlc29sdmUsIHJlamVjdCkgPT4ge1xuICAgICAgICBzb2NrZXQuZW1pdCgnc3RhcnRSZWNvcmRJbmcnLCB7IHJvb21OYW1lLCBtZW1iZXIgfSwgKHsgc3VjY2VzcyB9OiB7IHN1Y2Nlc3M6IGJvb2xlYW4gfSkgPT4ge1xuICAgICAgICAgIGlmIChzdWNjZXNzKSB7XG4gICAgICAgICAgICByZXNvbHZlKCk7XG4gICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIHJlamVjdChuZXcgRXJyb3IoJ0ZhaWxlZCB0byByZS1pbml0aWF0ZSByZWNvcmRpbmcuJykpO1xuICAgICAgICAgIH1cbiAgICAgICAgfSk7XG4gICAgICB9KTtcbiAgICB9XG4gIH07XG59XG4iXX0=

package/dist/esm2022/lib/producers/socket-receive-methods/receive-message.service.mjs

@@ -0,0 +1,96 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ReceiveMessage {
+    /**
+     * Receives and processes a message, updating the messages array and handling
+     * various message types and events.
+     *
+     * @param {ReceiveMessageOptions} options - The options for receiving the message.
+     * @param {Object} options.message - The message object containing sender, receivers, content, timestamp, and group.
+     * @param {Function} options.getUpdatedAllParams - Function to get updated parameters.
+     * @param {Array} options.messages - Array of current messages.
+     * @param {Array} options.participantsAll - Array of all participants.
+     * @param {string} options.member - The current member.
+     * @param {string} options.eventType - The type of event (e.g., "broadcast", "chat").
+     * @param {string} options.islevel - The level of the current member.
+     * @param {string} options.coHost - The co-host of the event.
+     * @param {Function} options.updateMessages - Function to update the messages array.
+     * @param {Function} options.updateShowMessagesBadge - Function to update the visibility of the messages badge.
+     *
+     * @returns {Promise<void>} A promise that resolves when the message has been processed.
+     */
+    receiveMessage = async ({ message, messages, participantsAll, member, eventType, islevel, coHost, updateMessages, updateShowMessagesBadge, }) => {
+        // Add the received message to the messages array
+        const { sender, receivers, message: content, timestamp, group } = message;
+        let oldMessages = messages;
+        messages = [...messages, { sender, receivers, message: content, timestamp, group }];
+        // Filter out messages with banned senders in the participants array
+        if (eventType !== 'broadcast' && eventType !== 'chat') {
+            messages = messages.filter((message) => participantsAll.some((participant) => participant.name === message.sender && !participant.isBanned));
+        }
+        else {
+            messages = messages.filter((message) => {
+                const participant = participantsAll.find((participant) => participant.name === message.sender);
+                return !participant || !participant.isBanned;
+            });
+        }
+        updateMessages(messages);
+        // Separate group and direct messages
+        const oldGroupMessages = oldMessages.filter((message) => message.group);
+        const oldDirectMessages = oldMessages.filter((message) => !message.group);
+        // Render and update counts for group messages
+        const groupMessages = messages.filter((message) => message.group);
+        if (eventType !== 'broadcast' && eventType !== 'chat') {
+            // Check if oldGroupMessages length is different from groupMessages length
+            if (oldGroupMessages.length !== groupMessages.length) {
+                // Identify new messages
+                const newGroupMessages = groupMessages.filter((message) => !oldGroupMessages.some((oldMessage) => oldMessage.timestamp === message.timestamp));
+                // Check if newGroupMessages sender is the member or receivers include the member
+                const newGroupMessages2 = newGroupMessages.filter((message) => message.sender === member || message.receivers.includes(member));
+                // Check if member is the sender of any newGroupMessages
+                const newGroupMessages3 = newGroupMessages2.filter((message) => message.sender === member);
+                // Check if member is the receiver of any newGroupMessages
+                if (newGroupMessages.length > 0 && newGroupMessages.length !== newGroupMessages3.length) {
+                    updateShowMessagesBadge(true);
+                }
+            }
+        }
+        // Render and update counts for direct messages
+        const directMessages = messages.filter((message) => !message.group);
+        if (eventType !== 'broadcast' && eventType !== 'chat') {
+            // Check if oldDirectMessages length is different from directMessages length
+            if (oldDirectMessages.length !== directMessages.length) {
+                // Identify new direct messages
+                const newDirectMessages = directMessages.filter((message) => !oldDirectMessages.some((oldMessage) => oldMessage.timestamp === message.timestamp));
+                // Check if newDirectMessages sender is the member or receivers include the member
+                const newDirectMessages2 = newDirectMessages.filter((message) => message.sender === member || message.receivers.includes(member));
+                // Check if member is the sender of any newDirectMessages
+                const newDirectMessages3 = newDirectMessages2.filter((message) => message.sender === member);
+                if ((newDirectMessages.length > 0 && newDirectMessages2.length > 0) ||
+                    (newDirectMessages.length > 0 && islevel === '2') ||
+                    coHost === member) {
+                    if (islevel === '2' || coHost === member) {
+                        if (newDirectMessages.length !== newDirectMessages3.length) {
+                            updateShowMessagesBadge(true);
+                        }
+                    }
+                    else {
+                        if (newDirectMessages2.length > 0 &&
+                            newDirectMessages.length !== newDirectMessages3.length) {
+                            updateShowMessagesBadge(true);
+                        }
+                    }
+                }
+            }
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveMessage, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveMessage, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ReceiveMessage, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"receive-message.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/receive-message.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { EventType, Message, Participant } from '../../@types/types';\n\nexport interface ReceiveMessageOptions {\n  message: Message;\n  messages: Message[];\n  participantsAll: Participant[];\n  member: string;\n  eventType: EventType;\n  islevel: string;\n  coHost: string;\n  updateMessages: (messages: Message[]) => void;\n  updateShowMessagesBadge: (showBadge: boolean) => void;\n}\n\n// Export the type definition for the function\nexport type ReceiveMessageType = (options: ReceiveMessageOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ReceiveMessage {\n  /**\n   * Receives and processes a message, updating the messages array and handling\n   * various message types and events.\n   *\n   * @param {ReceiveMessageOptions} options - The options for receiving the message.\n   * @param {Object} options.message - The message object containing sender, receivers, content, timestamp, and group.\n   * @param {Function} options.getUpdatedAllParams - Function to get updated parameters.\n   * @param {Array} options.messages - Array of current messages.\n   * @param {Array} options.participantsAll - Array of all participants.\n   * @param {string} options.member - The current member.\n   * @param {string} options.eventType - The type of event (e.g., \"broadcast\", \"chat\").\n   * @param {string} options.islevel - The level of the current member.\n   * @param {string} options.coHost - The co-host of the event.\n   * @param {Function} options.updateMessages - Function to update the messages array.\n   * @param {Function} options.updateShowMessagesBadge - Function to update the visibility of the messages badge.\n   *\n   * @returns {Promise<void>} A promise that resolves when the message has been processed.\n   */\n\n  receiveMessage = async ({\n    message,\n    messages,\n    participantsAll,\n    member,\n    eventType,\n    islevel,\n    coHost,\n    updateMessages,\n    updateShowMessagesBadge,\n  }: ReceiveMessageOptions): Promise<void> => {\n    // Add the received message to the messages array\n    const { sender, receivers, message: content, timestamp, group } = message;\n    let oldMessages = messages;\n    messages = [...messages, { sender, receivers, message: content, timestamp, group }];\n\n    // Filter out messages with banned senders in the participants array\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      messages = messages.filter((message: Message) =>\n        participantsAll.some(\n          (participant: any) => participant.name === message.sender && !participant.isBanned,\n        ),\n      );\n    } else {\n      messages = messages.filter((message: Message) => {\n        const participant = participantsAll.find(\n          (participant: any) => participant.name === message.sender,\n        );\n        return !participant || !participant.isBanned;\n      });\n    }\n    updateMessages(messages);\n\n    // Separate group and direct messages\n    const oldGroupMessages = oldMessages.filter((message: Message) => message.group);\n    const oldDirectMessages = oldMessages.filter((message: Message) => !message.group);\n\n    // Render and update counts for group messages\n    const groupMessages = messages.filter((message: Message) => message.group);\n\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      // Check if oldGroupMessages length is different from groupMessages length\n      if (oldGroupMessages.length !== groupMessages.length) {\n        // Identify new messages\n        const newGroupMessages = groupMessages.filter(\n          (message: Message) =>\n            !oldGroupMessages.some(\n              (oldMessage: Message) => oldMessage.timestamp === message.timestamp,\n            ),\n        );\n\n        // Check if newGroupMessages sender is the member or receivers include the member\n        const newGroupMessages2 = newGroupMessages.filter(\n          (message: Message) => message.sender === member || message.receivers.includes(member),\n        );\n\n        // Check if member is the sender of any newGroupMessages\n        const newGroupMessages3 = newGroupMessages2.filter(\n          (message: Message) => message.sender === member,\n        );\n\n        // Check if member is the receiver of any newGroupMessages\n        if (newGroupMessages.length > 0 && newGroupMessages.length !== newGroupMessages3.length) {\n          updateShowMessagesBadge(true);\n        }\n      }\n    }\n\n    // Render and update counts for direct messages\n    const directMessages = messages.filter((message: Message) => !message.group);\n\n    if (eventType !== 'broadcast' && eventType !== 'chat') {\n      // Check if oldDirectMessages length is different from directMessages length\n      if (oldDirectMessages.length !== directMessages.length) {\n        // Identify new direct messages\n        const newDirectMessages = directMessages.filter(\n          (message: Message) =>\n            !oldDirectMessages.some(\n              (oldMessage: Message) => oldMessage.timestamp === message.timestamp,\n            ),\n        );\n\n        // Check if newDirectMessages sender is the member or receivers include the member\n        const newDirectMessages2 = newDirectMessages.filter(\n          (message: Message) => message.sender === member || message.receivers.includes(member),\n        );\n\n        // Check if member is the sender of any newDirectMessages\n        const newDirectMessages3 = newDirectMessages2.filter(\n          (message: Message) => message.sender === member,\n        );\n\n        if (\n          (newDirectMessages.length > 0 && newDirectMessages2.length > 0) ||\n          (newDirectMessages.length > 0 && islevel === '2') ||\n          coHost === member\n        ) {\n          if (islevel === '2' || coHost === member) {\n            if (newDirectMessages.length !== newDirectMessages3.length) {\n              updateShowMessagesBadge(true);\n            }\n          } else {\n            if (\n              newDirectMessages2.length > 0 &&\n              newDirectMessages.length !== newDirectMessages3.length\n            ) {\n              updateShowMessagesBadge(true);\n            }\n          }\n        }\n      }\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/recording-notice.service.mjs

@@ -0,0 +1,195 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../methods/utils/sound-player.service";
+export class RecordingNotice {
+    SoundPlayerService;
+    constructor(SoundPlayerService) {
+        this.SoundPlayerService = SoundPlayerService;
+    }
+    /**
+     * Handles the recording notice state and updates various recording parameters accordingly.
+     *
+     * @param {Object} options - The options object.
+     * @param {string} options.state - The current state of the recording (e.g., "pause", "stop").
+     * @param {Object} options.userRecordingParam - The user recording parameters.
+     * @param {number} options.pauseCount - The count of pauses during the recording.
+     * @param {number} options.timeDone - The elapsed time of the recording.
+     * @param {Object} options.parameters - The parameters object containing various update functions and state variables.
+     * @param {string} options.parameters.islevel - The level of the recording.
+     * @param {Object} options.parameters.userRecordingParams - The user recording parameters.
+     * @param {number} options.parameters.pauseRecordCount - The count of pauses during the recording.
+     * @param {number} options.parameters.recordElapsedTime - The elapsed time of the recording.
+     * @param {number} options.parameters.recordStartTime - The start time of the recording.
+     * @param {boolean} options.parameters.recordStarted - Indicates if the recording has started.
+     * @param {boolean} options.parameters.recordPaused - Indicates if the recording is paused.
+     * @param {boolean} options.parameters.canLaunchRecord - Indicates if the recording can be launched.
+     * @param {boolean} options.parameters.stopLaunchRecord - Indicates if the recording launch should be stopped.
+     * @param {boolean} options.parameters.recordStopped - Indicates if the recording is stopped.
+     * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is running.
+     * @param {boolean} options.parameters.canPauseResume - Indicates if the recording can be paused or resumed.
+     * @param {string} options.parameters.eventType - The type of event triggering the recording notice.
+     * @param {Function} options.parameters.updateRecordingProgressTime - Function to update the recording progress time.
+     * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of record buttons.
+     * @param {Function} options.parameters.updateUserRecordingParams - Function to update user recording parameters.
+     * @param {Function} options.parameters.updateRecordingMediaOptions - Function to update recording media options.
+     * @param {Function} options.parameters.updateRecordingAudioOptions - Function to update recording audio options.
+     * @param {Function} options.parameters.updateRecordingVideoOptions - Function to update recording video options.
+     * @param {Function} options.parameters.updateRecordingVideoType - Function to update recording video type.
+     * @param {Function} options.parameters.updateRecordingVideoOptimized - Function to update recording video optimization.
+     * @param {Function} options.parameters.updateRecordingDisplayType - Function to update recording display type.
+     * @param {Function} options.parameters.updateRecordingAddHLS - Function to update HLS addition in recording.
+     * @param {Function} options.parameters.updateRecordingNameTags - Function to update recording name tags.
+     * @param {Function} options.parameters.updateRecordingBackgroundColor - Function to update recording background color.
+     * @param {Function} options.parameters.updateRecordingNameTagsColor - Function to update recording name tags color.
+     * @param {Function} options.parameters.updateRecordingOrientationVideo - Function to update recording orientation video.
+     * @param {Function} options.parameters.updateRecordingAddText - Function to update recording text addition.
+     * @param {Function} options.parameters.updateRecordingCustomText - Function to update custom text in recording.
+     * @param {Function} options.parameters.updateRecordingCustomTextPosition - Function to update custom text position.
+     * @param {Function} options.parameters.updateRecordingCustomTextColor - Function to update custom text color.
+     * @param {Function} options.parameters.updatePauseRecordCount - Function to update pause record count.
+     * @param {Function} options.parameters.updateRecordElapsedTime - Function to update record elapsed time.
+     * @param {Function} options.parameters.updateRecordStartTime - Function to update record start time.
+     * @param {Function} options.parameters.updateRecordStarted - Function to update record started status.
+     * @param {Function} options.parameters.updateRecordPaused - Function to update record paused status.
+     * @param {Function} options.parameters.updateCanLaunchRecord - Function to update can launch record status.
+     * @param {Function} options.parameters.updateStopLaunchRecord - Function to update stop launch record status.
+     * @param {Function} options.parameters.updateRecordStopped - Function to update record stopped status.
+     * @param {Function} options.parameters.updateIsTimerRunning - Function to update timer running status.
+     * @param {Function} options.parameters.updateCanPauseResume - Function to update can pause/resume status.
+     * @param {Function} options.parameters.updateRecordState - Function to update the record state.
+     *
+     * @returns {Promise<void>} A promise that resolves when the recording notice handling is complete.
+     *
+     * @throws {Error} Throws an error if handling the recording state and status fails.
+     */
+    RecordingNotice = async ({ state, userRecordingParam, pauseCount, timeDone, parameters, }) => {
+        let { islevel, userRecordingParams, pauseRecordCount, recordElapsedTime, recordStartTime, recordStarted, recordPaused, canLaunchRecord, stopLaunchRecord, recordStopped, isTimerRunning, canPauseResume, eventType, updateRecordingProgressTime, updateShowRecordButtons, updateUserRecordingParams, updateRecordingMediaOptions, updateRecordingAudioOptions, updateRecordingVideoOptions, updateRecordingVideoType, updateRecordingVideoOptimized, updateRecordingDisplayType, updateRecordingAddHLS, updateRecordingNameTags, updateRecordingBackgroundColor, updateRecordingNameTagsColor, updateRecordingOrientationVideo, updateRecordingAddText, updateRecordingCustomText, updateRecordingCustomTextPosition, updateRecordingCustomTextColor, updatePauseRecordCount, updateRecordElapsedTime, updateRecordStartTime, updateRecordStarted, updateRecordPaused, updateCanLaunchRecord, updateStopLaunchRecord, updateRecordStopped, updateIsTimerRunning, updateCanPauseResume, updateRecordState, } = parameters;
+        try {
+            if (islevel !== '2') {
+                if (state === 'pause') {
+                    updateRecordStarted(true);
+                    updateRecordPaused(true);
+                    updateRecordState('yellow');
+                    eventType !== 'broadcast' &&
+                        this.SoundPlayerService.playSound({
+                            soundUrl: 'https://www.mediasfu.com/sounds/record-paused.mp3',
+                        });
+                }
+                else if (state === 'stop') {
+                    updateRecordStarted(true);
+                    updateRecordStopped(true);
+                    updateRecordState('green');
+                    eventType !== 'broadcast' &&
+                        this.SoundPlayerService.playSound({
+                            soundUrl: 'https://www.mediasfu.com/sounds/record-stopped.mp3',
+                        });
+                }
+                else {
+                    updateRecordState('red');
+                    updateRecordStarted(true);
+                    updateRecordPaused(false);
+                    eventType !== 'broadcast' &&
+                        this.SoundPlayerService.playSound({
+                            soundUrl: 'https://www.mediasfu.com/sounds/record-progress.mp3',
+                        });
+                }
+            }
+            else {
+                if (state === 'pause') {
+                    updateRecordState('yellow');
+                    if (userRecordingParam) {
+                        userRecordingParams.mainSpecs = userRecordingParam.mainSpecs;
+                        userRecordingParams.dispSpecs = userRecordingParam.dispSpecs;
+                        userRecordingParams.textSpecs = userRecordingParam.textSpecs;
+                        updateUserRecordingParams(userRecordingParams);
+                        updateRecordingMediaOptions(userRecordingParams.mainSpecs.mediaOptions);
+                        updateRecordingAudioOptions(userRecordingParams.mainSpecs.audioOptions);
+                        updateRecordingVideoOptions(userRecordingParams.mainSpecs.videoOptions);
+                        updateRecordingVideoType(userRecordingParams.mainSpecs.videoType);
+                        updateRecordingVideoOptimized(userRecordingParams.mainSpecs.videoOptimized);
+                        updateRecordingDisplayType(userRecordingParams.mainSpecs.recordingDisplayType);
+                        updateRecordingAddHLS(userRecordingParams.mainSpecs.addHLS);
+                        updateRecordingNameTags(userRecordingParams.dispSpecs.nameTags);
+                        updateRecordingBackgroundColor(userRecordingParams.dispSpecs.backgroundColor);
+                        updateRecordingNameTagsColor(userRecordingParams.dispSpecs.nameTagsColor);
+                        updateRecordingOrientationVideo(userRecordingParams.dispSpecs.orientationVideo);
+                        updateRecordingAddText(userRecordingParams.textSpecs?.addText ?? false);
+                        updateRecordingCustomText(userRecordingParams.textSpecs?.customText ?? '');
+                        updateRecordingCustomTextPosition(userRecordingParams.textSpecs?.customTextPosition ?? '');
+                        updateRecordingCustomTextColor(userRecordingParams.textSpecs?.customTextColor ?? '');
+                        pauseRecordCount = pauseCount;
+                        updatePauseRecordCount(pauseRecordCount);
+                        recordElapsedTime = timeDone;
+                        recordElapsedTime = Math.floor(recordElapsedTime / 1000);
+                        recordStartTime = Math.floor(Date.now() / 1000) - recordElapsedTime;
+                        updateRecordStartTime(recordStartTime);
+                        updateRecordElapsedTime(recordElapsedTime);
+                        recordStarted = true;
+                        recordPaused = true;
+                        canLaunchRecord = false;
+                        recordStopped = false;
+                        updateRecordStarted(recordStarted);
+                        updateRecordPaused(recordPaused);
+                        updateCanLaunchRecord(canLaunchRecord);
+                        updateRecordStopped(recordStopped);
+                        updateShowRecordButtons(true);
+                        isTimerRunning = false;
+                        canPauseResume = true;
+                        updateIsTimerRunning(isTimerRunning);
+                        updateCanPauseResume(canPauseResume);
+                        const formattedTime = this.formatElapsedTime(recordElapsedTime);
+                        updateRecordingProgressTime(formattedTime);
+                    }
+                    this.SoundPlayerService.playSound({
+                        soundUrl: 'https://www.mediasfu.com/sounds/record-paused.mp3',
+                    });
+                }
+                else if (state === 'stop') {
+                    updateRecordStarted(true);
+                    updateRecordStopped(true);
+                    canLaunchRecord = false;
+                    stopLaunchRecord = true;
+                    updateRecordStarted(recordStarted);
+                    updateRecordStopped(recordStopped);
+                    updateCanLaunchRecord(canLaunchRecord);
+                    updateStopLaunchRecord(stopLaunchRecord);
+                    updateShowRecordButtons(false);
+                    updateRecordState('green');
+                    this.SoundPlayerService.playSound({
+                        soundUrl: 'https://www.mediasfu.com/sounds/record-stopped.mp3',
+                    });
+                }
+                else {
+                    updateRecordState('red');
+                    updateRecordStarted(true);
+                    updateRecordPaused(false);
+                    this.SoundPlayerService.playSound({
+                        soundUrl: 'https://www.mediasfu.com/sounds/record-progress.mp3',
+                    });
+                }
+            }
+        }
+        catch (error) {
+            console.log('Error in RecordingNotice: ', error);
+            // throw new Error("Failed to handle recording state and status.");
+        }
+    };
+    formatElapsedTime = (recordElapsedTime) => {
+        const hours = Math.floor(recordElapsedTime / 3600);
+        const minutes = Math.floor((recordElapsedTime % 3600) / 60);
+        const seconds = recordElapsedTime % 60;
+        return `${this.padNumber(hours)}:${this.padNumber(minutes)}:${this.padNumber(seconds)}`;
+    };
+    padNumber = (number) => {
+        return number.toString().padStart(2, '0');
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RecordingNotice, deps: [{ token: i1.SoundPlayer }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RecordingNotice, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RecordingNotice, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SoundPlayer }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recording-notice.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/recording-notice.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SoundPlayer } from '../../methods/utils/sound-player.service';\n\nimport { EventType, UserRecordingParams } from '../../@types/types';\n\nexport interface RecordingNoticeParameters {\n  islevel: string;\n  userRecordingParams: UserRecordingParams;\n  recordElapsedTime: number;\n  recordStartTime: number;\n  recordStarted: boolean;\n  recordPaused: boolean;\n  canLaunchRecord: boolean;\n  stopLaunchRecord: boolean;\n  recordStopped: boolean;\n  isTimerRunning: boolean;\n  canPauseResume: boolean;\n  eventType: EventType;\n\n  updateRecordingProgressTime: (time: string) => void;\n  updateShowRecordButtons: (show: boolean) => void;\n  updateUserRecordingParams: (params: UserRecordingParams) => void;\n  updateRecordingMediaOptions: (options: string) => void;\n  updateRecordingAudioOptions: (options: string) => void;\n  updateRecordingVideoOptions: (options: string) => void;\n  updateRecordingVideoType: (type: string) => void;\n  updateRecordingVideoOptimized: (optimized: boolean) => void;\n  updateRecordingDisplayType: (type: 'video' | 'media' | 'all') => void;\n  updateRecordingAddHLS: (addHLS: boolean) => void;\n  updateRecordingNameTags: (nameTags: boolean) => void;\n  updateRecordingBackgroundColor: (color: string) => void;\n  updateRecordingNameTagsColor: (color: string) => void;\n  updateRecordingOrientationVideo: (orientation: string) => void;\n  updateRecordingAddText: (addText: boolean) => void;\n  updateRecordingCustomText: (text: string) => void;\n  updateRecordingCustomTextPosition: (position: string) => void;\n  updateRecordingCustomTextColor: (color: string) => void;\n  updatePauseRecordCount: (count: number) => void;\n  updateRecordElapsedTime: (time: number) => void;\n  updateRecordStarted: (started: boolean) => void;\n  updateRecordPaused: (paused: boolean) => void;\n  updateCanLaunchRecord: (canLaunch: boolean) => void;\n  updateStopLaunchRecord: (stop: boolean) => void;\n  updateRecordStopped: (stopped: boolean) => void;\n  updateIsTimerRunning: (running: boolean) => void;\n  updateCanPauseResume: (canPause: boolean) => void;\n  updateRecordStartTime: (startTime: number) => void;\n  updateRecordState: (state: string) => void;\n\n  // mediasfu functions\n  [key: string]: any;\n}\n\nexport interface RecordingNoticeOptions {\n  state: string;\n  userRecordingParam: UserRecordingParams | null;\n  pauseCount: number;\n  timeDone: number;\n  parameters: RecordingNoticeParameters;\n}\n\n// Export the type definition for the function\nexport type RecordingNoticeType = (options: RecordingNoticeOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RecordingNotice {\n  constructor(private SoundPlayerService: SoundPlayer) {}\n\n  /**\n   * Handles the recording notice state and updates various recording parameters accordingly.\n   *\n   * @param {Object} options - The options object.\n   * @param {string} options.state - The current state of the recording (e.g., \"pause\", \"stop\").\n   * @param {Object} options.userRecordingParam - The user recording parameters.\n   * @param {number} options.pauseCount - The count of pauses during the recording.\n   * @param {number} options.timeDone - The elapsed time of the recording.\n   * @param {Object} options.parameters - The parameters object containing various update functions and state variables.\n   * @param {string} options.parameters.islevel - The level of the recording.\n   * @param {Object} options.parameters.userRecordingParams - The user recording parameters.\n   * @param {number} options.parameters.pauseRecordCount - The count of pauses during the recording.\n   * @param {number} options.parameters.recordElapsedTime - The elapsed time of the recording.\n   * @param {number} options.parameters.recordStartTime - The start time of the recording.\n   * @param {boolean} options.parameters.recordStarted - Indicates if the recording has started.\n   * @param {boolean} options.parameters.recordPaused - Indicates if the recording is paused.\n   * @param {boolean} options.parameters.canLaunchRecord - Indicates if the recording can be launched.\n   * @param {boolean} options.parameters.stopLaunchRecord - Indicates if the recording launch should be stopped.\n   * @param {boolean} options.parameters.recordStopped - Indicates if the recording is stopped.\n   * @param {boolean} options.parameters.isTimerRunning - Indicates if the timer is running.\n   * @param {boolean} options.parameters.canPauseResume - Indicates if the recording can be paused or resumed.\n   * @param {string} options.parameters.eventType - The type of event triggering the recording notice.\n   * @param {Function} options.parameters.updateRecordingProgressTime - Function to update the recording progress time.\n   * @param {Function} options.parameters.updateShowRecordButtons - Function to update the visibility of record buttons.\n   * @param {Function} options.parameters.updateUserRecordingParams - Function to update user recording parameters.\n   * @param {Function} options.parameters.updateRecordingMediaOptions - Function to update recording media options.\n   * @param {Function} options.parameters.updateRecordingAudioOptions - Function to update recording audio options.\n   * @param {Function} options.parameters.updateRecordingVideoOptions - Function to update recording video options.\n   * @param {Function} options.parameters.updateRecordingVideoType - Function to update recording video type.\n   * @param {Function} options.parameters.updateRecordingVideoOptimized - Function to update recording video optimization.\n   * @param {Function} options.parameters.updateRecordingDisplayType - Function to update recording display type.\n   * @param {Function} options.parameters.updateRecordingAddHLS - Function to update HLS addition in recording.\n   * @param {Function} options.parameters.updateRecordingNameTags - Function to update recording name tags.\n   * @param {Function} options.parameters.updateRecordingBackgroundColor - Function to update recording background color.\n   * @param {Function} options.parameters.updateRecordingNameTagsColor - Function to update recording name tags color.\n   * @param {Function} options.parameters.updateRecordingOrientationVideo - Function to update recording orientation video.\n   * @param {Function} options.parameters.updateRecordingAddText - Function to update recording text addition.\n   * @param {Function} options.parameters.updateRecordingCustomText - Function to update custom text in recording.\n   * @param {Function} options.parameters.updateRecordingCustomTextPosition - Function to update custom text position.\n   * @param {Function} options.parameters.updateRecordingCustomTextColor - Function to update custom text color.\n   * @param {Function} options.parameters.updatePauseRecordCount - Function to update pause record count.\n   * @param {Function} options.parameters.updateRecordElapsedTime - Function to update record elapsed time.\n   * @param {Function} options.parameters.updateRecordStartTime - Function to update record start time.\n   * @param {Function} options.parameters.updateRecordStarted - Function to update record started status.\n   * @param {Function} options.parameters.updateRecordPaused - Function to update record paused status.\n   * @param {Function} options.parameters.updateCanLaunchRecord - Function to update can launch record status.\n   * @param {Function} options.parameters.updateStopLaunchRecord - Function to update stop launch record status.\n   * @param {Function} options.parameters.updateRecordStopped - Function to update record stopped status.\n   * @param {Function} options.parameters.updateIsTimerRunning - Function to update timer running status.\n   * @param {Function} options.parameters.updateCanPauseResume - Function to update can pause/resume status.\n   * @param {Function} options.parameters.updateRecordState - Function to update the record state.\n   *\n   * @returns {Promise<void>} A promise that resolves when the recording notice handling is complete.\n   *\n   * @throws {Error} Throws an error if handling the recording state and status fails.\n   */\n  RecordingNotice = async ({\n    state,\n    userRecordingParam,\n    pauseCount,\n    timeDone,\n    parameters,\n  }: RecordingNoticeOptions): Promise<void> => {\n    let {\n      islevel,\n      userRecordingParams,\n      pauseRecordCount,\n      recordElapsedTime,\n      recordStartTime,\n      recordStarted,\n      recordPaused,\n      canLaunchRecord,\n      stopLaunchRecord,\n      recordStopped,\n      isTimerRunning,\n      canPauseResume,\n      eventType,\n\n      updateRecordingProgressTime,\n      updateShowRecordButtons,\n      updateUserRecordingParams,\n      updateRecordingMediaOptions,\n      updateRecordingAudioOptions,\n      updateRecordingVideoOptions,\n      updateRecordingVideoType,\n      updateRecordingVideoOptimized,\n      updateRecordingDisplayType,\n      updateRecordingAddHLS,\n      updateRecordingNameTags,\n      updateRecordingBackgroundColor,\n      updateRecordingNameTagsColor,\n      updateRecordingOrientationVideo,\n      updateRecordingAddText,\n      updateRecordingCustomText,\n      updateRecordingCustomTextPosition,\n      updateRecordingCustomTextColor,\n      updatePauseRecordCount,\n      updateRecordElapsedTime,\n      updateRecordStartTime,\n      updateRecordStarted,\n      updateRecordPaused,\n      updateCanLaunchRecord,\n      updateStopLaunchRecord,\n      updateRecordStopped,\n      updateIsTimerRunning,\n      updateCanPauseResume,\n      updateRecordState,\n    } = parameters;\n\n    try {\n      if (islevel !== '2') {\n        if (state === 'pause') {\n          updateRecordStarted(true);\n          updateRecordPaused(true);\n          updateRecordState('yellow');\n          eventType !== 'broadcast' &&\n            this.SoundPlayerService.playSound({\n              soundUrl: 'https://www.mediasfu.com/sounds/record-paused.mp3',\n            });\n        } else if (state === 'stop') {\n          updateRecordStarted(true);\n          updateRecordStopped(true);\n          updateRecordState('green');\n          eventType !== 'broadcast' &&\n            this.SoundPlayerService.playSound({\n              soundUrl: 'https://www.mediasfu.com/sounds/record-stopped.mp3',\n            });\n        } else {\n          updateRecordState('red');\n          updateRecordStarted(true);\n          updateRecordPaused(false);\n          eventType !== 'broadcast' &&\n            this.SoundPlayerService.playSound({\n              soundUrl: 'https://www.mediasfu.com/sounds/record-progress.mp3',\n            });\n        }\n      } else {\n        if (state === 'pause') {\n          updateRecordState('yellow');\n          if (userRecordingParam) {\n            userRecordingParams.mainSpecs = userRecordingParam.mainSpecs;\n            userRecordingParams.dispSpecs = userRecordingParam.dispSpecs;\n            userRecordingParams.textSpecs = userRecordingParam.textSpecs;\n\n            updateUserRecordingParams(userRecordingParams);\n            updateRecordingMediaOptions(userRecordingParams.mainSpecs.mediaOptions);\n            updateRecordingAudioOptions(userRecordingParams.mainSpecs.audioOptions);\n            updateRecordingVideoOptions(userRecordingParams.mainSpecs.videoOptions);\n            updateRecordingVideoType(userRecordingParams.mainSpecs.videoType);\n            updateRecordingVideoOptimized(userRecordingParams.mainSpecs.videoOptimized);\n            updateRecordingDisplayType(userRecordingParams.mainSpecs.recordingDisplayType);\n            updateRecordingAddHLS(userRecordingParams.mainSpecs.addHLS);\n            updateRecordingNameTags(userRecordingParams.dispSpecs.nameTags);\n            updateRecordingBackgroundColor(userRecordingParams.dispSpecs.backgroundColor);\n            updateRecordingNameTagsColor(userRecordingParams.dispSpecs.nameTagsColor);\n            updateRecordingOrientationVideo(userRecordingParams.dispSpecs.orientationVideo);\n            updateRecordingAddText(userRecordingParams.textSpecs?.addText ?? false);\n            updateRecordingCustomText(userRecordingParams.textSpecs?.customText ?? '');\n            updateRecordingCustomTextPosition(\n              userRecordingParams.textSpecs?.customTextPosition ?? '',\n            );\n            updateRecordingCustomTextColor(userRecordingParams.textSpecs?.customTextColor ?? '');\n\n            pauseRecordCount = pauseCount;\n            updatePauseRecordCount(pauseRecordCount);\n\n            recordElapsedTime = timeDone;\n            recordElapsedTime = Math.floor(recordElapsedTime / 1000);\n            recordStartTime = Math.floor(Date.now() / 1000) - recordElapsedTime;\n            updateRecordStartTime(recordStartTime);\n            updateRecordElapsedTime(recordElapsedTime);\n\n            recordStarted = true;\n            recordPaused = true;\n            canLaunchRecord = false;\n            recordStopped = false;\n\n            updateRecordStarted(recordStarted);\n            updateRecordPaused(recordPaused);\n            updateCanLaunchRecord(canLaunchRecord);\n            updateRecordStopped(recordStopped);\n            updateShowRecordButtons(true);\n\n            isTimerRunning = false;\n            canPauseResume = true;\n\n            updateIsTimerRunning(isTimerRunning);\n            updateCanPauseResume(canPauseResume);\n\n            const formattedTime = this.formatElapsedTime(recordElapsedTime);\n            updateRecordingProgressTime(formattedTime);\n          }\n          this.SoundPlayerService.playSound({\n            soundUrl: 'https://www.mediasfu.com/sounds/record-paused.mp3',\n          });\n        } else if (state === 'stop') {\n          updateRecordStarted(true);\n          updateRecordStopped(true);\n          canLaunchRecord = false;\n          stopLaunchRecord = true;\n\n          updateRecordStarted(recordStarted);\n          updateRecordStopped(recordStopped);\n          updateCanLaunchRecord(canLaunchRecord);\n          updateStopLaunchRecord(stopLaunchRecord);\n          updateShowRecordButtons(false);\n\n          updateRecordState('green');\n          this.SoundPlayerService.playSound({\n            soundUrl: 'https://www.mediasfu.com/sounds/record-stopped.mp3',\n          });\n        } else {\n          updateRecordState('red');\n          updateRecordStarted(true);\n          updateRecordPaused(false);\n          this.SoundPlayerService.playSound({\n            soundUrl: 'https://www.mediasfu.com/sounds/record-progress.mp3',\n          });\n        }\n      }\n    } catch (error) {\n      console.log('Error in RecordingNotice: ', error);\n      // throw new Error(\"Failed to handle recording state and status.\");\n    }\n  };\n\n  private formatElapsedTime = (recordElapsedTime: number): string => {\n    const hours = Math.floor(recordElapsedTime / 3600);\n    const minutes = Math.floor((recordElapsedTime % 3600) / 60);\n    const seconds = recordElapsedTime % 60;\n\n    return `${this.padNumber(hours)}:${this.padNumber(minutes)}:${this.padNumber(seconds)}`;\n  };\n\n  private padNumber = (number: number): string => {\n    return number.toString().padStart(2, '0');\n  };\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/room-record-params.service.mjs

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class RoomRecordParams {
+    /**
+     * Updates various recording parameters based on the provided `recordParams`.
+     *
+     * @param {Object} params - The parameters object.
+     * @param {RecordParams} params.recordParams - The recording parameters to update.
+     * @param {Parameters} params.parameters - The functions to update each recording parameter.
+     * @param {Function} params.parameters.updateRecordingAudioPausesLimit - Function to update the audio pauses limit.
+     * @param {Function} params.parameters.updateRecordingAudioPausesCount - Function to update the audio pauses count.
+     * @param {Function} params.parameters.updateRecordingAudioSupport - Function to update the audio support.
+     * @param {Function} params.parameters.updateRecordingAudioPeopleLimit - Function to update the audio people limit.
+     * @param {Function} params.parameters.updateRecordingAudioParticipantsTimeLimit - Function to update the audio participants time limit.
+     * @param {Function} params.parameters.updateRecordingVideoPausesCount - Function to update the video pauses count.
+     * @param {Function} params.parameters.updateRecordingVideoPausesLimit - Function to update the video pauses limit.
+     * @param {Function} params.parameters.updateRecordingVideoSupport - Function to update the video support.
+     * @param {Function} params.parameters.updateRecordingVideoPeopleLimit - Function to update the video people limit.
+     * @param {Function} params.parameters.updateRecordingVideoParticipantsTimeLimit - Function to update the video participants time limit.
+     * @param {Function} params.parameters.updateRecordingAllParticipantsSupport - Function to update the all participants support.
+     * @param {Function} params.parameters.updateRecordingVideoParticipantsSupport - Function to update the video participants support.
+     * @param {Function} params.parameters.updateRecordingAllParticipantsFullRoomSupport - Function to update the all participants full room support.
+     * @param {Function} params.parameters.updateRecordingVideoParticipantsFullRoomSupport - Function to update the video participants full room support.
+     * @param {Function} params.parameters.updateRecordingPreferredOrientation - Function to update the preferred orientation.
+     * @param {Function} params.parameters.updateRecordingSupportForOtherOrientation - Function to update the support for other orientation.
+     * @param {Function} params.parameters.updateRecordingMultiFormatsSupport - Function to update the multi-formats support.
+     * @returns {Promise<void>} A promise that resolves when all parameters have been updated.
+     */
+    roomRecordParams = ({ recordParams, parameters }) => {
+        let { updateRecordingAudioPausesLimit, updateRecordingAudioPausesCount, updateRecordingAudioSupport, updateRecordingAudioPeopleLimit, updateRecordingAudioParticipantsTimeLimit, updateRecordingVideoPausesCount, updateRecordingVideoPausesLimit, updateRecordingVideoSupport, updateRecordingVideoPeopleLimit, updateRecordingVideoParticipantsTimeLimit, updateRecordingAllParticipantsSupport, updateRecordingVideoParticipantsSupport, updateRecordingAllParticipantsFullRoomSupport, updateRecordingVideoParticipantsFullRoomSupport, updateRecordingPreferredOrientation, updateRecordingSupportForOtherOrientation, updateRecordingMultiFormatsSupport, } = parameters;
+        // Update each recording parameter based on the provided recordParams
+        updateRecordingAudioPausesLimit(recordParams.recordingAudioPausesLimit);
+        updateRecordingAudioPausesCount(recordParams.recordingAudioPausesCount);
+        updateRecordingAudioSupport(recordParams.recordingAudioSupport);
+        updateRecordingAudioPeopleLimit(recordParams.recordingAudioPeopleLimit);
+        updateRecordingAudioParticipantsTimeLimit(recordParams.recordingAudioParticipantsTimeLimit);
+        updateRecordingVideoPausesCount(recordParams.recordingVideoPausesCount);
+        updateRecordingVideoPausesLimit(recordParams.recordingVideoPausesLimit);
+        updateRecordingVideoSupport(recordParams.recordingVideoSupport);
+        updateRecordingVideoPeopleLimit(recordParams.recordingVideoPeopleLimit);
+        updateRecordingVideoParticipantsTimeLimit(recordParams.recordingVideoParticipantsTimeLimit);
+        updateRecordingAllParticipantsSupport(recordParams.recordingAllParticipantsSupport);
+        updateRecordingVideoParticipantsSupport(recordParams.recordingVideoParticipantsSupport);
+        updateRecordingAllParticipantsFullRoomSupport(recordParams.recordingAllParticipantsFullRoomSupport);
+        updateRecordingVideoParticipantsFullRoomSupport(recordParams.recordingVideoParticipantsFullRoomSupport);
+        updateRecordingPreferredOrientation(recordParams.recordingPreferredOrientation);
+        updateRecordingSupportForOtherOrientation(recordParams.recordingSupportForOtherOrientation);
+        updateRecordingMultiFormatsSupport(recordParams.recordingMultiFormatsSupport);
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RoomRecordParams, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RoomRecordParams, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: RoomRecordParams, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"room-record-params.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/room-record-params.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyD3C,MAAM,OAAO,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,gBAAgB,GAAG,CAAC,EAAE,YAAY,EAAE,UAAU,EAA2B,EAAQ,EAAE;QACjF,IAAI,EACF,+BAA+B,EAC/B,+BAA+B,EAC/B,2BAA2B,EAC3B,+BAA+B,EAC/B,yCAAyC,EACzC,+BAA+B,EAC/B,+BAA+B,EAC/B,2BAA2B,EAC3B,+BAA+B,EAC/B,yCAAyC,EACzC,qCAAqC,EACrC,uCAAuC,EACvC,6CAA6C,EAC7C,+CAA+C,EAC/C,mCAAmC,EACnC,yCAAyC,EACzC,kCAAkC,GACnC,GAAG,UAAU,CAAC;QAEf,qEAAqE;QACrE,+BAA+B,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;QACxE,+BAA+B,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;QACxE,2BAA2B,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAChE,+BAA+B,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;QACxE,yCAAyC,CAAC,YAAY,CAAC,mCAAmC,CAAC,CAAC;QAC5F,+BAA+B,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;QACxE,+BAA+B,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;QACxE,2BAA2B,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;QAChE,+BAA+B,CAAC,YAAY,CAAC,yBAAyB,CAAC,CAAC;QACxE,yCAAyC,CAAC,YAAY,CAAC,mCAAmC,CAAC,CAAC;QAC5F,qCAAqC,CAAC,YAAY,CAAC,+BAA+B,CAAC,CAAC;QACpF,uCAAuC,CAAC,YAAY,CAAC,iCAAiC,CAAC,CAAC;QACxF,6CAA6C,CAC3C,YAAY,CAAC,uCAAuC,CACrD,CAAC;QACF,+CAA+C,CAC7C,YAAY,CAAC,yCAAyC,CACvD,CAAC;QACF,mCAAmC,CAAC,YAAY,CAAC,6BAA6B,CAAC,CAAC;QAChF,yCAAyC,CAAC,YAAY,CAAC,mCAAmC,CAAC,CAAC;QAC5F,kCAAkC,CAAC,YAAY,CAAC,4BAA4B,CAAC,CAAC;IAChF,CAAC,CAAC;uGArES,gBAAgB;2GAAhB,gBAAgB,cAFf,MAAM;;2FAEP,gBAAgB;kBAH5B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nexport interface RecordParams {\n  recordingAudioPausesLimit: number;\n  recordingAudioPausesCount: number;\n  recordingAudioSupport: boolean;\n  recordingAudioPeopleLimit: number;\n  recordingAudioParticipantsTimeLimit: number;\n  recordingVideoPausesCount: number;\n  recordingVideoPausesLimit: number;\n  recordingVideoSupport: boolean;\n  recordingVideoPeopleLimit: number;\n  recordingVideoParticipantsTimeLimit: number;\n  recordingAllParticipantsSupport: boolean;\n  recordingVideoParticipantsSupport: boolean;\n  recordingAllParticipantsFullRoomSupport: boolean;\n  recordingVideoParticipantsFullRoomSupport: boolean;\n  recordingPreferredOrientation: string;\n  recordingSupportForOtherOrientation: boolean;\n  recordingMultiFormatsSupport: boolean;\n}\n\nexport interface RoomRecordParamsParameters {\n  updateRecordingAudioPausesLimit: (value: number) => void;\n  updateRecordingAudioPausesCount: (value: number) => void;\n  updateRecordingAudioSupport: (value: boolean) => void;\n  updateRecordingAudioPeopleLimit: (value: number) => void;\n  updateRecordingAudioParticipantsTimeLimit: (value: number) => void;\n  updateRecordingVideoPausesCount: (value: number) => void;\n  updateRecordingVideoPausesLimit: (value: number) => void;\n  updateRecordingVideoSupport: (value: boolean) => void;\n  updateRecordingVideoPeopleLimit: (value: number) => void;\n  updateRecordingVideoParticipantsTimeLimit: (value: number) => void;\n  updateRecordingAllParticipantsSupport: (value: boolean) => void;\n  updateRecordingVideoParticipantsSupport: (value: boolean) => void;\n  updateRecordingAllParticipantsFullRoomSupport: (value: boolean) => void;\n  updateRecordingVideoParticipantsFullRoomSupport: (value: boolean) => void;\n  updateRecordingPreferredOrientation: (value: string) => void;\n  updateRecordingSupportForOtherOrientation: (value: boolean) => void;\n  updateRecordingMultiFormatsSupport: (value: boolean) => void;\n\n  // mediasfu functions\n  [key: string]: any;\n}\nexport interface RoomRecordParamsOptions {\n  recordParams: RecordParams;\n  parameters: RoomRecordParamsParameters;\n}\n\n// Export the type definition for the function\nexport type RoomRecordParamsType = ({\n  recordParams,\n  parameters,\n}: RoomRecordParamsOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class RoomRecordParams {\n  /**\n   * Updates various recording parameters based on the provided `recordParams`.\n   *\n   * @param {Object} params - The parameters object.\n   * @param {RecordParams} params.recordParams - The recording parameters to update.\n   * @param {Parameters} params.parameters - The functions to update each recording parameter.\n   * @param {Function} params.parameters.updateRecordingAudioPausesLimit - Function to update the audio pauses limit.\n   * @param {Function} params.parameters.updateRecordingAudioPausesCount - Function to update the audio pauses count.\n   * @param {Function} params.parameters.updateRecordingAudioSupport - Function to update the audio support.\n   * @param {Function} params.parameters.updateRecordingAudioPeopleLimit - Function to update the audio people limit.\n   * @param {Function} params.parameters.updateRecordingAudioParticipantsTimeLimit - Function to update the audio participants time limit.\n   * @param {Function} params.parameters.updateRecordingVideoPausesCount - Function to update the video pauses count.\n   * @param {Function} params.parameters.updateRecordingVideoPausesLimit - Function to update the video pauses limit.\n   * @param {Function} params.parameters.updateRecordingVideoSupport - Function to update the video support.\n   * @param {Function} params.parameters.updateRecordingVideoPeopleLimit - Function to update the video people limit.\n   * @param {Function} params.parameters.updateRecordingVideoParticipantsTimeLimit - Function to update the video participants time limit.\n   * @param {Function} params.parameters.updateRecordingAllParticipantsSupport - Function to update the all participants support.\n   * @param {Function} params.parameters.updateRecordingVideoParticipantsSupport - Function to update the video participants support.\n   * @param {Function} params.parameters.updateRecordingAllParticipantsFullRoomSupport - Function to update the all participants full room support.\n   * @param {Function} params.parameters.updateRecordingVideoParticipantsFullRoomSupport - Function to update the video participants full room support.\n   * @param {Function} params.parameters.updateRecordingPreferredOrientation - Function to update the preferred orientation.\n   * @param {Function} params.parameters.updateRecordingSupportForOtherOrientation - Function to update the support for other orientation.\n   * @param {Function} params.parameters.updateRecordingMultiFormatsSupport - Function to update the multi-formats support.\n   * @returns {Promise<void>} A promise that resolves when all parameters have been updated.\n   */\n  roomRecordParams = ({ recordParams, parameters }: RoomRecordParamsOptions): void => {\n    let {\n      updateRecordingAudioPausesLimit,\n      updateRecordingAudioPausesCount,\n      updateRecordingAudioSupport,\n      updateRecordingAudioPeopleLimit,\n      updateRecordingAudioParticipantsTimeLimit,\n      updateRecordingVideoPausesCount,\n      updateRecordingVideoPausesLimit,\n      updateRecordingVideoSupport,\n      updateRecordingVideoPeopleLimit,\n      updateRecordingVideoParticipantsTimeLimit,\n      updateRecordingAllParticipantsSupport,\n      updateRecordingVideoParticipantsSupport,\n      updateRecordingAllParticipantsFullRoomSupport,\n      updateRecordingVideoParticipantsFullRoomSupport,\n      updateRecordingPreferredOrientation,\n      updateRecordingSupportForOtherOrientation,\n      updateRecordingMultiFormatsSupport,\n    } = parameters;\n\n    // Update each recording parameter based on the provided recordParams\n    updateRecordingAudioPausesLimit(recordParams.recordingAudioPausesLimit);\n    updateRecordingAudioPausesCount(recordParams.recordingAudioPausesCount);\n    updateRecordingAudioSupport(recordParams.recordingAudioSupport);\n    updateRecordingAudioPeopleLimit(recordParams.recordingAudioPeopleLimit);\n    updateRecordingAudioParticipantsTimeLimit(recordParams.recordingAudioParticipantsTimeLimit);\n    updateRecordingVideoPausesCount(recordParams.recordingVideoPausesCount);\n    updateRecordingVideoPausesLimit(recordParams.recordingVideoPausesLimit);\n    updateRecordingVideoSupport(recordParams.recordingVideoSupport);\n    updateRecordingVideoPeopleLimit(recordParams.recordingVideoPeopleLimit);\n    updateRecordingVideoParticipantsTimeLimit(recordParams.recordingVideoParticipantsTimeLimit);\n    updateRecordingAllParticipantsSupport(recordParams.recordingAllParticipantsSupport);\n    updateRecordingVideoParticipantsSupport(recordParams.recordingVideoParticipantsSupport);\n    updateRecordingAllParticipantsFullRoomSupport(\n      recordParams.recordingAllParticipantsFullRoomSupport,\n    );\n    updateRecordingVideoParticipantsFullRoomSupport(\n      recordParams.recordingVideoParticipantsFullRoomSupport,\n    );\n    updateRecordingPreferredOrientation(recordParams.recordingPreferredOrientation);\n    updateRecordingSupportForOtherOrientation(recordParams.recordingSupportForOtherOrientation);\n    updateRecordingMultiFormatsSupport(recordParams.recordingMultiFormatsSupport);\n  };\n}\n"]}