trtc-electron-sdk 12.1.608 → 12.2.701

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

@@ -0,0 +1,132 @@
+import { TRTCVideoEncParam, TRTCVideoRotation, TRTCVideoFillMode, TRTCVideoMirrorType, TRTCCameraCaptureParams, Rect } from '../../trtc_define';
+import { TRTCDeviceManager } from '../DeviceManager';
+export { TRTCLocalMediaTranscodingParams } from '../../LocalMediaTranscoder/index';
+export declare enum TRTCMediaMixingEvent {
+    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: Rect;
+    isSelected?: boolean;
+    rotation?: TRTCVideoRotation;
+    fillMode?: TRTCVideoFillMode;
+    mirrorType?: TRTCVideoMirrorType;
+};
+export declare type TRTCMediaMixingEncParam = {
+    videoEncoderParams: TRTCVideoEncParam;
+    canvasColor: number;
+};
+/**
+ * 本地混流管理器
+ */
+export declare class TRTCMediaMixingManager {
+    private logPrefix;
+    private static mediaMixingManager;
+    private nodeMediaMixingPlugin;
+    private deviceManager;
+    private eventEmitter;
+    constructor(options: {
+        deviceManager: TRTCDeviceManager;
+    });
+    /**
+     * 获取混流管理器
+     *
+     * @returns {TRTCMediaMixingManager}
+     */
+    static getInstance(options: {
+        deviceManager: TRTCDeviceManager;
+    }): TRTCMediaMixingManager;
+    private eventHandler;
+    /**
+     * 设置混流视频预览参数
+     *
+     * @param windowID {Number|Uint8Array} - 操作系统层的窗口 ID，Electron 下可以通过 getNativeWindowID 接口获取
+     * @param region {Rect} - 视频在窗口中的显示区域
+     */
+    setDisplayParams(windowID: number | Uint8Array, region: Rect): void;
+    /**
+     * 添加媒体源
+     * @param mediaSource {TRTCMediaSource} - 媒体源信息
+     * @returns {Promise<Rect>}
+     */
+    addMediaSource(mediaSource: TRTCMediaSource): Promise<Rect>;
+    /**
+     * 删除媒体源
+     * @param mediaSource {TRTCMediaSource} - 媒体源信息
+     * @returns {Promise<void>}
+     */
+    removeMediaSource(mediaSource: TRTCMediaSource): Promise<void>;
+    /**
+     * 更新媒体源
+     * @param mediaSource {TRTCMediaSource} - 媒体源信息
+     * @returns {Promise<void>}
+     */
+    updateMediaSource(mediaSource: TRTCMediaSource): Promise<void>;
+    /**
+     * 设置摄像头采集参数
+     * @param cameraID {string} - 摄像头 ID
+     * @param params {TRTCCameraCaptureParams} - 摄像头采集参数
+     */
+    setCameraCaptureParam(cameraID: string, params: TRTCCameraCaptureParams): void;
+    /**
+     * 开始推流
+     * @returns {Promise<void>}
+     */
+    startPublish(): Promise<void>;
+    /**
+     * 停止推流
+     * @returns {Promise<void>}
+     */
+    stopPublish(): Promise<void>;
+    /**
+     * 更新本地混流编码参数
+     * @param params {TRTCMediaMixingEncParam} - 推流视频编码参数、背景色等参数
+     * @returns {Promise<void>}
+     */
+    updatePublishParams(params: TRTCMediaMixingEncParam): Promise<void>;
+    /**
+     * @private
+   * 设置服务进程程序路径
+   *
+   * 开发模式，默认路径：node_modules\\trtc-electron-sdk\\build\\Release\\liteav_media_server.exe
+   * 构建模式，默认路径：${resourcesPath}\\liteav_media_server.exe
+   *
+   * 如果用户应用有特殊配置，默认路径可能找不到服务进程程序，需要自行传入路径。
+   *
+   * @param path {string} - 设置服务进程程序路径
+   *
+   * @returns {Promise<void>}
+   */
+    setMediaServerPath(path: string): Promise<void>;
+    /**
+     * 注册事件监听
+     *
+     * @param event {string} - 事件名称
+     * @param func {Function} - 事件回调函数
+     */
+    on(event: string, func: (...args: any[]) => void): void;
+    /**
+     * 取消事件监听
+     *
+     * @param event {string} - 事件名
+     * @param func {Function} - 事件回调函数
+     */
+    off(event: string, func: (...args: any[]) => void): void;
+    startCameraDeviceTest(windowID: number | Uint8Array, rect?: Rect): Promise<number>;
+    stopCameraDeviceTest(): Promise<number>;
+    setCameraTestRenderMirror(mirror: boolean): void;
+    setCameraTestDeviceId(cameraId: string): void;
+    setCameraTestResolution(width: number, height: number): void;
+    setCameraTestVideoPluginPath(path: string): void;
+    setCameraTestVideoPluginParameter(params: string): void;
+}
+export default TRTCMediaMixingManager;

