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

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

@@ -0,0 +1,44 @@
+import { TRTCVoiceReverbType, TRTCVoiceChangerType, TRTCAudioMusicParam } from '../../trtc_define';
+export declare class TRTCAudioEffectManager {
+    private logPrefix;
+    private static audioEffectManager;
+    private nativeAudioEffectManager;
+    private promiseStore;
+    constructor();
+    static getInstance(): TRTCAudioEffectManager;
+    enableVoiceEarMonitor(enable: boolean): void;
+    setVoiceEarMonitorVolume(volume: number): void;
+    setVoiceReverbType(type: TRTCVoiceReverbType): void;
+    setVoiceChangerType(type: TRTCVoiceChangerType): void;
+    setVoiceCaptureVolume(volume: number): void;
+    setVoicePitch(pitch: number): void;
+    setMusicObserver(observer: {
+        onStart: (id: number, errCode: number) => void;
+        onPlayProgress: (id: number, curPtsMS: number, durationMS: number) => void;
+        onComplete: (id: number, errCode: number) => void;
+    }): void;
+    startPlayMusic(param: TRTCAudioMusicParam): void;
+    stopPlayMusic(id: number): void;
+    pausePlayMusic(id: number): void;
+    resumePlayMusic(id: number): void;
+    setAllMusicVolume(volume: number): void;
+    setMusicPublishVolume(id: number, volume: number): void;
+    setMusicPlayoutVolume(id: number, volume: number): void;
+    setMusicPitch(id: number, pitch: number): void;
+    setMusicSpeedRate(id: number, speedRate: number): void;
+    getMusicCurrentPosInMS(id: number): Promise<number>;
+    getMusicDurationInMS(path: string): Promise<number>;
+    seekMusicToPosInTime(id: number, pts: number): void;
+    setMusicScratchSpeedRate(id: number, speedRate: number): void;
+    setPreloadObserver(observer: {
+        onLoadProgress: (id: number, progress: number) => void;
+        onLoadError: (id: number, errCode: number) => void;
+    }): void;
+    preloadMusic(param: TRTCAudioMusicParam): void;
+    getMusicTrackCount(id: number): Promise<number>;
+    setMusicTrack(id: number, trackIndex: number): void;
+    private eventHandler;
+    private addPromise;
+    private removePromise;
+}
+export default TRTCAudioEffectManager;

