vani-meeting-server 1.0.0

package/src/sfu/SFUEachRoomUserHandler.ts

@@ -0,0 +1,468 @@
+import { Router } from "mediasoup/node/lib/Router";
+import { BaseSFUWebsocket } from "../base/BaseSFUWebsocket";
+import { Participant } from "../models/Participant";
+import { SFUMessageType } from "../websocket/EachSocketConnectionHandler";
+import { SFUEachRoomHandlerInterface, SFUEachRoomProducer, SFUMessageBody } from "./SFUEachRoomHandler";
+import { WebRtcTransport } from "mediasoup/node/lib/WebRtcTransport";
+import { Transport } from "mediasoup/node/lib/Transport";
+import { Producer } from "mediasoup/node/lib/Producer";
+import { Consumer } from "mediasoup/node/lib/Consumer";
+import webrtcTransportConfiguration from "../utility/Constant";
+
+export class SFUEachRoomUserHandler extends BaseSFUWebsocket {
+
+    private isUserPresentInRoom = true
+    public selfParticipant: Participant
+    public recvRouter?: Router;
+    public sendRouter?: Router;
+    private webrtcSendTransport?: WebRtcTransport
+    private webrtcRecieveTransport?: WebRtcTransport
+    private roomHandlerDataSource?: SFUEachRoomHandlerInterface
+    public producers: Producer[] = []
+    public consumers: Consumer[] = []
+
+    constructor(participant: Participant, sendRouter: Router, recvRouters: Router, roomHandlerDataSource: SFUEachRoomHandlerInterface) {
+        super()
+        this.selfParticipant = participant;
+        this.sendRouter = sendRouter
+        this.recvRouter = recvRouters
+        this.roomHandlerDataSource =  roomHandlerDataSource
+        this.checkAllProducerAndConsuer = this.checkAllProducerAndConsuer.bind(this)
+        this.onConsumeProductId = this.onConsumeProductId.bind(this)
+        this.onReadyToConsume = this.onReadyToConsume.bind(this)
+        this.resumeConsumer = this.resumeConsumer.bind(this)
+        this.pauseConsumer = this.pauseConsumer.bind(this)
+        this.updateSpatialConsumer = this.updateSpatialConsumer.bind(this)
+        this.onTransportProduceSyncRequest = this.onTransportProduceSyncRequest.bind(this)
+        this.onResumeProducer = this.onResumeProducer.bind(this)
+        this.onPauseProducer = this.onPauseProducer.bind(this)
+        this.onNewProducer = this.onNewProducer.bind(this)
+        this.onGetAllProducers = this.onGetAllProducers.bind(this)
+        this.onProducerClosed = this.onProducerClosed.bind(this)
+        this.createWebrtcSendTransport = this.createWebrtcSendTransport.bind(this)
+        this.createWebrtcRecieveTransport = this.createWebrtcRecieveTransport.bind(this)
+        this.connectTransport = this.connectTransport.bind(this)
+        this.onRestartIceCandidate = this.onRestartIceCandidate.bind(this)
+        this.checkAllProducerAndConsuer = this.checkAllProducerAndConsuer.bind(this)
+        this.cleanUp = this.cleanUp.bind(this)
+
+        setTimeout(this.checkAllProducerAndConsuer, 5000)
+    }
+
+    public onNewMessage(payload: SFUMessageBody) {
+        if (payload.type === SFUMessageType.OnCreateTransports) {
+            this.createWebrtcSendTransport(this.selfParticipant)
+            this.createWebrtcRecieveTransport(this.selfParticipant)
+        }
+        else if (payload.type === SFUMessageType.OnTransportConnect) {
+            this.connectTransport(payload)
+        }
+        else if (payload.type === SFUMessageType.OnTransportProduceSyncRequest) {
+            this.onTransportProduceSyncRequest(payload)
+        }
+        else if (payload.type === SFUMessageType.OnReadyToConsume) {
+            this.onReadyToConsume(payload)
+        }
+        else if (payload.type === SFUMessageType.ConsumeProductId) {
+            this.onConsumeProductId(payload)
+        }
+        else if (payload.type === SFUMessageType.ResumeConsumer) {
+            this.resumeConsumer(payload)
+        }
+        else if (payload.type === SFUMessageType.PauseConsumer) {
+            this.pauseConsumer(payload)
+        }
+        else if (payload.type === SFUMessageType.UpdateSpatialConsumer) {
+            this.updateSpatialConsumer(payload)
+        }
+        else if (payload.type === SFUMessageType.OnProducerClosed) {
+            this.onProducerClosed(payload)
+        }
+        else if (payload.type === SFUMessageType.OnResumeProducer) {
+            this.onResumeProducer(payload)
+        }
+        else if (payload.type === SFUMessageType.OnPauseProducer) {
+            this.onPauseProducer(payload)
+        }
+        else if (payload.type === SFUMessageType.OnRestartIceCandidate) {
+            this.onRestartIceCandidate(payload)
+        }
+        else if (payload.type === SFUMessageType.GetAllProducers) {
+            this.onGetAllProducers(payload)
+        }
+        else if (payload.type === SFUMessageType.OnStopProducer) {
+            this.onProducerClosed(payload)
+        }
+
+    }
+
+
+
+    private async onConsumeProductId(payload: SFUMessageBody) {
+        try {
+            if (this.roomHandlerDataSource) {
+
+                const producer = this.roomHandlerDataSource.getProducerById(payload.message.producerId)
+                if (producer && producer.producer.closed === false) {
+
+                    const consumer = await this.webrtcRecieveTransport?.consume(payload.message)
+                    if (consumer) {
+                        consumer.on("producerclose", () => {
+                            console.log("producerclose");
+                            consumer.close()
+                            this.consumers = this.consumers.filter((eachConsumer) => eachConsumer.id !== consumer.id)
+                            const response = { producerId: consumer.producerId }
+                            this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnTrackEnded, response)));
+
+                        })
+                        consumer.on("producerpause", () => {
+                            console.log("producerpause");
+
+                            if (consumer.closed === false) {
+                                consumer.pause()
+                            }
+                        })
+                        consumer.on("producerresume", () => {
+                            console.log("producerresume");
+
+                            if (consumer.closed === false) {
+                                consumer.resume()// To be Done
+                            }
+                        })
+                        consumer.on("@close", () => {
+                            console.log("On closed")
+                            this.consumers = this.consumers.filter((eachConsumer) => eachConsumer.id !== consumer.id)
+                        })
+                        this.consumers.push(consumer)
+                        const consumeData = { consumer: { id: consumer?.id, producerId: consumer?.producerId, kind: consumer?.kind, rtpParameters: consumer?.rtpParameters, appData: consumer?.appData } }
+                        this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnServerConsumer, consumeData)));
+                    }
+                    else {
+                        console.error("Not able to consume")
+                    }
+                }
+                else {
+                    console.error(" onConsumeProductId : Producer not found ", this.selfParticipant.userData.name, payload)
+                }
+            }
+
+        }
+        catch (err) {
+            console.error(" Product Consume Error ", payload)
+            console.error(err)
+        }
+
+
+    }
+
+    private onReadyToConsume(payload: SFUMessageBody) {
+        if (this.roomHandlerDataSource) {
+            this.roomHandlerDataSource.getAllProducerForRoom().forEach((eachRoomProducer: SFUEachRoomProducer) => {
+                if (eachRoomProducer.participant.userId && this.selfParticipant.userId && eachRoomProducer.participant.userId !== this.selfParticipant.userId && eachRoomProducer.producer) {
+                    const producerData = { producer: { id: eachRoomProducer.producer.id, rtpParameters: eachRoomProducer.producer.rtpParameters, appData: eachRoomProducer.producer.appData } }
+                    this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnNewProducer, producerData)));
+                    console.log("On New Producer")
+                }
+            })
+        }
+    }
+
+    private resumeConsumer(payload: SFUMessageBody) {
+        const consumerId = payload.message.id;
+        if (consumerId) {
+            const consumer = this.consumers.find((consumer) => consumer.id === consumerId)
+            if (consumer && consumer.closed === false && consumer?.producerPaused === false) {
+                consumer.resume()
+                console.log("resumeConsumer", this.selfParticipant.userData.name)
+
+            }
+            else if (!consumer) {
+                console.error(" resumeConsumer : Consumer not found ")
+
+            }
+        }
+    }
+    private pauseConsumer(payload: SFUMessageBody) {
+        const consumerId = payload.message.id;
+        if (consumerId) {
+            const consumer = this.consumers.find((consumer) => consumer.id === consumerId)
+            if (consumer && consumer.closed === false) {
+                consumer.pause()
+                console.log("pauseConsumer", this.selfParticipant.userData.name)
+
+            }
+            else if (!consumer) {
+                console.error(" pauseConsumer : Consumer not found ")
+            }
+        }
+    }
+    private updateSpatialConsumer(payload: SFUMessageBody) {
+        const consumerId = payload.message.id;
+        const spatialLayer = payload.message.spatialLayer
+        if (consumerId && spatialLayer !== undefined) {
+            const consumer = this.consumers.find((consumer) => consumer.id === consumerId)
+            if (consumer && consumer.closed === false) {
+                console.log("updateSpatialConsumer consumer", consumer.id)
+
+                try {
+                    consumer.setPreferredLayers({ spatialLayer: spatialLayer })
+                    console.log("consumer.setPreferredLayers", spatialLayer)
+                }
+                catch (err) {
+                    console.error(err)
+                }
+            }
+            else if (!consumer) {
+                console.error(" updateSpatialConsumer : Consumer not found ")
+            }
+        }
+    }
+
+
+
+    private async onTransportProduceSyncRequest(payload: SFUMessageBody) {
+        if (this.roomHandlerDataSource) {
+
+            const producer = await this.webrtcSendTransport?.produce(payload.message)
+
+            if (producer) {
+                await this.onNewProducer(producer)
+                if (producer.kind === 'audio') {
+                    this.roomHandlerDataSource.addAudioObserverForProducer(producer)
+                }
+
+                this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnProduceSyncDone, { transportId: this.webrtcSendTransport?.id, producerId: producer.id, appData: producer.appData })));
+            }
+            else {
+                console.error(" Error in creating producer ", payload)
+            }
+        }
+
+
+    }
+
+    private async onResumeProducer(payload: SFUMessageBody) {
+        const producerId = payload.message.producerId
+        const producer = this.producers.find((eachProducer) => eachProducer.id === producerId)
+        if (producer && producer.closed === false) {
+            producer.resume()
+        }
+    }
+    private async onPauseProducer(payload: SFUMessageBody) {
+        const producerId = payload.message.producerId
+        const producer = this.producers.find((eachProducer) => eachProducer.id === producerId)
+        if (producer && producer.closed === false) {
+            producer.pause()
+        }
+    }
+    private async onNewProducer(producer: Producer) {
+        if (this.roomHandlerDataSource) {
+
+            if (producer.closed === false) {
+                await this.roomHandlerDataSource.pipeToRoute(producer)
+                this.producers.push(producer)
+                this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(false, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnNewProducer, { producer: { id: producer.id, appData: producer.appData } })));
+            }
+        }
+    }
+
+    private async onGetAllProducers(payload: SFUMessageBody) {
+        const producers: Producer[] = []
+        if (this.roomHandlerDataSource) {
+
+            this.roomHandlerDataSource.getAllProducerForRoom().forEach((eachRoomProducer: SFUEachRoomProducer) => {
+                if (eachRoomProducer.participant.userId && this.selfParticipant.userId && eachRoomProducer.participant.userId !== this.selfParticipant.userId && eachRoomProducer.producer) {
+                    producers.push(eachRoomProducer.producer)
+                }
+            })
+            this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnAllProducers, { producers: producers })));
+        }
+
+    }
+    private async onProducerClosed(payload: SFUMessageBody) {
+        const producerId = payload.message.producerId
+        if (producerId) {
+            const producerToBeClosed = this.producers.find((eachProducer) => eachProducer.id === producerId)
+            if (producerToBeClosed) {
+                console.log("onProducerClosed", payload.message)
+                producerToBeClosed.close()
+                const response = { producerId: producerId }
+                this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(false, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnTrackEnded, response)));
+                this.producers = this.producers.filter((eachProducer) => eachProducer.id !== producerId)
+            }
+        }
+
+    }
+
+    private async createWebrtcSendTransport(participant: Participant) {
+        if (!this.sendRouter) {
+            console.error("createWebrtcRecieveTransport no send router found ", participant.roomId!)
+            return
+        }
+
+
+        if (!this.webrtcSendTransport || this.webrtcSendTransport.closed) {
+            this.webrtcSendTransport = await this.sendRouter?.createWebRtcTransport(await webrtcTransportConfiguration())
+            if (this.webrtcSendTransport) {
+                this.webrtcSendTransport!.appData.type = 'send'
+                this.webrtcSendTransport!.appData.userId = participant.userId
+                this.webrtcSendTransport!.appData.participant = participant
+                this.webrtcSendTransport!.on("@newproducer", (produce) => {
+                })
+            }
+            else {
+                console.error("createWebrtcSendTransport Transport not created ", participant.roomId!)
+
+            }
+        }
+        if (this.webrtcSendTransport) {
+            const transportOptionForClient = {
+                iceRole: this.webrtcSendTransport.iceRole,
+                iceParameters: this.webrtcSendTransport.iceParameters,
+                iceCandidates: this.webrtcSendTransport.iceCandidates,
+                iceState: this.webrtcSendTransport.iceState,
+                iceSelectedTuple: this.webrtcSendTransport.iceSelectedTuple,
+                dtlsParameters: this.webrtcSendTransport.dtlsParameters,
+                dtlsState: this.webrtcSendTransport.dtlsState,
+                dtlsRemoteCert: this.webrtcSendTransport.dtlsRemoteCert,
+                sctpParameters: this.webrtcSendTransport.sctpParameters,
+                sctpState: this.webrtcSendTransport.sctpState,
+                id: this.webrtcSendTransport.id,
+                appData: this.webrtcSendTransport.appData
+            }
+            this.redisBroadcastMessageToTopic(participant.userId!, this.preapreClientMessageBody(true, participant, this.preapreWebSocketMessageBody(SFUMessageType.OnSendTransport, { transport: transportOptionForClient })));
+        }
+    }
+    private async createWebrtcRecieveTransport(participant: Participant) {
+        if (!this.recvRouter) {
+            console.error("createWebrtcRecieveTransport no recieve router found ", participant.roomId!)
+            return
+        }
+
+        if (!this.webrtcRecieveTransport || this.webrtcRecieveTransport.closed) {
+            this.webrtcRecieveTransport = await this.sendRouter?.createWebRtcTransport(await webrtcTransportConfiguration())
+            if (this.webrtcRecieveTransport) {
+                this.webrtcRecieveTransport!.appData.type = 'consumer'
+                this.webrtcRecieveTransport!.appData.userId = participant.userId
+                this.webrtcRecieveTransport!.appData.participant = participant
+            }
+            else {
+                console.error("webrtcRecieveTransport Transport not created ", participant.roomId!)
+
+            }
+        }
+        if (this.webrtcRecieveTransport) {
+            const transportOptionForClient = {
+                iceRole: this.webrtcRecieveTransport.iceRole,
+                iceParameters: this.webrtcRecieveTransport.iceParameters,
+                iceCandidates: this.webrtcRecieveTransport.iceCandidates,
+                iceState: this.webrtcRecieveTransport.iceState,
+                iceSelectedTuple: this.webrtcRecieveTransport.iceSelectedTuple,
+                dtlsParameters: this.webrtcRecieveTransport.dtlsParameters,
+                dtlsState: this.webrtcRecieveTransport.dtlsState,
+                dtlsRemoteCert: this.webrtcRecieveTransport.dtlsRemoteCert,
+                sctpParameters: this.webrtcRecieveTransport.sctpParameters,
+                sctpState: this.webrtcRecieveTransport.sctpState,
+                id: this.webrtcRecieveTransport.id,
+                appData: this.webrtcRecieveTransport.appData
+            }
+            this.redisBroadcastMessageToTopic(participant.userId!, this.preapreClientMessageBody(true, participant, this.preapreWebSocketMessageBody(SFUMessageType.OnConsumeTransport, { transport: transportOptionForClient })));
+        }
+    }
+
+
+    private async connectTransport(payload: SFUMessageBody) {
+        let transport;
+        if (payload.message.type && payload.message.type === 'send') {
+            transport = this.webrtcSendTransport
+        }
+        if (payload.message.type && payload.message.type === 'consumer') {
+            transport = this.webrtcRecieveTransport
+        }
+        const dtlsParameters = payload.message.dtlsParameters
+        if (transport) {
+            await transport.connect({ dtlsParameters })
+            this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnTransportConnectDone, { transportId: transport.id })));
+        }
+        else {
+            console.error("connectTransport no transport found ", payload)
+        }
+    }
+
+
+
+    private async onRestartIceCandidate(payload: SFUMessageBody) {
+        const transportId = payload.message.transportId
+        if (transportId) {
+            let transport: WebRtcTransport | undefined = undefined
+            if (this.webrtcRecieveTransport?.id === transportId) {
+                transport = this.webrtcRecieveTransport
+            }
+            else if (this.webrtcSendTransport?.id === transportId) {
+                transport = this.webrtcSendTransport
+            }
+
+            if (transport) {
+                const iceParameters = await transport.restartIce()
+                const response = { iceParameters: iceParameters, transportId: transportId }
+                this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnRestartIceCandidateResponse, response)));
+
+            }
+            else {
+                const response = { transportId: transportId }
+                this.redisBroadcastMessageToTopic(this.selfParticipant.userId!, this.preapreClientMessageBody(true, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnTransportNotFound, response)));
+
+            }
+        }
+    }
+
+    private async checkAllProducerAndConsuer() {
+        if (this.isUserPresentInRoom) {
+            try {
+                // console.log("checkAllProducerAndConsuer")
+                this.producers.forEach((eachProducer) => {
+                    if (eachProducer && eachProducer.closed === true) {
+                        const response = { producerId: eachProducer.id }
+                        this.redisBroadcastMessageToTopic(this.selfParticipant.roomId!, this.preapreClientMessageBody(false, this.selfParticipant, this.preapreWebSocketMessageBody(SFUMessageType.OnTrackEnded, response)));
+                    }
+                })
+
+                this.producers = this.producers.filter((eachProducer) =>
+                    eachProducer.closed === false
+                )
+            }
+            catch (err) {
+                console.error(err)
+            }
+            if (this.isUserPresentInRoom) {
+                setTimeout(this.checkAllProducerAndConsuer, 8000)
+
+
+            }
+        }
+
+    }
+
+    public cleanUp() {
+        this.isUserPresentInRoom = false
+        this.roomHandlerDataSource = undefined
+        this.producers.forEach(producer => {
+            producer.close()
+        });
+        this.consumers.forEach(consumer => {
+            consumer.close()
+        });
+        if (this.webrtcSendTransport) {
+            this.webrtcSendTransport.close()
+            this.webrtcSendTransport = undefined
+        }
+        if (this.webrtcRecieveTransport) {
+            this.webrtcRecieveTransport.close()
+            this.webrtcRecieveTransport = undefined
+        }
+        this.recvRouter = this.sendRouter = undefined
+        this.producers = []
+        this.consumers = []
+    }
+
+}