package/liteav/extensions/MediaMixingManager/index.js

@@ -0,0 +1,224 @@
+"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.TRTCMediaMixingEvent = void 0;
+const events_1 = require("events");
+const NodeTRTCEngine = require('../../../build/Release/trtc_electron_sdk.node');
+var TRTCMediaMixingEvent;
+(function (TRTCMediaMixingEvent) {
+    // 合图插件异常（比如独立进程异常等）
+    TRTCMediaMixingEvent["onError"] = "onError";
+})(TRTCMediaMixingEvent = exports.TRTCMediaMixingEvent || (exports.TRTCMediaMixingEvent = {}));
+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(options) {
+        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);
+            this.deviceManager = options.deviceManager;
+            TRTCMediaMixingManager.mediaMixingManager = this;
+            this.setMediaServerPath('');
+        }
+        else {
+            return TRTCMediaMixingManager.mediaMixingManager;
+        }
+    }
+    /**
+     * 获取混流管理器
+     *
+     * @returns {TRTCMediaMixingManager}
+     */
+    static getInstance(options) {
+        if (!TRTCMediaMixingManager.mediaMixingManager) {
+            TRTCMediaMixingManager.mediaMixingManager = new TRTCMediaMixingManager(options);
+        }
+        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: 待完善
+    }
+    /**
+     * 设置混流视频预览参数
+     *
+     * @param windowID {Number|Uint8Array} - 操作系统层的窗口 ID，Electron 下可以通过 getNativeWindowID 接口获取
+     * @param region {Rect} - 视频在窗口中的显示区域
+     */
+    setDisplayParams(windowID, region) {
+        let newWindowID = 0;
+        if (windowID instanceof Uint8Array) {
+            for (let i = windowID.length - 1; i >= 0; i--) {
+                newWindowID = (newWindowID * 256) + windowID[i];
+            }
+        }
+        else {
+            newWindowID = windowID;
+        }
+        this.nodeMediaMixingPlugin.setDisplayParams(newWindowID, region);
+    }
+    /**
+     * 添加媒体源
+     * @param mediaSource {TRTCMediaSource} - 媒体源信息
+     * @returns {Promise<Rect>}
+     */
+    addMediaSource(mediaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.addMediaSource(mediaSource);
+        });
+    }
+    /**
+     * 删除媒体源
+     * @param mediaSource {TRTCMediaSource} - 媒体源信息
+     * @returns {Promise<void>}
+     */
+    removeMediaSource(mediaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.removeMediaSource(mediaSource);
+        });
+    }
+    /**
+     * 更新媒体源
+     * @param mediaSource {TRTCMediaSource} - 媒体源信息
+     * @returns {Promise<void>}
+     */
+    updateMediaSource(mediaSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.updateMediaSource(mediaSource);
+        });
+    }
+    /**
+     * 设置摄像头采集参数
+     * @param cameraID {string} - 摄像头 ID
+     * @param params {TRTCCameraCaptureParams} - 摄像头采集参数
+     */
+    setCameraCaptureParam(cameraID, params) {
+        this.nodeMediaMixingPlugin.setCameraCaptureParam(cameraID, params);
+    }
+    /**
+     * 开始推流
+     * @returns {Promise<void>}
+     */
+    startPublish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.startPublish();
+        });
+    }
+    /**
+     * 停止推流
+     * @returns {Promise<void>}
+     */
+    stopPublish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.stopPublish();
+        });
+    }
+    /**
+     * 更新本地混流编码参数
+     * @param params {TRTCMediaMixingEncParam} - 推流视频编码参数、背景色等参数
+     * @returns {Promise<void>}
+     */
+    updatePublishParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.nodeMediaMixingPlugin.updatePublishParams(params);
+        });
+    }
+    /**
+     * @private
+   * 设置服务进程程序路径
+   *
+   * 开发模式，默认路径：node_modules\\trtc-electron-sdk\\build\\Release\\liteav_media_server.exe
+   * 构建模式，默认路径：${resourcesPath}\\liteav_media_server.exe
+   *
+   * 如果用户应用有特殊配置，默认路径可能找不到服务进程程序，需要自行传入路径。
+   *
+   * @param path {string} - 设置服务进程程序路径
+   *
+   * @returns {Promise<void>}
+   */
+    setMediaServerPath(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let serverPath = '';
+            if (path && path.trim() !== '') {
+                serverPath = path;
+            }
+            else {
+                const { resourcesPath, execPath } = globalThis.process;
+                if (execPath.endsWith('electron.exe')) {
+                    serverPath = '..\\..\\..\\..\\node_modules\\trtc-electron-sdk\\build\\Release\\liteav_media_server.exe';
+                }
+                else {
+                    serverPath = `${resourcesPath}\\liteav_media_server.exe`;
+                }
+            }
+            logger.log(`${this.logPrefix} server path:${serverPath}`);
+            return yield this.nodeMediaMixingPlugin.setMediaServerPath(serverPath);
+        });
+    }
+    /**
+     * 注册事件监听
+     *
+     * @param event {string} - 事件名称
+     * @param func {Function} - 事件回调函数
+     */
+    on(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.on(event, func);
+    }
+    /**
+     * 取消事件监听
+     *
+     * @param event {string} - 事件名
+     * @param func {Function} - 事件回调函数
+     */
+    off(event, func) {
+        var _a;
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.off(event, func);
+    }
+    // ******   这一部分接口暴露不合理，暂时不对暴露在 API 文档上   **************/
+    startCameraDeviceTest(windowID, rect) {
+        return this.deviceManager.startCameraDeviceTest(windowID, rect);
+    }
+    stopCameraDeviceTest() {
+        return this.deviceManager.stopCameraDeviceTest();
+    }
+    setCameraTestRenderMirror(mirror) {
+        this.deviceManager.setCameraTestRenderMirror(mirror);
+    }
+    setCameraTestDeviceId(cameraId) {
+        this.deviceManager.setCameraTestDeviceId(cameraId);
+    }
+    setCameraTestResolution(width, height) {
+        this.deviceManager.setCameraTestResolution(width, height);
+    }
+    setCameraTestVideoPluginPath(path) {
+        this.deviceManager.setCameraTestVideoPluginPath(path);
+    }
+    setCameraTestVideoPluginParameter(params) {
+        this.deviceManager.setCameraTestVideoPluginParameter(params);
+    }
+}
+exports.TRTCMediaMixingManager = TRTCMediaMixingManager;
+exports.default = TRTCMediaMixingManager;

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

