mediasfu-angular 1.0.0

package/dist/esm2022/lib/producers/producer-emits/join-con-room.service.mjs

@@ -0,0 +1,114 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../methods/utils/validate-alphanumeric.service";
+export class JoinConRoom {
+    validateAlphanumeric;
+    constructor(validateAlphanumeric) {
+        this.validateAlphanumeric = validateAlphanumeric;
+    }
+    /**
+     * Joins a conference room using the provided options.
+     *
+     * @param {JoinConRoomOptions} options - The options for joining the conference room.
+     * @param {Socket} options.socket - The socket instance to use for communication.
+     * @param {string} options.roomName - The name of the room to join.
+     * @param {string} options.islevel - The level of the user.
+     * @param {string} options.member - The member identifier.
+     * @param {string} options.sec - The security token.
+     * @param {string} options.apiUserName - The API username.
+     * @returns {Promise<JoinConRoomResponse>} A promise that resolves with the response of the join operation.
+     *
+     * @throws {Error} If any of the required parameters are missing or invalid.
+     * @throws {Error} If the user is banned, suspended, or if the host has not joined the room yet.
+     */
+    async joinConRoom({ socket, roomName, islevel, member, sec, apiUserName, }) {
+        return new Promise((resolve, reject) => {
+            // Validate inputs
+            if (!(sec && roomName && islevel && apiUserName && member)) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Missing required parameters',
+                };
+                reject(validationError);
+                return;
+            }
+            // Validate alphanumeric for roomName, apiUserName, and member
+            try {
+                this.validateAlphanumeric.validateAlphanumeric({ str: roomName });
+                this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });
+                this.validateAlphanumeric.validateAlphanumeric({ str: member });
+            }
+            catch (error) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Invalid roomName or apiUserName or member',
+                };
+                reject(validationError);
+                return;
+            }
+            // Validate roomName starts with 's' or 'p'
+            if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Invalid roomName, must start with s or p',
+                };
+                reject(validationError);
+                return;
+            }
+            // Validate other conditions for sec, roomName, islevel, apiUserName
+            if (!(sec.length === 64 &&
+                roomName.length >= 8 &&
+                islevel.length === 1 &&
+                apiUserName.length >= 6 &&
+                (islevel === '0' || islevel === '1' || islevel === '2'))) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Invalid roomName or islevel or apiUserName or secret',
+                };
+                reject(validationError);
+                return;
+            }
+            socket.emit('joinConRoom', { roomName, islevel, member, sec, apiUserName }, async (data) => {
+                try {
+                    // Check if rtpCapabilities is null
+                    if (data.rtpCapabilities === null) {
+                        // Check if banned, suspended, or noAdmin
+                        if (data.banned) {
+                            throw new Error('User is banned.');
+                        }
+                        if (data.suspended) {
+                            throw new Error('User is suspended.');
+                        }
+                        if (data.noAdmin) {
+                            throw new Error('Host has not joined the room yet.');
+                        }
+                        // Resolve with the data received from the 'joinConRoom' event
+                        resolve(data);
+                    }
+                    else {
+                        // Resolve with the data received from the 'joinConRoom' event
+                        resolve(data);
+                    }
+                }
+                catch (error) {
+                    // Handle errors during the joinConRoom process
+                    console.log('Error joining room:', error);
+                    reject(error);
+                }
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: JoinConRoom, deps: [{ token: i1.ValidateAlphanumeric }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: JoinConRoom, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: JoinConRoom, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ValidateAlphanumeric }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-con-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/producer-emits/join-con-room.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';\nimport { RtpCapabilities } from 'mediasoup-client/lib/types';\n\nexport interface JoinConRoomOptions {\n  socket: Socket;\n  roomName: string;\n  islevel: string;\n  member: string;\n  sec: string;\n  apiUserName: string;\n}\n\nexport interface JoinConRoomResponse {\n  success: boolean;\n  rtpCapabilities: RtpCapabilities | null;\n  reason?: string;\n  banned?: boolean;\n  suspended?: boolean;\n  noAdmin?: boolean;\n  [key: string]: any;\n}\n\n// Export the type definition for the function\nexport type JoinConRoomType = (options: JoinConRoomOptions) => Promise<JoinConRoomResponse>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinConRoom {\n  constructor(private validateAlphanumeric: ValidateAlphanumeric) {}\n\n  /**\n   * Joins a conference room using the provided options.\n   *\n   * @param {JoinConRoomOptions} options - The options for joining the conference room.\n   * @param {Socket} options.socket - The socket instance to use for communication.\n   * @param {string} options.roomName - The name of the room to join.\n   * @param {string} options.islevel - The level of the user.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.sec - The security token.\n   * @param {string} options.apiUserName - The API username.\n   * @returns {Promise<JoinConRoomResponse>} A promise that resolves with the response of the join operation.\n   *\n   * @throws {Error} If any of the required parameters are missing or invalid.\n   * @throws {Error} If the user is banned, suspended, or if the host has not joined the room yet.\n   */\n  async joinConRoom({\n    socket,\n    roomName,\n    islevel,\n    member,\n    sec,\n    apiUserName,\n  }: JoinConRoomOptions): Promise<object> {\n    return new Promise((resolve, reject) => {\n      // Validate inputs\n      if (!(sec && roomName && islevel && apiUserName && member)) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Missing required parameters',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate alphanumeric for roomName, apiUserName, and member\n      try {\n        this.validateAlphanumeric.validateAlphanumeric({ str: roomName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: member });\n      } catch (error) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or apiUserName or member',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate roomName starts with 's' or 'p'\n      if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName, must start with s or p',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate other conditions for sec, roomName, islevel, apiUserName\n      if (\n        !(\n          sec.length === 64 &&\n          roomName.length >= 8 &&\n          islevel.length === 1 &&\n          apiUserName.length >= 6 &&\n          (islevel === '0' || islevel === '1' || islevel === '2')\n        )\n      ) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or islevel or apiUserName or secret',\n        };\n        reject(validationError);\n        return;\n      }\n\n      socket.emit(\n        'joinConRoom',\n        { roomName, islevel, member, sec, apiUserName },\n        async (data: any) => {\n          try {\n            // Check if rtpCapabilities is null\n            if (data.rtpCapabilities === null) {\n              // Check if banned, suspended, or noAdmin\n              if (data.banned) {\n                throw new Error('User is banned.');\n              }\n              if (data.suspended) {\n                throw new Error('User is suspended.');\n              }\n              if (data.noAdmin) {\n                throw new Error('Host has not joined the room yet.');\n              }\n\n              // Resolve with the data received from the 'joinConRoom' event\n              resolve(data);\n            } else {\n              // Resolve with the data received from the 'joinConRoom' event\n              resolve(data);\n            }\n          } catch (error) {\n            // Handle errors during the joinConRoom process\n            console.log('Error joining room:', error);\n            reject(error);\n          }\n        },\n      );\n    });\n  }\n}\n"]}

package/dist/esm2022/lib/producers/producer-emits/join-room.service.mjs

@@ -0,0 +1,114 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../methods/utils/validate-alphanumeric.service";
+export class JoinRoom {
+    validateAlphanumeric;
+    constructor(validateAlphanumeric) {
+        this.validateAlphanumeric = validateAlphanumeric;
+    }
+    /**
+     * Joins a user to a specified room via a socket connection.
+     *
+     * @param {Object} options - The options for joining the room.
+     * @param {Socket} options.socket - The socket instance to use for communication.
+     * @param {string} options.roomName - The name of the room to join.
+     * @param {string} options.islevel - The level of the user.
+     * @param {string} options.member - The member identifier.
+     * @param {string} options.sec - The security token.
+     * @param {string} options.apiUserName - The API username of the user.
+     *
+     * @returns {Promise<object>} A promise that resolves with the data received from the 'joinRoom' event or rejects with a validation error.
+     *
+     * @throws {Error} Throws an error if the user is banned, suspended, or if the host has not joined the room yet.
+     */
+    async joinRoom({ socket, roomName, islevel, member, sec, apiUserName, }) {
+        return new Promise((resolve, reject) => {
+            // Validate inputs
+            if (!(sec && roomName && islevel && apiUserName && member)) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Missing required parameters',
+                };
+                reject(validationError);
+                return;
+            }
+            // Validate alphanumeric for roomName, apiUserName, and member
+            try {
+                this.validateAlphanumeric.validateAlphanumeric({ str: roomName });
+                this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });
+                this.validateAlphanumeric.validateAlphanumeric({ str: member });
+            }
+            catch (error) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Invalid roomName or apiUserName or member',
+                };
+                reject(validationError);
+                return;
+            }
+            // Validate roomName starts with 's' or 'p'
+            if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Invalid roomName, must start with s or p',
+                };
+                reject(validationError);
+                return;
+            }
+            // Validate other conditions for sec, roomName, islevel, apiUserName
+            if (!(sec.length === 64 &&
+                roomName.length >= 8 &&
+                islevel.length === 1 &&
+                apiUserName.length >= 6 &&
+                (islevel === '0' || islevel === '1' || islevel === '2'))) {
+                const validationError = {
+                    success: false,
+                    rtpCapabilities: null,
+                    reason: 'Invalid roomName or islevel or apiUserName or secret',
+                };
+                reject(validationError);
+                return;
+            }
+            socket.emit('joinRoom', { roomName, islevel, member, sec, apiUserName }, async (data) => {
+                try {
+                    // Check if rtpCapabilities is null
+                    if (data.rtpCapabilities === null) {
+                        // Check if banned, suspended, or noAdmin
+                        if (data.banned) {
+                            throw new Error('User is banned.');
+                        }
+                        if (data.suspended) {
+                            throw new Error('User is suspended.');
+                        }
+                        if (data.noAdmin) {
+                            throw new Error('Host has not joined the room yet.');
+                        }
+                        // Resolve with the data received from the 'joinRoom' event
+                        resolve(data);
+                    }
+                    else {
+                        // Resolve with the data received from the 'joinRoom' event
+                        resolve(data);
+                    }
+                }
+                catch (error) {
+                    // Handle errors during the joinRoom process
+                    console.log('Error joining room:', error);
+                    reject(error);
+                }
+            });
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: JoinRoom, deps: [{ token: i1.ValidateAlphanumeric }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: JoinRoom, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: JoinRoom, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.ValidateAlphanumeric }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"join-room.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/producer-emits/join-room.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport { ValidateAlphanumeric } from '../../methods/utils/validate-alphanumeric.service';\n\nexport interface JoinRoomOptions {\n  socket: Socket;\n  roomName: string;\n  islevel: string;\n  member: string;\n  sec: string;\n  apiUserName: string;\n}\n\n// Export the type definition for the function\nexport type JoinRoomType = (\n  socket: Socket,\n  roomName: string,\n  islevel: string,\n  member: string,\n  sec: string,\n  apiUserName: string,\n) => Promise<object>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class JoinRoom {\n  constructor(private validateAlphanumeric: ValidateAlphanumeric) {}\n\n  /**\n   * Joins a user to a specified room via a socket connection.\n   *\n   * @param {Object} options - The options for joining the room.\n   * @param {Socket} options.socket - The socket instance to use for communication.\n   * @param {string} options.roomName - The name of the room to join.\n   * @param {string} options.islevel - The level of the user.\n   * @param {string} options.member - The member identifier.\n   * @param {string} options.sec - The security token.\n   * @param {string} options.apiUserName - The API username of the user.\n   *\n   * @returns {Promise<object>} A promise that resolves with the data received from the 'joinRoom' event or rejects with a validation error.\n   *\n   * @throws {Error} Throws an error if the user is banned, suspended, or if the host has not joined the room yet.\n   */\n  async joinRoom({\n    socket,\n    roomName,\n    islevel,\n    member,\n    sec,\n    apiUserName,\n  }: JoinRoomOptions): Promise<object> {\n    return new Promise((resolve, reject) => {\n      // Validate inputs\n      if (!(sec && roomName && islevel && apiUserName && member)) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Missing required parameters',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate alphanumeric for roomName, apiUserName, and member\n      try {\n        this.validateAlphanumeric.validateAlphanumeric({ str: roomName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: apiUserName });\n        this.validateAlphanumeric.validateAlphanumeric({ str: member });\n      } catch (error) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or apiUserName or member',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate roomName starts with 's' or 'p'\n      if (!(roomName.startsWith('s') || roomName.startsWith('p'))) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName, must start with s or p',\n        };\n        reject(validationError);\n        return;\n      }\n\n      // Validate other conditions for sec, roomName, islevel, apiUserName\n      if (\n        !(\n          sec.length === 64 &&\n          roomName.length >= 8 &&\n          islevel.length === 1 &&\n          apiUserName.length >= 6 &&\n          (islevel === '0' || islevel === '1' || islevel === '2')\n        )\n      ) {\n        const validationError = {\n          success: false,\n          rtpCapabilities: null,\n          reason: 'Invalid roomName or islevel or apiUserName or secret',\n        };\n        reject(validationError);\n        return;\n      }\n\n      socket.emit(\n        'joinRoom',\n        { roomName, islevel, member, sec, apiUserName },\n        async (data: any) => {\n          try {\n            // Check if rtpCapabilities is null\n            if (data.rtpCapabilities === null) {\n              // Check if banned, suspended, or noAdmin\n              if (data.banned) {\n                throw new Error('User is banned.');\n              }\n              if (data.suspended) {\n                throw new Error('User is suspended.');\n              }\n              if (data.noAdmin) {\n                throw new Error('Host has not joined the room yet.');\n              }\n\n              // Resolve with the data received from the 'joinRoom' event\n              resolve(data);\n            } else {\n              // Resolve with the data received from the 'joinRoom' event\n              resolve(data);\n            }\n          } catch (error) {\n            // Handle errors during the joinRoom process\n            console.log('Error joining room:', error);\n            reject(error);\n          }\n        },\n      );\n    });\n  }\n}\n"]}

