agora-electron-sdk 0.0.0-dev.1

package/ts/Private/internal/MediaEngineInternal.ts

@@ -0,0 +1,190 @@
+import { createCheckers } from 'ts-interface-checker';
+
+import {
+  IAudioFrameObserver,
+  IFaceInfoObserver,
+  IVideoEncodedFrameObserver,
+  IVideoFrameObserver,
+} from '../AgoraMediaBase';
+import { IMediaEngineEvent } from '../extension/IAgoraMediaEngineExtension';
+import { IMediaEngineImpl } from '../impl/IAgoraMediaEngineImpl';
+import AgoraMediaBaseTI from '../ti/AgoraMediaBase-ti';
+const checkers = createCheckers(AgoraMediaBaseTI);
+
+import {
+  DeviceEventEmitter,
+  EVENT_TYPE,
+  EventProcessor,
+} from './IrisApiEngine';
+
+export class MediaEngineInternal extends IMediaEngineImpl {
+  static _audio_frame_observers: IAudioFrameObserver[] = [];
+  static _video_frame_observers: IVideoFrameObserver[] = [];
+  static _video_encoded_frame_observers: IVideoEncodedFrameObserver[] = [];
+  static _face_info_observers: IFaceInfoObserver[] = [];
+
+  override registerAudioFrameObserver(observer: IAudioFrameObserver): number {
+    if (
+      !MediaEngineInternal._audio_frame_observers.find(
+        (value) => value === observer
+      )
+    ) {
+      MediaEngineInternal._audio_frame_observers.push(observer);
+    }
+    return super.registerAudioFrameObserver(observer);
+  }
+
+  override unregisterAudioFrameObserver(observer: IAudioFrameObserver): number {
+    MediaEngineInternal._audio_frame_observers =
+      MediaEngineInternal._audio_frame_observers.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterAudioFrameObserver(observer);
+  }
+
+  override registerVideoFrameObserver(observer: IVideoFrameObserver): number {
+    if (
+      !MediaEngineInternal._video_frame_observers.find(
+        (value) => value === observer
+      )
+    ) {
+      MediaEngineInternal._video_frame_observers.push(observer);
+    }
+    return super.registerVideoFrameObserver(observer);
+  }
+
+  override unregisterVideoFrameObserver(observer: IVideoFrameObserver): number {
+    MediaEngineInternal._video_frame_observers =
+      MediaEngineInternal._video_frame_observers.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterVideoFrameObserver(observer);
+  }
+
+  override registerVideoEncodedFrameObserver(
+    observer: IVideoEncodedFrameObserver
+  ): number {
+    if (
+      !MediaEngineInternal._video_encoded_frame_observers.find(
+        (value) => value === observer
+      )
+    ) {
+      MediaEngineInternal._video_encoded_frame_observers.push(observer);
+    }
+    return super.registerVideoEncodedFrameObserver(observer);
+  }
+
+  override unregisterVideoEncodedFrameObserver(
+    observer: IVideoEncodedFrameObserver
+  ): number {
+    MediaEngineInternal._video_encoded_frame_observers =
+      MediaEngineInternal._video_encoded_frame_observers.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterVideoEncodedFrameObserver(observer);
+  }
+
+  override registerFaceInfoObserver(observer: IFaceInfoObserver): number {
+    if (
+      !MediaEngineInternal._face_info_observers.find(
+        (value) => value === observer
+      )
+    ) {
+      MediaEngineInternal._face_info_observers.push(observer);
+    }
+    return super.registerFaceInfoObserver(observer);
+  }
+
+  override unregisterFaceInfoObserver(observer: IFaceInfoObserver): number {
+    MediaEngineInternal._face_info_observers =
+      MediaEngineInternal._face_info_observers.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterFaceInfoObserver(observer);
+  }
+
+  override release() {
+    MediaEngineInternal._audio_frame_observers = [];
+    MediaEngineInternal._video_frame_observers = [];
+    MediaEngineInternal._video_encoded_frame_observers = [];
+    MediaEngineInternal._face_info_observers = [];
+    this.removeAllListeners();
+  }
+
+  _addListenerPreCheck<EventType extends keyof IMediaEngineEvent>(
+    eventType: EventType
+  ): boolean {
+    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 extends keyof IMediaEngineEvent>(
+    eventType: EventType,
+    listener: IMediaEngineEvent[EventType]
+  ) {
+    this._addListenerPreCheck(eventType);
+    const callback = (eventProcessor: EventProcessor<any>, data: any) => {
+      if (eventProcessor.type(data) !== EVENT_TYPE.IMediaEngine) {
+        return;
+      }
+      eventProcessor.func.map((it) => {
+        it({ [eventType]: listener }, eventType, data);
+      });
+    };
+    // @ts-ignore
+    listener!.agoraCallback = callback;
+    DeviceEventEmitter.addListener(eventType, callback);
+  }
+
+  removeListener<EventType extends keyof IMediaEngineEvent>(
+    eventType: EventType,
+    listener?: IMediaEngineEvent[EventType]
+  ) {
+    DeviceEventEmitter.removeListener(
+      eventType,
+      // @ts-ignore
+      listener?.agoraCallback ?? listener
+    );
+  }
+
+  removeAllListeners<EventType extends keyof IMediaEngineEvent>(
+    eventType?: EventType
+  ) {
+    DeviceEventEmitter.removeAllListeners(eventType);
+  }
+}

package/ts/Private/internal/MediaPlayerInternal.ts

@@ -0,0 +1,311 @@
+import { createCheckers } from 'ts-interface-checker';
+
+import { AgoraEnv, logError } from '../../Utils';
+import { ErrorCodeType } from '../AgoraBase';
+import {
+  IAudioPcmFrameSink,
+  IAudioSpectrumObserver,
+  RawAudioFrameOpModeType,
+  RenderModeType,
+  VideoSourceType,
+} from '../AgoraMediaBase';
+import { IMediaPlayerVideoFrameObserver } from '../IAgoraMediaPlayer';
+import { IMediaPlayerSourceObserver } from '../IAgoraMediaPlayerSource';
+import { IMediaPlayerEvent } from '../extension/IAgoraMediaPlayerExtension';
+import { IMediaPlayerImpl } from '../impl/IAgoraMediaPlayerImpl';
+import AgoraMediaBaseTI from '../ti/AgoraMediaBase-ti';
+import IAgoraMediaPlayerTI from '../ti/IAgoraMediaPlayer-ti';
+import IAgoraMediaPlayerSourceTI from '../ti/IAgoraMediaPlayerSource-ti';
+const checkers = createCheckers(
+  AgoraMediaBaseTI,
+  IAgoraMediaPlayerTI,
+  IAgoraMediaPlayerSourceTI
+);
+
+import {
+  DeviceEventEmitter,
+  EVENT_TYPE,
+  EventProcessor,
+} from './IrisApiEngine';
+
+export class MediaPlayerInternal extends IMediaPlayerImpl {
+  static _source_observers: Map<number, IMediaPlayerSourceObserver[]> = new Map<
+    number,
+    IMediaPlayerSourceObserver[]
+  >();
+  static _audio_frame_observers: Map<number, IAudioPcmFrameSink[]> = new Map<
+    number,
+    IAudioPcmFrameSink[]
+  >();
+  static _video_frame_observers: Map<number, IMediaPlayerVideoFrameObserver[]> =
+    new Map<number, IMediaPlayerVideoFrameObserver[]>();
+  static _audio_spectrum_observers: Map<number, IAudioSpectrumObserver[]> =
+    new Map<number, IAudioSpectrumObserver[]>();
+  private readonly _mediaPlayerId: number;
+
+  constructor(mediaPlayerId: number) {
+    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 extends keyof IMediaPlayerEvent>(
+    eventType: EventType
+  ): boolean {
+    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
+      ) {
+        logError(
+          'Please call `registerMediaPlayerAudioSpectrumObserver` before you want to receive event by `addListener`'
+        );
+        return false;
+      }
+    }
+    return true;
+  }
+
+  addListener<EventType extends keyof IMediaPlayerEvent>(
+    eventType: EventType,
+    listener: IMediaPlayerEvent[EventType]
+  ): void {
+    this._addListenerPreCheck(eventType);
+    const callback = (eventProcessor: EventProcessor<any>, data: any) => {
+      if (eventProcessor.type(data) !== EVENT_TYPE.IMediaPlayer) {
+        return;
+      }
+      if (data.playerId !== this._mediaPlayerId) {
+        return;
+      }
+      eventProcessor.func.map((it) => {
+        it({ [eventType]: listener }, eventType, data);
+      });
+    };
+    // @ts-ignore
+    listener!.agoraCallback = callback;
+    DeviceEventEmitter.addListener(eventType, callback);
+  }
+
+  removeListener<EventType extends keyof IMediaPlayerEvent>(
+    eventType: EventType,
+    listener?: IMediaPlayerEvent[EventType]
+  ) {
+    DeviceEventEmitter.removeListener(
+      eventType,
+      // @ts-ignore
+      listener?.agoraCallback ?? listener
+    );
+  }
+
+  removeAllListeners<EventType extends keyof IMediaPlayerEvent>(
+    eventType?: EventType
+  ) {
+    DeviceEventEmitter.removeAllListeners(eventType);
+  }
+
+  override getMediaPlayerId(): number {
+    return this._mediaPlayerId;
+  }
+
+  override registerPlayerSourceObserver(
+    observer: IMediaPlayerSourceObserver
+  ): number {
+    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);
+  }
+
+  override unregisterPlayerSourceObserver(
+    observer: IMediaPlayerSourceObserver
+  ): number {
+    let observers = MediaPlayerInternal._source_observers.get(
+      this._mediaPlayerId
+    );
+    if (observers === undefined) return -ErrorCodeType.ErrFailed;
+    MediaPlayerInternal._source_observers.set(
+      this._mediaPlayerId,
+      observers.filter((value) => value !== observer)
+    );
+    return super.unregisterPlayerSourceObserver(observer);
+  }
+
+  override registerAudioFrameObserver(
+    observer: IAudioPcmFrameSink,
+    mode: RawAudioFrameOpModeType = RawAudioFrameOpModeType.RawAudioFrameOpModeReadOnly
+  ): number {
+    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);
+  }
+
+  override unregisterAudioFrameObserver(observer: IAudioPcmFrameSink): number {
+    let observers = MediaPlayerInternal._audio_frame_observers.get(
+      this._mediaPlayerId
+    );
+    if (observers === undefined) return -ErrorCodeType.ErrFailed;
+    MediaPlayerInternal._audio_frame_observers.set(
+      this._mediaPlayerId,
+      observers.filter((value) => value !== observer)
+    );
+    return super.unregisterAudioFrameObserver(observer);
+  }
+
+  override registerVideoFrameObserver(
+    observer: IMediaPlayerVideoFrameObserver
+  ): number {
+    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);
+  }
+
+  override unregisterVideoFrameObserver(
+    observer: IMediaPlayerVideoFrameObserver
+  ): number {
+    let observers = MediaPlayerInternal._video_frame_observers.get(
+      this._mediaPlayerId
+    );
+    if (observers === undefined) return -ErrorCodeType.ErrFailed;
+    MediaPlayerInternal._video_frame_observers.set(
+      this._mediaPlayerId,
+      observers.filter((value) => value !== observer)
+    );
+    return super.unregisterVideoFrameObserver(observer);
+  }
+
+  override registerMediaPlayerAudioSpectrumObserver(
+    observer: IAudioSpectrumObserver,
+    intervalInMS: number
+  ): number {
+    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
+    );
+  }
+
+  override unregisterMediaPlayerAudioSpectrumObserver(
+    observer: IAudioSpectrumObserver
+  ): number {
+    let observers = MediaPlayerInternal._audio_spectrum_observers.get(
+      this._mediaPlayerId
+    );
+    if (observers === undefined) return -ErrorCodeType.ErrFailed;
+    MediaPlayerInternal._audio_spectrum_observers.set(
+      this._mediaPlayerId,
+      observers.filter((value) => value !== observer)
+    );
+    return super.unregisterMediaPlayerAudioSpectrumObserver(observer);
+  }
+
+  override setView(view: HTMLElement): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const renderer = AgoraEnv.AgoraRendererManager.addOrRemoveRenderer({
+      sourceType: VideoSourceType.VideoSourceMediaPlayer,
+      mediaPlayerId: this._mediaPlayerId,
+      view,
+    });
+    if (!renderer) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setRenderMode(renderMode: RenderModeType): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const renderer = AgoraEnv.AgoraRendererManager.setRendererContext({
+      sourceType: VideoSourceType.VideoSourceMediaPlayer,
+      mediaPlayerId: this._mediaPlayerId,
+      renderMode,
+    });
+    if (!renderer) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+}

