shengwang-electron-sdk 4.6.2-rc.1

package/js/Private/internal/IrisApiEngine.js

@@ -0,0 +1,451 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitEvent = exports.callIrisApi = exports.EVENT_PROCESSORS = exports.EVENT_TYPE = exports.isDebuggable = exports.setDebuggable = exports.AgoraElectronBridge = exports.DeviceEventEmitter = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+const json_bigint_1 = __importDefault(require("json-bigint"));
+const JSON = (0, json_bigint_1.default)({ storeAsString: true });
+const AgoraSdk_1 = __importDefault(require("../../AgoraSdk"));
+const Utils_1 = require("../../Utils");
+const AgoraMediaBase_1 = require("../AgoraMediaBase");
+const AgoraBaseImpl_1 = require("../impl/AgoraBaseImpl");
+const AgoraMediaBaseImpl_1 = require("../impl/AgoraMediaBaseImpl");
+const IAgoraH265TranscoderImpl_1 = require("../impl/IAgoraH265TranscoderImpl");
+const IAgoraMediaPlayerImpl_1 = require("../impl/IAgoraMediaPlayerImpl");
+const IAgoraMediaPlayerSourceImpl_1 = require("../impl/IAgoraMediaPlayerSourceImpl");
+const IAgoraMusicContentCenterImpl_1 = require("../impl/IAgoraMusicContentCenterImpl");
+const IAgoraRtcEngineImpl_1 = require("../impl/IAgoraRtcEngineImpl");
+const AgoraH265TranscoderInternal_1 = require("./AgoraH265TranscoderInternal");
+const AgoraMediaBaseInternal_1 = require("./AgoraMediaBaseInternal");
+const MediaEngineInternal_1 = require("./MediaEngineInternal");
+const MediaPlayerInternal_1 = require("./MediaPlayerInternal");
+const MediaRecorderInternal_1 = require("./MediaRecorderInternal");
+const MusicContentCenterInternal_1 = require("./MusicContentCenterInternal");
+const RtcEngineExInternal_1 = require("./RtcEngineExInternal");
+// @ts-ignore
+exports.DeviceEventEmitter = new eventemitter3_1.default();
+const AgoraNode = require('../../../build/Release/agora_node_ext');
+exports.AgoraElectronBridge = new AgoraNode.AgoraElectronBridge();
+exports.AgoraElectronBridge.OnEvent('call_back_with_buffer', (...params) => {
+    try {
+        handleEvent(...params);
+    }
+    catch (e) {
+        console.error(e);
+    }
+});
+/**
+ * @internal
+ */
+function setDebuggable(flag) {
+    Utils_1.AgoraEnv.enableLogging = flag;
+    Utils_1.AgoraEnv.enableDebugLogging = flag;
+}
+exports.setDebuggable = setDebuggable;
+/**
+ * @internal
+ */
+function isDebuggable() {
+    return Utils_1.AgoraEnv.enableLogging && Utils_1.AgoraEnv.enableDebugLogging;
+}
+exports.isDebuggable = isDebuggable;
+var EVENT_TYPE;
+(function (EVENT_TYPE) {
+    EVENT_TYPE[EVENT_TYPE["IMediaEngine"] = 0] = "IMediaEngine";
+    EVENT_TYPE[EVENT_TYPE["IMediaPlayer"] = 1] = "IMediaPlayer";
+    EVENT_TYPE[EVENT_TYPE["IMediaRecorder"] = 2] = "IMediaRecorder";
+    EVENT_TYPE[EVENT_TYPE["IRtcEngine"] = 3] = "IRtcEngine";
+    EVENT_TYPE[EVENT_TYPE["IMusicContentCenter"] = 4] = "IMusicContentCenter";
+    EVENT_TYPE[EVENT_TYPE["IAgoraH265Transcoder"] = 5] = "IAgoraH265Transcoder";
+})(EVENT_TYPE = exports.EVENT_TYPE || (exports.EVENT_TYPE = {}));
+/**
+ * @internal
+ */
+exports.EVENT_PROCESSORS = {
+    IAudioFrameObserver: {
+        suffix: 'AudioFrameObserver_',
+        type: () => EVENT_TYPE.IMediaEngine,
+        func: [AgoraMediaBaseImpl_1.processIAudioFrameObserver, AgoraMediaBaseImpl_1.processIAudioFrameObserverBase],
+        preprocess: (event, data, buffers) => {
+            if (data.audioFrame) {
+                data.audioFrame.buffer = buffers[0];
+            }
+        },
+        handlers: (event, data) => MediaEngineInternal_1.MediaEngineInternal._audio_frame_observers,
+    },
+    IVideoFrameObserver: {
+        suffix: 'VideoFrameObserver_',
+        type: () => EVENT_TYPE.IMediaEngine,
+        func: [AgoraMediaBaseImpl_1.processIVideoFrameObserver],
+        preprocess: (event, data, buffers) => {
+            if (data.videoFrame) {
+                data.videoFrame.yBuffer = buffers[0];
+                data.videoFrame.uBuffer = buffers[1];
+                data.videoFrame.vBuffer = buffers[2];
+                data.videoFrame.metadata_buffer = buffers[3];
+                data.videoFrame.alphaBuffer = buffers[4];
+                let metaInfo = data.videoFrame.metaInfo;
+                data.videoFrame.metaInfo = new AgoraMediaBaseInternal_1.VideoFrameMetaInfoInternal(metaInfo);
+            }
+        },
+        handlers: (event, data) => MediaEngineInternal_1.MediaEngineInternal._video_frame_observers,
+    },
+    IAudioSpectrumObserver: {
+        suffix: 'AudioSpectrumObserver_',
+        type: (data) => data.playerId === 0 ? EVENT_TYPE.IRtcEngine : EVENT_TYPE.IMediaPlayer,
+        func: [AgoraMediaBaseImpl_1.processIAudioSpectrumObserver],
+        handlers: (event, data) => data.playerId === 0
+            ? RtcEngineExInternal_1.RtcEngineExInternal._audio_spectrum_observers
+            : MediaPlayerInternal_1.MediaPlayerInternal._audio_spectrum_observers.get(data.playerId),
+    },
+    IAudioEncodedFrameObserver: {
+        suffix: 'AudioEncodedFrameObserver_',
+        type: () => EVENT_TYPE.IRtcEngine,
+        func: [AgoraBaseImpl_1.processIAudioEncodedFrameObserver],
+        preprocess: (event, data, buffers) => {
+            switch (event) {
+                case 'OnRecordAudioEncodedFrame':
+                case 'OnPlaybackAudioEncodedFrame':
+                case 'OnMixedAudioEncodedFrame':
+                    data.frameBuffer = buffers[0];
+                    break;
+            }
+        },
+        handlers: (event, data) => RtcEngineExInternal_1.RtcEngineExInternal._audio_encoded_frame_observers,
+    },
+    IVideoEncodedFrameObserver: {
+        suffix: 'VideoEncodedFrameObserver_',
+        type: () => EVENT_TYPE.IMediaEngine,
+        func: [AgoraMediaBaseImpl_1.processIVideoEncodedFrameObserver],
+        preprocess: (event, data, buffers) => {
+            switch (event) {
+                case 'onEncodedVideoFrameReceived':
+                    data.imageBuffer = buffers[0];
+                    break;
+            }
+        },
+        handlers: (event, data) => MediaEngineInternal_1.MediaEngineInternal._video_encoded_frame_observers,
+    },
+    IMediaPlayerSourceObserver: {
+        suffix: 'MediaPlayerSourceObserver_',
+        type: () => EVENT_TYPE.IMediaPlayer,
+        func: [IAgoraMediaPlayerSourceImpl_1.processIMediaPlayerSourceObserver],
+        handlers: (event, data) => MediaPlayerInternal_1.MediaPlayerInternal._source_observers.get(data.playerId),
+    },
+    IAudioPcmFrameSink: {
+        suffix: 'AudioPcmFrameSink_',
+        type: () => EVENT_TYPE.IMediaPlayer,
+        func: [AgoraMediaBaseImpl_1.processIAudioPcmFrameSink],
+        preprocess: (event, data, buffers) => {
+            if (data.frame) {
+                data.frame.data_ = Array.from(buffers[0] ?? []);
+            }
+        },
+        handlers: (event, data) => MediaPlayerInternal_1.MediaPlayerInternal._audio_frame_observers.get(data.playerId),
+    },
+    IMediaPlayerVideoFrameObserver: {
+        suffix: 'MediaPlayerVideoFrameObserver_',
+        type: () => EVENT_TYPE.IMediaPlayer,
+        func: [IAgoraMediaPlayerImpl_1.processIMediaPlayerVideoFrameObserver],
+        preprocess: (event, data, buffers) => {
+            if (data.frame) {
+                data.frame.yBuffer = buffers[0];
+                data.frame.uBuffer = buffers[1];
+                data.frame.vBuffer = buffers[2];
+                data.frame.metadata_buffer = buffers[3];
+                data.frame.alphaBuffer = buffers[4];
+                let metaInfo = data.frame.metaInfo;
+                data.frame.metaInfo = new AgoraMediaBaseInternal_1.VideoFrameMetaInfoInternal(metaInfo);
+            }
+        },
+        handlers: (event, data) => MediaPlayerInternal_1.MediaPlayerInternal._video_frame_observers.get(data.playerId),
+    },
+    IMediaRecorderObserver: {
+        suffix: 'MediaRecorderObserver_',
+        type: () => EVENT_TYPE.IMediaRecorder,
+        func: [AgoraMediaBaseImpl_1.processIMediaRecorderObserver],
+        handlers: (event, data) => [
+            MediaRecorderInternal_1.MediaRecorderInternal._observers.get(data.nativeHandle),
+        ],
+    },
+    IMetadataObserver: {
+        suffix: 'MetadataObserver_',
+        type: () => EVENT_TYPE.IRtcEngine,
+        func: [IAgoraRtcEngineImpl_1.processIMetadataObserver],
+        preprocess: (event, data, buffers) => {
+            switch (event) {
+                case 'onMetadataReceived':
+                    if (data.metadata) {
+                        data.metadata.buffer = buffers[0];
+                    }
+                    break;
+            }
+        },
+        handlers: (event, data) => RtcEngineExInternal_1.RtcEngineExInternal._metadata_observer,
+    },
+    IDirectCdnStreamingEventHandler: {
+        suffix: 'DirectCdnStreamingEventHandler_',
+        type: () => EVENT_TYPE.IRtcEngine,
+        func: [IAgoraRtcEngineImpl_1.processIDirectCdnStreamingEventHandler],
+        handlers: (event, data) => RtcEngineExInternal_1.RtcEngineExInternal._direct_cdn_streaming_event_handler,
+    },
+    IRtcEngineEventHandler: {
+        suffix: 'RtcEngineEventHandler_',
+        type: () => EVENT_TYPE.IRtcEngine,
+        func: [IAgoraRtcEngineImpl_1.processIRtcEngineEventHandler],
+        preprocess: (event, data, buffers) => {
+            switch (event) {
+                case 'onStreamMessage':
+                case 'onStreamMessageEx':
+                    data.data = buffers[0];
+                    break;
+                case 'onLocalVideoStats':
+                    if (data) {
+                        let rendererManager = Utils_1.AgoraEnv.AgoraRendererManager;
+                        if (rendererManager) {
+                            let sourceType = data.sourceType;
+                            let connection = data.connection;
+                            let rendererCaches = rendererManager.getRendererCachesBySourceType(sourceType);
+                            rendererCaches.forEach((cache) => {
+                                cache.setCallbackContext(connection, sourceType);
+                            });
+                        }
+                    }
+                    break;
+                case 'onRemoteVideoStats':
+                    if (data) {
+                        let rendererManager = Utils_1.AgoraEnv.AgoraRendererManager;
+                        if (rendererManager) {
+                            let connection = data.connection;
+                            const sourceType = AgoraMediaBase_1.VideoSourceType.VideoSourceRemote;
+                            let rendererCaches = rendererManager.getRendererCachesBySourceType(sourceType);
+                            rendererCaches.forEach((cache) => {
+                                cache.setCallbackContext(connection, sourceType);
+                            });
+                        }
+                    }
+                    break;
+            }
+        },
+        handlers: (event, data) => RtcEngineExInternal_1.RtcEngineExInternal._event_handlers,
+    },
+    IMusicContentCenterEventHandler: {
+        suffix: 'MusicContentCenterEventHandler_',
+        type: () => EVENT_TYPE.IMusicContentCenter,
+        func: [IAgoraMusicContentCenterImpl_1.processIMusicContentCenterEventHandler],
+        preprocess: (event, data, buffers) => {
+            switch (event) {
+                case 'onMusicCollectionResult': {
+                    const result = data.result;
+                    data.result = new MusicContentCenterInternal_1.MusicCollectionInternal(result);
+                    break;
+                }
+            }
+        },
+        handlers: (event, data) => MusicContentCenterInternal_1.MusicContentCenterInternal._event_handlers,
+    },
+    IH265TranscoderObserver: {
+        suffix: 'H265TranscoderObserver_',
+        type: () => EVENT_TYPE.IAgoraH265Transcoder,
+        func: [IAgoraH265TranscoderImpl_1.processIH265TranscoderObserver],
+        handlers: () => AgoraH265TranscoderInternal_1.H265TranscoderInternal._h265_transcoder_observers,
+    },
+    IFaceInfoObserver: {
+        suffix: 'FaceInfoObserver_',
+        type: () => EVENT_TYPE.IMediaEngine,
+        func: [AgoraMediaBaseImpl_1.processIFaceInfoObserver],
+        handlers: () => MediaEngineInternal_1.MediaEngineInternal._face_info_observers,
+    },
+};
+function handleEvent(...[event, data, buffers]) {
+    if (isDebuggable()) {
+        (0, Utils_1.logInfo)('onEvent', event, data, buffers);
+    }
+    let _event = event;
+    let processor = Object.values(exports.EVENT_PROCESSORS).find((it) => {
+        return _event.startsWith(it.suffix);
+    });
+    if (processor === undefined) {
+        return;
+    }
+    // allow replace preprocess to undefined for avoid call more than once
+    processor = { ...processor };
+    const reg = new RegExp(`^${processor.suffix}`, 'g');
+    _event = _event.replace(reg, '');
+    if (_event.endsWith('Ex')) {
+        _event = _event.replace(/Ex$/g, '');
+    }
+    // for new IrisType, but this is temporary
+    if (_event.includes('_')) {
+        _event = _event.substring(0, _event.indexOf('_'));
+    }
+    let _data;
+    try {
+        _data = JSON.parse(data) ?? {};
+    }
+    catch (e) {
+        _data = {};
+    }
+    const _buffers = buffers;
+    if (processor.handlers) {
+        const handlers = processor.handlers(_event, _data, _buffers);
+        if (handlers !== undefined) {
+            if (processor.preprocess) {
+                processor.preprocess(_event, _data, _buffers);
+                // call preprocess only once
+                processor.preprocess = undefined;
+            }
+            handlers.map((value) => {
+                if (value) {
+                    processor.func.map((it) => {
+                        it(value, _event, _data);
+                    });
+                }
+            });
+        }
+    }
+    emitEvent(_event, processor, _data, _buffers);
+}
+/**
+ * @internal
+ */
+function callIrisApi(funcName, params) {
+    try {
+        const buffers = [];
+        const rtcEngine = (0, AgoraSdk_1.default)();
+        if (funcName.startsWith('MediaEngine_')) {
+            switch (funcName) {
+                case 'MediaEngine_pushAudioFrame_c71f4ab':
+                    // frame.buffer
+                    buffers.push(params.frame.buffer);
+                    break;
+                case 'MediaEngine_pushVideoFrame_4e544e2':
+                    // frame.buffer
+                    buffers.push(params.frame.buffer);
+                    // frame.eglContext
+                    buffers.push(Buffer.from(''));
+                    // frame.metadata_buffer
+                    buffers.push(Buffer.from(''));
+                    // frame.alphaBuffer
+                    buffers.push(params.frame.alphaBuffer);
+                    // frame.d3d11_texture_2d
+                    buffers.push(Buffer.from(''));
+                    break;
+                case 'MediaEngine_pushEncodedVideoImage_e71452b':
+                    // imageBuffer
+                    buffers.push(params.imageBuffer);
+                    break;
+            }
+        }
+        else if (funcName.startsWith('MediaPlayer_') ||
+            funcName.startsWith('MusicPlayer_')) {
+            // @ts-ignore
+            params.mediaPlayerId = this.getMediaPlayerId();
+            const json = params.toJSON?.call();
+            params.toJSON = function () {
+                return { ...json, playerId: params.mediaPlayerId };
+            };
+        }
+        else if (funcName.startsWith('MediaRecorder_')) {
+            // @ts-ignore
+            params.nativeHandle = this.nativeHandle;
+            const json = params.toJSON?.call();
+            params.toJSON = function () {
+                return { ...json, nativeHandle: params.nativeHandle };
+            };
+        }
+        else if (funcName.startsWith('RtcEngine_')) {
+            switch (funcName) {
+                case 'RtcEngine_initialize_0320339':
+                    exports.AgoraElectronBridge.InitializeEnv();
+                    break;
+                case 'RtcEngine_release':
+                    exports.AgoraElectronBridge.CallApi(funcName, JSON.stringify(params), buffers, buffers.length);
+                    exports.AgoraElectronBridge.ReleaseEnv();
+                    return;
+                case 'RtcEngine_sendMetaData':
+                    // metadata.buffer
+                    buffers.push(params.metadata.buffer);
+                    break;
+                case 'RtcEngine_sendStreamMessage_8715a45':
+                case 'RtcEngineEx_sendStreamMessageEx_0c34857':
+                    // data
+                    buffers.push(params.data);
+                    break;
+                case 'RtcEngine_destroyMediaPlayer_328a49b':
+                    params.mediaPlayerId = params.media_player.getMediaPlayerId();
+                    params.toJSON = function () {
+                        return { playerId: params.mediaPlayerId };
+                    };
+                    break;
+                case 'RtcEngine_destroyMediaRecorder_95cdef5':
+                    // @ts-ignore
+                    params.nativeHandle = params.mediaRecorder.nativeHandle;
+                    params.toJSON = function () {
+                        return { nativeHandle: params.nativeHandle };
+                    };
+                    break;
+            }
+        }
+        if (funcName.indexOf('joinChannel') != -1) {
+            if (Utils_1.AgoraEnv.CapabilityManager?.webCodecsDecoderEnabled) {
+                rtcEngine.getMediaEngine().registerVideoEncodedFrameObserver({});
+            }
+        }
+        else if (funcName.indexOf('leaveChannel') != -1) {
+            if (Utils_1.AgoraEnv.CapabilityManager?.webCodecsDecoderEnabled) {
+                rtcEngine.getMediaEngine().unregisterVideoEncodedFrameObserver({});
+            }
+        }
+        let { callApiReturnCode, callApiResult } = exports.AgoraElectronBridge.CallApi(funcName, JSON.stringify(params), buffers, buffers.length);
+        let ret = callApiResult;
+        if (ret !== undefined && ret !== null && ret !== '' && ret !== 'null') {
+            const retObj = JSON.parse(ret);
+            if (isDebuggable()) {
+                if (typeof retObj.result === 'number' && retObj.result < 0) {
+                    (0, Utils_1.logError)('callApi', funcName, JSON.stringify(params), ret);
+                }
+                else {
+                    (0, Utils_1.logDebug)('callApi', funcName, JSON.stringify(params), ret);
+                }
+            }
+            return retObj;
+        }
+        else {
+            if (isDebuggable()) {
+                (0, Utils_1.logError)('callApi', funcName, JSON.stringify(params), callApiReturnCode);
+            }
+            else {
+                (0, Utils_1.logWarn)('callApi', funcName, JSON.stringify(params), callApiReturnCode);
+            }
+            return { result: callApiReturnCode };
+        }
+    }
+    catch (e) {
+        if (isDebuggable()) {
+            (0, Utils_1.logError)('callApi', funcName, JSON.stringify(params), e);
+        }
+        else {
+            (0, Utils_1.logWarn)('callApi', funcName, JSON.stringify(params), e);
+        }
+    }
+    return {};
+}
+exports.callIrisApi = callIrisApi;
+/**
+ * @internal
+ */
+function emitEvent(eventType, eventProcessor, data, buffers) {
+    if (exports.DeviceEventEmitter.listenerCount(eventType) === 0) {
+        return;
+    }
+    if (eventProcessor.preprocess) {
+        eventProcessor.preprocess(eventType, data, buffers ?? []);
+        // call preprocess only once
+        eventProcessor.preprocess = undefined;
+    }
+    exports.DeviceEventEmitter.emit(eventType, eventProcessor, data);
+}
+exports.emitEvent = emitEvent;

