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

package/README.md

@@ -23,7 +23,7 @@ Tencent Real-Time Communication (TRTC) is a set of low-latency, high-quality rea
 ## ⏬ Install
 By default, it will install the SDK compatible with your device Operation System platform and node.js CPU architecture. If you want to install SDK for specific Operating System or CPU architecture. You can configure the `platform` and `arch` you want in `package.json` or `.npmrc` file as following code. If you configure both, the configuration in `package.json` will work and override that in `.npmrc`.
 
-```json
+```js
 // package.json
 {
     ...
@@ -65,7 +65,7 @@ const version = rtcCloud.getSDKVersion();
 ## 📦 Build
 Taking webpack and electron-builder as example.
 
-```json
+```js
 // webpack config
 module.exports = {
     ...

package/liteav/VideoRenderControl/VideoRenderFPSMonitor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @class RenderFPSMonitor
+ */
+declare class VideoRenderFPSMonitor {
+    private logPrefix;
+    private emitter;
+    private nextAnimationFrame;
+    private lastTimestamp;
+    private refreshCount;
+    private pageRefreshFPS;
+    private lastPageRefreshFPS;
+    private videoRenderFPS;
+    private lastVideoRenderFPS;
+    private statisticDuration;
+    constructor();
+    private initPageRefreshFPSStatistic;
+    private statisticPageRefreshFPS;
+    /**
+     * 规则：
+     * 页面刷新帧率低于 10 时，设置渲染帧率为 5
+     * 页面刷新帧率低于 20 时，设置渲染帧率为 15
+     * 页面刷新帧率低于 30 时，设置渲染帧率为 25
+     * 页面刷新帧率高于 30 时，设置渲染帧率为 -1，负数表示关闭渲染帧率限制
+     * 页面刷新帧率从低于 10 到 30+ 时，持续 2 秒后，设置渲染帧率为 15
+     * 页面刷新帧率从低于 20 到 30+ 时，持续 2 秒后，设置渲染帧率为 25
+     * 页面刷新帧率从低于 30 到 30+ 时，持续 2 秒后，设置渲染帧率为 -1，负数表示关闭渲染帧率限制
+     */
+    private statisticVideoRenderFPS;
+    private onVisibilityChange;
+    private notifyFPS;
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    emit(event: string, ...args: any[]): void;
+}
+export declare const videoRenderFPSMonitor: VideoRenderFPSMonitor;
+export default VideoRenderFPSMonitor;

package/liteav/VideoRenderControl/VideoRenderFPSMonitor.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.videoRenderFPSMonitor = void 0;
+const events_1 = require("events");
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * @class RenderFPSMonitor
+ */
+class VideoRenderFPSMonitor {
+    constructor() {
+        this.logPrefix = '[RenderFPSMonitor]';
+        this.emitter = new events_1.EventEmitter();
+        this.nextAnimationFrame = 0;
+        this.lastTimestamp = 0;
+        this.refreshCount = 0;
+        this.pageRefreshFPS = 0;
+        this.lastPageRefreshFPS = 60;
+        this.videoRenderFPS = 0;
+        this.lastVideoRenderFPS = -1;
+        this.statisticDuration = 2000;
+        this.statisticPageRefreshFPS = this.statisticPageRefreshFPS.bind(this);
+        this.onVisibilityChange = this.onVisibilityChange.bind(this);
+        this.initPageRefreshFPSStatistic();
+        document.addEventListener('visibilitychange', this.onVisibilityChange);
+    }
+    initPageRefreshFPSStatistic() {
+        if (window.requestAnimationFrame) {
+            this.nextAnimationFrame = window.requestAnimationFrame(this.statisticPageRefreshFPS);
+        }
+    }
+    statisticPageRefreshFPS(timestamp) {
+        if (this.lastTimestamp === 0) {
+            this.lastTimestamp = timestamp;
+        }
+        this.refreshCount++;
+        const duration = timestamp - this.lastTimestamp;
+        if (duration >= this.statisticDuration) {
+            this.lastPageRefreshFPS = this.pageRefreshFPS;
+            this.pageRefreshFPS = Math.round(this.refreshCount * 1000 / duration);
+            setTimeout(() => {
+                this.statisticVideoRenderFPS();
+            }, 0);
+            this.lastTimestamp = timestamp;
+            this.refreshCount = 0;
+        }
+        this.nextAnimationFrame = window.requestAnimationFrame(this.statisticPageRefreshFPS);
+    }
+    /**
+     * 规则：
+     * 页面刷新帧率低于 10 时，设置渲染帧率为 5
+     * 页面刷新帧率低于 20 时，设置渲染帧率为 15
+     * 页面刷新帧率低于 30 时，设置渲染帧率为 25
+     * 页面刷新帧率高于 30 时，设置渲染帧率为 -1，负数表示关闭渲染帧率限制
+     * 页面刷新帧率从低于 10 到 30+ 时，持续 2 秒后，设置渲染帧率为 15
+     * 页面刷新帧率从低于 20 到 30+ 时，持续 2 秒后，设置渲染帧率为 25
+     * 页面刷新帧率从低于 30 到 30+ 时，持续 2 秒后，设置渲染帧率为 -1，负数表示关闭渲染帧率限制
+     */
+    statisticVideoRenderFPS() {
+        if (this.pageRefreshFPS <= 10) {
+            this.videoRenderFPS = this.pageRefreshFPS < 5 ? this.pageRefreshFPS : 5;
+        }
+        else if (this.pageRefreshFPS <= 20) {
+            this.videoRenderFPS = this.pageRefreshFPS < 15 ? this.pageRefreshFPS : 15;
+        }
+        else if (this.pageRefreshFPS <= 30) {
+            this.videoRenderFPS = this.pageRefreshFPS < 25 ? this.pageRefreshFPS : 25;
+        }
+        else if (this.pageRefreshFPS > 30 && this.lastPageRefreshFPS <= 10) {
+            this.videoRenderFPS = 15;
+        }
+        else if (this.pageRefreshFPS > 30 && this.lastPageRefreshFPS <= 20) {
+            this.videoRenderFPS = 25;
+        }
+        else {
+            this.videoRenderFPS = -1;
+        }
+        if (this.lastVideoRenderFPS !== this.videoRenderFPS) {
+            this.lastVideoRenderFPS = this.videoRenderFPS;
+            this.notifyFPS();
+        }
+    }
+    onVisibilityChange() {
+        if (document.hidden) {
+            logger_1.default.info(`${this.logPrefix} document hidden`);
+            this.videoRenderFPS = 1;
+            this.pageRefreshFPS = 1;
+        }
+        else {
+            logger_1.default.info(`${this.logPrefix} document show`);
+            this.videoRenderFPS = 5; // 慢启动
+            this.pageRefreshFPS = 5;
+        }
+        this.lastVideoRenderFPS = this.videoRenderFPS;
+        this.lastTimestamp = 0;
+        this.refreshCount = 0;
+        this.notifyFPS();
+    }
+    notifyFPS() {
+        logger_1.default.debug(`${this.logPrefix} pageRefreshFPS:${this.pageRefreshFPS} videoRenderFPS: ${this.videoRenderFPS}`);
+        this.emit('videoRenderFPS', {
+            pageFPS: this.pageRefreshFPS,
+            videoFPS: this.videoRenderFPS,
+        });
+    }
+    destroy() {
+        if (this.nextAnimationFrame) {
+            window.cancelAnimationFrame(this.nextAnimationFrame);
+            this.nextAnimationFrame = 0;
+        }
+        this.emitter.removeAllListeners();
+        document.removeEventListener('visibilitychange', this.onVisibilityChange);
+    }
+    on(event, listener) {
+        this.emitter.on(event, listener);
+    }
+    off(event, listener) {
+        this.emitter.off(event, listener);
+    }
+    emit(event, ...args) {
+        this.emitter.emit(event, ...args);
+    }
+}
+exports.videoRenderFPSMonitor = new VideoRenderFPSMonitor();
+exports.default = VideoRenderFPSMonitor;

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;