package/dist/esm2022/lib/producers/socket-receive-methods/all-members-rest.service.mjs

@@ -0,0 +1,155 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AllMembersRest {
+    /**
+     * Handles various tasks related to participant management and UI updates.
+     * @param {Object} params - The parameters passed to the allMembersRest method.
+     * @param {Array} params.members - The array of participant members.
+     * @param {Array} params.settings - The array of settings.
+     * @param {boolean} params.coHoste - The co-host state.
+     * @param {boolean} params.coHostRes - The co-host responsibility state.
+     * @param {Object} params.parameters - The object containing parameters for the allMembersRest method.
+     * @param {Array} params.consume_sockets - The array of consume sockets.
+     * @param {string} params.apiUserName - The API username.
+     * @param {string} params.apiKey - The API key.
+     * @param {string} params.apiToken - The API token.
+     * @returns {void} - No return value.
+     */
+    async allMembersRest({ members, settings, coHoste, coHostRes, parameters, consume_sockets, apiUserName, apiKey, apiToken, }) {
+        let { participantsAll, participants, dispActiveNames, requestList, coHost, coHostResponsibility, lock_screen, firstAll, membersReceived, roomRecvIPs, deferScreenReceived, screenId, shareScreenStarted, meetingDisplayType, audioSetting, videoSetting, screenshareSetting, chatSetting, updateParticipantsAll, updateParticipants, updateRequestList, updateCoHost, updateCoHostResponsibility, updateFirstAll, updateMembersReceived, updateDeferScreenReceived, updateShareScreenStarted, updateAudioSetting, updateVideoSetting, updateScreenshareSetting, updateChatSetting, updateConsume_sockets, updateRoomRecvIPs, updateIsLoadingModalVisible, onScreenChanges, connectIps, reorderStreams, sleep, } = parameters;
+        // Filter out the participant that isBanned == true or isSuspended == true
+        participantsAll = members.map((participant) => ({
+            isBanned: participant.isBanned,
+            isSuspended: participant.isSuspended,
+            name: participant.name,
+            audioID: participant.audioID,
+            videoID: participant.videoID,
+        }));
+        updateParticipantsAll(participantsAll);
+        participants = members.filter((participant) => !participant.isBanned && !participant.isSuspended);
+        updateParticipants(participants);
+        // Check if dispActiveNames is not empty and contains the name of the participant that is not in the participants array
+        if (dispActiveNames.length > 0) {
+            let dispActiveNames_ = dispActiveNames.filter((name) => !participants.map((participant) => participant.name).includes(name));
+            if (dispActiveNames_.length > 0 && membersReceived) {
+                await reorderStreams({ add: false, screenChanged: true, parameters });
+            }
+        }
+        // Operations to update the UI; make sure we are connected to the server before updating the UI
+        if (!membersReceived) {
+            if (roomRecvIPs.length < 1) {
+                // Keep checking every 0.01s
+                let checkIPs = setInterval(async () => {
+                    if (roomRecvIPs.length > 0) {
+                        clearInterval(checkIPs);
+                        if (deferScreenReceived && screenId != null) {
+                            shareScreenStarted = true;
+                            updateShareScreenStarted(shareScreenStarted);
+                        }
+                        const [sockets_, ips_] = await connectIps({
+                            consume_sockets,
+                            remIP: roomRecvIPs,
+                            parameters,
+                            apiUserName,
+                            apiKey,
+                            apiToken,
+                        });
+                        if (sockets_ && ips_) {
+                            updateConsume_sockets(sockets_);
+                            updateRoomRecvIPs(ips_);
+                        }
+                        membersReceived = true;
+                        updateMembersReceived(membersReceived);
+                        await sleep({ ms: 250 });
+                        updateIsLoadingModalVisible(false);
+                        deferScreenReceived = false;
+                        updateDeferScreenReceived(deferScreenReceived);
+                    }
+                }, 10);
+            }
+            else {
+                const [sockets_, ips_] = await connectIps({
+                    consume_sockets,
+                    remIP: roomRecvIPs,
+                    parameters,
+                    apiUserName,
+                    apiKey,
+                    apiToken,
+                });
+                if (sockets_ && ips_) {
+                    updateConsume_sockets(sockets_);
+                    updateRoomRecvIPs(ips_);
+                }
+                membersReceived = true;
+                updateMembersReceived(membersReceived);
+                if (deferScreenReceived && screenId != null) {
+                    shareScreenStarted = true;
+                    updateShareScreenStarted(shareScreenStarted);
+                }
+                await sleep({ ms: 250 });
+                updateIsLoadingModalVisible(false);
+                deferScreenReceived = false;
+                updateDeferScreenReceived(deferScreenReceived);
+            }
+        }
+        else {
+            if (screenId != null) {
+                let host = participants.find((participant) => participant.ScreenID == screenId && participant.ScreenOn == true);
+                if (deferScreenReceived && screenId != null && host) {
+                    shareScreenStarted = true;
+                    updateShareScreenStarted(shareScreenStarted);
+                }
+            }
+        }
+        // Return requests for only ids that are in the participants array and update the count badge
+        let requests = requestList;
+        requestList = requests.filter((request) => participants.some((participant) => participant.id == request.id));
+        updateRequestList(requestList);
+        if (coHoste !== undefined && coHoste !== null) {
+            coHost = coHoste;
+        }
+        if (coHost !== undefined && coHost !== null) {
+            updateCoHost(coHost);
+        }
+        if (coHostRes !== undefined && coHostRes !== null) {
+            coHostResponsibility = coHostRes;
+        }
+        updateCoHostResponsibility(coHostResponsibility);
+        try {
+            if (!lock_screen && !firstAll) {
+                await onScreenChanges({ parameters });
+                if (meetingDisplayType != 'all') {
+                    firstAll = true;
+                    updateFirstAll(firstAll);
+                }
+            }
+        }
+        catch (error) {
+            console.log('allMembersRest OnScreen', error);
+        }
+        try {
+            if (membersReceived) {
+                audioSetting = settings[0];
+                videoSetting = settings[1];
+                screenshareSetting = settings[2];
+                chatSetting = settings[3];
+                updateAudioSetting(audioSetting);
+                updateVideoSetting(videoSetting);
+                updateScreenshareSetting(screenshareSetting);
+                updateChatSetting(chatSetting);
+            }
+        }
+        catch (error) {
+            console.log('allMembersRest Settings', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllMembersRest, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllMembersRest, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: AllMembersRest, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"all-members-rest.service.js","sourceRoot":"","sources":["../../../../../../projects/mediasfu-angular/src/lib/producers/socket-receive-methods/all-members-rest.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport {\n  Participant,\n  CoHostResponsibility,\n  OnScreenChangesType,\n  OnScreenChangesParameters,\n  Request,\n  ConnectIpsParameters,\n  ReorderStreamsParameters,\n  ConnectIpsType,\n  SleepType,\n  ReorderStreamsType,\n  Settings,\n  ConsumeSocket,\n} from '../../@types/types';\nexport interface AllMembersRestParameters\n  extends OnScreenChangesParameters,\n    ConnectIpsParameters,\n    ReorderStreamsParameters {\n  participantsAll: Participant[];\n  participants: Participant[];\n  dispActiveNames: string[];\n  requestList: Request[];\n  coHost: string;\n  coHostResponsibility: CoHostResponsibility[];\n  lock_screen: boolean;\n  firstAll: boolean;\n  membersReceived: boolean;\n  roomRecvIPs: string[];\n  deferScreenReceived: boolean;\n  screenId?: string;\n  shareScreenStarted: boolean;\n  meetingDisplayType: string;\n  audioSetting: string;\n  videoSetting: string;\n  screenshareSetting: string;\n  chatSetting: string;\n\n  updateParticipantsAll: (participantsAll: Participant[]) => void;\n  updateParticipants: (participants: Participant[]) => void;\n  updateRequestList: (requestList: Request[]) => void;\n  updateCoHost: (coHost: string) => void;\n  updateCoHostResponsibility: (coHostResponsibility: CoHostResponsibility[]) => void;\n  updateFirstAll: (firstAll: boolean) => void;\n  updateMembersReceived: (membersReceived: boolean) => void;\n  updateDeferScreenReceived: (deferScreenReceived: boolean) => void;\n  updateShareScreenStarted: (shareScreenStarted: boolean) => void;\n  updateAudioSetting: (audioSetting: string) => void;\n  updateVideoSetting: (videoSetting: string) => void;\n  updateScreenshareSetting: (screenshareSetting: string) => void;\n  updateChatSetting: (chatSetting: string) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n  updateRoomRecvIPs: (ips: string[]) => void;\n  updateIsLoadingModalVisible: (visible: boolean) => void;\n\n  // mediasfu functions\n  onScreenChanges: OnScreenChangesType;\n  connectIps: ConnectIpsType;\n  sleep: SleepType;\n  reorderStreams: ReorderStreamsType;\n\n  getUpdatedAllParams: () => AllMembersRestParameters;\n  [key: string]: any;\n}\n\nexport interface AllMembersRestOptions {\n  members: Participant[];\n  settings: Settings;\n  coHoste?: string;\n  coHostRes?: CoHostResponsibility[];\n  parameters: AllMembersRestParameters;\n  consume_sockets: ConsumeSocket[];\n  apiUserName: string;\n  apiKey: string;\n  apiToken: string;\n}\n\n// Export the type definition for the function\nexport type AllMembersRestType = (options: AllMembersRestOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class AllMembersRest {\n  /**\n   * Handles various tasks related to participant management and UI updates.\n   * @param {Object} params - The parameters passed to the allMembersRest method.\n   * @param {Array} params.members - The array of participant members.\n   * @param {Array} params.settings - The array of settings.\n   * @param {boolean} params.coHoste - The co-host state.\n   * @param {boolean} params.coHostRes - The co-host responsibility state.\n   * @param {Object} params.parameters - The object containing parameters for the allMembersRest method.\n   * @param {Array} params.consume_sockets - The array of consume sockets.\n   * @param {string} params.apiUserName - The API username.\n   * @param {string} params.apiKey - The API key.\n   * @param {string} params.apiToken - The API token.\n   * @returns {void} - No return value.\n   */\n  async allMembersRest({\n    members,\n    settings,\n    coHoste,\n    coHostRes,\n    parameters,\n    consume_sockets,\n    apiUserName,\n    apiKey,\n    apiToken,\n  }: AllMembersRestOptions): Promise<void> {\n    let {\n      participantsAll,\n      participants,\n      dispActiveNames,\n      requestList,\n      coHost,\n      coHostResponsibility,\n      lock_screen,\n      firstAll,\n      membersReceived,\n      roomRecvIPs,\n      deferScreenReceived,\n      screenId,\n      shareScreenStarted,\n      meetingDisplayType,\n      audioSetting,\n      videoSetting,\n      screenshareSetting,\n      chatSetting,\n      updateParticipantsAll,\n      updateParticipants,\n      updateRequestList,\n      updateCoHost,\n      updateCoHostResponsibility,\n      updateFirstAll,\n      updateMembersReceived,\n      updateDeferScreenReceived,\n      updateShareScreenStarted,\n      updateAudioSetting,\n      updateVideoSetting,\n      updateScreenshareSetting,\n      updateChatSetting,\n      updateConsume_sockets,\n      updateRoomRecvIPs,\n      updateIsLoadingModalVisible,\n\n      onScreenChanges,\n      connectIps,\n      reorderStreams,\n      sleep,\n    } = parameters;\n\n    // Filter out the participant that isBanned == true or isSuspended == true\n    participantsAll = members.map((participant) => ({\n      isBanned: participant.isBanned,\n      isSuspended: participant.isSuspended,\n      name: participant.name,\n      audioID: participant.audioID,\n      videoID: participant.videoID,\n    }));\n    updateParticipantsAll(participantsAll);\n\n    participants = members.filter(\n      (participant) => !participant.isBanned && !participant.isSuspended,\n    );\n    updateParticipants(participants);\n\n    // Check if dispActiveNames is not empty and contains the name of the participant that is not in the participants array\n    if (dispActiveNames.length > 0) {\n      let dispActiveNames_ = dispActiveNames.filter(\n        (name: string) => !participants.map((participant: any) => participant.name).includes(name),\n      );\n      if (dispActiveNames_.length > 0 && membersReceived) {\n        await reorderStreams({ add: false, screenChanged: true, parameters });\n      }\n    }\n\n    // Operations to update the UI; make sure we are connected to the server before updating the UI\n    if (!membersReceived) {\n      if (roomRecvIPs.length < 1) {\n        // Keep checking every 0.01s\n        let checkIPs = setInterval(async () => {\n          if (roomRecvIPs.length > 0) {\n            clearInterval(checkIPs);\n\n            if (deferScreenReceived && screenId != null) {\n              shareScreenStarted = true;\n              updateShareScreenStarted(shareScreenStarted);\n            }\n\n            const [sockets_, ips_] = await connectIps({\n              consume_sockets,\n              remIP: roomRecvIPs,\n              parameters,\n              apiUserName,\n              apiKey,\n              apiToken,\n            });\n\n            if (sockets_ && ips_) {\n              updateConsume_sockets(sockets_);\n              updateRoomRecvIPs(ips_);\n            }\n\n            membersReceived = true;\n            updateMembersReceived(membersReceived);\n\n            await sleep({ ms: 250 });\n            updateIsLoadingModalVisible(false);\n            deferScreenReceived = false;\n            updateDeferScreenReceived(deferScreenReceived);\n          }\n        }, 10);\n      } else {\n        const [sockets_, ips_] = await connectIps({\n          consume_sockets,\n          remIP: roomRecvIPs,\n          parameters,\n          apiUserName,\n          apiKey,\n          apiToken,\n        });\n\n        if (sockets_ && ips_) {\n          updateConsume_sockets(sockets_);\n          updateRoomRecvIPs(ips_);\n        }\n        membersReceived = true;\n        updateMembersReceived(membersReceived);\n\n        if (deferScreenReceived && screenId != null) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n\n        await sleep({ ms: 250 });\n        updateIsLoadingModalVisible(false);\n        deferScreenReceived = false;\n        updateDeferScreenReceived(deferScreenReceived);\n      }\n    } else {\n      if (screenId != null) {\n        let host = participants.find(\n          (participant: any) => participant.ScreenID == screenId && participant.ScreenOn == true,\n        );\n        if (deferScreenReceived && screenId != null && host) {\n          shareScreenStarted = true;\n          updateShareScreenStarted(shareScreenStarted);\n        }\n      }\n    }\n\n    // Return requests for only ids that are in the participants array and update the count badge\n    let requests = requestList;\n    requestList = requests.filter((request: any) =>\n      participants.some((participant: any) => participant.id == request.id),\n    );\n    updateRequestList(requestList);\n\n    if (coHoste !== undefined && coHoste !== null) {\n      coHost = coHoste;\n    }\n    if (coHost !== undefined && coHost !== null) {\n      updateCoHost(coHost);\n    }\n    if (coHostRes !== undefined && coHostRes !== null) {\n      coHostResponsibility = coHostRes;\n    }\n    updateCoHostResponsibility(coHostResponsibility);\n\n    try {\n      if (!lock_screen && !firstAll) {\n        await onScreenChanges({ parameters });\n\n        if (meetingDisplayType != 'all') {\n          firstAll = true;\n          updateFirstAll(firstAll);\n        }\n      }\n    } catch (error) {\n      console.log('allMembersRest OnScreen', error);\n    }\n\n    try {\n      if (membersReceived) {\n        audioSetting = settings[0];\n        videoSetting = settings[1];\n        screenshareSetting = settings[2];\n        chatSetting = settings[3];\n\n        updateAudioSetting(audioSetting);\n        updateVideoSetting(videoSetting);\n        updateScreenshareSetting(screenshareSetting);\n        updateChatSetting(chatSetting);\n      }\n    } catch (error) {\n      console.log('allMembersRest Settings', error);\n    }\n  }\n}\n"]}