package/liteav/extensions/AudioEffectManager/index.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRTCAudioEffectManager = void 0;
+const NodeTRTCEngine = require('../../../build/Release/trtc_electron_sdk.node');
+// To do: 待替换为 SDK JS 层 Logger
+const logger = console;
+class TRTCAudioEffectManager {
+    constructor() {
+        this.logPrefix = "[TRTCAudioEffectManager]";
+        if (!TRTCAudioEffectManager.audioEffectManager) {
+            this.promiseStore = new Map();
+            this.nativeAudioEffectManager = new NodeTRTCEngine.NodeRemoteAudioEffectManager();
+            this.eventHandler = this.eventHandler.bind(this);
+            this.nativeAudioEffectManager.setRemoteAudioEffectManagerCallback(this.eventHandler);
+            TRTCAudioEffectManager.audioEffectManager = this;
+        }
+        else {
+            return TRTCAudioEffectManager.audioEffectManager;
+        }
+    }
+    static getInstance() {
+        if (!TRTCAudioEffectManager.audioEffectManager) {
+            TRTCAudioEffectManager.audioEffectManager = new TRTCAudioEffectManager();
+        }
+        return TRTCAudioEffectManager.audioEffectManager;
+    }
+    enableVoiceEarMonitor(enable) {
+        this.nativeAudioEffectManager.enableVoiceEarMonitor(enable);
+    }
+    setVoiceEarMonitorVolume(volume) {
+        this.nativeAudioEffectManager.setVoiceEarMonitorVolume(volume);
+    }
+    setVoiceReverbType(type) {
+        logger.debug(`${this.logPrefix}setVoiceReverbType: ${type}`);
+        this.nativeAudioEffectManager.setVoiceReverbType(type);
+    }
+    setVoiceChangerType(type) {
+        logger.debug(`${this.logPrefix}setVoiceChangerType: ${type}`);
+        this.nativeAudioEffectManager.setVoiceChangerType(type);
+    }
+    setVoiceCaptureVolume(volume) {
+        this.nativeAudioEffectManager.setVoiceCaptureVolume(volume);
+    }
+    setVoicePitch(pitch) {
+        this.nativeAudioEffectManager.setVoicePitch(pitch);
+    }
+    setMusicObserver(observer) {
+        this.nativeAudioEffectManager.setMusicObserver(observer.onStart, observer.onPlayProgress, observer.onComplete);
+    }
+    startPlayMusic(param) {
+        this.nativeAudioEffectManager.startPlayMusic(param);
+    }
+    stopPlayMusic(id) {
+        this.nativeAudioEffectManager.stopPlayMusic(id);
+    }
+    pausePlayMusic(id) {
+        this.nativeAudioEffectManager.pausePlayMusic(id);
+    }
+    resumePlayMusic(id) {
+        this.nativeAudioEffectManager.resumePlayMusic(id);
+    }
+    setAllMusicVolume(volume) {
+        this.nativeAudioEffectManager.setAllMusicVolume(volume);
+    }
+    setMusicPublishVolume(id, volume) {
+        this.nativeAudioEffectManager.setMusicPublishVolume(id, volume);
+    }
+    setMusicPlayoutVolume(id, volume) {
+        this.nativeAudioEffectManager.setMusicPlayoutVolume(id, volume);
+    }
+    setMusicPitch(id, pitch) {
+        this.nativeAudioEffectManager.setMusicPitch(id, pitch);
+    }
+    setMusicSpeedRate(id, speedRate) {
+        this.nativeAudioEffectManager.setMusicSpeedRate(id, speedRate);
+    }
+    getMusicCurrentPosInMS(id) {
+        logger.debug(`${this.logPrefix}getMusicCurrentPosInMS: ${id}`);
+        const promise = new Promise((resolve, reject) => {
+            const key = `onGetMusicCurrentPosInMS-${id}`;
+            this.addPromise(key, resolve, reject);
+            this.nativeAudioEffectManager.getMusicCurrentPosInMS(id);
+        });
+        return promise;
+    }
+    getMusicDurationInMS(path) {
+        logger.debug(`${this.logPrefix}getMusicDurationInMS: ${path}`);
+        const promise = new Promise((resolve, reject) => {
+            const key = `onGetMusicDurationInMS-${path}`;
+            this.addPromise(key, resolve, reject);
+            this.nativeAudioEffectManager.getMusicDurationInMS(path);
+        });
+        return promise;
+    }
+    seekMusicToPosInTime(id, pts) {
+        this.nativeAudioEffectManager.seekMusicToPosInTime(id, pts);
+    }
+    setMusicScratchSpeedRate(id, speedRate) {
+        this.nativeAudioEffectManager.setMusicScratchSpeedRate(id, speedRate);
+    }
+    setPreloadObserver(observer) {
+        this.nativeAudioEffectManager.setPreloadObserver(observer.onLoadProgress, observer.onLoadError);
+    }
+    preloadMusic(param) {
+        this.nativeAudioEffectManager.preloadMusic(param);
+    }
+    getMusicTrackCount(id) {
+        logger.debug(`${this.logPrefix}getMusicTrackCount: ${id}`);
+        const promise = new Promise((resolve, reject) => {
+            const key = `onGetMusicTrackCount-${id}`;
+            this.addPromise(key, resolve, reject);
+            this.nativeAudioEffectManager.getMusicTrackCount(id);
+        });
+        return promise;
+    }
+    setMusicTrack(id, trackIndex) {
+        this.nativeAudioEffectManager.setMusicTrack(id, trackIndex);
+    }
+    eventHandler(args) {
+        logger.debug(`${this.logPrefix} event:`, args);
+        const key = args[0];
+        const data = args[1];
+        logger.debug(`${this.logPrefix} event key: ${key} data:`, data);
+        switch (key) {
+            case "onGetMusicCurrentPosInMS":
+                this.removePromise(`${key}-${data.id}`, data.currentPos);
+                break;
+            case 'onGetMusicDurationInMS':
+                this.removePromise(`${key}-${data.path}`, data.durationInMS);
+                break;
+            case 'onGetMusicTrackCount':
+                this.removePromise(`${key}-${data.id}`, data.trackCount);
+                break;
+            default:
+                logger.warn(`${this.logPrefix}eventHandler un-supported event:`, key);
+        }
+    }
+    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);
+        }
+    }
+}
+exports.TRTCAudioEffectManager = TRTCAudioEffectManager;
+exports.default = TRTCAudioEffectManager;

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

