trtc-electron-sdk 12.1.608 → 12.2.701

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

@@ -0,0 +1,91 @@
+declare const NodeTRTCEngine: any;
+import { TRTCCameraCaptureParams, TRTCDeviceInfo, TRTCDeviceType, Rect } from '../../trtc_define';
+/**
+ * 设备管理器
+ */
+export declare class TRTCDeviceManager {
+    private logPrefix;
+    private static deviceNanager;
+    private static isIPCMode;
+    private nodeDeviceManager;
+    private promiseStore;
+    private eventEmitter;
+    constructor(options: {
+        isIPCMode: boolean;
+        nodeTRTCCloud: typeof NodeTRTCEngine.TRTCCloud | typeof NodeTRTCEngine.RemoteTRTCCloud;
+    });
+    /**
+     * 获取设备管理器
+     * @returns {TRTCDeviceManager}
+     */
+    static getInstance(options: {
+        isIPCMode: boolean;
+        nodeTRTCCloud: typeof NodeTRTCEngine.TRTCCloud | typeof NodeTRTCEngine.RemoteTRTCCloud;
+    }): TRTCDeviceManager;
+    /**
+     * 获取设备列表
+     *
+     * @param type {TRTCDeviceType} - 设备类型
+     * @returns {Array<TRTCDeviceInfo>}
+     */
+    getDevicesList(type: TRTCDeviceType): Array<TRTCDeviceInfo>;
+    setCurrentDevice(type: TRTCDeviceType, deviceId: string): Promise<void> | void;
+    getCurrentDevice(type: TRTCDeviceType): Promise<TRTCDeviceInfo> | TRTCDeviceInfo;
+    setCurrentDeviceVolume(type: TRTCDeviceType, volume: number): Promise<void> | void;
+    getCurrentDeviceVolume(type: TRTCDeviceType): Promise<number> | number;
+    setCurrentDeviceMute(type: TRTCDeviceType, mute: boolean): Promise<void> | void;
+    getCurrentDeviceMute(type: TRTCDeviceType): Promise<boolean> | boolean;
+    enableFollowingDefaultAudioDevice(type: TRTCDeviceType, enable: boolean): Promise<void> | void;
+    startMicDeviceTest(interval: number, playback?: boolean): Promise<void> | void;
+    stopMicDeviceTest(): Promise<void> | void;
+    startSpeakerDeviceTest(filePath: string): Promise<void> | void;
+    stopSpeakerDeviceTest(): Promise<void> | void;
+    setApplicationPlayVolume(volume: number): Promise<void> | void;
+    getApplicationPlayVolume(): Promise<number> | number;
+    setApplicationMuteState(mute: boolean): Promise<void> | void;
+    getApplicationMuteState(): Promise<boolean> | boolean;
+    setCameraCaptureParam(params: TRTCCameraCaptureParams): Promise<void> | 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;
+    private addPromise;
+    private removePromise;
+    private eventHandler;
+    private onDeviceChange;
+    private onSetCurrentDeviceFinished;
+    private onGetCurrentDeviceFinished;
+    private onSetCurrentDeviceVolumeFinished;
+    private onGetCurrentDeviceVolumeFinished;
+    private onSetCurrentDeviceMuteFinished;
+    private onGetCurrentDeviceMuteFinished;
+    private onEnableFollowingDefaultAudioDeviceFinished;
+    private onStartCameraDeviceTestFinished;
+    private onStopCameraDeviceTestFinished;
+    private onStartMicDeviceTestFinished;
+    private onStopMicDeviceTestFinished;
+    private onStartSpeakerDeviceTestFinished;
+    private onStopSpeakerDeviceTestFinished;
+    private onSetApplicationPlayVolumeFinished;
+    private onGetApplicationPlayVolumeFinished;
+    private onSetApplicationMuteStateFinished;
+    private onGetApplicationMuteStateFinished;
+    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 TRTCDeviceManager;

package/liteav/extensions/DeviceManager/index.js

@@ -0,0 +1,505 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRTCDeviceManager = void 0;
+const events_1 = require("events");
+const NodeTRTCEngine = require('../../../build/Release/trtc_electron_sdk.node');
+const trtc_define_1 = require("../../trtc_define");
+const logger = console;
+/**
+ * 设备管理器
+ */
+class TRTCDeviceManager {
+    constructor(options) {
+        this.logPrefix = '[TRTCDeviceManager]';
+        if (!TRTCDeviceManager.deviceNanager) {
+            this.promiseStore = new Map();
+            this.eventEmitter = new events_1.EventEmitter();
+            this.eventHandler = this.eventHandler.bind(this);
+            TRTCDeviceManager.isIPCMode = options.isIPCMode;
+            if (TRTCDeviceManager.isIPCMode) {
+                this.nodeDeviceManager = new NodeTRTCEngine.NodeRemoteDeviceManager();
+                this.nodeDeviceManager.setRemoteDeviceManagerCallback(this.eventHandler);
+            }
+            else {
+                this.nodeDeviceManager = options.nodeTRTCCloud;
+            }
+            TRTCDeviceManager.deviceNanager = this;
+        }
+        else {
+            return TRTCDeviceManager.deviceNanager;
+        }
+    }
+    /**
+     * 获取设备管理器
+     * @returns {TRTCDeviceManager}
+     */
+    static getInstance(options) {
+        if (!TRTCDeviceManager.deviceNanager) {
+            TRTCDeviceManager.deviceNanager = new TRTCDeviceManager(options);
+        }
+        return TRTCDeviceManager.deviceNanager;
+    }
+    /**
+     * 获取设备列表
+     *
+     * @param type {TRTCDeviceType} - 设备类型
+     * @returns {Array<TRTCDeviceInfo>}
+     */
+    getDevicesList(type) {
+        logger.debug(`${this.logPrefix}getDevicesList`, type);
+        const deviceInfos = this.nodeDeviceManager.getDevicesList(type);
+        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(`${this.logPrefix}camera device properties parse error.`, JSON.stringify(item));
+                    item.deviceProperties = {};
+                }
+            });
+        }
+        return deviceInfos;
+    }
+    setCurrentDevice(type, deviceId) {
+        logger.debug(`${this.logPrefix}setCurrentDevice`, type, deviceId);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `setCurrentDevice-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.setCurrentDevice(type, deviceId);
+            });
+        }
+        else {
+            this.nodeDeviceManager.setCurrentDevice(type, deviceId);
+        }
+    }
+    getCurrentDevice(type) {
+        logger.debug(`${this.logPrefix}getCurrentDevice`, type);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `getCurrentDevice-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.getCurrentDevice(type);
+            });
+        }
+        else {
+            return this.nodeDeviceManager.getCurrentDevice(type);
+        }
+    }
+    setCurrentDeviceVolume(type, volume) {
+        logger.debug(`${this.logPrefix}setCurrentDeviceVolume`, type, volume);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `setCurrentDeviceVolume-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.setCurrentDeviceVolume(type, volume);
+            });
+        }
+        else {
+            this.nodeDeviceManager.setCurrentDeviceVolume(type, volume);
+        }
+    }
+    getCurrentDeviceVolume(type) {
+        logger.debug(`${this.logPrefix}getCurrentDeviceVolume`, type);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `getCurrentDeviceVolume-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.getCurrentDeviceVolume(type);
+            });
+        }
+        else {
+            return this.nodeDeviceManager.getCurrentDeviceVolume(type);
+        }
+    }
+    setCurrentDeviceMute(type, mute) {
+        logger.debug(`${this.logPrefix}setCurrentDeviceMute`, type, mute);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `setCurrentDeviceMute-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.setCurrentDeviceMute(type, mute);
+            });
+        }
+        else {
+            this.nodeDeviceManager.setCurrentDeviceMute(type, mute);
+        }
+    }
+    getCurrentDeviceMute(type) {
+        logger.debug(`${this.logPrefix}getCurrentDeviceMute`);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `getCurrentDeviceMute-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.getCurrentDeviceMute(type);
+            });
+        }
+        else {
+            return this.nodeDeviceManager.getCurrentDeviceMute(type);
+        }
+    }
+    enableFollowingDefaultAudioDevice(type, enable) {
+        logger.debug(`${this.logPrefix}enableFollowingDefaultAudioDevice`, type, enable);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `enableFollowingDefaultAudioDevice-${type}`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.enableFollowingDefaultAudioDevice(type, enable);
+            });
+        }
+        else {
+            this.nodeDeviceManager.enableFollowingDefaultAudioDevice(type, enable);
+        }
+    }
+    startMicDeviceTest(interval, playback = false) {
+        logger.debug(`${this.logPrefix}startMicDeviceTest`, interval, playback);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `startMicDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.startMicDeviceTest(interval, playback);
+            });
+        }
+        else {
+            this.nodeDeviceManager.startMicDeviceTest(interval, playback);
+        }
+    }
+    stopMicDeviceTest() {
+        logger.debug(`${this.logPrefix}stopMicDeviceTest`);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `stopMicDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.stopMicDeviceTest();
+            });
+        }
+        else {
+            this.nodeDeviceManager.stopMicDeviceTest();
+        }
+    }
+    startSpeakerDeviceTest(filePath) {
+        logger.debug(`${this.logPrefix}startSpeakerDeviceTest`, filePath);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `startSpeakerDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.startSpeakerDeviceTest(filePath);
+            });
+        }
+        else {
+            this.nodeDeviceManager.startSpeakerDeviceTest(filePath);
+        }
+    }
+    stopSpeakerDeviceTest() {
+        logger.debug(`${this.logPrefix}stopSpeakerDeviceTest`);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `stopSpeakerDeviceTest`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.stopSpeakerDeviceTest();
+            });
+        }
+        else {
+            this.nodeDeviceManager.stopSpeakerDeviceTest();
+        }
+    }
+    setApplicationPlayVolume(volume) {
+        logger.debug(`${this.logPrefix}setApplicationPlayVolume`, volume);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `setApplicationPlayVolume`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.setApplicationPlayVolume(volume);
+            });
+        }
+        else {
+            this.nodeDeviceManager.setApplicationPlayVolume(volume);
+        }
+    }
+    getApplicationPlayVolume() {
+        logger.debug(`${this.logPrefix}getApplicationPlayVolume`);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `getApplicationPlayVolume`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.getApplicationPlayVolume();
+            });
+        }
+        else {
+            return this.nodeDeviceManager.getApplicationPlayVolume();
+        }
+    }
+    setApplicationMuteState(mute) {
+        logger.debug(`${this.logPrefix}setApplicationMuteState`, mute);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `setApplicationMuteState`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.setApplicationMuteState(mute);
+            });
+        }
+        else {
+            this.nodeDeviceManager.setApplicationMuteState(mute);
+        }
+    }
+    getApplicationMuteState() {
+        logger.debug(`${this.logPrefix}getApplicationMuteState`);
+        if (TRTCDeviceManager.isIPCMode) {
+            return new Promise((resolve, reject) => {
+                const key = `setApplicationMuteState`;
+                this.addPromise(key, resolve, reject);
+                this.nodeDeviceManager.getApplicationMuteState();
+            });
+        }
+        else {
+            return this.nodeDeviceManager.getApplicationMuteState();
+        }
+    }
+    setCameraCaptureParam(params) {
+        logger.debug(`${this.logPrefix}setCameraCaptureParam:`, params);
+        if (TRTCDeviceManager.isIPCMode) {
+            return this.nodeDeviceManager.setCameraCapturerParam(params);
+        }
+        else {
+            this.nodeDeviceManager.setCameraCaptureParam(params);
+        }
+    }
+    /**
+     * 监听事件
+     *
+     * @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);
+    }
+    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 "onDeviceChanged":
+                this.onDeviceChange(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;
+        }
+    }
+    onDeviceChange(deviceId, type, state) {
+        var _a;
+        logger.debug(`${this.logPrefix}onDeviceChange`, deviceId, type, state);
+        (_a = this.eventEmitter) === null || _a === void 0 ? void 0 : _a.emit('onDeviceChange', 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);
+    }
+    // ******   这一部分接口暴露不合理，暂时通过 TRTCMediaMixingManager 暴露给用户   **************/
+    startCameraDeviceTest(windowID, rect) {
+        logger.debug(`${this.logPrefix}startCameraDeviceTest`, windowID, rect);
+        let newWindowID = 0;
+        if (windowID instanceof Uint8Array) {
+            for (let i = windowID.length - 1; i >= 0; i--) {
+                newWindowID = (newWindowID * 256) + windowID[i];
+            }
+        }
+        else {
+            newWindowID = windowID;
+        }
+        return new Promise((resolve, reject) => {
+            const key = `startCameraDeviceTest`;
+            this.addPromise(key, resolve, reject);
+            this.nodeDeviceManager.startCameraDeviceTest(newWindowID, rect);
+        });
+    }
+    stopCameraDeviceTest() {
+        logger.debug(`${this.logPrefix}stopCameraDeviceTest`);
+        return new Promise((resolve, reject) => {
+            const key = `stopCameraDeviceTest`;
+            this.addPromise(key, resolve, reject);
+            this.nodeDeviceManager.stopCameraDeviceTest();
+        });
+    }
+    setCameraTestRenderMirror(mirror) {
+        logger.debug(`${this.logPrefix}setCameraTestRenderMirror`, mirror);
+        this.nodeDeviceManager.setCameraTestRenderMirror(mirror);
+    }
+    setCameraTestDeviceId(cameraId) {
+        logger.debug(`${this.logPrefix}setCameraTestDeviceId`, cameraId);
+        this.nodeDeviceManager.setCameraTestDeviceId(cameraId);
+    }
+    setCameraTestResolution(width, height) {
+        logger.debug(`${this.logPrefix}setCameraTestResolution`, width, height);
+        this.nodeDeviceManager.setCameraTestResolution(width, height);
+    }
+    setCameraTestVideoPluginPath(path) {
+        logger.debug(`${this.logPrefix}setCameraTestVideoPluginPath`, path);
+        this.nodeDeviceManager.setCameraTestVideoPluginPath(path);
+    }
+    setCameraTestVideoPluginParameter(params) {
+        logger.debug(`${this.logPrefix}setCameraTestVideoPluginParameter`, params);
+        this.nodeDeviceManager.setCameraTestVideoPluginParameter(params);
+    }
+}
+exports.TRTCDeviceManager = TRTCDeviceManager;
+exports.default = TRTCDeviceManager;