package/ts/Private/internal/MediaRecorderInternal.ts

@@ -0,0 +1,100 @@
+import { createCheckers } from 'ts-interface-checker';
+
+import { ErrorCodeType } from '../AgoraBase';
+import { IMediaRecorderObserver } from '../AgoraMediaBase';
+import { IMediaRecorderEvent } from '../extension/IAgoraMediaRecorderExtension';
+import { IMediaRecorderImpl } from '../impl/IAgoraMediaRecorderImpl';
+import AgoraMediaBaseTI from '../ti/AgoraMediaBase-ti';
+const checkers = createCheckers(AgoraMediaBaseTI);
+
+import {
+  DeviceEventEmitter,
+  EVENT_TYPE,
+  EventProcessor,
+} from './IrisApiEngine';
+
+export class MediaRecorderInternal extends IMediaRecorderImpl {
+  static _observers: Map<string, IMediaRecorderObserver> = new Map<
+    string,
+    IMediaRecorderObserver
+  >();
+  private readonly _nativeHandle: string;
+
+  constructor(nativeHandle: string) {
+    super();
+    this._nativeHandle = nativeHandle;
+  }
+
+  release() {
+    MediaRecorderInternal._observers.delete(this._nativeHandle);
+    this.removeAllListeners();
+  }
+
+  get nativeHandle(): string {
+    return this._nativeHandle;
+  }
+
+  override setMediaRecorderObserver(callback: IMediaRecorderObserver): number {
+    const key = this._nativeHandle;
+    if (MediaRecorderInternal._observers.has(key)) {
+      return ErrorCodeType.ErrOk;
+    }
+    MediaRecorderInternal._observers.set(key, callback);
+    return super.setMediaRecorderObserver(callback);
+  }
+
+  _addListenerPreCheck<EventType extends keyof IMediaRecorderEvent>(
+    eventType: EventType
+  ): boolean {
+    if (
+      checkers.IMediaRecorderObserver?.strictTest({
+        [eventType]: undefined,
+      })
+    ) {
+      if (
+        MediaRecorderInternal._observers.get(this._nativeHandle) === undefined
+      ) {
+        this.setMediaRecorderObserver({});
+      }
+    }
+    return true;
+  }
+
+  addListener<EventType extends keyof IMediaRecorderEvent>(
+    eventType: EventType,
+    listener: IMediaRecorderEvent[EventType]
+  ): void {
+    this._addListenerPreCheck(eventType);
+    const callback = (eventProcessor: EventProcessor<any>, data: any) => {
+      if (eventProcessor.type(data) !== EVENT_TYPE.IMediaRecorder) {
+        return;
+      }
+      if (data.nativeHandle !== this._nativeHandle) {
+        return;
+      }
+      eventProcessor.func.map((it) => {
+        it({ [eventType]: listener }, eventType, data);
+      });
+    };
+    // @ts-ignore
+    listener!.agoraCallback = callback;
+    DeviceEventEmitter.addListener(eventType, callback);
+  }
+
+  removeListener<EventType extends keyof IMediaRecorderEvent>(
+    eventType: EventType,
+    listener?: IMediaRecorderEvent[EventType]
+  ) {
+    DeviceEventEmitter.removeListener(
+      eventType,
+      // @ts-ignore
+      listener?.agoraCallback ?? listener
+    );
+  }
+
+  removeAllListeners<EventType extends keyof IMediaRecorderEvent>(
+    eventType?: EventType
+  ) {
+    DeviceEventEmitter.removeAllListeners(eventType);
+  }
+}