agora-electron-sdk 0.0.0-dev.1

package/js/Private/internal/MediaPlayerInternal.js

@@ -0,0 +1,194 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaPlayerInternal = void 0;
+const ts_interface_checker_1 = require("ts-interface-checker");
+const Utils_1 = require("../../Utils");
+const AgoraBase_1 = require("../AgoraBase");
+const AgoraMediaBase_1 = require("../AgoraMediaBase");
+const IAgoraMediaPlayerImpl_1 = require("../impl/IAgoraMediaPlayerImpl");
+const AgoraMediaBase_ti_1 = __importDefault(require("../ti/AgoraMediaBase-ti"));
+const IAgoraMediaPlayer_ti_1 = __importDefault(require("../ti/IAgoraMediaPlayer-ti"));
+const IAgoraMediaPlayerSource_ti_1 = __importDefault(require("../ti/IAgoraMediaPlayerSource-ti"));
+const checkers = (0, ts_interface_checker_1.createCheckers)(AgoraMediaBase_ti_1.default, IAgoraMediaPlayer_ti_1.default, IAgoraMediaPlayerSource_ti_1.default);
+const IrisApiEngine_1 = require("./IrisApiEngine");
+class MediaPlayerInternal extends IAgoraMediaPlayerImpl_1.IMediaPlayerImpl {
+    constructor(mediaPlayerId) {
+        super();
+        this._mediaPlayerId = mediaPlayerId;
+    }
+    release() {
+        MediaPlayerInternal._source_observers.delete(this._mediaPlayerId);
+        MediaPlayerInternal._audio_frame_observers.delete(this._mediaPlayerId);
+        MediaPlayerInternal._video_frame_observers.delete(this._mediaPlayerId);
+        MediaPlayerInternal._audio_spectrum_observers.delete(this._mediaPlayerId);
+        this.removeAllListeners();
+    }
+    _addListenerPreCheck(eventType) {
+        if (checkers.IMediaPlayerSourceObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaPlayerInternal._source_observers.get(this._mediaPlayerId)
+                ?.length === 0) {
+                this.registerPlayerSourceObserver({});
+            }
+        }
+        if (checkers.IMediaPlayerAudioFrameObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaPlayerInternal._audio_frame_observers.get(this._mediaPlayerId)
+                ?.length === 0) {
+                this.registerAudioFrameObserver({});
+            }
+        }
+        if (checkers.IMediaPlayerVideoFrameObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaPlayerInternal._video_frame_observers.get(this._mediaPlayerId)
+                ?.length === 0) {
+                this.registerVideoFrameObserver({});
+            }
+        }
+        if (checkers.IAudioSpectrumObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaPlayerInternal._audio_spectrum_observers.get(this._mediaPlayerId)
+                ?.length === 0) {
+                (0, Utils_1.logError)('Please call `registerMediaPlayerAudioSpectrumObserver` before you want to receive event by `addListener`');
+                return false;
+            }
+        }
+        return true;
+    }
+    addListener(eventType, listener) {
+        this._addListenerPreCheck(eventType);
+        const callback = (eventProcessor, data) => {
+            if (eventProcessor.type(data) !== IrisApiEngine_1.EVENT_TYPE.IMediaPlayer) {
+                return;
+            }
+            if (data.playerId !== this._mediaPlayerId) {
+                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);
+    }
+    getMediaPlayerId() {
+        return this._mediaPlayerId;
+    }
+    registerPlayerSourceObserver(observer) {
+        let observers = MediaPlayerInternal._source_observers.get(this._mediaPlayerId);
+        if (observers === undefined) {
+            observers = [];
+            MediaPlayerInternal._source_observers.set(this._mediaPlayerId, observers);
+        }
+        if (!observers.find((value) => value === observer)) {
+            observers.push(observer);
+        }
+        return super.registerPlayerSourceObserver(observer);
+    }
+    unregisterPlayerSourceObserver(observer) {
+        let observers = MediaPlayerInternal._source_observers.get(this._mediaPlayerId);
+        if (observers === undefined)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        MediaPlayerInternal._source_observers.set(this._mediaPlayerId, observers.filter((value) => value !== observer));
+        return super.unregisterPlayerSourceObserver(observer);
+    }
+    registerAudioFrameObserver(observer, mode = AgoraMediaBase_1.RawAudioFrameOpModeType.RawAudioFrameOpModeReadOnly) {
+        let observers = MediaPlayerInternal._audio_frame_observers.get(this._mediaPlayerId);
+        if (observers === undefined) {
+            observers = [];
+            MediaPlayerInternal._audio_frame_observers.set(this._mediaPlayerId, observers);
+        }
+        if (!observers.find((value) => value === observer)) {
+            observers.push(observer);
+        }
+        return super.registerAudioFrameObserver(observer, mode);
+    }
+    unregisterAudioFrameObserver(observer) {
+        let observers = MediaPlayerInternal._audio_frame_observers.get(this._mediaPlayerId);
+        if (observers === undefined)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        MediaPlayerInternal._audio_frame_observers.set(this._mediaPlayerId, observers.filter((value) => value !== observer));
+        return super.unregisterAudioFrameObserver(observer);
+    }
+    registerVideoFrameObserver(observer) {
+        let observers = MediaPlayerInternal._video_frame_observers.get(this._mediaPlayerId);
+        if (observers === undefined) {
+            observers = [];
+            MediaPlayerInternal._video_frame_observers.set(this._mediaPlayerId, observers);
+        }
+        if (!observers.find((value) => value === observer)) {
+            observers.push(observer);
+        }
+        return super.registerVideoFrameObserver(observer);
+    }
+    unregisterVideoFrameObserver(observer) {
+        let observers = MediaPlayerInternal._video_frame_observers.get(this._mediaPlayerId);
+        if (observers === undefined)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        MediaPlayerInternal._video_frame_observers.set(this._mediaPlayerId, observers.filter((value) => value !== observer));
+        return super.unregisterVideoFrameObserver(observer);
+    }
+    registerMediaPlayerAudioSpectrumObserver(observer, intervalInMS) {
+        let observers = MediaPlayerInternal._audio_spectrum_observers.get(this._mediaPlayerId);
+        if (observers === undefined) {
+            observers = [];
+            MediaPlayerInternal._audio_spectrum_observers.set(this._mediaPlayerId, observers);
+        }
+        if (!observers.find((value) => value === observer)) {
+            observers.push(observer);
+        }
+        return super.registerMediaPlayerAudioSpectrumObserver(observer, intervalInMS);
+    }
+    unregisterMediaPlayerAudioSpectrumObserver(observer) {
+        let observers = MediaPlayerInternal._audio_spectrum_observers.get(this._mediaPlayerId);
+        if (observers === undefined)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        MediaPlayerInternal._audio_spectrum_observers.set(this._mediaPlayerId, observers.filter((value) => value !== observer));
+        return super.unregisterMediaPlayerAudioSpectrumObserver(observer);
+    }
+    setView(view) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const renderer = Utils_1.AgoraEnv.AgoraRendererManager.addOrRemoveRenderer({
+            sourceType: AgoraMediaBase_1.VideoSourceType.VideoSourceMediaPlayer,
+            mediaPlayerId: this._mediaPlayerId,
+            view,
+        });
+        if (!renderer)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+    setRenderMode(renderMode) {
+        if (!Utils_1.AgoraEnv.AgoraRendererManager)
+            return -AgoraBase_1.ErrorCodeType.ErrNotInitialized;
+        const renderer = Utils_1.AgoraEnv.AgoraRendererManager.setRendererContext({
+            sourceType: AgoraMediaBase_1.VideoSourceType.VideoSourceMediaPlayer,
+            mediaPlayerId: this._mediaPlayerId,
+            renderMode,
+        });
+        if (!renderer)
+            return -AgoraBase_1.ErrorCodeType.ErrFailed;
+        return AgoraBase_1.ErrorCodeType.ErrOk;
+    }
+}
+exports.MediaPlayerInternal = MediaPlayerInternal;
+MediaPlayerInternal._source_observers = new Map();
+MediaPlayerInternal._audio_frame_observers = new Map();
+MediaPlayerInternal._video_frame_observers = new Map();
+MediaPlayerInternal._audio_spectrum_observers = new Map();