@@ -0,0 +1,62 @@
+import { TRTCPluginType, TRTCVideoProcessPluginOptions, TRTCMediaEncryptDecryptPluginOptions, TRTCAudioProcessPluginOptions, TRTCPluginInfo } from "../../trtc_define";
+declare const NodeTRTCEngine: any;
+/**
+ * TRTC 插件
+ */
+export declare class TRTCPlugin {
+    private logPrefix;
+    private pluginId;
+    private device_id;
+    private nativeVideoEffectPlugin;
+    constructor(pluginId: string, deviceId: string, nativeVideoEffectPlugin: typeof NodeTRTCEngine.NodeRemoteVideoPlugin);
+    get deviceId(): string;
+    get id(): string;
+    enable(flag?: boolean): void;
+    /**
+     * @deprecated
+     */
+    disable(): void;
+    setParameter(param: string): void;
+}
+/**
+ * TRTC 插件管理器
+ */
+export declare class TRTCPluginManager {
+    private logPrefix;
+    private static pluginManager;
+    private static isIPCMode;
+    private nodePluginManager;
+    private videoProcessBufferType;
+    private videoProcessPixelFormat;
+    constructor(options: {
+        isIPCMode: boolean;
+        nodeTRTCCloud: typeof NodeTRTCEngine.TRTCCloud | typeof NodeTRTCEngine.RemoteTRTCCloud;
+    });
+    /**
+     * 获取插件管理器
+     *
+     * @returns {TRTCPluginManager}
+     */
+    static getInstance(options: {
+        isIPCMode: boolean;
+        nodeTRTCCloud: typeof NodeTRTCEngine.TRTCCloud | typeof NodeTRTCEngine.RemoteTRTCCloud;
+    }): TRTCPluginManager;
+    setPluginParams(type: TRTCPluginType, options: TRTCVideoProcessPluginOptions | TRTCMediaEncryptDecryptPluginOptions | TRTCAudioProcessPluginOptions): void;
+    private _setVideoProcessPluginParams;
+    private _setMediaEncryptDecryptPluginParams;
+    private _setAudioProcessPluginParams;
+    addPlugin(options: {
+        id: string;
+        path: string;
+        type?: TRTCPluginType;
+        deviceId?: string;
+    }): TRTCPluginInfo;
+    private _createPlugin;
+    removePlugin(pluginId: string, deviceId: string): void;
+    setCallback(callback: (pluginId: string, error: number, errorMessage: string) => void): void;
+    /**
+     * @deprecated
+     */
+    getPluginList(): TRTCPluginInfo[] | null;
+}
+export default TRTCPluginManager;