package/src/sfu/SFUHandler.ts

@@ -0,0 +1,67 @@
+
+import os from 'os';
+import { Worker } from 'mediasoup/node/lib/Worker';
+import { SFUEachRoomHandler } from './SFUEachRoomHandler';
+import { Participant } from '../models/Participant';
+import { ServerHandler } from '../ServerHandler';
+const mediasoup = require("mediasoup");
+
+export class SFUHandler {
+
+    static instance = new SFUHandler()
+    private workers: Worker[] = []
+    private sfuRooms = new Map<string, SFUEachRoomHandler>()
+
+    static getInstance() {
+        return SFUHandler.instance;
+    }
+
+    constructor() {
+        this.init = this.init.bind(this)
+        this.createWorkers = this.createWorkers.bind(this)
+
+    }
+
+
+
+    public async init() {
+
+        await this.createWorkers()
+    }
+
+    public async checkAndSetupRoom(roomId: string) {
+        if (this.sfuRooms.has(roomId) === false) {
+            console.log("On New Room")
+            const sfuEachRoomHandler = new SFUEachRoomHandler(roomId, this.workers, (this.sfuRooms.size % this.workers.length))
+            this.sfuRooms.set(roomId, sfuEachRoomHandler)
+        }
+    }
+
+    public checkIfCanCloseRoom(roomId: string) {
+        const room = this.getRoomSFUHandler(roomId)
+        if (room && room.roomPaticipants.size === 0) {
+            room.cleanUp()
+            this.sfuRooms.delete(roomId)
+        }
+    }
+
+    public getRoomSFUHandler(roomId: string): SFUEachRoomHandler | undefined {
+        if (this.sfuRooms.has(roomId)) {
+            return this.sfuRooms.get(roomId)
+        }
+        else {
+            console.error("No Room Found During SFU Message", roomId)
+        }
+    }
+
+    private async createWorkers() {
+        while (this.workers.length < os.cpus().length) {
+            mediasoup.logLevel = "info"
+            const worker: Worker = await mediasoup.createWorker({ rtcMinPort: ServerHandler.getInstance().serverStartRequest.rtcMinPort, rtcMaxPort: ServerHandler.getInstance().serverStartRequest.rtcMaxPort })
+            worker.updateSettings({ logLevel: "debug" })
+            this.workers.push(worker)
+        }
+
+    }
+
+}

