[mirotalksfu] - refactoring

app/src/Peer.js

@@ -98,12 +98,12 @@ module.exports = class Peer {
     async createProducer(producerTransportId, producer_rtpParameters, producer_kind, producer_type) {
         try {
             if (!producerTransportId) {
-                throw new Error('Invalid producer transport ID');
+                return 'Invalid producer transport ID';
             }
 
             const producerTransport = this.transports.get(producerTransportId);
             if (!producerTransport) {
-                throw new Error(`Producer transport with ID ${producerTransportId} not found`);
+                return `Producer transport with ID ${producerTransportId} not found`;
             }
 
             const producer = await producerTransport.produce({
@@ -112,7 +112,7 @@ module.exports = class Peer {
             });
 
             if (!producer) {
-                throw new Error(`Producer type: ${producer_type} kind: ${producer_kind} not found`);
+                return `Producer type: ${producer_type} kind: ${producer_kind} not found`;
             }
 
             const { id, appData, type, kind, rtpParameters } = producer;
@@ -145,7 +145,7 @@ module.exports = class Peer {
             return producer;
         } catch (error) {
             log.error('Error creating producer', error.message);
-            return null;
+            return error.message;
         }
     }
 
@@ -153,8 +153,8 @@ module.exports = class Peer {
         if (!this.producers.has(producer_id)) return;
         try {
             this.producers.get(producer_id).close();
-        } catch (ex) {
-            log.warn('Close Producer', ex);
+        } catch (error) {
+            log.warn('Close Producer', error.message);
         }
         this.producers.delete(producer_id);
     }
@@ -168,7 +168,7 @@ module.exports = class Peer {
             const consumerTransport = this.transports.get(consumer_transport_id);
 
             if (!consumerTransport) {
-                throw new Error(`Consumer transport with id ${consumer_transport_id} not found`);
+                return `Consumer transport with id ${consumer_transport_id} not found`;
             }
 
             const consumer = await consumerTransport.consume({
@@ -179,7 +179,7 @@ module.exports = class Peer {
             });
 
             if (!consumer) {
-                throw new Error(`Consumer for producer ID ${producer_id} not found`);
+                return `Consumer for producer ID ${producer_id} not found`;
             }
 
             const { id, type, kind, rtpParameters, producerPaused } = consumer;
@@ -224,7 +224,7 @@ module.exports = class Peer {
             };
         } catch (error) {
             log.error('Error creating consumer', error.message);
-            return null;
+            return error.message;
         }
     }
 

app/src/Room.js

@@ -216,22 +216,6 @@ module.exports = class Room {
         return producerList;
     }
 
-    async connectPeerTransport(socket_id, transport_id, dtlsParameters) {
-        try {
-            if (!socket_id || !transport_id || !dtlsParameters) {
-                throw new Error('Invalid input parameters');
-            }
-
-            if (!this.peers.has(socket_id)) {
-                throw new Error(`Peer with socket ID ${socket_id} not found`);
-            }
-
-            await this.peers.get(socket_id).connectTransport(transport_id, dtlsParameters);
-        } catch (error) {
-            log.error('Error connecting peer transport', error.message);
-        }
-    }
-
     async removePeer(socket_id) {
         if (!this.peers.has(socket_id)) return;
         this.peers.get(socket_id).close();
@@ -243,92 +227,103 @@ module.exports = class Room {
     // ####################################################
 
     async createWebRtcTransport(socket_id) {
-        try {
-            if (!socket_id || !this.peers.has(socket_id)) {
-                throw new Error(`Invalid socket ID: ${socket_id}`);
+        if (!this.peers.has(socket_id)) {
+            return this.printError(`[Room|createWebRtcTransport] Invalid socket ID: ${socket_id}`);
+        }
+
+        const { maxIncomingBitrate, initialAvailableOutgoingBitrate, listenInfos } = this.webRtcTransport;
+
+        const webRtcTransportOptions = {
+            ...(this.webRtcServerActive ? { webRtcServer: this.webRtcServer } : { listenInfos }),
+            enableUdp: true,
+            enableTcp: true,
+            preferUdp: true,
+            iceConsentTimeout: 20,
+            initialAvailableOutgoingBitrate,
+        };
+
+        const transport = await this.router.createWebRtcTransport(webRtcTransportOptions);
+
+        if (!transport) {
+            return this.printError('[Room|createWebRtcTransport] Failed to create WebRTC transport');
+        }
+
+        const { id, iceParameters, iceCandidates, dtlsParameters } = transport;
+
+        if (maxIncomingBitrate) {
+            try {
+                await transport.setMaxIncomingBitrate(maxIncomingBitrate);
+            } catch (error) {
+                log.debug('Transport setMaxIncomingBitrate error', error.message);
             }
+        }
 
-            const { maxIncomingBitrate, initialAvailableOutgoingBitrate, listenInfos } = this.webRtcTransport;
+        const peer = this.peers.get(socket_id);
 
-            const webRtcTransportOptions = {
-                ...(this.webRtcServerActive ? { webRtcServer: this.webRtcServer } : { listenInfos }),
-                enableUdp: true,
-                enableTcp: true,
-                preferUdp: true,
-                iceConsentTimeout: 20,
-                initialAvailableOutgoingBitrate,
-            };
+        const { peer_name } = peer;
 
-            const transport = await this.router.createWebRtcTransport(webRtcTransportOptions);
-
-            if (!transport) {
-                throw new Error('Failed to create WebRTC transport');
-            }
-
-            const { id, iceParameters, iceCandidates, dtlsParameters } = transport;
-
-            if (maxIncomingBitrate) {
-                try {
-                    await transport.setMaxIncomingBitrate(maxIncomingBitrate);
-                } catch (error) {
-                    log.debug('Transport setMaxIncomingBitrate error', error.message);
-                }
-            }
-
-            const peer = this.peers.get(socket_id);
-
-            const { peer_name } = peer;
-
-            transport.on('icestatechange', (iceState) => {
-                if (iceState === 'disconnected' || iceState === 'closed') {
-                    log.debug('Transport closed "icestatechange" event', {
-                        peer_name: peer_name,
-                        iceState: iceState,
-                    });
-                    transport.close();
-                    //this.router.close();
-                    //peer.close();
-                }
-            });
-
-            transport.on('sctpstatechange', (sctpState) => {
-                log.debug('Transport "sctpstatechange" event', {
+        transport.on('icestatechange', (iceState) => {
+            if (iceState === 'disconnected' || iceState === 'closed') {
+                log.debug('Transport closed "icestatechange" event', {
                     peer_name: peer_name,
-                    sctpState: sctpState,
+                    iceState: iceState,
                 });
+                transport.close();
+                //this.router.close();
+                //peer.close();
+            }
+        });
+
+        transport.on('sctpstatechange', (sctpState) => {
+            log.debug('Transport "sctpstatechange" event', {
+                peer_name: peer_name,
+                sctpState: sctpState,
             });
+        });
 
-            transport.on('dtlsstatechange', (dtlsState) => {
-                if (dtlsState === 'failed' || dtlsState === 'closed') {
-                    log.debug('Transport closed "dtlsstatechange" event', {
-                        peer_name: peer_name,
-                        dtlsState: dtlsState,
-                    });
-                    transport.close();
-                    //this.router.close();
-                    //peer.close();
-                }
-            });
+        transport.on('dtlsstatechange', (dtlsState) => {
+            if (dtlsState === 'failed' || dtlsState === 'closed') {
+                log.debug('Transport closed "dtlsstatechange" event', {
+                    peer_name: peer_name,
+                    dtlsState: dtlsState,
+                });
+                transport.close();
+                //this.router.close();
+                //peer.close();
+            }
+        });
 
-            transport.on('close', () => {
-                log.debug('Transport closed', { peer_name: peer_name });
-            });
+        transport.on('close', () => {
+            log.debug('Transport closed', { peer_name: peer_name });
+        });
 
-            log.debug('Adding transport', { transportId: id });
+        log.debug('Adding transport', { transportId: id });
 
-            peer.addTransport(transport);
+        peer.addTransport(transport);
 
-            return {
-                params: {
-                    id: id,
-                    iceParameters: iceParameters,
-                    iceCandidates: iceCandidates,
-                    dtlsParameters: dtlsParameters,
-                },
-            };
+        return {
+            id: id,
+            iceParameters: iceParameters,
+            iceCandidates: iceCandidates,
+            dtlsParameters: dtlsParameters,
+        };
+    }
+
+    async connectPeerTransport(socket_id, transport_id, dtlsParameters) {
+        try {
+            if (!socket_id || !transport_id || !dtlsParameters) {
+                return this.printError('[Room|connectPeerTransport] Invalid input parameters');
+            }
+
+            if (!this.peers.has(socket_id)) {
+                return this.printError(`[Room|connectPeerTransport] Peer with socket ID ${socket_id} not found`);
+            }
+
+            await this.peers.get(socket_id).connectTransport(transport_id, dtlsParameters);
+            return '[Room|connectPeerTransport] done';
         } catch (error) {
-            log.error('Error creating WebRTC transport', error.message);
-            return null;
+            log.error('Error connecting peer transport', error.message);
+            return this.printError(`[Room|connectPeerTransport] error: ${error.message}`);
         }
     }
 
@@ -337,41 +332,37 @@ module.exports = class Room {
     // ####################################################
 
     async produce(socket_id, producerTransportId, rtpParameters, kind, type) {
-        try {
-            if (!socket_id || !producerTransportId || !rtpParameters || !kind || !type) {
-                throw new Error('Invalid input parameters');
-            }
-
-            if (!this.peers.has(socket_id)) {
-                throw new Error(`Invalid socket ID: ${socket_id}`);
-            }
-
-            const peer = this.peers.get(socket_id);
-
-            const producer = await peer.createProducer(producerTransportId, rtpParameters, kind, type);
-            if (!producer) {
-                throw new Error('Failed to create producer');
-            }
-
-            const { id } = producer;
-
-            const { peer_name, peer_info } = peer;
-
-            this.broadCast(socket_id, 'newProducers', [
-                {
-                    producer_id: id,
-                    producer_socket_id: socket_id,
-                    peer_name: peer_name,
-                    peer_info: peer_info,
-                    type: type,
-                },
-            ]);
-
-            return id;
-        } catch (error) {
-            console.error('Error producing', error.message);
-            throw error.message;
+        //
+        if (!socket_id || !producerTransportId || !rtpParameters || !kind || !type) {
+            return this.printError('[Room|produce] Invalid input parameters');
         }
+
+        if (!this.peers.has(socket_id)) {
+            return this.printError(`[Room|produce] Invalid socket ID: ${socket_id}`);
+        }
+
+        const peer = this.peers.get(socket_id);
+
+        const peerProducer = await peer.createProducer(producerTransportId, rtpParameters, kind, type);
+        if (!peerProducer || !peerProducer.id) {
+            return this.printError(`[Room|produce] peerProducer error: '${peerProducer}'`);
+        }
+
+        const { id } = peerProducer;
+
+        const { peer_name, peer_info } = peer;
+
+        this.broadCast(socket_id, 'newProducers', [
+            {
+                producer_id: id,
+                producer_socket_id: socket_id,
+                peer_name: peer_name,
+                peer_info: peer_info,
+                type: type,
+            },
+        ]);
+
+        return id;
     }
 
     // ####################################################
@@ -381,7 +372,7 @@ module.exports = class Room {
     async consume(socket_id, consumer_transport_id, producer_id, rtpCapabilities) {
         try {
             if (!socket_id || !consumer_transport_id || !producer_id || !rtpCapabilities) {
-                throw new Error('Invalid input parameters');
+                return this.printError('[Room|consume] Invalid input parameters');
             }
 
             if (!this.router.canConsume({ producerId: producer_id, rtpCapabilities })) {
@@ -390,26 +381,26 @@ module.exports = class Room {
                     consumer_transport_id,
                     producer_id,
                 });
-                return;
+                return this.printError(`[Room|consume] Room router cannot consume producer_id: '${producer_id}'`);
             }
 
             if (!this.peers.has(socket_id)) {
                 log.warn('Peer not found for socket ID', socket_id);
-                return;
+                return this.printError('[Room|consume] Peer not found');
             }
 
             const peer = this.peers.get(socket_id);
 
             const { peer_name } = peer;
 
-            const result = await peer.createConsumer(consumer_transport_id, producer_id, rtpCapabilities);
+            const peerConsumer = await peer.createConsumer(consumer_transport_id, producer_id, rtpCapabilities);
 
-            if (!result || !result.consumer || !result.params) {
-                log.debug('Consumer or params are not defined in createConsumer result');
-                return;
+            if (!peerConsumer || !peerConsumer.consumer || !peerConsumer.params) {
+                log.debug('peerConsumer or params are not defined');
+                return this.printError(`[Room|consume] peerConsumer error: '${peerConsumer}'`);
             }
 
-            const { consumer, params } = result;
+            const { consumer, params } = peerConsumer;
 
             const { id, kind } = consumer;
 
@@ -430,19 +421,13 @@ module.exports = class Room {
             return params;
         } catch (error) {
             log.error('Error occurred during consumption', error.message);
-            return;
+            return this.printError(`[Room|consume] ${error.message}`);
         }
     }
 
     closeProducer(socket_id, producer_id) {
-        try {
-            if (!socket_id || !producer_id || !this.peers.has(socket_id)) {
-                throw new Error('Invalid socket ID or producer ID');
-            }
-            this.peers.get(socket_id).closeProducer(producer_id);
-        } catch (error) {
-            log.error('Error closing producer', error.message);
-        }
+        if (!socket_id || !producer_id || !this.peers.has(socket_id)) return;
+        this.peers.get(socket_id).closeProducer(producer_id);
     }
 
     // ####################################################
@@ -499,6 +484,14 @@ module.exports = class Room {
         this._hostOnlyRecording = status;
     }
 
+    // ####################################################
+    // ERRORS
+    // ####################################################
+
+    printError(message) {
+        return { error: message };
+    }
+
     // ####################################################
     // SENDER
     // ####################################################

app/src/Server.js

@@ -41,7 +41,7 @@ dependencies: {
  * @license For commercial or closed source, contact us at license.mirotalk@gmail.com or purchase directly via CodeCanyon
  * @license CodeCanyon: https://codecanyon.net/item/mirotalk-sfu-webrtc-realtime-video-conferences/40769970
  * @author  Miroslav Pejic - miroslav.pejic.85@gmail.com
- * @version 1.3.92
+ * @version 1.3.93
  *
  */
 
@@ -1001,8 +1001,8 @@ function startServer() {
 
             log.debug('Get RouterRtpCapabilities', getPeerName(room));
             try {
-                const routerRtpCapabilities = room.getRtpCapabilities();
-                callback(routerRtpCapabilities);
+                const getRouterRtpCapabilities = room.getRtpCapabilities();
+                callback(getRouterRtpCapabilities);
             } catch (err) {
                 log.error('Get RouterRtpCapabilities error', err.message);
                 callback({
@@ -1020,8 +1020,8 @@ function startServer() {
 
             log.debug('Create webrtc transport', getPeerName(room));
             try {
-                const { params } = await room.createWebRtcTransport(socket.id);
-                callback(params);
+                const createWebRtcTransport = await room.createWebRtcTransport(socket.id);
+                callback(createWebRtcTransport);
             } catch (err) {
                 log.error('Create WebRtc Transport error', err.message);
                 callback({
@@ -1042,8 +1042,8 @@ function startServer() {
             log.debug('Connect transport', { peer_name: peer_name, transport_id: transport_id });
 
             try {
-                await room.connectPeerTransport(socket.id, transport_id, dtlsParameters);
-                callback('success');
+                const connectTransport = await room.connectPeerTransport(socket.id, transport_id, dtlsParameters);
+                callback(connectTransport);
             } catch (err) {
                 log.error('Connect transport error', err.message);
                 callback({
@@ -1052,7 +1052,7 @@ function startServer() {
             }
         });
 
-        socket.on('produce', async ({ producerTransportId, kind, appData, rtpParameters }, callback) => {
+        socket.on('produce', async ({ producerTransportId, kind, appData, rtpParameters }, callback, errback) => {
             if (!roomList.has(socket.room_id)) {
                 return callback({ error: 'Room not found' });
             }