vani-meeting-server 1.2.2 → 1.2.4

package/lib/ServerHandler.d.ts

@@ -2,6 +2,15 @@ import { RedisHandler } from "./lib/redis/RedisHandler";
 import { WebSocketServerStartRequest } from "./models/WebSocketServerStartRequest";
 import { SFUHandler } from "./sfu/SFUHandler";
 import { WebSocketHandler } from "./websocket/WebSocketHandler";
+export interface PlainTransportPayload {
+    remoteIpAddress: string;
+    isAudioRequired: boolean;
+    isVideoRequired: boolean;
+    audioPort: number;
+    audioRtcpPort: number;
+    videoPort: number;
+    videoRtcpPort: number;
+}
 export declare class ServerHandler {
     serverStartRequest: WebSocketServerStartRequest;
     rediHandler?: RedisHandler;
@@ -11,4 +20,5 @@ export declare class ServerHandler {
     static getInstance(): ServerHandler;
     constructor();
     initWithServerStartRequest(serverStartRequest: WebSocketServerStartRequest): Promise<void>;
+    startPlainTransportForBroadcasting(plainTransportPayload: PlainTransportPayload, forRoomid: string): Promise<void>;
 }

package/lib/ServerHandler.js

@@ -29,5 +29,7 @@ class ServerHandler {
         this.sfuHandler = SFUHandler_1.SFUHandler.getInstance();
         this.sfuHandler.init();
     }
+    async startPlainTransportForBroadcasting(plainTransportPayload, forRoomid) {
+    }
 }
 exports.ServerHandler = ServerHandler;

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export * from './models/Event';
 export * from './models/WebSocketServerStartRequest';
 export * from './ServerHandler';
+export * from './utility/EventEmitterHandler';

package/lib/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./models/Event"), exports);
 __exportStar(require("./models/WebSocketServerStartRequest"), exports);
 __exportStar(require("./ServerHandler"), exports);
+__exportStar(require("./utility/EventEmitterHandler"), exports);

package/lib/models/Event.d.ts

@@ -4,7 +4,8 @@ export declare enum VaniEvent {
     OnNewMeetingEnded = "onNewMeetingEnded",
     OnUserJoined = "onUserJoined",
     OnUserLeft = "onUserLeft",
-    OnServerStarted = "onServerStarted"
+    OnServerStarted = "onServerStarted",
+    OnPlainTransportCreated = "onPlainTransportCreated"
 }
 interface VaniConnectionEvents {
     [VaniEvent.OnNewMeetingStarted]: (roomId: string) => any;
@@ -12,6 +13,7 @@ interface VaniConnectionEvents {
     [VaniEvent.OnUserJoined]: (participant: Participant) => any;
     [VaniEvent.OnUserLeft]: (participant: Participant) => any;
     [VaniEvent.OnServerStarted]: () => any;
+    [VaniEvent.OnPlainTransportCreated]: () => any;
 }
 export declare interface VaniEventListener {
     on<U extends keyof VaniConnectionEvents>(event: U, listener: VaniConnectionEvents[U]): this;

package/lib/models/Event.js

@@ -8,4 +8,5 @@ var VaniEvent;
     VaniEvent["OnUserJoined"] = "onUserJoined";
     VaniEvent["OnUserLeft"] = "onUserLeft";
     VaniEvent["OnServerStarted"] = "onServerStarted";
+    VaniEvent["OnPlainTransportCreated"] = "onPlainTransportCreated";
 })(VaniEvent = exports.VaniEvent || (exports.VaniEvent = {}));

package/lib/sfu/SFUEachRoomHandler.d.ts

@@ -4,6 +4,7 @@ import { Router } from "mediasoup/node/lib/Router";
 import { Worker } from "mediasoup/node/lib/Worker";
 import { BaseSFUWebsocket } from "../base/BaseSFUWebsocket";
 import { Participant } from "../models/Participant";
+import { PlainTransportPayload } from "../ServerHandler";
 import { SFUMessageType } from "../websocket/EachSocketConnectionHandler";
 import { SFUEachRoomUserHandler } from "./SFUEachRoomUserHandler";
 export interface SFUEachRoomParticipantInterface {
@@ -37,6 +38,7 @@ export declare class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUE
     roomPaticipants: Map<string, SFUEachRoomUserHandler>;
     private plainTransportForAudio?;
     private plainTransportForVideo?;
+    private plainTransportConsumers;
     private workers?;
     private sendWorkerIndex;
     private audioObserver?;
@@ -56,6 +58,8 @@ export declare class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUE
     onNewProducer(producer: Producer, participant: Participant): Promise<void>;
     addAudioObserverForProducer(audioProducer: Producer): Promise<void>;
     onUserLeft(participant: Participant): void;
-    private startBroadcasting;
+    resumeAllBroadcastingConsumers(): Promise<void>;
+    startBroadcasting(plainTransportPayload: PlainTransportPayload): Promise<void>;
+    private consumeProducerForPlainTransport;
     cleanUp(): void;
 }