package/js/Private/internal/LocalSpatialAudioEngineInternal.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalSpatialAudioEngineInternal = void 0;
+const IAgoraSpatialAudioImpl_1 = require("../impl/IAgoraSpatialAudioImpl");
+class LocalSpatialAudioEngineInternal extends IAgoraSpatialAudioImpl_1.ILocalSpatialAudioEngineImpl {
+}
+exports.LocalSpatialAudioEngineInternal = LocalSpatialAudioEngineInternal;

package/js/Private/internal/MediaEngineInternal.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaEngineInternal = void 0;
+const ts_interface_checker_1 = require("ts-interface-checker");
+const IAgoraMediaEngineImpl_1 = require("../impl/IAgoraMediaEngineImpl");
+const AgoraMediaBase_ti_1 = __importDefault(require("../ti/AgoraMediaBase-ti"));
+const checkers = (0, ts_interface_checker_1.createCheckers)(AgoraMediaBase_ti_1.default);
+const IrisApiEngine_1 = require("./IrisApiEngine");
+class MediaEngineInternal extends IAgoraMediaEngineImpl_1.IMediaEngineImpl {
+    registerAudioFrameObserver(observer) {
+        if (!MediaEngineInternal._audio_frame_observers.find((value) => value === observer)) {
+            MediaEngineInternal._audio_frame_observers.push(observer);
+        }
+        return super.registerAudioFrameObserver(observer);
+    }
+    unregisterAudioFrameObserver(observer) {
+        MediaEngineInternal._audio_frame_observers =
+            MediaEngineInternal._audio_frame_observers.filter((value) => value !== observer);
+        return super.unregisterAudioFrameObserver(observer);
+    }
+    registerVideoFrameObserver(observer) {
+        if (!MediaEngineInternal._video_frame_observers.find((value) => value === observer)) {
+            MediaEngineInternal._video_frame_observers.push(observer);
+        }
+        return super.registerVideoFrameObserver(observer);
+    }
+    unregisterVideoFrameObserver(observer) {
+        MediaEngineInternal._video_frame_observers =
+            MediaEngineInternal._video_frame_observers.filter((value) => value !== observer);
+        return super.unregisterVideoFrameObserver(observer);
+    }
+    registerVideoEncodedFrameObserver(observer) {
+        if (!MediaEngineInternal._video_encoded_frame_observers.find((value) => value === observer)) {
+            MediaEngineInternal._video_encoded_frame_observers.push(observer);
+        }
+        return super.registerVideoEncodedFrameObserver(observer);
+    }
+    unregisterVideoEncodedFrameObserver(observer) {
+        MediaEngineInternal._video_encoded_frame_observers =
+            MediaEngineInternal._video_encoded_frame_observers.filter((value) => value !== observer);
+        return super.unregisterVideoEncodedFrameObserver(observer);
+    }
+    registerFaceInfoObserver(observer) {
+        if (!MediaEngineInternal._face_info_observers.find((value) => value === observer)) {
+            MediaEngineInternal._face_info_observers.push(observer);
+        }
+        return super.registerFaceInfoObserver(observer);
+    }
+    unregisterFaceInfoObserver(observer) {
+        MediaEngineInternal._face_info_observers =
+            MediaEngineInternal._face_info_observers.filter((value) => value !== observer);
+        return super.unregisterFaceInfoObserver(observer);
+    }
+    release() {
+        MediaEngineInternal._audio_frame_observers = [];
+        MediaEngineInternal._video_frame_observers = [];
+        MediaEngineInternal._video_encoded_frame_observers = [];
+        MediaEngineInternal._face_info_observers = [];
+        this.removeAllListeners();
+    }
+    _addListenerPreCheck(eventType) {
+        if (checkers.IAudioFrameObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaEngineInternal._audio_frame_observers.length === 0) {
+                this.registerAudioFrameObserver({});
+            }
+        }
+        if (checkers.IVideoFrameObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaEngineInternal._video_frame_observers.length === 0) {
+                this.registerVideoFrameObserver({});
+            }
+        }
+        if (checkers.IVideoEncodedFrameObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaEngineInternal._video_encoded_frame_observers.length === 0) {
+                this.registerVideoEncodedFrameObserver({});
+            }
+        }
+        if (checkers.IFaceInfoObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaEngineInternal._face_info_observers.length === 0) {
+                this.registerFaceInfoObserver({});
+            }
+        }
+        return true;
+    }
+    addListener(eventType, listener) {
+        this._addListenerPreCheck(eventType);
+        const callback = (eventProcessor, data) => {
+            if (eventProcessor.type(data) !== IrisApiEngine_1.EVENT_TYPE.IMediaEngine) {
+                return;
+            }
+            eventProcessor.func.map((it) => {
+                it({ [eventType]: listener }, eventType, data);
+            });
+        };
+        // @ts-ignore
+        listener.agoraCallback = callback;
+        IrisApiEngine_1.DeviceEventEmitter.addListener(eventType, callback);
+    }
+    removeListener(eventType, listener) {
+        IrisApiEngine_1.DeviceEventEmitter.removeListener(eventType, 
+        // @ts-ignore
+        listener?.agoraCallback ?? listener);
+    }
+    removeAllListeners(eventType) {
+        IrisApiEngine_1.DeviceEventEmitter.removeAllListeners(eventType);
+    }
+}
+exports.MediaEngineInternal = MediaEngineInternal;
+MediaEngineInternal._audio_frame_observers = [];
+MediaEngineInternal._video_frame_observers = [];
+MediaEngineInternal._video_encoded_frame_observers = [];
+MediaEngineInternal._face_info_observers = [];