sceyt-call 1.0.0

package/src/classes/internal-call-handler/index.ts

@@ -0,0 +1,764 @@
+import {
+    ConnectionState,
+    ICallEvents,
+    ICallEventType,
+    ICallParticipantsRTCMap,
+    IJoinSignalMessage,
+    IOfferSignalMessage,
+    ISignalMessageResponse,
+    PresenceState
+} from "../../types";
+import { Participant } from "../participant";
+import { WebRTCClient } from "../webrtcClient";
+import { Signaling } from "../signaling";
+import { INFO_MESSAGE, SIGNAL } from "../../constants";
+import { CALL_TYPE } from "../../enum";
+import { Call } from "../call";
+import { getEmptyVideoTrack, makeFirstById } from "../../helpers";
+import logger from "../../utils/logger";
+
+export class InternalCallHandler {
+    private static instance: InternalCallHandler | null = null;
+    private readonly chatClient: any;
+    private rtcConfig?: RTCConfiguration;
+    private callParticipantsRTCMap: ICallParticipantsRTCMap = {};
+    private readonly signalingClient: Signaling;
+    activeCalls: Call[] = [];
+    private callEvents: ICallEvents = {};
+    private readonly user: any;
+
+    constructor(chatClient: any) {
+        if (!chatClient) {
+            logger.info('ChatClient is required for InternalCallHandler initialization');
+        }
+        this.chatClient = chatClient;
+        this.user = chatClient.user;
+        this.signalingClient = new Signaling(chatClient, this.handleSignalMessage.bind(this));
+    }
+
+    public static initialize(chatClient: any): InternalCallHandler {
+        if (!InternalCallHandler.instance) {
+            InternalCallHandler.instance = new InternalCallHandler(chatClient);
+        }
+        return InternalCallHandler.instance;
+    }
+
+    public static getInstance(): InternalCallHandler | null {
+        if (!InternalCallHandler.instance) {
+            logger.info('InternalCallHandler not initialized. Call initialize() with chatClient first.');
+            return null;
+        }
+        return InternalCallHandler.instance;
+    }
+
+    public static hasInstance(): boolean {
+        return InternalCallHandler.instance !== null;
+    }
+
+    public static reset(): void {
+        InternalCallHandler.instance = null;
+    }
+
+    public setCallEvent(eventType: ICallEventType, callback: (...args: any) => void): void {
+        this.callEvents[eventType] = callback;
+    }
+
+    private async handleSignalMessage(message: ISignalMessageResponse): Promise<void> {
+        if (!this.activeCalls) return;
+
+        const call = this.activeCalls.find((call) => call.id === message.roomId);
+        if (!call) return;
+
+        try {
+            switch (message.signal) {
+                case SIGNAL.OFFER:
+                    await this.handleOffer(call, message);
+                    break;
+                case SIGNAL.ANSWER:
+                    await this.handleAnswer(call, message);
+                    break;
+                case SIGNAL.USER_JOINED:
+                    await this.handleUserJoined(call, message);
+                    break;
+                case SIGNAL.LEAVE:
+                    await this.handleLeave(call, message);
+                    break;
+                case SIGNAL.INVITE:
+                    await this.handleInvite(message);
+                    break;
+                default:
+                    logger.warn(`Unhandled signal type: ${message.signal}`);
+            }
+        } catch (error) {
+            logger.error(`Error handling signal ${message.signal}:`, error);
+            this.handleSignalingError(call, error);
+        }
+    }
+
+    private async handleOffer(call: Call, message: ISignalMessageResponse): Promise<void> {
+        if (call.state !== "connected") return;
+
+        const participant = call.participants.find((p) => p.id === message.from);
+        if (!participant) return;
+
+        try {
+            if (call.mediaFlow === "p2p") {
+                await this.addTracksToPeerConnection(call, participant.id);
+            }
+
+            if (participant.shouldResetPC) {
+                await this.resetPeerConnection(call, participant);
+            }
+
+            await this.setRemoteDescription(call.id, participant.id, {
+                sdp: message.sdp,
+                type: "offer"
+            });
+
+            const answer = await this.callParticipantsRTCMap[call.id][participant.id].createAnswer();
+            await this.setLocalDescription(call.id, participant.id, answer);
+
+            await this.signalingClient.sendSignalMessage({
+                to: message.from,
+                callType: message.type,
+                roomId: call.id,
+                signal: SIGNAL.ANSWER,
+                sdp: answer.sdp,
+                sessionId: message.sessionId
+            });
+        } catch (error) {
+            logger.error('Error handling offer:', error);
+            participant.handleEvent("CALL_DISCONNECTED");
+            throw error;
+        }
+    }
+
+    private async resetPeerConnection(call: Call, participant: Participant): Promise<void> {
+        this.closePeerConnections(call.id, participant.id);
+        this.addParticipantToRTCMap(call, participant);
+        participant.setShouldResetPC(false);
+    }
+
+    private handleSignalingError(call: Call, error: any): void {
+        logger.error('Signaling error:', error);
+        // Implement appropriate error recovery logic
+        if (call.state === "connected") {
+            call.setState("reconnecting");
+            // Attempt to recover the connection
+            this.attemptConnectionRecovery(call).catch(e =>
+                logger.error('Failed to recover connection:', e)
+            );
+        }
+    }
+
+    private async attemptConnectionRecovery(call: Call): Promise<void> {
+        // Wait a bit before attempting recovery
+        await new Promise(resolve => setTimeout(resolve, 2000));
+
+        try {
+            // Attempt to re-establish connections for all participants
+            for (const participant of call.participants) {
+                if (participant.id !== this.user.id) {
+                    await this.resetPeerConnection(call, participant);
+                    // Create new offer for the participant
+                    const desc = await this.callParticipantsRTCMap[call.id][participant.id].createOffer();
+                    await this.setLocalDescription(call.id, participant.id, desc);
+                    await this.sendOffer({
+                        callType: CALL_TYPE.group,
+                        callId: call.id,
+                        description: desc,
+                        to: participant.id,
+                        sessionId: call.sessionId,
+                    });
+                }
+            }
+        } catch (error) {
+            logger.error('Recovery attempt failed:', error);
+            call.setState("idle"); // Reset to idle state on complete failure
+            // Notify about the failed recovery
+            call.onCallStateChanged(call, "Failed to recover connection");
+        }
+    }
+
+    private async handleAnswer(call: Call, message: ISignalMessageResponse): Promise<void> {
+        if (call.state !== "connected") return;
+
+        try {
+            let participant;
+            if (call.serverParticipant && call.serverParticipant.id === message.from) {
+                participant = call.serverParticipant;
+                
+                // For group calls, when server answers, set local participant to connected
+                if (call.mediaFlow !== "p2p") {
+                    logger.info("Setting local participant to connected in group call");
+                    call.localParticipant.handleEvent("CALL_CONNECTED");
+                }
+            } else {
+                participant = call.participants.find((p) => p.id === message.from);
+            }
+            
+            if (participant) {
+                await this.setRemoteDescription(call.id, participant.id, {
+                    sdp: message.sdp,
+                    type: "answer"
+                });
+                
+                if (call.mediaFlow !== "p2p") {
+                    message.participants?.forEach((p) => {
+                        if (p.id !== this.user.id) {
+                            logger.info("Send CONNECT to participant: ", p.id);
+                            this.signalingClient.sendSignalMessage({
+                                to: p.id,
+                                callType: message.type,
+                                roomId: call.id,
+                                signal: SIGNAL.CONNECT,
+                                sessionId: call.sessionId
+                            });
+                        }
+                    });
+                    
+                    // Set server participant to connected state
+                    participant.handleEvent("CALL_CONNECTED");
+                }
+                
+                call.setState("connected");
+            }
+        } catch (error) {
+            logger.error('Error handling answer:', error);
+        }
+    }
+
+    private async handleUserJoined(call: Call, message: ISignalMessageResponse): Promise<void> {
+        logger.info("handle user joined", message);
+        const participant = call.participants.find((p) => p.id === message.from);
+        if (participant) {
+            // Follow the correct state transition flow
+            participant.handleEvent("CALL_INVITED");  // Pending -> Invited
+            participant.handleEvent("CALL_RINGING"); // Invited -> Ringing
+            participant.handleEvent("CALL_ACCEPTED"); // Ringing -> Joined
+            
+            if (message.videoEnabled) {
+                participant.setVideoEnabled(true);
+                call.setVideoEnabled(true);
+            }
+            
+            if (call.mediaFlow === "p2p") {
+                this.addParticipantToRTCMap(call, participant);
+                this.addTracksToPeerConnection(call, participant.id);
+                const desc = await this.createOffer(call.id, participant.id);
+                await this.setLocalDescription(call.id, participant.id, desc);
+                await this.sendOffer({
+                    callType: CALL_TYPE.p2p,
+                    callId: call.id,
+                    to: participant.id,
+                    description: desc,
+                    sessionId: call.sessionId,
+                });
+            }
+        }
+    }
+
+    private async handleLeave(call: Call, message: ISignalMessageResponse): Promise<void> {
+        logger.info("handle leave", message);
+        const participant = call.participants.find((p) => p.id === message.from);
+        if (participant) {
+            participant.setPresenceState(PresenceState.Left);
+            participant.setConnectionState(ConnectionState.Disconnected);
+            call.onParticipantStateChanged(call, participant, ConnectionState.Disconnected);
+            call.kickParticipantFromList(participant);
+            call.onParticipantLeft(call, participant);
+            this.closePeerConnections(call.id, participant.id);
+        }
+    }
+
+    private async handleInvite(message: ISignalMessageResponse): Promise<void> {
+        logger.info("handle invite", message);
+        if (!message.participants) {
+            logger.error("No participants in invite message");
+            return;
+        }
+
+        const call = new Call({
+            id: message.roomId,
+            sessionId: message.sessionId,
+            mediaFlow: message.type === CALL_TYPE.group ? "sfu" : "p2p",
+            originatorId: message.from,
+            localParticipant: new Participant(this.user.id),
+            participants: message.participants.map((p: any) => new Participant(p.id)),
+        });
+
+        // Set initial states for all participants using events
+        call.participants.forEach(participant => {
+            if (participant.id === message.from) {
+                // Originator follows Pending -> Invited -> Ringing -> Joined
+                participant.handleEvent("CALL_INVITED");
+                participant.handleEvent("CALL_RINGING");
+                participant.handleEvent("CALL_ACCEPTED");
+            } else if (participant.id === this.user.id) {
+                // Local user is being invited: Pending -> Invited
+                participant.handleEvent("CALL_INVITED");
+            } else {
+                // Other participants start in Pending state
+                // They will receive CALL_INVITED when they get the invite signal
+            }
+        });
+
+        this.activeCalls.push(call);
+        if (this.callEvents.onInvitedToCall) {
+            this.callEvents.onInvitedToCall(call);
+        }
+
+        // Send ringing signal for the local participant
+        await this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            signal: SIGNAL.RINGING,
+            sessionId: call.sessionId,
+            participantIds: [message.from] // Send ringing only to the originator
+        });
+
+        // Update local participant state to ringing
+        call.localParticipant.handleEvent("CALL_RINGING");
+    }
+
+    setRTCConfig(config: RTCConfiguration) {
+        this.rtcConfig = config;
+    }
+
+    private onIceCandidate = (participant: Participant, e: RTCPeerConnectionIceEvent, call: Call) => {
+        if (e.candidate) {
+            try {
+                this.signalingClient.sendSignalMessage({
+                    to: participant.id,
+                    signal: SIGNAL.ICE,
+                    callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+                    roomId: call.id,
+                    sessionId: call.sessionId,
+                    ice: {
+                        candidate: e.candidate.candidate,
+                        sdpMid: e.candidate.sdpMid || "",
+                        sdpMLineIndex: e.candidate.sdpMLineIndex || 0,
+                    },
+                });
+            } catch (e) {
+                logger.info("Failed to send ice: ", e);
+            }
+            /*  .then((res: any) => {
+                                                    logger.info("ice res: ", res);
+                                                  })
+                                                  .catch((e: any) => {
+                                                    logger.info("error ice:", e);
+                                                  });*/
+        }
+    };
+
+    private onTrack = (call: Call, participant: Participant, e: any) => {
+        if (e.track.kind === "audio") {
+            participant.setAudioTracks([e.track]);
+            call.onParticipantAudioTrackAdded(call, participant, e.track);
+        } else if (e.track.kind === "video") {
+            participant.setVideoTracks([e.track]);
+            if (call.videoEnabled && !participant.videoEnabled) {
+                participant.setVideoEnabled(true);
+                call.setVideoEnabled(true);
+            }
+            call.onParticipantVideoTrackAdded(call, participant, e.track);
+        }
+    };
+
+    onIceCandidateListener(participant: Participant, call: Call) {
+        return (e: any) => {
+            this.onIceCandidate(participant, e, call);
+        };
+    }
+
+    onSignalingStateChangeListener(participant: Participant) {
+        return () => {
+            logger.info(`PC signalingstatechange, participant: ${participant.id}`);
+        };
+    }
+
+    onIceConnectionStateChangeListener(participant: Participant, call: Call, client: WebRTCClient) {
+        return () => {
+            const state = client.peerConnection.iceConnectionState;
+            logger.info("Ice connection state changed to: ", state);
+            switch (state) {
+                case "checking":
+                    participant.setConnectionState(ConnectionState.Connecting);
+                    call.onParticipantStateChanged(call, participant, ConnectionState.Connecting);
+                    break;
+                case "connected":
+                    participant.setConnectionState(ConnectionState.Connected);
+                    call.onParticipantStateChanged(call, participant, ConnectionState.Connected);
+                    break;
+                case "disconnected":
+                    participant.setConnectionState(ConnectionState.Reconnecting);
+                    call.onParticipantStateChanged(call, participant, ConnectionState.Reconnecting);
+                    break;
+                case "failed":
+                case "closed":
+                    participant.setConnectionState(ConnectionState.Disconnected);
+                    call.onParticipantStateChanged(call, participant, ConnectionState.Disconnected);
+                    break;
+                default:
+                    break;
+            }
+        };
+    }
+
+    onTrackListener(call: Call, participant: Participant) {
+        return (event: any) => {
+            logger.info(`PC track, participant: ${participant.id}`);
+            this.onTrack(call, participant, event);
+        };
+    }
+
+    private closePeerConnections(callId: string, participantId: string) {
+        logger.info("close  peer connection >>.... callId ,, ", callId, "participantId: ", participantId);
+        logger.info("this.callParticipantsRTCMap >>.... ", this.callParticipantsRTCMap);
+        logger.info("this.callParticipantsRTCMap[callId] >>.... ", this.callParticipantsRTCMap[callId]);
+        const webrtcClient = this.callParticipantsRTCMap[callId] && this.callParticipantsRTCMap[callId][participantId];
+        logger.info("webrtcClient. . . . ", webrtcClient);
+        if (webrtcClient) {
+            if (webrtcClient.listeners) {
+                logger.info("webrtcClient.listeners: ", webrtcClient.listeners);
+                logger.info("Object.keys(webrtcClient.listeners): ", Object.keys(webrtcClient.listeners));
+                Object.keys(webrtcClient.listeners).forEach((listener) => {
+                    logger.info("close listener: ", listener);
+                    webrtcClient.removeEventListener(listener, webrtcClient.listeners[listener]);
+                });
+            }
+            webrtcClient.close();
+            // @ts-ignore
+            this.callParticipantsRTCMap[callId][participantId] = null;
+            delete this.callParticipantsRTCMap[callId][participantId];
+        }
+    }
+
+    addParticipantToRTCMap(call: Call, participant: Participant) {
+        if (!this.callParticipantsRTCMap[call.id]) {
+            this.callParticipantsRTCMap[call.id] = {};
+        }
+        // this.callParticipantsRTCMap[call.id][participant.id] = new WebrtcClient(this.rtcConfig);
+        const webrtcClient = new WebRTCClient(this.rtcConfig);
+        this.callParticipantsRTCMap[call.id][participant.id] = webrtcClient;
+        const iceCandidateListener = this.onIceCandidateListener(participant, call);
+        const signalingStateChangeListener = this.onSignalingStateChangeListener(participant);
+        const iceConnectionStateChangeListener = this.onIceConnectionStateChangeListener(participant, call, webrtcClient);
+        const trackListener = this.onTrackListener(call, participant);
+        webrtcClient.addEventListener("icecandidate", iceCandidateListener);
+        webrtcClient.addEventListener("signalingstatechange", signalingStateChangeListener);
+        webrtcClient.addEventListener("connectionstatechange", iceConnectionStateChangeListener);
+        webrtcClient.addEventListener("track", trackListener);
+        webrtcClient.setListeners({
+            iceCandidateListener,
+            signalingStateChangeListener,
+            iceConnectionStateChangeListener,
+            trackListener,
+        });
+
+        logger.info("webrtcClient: set to callParticipantsRTCMap", call.id, " participant.id. .. ", participant.id);
+        logger.info("webrtcClient: ", webrtcClient);
+
+        /*  this.callParticipantsRTCMap[call.id][participant.id].addEventListener(
+                            "icecandidate",
+                            (e: RTCPeerConnectionIceEvent) => this.onIceCandidate(participant, e, call),
+                        );
+                        this.callParticipantsRTCMap[call.id][participant.id].addEventListener("signalingstatechange", (event: any) => {
+                            logger.info(`PC signalingstatechange: ${event}, participant: ${participant.id}`);
+                        });
+
+                        this.callParticipantsRTCMap[call.id][participant.id].addEventListener("connectionstatechange", (event: any) => {
+                            logger.info(
+                                "PC connectionstatechange:",
+                                event.currentTarget.connectionState,
+                                "  participant: .. ",
+                                participant.id,
+                            );
+                            participant.setState(event.currentTarget.connectionState);
+                            call.onParticipantStateChanged(call, participant, event.currentTarget.connectionState);
+                        });
+
+                        this.callParticipantsRTCMap[call.id][participant.id].addEventListener("track", (event: any) => {
+                            logger.info(`PC track: ${event}, participant: ${participant.id}`);
+                            this.onTrack(call!, participant, event);
+                        });*/
+        return participant;
+    }
+
+    joinToCall(options: IJoinSignalMessage) {
+        return this.signalingClient.sendSignalMessage({
+            callType: options.callType,
+            roomId: options.roomId,
+            ...(options.sessionId && { sessionId: options.sessionId }),
+            signal: SIGNAL.JOIN,
+            participantIds: options.participantIds,
+            videoEnabled: options.videoEnabled,
+        });
+    }
+
+    sendRinging(call: Call) {
+        return this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            sessionId: call.sessionId,
+            signal: SIGNAL.RINGING,
+            participantIds: call.participants.map((participant) => participant.id),
+        });
+    }
+
+    rejectCall(call: Call, reason?: string) {
+        call.localParticipant.handleEvent("CALL_DECLINED");
+        this.activeCalls = this.activeCalls.filter((activeCall) => activeCall.id !== call.id);
+        return this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            sessionId: call.sessionId,
+            signal: SIGNAL.DECLINE,
+            participantIds: call.participants.map((participant) => participant.id),
+            message: reason || "",
+        });
+    }
+
+    private closeCall(call: Call) {
+        logger.info('Handle close call. .... ')
+        logger.info('call.localAudioTracks. .... ', call.localAudioTracks)
+        call.localAudioTracks.forEach((track) => {
+            track.stop();
+        });
+        logger.info('call.localVideoTracks.  .. ', call.localVideoTracks)
+        call.localVideoTracks.forEach((track) => {
+            track.stop();
+        });
+        call.participants.forEach((participant) => {
+            this.closePeerConnections(call.id, participant.id);
+        });
+
+        const callIndex = this.activeCalls.findIndex((call) => call.id === call.id);
+        this.activeCalls.splice(callIndex, 1);
+        delete this.callParticipantsRTCMap[call.id];
+    }
+
+    leaveCall(call: Call) {
+        if (call) {
+            call.localParticipant.handleEvent("CALL_LEFT");
+            this.closeCall(call);
+            return this.signalingClient.sendSignalMessage({
+                callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+                roomId: call.id,
+                sessionId: call.sessionId,
+                signal: SIGNAL.LEAVE,
+                participantIds: call.participants.map((participant) => participant.id),
+            });
+        }
+    }
+
+    sendOffer(offerOptions: IOfferSignalMessage) {
+        logger.info(`Send signal: ${SIGNAL.OFFER}, to participant: ${offerOptions.to}`);
+        return this.signalingClient.sendSignalMessage({
+            callType: offerOptions.callType,
+            roomId: offerOptions.callId,
+            signal: SIGNAL.OFFER,
+            sdp: offerOptions.description.sdp,
+            ...(offerOptions.to && { to: offerOptions.to }),
+            sessionId: offerOptions.sessionId,
+        });
+    }
+
+    addParticipantsToCall(participantsIds: string[], call: Call) {
+        participantsIds.forEach((participantId) => {
+            const participant = new Participant(participantId);
+            call.addParticipantToList(participant);
+            call.onParticipantJoined(call, participant);
+            this.addParticipantToRTCMap(call, participant);
+        });
+
+        return this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            sessionId: call.sessionId,
+            signal: SIGNAL.USER_ADDED,
+            participantIds: participantsIds,
+            videoEnabled: call.videoEnabled,
+        });
+    }
+
+    createAnswer(callId: string, participantId: string) {
+        const webrtcClient = this.callParticipantsRTCMap[callId][participantId];
+        return webrtcClient.createAnswer();
+    }
+
+    createOffer(callId: string, participantId: string) {
+        const webrtcClient = this.callParticipantsRTCMap[callId][participantId];
+        return webrtcClient.createOffer();
+    }
+
+    setLocalDescription(callId: string, participantId: string, sdp: RTCSessionDescriptionInit) {
+        const webrtcClient = this.callParticipantsRTCMap[callId][participantId];
+        return webrtcClient.setLocalDescription(sdp);
+    }
+
+    setRemoteDescription(callId: string, participantId: string, sdp: RTCSessionDescriptionInit) {
+        const webrtcClient = this.callParticipantsRTCMap[callId][participantId];
+        return webrtcClient.setRemoteDescription(sdp);
+    }
+
+    sendVideoEnabled(call: Call, videoEnabled: boolean, videoTrack: MediaStreamTrack) {
+        if (call.mediaFlow === "p2p") {
+            call.participants.forEach((participant) => {
+                if (participant.id !== this.user.id) {
+                    this.callParticipantsRTCMap[call.id][participant.id].enableVideoOnPeerConnection(videoEnabled, videoTrack);
+                }
+            });
+        } else {
+            this.callParticipantsRTCMap[call.id][call.serverParticipant!.id].enableVideoOnPeerConnection(
+                videoEnabled,
+                videoTrack,
+            );
+        }
+        call.localParticipant.videoTracks.forEach((track) => {
+            track.enabled = videoEnabled;
+        });
+
+        call.onParticipantEvent(call, call.localParticipant, videoEnabled ? "VideoEnabled" : "VideoDisabled");
+
+        return this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            signal: SIGNAL.INFO,
+            sessionId: call.sessionId,
+            message: videoEnabled ? INFO_MESSAGE.VIDEO_ENABLED : INFO_MESSAGE.VIDEO_DISABLED,
+            participantIds: call.participants.map((participant) => participant.id),
+        });
+    }
+
+    getStats(call: Call) {
+        const participant = call.participants.find((participant) => {
+            if (participant.id !== this.user.id) {
+                return participant;
+            }
+        });
+
+        if (participant) {
+            return this.callParticipantsRTCMap[call.id][participant?.id].getConnectionStats(
+                call.id,
+                call.sessionId,
+                call.localParticipant.id,
+            );
+        }
+    }
+
+    sendScreenShare(call: Call, startSharing: boolean, videoTrack: MediaStreamTrack) {
+        if (call.mediaFlow === "p2p") {
+            call.participants.forEach((participant) => {
+                if (participant.id !== this.user.id) {
+                    this.callParticipantsRTCMap[call.id][participant.id].enableVideoOnPeerConnection(startSharing, videoTrack);
+                }
+            });
+        } else {
+            this.callParticipantsRTCMap[call.id][call.serverParticipant!.id].enableVideoOnPeerConnection(
+                startSharing,
+                videoTrack,
+            );
+        }
+        call.localParticipant.videoTracks.forEach((track) => {
+            track.enabled = startSharing;
+        });
+
+        call.onParticipantEvent(
+            call,
+            call.localParticipant,
+            startSharing ? "ScreenSharingStarted" : "ScreenSharingStopped",
+        );
+
+        return this.sendSignalScreenShare(call, startSharing);
+    }
+
+    sendSignalScreenShare = (call: Call, startSharing: boolean) => {
+        return this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            signal: SIGNAL.INFO,
+            sessionId: call.sessionId,
+            message: startSharing ? INFO_MESSAGE.START_SCREEN_SHARE : INFO_MESSAGE.STOP_SCREEN_SHARE,
+            participantIds: call.participants.map((participant) => participant.id),
+        });
+    };
+
+    sendAudioEnable(call: Call, mute: boolean) {
+        if (call.mediaFlow === "p2p") {
+            call.participants.forEach((participant) => {
+                if (participant.id !== this.user.id) {
+                    this.callParticipantsRTCMap[call.id][participant.id].enableAudioPeerConnection(mute);
+                }
+            });
+        } else {
+            this.callParticipantsRTCMap[call.id][call.serverParticipant!.id].enableAudioPeerConnection(mute);
+        }
+        call.localParticipant.audioTracks.forEach((track) => {
+            track.enabled = !mute;
+        });
+
+        call.onParticipantEvent(call, call.localParticipant, mute ? "Mute" : "Unmute");
+
+        return this.signalingClient.sendSignalMessage({
+            callType: CALL_TYPE[call.mediaFlow === "sfu" ? "group" : "p2p"],
+            roomId: call.id,
+            signal: SIGNAL.INFO,
+            sessionId: call.sessionId,
+            message: mute ? INFO_MESSAGE.MUTE : INFO_MESSAGE.UNMUTE,
+            participantIds: call.participants.map((participant) => participant.id),
+        });
+    }
+
+    addTracksToPeerConnection = (call: Call, participantId: string) => {
+        let localVideoTracks = call.localVideoTracks;
+        const localAudioTrack = call.localAudioTracks;
+        const mediaStream = new MediaStream();
+        if (localAudioTrack && localAudioTrack.length > 0) {
+            mediaStream.addTrack(localAudioTrack[0]);
+        }
+        this.callParticipantsRTCMap[call.id][participantId].addTrackToPeerConnection(localAudioTrack[0], mediaStream);
+
+        if (!(localVideoTracks && localVideoTracks.length > 0)) {
+            localVideoTracks = getEmptyVideoTrack();
+        }
+        mediaStream.addTrack(localVideoTracks[0]);
+        this.callParticipantsRTCMap[call.id][participantId].addTrackToPeerConnection(localVideoTracks[0], mediaStream);
+    };
+
+    async switchCallToSfu(call: Call) {
+        try {
+            const switchRes = await this.signalingClient.sendSignalMessage({
+                callType: CALL_TYPE.group,
+                roomId: call.id,
+                signal: SIGNAL.SWITCH_CALL_TYPE,
+                sessionId: call.sessionId,
+            });
+
+            logger.info("switchRes: ", switchRes);
+
+            const serverParticipant = new Participant(call.id);
+            this.addParticipantToRTCMap(call!, serverParticipant);
+            this.addTracksToPeerConnection(call, serverParticipant.id);
+            const desc = await this.createOffer(call.id, serverParticipant.id);
+            await this.setLocalDescription(call.id, serverParticipant.id, desc);
+
+            call.setServerParticipant(serverParticipant);
+
+            call.participants.forEach((participant) => {
+                participant.setShouldResetPC(true);
+            });
+            await this.sendOffer({
+                callType: CALL_TYPE.group,
+                callId: call.id,
+                description: desc,
+                sessionId: call.sessionId,
+            });
+        } catch (e) {
+            logger.info("Failed to switch sfu");
+            return false;
+        }
+        return true;
+    }
+}