@softtynet/zca-js 2.3.3 → 2.3.5

package/dist/call-engine/ZaloCallController.js

@@ -0,0 +1,638 @@
+import EventEmitter from "node:events";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CallType } from "../apis/call/sendVoiceCall.js";
+import { CallEventType } from "../models/CallEvent.js";
+import { ZaloCallTransport, } from "./ZaloCallTransport.js";
+import { ZaloRtcSession, parseIncomingCallEvent, } from "./ZaloRtcSession.js";
+/**
+ * Bộ điều phối cuộc gọi thuần TypeScript / Node.js tích hợp sẵn `ZaloRtcSession`
+ * và kênh IPC cục bộ (`ZaloCallTransport`) cho giao diện tuỳ chỉnh (HTML/JS, Electron, WebView, Mobile Bridge)
+ * mà hoàn toàn không phụ thuộc ứng dụng Zalo PC.
+ */
+export class ZaloCallController extends EventEmitter {
+    api;
+    transport;
+    activeSession = null;
+    isEngineReady = false;
+    options;
+    boundCallEventListener;
+    ringNotifiedCalls = new Set();
+    constructor(api, options = {}) {
+        super();
+        this.api = api;
+        this.options = {
+            spawnProcess: false,
+            autoForwardCallEvents: true,
+            ...options,
+        };
+        this.transport = new ZaloCallTransport(options);
+        this.transport.on("client_connected", () => {
+            this.isEngineReady = true;
+            this.sendBootstrapConfig();
+            this.emit("ready");
+        });
+        this.transport.on("message", (msg) => {
+            void this.handleIpcMessage(msg);
+        });
+        this.transport.on("error", (err) => {
+            this.emit("error", err);
+        });
+    }
+    isReady() {
+        return this.isEngineReady;
+    }
+    getActiveSession() {
+        return this.activeSession;
+    }
+    /**
+     * Khởi tạo bộ điều khiển cuộc gọi thuần TypeScript & kênh IPC cục bộ.
+     */
+    async start() {
+        await this.transport.start();
+        if (this.options.autoForwardCallEvents) {
+            this.attachCallEventListener();
+        }
+        this.isEngineReady = true;
+        this.emit("ready");
+    }
+    /**
+     * Thực hiện cuộc gọi 1-1 (Thoại hoặc Video) bằng thuật toán thuần TypeScript (`ZaloRtcSession`).
+     */
+    async makeCall(options) {
+        const isVideo = Boolean(options.isVideoCall);
+        if (this.activeSession) {
+            await this.activeSession.endCall("new_call").catch(() => { });
+        }
+        const session = new ZaloRtcSession(this.api, this.options);
+        this.activeSession = session;
+        session.on("ended", (reason) => {
+            this.emit("call_ended", { reason });
+        });
+        session.on("error", (err) => {
+            this.emit("error", err);
+        });
+        const params = await session.startOutgoingCall(String(options.calleeId), {
+            callType: isVideo ? CallType.Video : CallType.Audio,
+            offCameraAtStart: isVideo && options.enableCamera === false,
+        });
+        this.emit("connection_params", params);
+        return params;
+    }
+    /**
+     * Giải mã và báo máy đang đổ chuông (`ringRingVoiceCall` / `ringRingGroupCall`) cho cuộc gọi đến.
+     */
+    async ringIncomingCall(callEvent) {
+        const info = parseIncomingCallEvent(callEvent, this.api.getContext().uid);
+        if (this.activeSession &&
+            this.activeSession.getState() !== "idle" &&
+            this.activeSession.getState() !== "ended" &&
+            this.activeSession.getMediaState().callId !== info.callId) {
+            await this.activeSession.endCall("new_incoming_call").catch(() => { });
+            this.activeSession = null;
+        }
+        if (!this.activeSession || this.activeSession.getState() === "ended") {
+            const session = new ZaloRtcSession(this.api, this.options);
+            this.activeSession = session;
+            session.on("ended", (reason) => {
+                this.emit("call_ended", { reason });
+            });
+            session.on("error", (err) => {
+                this.emit("error", err);
+            });
+        }
+        return this.activeSession.ringIncomingCall(callEvent);
+    }
+    /**
+     * Chấp nhận cuộc gọi đến (1-1 hoặc Nhóm) bằng `ZaloRtcSession` thuần TypeScript.
+     */
+    async acceptIncomingCall(callEvent, options = {}) {
+        const info = parseIncomingCallEvent(callEvent, this.api.getContext().uid);
+        if (this.activeSession &&
+            this.activeSession.getState() !== "idle" &&
+            this.activeSession.getState() !== "ended" &&
+            this.activeSession.getMediaState().callId !== info.callId) {
+            await this.activeSession.endCall("accept_new_incoming_call").catch(() => { });
+            this.activeSession = null;
+        }
+        if (!this.activeSession || this.activeSession.getState() === "ended") {
+            const session = new ZaloRtcSession(this.api, this.options);
+            this.activeSession = session;
+            session.on("ended", (reason) => {
+                this.emit("call_ended", { reason });
+            });
+            session.on("error", (err) => {
+                this.emit("error", err);
+            });
+        }
+        const params = await this.activeSession.acceptIncomingCall(callEvent, options);
+        this.emit("connection_params", params);
+        return params;
+    }
+    /**
+     * Tái kích hoạt kết nối UDP (Re-bind UDP socket + bắt tay `InitCall` + khởi động lại vòng lặp Ping/Media/RTCP)
+     * cho phiên gọi đang hoạt động.
+     */
+    async reconnectUdp(options = {}) {
+        if (!this.activeSession)
+            return null;
+        const params = await this.activeSession.reconnectUdp(options);
+        this.emit("connection_params", params);
+        return params;
+    }
+    /**
+     * Từ chối cuộc gọi đến (1-1 hoặc Nhóm) bằng `ZaloRtcSession` thuần TypeScript.
+     */
+    async rejectIncomingCall(callEvent, options = {}) {
+        const session = this.activeSession ?? new ZaloRtcSession(this.api, this.options);
+        await session.rejectIncomingCall(callEvent, options);
+    }
+    /**
+     * Ngắt kênh UDP cục bộ tại Worker để bàn giao luồng kết nối UDP trực tiếp cho Mobile App.
+     */
+    handoffUdpToExternal(routingTokenOverride) {
+        if (!this.activeSession)
+            return null;
+        return this.activeSession.handoffUdpToExternal(routingTokenOverride);
+    }
+    /**
+     * Khởi tạo cuộc gọi Nhóm (Group Audio / Video Call) qua kênh IPC và `ZaloRtcSession`.
+     */
+    makeGroupCall(options) {
+        const isVideo = Boolean(options.isVideoCall);
+        this.transport.send({
+            type: "request",
+            command: "makeCall",
+            data: {
+                partner: options.members.map((m) => ({
+                    id: String(m.id),
+                    name: m.name,
+                    avatar: m.avatar ?? "",
+                })),
+                type: isVideo ? CallType.GroupVideo : CallType.GroupAudio,
+                groupInfo: {
+                    id: String(options.groupId),
+                    name: options.groupName ?? String(options.groupId),
+                    avatar: options.groupAvatar ?? "",
+                },
+            },
+        });
+    }
+    /**
+     * Chuyển tiếp một sự kiện `call_event` từ WebSocket Zalo xuống `ZaloCall` dưới dạng gói `{ type: "control" }`.
+     */
+    forwardCallEvent(event) {
+        const normalizedAct = this.normalizeControlAct(event.act);
+        const parsedInfo = parseIncomingCallEvent(event, this.api.getContext().uid);
+        const callId = parsedInfo.callId ||
+            Number(event.data.callId ?? event.data.call_id ?? event.data.id ?? 0);
+        if (event.type === CallEventType.REQUEST ||
+            event.type === CallEventType.GROUP_REQUEST ||
+            normalizedAct === "request" ||
+            normalizedAct === "group_request") {
+            this.emit("incoming_call", parsedInfo);
+        }
+        if (normalizedAct === "ring_ring" && callId > 0) {
+            this.ringNotifiedCalls.add(callId);
+        }
+        // Trong ZCallInfo::receiveAnswer (0x1000cbf28), ZaloCall yêu cầu trạng thái đã qua bước ring_ring (state 8)
+        if (normalizedAct === "answer" && callId > 0 && !this.ringNotifiedCalls.has(callId)) {
+            this.ringNotifiedCalls.add(callId);
+            this.transport.send({
+                type: "control",
+                data: {
+                    act: "ring_ring",
+                    act_type: "voip",
+                    inCallStatus: "zalo",
+                    data: {
+                        callId,
+                        codec: typeof event.data.codec === "string" ? event.data.codec : "[]",
+                        params: typeof event.data.params === "string"
+                            ? event.data.params
+                            : JSON.stringify(event.data.params ?? {}),
+                    },
+                },
+            });
+        }
+        const controlData = {
+            ...event.data,
+        };
+        if (callId > 0) {
+            controlData.callId = callId;
+            controlData.id = callId;
+        }
+        if (normalizedAct === "answer" &&
+            controlData.params &&
+            typeof controlData.params !== "string") {
+            controlData.params = JSON.stringify(controlData.params);
+        }
+        this.transport.send({
+            type: "control",
+            data: {
+                act: normalizedAct,
+                act_type: event.act_type || "voip",
+                inCallStatus: "zalo",
+                data: controlData,
+            },
+        });
+    }
+    /**
+     * Đóng phiên gọi hiện tại và giải phóng toàn bộ kênh IPC.
+     */
+    async stop() {
+        this.detachCallEventListener();
+        this.isEngineReady = false;
+        if (this.activeSession) {
+            await this.activeSession.endCall("controller_stop").catch(() => { });
+            this.activeSession = null;
+        }
+        await this.transport.close();
+    }
+    sendBootstrapConfig() {
+        const ctx = this.api.getContext();
+        const appPath = path.join(os.tmpdir(), `zalo-call-${this.transport.socketId}`);
+        try {
+            fs.mkdirSync(appPath, { recursive: true });
+        }
+        catch {
+            // Ignore
+        }
+        this.transport.send({
+            type: "update",
+            command: "init",
+            data: {
+                local: {
+                    id: String(ctx.uid ?? "0"),
+                    name: this.options.displayName ?? "Zalo User",
+                    avatar: this.options.avatar ?? "",
+                },
+                osInfo: process.platform === "darwin" ? "macOS" : "Windows",
+                mainWindowId: 1,
+                logPath: appPath,
+                zrtcLogPath: appPath,
+                dumpPath: appPath,
+                clientVersion: ctx.API_VERSION || 689,
+                language: this.options.lang ?? ctx.language ?? "vi",
+                timeoutMakeCall2ZRtp: 30000,
+                enablePreviewDeviceOutgoing: false,
+                enablePreviewDeviceIncall: true,
+                enableUnstableConnecting: true,
+                autoAudioInput: true,
+                autoAudioOutput: true,
+                defaultAudInputDevice: "",
+                defaultAudOutputDevice: "",
+                defaultVidDevice: "",
+            },
+        });
+    }
+    async handleIpcMessage(msg) {
+        this.emit("ipc_message", msg);
+        if (msg.type === "ready") {
+            if (!this.isEngineReady) {
+                this.isEngineReady = true;
+                this.sendBootstrapConfig();
+                this.emit("ready");
+            }
+            return;
+        }
+        if ((msg.type === "request" && msg.command === "serverTime") ||
+            msg.type === "serverTime") {
+            this.transport.send({
+                type: "response",
+                command: "serverTime",
+                data: { timestamp: Date.now() },
+            });
+            return;
+        }
+        if ((msg.type === "request" && msg.command === "getAliasName") ||
+            msg.type === "getAliasName") {
+            const reqData = (msg.data ?? {});
+            this.transport.send({
+                type: "response",
+                command: "getAliasName",
+                data: {
+                    uid: reqData.uid,
+                    aliasName: reqData.name ?? "",
+                },
+            });
+            return;
+        }
+        if (msg.type === "sendSignal") {
+            const inner = (msg.data ?? {});
+            const signalType = Number(msg.command ?? inner.type ?? 0);
+            const seqId = Number(inner.seqId ?? 0);
+            const rawParams = inner.params !== undefined ? inner.params : inner;
+            if (signalType > 0) {
+                await this.handleSignalFromEngine(signalType, seqId, rawParams);
+            }
+            return;
+        }
+        if (msg.type === "endCall" || msg.command === "endCall") {
+            this.emit("call_ended", msg.data);
+        }
+        else if (msg.type === "stats" || msg.command === "stats") {
+            this.emit("call_stats", msg.data);
+        }
+    }
+    /**
+     * Cầu nối điều phối toàn bộ 28 mã lệnh `sendSignal` (`401..418` và `501..514`)
+     * từ `ZaloCall` sang các hàm trong `api.call.*` và trả kết quả về qua `recvSignal`.
+     */
+    async handleSignalFromEngine(type, seqId, rawParams) {
+        const paramsObj = typeof rawParams === "string"
+            ? JSON.parse(rawParams)
+            : (rawParams ?? {});
+        this.emit("signal_sent", type, seqId, paramsObj);
+        const partnerId = String(paramsObj.calleeId ?? paramsObj.callerId ?? paramsObj.partnerId ?? paramsObj.uid ?? "");
+        const callId = Number(paramsObj.callId ?? 0);
+        const session = String(paramsObj.session ?? paramsObj.sessionId ?? paramsObj.sessId ?? "");
+        const rtpAddress = String(paramsObj.rtpAddress ?? "");
+        const rtcpAddress = String(paramsObj.rtcpAddress ?? rtpAddress);
+        const codec = typeof paramsObj.codec === "string" ? paramsObj.codec : undefined;
+        const extendData = paramsObj.extendData;
+        try {
+            let result;
+            switch (type) {
+                case 401: {
+                    const srv = (await this.api.call.requestVoiceCall(partnerId, {
+                        callId: callId || undefined,
+                        callType: Number(paramsObj.typeRequest) || CallType.Audio,
+                        codec,
+                    }));
+                    const rtpAddr = srv.rtpServer ?? srv.rtpIP ?? srv.servers?.[0]?.rtpaddr ?? "";
+                    const rtcpAddr = srv.rtcpServer ?? srv.rtcpIP ?? srv.servers?.[0]?.rtcpaddr ?? rtpAddr;
+                    result = {
+                        ...srv,
+                        id: srv.callId || callId,
+                        callId: srv.callId || callId,
+                        fromId: srv.fromId ?? String(this.api.getContext().uid ?? ""),
+                        toId: srv.toId ?? partnerId,
+                        ts: srv.ts ?? Date.now(),
+                        protocol: srv.protocol ?? 3,
+                        status: 0,
+                        sessId: srv.sessId ?? `${partnerId}_${srv.callId || callId}_401`,
+                        msg: "",
+                        showDebugInfo: 0,
+                        showShareScreenBtn: 1,
+                        zrtc_config: srv.zrtc_config ?? {},
+                        servers: srv.servers ?? [
+                            { rtpaddr: rtpAddr, rtcpaddr: rtcpAddr, spTcp: 1, bonus: 0 },
+                        ],
+                    };
+                    break;
+                }
+                case 402:
+                    result = await this.api.call.answerVoiceCall(partnerId, callId, {
+                        sessionId: session,
+                        rtpAddress,
+                        rtcpAddress,
+                        codec,
+                        extendData,
+                        status: Number(paramsObj.status ?? 0),
+                    });
+                    break;
+                case 403:
+                    result = await this.api.call.holdVoiceCall(partnerId, {
+                        isResponse: false,
+                    });
+                    break;
+                case 404:
+                    result = await this.api.call.holdVoiceCall(partnerId, {
+                        isResponse: true,
+                    });
+                    break;
+                case 405:
+                    result = await this.api.call.cancelVoiceCall(partnerId, callId, {
+                        callType: Number(paramsObj.callType) || CallType.Audio,
+                    });
+                    break;
+                case 406:
+                    result = await this.api.call.endVoiceCall(partnerId, callId, {
+                        status: Number(paramsObj.status ?? 3),
+                    });
+                    break;
+                case 407:
+                    result = await this.api.call.ringRingVoiceCall(partnerId, callId, {
+                        status: Number(paramsObj.status ?? 0),
+                    });
+                    break;
+                case 408:
+                    result = await this.api.call.logEndVoiceCall(partnerId, callId, {
+                        duration: Number(paramsObj.duration ?? 0),
+                        status: Number(paramsObj.status ?? 0),
+                    });
+                    break;
+                case 409:
+                    result = await this.api.call.answerAckVoiceCall(partnerId, callId);
+                    break;
+                case 411:
+                    result = await this.api.call.unholdVoiceCall(partnerId, {
+                        isResponse: false,
+                    });
+                    break;
+                case 412:
+                    result = await this.api.call.unholdVoiceCall(partnerId, {
+                        isResponse: true,
+                    });
+                    break;
+                case 413:
+                case 415:
+                    result = await this.api.call.updateCallMediaState(partnerId, callId, {
+                        isOnCam: paramsObj.isOnCam === -1 ||
+                            paramsObj.isOnCam === 0 ||
+                            paramsObj.isOnCam === 1 ||
+                            typeof paramsObj.isOnCam === "boolean"
+                            ? paramsObj.isOnCam
+                            : undefined,
+                        isOnMic: paramsObj.isOnMic === -1 ||
+                            paramsObj.isOnMic === 0 ||
+                            paramsObj.isOnMic === 1 ||
+                            typeof paramsObj.isOnMic === "boolean"
+                            ? paramsObj.isOnMic
+                            : undefined,
+                    });
+                    break;
+                case 416: {
+                    const reqRes = await this.api.call.sendRequestVoiceCall(partnerId, {
+                        callId,
+                        session,
+                        rtpAddress,
+                        rtcpAddress,
+                        codec,
+                        extendData,
+                        subCommand: Number(paramsObj.subCommand ?? 3),
+                    });
+                    result = {
+                        ...(typeof reqRes === "object" && reqRes !== null ? reqRes : {}),
+                        status: 0,
+                        id: callId,
+                    };
+                    break;
+                }
+                case 417:
+                    result = await this.api.call.requestAudioToVideoCall(partnerId, callId, {
+                        status: Number(paramsObj.status ?? 0),
+                    });
+                    break;
+                case 418:
+                    result = await this.api.call.requestShareScreenCall(partnerId, callId, {
+                        status: Number(paramsObj.status ?? 1),
+                    });
+                    break;
+                case 501:
+                    result = await this.api.call.requestGroupCall(String(paramsObj.groupId ?? ""), {
+                        callId: callId || undefined,
+                        typeRequest: Number(paramsObj.typeRequest) || CallType.GroupAudio,
+                        data: paramsObj.data,
+                        partners: paramsObj.partners ?? [],
+                    });
+                    break;
+                case 502:
+                    result = await this.api.call.addUserGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                        session,
+                        partners: paramsObj.partners ?? [],
+                    });
+                    break;
+                case 503:
+                    result = await this.api.call.answerGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                        data: paramsObj.data,
+                    });
+                    break;
+                case 504:
+                    result = await this.api.call.cancelGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                        data: paramsObj.data,
+                    });
+                    break;
+                case 505:
+                    result = await this.api.call.endGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                        data: paramsObj.data,
+                    });
+                    break;
+                case 506:
+                    result = await this.api.call.ringRingGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                        data: paramsObj.data,
+                    });
+                    break;
+                case 507:
+                    result = await this.api.call.finishGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                        duration: Number(paramsObj.duration ?? 0),
+                    });
+                    break;
+                case 508:
+                    result = await this.api.call.getGroupCallState(callId, String(paramsObj.hostCall ?? ""));
+                    break;
+                case 509:
+                    result = await this.api.call.pingGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                    });
+                    break;
+                case 510:
+                    result = await this.api.call.broadcastGroupCallState(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                    });
+                    break;
+                case 511:
+                    result = await this.api.call.joinGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                    });
+                    break;
+                case 512:
+                    result = await this.api.call.shareScreenGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                    });
+                    break;
+                case 513:
+                    result = await this.api.call.sendRequestGroupCall(String(paramsObj.groupId ?? ""), {
+                        callId,
+                        session,
+                        partners: paramsObj.partners ?? [],
+                    });
+                    break;
+                case 514:
+                    result = await this.api.call.notifyGroupCall(callId, {
+                        hostCall: String(paramsObj.hostCall ?? ""),
+                    });
+                    break;
+                default:
+                    result = {};
+                    break;
+            }
+            this.emit("signal_response", type, seqId, result);
+            this.transport.send({
+                type: "recvSignal",
+                command: type,
+                data: {
+                    ...(typeof result === "object" && result !== null
+                        ? result
+                        : {}),
+                    type,
+                    seqId,
+                    errorCode: 0,
+                    errorMessage: "Successful.",
+                },
+            });
+        }
+        catch (err) {
+            this.emit("error", err);
+            this.transport.send({
+                type: "recvSignal",
+                command: type,
+                data: {
+                    type,
+                    seqId,
+                    errorCode: -1,
+                    errorMessage: err instanceof Error ? err.message : String(err),
+                },
+            });
+        }
+    }
+    normalizeControlAct(act) {
+        switch (act) {
+            case "ringring":
+                return "ring_ring";
+            case "end":
+            case "endcall":
+                return "end_call";
+            case "answerack":
+                return "answer_ack";
+            case "group_ringring":
+                return "group_ring_ring";
+            case "group_end":
+            case "group_endcall":
+                return "group_end_call";
+            default:
+                return act;
+        }
+    }
+    attachCallEventListener() {
+        if (this.boundCallEventListener)
+            return;
+        this.boundCallEventListener = (event) => {
+            this.forwardCallEvent(event);
+        };
+        try {
+            this.api.listener.on("call_event", this.boundCallEventListener);
+        }
+        catch {
+            // Ignore if listener is not active
+        }
+    }
+    detachCallEventListener() {
+        if (!this.boundCallEventListener)
+            return;
+        try {
+            this.api.listener.removeListener("call_event", this.boundCallEventListener);
+        }
+        catch {
+            // Ignore
+        }
+        this.boundCallEventListener = undefined;
+    }
+}