agora-electron-sdk 4.1.1-rc.1 → 4.2.0-dev.13

package/ts/Private/impl/IAgoraMediaEngineImpl.ts

@@ -1,15 +1,19 @@
-import { callIrisApi } from '../internal/IrisApiEngine';
-import { IMediaEngine } from '../IAgoraMediaEngine';
 import {
-  IAudioFrameObserver,
-  IVideoFrameObserver,
-  IVideoEncodedFrameObserver,
-  MediaSourceType,
+  AudioTrackConfig,
+  AudioTrackType,
+  EncodedVideoFrameInfo,
+  SenderOptions,
+} from '../AgoraBase';
+import {
   AudioFrame,
-  ExternalVideoSourceType,
   ExternalVideoFrame,
+  ExternalVideoSourceType,
+  IAudioFrameObserver,
+  IVideoEncodedFrameObserver,
+  IVideoFrameObserver,
 } from '../AgoraMediaBase';
-import { SenderOptions, EncodedVideoFrameInfo } from '../AgoraBase';
+import { IMediaEngine } from '../IAgoraMediaEngine';
+
 // @ts-ignore
 export class IMediaEngineImpl implements IMediaEngine {
   registerAudioFrameObserver(observer: IAudioFrameObserver): number {
@@ -69,29 +73,15 @@ export class IMediaEngineImpl implements IMediaEngine {
     return 'MediaEngine_registerVideoEncodedFrameObserver';
   }
 
-  pushAudioFrame(
-    type: MediaSourceType,
-    frame: AudioFrame,
-    wrap = false,
-    sourceId = 0
-  ): number {
-    const apiType = this.getApiTypeFromPushAudioFrame(
-      type,
-      frame,
-      wrap,
-      sourceId
-    );
+  pushAudioFrame(frame: AudioFrame, trackId: number = 0): number {
+    const apiType = this.getApiTypeFromPushAudioFrame(frame, trackId);
     const jsonParams = {
-      type: type,
       frame: frame,
-      wrap: wrap,
-      sourceId: sourceId,
+      trackId: trackId,
       toJSON: () => {
         return {
-          type: type,
           frame: frame,
-          wrap: wrap,
-          sourceId: sourceId,
+          trackId: trackId,
         };
       },
     };
@@ -100,68 +90,12 @@ export class IMediaEngineImpl implements IMediaEngine {
   }
 
   protected getApiTypeFromPushAudioFrame(
-    type: MediaSourceType,
     frame: AudioFrame,
-    wrap = false,
-    sourceId = 0
+    trackId: number = 0
   ): string {
     return 'MediaEngine_pushAudioFrame';
   }
 
-  pushCaptureAudioFrame(frame: AudioFrame): number {
-    const apiType = this.getApiTypeFromPushCaptureAudioFrame(frame);
-    const jsonParams = {
-      frame: frame,
-      toJSON: () => {
-        return {
-          frame: frame,
-        };
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromPushCaptureAudioFrame(frame: AudioFrame): string {
-    return 'MediaEngine_pushCaptureAudioFrame';
-  }
-
-  pushReverseAudioFrame(frame: AudioFrame): number {
-    const apiType = this.getApiTypeFromPushReverseAudioFrame(frame);
-    const jsonParams = {
-      frame: frame,
-      toJSON: () => {
-        return {
-          frame: frame,
-        };
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromPushReverseAudioFrame(frame: AudioFrame): string {
-    return 'MediaEngine_pushReverseAudioFrame';
-  }
-
-  pushDirectAudioFrame(frame: AudioFrame): number {
-    const apiType = this.getApiTypeFromPushDirectAudioFrame(frame);
-    const jsonParams = {
-      frame: frame,
-      toJSON: () => {
-        return {
-          frame: frame,
-        };
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromPushDirectAudioFrame(frame: AudioFrame): string {
-    return 'MediaEngine_pushDirectAudioFrame';
-  }
-
   pullAudioFrame(): AudioFrame {
     const apiType = this.getApiTypeFromPullAudioFrame();
     const jsonParams = {};
@@ -217,15 +151,13 @@ export class IMediaEngineImpl implements IMediaEngine {
     enabled: boolean,
     sampleRate: number,
     channels: number,
-    sourceNumber = 1,
-    localPlayback = false,
-    publish = true
+    localPlayback: boolean = false,
+    publish: boolean = true
   ): number {
     const apiType = this.getApiTypeFromSetExternalAudioSource(
       enabled,
       sampleRate,
       channels,
-      sourceNumber,
       localPlayback,
       publish
     );
@@ -233,7 +165,6 @@ export class IMediaEngineImpl implements IMediaEngine {
       enabled: enabled,
       sampleRate: sampleRate,
       channels: channels,
-      sourceNumber: sourceNumber,
       localPlayback: localPlayback,
       publish: publish,
       toJSON: () => {
@@ -241,7 +172,6 @@ export class IMediaEngineImpl implements IMediaEngine {
           enabled: enabled,
           sampleRate: sampleRate,
           channels: channels,
-          sourceNumber: sourceNumber,
           localPlayback: localPlayback,
           publish: publish,
         };
@@ -255,13 +185,59 @@ export class IMediaEngineImpl implements IMediaEngine {
     enabled: boolean,
     sampleRate: number,
     channels: number,
-    sourceNumber = 1,
-    localPlayback = false,
-    publish = true
+    localPlayback: boolean = false,
+    publish: boolean = true
   ): string {
     return 'MediaEngine_setExternalAudioSource';
   }
 
+  createCustomAudioTrack(
+    trackType: AudioTrackType,
+    config: AudioTrackConfig
+  ): number {
+    const apiType = this.getApiTypeFromCreateCustomAudioTrack(
+      trackType,
+      config
+    );
+    const jsonParams = {
+      trackType: trackType,
+      config: config,
+      toJSON: () => {
+        return {
+          trackType: trackType,
+          config: config,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromCreateCustomAudioTrack(
+    trackType: AudioTrackType,
+    config: AudioTrackConfig
+  ): string {
+    return 'MediaEngine_createCustomAudioTrack';
+  }
+
+  destroyCustomAudioTrack(trackId: number): number {
+    const apiType = this.getApiTypeFromDestroyCustomAudioTrack(trackId);
+    const jsonParams = {
+      trackId: trackId,
+      toJSON: () => {
+        return {
+          trackId: trackId,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromDestroyCustomAudioTrack(trackId: number): string {
+    return 'MediaEngine_destroyCustomAudioTrack';
+  }
+
   setExternalAudioSink(
     enabled: boolean,
     sampleRate: number,
@@ -296,17 +272,17 @@ export class IMediaEngineImpl implements IMediaEngine {
     return 'MediaEngine_setExternalAudioSink';
   }
 
-  enableCustomAudioLocalPlayback(sourceId: number, enabled: boolean): number {
+  enableCustomAudioLocalPlayback(trackId: number, enabled: boolean): number {
     const apiType = this.getApiTypeFromEnableCustomAudioLocalPlayback(
-      sourceId,
+      trackId,
       enabled
     );
     const jsonParams = {
-      sourceId: sourceId,
+      trackId: trackId,
       enabled: enabled,
       toJSON: () => {
         return {
-          sourceId: sourceId,
+          trackId: trackId,
           enabled: enabled,
         };
       },
@@ -316,39 +292,13 @@ export class IMediaEngineImpl implements IMediaEngine {
   }
 
   protected getApiTypeFromEnableCustomAudioLocalPlayback(
-    sourceId: number,
+    trackId: number,
     enabled: boolean
   ): string {
     return 'MediaEngine_enableCustomAudioLocalPlayback';
   }
 
-  setDirectExternalAudioSource(enable: boolean, localPlayback = false): number {
-    const apiType = this.getApiTypeFromSetDirectExternalAudioSource(
-      enable,
-      localPlayback
-    );
-    const jsonParams = {
-      enable: enable,
-      localPlayback: localPlayback,
-      toJSON: () => {
-        return {
-          enable: enable,
-          localPlayback: localPlayback,
-        };
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromSetDirectExternalAudioSource(
-    enable: boolean,
-    localPlayback = false
-  ): string {
-    return 'MediaEngine_setDirectExternalAudioSource';
-  }
-
-  pushVideoFrame(frame: ExternalVideoFrame, videoTrackId = 0): number {
+  pushVideoFrame(frame: ExternalVideoFrame, videoTrackId: number = 0): number {
     const apiType = this.getApiTypeFromPushVideoFrame(frame, videoTrackId);
     const jsonParams = {
       frame: frame,
@@ -366,7 +316,7 @@ export class IMediaEngineImpl implements IMediaEngine {
 
   protected getApiTypeFromPushVideoFrame(
     frame: ExternalVideoFrame,
-    videoTrackId = 0
+    videoTrackId: number = 0
   ): string {
     return 'MediaEngine_pushVideoFrame';
   }
@@ -375,7 +325,7 @@ export class IMediaEngineImpl implements IMediaEngine {
     imageBuffer: Uint8Array,
     length: number,
     videoEncodedFrameInfo: EncodedVideoFrameInfo,
-    videoTrackId = 0
+    videoTrackId: number = 0
   ): number {
     const apiType = this.getApiTypeFromPushEncodedVideoImage(
       imageBuffer,
@@ -404,7 +354,7 @@ export class IMediaEngineImpl implements IMediaEngine {
     imageBuffer: Uint8Array,
     length: number,
     videoEncodedFrameInfo: EncodedVideoFrameInfo,
-    videoTrackId = 0
+    videoTrackId: number = 0
   ): string {
     return 'MediaEngine_pushEncodedVideoImage';
   }
@@ -476,3 +426,5 @@ export class IMediaEngineImpl implements IMediaEngine {
     return 'MediaEngine_unregisterVideoEncodedFrameObserver';
   }
 }
+
+import { callIrisApi } from '../internal/IrisApiEngine';

package/ts/Private/impl/IAgoraMediaPlayerImpl.ts

@@ -1,22 +1,23 @@
-import { callIrisApi } from '../internal/IrisApiEngine';
+import { SpatialAudioParams } from '../AgoraBase';
 import {
-  IMediaPlayer,
-  IMediaPlayerAudioFrameObserver,
-  IMediaPlayerVideoFrameObserver,
-  IMediaPlayerCacheManager,
-} from '../IAgoraMediaPlayer';
+  AudioDualMonoMode,
+  IAudioPcmFrameSink,
+  IAudioSpectrumObserver,
+  RawAudioFrameOpModeType,
+  RenderModeType,
+} from '../AgoraMediaBase';
 import {
+  MediaPlayerState,
   MediaSource,
   PlayerStreamInfo,
-  MediaPlayerState,
 } from '../AgoraMediaPlayerTypes';
 import {
-  RenderModeType,
-  IAudioSpectrumObserver,
-  AudioDualMonoMode,
-} from '../AgoraMediaBase';
+  IMediaPlayer,
+  IMediaPlayerCacheManager,
+  IMediaPlayerVideoFrameObserver,
+} from '../IAgoraMediaPlayer';
 import { IMediaPlayerSourceObserver } from '../IAgoraMediaPlayerSource';
-import { SpatialAudioParams } from '../AgoraBase';
+
 // @ts-ignore
 export class IMediaPlayerImpl implements IMediaPlayer {
   getMediaPlayerId(): number {
@@ -530,6 +531,90 @@ export class IMediaPlayerImpl implements IMediaPlayer {
     return 'MediaPlayer_unregisterPlayerSourceObserver';
   }
 
+  registerAudioFrameObserver(
+    observer: IAudioPcmFrameSink,
+    mode: RawAudioFrameOpModeType = RawAudioFrameOpModeType.RawAudioFrameOpModeReadOnly
+  ): number {
+    const apiType = this.getApiTypeFromRegisterAudioFrameObserver(
+      observer,
+      mode
+    );
+    const jsonParams = {
+      observer: observer,
+      mode: mode,
+      toJSON: () => {
+        return {
+          mode: mode,
+        };
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromRegisterAudioFrameObserver(
+    observer: IAudioPcmFrameSink,
+    mode: RawAudioFrameOpModeType = RawAudioFrameOpModeType.RawAudioFrameOpModeReadOnly
+  ): string {
+    return 'MediaPlayer_registerAudioFrameObserver';
+  }
+
+  unregisterAudioFrameObserver(observer: IAudioPcmFrameSink): number {
+    const apiType = this.getApiTypeFromUnregisterAudioFrameObserver(observer);
+    const jsonParams = {
+      observer: observer,
+      toJSON: () => {
+        return {};
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromUnregisterAudioFrameObserver(
+    observer: IAudioPcmFrameSink
+  ): string {
+    return 'MediaPlayer_unregisterAudioFrameObserver';
+  }
+
+  registerVideoFrameObserver(observer: IMediaPlayerVideoFrameObserver): number {
+    const apiType = this.getApiTypeFromRegisterVideoFrameObserver(observer);
+    const jsonParams = {
+      observer: observer,
+      toJSON: () => {
+        return {};
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromRegisterVideoFrameObserver(
+    observer: IMediaPlayerVideoFrameObserver
+  ): string {
+    return 'MediaPlayer_registerVideoFrameObserver';
+  }
+
+  unregisterVideoFrameObserver(
+    observer: IMediaPlayerVideoFrameObserver
+  ): number {
+    const apiType = this.getApiTypeFromUnregisterVideoFrameObserver(observer);
+    const jsonParams = {
+      observer: observer,
+      toJSON: () => {
+        return {};
+      },
+    };
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return jsonResults.result;
+  }
+
+  protected getApiTypeFromUnregisterVideoFrameObserver(
+    observer: IMediaPlayerVideoFrameObserver
+  ): string {
+    return 'MediaPlayer_unregisterVideoFrameObserver';
+  }
+
   registerMediaPlayerAudioSpectrumObserver(
     observer: IAudioSpectrumObserver,
     intervalInMS: number
@@ -725,7 +810,7 @@ export class IMediaPlayerImpl implements IMediaPlayer {
     return 'MediaPlayer_renewAgoraCDNSrcToken';
   }
 
-  switchAgoraCDNSrc(src: string, syncPts = false): number {
+  switchAgoraCDNSrc(src: string, syncPts: boolean = false): number {
     const apiType = this.getApiTypeFromSwitchAgoraCDNSrc(src, syncPts);
     const jsonParams = {
       src: src,
@@ -743,12 +828,12 @@ export class IMediaPlayerImpl implements IMediaPlayer {
 
   protected getApiTypeFromSwitchAgoraCDNSrc(
     src: string,
-    syncPts = false
+    syncPts: boolean = false
   ): string {
     return 'MediaPlayer_switchAgoraCDNSrc';
   }
 
-  switchSrc(src: string, syncPts = true): number {
+  switchSrc(src: string, syncPts: boolean = true): number {
     const apiType = this.getApiTypeFromSwitchSrc(src, syncPts);
     const jsonParams = {
       src: src,
@@ -764,7 +849,10 @@ export class IMediaPlayerImpl implements IMediaPlayer {
     return jsonResults.result;
   }
 
-  protected getApiTypeFromSwitchSrc(src: string, syncPts = true): string {
+  protected getApiTypeFromSwitchSrc(
+    src: string,
+    syncPts: boolean = true
+  ): string {
     return 'MediaPlayer_switchSrc';
   }
 
@@ -866,82 +954,6 @@ export class IMediaPlayerImpl implements IMediaPlayer {
   ): string {
     return 'MediaPlayer_setSoundPositionParams';
   }
-
-  registerAudioFrameObserver(observer: IMediaPlayerAudioFrameObserver): number {
-    const apiType = this.getApiTypeFromRegisterAudioFrameObserver(observer);
-    const jsonParams = {
-      observer: observer,
-      toJSON: () => {
-        return {};
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromRegisterAudioFrameObserver(
-    observer: IMediaPlayerAudioFrameObserver
-  ): string {
-    return 'MediaPlayer_registerAudioFrameObserver';
-  }
-
-  unregisterAudioFrameObserver(
-    observer: IMediaPlayerAudioFrameObserver
-  ): number {
-    const apiType = this.getApiTypeFromUnregisterAudioFrameObserver(observer);
-    const jsonParams = {
-      observer: observer,
-      toJSON: () => {
-        return {};
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromUnregisterAudioFrameObserver(
-    observer: IMediaPlayerAudioFrameObserver
-  ): string {
-    return 'MediaPlayer_unregisterAudioFrameObserver';
-  }
-
-  registerVideoFrameObserver(observer: IMediaPlayerVideoFrameObserver): number {
-    const apiType = this.getApiTypeFromRegisterVideoFrameObserver(observer);
-    const jsonParams = {
-      observer: observer,
-      toJSON: () => {
-        return {};
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromRegisterVideoFrameObserver(
-    observer: IMediaPlayerVideoFrameObserver
-  ): string {
-    return 'MediaPlayer_registerVideoFrameObserver';
-  }
-
-  unregisterVideoFrameObserver(
-    observer: IMediaPlayerVideoFrameObserver
-  ): number {
-    const apiType = this.getApiTypeFromUnregisterVideoFrameObserver(observer);
-    const jsonParams = {
-      observer: observer,
-      toJSON: () => {
-        return {};
-      },
-    };
-    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
-    return jsonResults.result;
-  }
-
-  protected getApiTypeFromUnregisterVideoFrameObserver(
-    observer: IMediaPlayerVideoFrameObserver
-  ): string {
-    return 'MediaPlayer_unregisterVideoFrameObserver';
-  }
 }
 
 // @ts-ignore
@@ -1111,20 +1123,6 @@ export class IMediaPlayerCacheManagerImpl implements IMediaPlayerCacheManager {
   }
 }
 
-export function processIMediaPlayerAudioFrameObserver(
-  handler: IMediaPlayerAudioFrameObserver,
-  event: string,
-  jsonParams: any
-) {
-  switch (event) {
-    case 'onFrame':
-      if (handler.onFrame !== undefined) {
-        handler.onFrame(jsonParams.frame);
-      }
-      break;
-  }
-}
-
 export function processIMediaPlayerVideoFrameObserver(
   handler: IMediaPlayerVideoFrameObserver,
   event: string,
@@ -1138,3 +1136,5 @@ export function processIMediaPlayerVideoFrameObserver(
       break;
   }
 }
+
+import { callIrisApi } from '../internal/IrisApiEngine';

package/ts/Private/impl/IAgoraMediaRecorderImpl.ts

@@ -1,27 +1,17 @@
-import { callIrisApi } from '../internal/IrisApiEngine';
-import { IMediaRecorder } from '../IAgoraMediaRecorder';
-import { RtcConnection } from '../IAgoraRtcEngineEx';
 import {
   IMediaRecorderObserver,
   MediaRecorderConfiguration,
 } from '../AgoraMediaBase';
+import { IMediaRecorder } from '../IAgoraMediaRecorder';
+
 // @ts-ignore
 export class IMediaRecorderImpl implements IMediaRecorder {
-  setMediaRecorderObserver(
-    connection: RtcConnection,
-    callback: IMediaRecorderObserver
-  ): number {
-    const apiType = this.getApiTypeFromSetMediaRecorderObserver(
-      connection,
-      callback
-    );
+  setMediaRecorderObserver(callback: IMediaRecorderObserver): number {
+    const apiType = this.getApiTypeFromSetMediaRecorderObserver(callback);
     const jsonParams = {
-      connection: connection,
       callback: callback,
       toJSON: () => {
-        return {
-          connection: connection,
-        };
+        return {};
       },
     };
     const jsonResults = callIrisApi.call(this, apiType, jsonParams);
@@ -29,23 +19,17 @@ export class IMediaRecorderImpl implements IMediaRecorder {
   }
 
   protected getApiTypeFromSetMediaRecorderObserver(
-    connection: RtcConnection,
     callback: IMediaRecorderObserver
   ): string {
     return 'MediaRecorder_setMediaRecorderObserver';
   }
 
-  startRecording(
-    connection: RtcConnection,
-    config: MediaRecorderConfiguration
-  ): number {
-    const apiType = this.getApiTypeFromStartRecording(connection, config);
+  startRecording(config: MediaRecorderConfiguration): number {
+    const apiType = this.getApiTypeFromStartRecording(config);
     const jsonParams = {
-      connection: connection,
       config: config,
       toJSON: () => {
         return {
-          connection: connection,
           config: config,
         };
       },
@@ -55,37 +39,21 @@ export class IMediaRecorderImpl implements IMediaRecorder {
   }
 
   protected getApiTypeFromStartRecording(
-    connection: RtcConnection,
     config: MediaRecorderConfiguration
   ): string {
     return 'MediaRecorder_startRecording';
   }
 
-  stopRecording(connection: RtcConnection): number {
-    const apiType = this.getApiTypeFromStopRecording(connection);
-    const jsonParams = {
-      connection: connection,
-      toJSON: () => {
-        return {
-          connection: connection,
-        };
-      },
-    };
+  stopRecording(): number {
+    const apiType = this.getApiTypeFromStopRecording();
+    const jsonParams = {};
     const jsonResults = callIrisApi.call(this, apiType, jsonParams);
     return jsonResults.result;
   }
 
-  protected getApiTypeFromStopRecording(connection: RtcConnection): string {
+  protected getApiTypeFromStopRecording(): string {
     return 'MediaRecorder_stopRecording';
   }
-
-  release(): void {
-    const apiType = this.getApiTypeFromRelease();
-    const jsonParams = {};
-    callIrisApi.call(this, apiType, jsonParams);
-  }
-
-  protected getApiTypeFromRelease(): string {
-    return 'MediaRecorder_release';
-  }
 }
+
+import { callIrisApi } from '../internal/IrisApiEngine';