@@ -0,0 +1,99 @@
+import { TRTCCameraCaptureParams, TRTCDeviceInfo, TRTCDeviceType, TRTCRect } from '../../trtc_define';
+/**
+ * 音视频设备事件类型
+ */
+export declare enum TRTCDeviceEventType {
+    /** 设备状态变更 */
+    onDeviceChanged = "onDeviceChanged"
+}
+export declare class TRTCDeviceManager {
+    private logPrefix;
+    private static deviceNanager;
+    private nodeDeviceManagerPlugin;
+    private promiseStore;
+    private eventEmitter;
+    constructor();
+    static getInstance(): TRTCDeviceManager;
+    /**
+     *
+     * @returns
+     *
+     * @deprecated
+     */
+    getCameraDevicesList(): Array<TRTCDeviceInfo>;
+    /**
+     *
+     * @returns
+     *
+     * @deprecated
+     */
+    getMicDevicesList(): Array<TRTCDeviceInfo>;
+    /**
+     *
+     * @returns
+     *
+     * @deprecated
+     */
+    getSpeakerDevicesList(): Array<TRTCDeviceInfo>;
+    getDevicesList(type: TRTCDeviceType): Array<TRTCDeviceInfo>;
+    setCurrentDevice(type: TRTCDeviceType, deviceId: string): Promise<number>;
+    getCurrentDevice(type: TRTCDeviceType): Promise<TRTCDeviceInfo>;
+    setCurrentDeviceVolume(type: TRTCDeviceType, volume: number): Promise<number>;
+    getCurrentDeviceVolume(type: TRTCDeviceType): Promise<number>;
+    setCurrentDeviceMute(type: TRTCDeviceType, mute: boolean): Promise<number>;
+    getCurrentDeviceMute(type: TRTCDeviceType): Promise<boolean>;
+    enableFollowingDefaultAudioDevice(type: TRTCDeviceType, enable: boolean): Promise<number>;
+    startCameraDeviceTest(windowID: number, rect: TRTCRect): 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;
+    startMicDeviceTest(interval: number, playback?: boolean): Promise<number>;
+    stopMicDeviceTest(): Promise<number>;
+    startSpeakerDeviceTest(filePath: string): Promise<number>;
+    stopSpeakerDeviceTest(): Promise<number>;
+    setApplicationPlayVolume(volume: number): Promise<number>;
+    getApplicationPlayVolume(): Promise<number>;
+    setApplicationMuteState(mute: boolean): Promise<number>;
+    getApplicationMuteState(): Promise<boolean>;
+    setCameraCaptureParam(params: TRTCCameraCaptureParams): Promise<void>;
+    /**
+     * 监听事件
+     *
+     * @param event {TRTCDeviceEventType} - 事件名称
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     * @param context {object} - 回调函数执行的上下文
+     */
+    on(event: TRTCDeviceEventType, func: (...args: any[]) => void): void;
+    /**
+     * 取消事件监听
+     *
+     * @param event {TRTCDeviceEventType} - 事件名
+     * @param func {(...args: any[]) => void} - 事件回调函数
+     */
+    off(event: TRTCDeviceEventType, func: (...args: any[]) => void): void;
+    private addPromise;
+    private removePromise;
+    private eventHandler;
+    private onDeviceChanged;
+    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;
+}
+export default TRTCDeviceManager;