package/js/Private/internal/MediaRecorderInternal.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaRecorderInternal = void 0;
+const ts_interface_checker_1 = require("ts-interface-checker");
+const AgoraBase_1 = require("../AgoraBase");
+const IAgoraMediaRecorderImpl_1 = require("../impl/IAgoraMediaRecorderImpl");
+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 MediaRecorderInternal extends IAgoraMediaRecorderImpl_1.IMediaRecorderImpl {
+    constructor(nativeHandle) {
+        super();
+        this._nativeHandle = nativeHandle;
+    }
+    release() {
+        MediaRecorderInternal._observers.delete(this._nativeHandle);
+        this.removeAllListeners();
+    }
+    get nativeHandle() {
+        return this._nativeHandle;
+    }
+    setMediaRecorderObserver(callback) {
+        const key = this._nativeHandle;
+        if (MediaRecorderInternal._observers.has(key)) {
+            return AgoraBase_1.ErrorCodeType.ErrOk;
+        }
+        MediaRecorderInternal._observers.set(key, callback);
+        return super.setMediaRecorderObserver(callback);
+    }
+    _addListenerPreCheck(eventType) {
+        if (checkers.IMediaRecorderObserver?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MediaRecorderInternal._observers.get(this._nativeHandle) === undefined) {
+                this.setMediaRecorderObserver({});
+            }
+        }
+        return true;
+    }
+    addListener(eventType, listener) {
+        this._addListenerPreCheck(eventType);
+        const callback = (eventProcessor, data) => {
+            if (eventProcessor.type(data) !== IrisApiEngine_1.EVENT_TYPE.IMediaRecorder) {
+                return;
+            }
+            if (data.nativeHandle !== this._nativeHandle) {
+                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.MediaRecorderInternal = MediaRecorderInternal;
+MediaRecorderInternal._observers = new Map();

package/js/Private/internal/MusicContentCenterInternal.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MusicCollectionInternal = exports.MusicPlayerInternal = exports.MusicContentCenterInternal = void 0;
+const ts_interface_checker_1 = require("ts-interface-checker");
+const IAgoraMusicContentCenter_1 = require("../IAgoraMusicContentCenter");
+const IAgoraMusicContentCenterImpl_1 = require("../impl/IAgoraMusicContentCenterImpl");
+const IAgoraMusicContentCenter_ti_1 = __importDefault(require("../ti/IAgoraMusicContentCenter-ti"));
+const checkers = (0, ts_interface_checker_1.createCheckers)(IAgoraMusicContentCenter_ti_1.default);
+const IrisApiEngine_1 = require("./IrisApiEngine");
+const MediaPlayerInternal_1 = require("./MediaPlayerInternal");
+class MusicContentCenterInternal extends IAgoraMusicContentCenterImpl_1.IMusicContentCenterImpl {
+    _addListenerPreCheck(eventType) {
+        if (checkers.IMusicContentCenterEventHandler?.strictTest({
+            [eventType]: undefined,
+        })) {
+            if (MusicContentCenterInternal._event_handlers.length === 0) {
+                this.registerEventHandler({});
+            }
+        }
+        return true;
+    }
+    addListener(eventType, listener) {
+        this._addListenerPreCheck(eventType);
+        const callback = (eventProcessor, data) => {
+            if (eventProcessor.type(data) !== IrisApiEngine_1.EVENT_TYPE.IMusicContentCenter) {
+                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);
+    }
+    registerEventHandler(eventHandler) {
+        if (!MusicContentCenterInternal._event_handlers.find((value) => value === eventHandler)) {
+            MusicContentCenterInternal._event_handlers.push(eventHandler);
+        }
+        return super.registerEventHandler(eventHandler);
+    }
+    unregisterEventHandler() {
+        MusicContentCenterInternal._event_handlers = [];
+        return super.unregisterEventHandler();
+    }
+    release() {
+        MusicContentCenterInternal._event_handlers = [];
+        this.removeAllListeners();
+        super.release();
+    }
+    createMusicPlayer() {
+        // @ts-ignore
+        const mediaPlayerId = super.createMusicPlayer();
+        return new MusicPlayerInternal(mediaPlayerId);
+    }
+}
+exports.MusicContentCenterInternal = MusicContentCenterInternal;
+MusicContentCenterInternal._event_handlers = [];
+class _MusicPlayerInternal extends IAgoraMusicContentCenterImpl_1.IMusicPlayerImpl {
+    constructor(mediaPlayerId) {
+        super();
+        this._mediaPlayerId = mediaPlayerId;
+    }
+    getMediaPlayerId() {
+        return this._mediaPlayerId;
+    }
+}
+class MusicPlayerInternal extends MediaPlayerInternal_1.MediaPlayerInternal {
+    constructor(mediaPlayerId) {
+        super(mediaPlayerId);
+        // @ts-ignore
+        this._musicPlayer = new _MusicPlayerInternal(mediaPlayerId);
+    }
+    setPlayMode(mode) {
+        return this._musicPlayer.setPlayMode(mode);
+    }
+    openWithSongCode(songCode, startPos) {
+        return this._musicPlayer.openWithSongCode(songCode, startPos);
+    }
+}
+exports.MusicPlayerInternal = MusicPlayerInternal;
+class _MusicCollection extends IAgoraMusicContentCenter_1.MusicCollection {
+    constructor(collection) {
+        super();
+        this.count = collection.count;
+        this.music = collection.music;
+        this.page = collection.page;
+        this.pageSize = collection.pageSize;
+        this.total = collection.total;
+    }
+    getCount() {
+        return this.count;
+    }
+    getMusic(index) {
+        return this.music[index] ?? {};
+    }
+    getPage() {
+        return this.page;
+    }
+    getPageSize() {
+        return this.pageSize;
+    }
+    getTotal() {
+        return this.total;
+    }
+}
+class MusicCollectionInternal extends IAgoraMusicContentCenterImpl_1.MusicCollectionImpl {
+    constructor(musicCollection) {
+        super();
+        this._musicCollection = new _MusicCollection(musicCollection);
+    }
+    getCount() {
+        return this._musicCollection.getCount();
+    }
+    getMusic(index) {
+        return this._musicCollection.getMusic(index);
+    }
+    getPage() {
+        return this._musicCollection.getPage();
+    }
+    getPageSize() {
+        return this._musicCollection.getPageSize();
+    }
+    getTotal() {
+        return this._musicCollection.getTotal();
+    }
+}
+exports.MusicCollectionInternal = MusicCollectionInternal;