shengwang-electron-sdk 4.6.2-rc.1

package/js/Private/internal/RtcEngineExInternal.js

@@ -0,0 +1,488 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtcEngineExInternal = void 0;
+const ts_interface_checker_1 = require("ts-interface-checker");
+const IrisApiEngine_1 = require("../../Private/internal/IrisApiEngine");
+const Utils_1 = require("../../Utils");
+let RendererManager;
+let CapabilityManager;
+//@ts-ignore
+if (process.type === 'renderer') {
+    RendererManager = require('../../Renderer/RendererManager').RendererManager;
+    CapabilityManager =
+        require('../../Renderer/CapabilityManager').CapabilityManager;
+}
+else {
+    RendererManager = undefined;
+    CapabilityManager = undefined;
+}
+const AgoraBase_1 = require("../AgoraBase");
+const AgoraMediaBase_1 = require("../AgoraMediaBase");
+const IAgoraRtcEngineExImpl_1 = require("../impl/IAgoraRtcEngineExImpl");
+const IAgoraRtcEngineImpl_1 = require("../impl/IAgoraRtcEngineImpl");
+const AgoraBase_ti_1 = __importDefault(require("../ti/AgoraBase-ti"));
+const AgoraMediaBase_ti_1 = __importDefault(require("../ti/AgoraMediaBase-ti"));
+const IAgoraRtcEngine_ti_1 = __importDefault(require("../ti/IAgoraRtcEngine-ti"));
+const AgoraH265TranscoderInternal_1 = require("./AgoraH265TranscoderInternal");
+const AudioDeviceManagerInternal_1 = require("./AudioDeviceManagerInternal");
+const IrisApiEngine_2 = require("./IrisApiEngine");
+const LocalSpatialAudioEngineInternal_1 = require("./LocalSpatialAudioEngineInternal");
+const MediaEngineInternal_1 = require("./MediaEngineInternal");
+const MediaPlayerInternal_1 = require("./MediaPlayerInternal");
+const MediaRecorderInternal_1 = require("./MediaRecorderInternal");
+const MusicContentCenterInternal_1 = require("./MusicContentCenterInternal");
+const checkers = (0, ts_interface_checker_1.createCheckers)(AgoraBase_ti_1.default, AgoraMediaBase_ti_1.default, IAgoraRtcEngine_ti_1.default);
+class RtcEngineExInternal extends IAgoraRtcEngineExImpl_1.IRtcEngineExImpl {
+    constructor() {
+        super(...arguments);
+        this._audio_device_manager = new AudioDeviceManagerInternal_1.AudioDeviceManagerInternal();
+        this._video_device_manager = new IAgoraRtcEngineImpl_1.IVideoDeviceManagerImpl();
+        this._media_engine = new MediaEngineInternal_1.MediaEngineInternal();
+        this._music_content_center = new MusicContentCenterInternal_1.MusicContentCenterInternal();
+        this._local_spatial_audio_engine = new LocalSpatialAudioEngineInternal_1.LocalSpatialAudioEngineInternal();
+        this._h265_transcoder = new AgoraH265TranscoderInternal_1.H265TranscoderInternal();
+        this.performanceInterval = 6000;
+        this.VideoRemoteRenderMeanFpsCounterId = 537;
+        this.VideoRemoteRenderDrawCostCounterId = 576;
+        this.VideoLocalRenderMeanFpsCounterId = 526;
+        this.VideoLocalRenderDrawCostCounterId = 577;
+    }
+    initialize(context) {
+        const ret = super.initialize(context);
+        IrisApiEngine_2.callIrisApi.call(this, 'RtcEngine_setAppType', {
+            appType: 3,
+        });
+        if (Utils_1.AgoraEnv.webEnvReady) {
+            // @ts-ignore
+            window.AgoraEnv = Utils_1.AgoraEnv;
+            if (Utils_1.AgoraEnv.AgoraRendererManager === undefined && RendererManager) {
+                Utils_1.AgoraEnv.AgoraRendererManager = new RendererManager();
+            }
+            if (Utils_1.AgoraEnv.CapabilityManager === undefined && CapabilityManager) {
+                Utils_1.AgoraEnv.CapabilityManager = new CapabilityManager();
+            }
+            if (Utils_1.AgoraEnv.enableArgusCounters) {
+                try {
+                    this.performanceIntervalFunc = setInterval(() => {
+                        let rendererManager = Utils_1.AgoraEnv.AgoraRendererManager;
+                        let counters = [];
+                        if (rendererManager) {
+                            rendererManager.getRendererCaches().forEach((cache) => {
+                                const isRemote = cache.callbackContext.sourceType ===
+                                    AgoraMediaBase_1.VideoSourceType.VideoSourceRemote;
+                                if (cache.callbackContext.connection?.channelId &&
+                                    (cache.callbackContext.connection?.localUid || isRemote)) {
+                                    let counter = counters.find((counter) => counter.connection.channelId ===
+                                        cache.callbackContext.connection.channelId &&
+                                        counter.connection.localUid ===
+                                            cache.callbackContext.connection.localUid);
+                                    let data = {
+                                        counters: [
+                                            {
+                                                counterId: isRemote
+                                                    ? this.VideoRemoteRenderMeanFpsCounterId
+                                                    : this.VideoLocalRenderMeanFpsCounterId,
+                                                value: Math.floor(cache.actualFps),
+                                            },
+                                            {
+                                                counterId: isRemote
+                                                    ? this.VideoRemoteRenderDrawCostCounterId
+                                                    : this.VideoLocalRenderDrawCostCounterId,
+                                                value: Math.floor(cache.avgFrameInterval),
+                                            },
+                                        ],
+                                        uid: isRemote ? cache.cacheContext.uid : 0,
+                                    };
+                                    if (!counter) {
+                                        counters.push({
+                                            data: [data],
+                                            connection: cache.callbackContext.connection,
+                                        });
+                                    }
+                                    else {
+                                        counter.data.push(data);
+                                    }
+                                }
+                            });
+                        }
+                        counters.forEach((counter) => {
+                            this.setParameters(JSON.stringify({ 'rtc.report.argus_counters': counter }));
+                        });
+                    }, this.performanceInterval);
+                }
+                catch (error) {
+                    (0, Utils_1.logDebug)('argus counters report error', error);
+                }
+            }
+        }
+        return ret;
+    }
+    release(sync = false) {
+        IrisApiEngine_1.AgoraElectronBridge.ReleaseRenderer();
+        Utils_1.AgoraEnv.AgoraRendererManager?.release();
+        Utils_1.AgoraEnv.AgoraRendererManager = undefined;
+        this._media_engine.release();
+        this._local_spatial_audio_engine.release();
+        RtcEngineExInternal._event_handlers = [];
+        RtcEngineExInternal._event_handlers.map((it) => {
+            super.unregisterEventHandler(it);
+        });
+        RtcEngineExInternal._direct_cdn_streaming_event_handler = [];
+        RtcEngineExInternal._metadata_observer = [];
+        RtcEngineExInternal._audio_encoded_frame_observers = [];
+        RtcEngineExInternal._audio_spectrum_observers = [];
+        MediaPlayerInternal_1.MediaPlayerInternal._source_observers.clear();
+        MediaPlayerInternal_1.MediaPlayerInternal._audio_frame_observers.clear();
+        MediaPlayerInternal_1.MediaPlayerInternal._video_frame_observers.clear();
+        MediaPlayerInternal_1.MediaPlayerInternal._audio_spectrum_observers.clear();
+        MediaRecorderInternal_1.MediaRecorderInternal._observers.clear();
+        this._h265_transcoder.release();
+        this.removeAllListeners();
+        Utils_1.AgoraEnv.CapabilityManager?.release();
+        Utils_1.AgoraEnv.CapabilityManager = undefined;
+        if (this.performanceIntervalFunc) {
+            clearInterval(this.performanceIntervalFunc);
+            this.performanceIntervalFunc = undefined;
+        }
+        super.release(sync);
+    }
+    _addListenerPreCheck(eventType) {
+        if (checkers.IRtcEngineEventHandler?.strictTest({ [eventType]: undefined })) {
+            if (RtcEngineExInternal._event_handlers.length === 0) {
+                this.registerEventHandler({});
+            }
+        }
+        if (checkers.IDirectCdnStreamingEventHandler?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (RtcEngineExInternal._direct_cdn_streaming_event_handler.length === 0) {
+                (0, Utils_1.logError)('Please call `startDirectCdnStreaming` before you want to receive event by `addListener`');
+                return false;
+            }
+        }
+        if (checkers.IMetadataObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (RtcEngineExInternal._metadata_observer.length === 0) {
+                (0, Utils_1.logError)('Please call `registerMediaMetadataObserver` before you want to receive event by `addListener`');
+                return false;
+            }
+        }
+        if (checkers.IAudioEncodedFrameObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (RtcEngineExInternal._audio_encoded_frame_observers.length === 0) {
+                (0, Utils_1.logError)('Please call `registerAudioEncodedFrameObserver` before you want to receive event by `addListener`');
+                return false;
+            }
+        }
+        if (checkers.IAudioSpectrumObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (RtcEngineExInternal._audio_spectrum_observers.length === 0) {
+                this.registerAudioSpectrumObserver({});
+            }
+        }
+        return true;
+    }
+    addListener(eventType, listener) {
+        this._addListenerPreCheck(eventType);
+        const callback = (eventProcessor, data) => {
+            if (eventProcessor.type(data) !== IrisApiEngine_2.EVENT_TYPE.IRtcEngine) {
+                return;
+            }
+            eventProcessor.func.map((it) => {
+                it({ [eventType]: listener }, eventType, data);
+            });
+        };
+        // @ts-ignore
+        listener.agoraCallback = callback;
+        IrisApiEngine_2.DeviceEventEmitter.addListener(eventType, callback);
+    }
+    removeListener(eventType, listener) {
+        IrisApiEngine_2.DeviceEventEmitter.removeListener(eventType, 
+        // @ts-ignore
+        listener?.agoraCallback ?? listener);
+    }
+    removeAllListeners(eventType) {
+        IrisApiEngine_2.DeviceEventEmitter.removeAllListeners(eventType);
+    }
+    getVersion() {
+        const apiType = 'RtcEngine_getVersion_915cb25';
+        const jsonParams = {};
+        const jsonResults = IrisApiEngine_2.callIrisApi.call(this, apiType, jsonParams);
+        return {
+            build: jsonResults.build,
+            version: jsonResults.result,
+        };
+    }
+    registerEventHandler(eventHandler) {
+        // only call iris when no event handler registered
+        let callIris = RtcEngineExInternal._event_handlers.length === 0;
+        if (!RtcEngineExInternal._event_handlers.find((value) => value === eventHandler)) {
+            RtcEngineExInternal._event_handlers.push(eventHandler);
+        }
+        return callIris ? super.registerEventHandler(eventHandler) : true;
+    }
+    unregisterEventHandler(eventHandler) {
+        RtcEngineExInternal._event_handlers =
+            RtcEngineExInternal._event_handlers.filter((value) => value !== eventHandler);
+        // only call iris when no event handler registered
+        let callIris = RtcEngineExInternal._event_handlers.length === 0;
+        return callIris ? super.unregisterEventHandler(eventHandler) : true;
+    }
+    createMediaPlayer() {
+        // @ts-ignore
+        const mediaPlayerId = super.createMediaPlayer();
+        return new MediaPlayerInternal_1.MediaPlayerInternal(mediaPlayerId);
+    }
+    destroyMediaPlayer(mediaPlayer) {
+        const ret = super.destroyMediaPlayer(mediaPlayer);
+        mediaPlayer.release?.call(mediaPlayer);
+        return ret;
+    }
+    createMediaRecorder(info) {
+        // @ts-ignore
+        const nativeHandle = super.createMediaRecorder(info);
+        return new MediaRecorderInternal_1.MediaRecorderInternal(nativeHandle);
+    }
+    destroyMediaRecorder(mediaRecorder) {
+        const ret = super.destroyMediaRecorder(mediaRecorder);
+        mediaRecorder.release?.call(mediaRecorder);
+        return ret;
+    }
+    startDirectCdnStreaming(eventHandler, publishUrl, options) {
+        if (!RtcEngineExInternal._direct_cdn_streaming_event_handler.find((value) => value === eventHandler)) {
+            RtcEngineExInternal._direct_cdn_streaming_event_handler.push(eventHandler);
+        }
+        return super.startDirectCdnStreaming(eventHandler, publishUrl, options);
+    }
+    registerMediaMetadataObserver(observer, type) {
+        if (!RtcEngineExInternal._metadata_observer.find((value) => value === observer)) {
+            RtcEngineExInternal._metadata_observer.push(observer);
+        }
+        return super.registerMediaMetadataObserver(observer, type);
+    }
+    unregisterMediaMetadataObserver(observer, type) {
+        RtcEngineExInternal._metadata_observer =
+            RtcEngineExInternal._metadata_observer.filter((value) => value !== observer);
+        return super.unregisterMediaMetadataObserver(observer, type);
+    }
+    getApiTypeFromJoinChannel(token, channelId, uid, options) {
+        if (Utils_1.AgoraEnv.AgoraRendererManager) {
+            Utils_1.AgoraEnv.AgoraRendererManager.defaultChannelId = channelId;
+        }
+        return options === undefined
+            ? 'RtcEngine_joinChannel_f097389'
+            : 'RtcEngine_joinChannel_cdbb747';
+    }
+    getApiTypeFromLeaveChannel(options) {
+        return options === undefined
+            ? 'RtcEngine_leaveChannel'
+            : 'RtcEngine_leaveChannel_2c0e3aa';
+    }
+    getApiTypeFromLeaveChannelEx(connection, options) {
+        return options === undefined
+            ? 'RtcEngineEx_leaveChannelEx_c81e1a4'
+            : 'RtcEngineEx_leaveChannelEx_b03ee9a';
+    }
+    getApiTypeFromSetClientRole(role, options) {
+        return options === undefined
+            ? 'RtcEngine_setClientRole_3426fa6'
+            : 'RtcEngine_setClientRole_b46cc48';
+    }
+    getApiTypeFromEnableDualStreamMode(enabled, streamConfig) {
+        return streamConfig === undefined
+            ? 'RtcEngine_enableDualStreamMode_5039d15'
+            : 'RtcEngine_enableDualStreamMode_9822d8a';
+    }
+    getApiTypeFromSetDualStreamMode(mode, streamConfig) {
+        return streamConfig === undefined
+            ? 'RtcEngine_setDualStreamMode_3a7f662'
+            : 'RtcEngine_setDualStreamMode_b3a4f6c';
+    }
+    getApiTypeFromJoinChannelWithUserAccount(token, channelId, userAccount, options) {
+        if (Utils_1.AgoraEnv.AgoraRendererManager) {
+            Utils_1.AgoraEnv.AgoraRendererManager.defaultChannelId = channelId;
+        }
+        return options === undefined
+            ? 'RtcEngine_joinChannelWithUserAccount_0e4f59e'
+            : 'RtcEngine_joinChannelWithUserAccount_4685af9';
+    }
+    getAudioDeviceManager() {
+        return this._audio_device_manager;
+    }
+    getVideoDeviceManager() {
+        return this._video_device_manager;
+    }
+    getMediaEngine() {
+        return this._media_engine;
+    }
+    getMusicContentCenter() {
+        return this._music_content_center;
+    }
+    getLocalSpatialAudioEngine() {
+        return this._local_spatial_audio_engine;
+    }
+    getH265Transcoder() {
+        return this._h265_transcoder;
+    }
+    getNativeHandle() {
+        let result = super.getNativeHandle();
+        return (0, Utils_1.parseIntPtr2Number)(result);
+    }
+    registerAudioEncodedFrameObserver(config, observer) {
+        if (!RtcEngineExInternal._audio_encoded_frame_observers.find((value) => value === observer)) {
+            RtcEngineExInternal._audio_encoded_frame_observers.push(observer);
+        }
+        return super.registerAudioEncodedFrameObserver(config, observer);
+    }
+    unregisterAudioEncodedFrameObserver(observer) {
+        RtcEngineExInternal._audio_encoded_frame_observers =
+            RtcEngineExInternal._audio_encoded_frame_observers.filter((value) => value !== observer);
+        return super.unregisterAudioEncodedFrameObserver(observer);
+    }
+    registerAudioSpectrumObserver(observer) {
+        if (!RtcEngineExInternal._audio_spectrum_observers.find((value) => value === observer)) {
+            RtcEngineExInternal._audio_spectrum_observers.push(observer);
+        }
+        return super.registerAudioSpectrumObserver(observer);
+    }
+    unregisterAudioSpectrumObserver(observer) {
+        RtcEngineExInternal._audio_spectrum_observers =
+            RtcEngineExInternal._audio_spectrum_observers.filter((value) => value !== observer);
+        return super.unregisterAudioSpectrumObserver(observer);
+    }
+    getScreenCaptureSources(thumbSize, iconSize, includeScreen) {
+        const apiType = this.getApiTypeFromGetScreenCaptureSources(thumbSize, iconSize, includeScreen);
+        const jsonParams = {
+            thumbSize: thumbSize,
+            iconSize: iconSize,
+            includeScreen: includeScreen,
+            toJSON: () => {
+                return {
+                    thumbSize: thumbSize,
+                    iconSize: iconSize,
+                    includeScreen: includeScreen,
+                };
+            },
+        };
+        const { result, sources } = IrisApiEngine_2.callIrisApi.call(this, apiType, jsonParams);
+        const screenCaptureSources = result.map((value) => {
+            if (!value.thumbImage?.buffer || !value.thumbImage?.length) {
+                value.thumbImage.buffer = undefined;
+            }
+            else {
+                value.thumbImage.buffer = IrisApiEngine_1.AgoraElectronBridge.GetBuffer(value.thumbImage.buffer, value.thumbImage.length);
+            }
+            if (!value.iconImage?.buffer || !value.iconImage?.length) {
+                value.iconImage.buffer = undefined;
+            }
+            else {
+                value.iconImage.buffer = IrisApiEngine_1.AgoraElectronBridge.GetBuffer(value.iconImage.buffer, value.iconImage.length);
+            }
+            value.sourceDisplayId = (0, Utils_1.parseIntPtr2Number)(value.sourceDisplayId);
+            return value;
+        });
+        IrisApiEngine_2.callIrisApi.call(this, 'RtcEngine_releaseScreenCaptureSources', {
+            sources,
+        });
+        return screenCaptureSources;
+    }
+    setupLocalVideo(canvas) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const renderer = Utils_1.AgoraEnv.AgoraRendererManager.addOrRemoveRenderer(canvas);
+        if (!renderer)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setupRemoteVideo(canvas) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const renderer = Utils_1.AgoraEnv.AgoraRendererManager.addOrRemoveRenderer(canvas);
+        if (!renderer)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setupRemoteVideoEx(canvas, connection) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const renderer = Utils_1.AgoraEnv.AgoraRendererManager.addOrRemoveRenderer({
+            ...canvas,
+            ...connection,
+        });
+        if (!renderer)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setLocalRenderMode(renderMode, mirrorMode = AgoraBase_1.VideoMirrorModeType.VideoMirrorModeAuto) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const result = Utils_1.AgoraEnv.AgoraRendererManager.setRendererContext({
+            sourceType: AgoraMediaBase_1.VideoSourceType.VideoSourceCamera,
+            renderMode,
+            mirrorMode,
+        });
+        if (!result)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setRemoteRenderMode(uid, renderMode, mirrorMode) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const result = Utils_1.AgoraEnv.AgoraRendererManager.setRendererContext({
+            sourceType: AgoraMediaBase_1.VideoSourceType.VideoSourceRemote,
+            uid,
+            renderMode,
+            mirrorMode,
+        });
+        if (!result)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setRemoteRenderModeEx(uid, renderMode, mirrorMode, connection) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const result = Utils_1.AgoraEnv.AgoraRendererManager.setRendererContext({
+            sourceType: AgoraMediaBase_1.VideoSourceType.VideoSourceRemote,
+            ...connection,
+            uid,
+            renderMode,
+            mirrorMode,
+        });
+        if (!result)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setLocalVideoMirrorMode(mirrorMode) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const result = Utils_1.AgoraEnv.AgoraRendererManager.setRendererContext({
+            sourceType: AgoraMediaBase_1.VideoSourceType.VideoSourceCamera,
+            mirrorMode,
+        });
+        if (!result)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    destroyRendererByView(view) {
+        Utils_1.AgoraEnv.AgoraRendererManager?.removeRendererFromCache({ view });
+    }
+    destroyRendererByConfig(sourceType, channelId, uid) {
+        Utils_1.AgoraEnv.AgoraRendererManager?.removeRendererFromCache({
+            sourceType,
+            channelId,
+            uid,
+        });
+    }
+}
+exports.RtcEngineExInternal = RtcEngineExInternal;
+RtcEngineExInternal._event_handlers = [];
+RtcEngineExInternal._direct_cdn_streaming_event_handler = [];
+RtcEngineExInternal._metadata_observer = [];
+RtcEngineExInternal._audio_encoded_frame_observers = [];
+RtcEngineExInternal._audio_spectrum_observers = [];