package/src/utility/Constant.ts

@@ -0,0 +1,63 @@
+import { RtpCodecCapability } from "mediasoup/node/lib/RtpParameters";
+import { WebRtcTransportOptions } from "mediasoup/node/lib/WebRtcTransport";
+import { ServerHandler } from "../ServerHandler";
+const publicIp = require('public-ip');
+let publicIpAddress : string | undefined;
+(async () => {
+    publicIpAddress = await publicIp.v4();
+    console.log(publicIpAddress)
+})();
+export const mediaCodecs: RtpCodecCapability[] = [
+    {
+        kind: 'audio',
+        mimeType: 'audio/opus',
+        clockRate: 48000,
+        channels: 2
+    },
+    {
+        kind: 'video',
+        mimeType: 'video/VP8',
+        clockRate: 90000,
+        parameters: {
+            'x-google-start-bitrate': 1000
+        }
+    },
+    {
+        kind: 'video',
+        mimeType: 'video/VP9',
+        clockRate: 90000,
+        parameters: {
+            'profile-id': 2,
+            'x-google-start-bitrate': 1000
+        }
+    },
+    {
+        kind: 'video',
+        mimeType: 'video/h264',
+        clockRate: 90000,
+        parameters: {
+            'packetization-mode': 1,
+            'profile-level-id': '42001f',
+            'level-asymmetry-allowed': 1,
+            'x-google-start-bitrate': 1000
+        }
+    }
+];
+
+
+export default async function webrtcTransportConfiguration() {
+    if(!publicIpAddress){
+        publicIpAddress = await publicIp.v4();
+    }
+    return {
+
+        listenIps: [{ ip: '0.0.0.0', announcedIp: publicIpAddress }],
+        enableUdp: true,
+        enableTcp: true,
+        preferUdp: !ServerHandler.getInstance().serverStartRequest.isTCPConnection ,
+        preferTcp:  ServerHandler.getInstance().serverStartRequest.isTCPConnection,
+        maxSctpMessageSize: 262144 * 10,
+        sctpSendBufferSize: 262144 * 10,
+        enableSctp: true,
+    }
+}

package/src/utility/EventEmitterHandler.ts

@@ -0,0 +1,10 @@
+import { VaniEventListener } from "./VaniEventListener";
+
+export class EventEmitterHandler {
+
+    static instance = new EventEmitterHandler()
+    public vaniEventEmitter : VaniEventListener = new VaniEventListener()
+    static getInstance(): EventEmitterHandler {
+        return EventEmitterHandler.instance;
+    }
+}

package/src/utility/VaniEventListener.ts

@@ -0,0 +1,7 @@
+import * as events from "events";
+
+export class VaniEventListener extends events.EventEmitter {
+  
+}
+
+