package/lib/sfu/SFUEachRoomHandler.js

@@ -38,6 +38,7 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
     roomPaticipants = new Map();
     plainTransportForAudio;
     plainTransportForVideo;
+    plainTransportConsumers = [];
     workers;
     sendWorkerIndex = -1;
     audioObserver;
@@ -54,9 +55,9 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         if (payload.type === EachSocketConnectionHandler_1.SFUMessageType.GetRouterRtpCapabilities) {
             this.onGetRTPCapabilities(participant);
         }
-        else if (payload.type === EachSocketConnectionHandler_1.SFUMessageType.StartBroadcasting) {
-            this.startBroadcasting(payload);
-        }
+        // else if (payload.type === SFUMessageType.StartBroadcasting) {
+        //     this.startBroadcasting(payload)
+        // }
         else {
             const sfuEachRoomUser = this.getEachRoomUserFromParticipant(participant);
             if (sfuEachRoomUser) {
@@ -186,18 +187,10 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
     async onNewProducer(producer, participant) {
         if (producer && producer.closed === false) {
             if (this.plainTransportForAudio && producer.kind === "audio") {
-                this.plainTransportForAudio.consume({
-                    producerId: producer.id,
-                    rtpCapabilities: this.sendRouter.rtpCapabilities,
-                    paused: false,
-                });
+                this.consumeProducerForPlainTransport(this.plainTransportForAudio, producer);
             }
             else if (this.plainTransportForVideo && producer.kind === "video") {
-                this.plainTransportForVideo.consume({
-                    producerId: producer.id,
-                    rtpCapabilities: this.sendRouter.rtpCapabilities,
-                    paused: false,
-                });
+                this.consumeProducerForPlainTransport(this.plainTransportForVideo, producer);
             }
         }
     }
@@ -213,61 +206,79 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
             this.roomPaticipants.delete(participant.userId);
         }
     }