package/liteav/extensions/PluginManager/index.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRTCPluginManager = exports.TRTCPlugin = void 0;
+const trtc_define_1 = require("../../trtc_define");
+const NodeTRTCEngine = require('../../../build/Release/trtc_electron_sdk.node');
+const logger = console;
+/**
+ * TRTC 插件
+ */
+class TRTCPlugin {
+    constructor(pluginId, deviceId, nativeVideoEffectPlugin) {
+        this.logPrefix = "[TRTCPlugin]";
+        this.pluginId = pluginId;
+        this.device_id = deviceId;
+        this.nativeVideoEffectPlugin = nativeVideoEffectPlugin;
+    }
+    get deviceId() {
+        return this.device_id;
+    }
+    get id() {
+        return this.pluginId;
+    }
+    enable(flag = true) {
+        logger.log(`${this.logPrefix}enable:${flag} ${this.pluginId}`);
+        this.nativeVideoEffectPlugin.enable(flag);
+    }
+    /**
+     * @deprecated
+     */
+    disable() {
+        this.enable(false);
+    }
+    setParameter(param) {
+        logger.log(`${this.logPrefix}setParameter:${this.pluginId}`);
+        this.nativeVideoEffectPlugin.setParameter(param);
+    }
+}
+exports.TRTCPlugin = TRTCPlugin;
+/**
+ * TRTC 插件管理器
+ */
+class TRTCPluginManager {
+    constructor(options) {
+        this.logPrefix = '[TRTCPluginManager]';
+        this.videoProcessBufferType = trtc_define_1.TRTCVideoBufferType.TRTCVideoBufferType_Buffer;
+        this.videoProcessPixelFormat = trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_I420;
+        if (!TRTCPluginManager.pluginManager) {
+            TRTCPluginManager.isIPCMode = options.isIPCMode;
+            if (TRTCPluginManager.isIPCMode) {
+                this.nodePluginManager = new NodeTRTCEngine.NodeRemoteVideoPluginManager();
+            }
+            else {
+                this.videoProcessBufferType = trtc_define_1.TRTCVideoBufferType.TRTCVideoBufferType_Buffer;
+                this.videoProcessPixelFormat = trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_I420;
+                this.nodePluginManager = options.nodeTRTCCloud;
+            }
+            TRTCPluginManager.pluginManager = this;
+        }
+        else {
+            return TRTCPluginManager.pluginManager;
+        }
+    }
+    ;
+    /**
+     * 获取插件管理器
+     *
+     * @returns {TRTCPluginManager}
+     */
+    static getInstance(options) {
+        if (!TRTCPluginManager.pluginManager) {
+            TRTCPluginManager.pluginManager = new TRTCPluginManager(options);
+        }
+        return TRTCPluginManager.pluginManager;
+    }
+    setPluginParams(type, options) {
+        logger.log(`${this.logPrefix}setPluginParams params:`, type, options);
+        if (TRTCPluginManager.isIPCMode) {
+            if (type === trtc_define_1.TRTCPluginType.TRTCPluginTypeVideoProcess) {
+                this.nodePluginManager.setVideoPluginFormat(trtc_define_1.TRTCVideoBufferType.TRTCVideoBufferType_Buffer, options.pixelFormat);
+            }
+            else {
+                logger.log(`${this.logPrefix}setPluginParams not supported params:`, type, options);
+            }
+        }
+        else {
+            switch (type) {
+                case trtc_define_1.TRTCPluginType.TRTCPluginTypeVideoProcess:
+                    this._setVideoProcessPluginParams(options);
+                    break;
+                case trtc_define_1.TRTCPluginType.TRTCPluginTypeMediaEncryptDecrypt:
+                    this._setMediaEncryptDecryptPluginParams(options);
+                    break;
+                case trtc_define_1.TRTCPluginType.TRTCPluginTypeAudioProcess:
+                    this._setAudioProcessPluginParams(options);
+                    break;
+                default:
+                    logger.log(`setPluginParams invalid type:${type}`);
+                    break;
+            }
+        }
+    }
+    _setVideoProcessPluginParams(options) {
+        if (options.pixelFormat !== undefined) {
+            switch (options.pixelFormat) {
+                case trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_I420:
+                case trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_RGBA32:
+                case trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_BGRA32:
+                    this.videoProcessBufferType = trtc_define_1.TRTCVideoBufferType.TRTCVideoBufferType_Buffer;
+                    break;
+                case trtc_define_1.TRTCVideoPixelFormat.TRTCVideoPixelFormat_Texture_2D:
+                    this.videoProcessBufferType = trtc_define_1.TRTCVideoBufferType.TRTCVideoBufferType_Texture;
+                    break;
+                default:
+                    logger.error(`${this.logPrefix}setPluginParams() unspported pixelFormat: ${options.pixelFormat}`);
+                    return;
+            }
+            this.videoProcessPixelFormat = options.pixelFormat;
+        }
+        if (options.enable !== undefined) {
+            this.nodePluginManager.enableLocalVideoCustomProcess(!!options.enable, this.videoProcessPixelFormat, this.videoProcessBufferType);
+        }
+    }
+    _setMediaEncryptDecryptPluginParams(options) {
+        if (options.enable !== undefined) {
+            this.nodePluginManager.enableEncodedDataCustomProcess(!!options.enable);
+        }
+    }
+    _setAudioProcessPluginParams(options) {
+        if (options.enable !== undefined) {
+            this.nodePluginManager.enableAudioFrameCustomProcess(!!options.enable);
+        }
+    }
+    addPlugin(options) {
+        logger.log(`${this.logPrefix}addPlugin options:`, options);
+        if (TRTCPluginManager.isIPCMode) {
+            const nativeVideoEffectPlugin = this.nodePluginManager.addVideoPlugin(options.deviceId, options.id, options.path);
+            return new TRTCPlugin(options.id, options.deviceId || '', nativeVideoEffectPlugin);
+        }
+        else {
+            const pluginType = options.type || trtc_define_1.TRTCPluginType.TRTCPluginTypeVideoProcess;
+            const realDeviceId = options.deviceId || "";
+            this.nodePluginManager.registerPlugin(options.id, options.path, pluginType, realDeviceId);
+            return this._createPlugin(options.id, realDeviceId);
+        }
+    }
+    _createPlugin(pluginId, deviceId) {
+        return {
+            id: pluginId,
+            deviceId: deviceId || "",
+            enable: (flag = true) => {
+                return this.nodePluginManager.enablePlugin(pluginId, flag, deviceId || "");
+            },
+            disable: () => {
+                return this.nodePluginManager.enablePlugin(pluginId, false, deviceId || "");
+            },
+            setParameter: (param) => {
+                return this.nodePluginManager.setPluginParameter(pluginId, param, deviceId || "");
+            }
+        };
+    }
+    removePlugin(pluginId, deviceId) {
+        logger.log(`${this.logPrefix}removePlugin pluginId:${pluginId} deviceId:${deviceId}`);
+        if (TRTCPluginManager.isIPCMode) {
+            this.nodePluginManager.removeVideoPlugin(deviceId, pluginId);
+        }
+        else {
+            this.nodePluginManager.unregisterPlugin(pluginId, deviceId || "");
+        }
+    }
+    setCallback(callback) {
+        if (TRTCPluginManager.isIPCMode) {
+            this.nodePluginManager.setCallback(callback);
+        }
+        else {
+            this.nodePluginManager.setPluginCallback(callback);
+        }
+    }
+    /**
+     * @deprecated
+     */
+    getPluginList() {
+        logger.log(`${this.logPrefix}getPluginList`);
+        if (TRTCPluginManager.isIPCMode) {
+            logger.warn(`${this.logPrefix}getPluginList not supported`);
+            return null;
+        }
+        else {
+            return this.nodePluginManager.getPluginIds().map((item) => {
+                const ids = item.split('__');
+                return this._createPlugin(ids[0], ids[1]);
+            });
+        }
+    }
+}
+exports.TRTCPluginManager = TRTCPluginManager;
+exports.default = TRTCPluginManager;