package/js/Private/ipc/main.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//@ts-ignore
+const electron_1 = require("electron");
+const gpu_utils_1 = require("../../Decoder/gpu-utils");
+const Types_1 = require("../../Types");
+//@ts-ignore
+if (process.type !== 'renderer') {
+    electron_1.ipcMain.handle(Types_1.IPCMessageType.AGORA_IPC_GET_GPU_INFO, () => {
+        return new Promise((resolve) => {
+            (0, gpu_utils_1.getGpuInfoInternal)((result) => {
+                resolve(result);
+            });
+        });
+    });
+    console.log('[agora-electron] main process AgoraIPCMain handler registered');
+    electron_1.app.on('quit', () => {
+        electron_1.ipcMain.removeHandler(Types_1.IPCMessageType.AGORA_IPC_GET_GPU_INFO);
+        console.log('[agora-electron] main process AgoraIPCMain handler removed');
+    });
+}

package/js/Private/ipc/renderer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ipcSend = void 0;
+//@ts-ignore
+const electron_1 = require("electron");
+const Types_1 = require("../../Types");
+const Utils_1 = require("../../Utils");
+async function ipcSend(channel, ...args) {
+    if (!Object.values(Types_1.IPCMessageType).includes(channel)) {
+        (0, Utils_1.logError)('Invalid IPCMessageType');
+        return;
+    }
+    //@ts-ignore
+    if (process.type === 'renderer') {
+        return await electron_1.ipcRenderer.invoke(channel, ...args);
+    }
+    else {
+        (0, Utils_1.logError)('Not in renderer process, cannot send ipc message');
+    }
+}
+exports.ipcSend = ipcSend;