-    async startBroadcasting(payload) {
+    async resumeAllBroadcastingConsumers() {
+        this.plainTransportConsumers.forEach((eachConsumer) => {
+            if (eachConsumer && eachConsumer.closed === false) {
+                try {
+                    eachConsumer.resume();
+                }
+                catch (err) {
+                }
+            }
+        });
+    }
+    async startBroadcasting(plainTransportPayload) {
+        //Create Plain Transport
         console.log("=====startBroadcasting=======");
-        console.log(payload);
+        console.log(plainTransportPayload);
         console.log("=====startBroadcasting=======");
-        const isAudioRequired = payload.message.isAudioRequired;
-        const isVideoRequired = payload.message.isVideoRequired;
-        const connectToIp = payload.message.connectToIp;
+        const isAudioRequired = plainTransportPayload.isAudioRequired;
+        const isVideoRequired = plainTransportPayload.isVideoRequired;
+        const connectToIp = plainTransportPayload.remoteIpAddress;
         if (isAudioRequired && this.plainTransportForAudio === undefined) {
             this.plainTransportForAudio = await this.sendRouter?.createPlainTransport(await Constant_1.default.plainTransportConfiguration());
             if (this.plainTransportForAudio) {
-                const port = payload.message.audio.port;
-                const rtcpPort = payload.message.audio.rtcpPort;
+                const port = plainTransportPayload.audioPort;
+                const rtcpPort = plainTransportPayload.audioRtcpPort;
                 await this.plainTransportForAudio.connect({
                     ip: connectToIp,
                     port: port,
                     rtcpPort: rtcpPort,
                 });
-                this.getAllProducerForRoom().forEach((eachRoomProducer) => {
-                    if (eachRoomProducer && eachRoomProducer.producer && eachRoomProducer.producer.closed === false && eachRoomProducer.producer.kind === 'audio') {
-                        try {
-                            this.plainTransportForAudio?.consume({
-                                producerId: eachRoomProducer.producer.id,
-                                rtpCapabilities: this.sendRouter.rtpCapabilities,
-                                paused: false,
-                            });
-                        }
-                        catch (err) {
-                        }
-                    }
-                });
             }
+            this.getAllProducerForRoom().forEach((eachRoomProducer) => {
+                if (this.plainTransportForAudio && eachRoomProducer && eachRoomProducer.producer && eachRoomProducer.producer.kind === 'audio') {
+                    try {
+                        this.consumeProducerForPlainTransport(this.plainTransportForAudio, eachRoomProducer.producer);
+                    }
+                    catch (err) {
+                    }
+                }
+            });
         }
         if (isVideoRequired && this.plainTransportForVideo === undefined) {
             this.plainTransportForVideo = await this.sendRouter?.createPlainTransport(await Constant_1.default.plainTransportConfiguration());
             if (this.plainTransportForVideo) {
-                const port = payload.message.video.port;
-                const rtcpPort = payload.message.video.rtcpPort;
+                const port = plainTransportPayload.videoPort;
+                const rtcpPort = plainTransportPayload.videoRtcpPort;
                 await this.plainTransportForVideo.connect({
                     ip: connectToIp,
                     port: port,
                     rtcpPort: rtcpPort,
                 });
-                this.getAllProducerForRoom().forEach((eachRoomProducer) => {
-                    if (eachRoomProducer && eachRoomProducer.producer && eachRoomProducer.producer.closed === false && eachRoomProducer.producer.kind === 'video') {
-                        try {
-                            this.plainTransportForVideo?.consume({
-                                producerId: eachRoomProducer.producer.id,
-                                rtpCapabilities: this.sendRouter.rtpCapabilities,
-                                paused: false,
-                            });
-                        }
-                        catch (err) {
-                        }
+            }
+            this.getAllProducerForRoom().forEach((eachRoomProducer) => {
+                if (this.plainTransportForVideo && eachRoomProducer && eachRoomProducer.producer && eachRoomProducer.producer.kind === 'video') {
+                    try {
+                        this.consumeProducerForPlainTransport(this.plainTransportForVideo, eachRoomProducer.producer);
                     }
-                });
+                    catch (err) {
+                    }
+                }
+            });
+        }
+        EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.emit(Event_1.VaniEvent.OnPlainTransportCreated, {});
+    }
+    async consumeProducerForPlainTransport(plainTransport, producer) {
+        if (producer && producer.closed === false && this.sendRouter && this.sendRouter.rtpCapabilities) {
+            try {
+                this.plainTransportConsumers.push(await plainTransport.consume({
+                    producerId: producer.id,
+                    rtpCapabilities: this.sendRouter.rtpCapabilities,
+                    paused: true,
+                }));
+            }
+            catch (err) {
             }
         }
     }
@@ -278,6 +289,22 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         this.roomPaticipants.forEach((sfuEachRoomUser) => {
             this.onUserLeft(sfuEachRoomUser.selfParticipant);
         });
+        this.plainTransportConsumers.forEach((eachConsumer) => {
+            try {
+                eachConsumer.close();
+            }
+            catch (err) {
+            }
+        });
+        this.plainTransportConsumers = [];
+        if (this.plainTransportForAudio) {
+            this.plainTransportForAudio.close();
+            this.plainTransportForAudio = undefined;
+        }
+        if (this.plainTransportForVideo) {
+            this.plainTransportForVideo.close();
+            this.plainTransportForVideo = undefined;
+        }
         this.recvRouter.forEach((eachRouter) => {
             eachRouter.close();
         });

package/lib/sfu/SFUHandler.d.ts

@@ -1,4 +1,5 @@
 import { SFUEachRoomHandler } from './SFUEachRoomHandler';
+import { PlainTransportPayload } from '../ServerHandler';
 export declare class SFUHandler {
     static instance: SFUHandler;
     private workers;
@@ -9,5 +10,6 @@ export declare class SFUHandler {
     checkAndSetupRoom(roomId: string): Promise<void>;
     checkIfCanCloseRoom(roomId: string): void;
     getRoomSFUHandler(roomId: string): SFUEachRoomHandler | undefined;
+    startPlainTransportForBroadcasting(plainTransportPayload: PlainTransportPayload, forRoomid: string): Promise<void>;
     private createWorkers;
 }

package/lib/sfu/SFUHandler.js

@@ -64,6 +64,12 @@ class SFUHandler {
             console.error("No Room Found During SFU Message", roomId);
         }
     }
+    async startPlainTransportForBroadcasting(plainTransportPayload, forRoomid) {
+        const sfuEachRoomHandler = this.getRoomSFUHandler(forRoomid);
+        if (sfuEachRoomHandler) {
+            sfuEachRoomHandler.startBroadcasting(plainTransportPayload);
+        }
+    }
     async createWorkers() {
         while (this.workers.length < os.cpus().length) {
             mediasoup.logLevel = "info";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vani-meeting-server",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Vani Meeting Server SDK",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",