trtc-electron-sdk 12.1.607 → 12.1.701-alpha.0

package/liteav/extensions/DeviceManager/index.js

@@ -0,0 +1,515 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRTCDeviceManager = exports.TRTCDeviceEventType = void 0;
+const events_1 = require("events");
+const NodeTRTCEngine = require('../../../build/Release/trtc_electron_sdk.node');
+const trtc_define_1 = require("../../trtc_define");
+/**
+ * 音视频设备事件类型
+ */
+var TRTCDeviceEventType;
+(function (TRTCDeviceEventType) {
+    /** 设备状态变更 */
+    TRTCDeviceEventType["onDeviceChanged"] = "onDeviceChanged";
+})(TRTCDeviceEventType = exports.TRTCDeviceEventType || (exports.TRTCDeviceEventType = {}));
+const logger = console;
+class TRTCDeviceManager {
+    constructor() {
+        this.logPrefix = '[TRTCDeviceManager]';
+        if (!TRTCDeviceManager.deviceNanager) {
+            this.promiseStore = new Map();
+            this.eventEmitter = new events_1.EventEmitter();
+            this.eventHandler = this.eventHandler.bind(this);
+            this.nodeDeviceManagerPlugin = new NodeTRTCEngine.NodeRemoteDeviceManager();
+            this.nodeDeviceManagerPlugin.setRemoteDeviceManagerCallback(this.eventHandler);
+            TRTCDeviceManager.deviceNanager = this;
+        }
+        else {
+            return TRTCDeviceManager.deviceNanager;
+        }
+    }
+    static getInstance() {
+        if (!TRTCDeviceManager.deviceNanager) {
+            TRTCDeviceManager.deviceNanager = new TRTCDeviceManager();
+        }
+        return TRTCDeviceManager.deviceNanager;
+    }
+    /**
+     *
+     * @returns
+     *
+     * @deprecated
+     */
+    getCameraDevicesList() {
+        const deviceInfos = this.nodeDeviceManagerPlugin.getDevicesList(trtc_define_1.TRTCDeviceType.TRTCDeviceTypeCamera);
+        deviceInfos === null || deviceInfos === void 0 ? void 0 : deviceInfos.forEach((item) => {
+            try {
+                if (item.deviceProperties) {
+                    const properties = JSON.parse(item.deviceProperties);
+                    item.deviceProperties = properties;
+                }
+                else {
+                    // 虚拟摄像头可能没有 deviceProperties 字段
+                    item.deviceProperties = {};
+                }
+            }
+            catch (e) {
+                logger.warn('[TRTCDeviceManager]camera device properties parse error.', JSON.stringify(item));
+                item.deviceProperties = {};
+            }
+        });
+        return deviceInfos;
+    }
+    /**
+     *
+     * @returns
+     *
+     * @deprecated
+     */
+    getMicDevicesList() {
+        return this.nodeDeviceManagerPlugin.getDevicesList(trtc_define_1.TRTCDeviceType.TRTCDeviceTypeMic);
+    }
+    /**
+     *
+     * @returns
+     *
+     * @deprecated
+     */
+    getSpeakerDevicesList() {
+        return this.nodeDeviceManagerPlugin.getDevicesList(trtc_define_1.TRTCDeviceType.TRTCDeviceTypeSpeaker);
+    }
+    getDevicesList(type) {
+        const deviceInfos = this.nodeDeviceManagerPlugin.getDevicesList(trtc_define_1.TRTCDeviceType.TRTCDeviceTypeCamera);
+        if (type === trtc_define_1.TRTCDeviceType.TRTCDeviceTypeCamera) {
+            deviceInfos === null || deviceInfos === void 0 ? void 0 : deviceInfos.forEach((item) => {
+                try {
+                    if (item.deviceProperties) {
+                        const properties = JSON.parse(item.deviceProperties);
+                        item.deviceProperties = properties;
+                    }
+                    else {
+                        // 虚拟摄像头可能没有 deviceProperties 字段
+                        item.deviceProperties = {};
+                    }
+                }
+                catch (e) {
+                    logger.warn('[TRTCDeviceManager]camera device properties parse error.', JSON.stringify(item));
+                    item.deviceProperties = {};
+                }
+            });
+        }
+        return deviceInfos;
+    }
+    setCurrentDevice(type, deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]setCurrentDevice", type, deviceId);
+            const promise = new Promise((resolve, reject) => {
+                const key = `setCurrentDevice-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.setCurrentDevice(type, deviceId);
+            });
+            return promise;
+        });
+    }
+    getCurrentDevice(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]getCurrentDevice", type);
+            const promise = new Promise((resolve, reject) => {
+                const key = `getCurrentDevice-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.getCurrentDevice(type);
+            });
+            return promise;
+        });
+    }
+    setCurrentDeviceVolume(type, volume) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]setCurrentDeviceVolume", type, volume);
+            const promise = new Promise((resolve, reject) => {
+                const key = `setCurrentDeviceVolume-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.setCurrentDeviceVolume(type, volume);
+            });
+            return promise;
+        });
+    }
+    getCurrentDeviceVolume(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]getCurrentDeviceVolume", type);
+            const promise = new Promise((resolve, reject) => {
+                const key = `getCurrentDeviceVolume-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.getCurrentDeviceVolume(type);
+            });
+            return promise;
+        });
+    }
+    setCurrentDeviceMute(type, mute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]setCurrentDeviceMute", type, mute);
+            const promise = new Promise((resolve, reject) => {
+                const key = `setCurrentDeviceMute-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.setCurrentDeviceMute(type, mute);
+            });
+            return promise;
+        });
+    }
+    getCurrentDeviceMute(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]getCurrentDeviceMute");
+            const promise = new Promise((resolve, reject) => {
+                const key = `getCurrentDeviceMute-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.getCurrentDeviceMute(type);
+            });
+            return promise;
+        });
+    }
+    enableFollowingDefaultAudioDevice(type, enable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]enableFollowingDefaultAudioDevice", type, enable);
+            const promise = new Promise((resolve, reject) => {
+                const key = `enableFollowingDefaultAudioDevice-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.enableFollowingDefaultAudioDevice(type, enable);
+            });
+            return promise;
+        });
+    }
+    startCameraDeviceTest(windowID, rect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]startCameraDeviceTest", windowID, rect);
+            const promise = new Promise((resolve, reject) => {
+                const key = `startCameraDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.startCameraDeviceTest(windowID, rect);
+            });
+            return promise;
+        });
+    }
+    stopCameraDeviceTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]stopCameraDeviceTest");
+            const promise = new Promise((resolve, reject) => {
+                const key = `stopCameraDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.stopCameraDeviceTest();
+            });
+            return promise;
+        });
+    }
+    setCameraTestRenderMirror(mirror) {
+        logger.debug("[TRTCDeviceManager]setCameraTestRenderMirror", mirror);
+        this.nodeDeviceManagerPlugin.setCameraTestRenderMirror(mirror);
+    }
+    setCameraTestDeviceId(cameraId) {
+        logger.debug("[TRTCDeviceManager]setCameraTestDeviceId", cameraId);
+        this.nodeDeviceManagerPlugin.setCameraTestDeviceId(cameraId);
+    }
+    setCameraTestResolution(width, height) {
+        logger.debug("[TRTCDeviceManager]setCameraTestResolution", width, height);
+        this.nodeDeviceManagerPlugin.setCameraTestResolution(width, height);
+    }
+    setCameraTestVideoPluginPath(path) {
+        logger.debug("[TRTCDeviceManager]setCameraTestVideoPluginPath", path);
+        this.nodeDeviceManagerPlugin.setCameraTestVideoPluginPath(path);
+    }
+    setCameraTestVideoPluginParameter(params) {
+        logger.debug("[TRTCDeviceManager]setCameraTestVideoPluginParameter", params);
+        this.nodeDeviceManagerPlugin.setCameraTestVideoPluginParameter(params);
+    }
+    startMicDeviceTest(interval, playback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]startMicDeviceTest", interval, playback);
+            const promise = new Promise((resolve, reject) => {
+                const key = `startMicDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                if (playback !== undefined) {
+                    this.nodeDeviceManagerPlugin.startMicDeviceTest(interval, playback);
+                }
+                else {
+                    this.nodeDeviceManagerPlugin.startMicDeviceTest(interval);
+                }
+            });
+            return promise;
+        });
+    }
+    stopMicDeviceTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]stopMicDeviceTest");
+            const promise = new Promise((resolve, reject) => {
+                const key = `stopMicDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.stopMicDeviceTest();
+            });
+            return promise;
+        });
+    }
+    startSpeakerDeviceTest(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]startSpeakerDeviceTest", filePath);
+            const promise = new Promise((resolve, reject) => {
+                const key = `startSpeakerDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.startSpeakerDeviceTest(filePath);
+            });
+            return promise;
+        });
+    }
+    stopSpeakerDeviceTest() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]stopSpeakerDeviceTest");
+            const promise = new Promise((resolve, reject) => {
+                const key = `stopSpeakerDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.stopSpeakerDeviceTest();
+            });
+            return promise;
+        });
+    }
+    setApplicationPlayVolume(volume) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]setApplicationPlayVolume", volume);
+            const promise = new Promise((resolve, reject) => {
+                const key = `setApplicationPlayVolume`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.setApplicationPlayVolume(volume);
+            });
+            return promise;
+        });
+    }
+    getApplicationPlayVolume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]getApplicationPlayVolume");
+            const promise = new Promise((resolve, reject) => {
+                const key = `getApplicationPlayVolume`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.getApplicationPlayVolume();
+            });
+            return promise;
+        });
+    }
+    setApplicationMuteState(mute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]setApplicationMuteState", mute);
+            const promise = new Promise((resolve, reject) => {
+                const key = `setApplicationMuteState`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.setApplicationMuteState(mute);
+            });
+            return promise;
+        });
+    }
+    getApplicationMuteState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]getApplicationMuteState");
+            const promise = new Promise((resolve, reject) => {
+                const key = `setApplicationMuteState`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManagerPlugin.getApplicationMuteState();
+            });
+            return promise;
+        });
+    }
+    setCameraCaptureParam(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug("[TRTCDeviceManager]setCameraCaptureParam:", params);
+            return yield this.nodeDeviceManagerPlugin.setCameraCapturerParam(params);
+        });
+    }
+    /**
+     * 监听事件
+     *
+     * @param event {TRTCDeviceEventType} - 事件名称
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     * @param context {object} - 回调函数执行的上下文
+     */
+    on(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.on(event, func);
+    }
+    /**
+     * 取消事件监听
+     *
+     * @param event {TRTCDeviceEventType} - 事件名
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     */
+    off(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.off(event, func);
+    }
+    addPromise(key, resolve, reject) {
+        var _a, _b, _c;
+        if (!((_a = this.promiseStore) === null || _a === void 0 ? void 0 : _a.has(key))) {
+            (_b = this.promiseStore) === null || _b === void 0 ? void 0 : _b.set(key, []);
+        }
+        const storedPromises = (_c = this.promiseStore) === null || _c === void 0 ? void 0 : _c.get(key);
+        storedPromises === null || storedPromises === void 0 ? void 0 : storedPromises.push({
+            resolve,
+            reject
+        });
+    }
+    removePromise(key, value) {
+        var _a, _b;
+        const storedPromises = (_a = this.promiseStore) === null || _a === void 0 ? void 0 : _a.get(key);
+        if (storedPromises) {
+            storedPromises.forEach(({ resolve, reject }) => {
+                resolve(value);
+            });
+            (_b = this.promiseStore) === null || _b === void 0 ? void 0 : _b.delete(key);
+        }
+    }
+    eventHandler(args) {
+        logger.debug('TRTCDeviceManager event:', args);
+        const key = args[0];
+        const data = args[1];
+        switch (key) {
+            case TRTCDeviceEventType.onDeviceChanged:
+                this.onDeviceChanged(data.deviceId, data.type, data.state);
+                break;
+            case "onSetCurrentDeviceFinished":
+                this.onSetCurrentDeviceFinished(data.type, data.result);
+                break;
+            case "onGetCurrentDeviceFinished":
+                this.onGetCurrentDeviceFinished(data.type, {
+                    deviceId: data.deviceId,
+                    deviceName: data.deviceName,
+                    deviceProperties: {}
+                });
+                break;
+            case "onSetCurrentDeviceVolumeFinished":
+                this.onSetCurrentDeviceVolumeFinished(data.type, data.result);
+                break;
+            case "onGetCurrentDeviceVolumeFinished":
+                this.onGetCurrentDeviceVolumeFinished(data.type, data.volume);
+                break;
+            case "onSetCurrentDeviceMuteFinished":
+                this.onSetCurrentDeviceMuteFinished(data.type, data.result);
+                break;
+            case "onGetCurrentDeviceMuteFinished":
+                this.onGetCurrentDeviceMuteFinished(data.type, data.muted);
+                break;
+            case "onEnableFollowingDefaultAudioDeviceFinished":
+                this.onEnableFollowingDefaultAudioDeviceFinished(data.type, data.result);
+                break;
+            case "onStartCameraDeviceTestFinished":
+                this.onStartCameraDeviceTestFinished(data.result);
+                break;
+            case "onStopCameraDeviceTestFinished":
+                this.onStopCameraDeviceTestFinished(data.result);
+                break;
+            case "onStartMicDeviceTestFinished":
+                this.onStartMicDeviceTestFinished(data.result);
+                break;
+            case "onStopMicDeviceTestFinished":
+                this.onStopMicDeviceTestFinished(data.result);
+                break;
+            case "onStartSpeakerDeviceTestFinished":
+                this.onStartSpeakerDeviceTestFinished(data.result);
+                break;
+            case "onStopSpeakerDeviceTestFinished":
+                this.onStopSpeakerDeviceTestFinished(data.result);
+                break;
+            case "onSetApplicationPlayVolumeFinished":
+                this.onSetApplicationPlayVolumeFinished(data.result);
+                break;
+            case "onGetApplicationPlayVolumeFinished":
+                this.onGetApplicationPlayVolumeFinished(data.volume);
+                break;
+            case "onSetApplicationMuteStateFinished":
+                this.onSetApplicationMuteStateFinished(data.result);
+                break;
+            case "onGetApplicationMuteStateFinished":
+                this.onGetApplicationMuteStateFinished(data.muted);
+                break;
+            default:
+                logger.warn("TRTCDeviceManager unsupported event type:", key);
+                break;
+        }
+    }
+    onDeviceChanged(deviceId, type, state) {
+        var _a;
+        logger.debug("[TRTCDeviceManager]onDeviceChanged", deviceId, type, state);
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit('onDeviceChanged', deviceId, type, state);
+    }
+    onSetCurrentDeviceFinished(type, result) {
+        const key = `setCurrentDevice-${type}`;
+        this.removePromise(key, result);
+    }
+    onGetCurrentDeviceFinished(type, deviceInfo) {
+        const key = `getCurrentDevice-${type}`;
+        this.removePromise(key, deviceInfo);
+    }
+    onSetCurrentDeviceVolumeFinished(type, result) {
+        const key = `setCurrentDeviceVolume-${type}`;
+        this.removePromise(key, result);
+    }
+    onGetCurrentDeviceVolumeFinished(type, volume) {
+        const key = `getCurrentDeviceVolume-${type}`;
+        this.removePromise(key, volume);
+    }
+    onSetCurrentDeviceMuteFinished(type, result) {
+        const key = `setCurrentDeviceMute-${type}`;
+        this.removePromise(key, result);
+    }
+    onGetCurrentDeviceMuteFinished(type, muted) {
+        const key = `getCurrentDeviceMute-${type}`;
+        this.removePromise(key, muted);
+    }
+    onEnableFollowingDefaultAudioDeviceFinished(type, result) {
+        const key = `enableFollowingDefaultAudioDevice-${type}`;
+        this.removePromise(key, result);
+    }
+    onStartCameraDeviceTestFinished(result) {
+        const key = `startCameraDeviceTest`;
+        this.removePromise(key, result);
+    }
+    onStopCameraDeviceTestFinished(result) {
+        const key = `stopCameraDeviceTest`;
+        this.removePromise(key, result);
+    }
+    onStartMicDeviceTestFinished(result) {
+        const key = `startMicDeviceTest`;
+        this.removePromise(key, result);
+    }
+    onStopMicDeviceTestFinished(result) {
+        const key = `stopMicDeviceTest`;
+        this.removePromise(key, result);
+    }
+    onStartSpeakerDeviceTestFinished(result) {
+        const key = `startSpeakerDeviceTest`;
+        this.removePromise(key, result);
+    }
+    onStopSpeakerDeviceTestFinished(result) {
+        const key = `stopSpeakerDeviceTest`;
+        this.removePromise(key, result);
+    }
+    onSetApplicationPlayVolumeFinished(result) {
+        const key = `setApplicationPlayVolume`;
+        this.removePromise(key, result);
+    }
+    onGetApplicationPlayVolumeFinished(volume) {
+        const key = `getApplicationPlayVolume`;
+        this.removePromise(key, volume);
+    }
+    onSetApplicationMuteStateFinished(result) {
+        const key = `setApplicationMuteState`;
+        this.removePromise(key, result);
+    }
+    onGetApplicationMuteStateFinished(muted) {
+        const key = `getApplicationMuteState`;
+        this.removePromise(key, muted);
+    }
+}
+exports.TRTCDeviceManager = TRTCDeviceManager;
+exports.default = TRTCDeviceManager;

package/liteav/extensions/MediaMixingManager/index.d.ts

@@ -0,0 +1,58 @@
+import { TRTCLocalMediaTranscodingParams } from '../../LocalMediaTranscoder/index';
+import { TRTCVideoRotation, TRTCVideoFillMode, TRTCVideoMirrorType, TRTCCameraCaptureParams, TRTCRect } from '../../trtc_define';
+export { TRTCLocalMediaTranscodingParams } from '../../LocalMediaTranscoder/index';
+export declare enum TRTCMultiSourcePluginEvent {
+    onError = "onError"
+}
+export declare enum TRTCMediaSourceType {
+    kCamera = 0,
+    kScreen = 1,
+    kImage = 2,
+    kRemoteVideo = 3
+}
+export declare type TRTCMediaSource = {
+    sourceType: TRTCMediaSourceType;
+    sourceId: string;
+    zOrder?: number;
+    enableGreenScreen?: boolean;
+    rect?: TRTCRect;
+    isSelected?: boolean;
+    rotation?: TRTCVideoRotation;
+    fillMode?: TRTCVideoFillMode;
+    mirrorType?: TRTCVideoMirrorType;
+};
+export declare class TRTCMediaMixingManager {
+    private logPrefix;
+    private static mediaMixingManager;
+    private nodeMediaMixingPlugin;
+    private eventEmitter;
+    constructor();
+    static getInstance(): TRTCMediaMixingManager;
+    private eventHandler;
+    setMediaServerPath(path: string): Promise<void>;
+    setDisplayParams(windowId: number, region: TRTCRect): void;
+    addMediaSource(mediaSource: TRTCMediaSource): Promise<TRTCRect>;
+    removeMediaSource(mediaSource: TRTCMediaSource): Promise<void>;
+    updateMediaSource(mediaSource: TRTCMediaSource): Promise<void>;
+    muteMediaSource(mediaSource: TRTCMediaSource, mute: boolean): Promise<void>;
+    setCameraCaptureParam(cameraID: string, params: TRTCCameraCaptureParams): void;
+    startPublish(): Promise<void>;
+    stopPublish(): Promise<void>;
+    updatePublishParams(params: TRTCLocalMediaTranscodingParams): Promise<void>;
+    /**
+     * 监听事件
+     *
+     * @param event {string} - 事件名称
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     * @param context {object} - 回调函数执行的上下文
+     */
+    on(event: string, func: (...args: any[]) => void): void;
+    /**
+     * 取消事件监听
+     *
+     * @param event {string} - 事件名
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     */
+    off(event: string, func: (...args: any[]) => void): void;
+}
+export default TRTCMediaMixingManager;

package/liteav/extensions/MediaMixingManager/index.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRTCMediaMixingManager = exports.TRTCMediaSourceType = exports.TRTCMultiSourcePluginEvent = void 0;
+const events_1 = require("events");
+const NodeTRTCEngine = require('../../../build/Release/trtc_electron_sdk.node');
+var TRTCMultiSourcePluginEvent;
+(function (TRTCMultiSourcePluginEvent) {
+    // 合图插件异常（比如独立进程异常等）
+    TRTCMultiSourcePluginEvent["onError"] = "onError";
+})(TRTCMultiSourcePluginEvent = exports.TRTCMultiSourcePluginEvent || (exports.TRTCMultiSourcePluginEvent = {}));
+var TRTCMediaSourceType;
+(function (TRTCMediaSourceType) {
+    TRTCMediaSourceType[TRTCMediaSourceType["kCamera"] = 0] = "kCamera";
+    TRTCMediaSourceType[TRTCMediaSourceType["kScreen"] = 1] = "kScreen";
+    TRTCMediaSourceType[TRTCMediaSourceType["kImage"] = 2] = "kImage";
+    TRTCMediaSourceType[TRTCMediaSourceType["kRemoteVideo"] = 3] = "kRemoteVideo";
+})(TRTCMediaSourceType = exports.TRTCMediaSourceType || (exports.TRTCMediaSourceType = {}));
+const logger = console;
+class TRTCMediaMixingManager {
+    constructor() {
+        this.logPrefix = '[TRTCMediaMixingManager]';
+        if (!TRTCMediaMixingManager.mediaMixingManager) {
+            this.eventEmitter = new events_1.EventEmitter();
+            this.eventHandler = this.eventHandler.bind(this);
+            this.nodeMediaMixingPlugin = new NodeTRTCEngine.NodeRemoteMultiSourcePlugin();
+            this.nodeMediaMixingPlugin.setRemoteMultiSourcePluginCallback(this.eventHandler);
+            TRTCMediaMixingManager.mediaMixingManager = this;
+        }
+        else {
+            return TRTCMediaMixingManager.mediaMixingManager;
+        }
+    }
+    static getInstance() {
+        if (!TRTCMediaMixingManager.mediaMixingManager) {
+            TRTCMediaMixingManager.mediaMixingManager = new TRTCMediaMixingManager();
+        }
+        return TRTCMediaMixingManager.mediaMixingManager;
+    }
+    eventHandler(args) {
+        logger.log(`${this.logPrefix} event:`, args);
+        // const key = args[0] as string;
+        // const data = args[1] as { [key: string]: never };
+        // To do: 待完善
+    }
+    setMediaServerPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.setMediaServerPath(path);
+        });
+    }
+    // 设置显示参数
+    setDisplayParams(windowId, region) {
+        this.nodeMediaMixingPlugin.setDisplayParams(windowId, region);
+    }
+    addMediaSource(mediaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.addMediaSource(mediaSource);
+        });
+    }
+    removeMediaSource(mediaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.removeMediaSource(mediaSource);
+        });
+    }
+    updateMediaSource(mediaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.updateMediaSource(mediaSource);
+        });
+    }
+    muteMediaSource(mediaSource, mute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.muteMediaSource(mediaSource, mute);
+        });
+    }
+    setCameraCaptureParam(cameraID, params) {
+        this.nodeMediaMixingPlugin.setCameraCaptureParam(cameraID, params);
+    }
+    startPublish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.startPublish();
+        });
+    }
+    stopPublish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.stopPublish();
+        });
+    }
+    updatePublishParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.updatePublishParams(params);
+        });
+    }
+    /**
+     * 监听事件
+     *
+     * @param event {string} - 事件名称
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     * @param context {object} - 回调函数执行的上下文
+     */
+    on(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.on(event, func);
+    }
+    /**
+     * 取消事件监听
+     *
+     * @param event {string} - 事件名
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     */
+    off(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.off(event, func);
+    }
+}
+exports.TRTCMediaMixingManager = TRTCMediaMixingManager;
+exports.default = TRTCMediaMixingManager;