package/js/Private/ti/AgoraBase-ti.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IAudioEncodedFrameObserver = void 0;
+/**
+ * This module was automatically generated by `ts-interface-builder`
+ */
+const t = __importStar(require("ts-interface-checker"));
+// tslint:disable:object-literal-key-quotes
+exports.IAudioEncodedFrameObserver = t.iface([], {
+    "onRecordAudioEncodedFrame": t.opt(t.func("void", t.param("frameBuffer", "Uint8Array"), t.param("length", "number"), t.param("audioEncodedFrameInfo", "EncodedAudioFrameInfo"))),
+    "onPlaybackAudioEncodedFrame": t.opt(t.func("void", t.param("frameBuffer", "Uint8Array"), t.param("length", "number"), t.param("audioEncodedFrameInfo", "EncodedAudioFrameInfo"))),
+    "onMixedAudioEncodedFrame": t.opt(t.func("void", t.param("frameBuffer", "Uint8Array"), t.param("length", "number"), t.param("audioEncodedFrameInfo", "EncodedAudioFrameInfo"))),
+});
+const exportedTypeSuite = {
+    IAudioEncodedFrameObserver: exports.IAudioEncodedFrameObserver,
+};
+exports.default = exportedTypeSuite;

package/js/Private/ti/AgoraMediaBase-ti.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMediaRecorderObserver = exports.IFaceInfoObserver = exports.IVideoFrameObserver = exports.IVideoEncodedFrameObserver = exports.IAudioSpectrumObserver = exports.IAudioFrameObserver = exports.IAudioFrameObserverBase = exports.IAudioPcmFrameSink = void 0;
+/**
+ * This module was automatically generated by `ts-interface-builder`
+ */
+const t = __importStar(require("ts-interface-checker"));
+// tslint:disable:object-literal-key-quotes
+exports.IAudioPcmFrameSink = t.iface([], {
+    "onFrame": t.opt(t.func("void", t.param("frame", "AudioPcmFrame"))),
+});
+exports.IAudioFrameObserverBase = t.iface([], {
+    "onRecordAudioFrame": t.opt(t.func("void", t.param("channelId", "string"), t.param("audioFrame", "AudioFrame"))),
+    "onPlaybackAudioFrame": t.opt(t.func("void", t.param("channelId", "string"), t.param("audioFrame", "AudioFrame"))),
+    "onMixedAudioFrame": t.opt(t.func("void", t.param("channelId", "string"), t.param("audioFrame", "AudioFrame"))),
+    "onEarMonitoringAudioFrame": t.opt(t.func("void", t.param("audioFrame", "AudioFrame"))),
+});
+exports.IAudioFrameObserver = t.iface(["IAudioFrameObserverBase"], {
+    "onPlaybackAudioFrameBeforeMixing": t.opt(t.func("void", t.param("channelId", "string"), t.param("uid", "number"), t.param("audioFrame", "AudioFrame"))),
+});
+exports.IAudioSpectrumObserver = t.iface([], {
+    "onLocalAudioSpectrum": t.opt(t.func("void", t.param("data", "AudioSpectrumData"))),
+    "onRemoteAudioSpectrum": t.opt(t.func("void", t.param("spectrums", t.array("UserAudioSpectrumInfo")), t.param("spectrumNumber", "number"))),
+});
+exports.IVideoEncodedFrameObserver = t.iface([], {
+    "onEncodedVideoFrameReceived": t.opt(t.func("void", t.param("channelId", "string"), t.param("uid", "number"), t.param("imageBuffer", "Uint8Array"), t.param("length", "number"), t.param("videoEncodedFrameInfo", "EncodedVideoFrameInfo"))),
+});
+exports.IVideoFrameObserver = t.iface([], {
+    "onCaptureVideoFrame": t.opt(t.func("void", t.param("sourceType", "VideoSourceType"), t.param("videoFrame", "VideoFrame"))),
+    "onPreEncodeVideoFrame": t.opt(t.func("void", t.param("sourceType", "VideoSourceType"), t.param("videoFrame", "VideoFrame"))),
+    "onMediaPlayerVideoFrame": t.opt(t.func("void", t.param("videoFrame", "VideoFrame"), t.param("mediaPlayerId", "number"))),
+    "onRenderVideoFrame": t.opt(t.func("void", t.param("channelId", "string"), t.param("remoteUid", "number"), t.param("videoFrame", "VideoFrame"))),
+    "onTranscodedVideoFrame": t.opt(t.func("void", t.param("videoFrame", "VideoFrame"))),
+});
+exports.IFaceInfoObserver = t.iface([], {
+    "onFaceInfo": t.opt(t.func("void", t.param("outFaceInfo", "string"))),
+});
+exports.IMediaRecorderObserver = t.iface([], {
+    "onRecorderStateChanged": t.opt(t.func("void", t.param("channelId", "string"), t.param("uid", "number"), t.param("state", "RecorderState"), t.param("reason", "RecorderReasonCode"))),
+    "onRecorderInfoUpdated": t.opt(t.func("void", t.param("channelId", "string"), t.param("uid", "number"), t.param("info", "RecorderInfo"))),
+});
+const exportedTypeSuite = {
+    IAudioPcmFrameSink: exports.IAudioPcmFrameSink,
+    IAudioFrameObserverBase: exports.IAudioFrameObserverBase,
+    IAudioFrameObserver: exports.IAudioFrameObserver,
+    IAudioSpectrumObserver: exports.IAudioSpectrumObserver,
+    IVideoEncodedFrameObserver: exports.IVideoEncodedFrameObserver,
+    IVideoFrameObserver: exports.IVideoFrameObserver,
+    IFaceInfoObserver: exports.IFaceInfoObserver,
+    IMediaRecorderObserver: exports.IMediaRecorderObserver,
+};
+exports.default = exportedTypeSuite;

package/js/Private/ti/AgoraMediaPlayerTypes-ti.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// tslint:disable:object-literal-key-quotes
+const exportedTypeSuite = {};
+exports.default = exportedTypeSuite;