mediasfu-angular 1.0.0

package/dist/esm2022/lib/consumers/compare-active-names.service.mjs

@@ -0,0 +1,75 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CompareActiveNames {
+    /**
+     * Compares the current active names with the previous active names and triggers an action if there are changes.
+     *
+     * @param {Object} options - The options for comparing active names.
+     * @param {boolean} [options.restart=false] - Whether to restart the comparison.
+     * @param {CompareActiveNamesOptions} options.parameters - The parameters for the comparison.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {string[]} options.parameters.activeNames - The current active names.
+     * @param {string[]} options.parameters.prevActiveNames - The previous active names.
+     * @param {Function} options.parameters.updatePrevActiveNames - Function to update the previous active names.
+     * @param {Function} options.parameters.trigger - Function to trigger an action when names change.
+     *
+     * @returns {Promise<void>} A promise that resolves when the comparison is complete.
+     *
+     * @throws Will log an error message if an error occurs during the comparison.
+     */
+    async compareActiveNames({ restart = false, parameters, }) {
+        try {
+            let { getUpdatedAllParams } = parameters;
+            parameters = getUpdatedAllParams();
+            let { activeNames, prevActiveNames, updatePrevActiveNames, trigger } = parameters;
+            // Restart the comparison if needed
+            if (restart) {
+                await trigger({ ref_ActiveNames: activeNames, parameters });
+                return;
+            }
+            // Array to track changes in activeNames
+            let nameChanged = [];
+            // Compare each name in activeNames
+            for (let i = 0; i < activeNames.length; i++) {
+                const currentName = activeNames[i];
+                // Check if the name is present in prevActiveNames
+                const hasNameChanged = !prevActiveNames.includes(currentName);
+                if (hasNameChanged) {
+                    nameChanged.push(true);
+                    trigger({ ref_ActiveNames: activeNames, parameters });
+                    break;
+                }
+            }
+            // Count the number of true in nameChanged
+            let count = nameChanged.filter((value) => value === true).length;
+            if (count < 1) {
+                // Check for new names in prevActiveNames
+                for (let i = 0; i < prevActiveNames.length; i++) {
+                    const currentName = prevActiveNames[i];
+                    // Check if the name is present in activeNames
+                    const hasNameChanged = !activeNames.includes(currentName);
+                    // Signal change if the name is new
+                    if (hasNameChanged) {
+                        trigger({ ref_ActiveNames: activeNames, parameters });
+                        break;
+                    }
+                }
+            }
+            // Update prevActiveNames with current activeNames
+            prevActiveNames = [...activeNames];
+            updatePrevActiveNames(prevActiveNames);
+        }
+        catch (error) {
+            console.log('compareActiveNames error', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CompareActiveNames, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CompareActiveNames, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CompareActiveNames, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/compare-screen-states.service.mjs

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CompareScreenStates {
+    /**
+     * Compares the current screen states with the previous screen states and triggers actions based on changes.
+     *
+     * @param {Object} options - The options for comparing screen states.
+     * @param {boolean} [options.restart=false] - Whether to restart the comparison process.
+     * @param {CompareScreenStatesOptions} options.parameters - The parameters for the comparison.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to get updated parameters.
+     * @param {string} options.parameters.recordingDisplayType - The type of display being recorded.
+     * @param {boolean} options.parameters.recordingVideoOptimized - Whether the recording is optimized for video.
+     * @param {Array<ScreenState>} options.parameters.screenStates - The current screen states.
+     * @param {Array<ScreenState>} options.parameters.prevScreenStates - The previous screen states.
+     * @param {Array<string>} options.parameters.activeNames - The active names in the current context.
+     * @param {Function} options.parameters.trigger - Function to trigger actions based on changes.
+     *
+     * @returns {Promise<void>} A promise that resolves when the comparison and any triggered actions are complete.
+     *
+     * @throws Will log an error message if an error occurs during the comparison process.
+     */
+    async compareScreenStates({ restart = false, parameters, }) {
+        try {
+            let { getUpdatedAllParams } = parameters;
+            parameters = getUpdatedAllParams();
+            let { recordingDisplayType, recordingVideoOptimized, screenStates, prevScreenStates, activeNames, trigger, } = parameters;
+            // Restart the comparison if needed
+            if (restart) {
+                // Perform necessary actions on restart
+                return;
+            }
+            // Compare each key-value pair in the screenStates objects
+            for (let i = 0; i < screenStates.length; i++) {
+                const currentScreenState = screenStates[i];
+                const prevScreenState = prevScreenStates[i];
+                // Check if any value has changed
+                const hasChanged = Object.keys(currentScreenState).some((key) => currentScreenState[key] !== prevScreenState[key]);
+                // Signal change if any value has changed
+                if (hasChanged) {
+                    // Perform actions or trigger events based on the change
+                    if (recordingDisplayType === 'video' && recordingVideoOptimized) {
+                        await trigger({ ref_ActiveNames: activeNames, parameters });
+                        break;
+                    }
+                    await trigger({ ref_ActiveNames: activeNames, parameters });
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            console.log('compareScreenStates error', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CompareScreenStates, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CompareScreenStates, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: CompareScreenStates, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consumers/connect-ips.service.mjs

@@ -0,0 +1,112 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../sockets/socket-manager.service";
+import * as i2 from "./socket-receive-methods/new-pipe-producer.service";
+import * as i3 from "./socket-receive-methods/producer-closed.service";
+import * as i4 from "./socket-receive-methods/join-consume-room.service";
+export class ConnectIps {
+    socketManagerService;
+    newPipeProducerService;
+    producerClosedService;
+    joinConsumeRoomService;
+    constructor(socketManagerService, newPipeProducerService, producerClosedService, joinConsumeRoomService) {
+        this.socketManagerService = socketManagerService;
+        this.newPipeProducerService = newPipeProducerService;
+        this.producerClosedService = producerClosedService;
+        this.joinConsumeRoomService = joinConsumeRoomService;
+    }
+    /**
+     * Connects to remote IPs and manages socket connections.
+     *
+     * @param {Object} options - The options for connecting IPs.
+     * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.
+     * @param {string[]} options.remIP - The list of remote IPs to connect to.
+     * @param {string} options.apiUserName - The API username for authentication.
+     * @param {string} [options.apiKey] - The API key for authentication.
+     * @param {string} [options.apiToken] - The API token for authentication.
+     * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.
+     * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.
+     * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.
+     * @param {Object} options.parameters - Additional parameters.
+     * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.
+     * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.
+     * @param {Function} options.parameters.updateConsume_sockets - The function to update the consume sockets.
+     *
+     * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.
+     *
+     * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.
+     */
+    connectIps = async ({ consume_sockets, remIP, apiUserName, apiKey = '', apiToken = '', newProducerMethod = this.newPipeProducerService.newPipeProducer, closedProducerMethod = this.producerClosedService.producerClosed, joinConsumeRoomMethod = this.joinConsumeRoomService.joinConsumeRoom, parameters, }) => {
+        try {
+            const { roomRecvIPs, updateRoomRecvIPs, updateConsume_sockets } = parameters;
+            if (!consume_sockets || !remIP || !apiUserName || (!apiKey && !apiToken)) {
+                console.log('Missing required parameters - consume_sockets, remIP, apiUserName, apiKey, apiToken');
+                return [consume_sockets, roomRecvIPs];
+            }
+            await Promise.all(remIP.map(async (ip) => {
+                try {
+                    // Check if the IP is already connected
+                    const matching = consume_sockets.find((socketObj) => Object.keys(socketObj)[0] == ip);
+                    if (matching || !ip || ip === '' || ip === null || ip === undefined) {
+                        // Skip if the IP is already connected
+                        return;
+                    }
+                    // Connect to the remote socket using socket.io-client
+                    const remote_sock = await this.socketManagerService.connectSocket({
+                        apiUserName,
+                        apiKey,
+                        apiToken,
+                        link: `https://${ip}.mediasfu.com`,
+                    });
+                    // Handle successful connection to the remote socket
+                    if (remote_sock.id) {
+                        // Check if the IP is in the roomRecvIPs, if not, add it
+                        if (!roomRecvIPs.includes(ip)) {
+                            roomRecvIPs.push(ip);
+                            updateRoomRecvIPs(roomRecvIPs);
+                        }
+                        // Handle new pipe producer event
+                        remote_sock.on('new-pipe-producer', async ({ producerId, islevel }) => {
+                            await newProducerMethod({ producerId, islevel, nsock: remote_sock, parameters });
+                        });
+                        // Handle producer closed event
+                        remote_sock.on('producer-closed', async ({ remoteProducerId }) => {
+                            await closedProducerMethod({ remoteProducerId, parameters });
+                        });
+                        // Handle new consuming room by joining the room
+                        const data = await joinConsumeRoomMethod({
+                            remote_sock,
+                            apiToken,
+                            apiUserName,
+                            parameters,
+                        });
+                        if (!data.rtpCapabilities) {
+                            return;
+                        }
+                        // Add the remote socket to the consume_sockets array
+                        consume_sockets.push({ [ip]: remote_sock });
+                        updateConsume_sockets(consume_sockets);
+                    }
+                }
+                catch (error) {
+                    // Handle the error
+                    console.log('connectIps error', error);
+                }
+            }));
+            return [consume_sockets, roomRecvIPs];
+        }
+        catch (error) {
+            // Handle the error
+            console.log('connectIps error', error);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectIps, deps: [{ token: i1.SocketManager }, { token: i2.NewPipeProducer }, { token: i3.ProducerClosed }, { token: i4.JoinConsumeRoom }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectIps, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectIps, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SocketManager }, { type: i2.NewPipeProducer }, { type: i3.ProducerClosed }, { type: i4.JoinConsumeRoom }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-ips.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-ips.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;;;;AAsD3C,MAAM,OAAO,UAAU;IAEX;IACA;IACA;IACA;IAJV,YACU,oBAAmC,EACnC,sBAAuC,EACvC,qBAAqC,EACrC,sBAAuC;QAHvC,yBAAoB,GAApB,oBAAoB,CAAe;QACnC,2BAAsB,GAAtB,sBAAsB,CAAiB;QACvC,0BAAqB,GAArB,qBAAqB,CAAgB;QACrC,2BAAsB,GAAtB,sBAAsB,CAAiB;IAC9C,CAAC;IAEJ;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,UAAU,GAAG,KAAK,EAAE,EAClB,eAAe,EACf,KAAK,EACL,WAAW,EACX,MAAM,GAAG,EAAE,EACX,QAAQ,GAAG,EAAE,EACb,iBAAiB,GAAG,IAAI,CAAC,sBAAsB,CAAC,eAAe,EAC/D,oBAAoB,GAAG,IAAI,CAAC,qBAAqB,CAAC,cAAc,EAChE,qBAAqB,GAAG,IAAI,CAAC,sBAAsB,CAAC,eAAe,EACnE,UAAU,GACQ,EAAgB,EAAE;QACpC,IAAI,CAAC;YACH,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,GAAG,UAAU,CAAC;YAE7E,IAAI,CAAC,eAAe,IAAI,CAAC,KAAK,IAAI,CAAC,WAAW,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACzE,OAAO,CAAC,GAAG,CACT,qFAAqF,CACtF,CAAC;gBACF,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;YACxC,CAAC;YAED,MAAM,OAAO,CAAC,GAAG,CACf,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;gBACrB,IAAI,CAAC;oBACH,uCAAuC;oBACvC,MAAM,QAAQ,GAAG,eAAe,CAAC,IAAI,CACnC,CAAC,SAAc,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CACpD,CAAC;oBAEF,IAAI,QAAQ,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;wBACpE,sCAAsC;wBACtC,OAAO;oBACT,CAAC;oBAED,sDAAsD;oBACtD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,aAAa,CAAC;wBAChE,WAAW;wBACX,MAAM;wBACN,QAAQ;wBACR,IAAI,EAAE,WAAW,EAAE,eAAe;qBACnC,CAAC,CAAC;oBAEH,oDAAoD;oBACpD,IAAI,WAAW,CAAC,EAAE,EAAE,CAAC;wBACnB,wDAAwD;wBACxD,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;4BAC9B,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;4BACrB,iBAAiB,CAAC,WAAW,CAAC,CAAC;wBACjC,CAAC;wBAED,iCAAiC;wBACjC,WAAW,CAAC,EAAE,CACZ,mBAAmB,EACnB,KAAK,EAAE,EAAE,UAAU,EAAE,OAAO,EAA2C,EAAE,EAAE;4BACzE,MAAM,iBAAiB,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC,CAAC;wBACnF,CAAC,CACF,CAAC;wBAEF,+BAA+B;wBAC/B,WAAW,CAAC,EAAE,CACZ,iBAAiB,EACjB,KAAK,EAAE,EAAE,gBAAgB,EAAgC,EAAE,EAAE;4BAC3D,MAAM,oBAAoB,CAAC,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,CAAC;wBAC/D,CAAC,CACF,CAAC;wBAEF,gDAAgD;wBAChD,MAAM,IAAI,GAAG,MAAM,qBAAqB,CAAC;4BACvC,WAAW;4BACX,QAAQ;4BACR,WAAW;4BACX,UAAU;yBACX,CAAC,CAAC;wBACH,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;4BAC1B,OAAO;wBACT,CAAC;wBAED,qDAAqD;wBACrD,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;wBAC5C,qBAAqB,CAAC,eAAe,CAAC,CAAC;oBACzC,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,mBAAmB;oBACnB,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;gBACzC,CAAC;YACH,CAAC,CAAC,CACH,CAAC;YAEF,OAAO,CAAC,eAAe,EAAE,WAAW,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,mBAAmB;YACnB,OAAO,CAAC,GAAG,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QACzC,CAAC;IACH,CAAC,CAAC;uGA1HS,UAAU;2GAAV,UAAU,cAFT,MAAM;;2FAEP,UAAU;kBAHtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { SocketManager } from '../sockets/socket-manager.service';\nimport { NewPipeProducer } from './socket-receive-methods/new-pipe-producer.service';\nimport { ProducerClosed } from './socket-receive-methods/producer-closed.service';\nimport { JoinConsumeRoom } from './socket-receive-methods/join-consume-room.service';\nimport { Device } from 'mediasoup-client/lib/types';\nimport {\n  ReorderStreamsParameters,\n  ReorderStreamsType,\n  NewPipeProducerParameters,\n  NewPipeProducerType,\n  ProducerClosedType,\n  ProducerClosedParameters,\n  JoinConsumeRoomType,\n  JoinConsumeRoomParameters,\n  ConsumeSocket,\n} from '../@types/types';\n\nexport interface ConnectIpsParameters\n  extends ReorderStreamsParameters,\n    JoinConsumeRoomParameters,\n    ProducerClosedParameters,\n    NewPipeProducerParameters {\n  device: Device | null;\n  roomRecvIPs: string[];\n  updateRoomRecvIPs: (roomRecvIPs: string[]) => void;\n  updateConsume_sockets: (consume_sockets: ConsumeSocket[]) => void;\n\n  // mediasfu functions\n  reorderStreams: ReorderStreamsType;\n  getUpdatedAllParams: () => ConnectIpsParameters;\n  [key: string]: any;\n}\n\nexport interface ConnectIpsOptions {\n  consume_sockets: ConsumeSocket[];\n  remIP: string[];\n  apiUserName: string;\n  apiKey?: string;\n  apiToken: string;\n  newProducerMethod?: NewPipeProducerType;\n  closedProducerMethod?: ProducerClosedType;\n  joinConsumeRoomMethod?: JoinConsumeRoomType;\n  parameters: ConnectIpsParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectIpsType = (\n  options: ConnectIpsOptions,\n) => Promise<[Record<string, any>[], string[]]>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectIps {\n  constructor(\n    private socketManagerService: SocketManager,\n    private newPipeProducerService: NewPipeProducer,\n    private producerClosedService: ProducerClosed,\n    private joinConsumeRoomService: JoinConsumeRoom,\n  ) {}\n\n  /**\n   * Connects to remote IPs and manages socket connections.\n   *\n   * @param {Object} options - The options for connecting IPs.\n   * @param {Record<string, any>[]} options.consume_sockets - The array of current socket connections.\n   * @param {string[]} options.remIP - The list of remote IPs to connect to.\n   * @param {string} options.apiUserName - The API username for authentication.\n   * @param {string} [options.apiKey] - The API key for authentication.\n   * @param {string} [options.apiToken] - The API token for authentication.\n   * @param {Function} [options.newProducerMethod=newPipeProducer] - The method to handle new pipe producer events.\n   * @param {Function} [options.closedProducerMethod=producerClosed] - The method to handle producer closed events.\n   * @param {Function} [options.joinConsumeRoomMethod=joinConsumeRoom] - The method to handle joining a consuming room.\n   * @param {Object} options.parameters - Additional parameters.\n   * @param {string[]} options.parameters.roomRecvIPs - The list of IPs that have been received in the room.\n   * @param {Function} options.parameters.updateRoomRecvIPs - The function to update the room received IPs.\n   * @param {Function} options.parameters.updateConsume_sockets - The function to update the consume sockets.\n   *\n   * @returns {Promise<[Record<string, any>[], string[]]>} A promise that resolves to an array containing the updated consume sockets and room received IPs.\n   *\n   * @throws Will throw an error if required parameters are missing or if there is an issue connecting to a remote IP.\n   */\n  connectIps = async ({\n    consume_sockets,\n    remIP,\n    apiUserName,\n    apiKey = '',\n    apiToken = '',\n    newProducerMethod = this.newPipeProducerService.newPipeProducer,\n    closedProducerMethod = this.producerClosedService.producerClosed,\n    joinConsumeRoomMethod = this.joinConsumeRoomService.joinConsumeRoom,\n    parameters,\n  }: ConnectIpsOptions): Promise<any> => {\n    try {\n      const { roomRecvIPs, updateRoomRecvIPs, updateConsume_sockets } = parameters;\n\n      if (!consume_sockets || !remIP || !apiUserName || (!apiKey && !apiToken)) {\n        console.log(\n          'Missing required parameters - consume_sockets, remIP, apiUserName, apiKey, apiToken',\n        );\n        return [consume_sockets, roomRecvIPs];\n      }\n\n      await Promise.all(\n        remIP.map(async (ip) => {\n          try {\n            // Check if the IP is already connected\n            const matching = consume_sockets.find(\n              (socketObj: any) => Object.keys(socketObj)[0] == ip,\n            );\n\n            if (matching || !ip || ip === '' || ip === null || ip === undefined) {\n              // Skip if the IP is already connected\n              return;\n            }\n\n            // Connect to the remote socket using socket.io-client\n            const remote_sock = await this.socketManagerService.connectSocket({\n              apiUserName,\n              apiKey,\n              apiToken,\n              link: `https://${ip}.mediasfu.com`,\n            });\n\n            // Handle successful connection to the remote socket\n            if (remote_sock.id) {\n              // Check if the IP is in the roomRecvIPs, if not, add it\n              if (!roomRecvIPs.includes(ip)) {\n                roomRecvIPs.push(ip);\n                updateRoomRecvIPs(roomRecvIPs);\n              }\n\n              // Handle new pipe producer event\n              remote_sock.on(\n                'new-pipe-producer',\n                async ({ producerId, islevel }: { producerId: string; islevel: string }) => {\n                  await newProducerMethod({ producerId, islevel, nsock: remote_sock, parameters });\n                },\n              );\n\n              // Handle producer closed event\n              remote_sock.on(\n                'producer-closed',\n                async ({ remoteProducerId }: { remoteProducerId: string }) => {\n                  await closedProducerMethod({ remoteProducerId, parameters });\n                },\n              );\n\n              // Handle new consuming room by joining the room\n              const data = await joinConsumeRoomMethod({\n                remote_sock,\n                apiToken,\n                apiUserName,\n                parameters,\n              });\n              if (!data.rtpCapabilities) {\n                return;\n              }\n\n              // Add the remote socket to the consume_sockets array\n              consume_sockets.push({ [ip]: remote_sock });\n              updateConsume_sockets(consume_sockets);\n            }\n          } catch (error) {\n            // Handle the error\n            console.log('connectIps error', error);\n          }\n        }),\n      );\n\n      return [consume_sockets, roomRecvIPs];\n    } catch (error) {\n      // Handle the error\n      console.log('connectIps error', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/connect-recv-transport.service.mjs

@@ -0,0 +1,113 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConnectRecvTransport {
+    /**
+     * Connects the receiving transport to consume media from a remote producer.
+     *
+     * @param {Object} options - The options for connecting the receiving transport.
+     * @param {Transport} options.consumerTransport - The transport used for consuming media.
+     * @param {string} options.remoteProducerId - The ID of the remote producer.
+     * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.
+     * @param {Socket} options.nsock - The socket used for communication.
+     * @param {ConnectRecvTransportOptions} options.parameters - The parameters for the connection.
+     *
+     * @returns {Promise<void>} A promise that resolves when the connection is established.
+     *
+     * @throws Will throw an error if the connection or consumption fails.
+     *
+     * @example
+     * ```typescript
+     * const options = {
+     *   consumerTransport,
+     *   remoteProducerId: 'producer-id',
+     *   serverConsumerTransportId: 'transport-id',
+     *   nsock: socket,
+     *   parameters: connectRecvTransportOptions,
+     * };
+     *
+     * connectRecvTransport(options)
+     *   .then(() => {
+     *     console.log('Transport connected and consuming media');
+     *   })
+     *   .catch((error) => {
+     *     console.error('Error connecting transport:', error);
+     *   });
+     * ```
+     */
+    connectRecvTransport = async ({ consumerTransport, remoteProducerId, serverConsumerTransportId, nsock, parameters, }) => {
+        try {
+            parameters = parameters.getUpdatedAllParams();
+            const { device, consumerTransports, updateConsumerTransports, consumerResume } = parameters;
+            // Emit 'consume' event to signal consumption initiation
+            nsock.emit('consume', {
+                rtpCapabilities: device ? device.rtpCapabilities : null,
+                remoteProducerId,
+                serverConsumerTransportId,
+            }, async ({ params }) => {
+                if (params.error) {
+                    // Handle error
+                    console.log('consume error', params.error);
+                    return;
+                }
+                try {
+                    // Consume media using received parameters
+                    const consumer = await consumerTransport.consume({
+                        id: params.id,
+                        producerId: params.producerId,
+                        kind: params.kind,
+                        rtpParameters: params.rtpParameters,
+                    });
+                    // Update consumerTransports array with the new consumer
+                    consumerTransports.push({
+                        consumerTransport,
+                        serverConsumerTransportId: params.id,
+                        producerId: remoteProducerId,
+                        consumer,
+                        socket_: nsock,
+                    });
+                    updateConsumerTransports(consumerTransports);
+                    // Extract track from the consumer
+                    const { track } = consumer;
+                    // Emit 'consumer-resume' event to signal consumer resumption
+                    nsock.emit('consumer-resume', { serverConsumerId: params.serverConsumerId }, async ({ resumed }) => {
+                        if (resumed) {
+                            // Consumer resumed and ready to be used
+                            try {
+                                await consumerResume({
+                                    track,
+                                    kind: params.kind,
+                                    remoteProducerId,
+                                    params,
+                                    parameters,
+                                    nsock,
+                                });
+                            }
+                            catch (error) {
+                                // Handle error
+                                console.log('consumerResume error', error);
+                            }
+                        }
+                    });
+                }
+                catch (error) {
+                    // Handle error
+                    console.log('consume error', error);
+                    return;
+                }
+            });
+        }
+        catch (error) {
+            // Handle error
+            console.log('connectRecvTransport error', error);
+        }
+    };
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectRecvTransport, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectRecvTransport, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectRecvTransport, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connect-recv-transport.service.js","sourceRoot":"","sources":["../../../../../projects/mediasfu-angular/src/lib/consumers/connect-recv-transport.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;AAyC3C,MAAM,OAAO,oBAAoB;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IAEH,oBAAoB,GAAG,KAAK,EAAE,EAC5B,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EACzB,KAAK,EACL,UAAU,GACkB,EAAiB,EAAE;QAC/C,IAAI,CAAC;YACH,UAAU,GAAG,UAAU,CAAC,mBAAmB,EAAE,CAAC;YAC9C,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,cAAc,EAAE,GAAG,UAAU,CAAC;YAE5F,wDAAwD;YACxD,KAAK,CAAC,IAAI,CACR,SAAS,EACT;gBACE,eAAe,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI;gBACvD,gBAAgB;gBAChB,yBAAyB;aAC1B,EACD,KAAK,EAAE,EAAE,MAAM,EAAsB,EAAE,EAAE;gBACvC,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;oBACjB,eAAe;oBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;oBAC3C,OAAO;gBACT,CAAC;gBAED,IAAI,CAAC;oBACH,0CAA0C;oBAC1C,MAAM,QAAQ,GAAa,MAAM,iBAAiB,CAAC,OAAO,CAAC;wBACzD,EAAE,EAAE,MAAM,CAAC,EAAE;wBACb,UAAU,EAAE,MAAM,CAAC,UAAU;wBAC7B,IAAI,EAAE,MAAM,CAAC,IAAyB;wBACtC,aAAa,EAAE,MAAM,CAAC,aAAa;qBACpC,CAAC,CAAC;oBAEH,wDAAwD;oBACxD,kBAAkB,CAAC,IAAI,CAAC;wBACtB,iBAAiB;wBACjB,yBAAyB,EAAE,MAAM,CAAC,EAAE;wBACpC,UAAU,EAAE,gBAAgB;wBAC5B,QAAQ;wBACR,OAAO,EAAE,KAAK;qBACf,CAAC,CAAC;oBAEH,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;oBAE7C,kCAAkC;oBAClC,MAAM,EAAE,KAAK,EAAE,GAAG,QAAQ,CAAC;oBAE3B,6DAA6D;oBAC7D,KAAK,CAAC,IAAI,CACR,iBAAiB,EACjB,EAAE,gBAAgB,EAAE,MAAM,CAAC,gBAAgB,EAAE,EAC7C,KAAK,EAAE,EAAE,OAAO,EAAO,EAAE,EAAE;wBACzB,IAAI,OAAO,EAAE,CAAC;4BACZ,wCAAwC;4BACxC,IAAI,CAAC;gCACH,MAAM,cAAc,CAAC;oCACnB,KAAK;oCACL,IAAI,EAAE,MAAM,CAAC,IAAI;oCACjB,gBAAgB;oCAChB,MAAM;oCACN,UAAU;oCACV,KAAK;iCACN,CAAC,CAAC;4BACL,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,eAAe;gCACf,OAAO,CAAC,GAAG,CAAC,sBAAsB,EAAE,KAAK,CAAC,CAAC;4BAC7C,CAAC;wBACH,CAAC;oBACH,CAAC,CACF,CAAC;gBACJ,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,eAAe;oBACf,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;oBACpC,OAAO;gBACT,CAAC;YACH,CAAC,CACF,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,eAAe;YACf,OAAO,CAAC,GAAG,CAAC,4BAA4B,EAAE,KAAK,CAAC,CAAC;QACnD,CAAC;IACH,CAAC,CAAC;uGAtHS,oBAAoB;2GAApB,oBAAoB,cAFnB,MAAM;;2FAEP,oBAAoB;kBAHhC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Socket } from 'socket.io-client';\nimport {\n  ConsumerResumeType,\n  ConsumerResumeParameters,\n  Transport as TransportType,\n} from '../@types/types';\nimport { Consumer, Device, Transport } from 'mediasoup-client/lib/types';\ninterface Params {\n  id: string;\n  producerId: string;\n  kind: string;\n  rtpParameters: any;\n  serverConsumerId: string;\n  error?: string;\n}\n\nexport interface ConnectRecvTransportParameters extends ConsumerResumeParameters {\n  device: Device | null;\n  consumerTransports: TransportType[];\n  updateConsumerTransports: (transports: TransportType[]) => void;\n\n  // mediasfu functions\n  consumerResume: ConsumerResumeType;\n  getUpdatedAllParams: () => ConnectRecvTransportParameters;\n  [key: string]: any; // Extendable for additional parameters\n}\nexport interface ConnectRecvTransportOptions {\n  consumerTransport: Transport;\n  remoteProducerId: string;\n  serverConsumerTransportId: string;\n  nsock: Socket;\n  parameters: ConnectRecvTransportParameters;\n}\n\n// Export the type definition for the function\nexport type ConnectRecvTransportType = (options: ConnectRecvTransportOptions) => Promise<void>;\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ConnectRecvTransport {\n  /**\n   * Connects the receiving transport to consume media from a remote producer.\n   *\n   * @param {Object} options - The options for connecting the receiving transport.\n   * @param {Transport} options.consumerTransport - The transport used for consuming media.\n   * @param {string} options.remoteProducerId - The ID of the remote producer.\n   * @param {string} options.serverConsumerTransportId - The ID of the server consumer transport.\n   * @param {Socket} options.nsock - The socket used for communication.\n   * @param {ConnectRecvTransportOptions} options.parameters - The parameters for the connection.\n   *\n   * @returns {Promise<void>} A promise that resolves when the connection is established.\n   *\n   * @throws Will throw an error if the connection or consumption fails.\n   *\n   * @example\n   * ```typescript\n   * const options = {\n   *   consumerTransport,\n   *   remoteProducerId: 'producer-id',\n   *   serverConsumerTransportId: 'transport-id',\n   *   nsock: socket,\n   *   parameters: connectRecvTransportOptions,\n   * };\n   *\n   * connectRecvTransport(options)\n   *   .then(() => {\n   *     console.log('Transport connected and consuming media');\n   *   })\n   *   .catch((error) => {\n   *     console.error('Error connecting transport:', error);\n   *   });\n   * ```\n   */\n\n  connectRecvTransport = async ({\n    consumerTransport,\n    remoteProducerId,\n    serverConsumerTransportId,\n    nsock,\n    parameters,\n  }: ConnectRecvTransportOptions): Promise<void> => {\n    try {\n      parameters = parameters.getUpdatedAllParams();\n      const { device, consumerTransports, updateConsumerTransports, consumerResume } = parameters;\n\n      // Emit 'consume' event to signal consumption initiation\n      nsock.emit(\n        'consume',\n        {\n          rtpCapabilities: device ? device.rtpCapabilities : null,\n          remoteProducerId,\n          serverConsumerTransportId,\n        },\n        async ({ params }: { params: Params }) => {\n          if (params.error) {\n            // Handle error\n            console.log('consume error', params.error);\n            return;\n          }\n\n          try {\n            // Consume media using received parameters\n            const consumer: Consumer = await consumerTransport.consume({\n              id: params.id,\n              producerId: params.producerId,\n              kind: params.kind as 'audio' | 'video',\n              rtpParameters: params.rtpParameters,\n            });\n\n            // Update consumerTransports array with the new consumer\n            consumerTransports.push({\n              consumerTransport,\n              serverConsumerTransportId: params.id,\n              producerId: remoteProducerId,\n              consumer,\n              socket_: nsock,\n            });\n\n            updateConsumerTransports(consumerTransports);\n\n            // Extract track from the consumer\n            const { track } = consumer;\n\n            // Emit 'consumer-resume' event to signal consumer resumption\n            nsock.emit(\n              'consumer-resume',\n              { serverConsumerId: params.serverConsumerId },\n              async ({ resumed }: any) => {\n                if (resumed) {\n                  // Consumer resumed and ready to be used\n                  try {\n                    await consumerResume({\n                      track,\n                      kind: params.kind,\n                      remoteProducerId,\n                      params,\n                      parameters,\n                      nsock,\n                    });\n                  } catch (error) {\n                    // Handle error\n                    console.log('consumerResume error', error);\n                  }\n                }\n              },\n            );\n          } catch (error) {\n            // Handle error\n            console.log('consume error', error);\n            return;\n          }\n        },\n      );\n    } catch (error) {\n      // Handle error\n      console.log('connectRecvTransport error', error);\n    }\n  };\n}\n"]}

package/dist/esm2022/lib/consumers/connect-send-transport-audio.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConnectSendTransportAudio {
+    /**
+     * Connects the send transport for audio by producing audio data and updating the audio producer and producer transport objects.
+     *
+     * @param {Object} params - The parameters for connecting the send transport.
+     * @param {ProducerOptions} params.audioParams - The options for the audio producer.
+     * @param {ConnectSendTransportAudioParameters} params.parameters - The parameters containing the audio producer, producer transport, and update functions.
+     * @param {Producer} params.parameters.audioProducer - The current audio producer.
+     * @param {Transport} params.parameters.producerTransport - The transport used to produce audio data.
+     * @param {Function} params.parameters.updateAudioProducer - Function to update the audio producer.
+     * @param {Function} params.parameters.updateProducerTransport - Function to update the producer transport.
+     *
+     * @returns {Promise<void>} A promise that resolves when the audio transport is successfully connected.
+     *
+     * @throws Will throw an error if the connection fails.
+     */
+    async connectSendTransportAudio({ audioParams, parameters, }) {
+        try {
+            let { audioProducer, producerTransport, updateAudioProducer, updateProducerTransport } = parameters;
+            // Connect the send transport for audio by producing audio data
+            if (producerTransport) {
+                audioProducer = await producerTransport.produce(audioParams);
+            }
+            else {
+                throw new Error('Producer transport is null');
+            }
+            // Update the audio producer and producer transport objects
+            updateAudioProducer(audioProducer);
+            updateProducerTransport(producerTransport);
+        }
+        catch (error) {
+            console.log('connectSendTransportAudio error', error);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectSendTransportAudio, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectSendTransportAudio, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectSendTransportAudio, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdC1zZW5kLXRyYW5zcG9ydC1hdWRpby5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbWVkaWFzZnUtYW5ndWxhci9zcmMvbGliL2NvbnN1bWVycy9jb25uZWN0LXNlbmQtdHJhbnNwb3J0LWF1ZGlvLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFzQjNDLE1BQU0sT0FBTyx5QkFBeUI7SUFDcEM7Ozs7Ozs7Ozs7Ozs7O09BY0c7SUFFSCxLQUFLLENBQUMseUJBQXlCLENBQUMsRUFDOUIsV0FBVyxFQUNYLFVBQVUsR0FDdUI7UUFDakMsSUFBSSxDQUFDO1lBQ0gsSUFBSSxFQUFFLGFBQWEsRUFBRSxpQkFBaUIsRUFBRSxtQkFBbUIsRUFBRSx1QkFBdUIsRUFBRSxHQUNwRixVQUFVLENBQUM7WUFFYiwrREFBK0Q7WUFDL0QsSUFBSSxpQkFBaUIsRUFBRSxDQUFDO2dCQUN0QixhQUFhLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQyxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUM7WUFDL0QsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE1BQU0sSUFBSSxLQUFLLENBQUMsNEJBQTRCLENBQUMsQ0FBQztZQUNoRCxDQUFDO1lBRUQsMkRBQTJEO1lBQzNELG1CQUFtQixDQUFDLGFBQWEsQ0FBQyxDQUFDO1lBQ25DLHVCQUF1QixDQUFDLGlCQUFpQixDQUFDLENBQUM7UUFDN0MsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixPQUFPLENBQUMsR0FBRyxDQUFDLGlDQUFpQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQ3hELENBQUM7SUFDSCxDQUFDO3VHQXRDVSx5QkFBeUI7MkdBQXpCLHlCQUF5QixjQUZ4QixNQUFNOzsyRkFFUCx5QkFBeUI7a0JBSHJDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBUcmFuc3BvcnQsIFByb2R1Y2VyLCBQcm9kdWNlck9wdGlvbnMgfSBmcm9tICdtZWRpYXNvdXAtY2xpZW50L2xpYi90eXBlcyc7XG5leHBvcnQgaW50ZXJmYWNlIENvbm5lY3RTZW5kVHJhbnNwb3J0QXVkaW9QYXJhbWV0ZXJzIHtcbiAgYXVkaW9Qcm9kdWNlcjogUHJvZHVjZXIgfCBudWxsO1xuICBwcm9kdWNlclRyYW5zcG9ydDogVHJhbnNwb3J0IHwgbnVsbDtcbiAgdXBkYXRlQXVkaW9Qcm9kdWNlcjogKHByb2R1Y2VyOiBQcm9kdWNlciB8IG51bGwpID0+IHZvaWQ7XG4gIHVwZGF0ZVByb2R1Y2VyVHJhbnNwb3J0OiAodHJhbnNwb3J0OiBUcmFuc3BvcnQgfCBudWxsKSA9PiB2b2lkO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvbm5lY3RTZW5kVHJhbnNwb3J0QXVkaW9PcHRpb25zIHtcbiAgYXVkaW9QYXJhbXM6IFByb2R1Y2VyT3B0aW9ucztcbiAgcGFyYW1ldGVyczogQ29ubmVjdFNlbmRUcmFuc3BvcnRBdWRpb1BhcmFtZXRlcnM7XG59XG5cbi8vIEV4cG9ydCB0aGUgdHlwZSBkZWZpbml0aW9uIGZvciB0aGUgZnVuY3Rpb25cbmV4cG9ydCB0eXBlIENvbm5lY3RTZW5kVHJhbnNwb3J0QXVkaW9UeXBlID0gKFxuICBvcHRpb25zOiBDb25uZWN0U2VuZFRyYW5zcG9ydEF1ZGlvT3B0aW9ucyxcbikgPT4gUHJvbWlzZTx2b2lkPjtcbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnLFxufSlcbmV4cG9ydCBjbGFzcyBDb25uZWN0U2VuZFRyYW5zcG9ydEF1ZGlvIHtcbiAgLyoqXG4gICAqIENvbm5lY3RzIHRoZSBzZW5kIHRyYW5zcG9ydCBmb3IgYXVkaW8gYnkgcHJvZHVjaW5nIGF1ZGlvIGRhdGEgYW5kIHVwZGF0aW5nIHRoZSBhdWRpbyBwcm9kdWNlciBhbmQgcHJvZHVjZXIgdHJhbnNwb3J0IG9iamVjdHMuXG4gICAqXG4gICAqIEBwYXJhbSB7T2JqZWN0fSBwYXJhbXMgLSBUaGUgcGFyYW1ldGVycyBmb3IgY29ubmVjdGluZyB0aGUgc2VuZCB0cmFuc3BvcnQuXG4gICAqIEBwYXJhbSB7UHJvZHVjZXJPcHRpb25zfSBwYXJhbXMuYXVkaW9QYXJhbXMgLSBUaGUgb3B0aW9ucyBmb3IgdGhlIGF1ZGlvIHByb2R1Y2VyLlxuICAgKiBAcGFyYW0ge0Nvbm5lY3RTZW5kVHJhbnNwb3J0QXVkaW9QYXJhbWV0ZXJzfSBwYXJhbXMucGFyYW1ldGVycyAtIFRoZSBwYXJhbWV0ZXJzIGNvbnRhaW5pbmcgdGhlIGF1ZGlvIHByb2R1Y2VyLCBwcm9kdWNlciB0cmFuc3BvcnQsIGFuZCB1cGRhdGUgZnVuY3Rpb25zLlxuICAgKiBAcGFyYW0ge1Byb2R1Y2VyfSBwYXJhbXMucGFyYW1ldGVycy5hdWRpb1Byb2R1Y2VyIC0gVGhlIGN1cnJlbnQgYXVkaW8gcHJvZHVjZXIuXG4gICAqIEBwYXJhbSB7VHJhbnNwb3J0fSBwYXJhbXMucGFyYW1ldGVycy5wcm9kdWNlclRyYW5zcG9ydCAtIFRoZSB0cmFuc3BvcnQgdXNlZCB0byBwcm9kdWNlIGF1ZGlvIGRhdGEuXG4gICAqIEBwYXJhbSB7RnVuY3Rpb259IHBhcmFtcy5wYXJhbWV0ZXJzLnVwZGF0ZUF1ZGlvUHJvZHVjZXIgLSBGdW5jdGlvbiB0byB1cGRhdGUgdGhlIGF1ZGlvIHByb2R1Y2VyLlxuICAgKiBAcGFyYW0ge0Z1bmN0aW9ufSBwYXJhbXMucGFyYW1ldGVycy51cGRhdGVQcm9kdWNlclRyYW5zcG9ydCAtIEZ1bmN0aW9uIHRvIHVwZGF0ZSB0aGUgcHJvZHVjZXIgdHJhbnNwb3J0LlxuICAgKlxuICAgKiBAcmV0dXJucyB7UHJvbWlzZTx2b2lkPn0gQSBwcm9taXNlIHRoYXQgcmVzb2x2ZXMgd2hlbiB0aGUgYXVkaW8gdHJhbnNwb3J0IGlzIHN1Y2Nlc3NmdWxseSBjb25uZWN0ZWQuXG4gICAqXG4gICAqIEB0aHJvd3MgV2lsbCB0aHJvdyBhbiBlcnJvciBpZiB0aGUgY29ubmVjdGlvbiBmYWlscy5cbiAgICovXG5cbiAgYXN5bmMgY29ubmVjdFNlbmRUcmFuc3BvcnRBdWRpbyh7XG4gICAgYXVkaW9QYXJhbXMsXG4gICAgcGFyYW1ldGVycyxcbiAgfTogQ29ubmVjdFNlbmRUcmFuc3BvcnRBdWRpb09wdGlvbnMpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICB0cnkge1xuICAgICAgbGV0IHsgYXVkaW9Qcm9kdWNlciwgcHJvZHVjZXJUcmFuc3BvcnQsIHVwZGF0ZUF1ZGlvUHJvZHVjZXIsIHVwZGF0ZVByb2R1Y2VyVHJhbnNwb3J0IH0gPVxuICAgICAgICBwYXJhbWV0ZXJzO1xuXG4gICAgICAvLyBDb25uZWN0IHRoZSBzZW5kIHRyYW5zcG9ydCBmb3IgYXVkaW8gYnkgcHJvZHVjaW5nIGF1ZGlvIGRhdGFcbiAgICAgIGlmIChwcm9kdWNlclRyYW5zcG9ydCkge1xuICAgICAgICBhdWRpb1Byb2R1Y2VyID0gYXdhaXQgcHJvZHVjZXJUcmFuc3BvcnQucHJvZHVjZShhdWRpb1BhcmFtcyk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ1Byb2R1Y2VyIHRyYW5zcG9ydCBpcyBudWxsJyk7XG4gICAgICB9XG5cbiAgICAgIC8vIFVwZGF0ZSB0aGUgYXVkaW8gcHJvZHVjZXIgYW5kIHByb2R1Y2VyIHRyYW5zcG9ydCBvYmplY3RzXG4gICAgICB1cGRhdGVBdWRpb1Byb2R1Y2VyKGF1ZGlvUHJvZHVjZXIpO1xuICAgICAgdXBkYXRlUHJvZHVjZXJUcmFuc3BvcnQocHJvZHVjZXJUcmFuc3BvcnQpO1xuICAgIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgICBjb25zb2xlLmxvZygnY29ubmVjdFNlbmRUcmFuc3BvcnRBdWRpbyBlcnJvcicsIGVycm9yKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/esm2022/lib/consumers/connect-send-transport-screen.service.mjs

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ConnectSendTransportScreen {
+    /**
+     * Connects and sets up the screen sharing transport for sending video streams.
+     *
+     * @param {Object} options - The options for connecting the screen transport.
+     * @param {MediaStream} options.stream - The media stream containing the screen video track.
+     * @param {ConnectSendTransportScreenOptions} options.parameters - The parameters required for setting up the transport.
+     * @param {Producer} options.parameters.screenProducer - The screen producer object.
+     * @param {Device} options.parameters.device - The device object containing RTP capabilities.
+     * @param {Promise<ScreenParams>} options.parameters.screenParams - A promise resolving to screen share parameters.
+     * @param {Transport} options.parameters.producerTransport - The transport object used for producing the screen share.
+     * @param {Params} options.parameters.params - The parameters for producing the screen share.
+     * @param {Function} options.parameters.updateScreenProducer - Function to update the screen producer object.
+     * @param {Function} options.parameters.updateProducerTransport - Function to update the producer transport object.
+     * @param {Function} options.parameters.getUpdatedAllParams - Function to fetch updated device information.
+     *
+     * @returns {Promise<void>} A promise that resolves when the screen transport is successfully connected and set up.
+     *
+     * @throws Will throw an error if the connection or setup process fails.
+     */
+    async connectSendTransportScreen({ stream, parameters, }) {
+        try {
+            let { screenProducer, device, screenParams, producerTransport, params, updateScreenProducer, updateProducerTransport, } = parameters;
+            device = parameters.getUpdatedAllParams().device;
+            // Connect the send transport for screen share by producing screen video data
+            params = screenParams;
+            // Find VP9 codec for screen share
+            if (!device || !device.rtpCapabilities || !device.rtpCapabilities.codecs) {
+                throw new Error('Device or its RTP capabilities are not available.');
+            }
+            let codec = device.rtpCapabilities.codecs.find((codec) => codec.mimeType.toLowerCase() === 'video/vp9' && codec.kind === 'video');
+            // Produce screen share data using the producer transport
+            if (!producerTransport) {
+                throw new Error('Producer transport is not available.');
+            }
+            screenProducer = await producerTransport.produce({
+                track: stream?.getVideoTracks()[0],
+                ...params,
+                codec: codec,
+                appData: { mediaTag: 'screen-video' },
+            });
+            // Update the screen producer and producer transport objects
+            updateScreenProducer(screenProducer);
+            updateProducerTransport(producerTransport);
+        }
+        catch (error) {
+            console.log('connectSendTransportScreen error', error);
+            throw error;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectSendTransportScreen, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectSendTransportScreen, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImport: i0, type: ConnectSendTransportScreen, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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