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

package/ts/Private/internal/RtcEngineExInternal.ts

@@ -9,21 +9,25 @@ import {
   ClientRoleOptions,
   ClientRoleType,
   DataStreamConfig,
+  EchoTestConfiguration,
   ErrorCodeType,
   IAudioEncodedFrameObserver,
+  RecorderStreamInfo,
   SimulcastStreamConfig,
   SimulcastStreamMode,
   VideoCanvas,
   VideoMirrorModeType,
-  VideoSourceType,
   WatermarkOptions,
 } from '../AgoraBase';
-import { IAudioSpectrumObserver } from '../AgoraMediaBase';
+import {
+  IAudioSpectrumObserver,
+  RenderModeType,
+  VideoSourceType,
+} from '../AgoraMediaBase';
 import { IMediaEngine } from '../IAgoraMediaEngine';
 import { IMediaPlayer } from '../IAgoraMediaPlayer';
 import { IMediaRecorder } from '../IAgoraMediaRecorder';
 import { IMusicContentCenter } from '../IAgoraMusicContentCenter';
-import { RtcConnection } from '../IAgoraRtcEngineEx';
 import {
   ChannelMediaOptions,
   DirectCdnStreamingMediaOptions,
@@ -34,13 +38,14 @@ import {
   LeaveChannelOptions,
   MetadataType,
   RtcEngineContext,
-  ScreenCaptureSourceInfo,
   SDKBuildInfo,
+  ScreenCaptureConfiguration,
+  ScreenCaptureSourceInfo,
   Size,
 } from '../IAgoraRtcEngine';
+import { RtcConnection } from '../IAgoraRtcEngineEx';
 import { ILocalSpatialAudioEngine } from '../IAgoraSpatialAudio';
 import { IAudioDeviceManager } from '../IAudioDeviceManager';
-
 import { IRtcEngineEvent } from '../extension/IAgoraRtcEngineExtension';
 
 import { processIAudioEncodedFrameObserver } from '../impl/AgoraBaseImpl';
@@ -56,21 +61,21 @@ import {
 import AgoraBaseTI from '../ti/AgoraBase-ti';
 import AgoraMediaBaseTI from '../ti/AgoraMediaBase-ti';
 import IAgoraRtcEngineTI from '../ti/IAgoraRtcEngine-ti';
-const checkers = createCheckers(
-  AgoraBaseTI,
-  AgoraMediaBaseTI,
-  IAgoraRtcEngineTI
-);
 
 import { AudioDeviceManagerInternal } from './AudioDeviceManagerInternal';
+import { DeviceEventEmitter, EVENT_TYPE, callIrisApi } from './IrisApiEngine';
 import { LocalSpatialAudioEngineInternal } from './LocalSpatialAudioEngineInternal';
 import { MediaEngineInternal } from './MediaEngineInternal';
 import { MediaPlayerInternal } from './MediaPlayerInternal';
 import { MediaRecorderInternal } from './MediaRecorderInternal';
 import { MusicContentCenterInternal } from './MusicContentCenterInternal';
+import type { EmitterSubscription } from './emitter/EventEmitter';
 
-import { callIrisApi, DeviceEventEmitter, EVENT_TYPE } from './IrisApiEngine';
-import { EmitterSubscription } from './emitter/EventEmitter';
+const checkers = createCheckers(
+  AgoraBaseTI,
+  AgoraMediaBaseTI,
+  IAgoraRtcEngineTI
+);
 
 export class RtcEngineExInternal extends IRtcEngineExImpl {
   static _event_handlers: IRtcEngineEventHandler[] = [];
@@ -84,7 +89,6 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
   private _video_device_manager: IVideoDeviceManager =
     new IVideoDeviceManagerImpl();
   private _media_engine: IMediaEngine = new MediaEngineInternal();
-  private _media_recorder: IMediaRecorder = new MediaRecorderInternal();
   private _music_content_center: IMusicContentCenter =
     new MusicContentCenterInternal();
   private _local_spatial_audio_engine: ILocalSpatialAudioEngine =
@@ -103,7 +107,11 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     }
   >();
 
-  initialize(context: RtcEngineContext): number {
+  override initialize(context: RtcEngineContext): number {
+    if (AgoraEnv.webEnvReady) {
+      const { RendererManager } = require('../../Renderer/RendererManager');
+      AgoraEnv.AgoraRendererManager = new RendererManager();
+    }
     AgoraEnv.AgoraRendererManager?.enableRender();
     const ret = super.initialize(context);
     callIrisApi.call(this, 'RtcEngine_setAppType', {
@@ -112,12 +120,13 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return ret;
   }
 
-  release(sync: boolean = false) {
-    AgoraEnv.AgoraRendererManager?.enableRender(false);
+  override release(sync: boolean = false) {
+    AgoraEnv.AgoraElectronBridge.ReleaseRenderer();
+    AgoraEnv.AgoraRendererManager?.clear();
+    AgoraEnv.AgoraRendererManager = undefined;
     this._audio_device_manager.release();
     this._video_device_manager.release();
     this._media_engine.release();
-    this._media_recorder.release();
     this._local_spatial_audio_engine.release();
     RtcEngineExInternal._event_handlers = [];
     RtcEngineExInternal._direct_cdn_streaming_event_handler = [];
@@ -233,9 +242,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     listener: IRtcEngineEvent[EventType]
   ) {
     if (!this._events.has(listener)) return;
-    DeviceEventEmitter.removeSubscription(
-      this._events.get(listener)!.subscription
-    );
+    this._events.get(listener)!.subscription.remove();
     this._events.delete(listener);
   }
 
@@ -257,7 +264,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     }
   }
 
-  getVersion(): SDKBuildInfo {
+  override getVersion(): SDKBuildInfo {
     const apiType = 'RtcEngine_getVersion';
     const jsonParams = {};
     const jsonResults = callIrisApi.call(this, apiType, jsonParams);
@@ -267,7 +274,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     };
   }
 
-  registerEventHandler(eventHandler: IRtcEngineEventHandler): boolean {
+  override registerEventHandler(eventHandler: IRtcEngineEventHandler): boolean {
     if (
       !RtcEngineExInternal._event_handlers.find(
         (value) => value === eventHandler
@@ -278,7 +285,9 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.registerEventHandler(eventHandler);
   }
 
-  unregisterEventHandler(eventHandler: IRtcEngineEventHandler): boolean {
+  override unregisterEventHandler(
+    eventHandler: IRtcEngineEventHandler
+  ): boolean {
     RtcEngineExInternal._event_handlers =
       RtcEngineExInternal._event_handlers.filter(
         (value) => value !== eventHandler
@@ -286,19 +295,31 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.unregisterEventHandler(eventHandler);
   }
 
-  createMediaPlayer(): IMediaPlayer {
+  override createMediaPlayer(): IMediaPlayer {
     // @ts-ignore
     const mediaPlayerId = super.createMediaPlayer() as number;
     return new MediaPlayerInternal(mediaPlayerId);
   }
 
-  destroyMediaPlayer(mediaPlayer: IMediaPlayer): number {
+  override destroyMediaPlayer(mediaPlayer: IMediaPlayer): number {
     const ret = super.destroyMediaPlayer(mediaPlayer);
     mediaPlayer.release?.call(mediaPlayer);
     return ret;
   }
 
-  startDirectCdnStreaming(
+  override createMediaRecorder(info: RecorderStreamInfo): IMediaRecorder {
+    // @ts-ignore
+    const nativeHandle = super.createMediaRecorder(info) as string;
+    return new MediaRecorderInternal(nativeHandle);
+  }
+
+  override destroyMediaRecorder(mediaRecorder: IMediaRecorder): number {
+    const ret = super.destroyMediaRecorder(mediaRecorder);
+    mediaRecorder.release?.call(mediaRecorder);
+    return ret;
+  }
+
+  override startDirectCdnStreaming(
     eventHandler: IDirectCdnStreamingEventHandler,
     publishUrl: string,
     options: DirectCdnStreamingMediaOptions
@@ -315,7 +336,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.startDirectCdnStreaming(eventHandler, publishUrl, options);
   }
 
-  registerMediaMetadataObserver(
+  override registerMediaMetadataObserver(
     observer: IMetadataObserver,
     type: MetadataType
   ): number {
@@ -329,7 +350,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.registerMediaMetadataObserver(observer, type);
   }
 
-  unregisterMediaMetadataObserver(
+  override unregisterMediaMetadataObserver(
     observer: IMetadataObserver,
     type: MetadataType
   ): number {
@@ -340,22 +361,27 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.unregisterMediaMetadataObserver(observer, type);
   }
 
-  protected getApiTypeFromJoinChannel(
+  protected override getApiTypeFromJoinChannel(
     token: string,
     channelId: string,
     uid: number,
     options: ChannelMediaOptions
   ): string {
+    if (AgoraEnv.AgoraRendererManager) {
+      AgoraEnv.AgoraRendererManager.defaultRenderConfig.channelId = channelId;
+    }
     return 'RtcEngine_joinChannel2';
   }
 
-  protected getApiTypeFromLeaveChannel(options?: LeaveChannelOptions): string {
+  protected override getApiTypeFromLeaveChannel(
+    options?: LeaveChannelOptions
+  ): string {
     return options === undefined
       ? 'RtcEngine_leaveChannel'
       : 'RtcEngine_leaveChannel2';
   }
 
-  protected getApiTypeFromSetClientRole(
+  protected override getApiTypeFromSetClientRole(
     role: ClientRoleType,
     options?: ClientRoleOptions
   ): string {
@@ -364,31 +390,31 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
       : 'RtcEngine_setClientRole2';
   }
 
-  protected getApiTypeFromStartEchoTest(
-    intervalInSeconds: number = 10
+  protected override getApiTypeFromStartEchoTest(
+    config: EchoTestConfiguration
   ): string {
-    return 'RtcEngine_startEchoTest2';
+    return 'RtcEngine_startEchoTest3';
   }
 
-  protected getApiTypeFromStartPreview(
+  protected override getApiTypeFromStartPreview(
     sourceType: VideoSourceType = VideoSourceType.VideoSourceCameraPrimary
   ): string {
     return 'RtcEngine_startPreview2';
   }
 
-  protected getApiTypeFromStopPreview(
+  protected override getApiTypeFromStopPreview(
     sourceType: VideoSourceType = VideoSourceType.VideoSourceCameraPrimary
   ): string {
     return 'RtcEngine_stopPreview2';
   }
 
-  protected getApiTypeFromStartAudioRecording(
+  protected override getApiTypeFromStartAudioRecording(
     config: AudioRecordingConfiguration
   ): string {
     return 'RtcEngine_startAudioRecording3';
   }
 
-  protected getApiTypeFromStartAudioMixing(
+  protected override getApiTypeFromStartAudioMixing(
     filePath: string,
     loopback: boolean,
     cycle: number,
@@ -397,7 +423,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return 'RtcEngine_startAudioMixing2';
   }
 
-  protected getApiTypeFromEnableDualStreamMode(
+  protected override getApiTypeFromEnableDualStreamMode(
     enabled: boolean,
     streamConfig?: SimulcastStreamConfig
   ): string {
@@ -406,7 +432,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
       : 'RtcEngine_enableDualStreamMode2';
   }
 
-  protected getApiTypeFromSetDualStreamMode(
+  protected override getApiTypeFromSetDualStreamMode(
     mode: SimulcastStreamMode,
     streamConfig?: SimulcastStreamConfig
   ): string {
@@ -415,67 +441,81 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
       : 'RtcEngine_setDualStreamMode2';
   }
 
-  protected getApiTypeFromLeaveChannelEx(
+  protected override getApiTypeFromLeaveChannelEx(
     connection: RtcConnection,
     options?: LeaveChannelOptions
   ): string {
     return 'RtcEngineEx_leaveChannelEx2';
   }
 
-  protected getApiTypeFromCreateDataStream(config: DataStreamConfig): string {
+  protected override getApiTypeFromCreateDataStream(
+    config: DataStreamConfig
+  ): string {
     return 'RtcEngine_createDataStream2';
   }
 
-  protected getApiTypeFromAddVideoWatermark(
+  protected override getApiTypeFromAddVideoWatermark(
     watermarkUrl: string,
     options: WatermarkOptions
   ): string {
     return 'RtcEngine_addVideoWatermark2';
   }
 
-  protected getApiTypeFromJoinChannelWithUserAccount(
+  protected override getApiTypeFromJoinChannelWithUserAccount(
     token: string,
     channelId: string,
     userAccount: string,
     options?: ChannelMediaOptions
   ): string {
+    if (AgoraEnv.AgoraRendererManager) {
+      AgoraEnv.AgoraRendererManager.defaultRenderConfig.channelId = channelId;
+    }
     return options === undefined
       ? 'RtcEngine_joinChannelWithUserAccount'
       : 'RtcEngine_joinChannelWithUserAccount2';
   }
 
-  protected getApiTypeFromCreateDataStreamEx(
+  protected override getApiTypeFromCreateDataStreamEx(
     config: DataStreamConfig,
     connection: RtcConnection
   ): string {
     return 'RtcEngineEx_createDataStreamEx2';
   }
 
-  getAudioDeviceManager(): IAudioDeviceManager {
+  protected override getApiTypeFromStartScreenCaptureBySourceType(
+    sourceType: VideoSourceType,
+    config: ScreenCaptureConfiguration
+  ): string {
+    return 'RtcEngine_startScreenCapture2';
+  }
+
+  protected override getApiTypeFromStopScreenCaptureBySourceType(
+    sourceType: VideoSourceType
+  ): string {
+    return 'RtcEngine_stopScreenCapture2';
+  }
+
+  override getAudioDeviceManager(): IAudioDeviceManager {
     return this._audio_device_manager;
   }
 
-  getVideoDeviceManager(): IVideoDeviceManager {
+  override getVideoDeviceManager(): IVideoDeviceManager {
     return this._video_device_manager;
   }
 
-  getMediaEngine(): IMediaEngine {
+  override getMediaEngine(): IMediaEngine {
     return this._media_engine;
   }
 
-  getMediaRecorder(): IMediaRecorder {
-    return this._media_recorder;
-  }
-
-  getMusicContentCenter(): IMusicContentCenter {
+  override getMusicContentCenter(): IMusicContentCenter {
     return this._music_content_center;
   }
 
-  getLocalSpatialAudioEngine(): ILocalSpatialAudioEngine {
+  override getLocalSpatialAudioEngine(): ILocalSpatialAudioEngine {
     return this._local_spatial_audio_engine;
   }
 
-  registerAudioEncodedFrameObserver(
+  override registerAudioEncodedFrameObserver(
     config: AudioEncodedFrameObserverConfig,
     observer: IAudioEncodedFrameObserver
   ): number {
@@ -489,7 +529,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.registerAudioEncodedFrameObserver(config, observer);
   }
 
-  unregisterAudioEncodedFrameObserver(
+  override unregisterAudioEncodedFrameObserver(
     observer: IAudioEncodedFrameObserver
   ): number {
     RtcEngineExInternal._audio_encoded_frame_observers =
@@ -499,7 +539,9 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.unregisterAudioEncodedFrameObserver(observer);
   }
 
-  registerAudioSpectrumObserver(observer: IAudioSpectrumObserver): number {
+  override registerAudioSpectrumObserver(
+    observer: IAudioSpectrumObserver
+  ): number {
     if (
       !RtcEngineExInternal._audio_spectrum_observers.find(
         (value) => value === observer
@@ -510,7 +552,9 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.registerAudioSpectrumObserver(observer);
   }
 
-  unregisterAudioSpectrumObserver(observer: IAudioSpectrumObserver): number {
+  override unregisterAudioSpectrumObserver(
+    observer: IAudioSpectrumObserver
+  ): number {
     RtcEngineExInternal._audio_spectrum_observers =
       RtcEngineExInternal._audio_spectrum_observers.filter(
         (value) => value !== observer
@@ -518,7 +562,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return super.unregisterAudioSpectrumObserver(observer);
   }
 
-  getScreenCaptureSources(
+  override getScreenCaptureSources(
     thumbSize: Size,
     iconSize: Size,
     includeScreen: boolean
@@ -546,14 +590,21 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
       });
   }
 
-  setupLocalVideo(canvas: VideoCanvas): number {
-    const {
+  override setupLocalVideo(canvas: VideoCanvas): number {
+    let {
       sourceType = VideoSourceType.VideoSourceCamera,
       uid,
+      mediaPlayerId,
       view,
       renderMode,
       mirrorMode,
     } = canvas;
+    if (
+      sourceType === VideoSourceType.VideoSourceMediaPlayer &&
+      mediaPlayerId !== undefined
+    ) {
+      uid = mediaPlayerId;
+    }
     return (
       AgoraEnv.AgoraRendererManager?.setupLocalVideo({
         videoSourceType: sourceType,
@@ -568,7 +619,7 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     );
   }
 
-  setupRemoteVideo(canvas: VideoCanvas): number {
+  override setupRemoteVideo(canvas: VideoCanvas): number {
     const {
       sourceType = VideoSourceType.VideoSourceRemote,
       uid,
@@ -579,7 +630,8 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     return (
       AgoraEnv.AgoraRendererManager?.setupRemoteVideo({
         videoSourceType: sourceType,
-        channelId: '',
+        channelId:
+          AgoraEnv.AgoraRendererManager?.defaultRenderConfig?.channelId,
         uid,
         view,
         rendererOptions: {
@@ -590,7 +642,10 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     );
   }
 
-  setupRemoteVideoEx(canvas: VideoCanvas, connection: RtcConnection): number {
+  override setupRemoteVideoEx(
+    canvas: VideoCanvas,
+    connection: RtcConnection
+  ): number {
     const {
       sourceType = VideoSourceType.VideoSourceRemote,
       uid,
@@ -613,11 +668,79 @@ export class RtcEngineExInternal extends IRtcEngineExImpl {
     );
   }
 
-  destroyRendererByView(view: any) {
+  override setLocalRenderMode(
+    renderMode: RenderModeType,
+    mirrorMode: VideoMirrorModeType = VideoMirrorModeType.VideoMirrorModeAuto
+  ): number {
+    return (
+      AgoraEnv.AgoraRendererManager?.setRenderOptionByConfig({
+        videoSourceType: VideoSourceType.VideoSourceCamera,
+        channelId: '',
+        uid: 0,
+        rendererOptions: {
+          contentMode: renderMode,
+          mirror: mirrorMode === VideoMirrorModeType.VideoMirrorModeEnabled,
+        },
+      }) ?? -ErrorCodeType.ErrNotInitialized
+    );
+  }
+
+  override setRemoteRenderMode(
+    uid: number,
+    renderMode: RenderModeType,
+    mirrorMode: VideoMirrorModeType
+  ): number {
+    return (
+      AgoraEnv.AgoraRendererManager?.setRenderOptionByConfig({
+        videoSourceType: VideoSourceType.VideoSourceRemote,
+        channelId: AgoraEnv.AgoraRendererManager?.defaultRenderConfig.channelId,
+        uid,
+        rendererOptions: {
+          contentMode: renderMode,
+          mirror: mirrorMode === VideoMirrorModeType.VideoMirrorModeEnabled,
+        },
+      }) ?? -ErrorCodeType.ErrNotInitialized
+    );
+  }
+
+  override setRemoteRenderModeEx(
+    uid: number,
+    renderMode: RenderModeType,
+    mirrorMode: VideoMirrorModeType,
+    connection: RtcConnection
+  ): number {
+    const { channelId } = connection;
+    return (
+      AgoraEnv.AgoraRendererManager?.setRenderOptionByConfig({
+        videoSourceType: VideoSourceType.VideoSourceRemote,
+        channelId,
+        uid,
+        rendererOptions: {
+          contentMode: renderMode,
+          mirror: mirrorMode === VideoMirrorModeType.VideoMirrorModeEnabled,
+        },
+      }) ?? -ErrorCodeType.ErrNotInitialized
+    );
+  }
+
+  override setLocalVideoMirrorMode(mirrorMode: VideoMirrorModeType): number {
+    return (
+      AgoraEnv.AgoraRendererManager?.setRenderOptionByConfig({
+        videoSourceType: VideoSourceType.VideoSourceCamera,
+        channelId: '',
+        uid: 0,
+        rendererOptions: {
+          mirror: mirrorMode === VideoMirrorModeType.VideoMirrorModeEnabled,
+        },
+      }) ?? -ErrorCodeType.ErrNotInitialized
+    );
+  }
+
+  override destroyRendererByView(view: any) {
     AgoraEnv.AgoraRendererManager?.destroyRendererByView(view);
   }
 
-  destroyRendererByConfig(
+  override destroyRendererByConfig(
     videoSourceType: VideoSourceType,
     channelId?: Channel,
     uid?: number

package/ts/Private/ti/AgoraMediaBase-ti.ts

@@ -4,6 +4,10 @@
 import * as t from "ts-interface-checker";
 // tslint:disable:object-literal-key-quotes
 
+export const IAudioPcmFrameSink = t.iface([], {
+  "onFrame": t.opt(t.func("void", t.param("frame", "AudioPcmFrame"))),
+});
+
 export const IAudioFrameObserverBase = t.iface([], {
   "onRecordAudioFrame": t.opt(t.func("boolean", t.param("channelId", "string"), t.param("audioFrame", "AudioFrame"))),
   "onPlaybackAudioFrame": t.opt(t.func("boolean", t.param("channelId", "string"), t.param("audioFrame", "AudioFrame"))),
@@ -25,25 +29,20 @@ export const IVideoEncodedFrameObserver = t.iface([], {
 });
 
 export const IVideoFrameObserver = t.iface([], {
-  "onCaptureVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
-  "onPreEncodeVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
-  "onSecondaryCameraCaptureVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
-  "onSecondaryPreEncodeCameraVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
-  "onScreenCaptureVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
-  "onPreEncodeScreenVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
+  "onCaptureVideoFrame": t.opt(t.func("boolean", t.param("sourceType", "VideoSourceType"), t.param("videoFrame", "VideoFrame"))),
+  "onPreEncodeVideoFrame": t.opt(t.func("boolean", t.param("sourceType", "VideoSourceType"), t.param("videoFrame", "VideoFrame"))),
   "onMediaPlayerVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"), t.param("mediaPlayerId", "number"))),
-  "onSecondaryScreenCaptureVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
-  "onSecondaryPreEncodeScreenVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
   "onRenderVideoFrame": t.opt(t.func("boolean", t.param("channelId", "string"), t.param("remoteUid", "number"), t.param("videoFrame", "VideoFrame"))),
   "onTranscodedVideoFrame": t.opt(t.func("boolean", t.param("videoFrame", "VideoFrame"))),
 });
 
 export const IMediaRecorderObserver = t.iface([], {
-  "onRecorderStateChanged": t.opt(t.func("void", t.param("state", "RecorderState"), t.param("error", "RecorderErrorCode"))),
-  "onRecorderInfoUpdated": t.opt(t.func("void", t.param("info", "RecorderInfo"))),
+  "onRecorderStateChanged": t.opt(t.func("void", t.param("channelId", "string"), t.param("uid", "number"), t.param("state", "RecorderState"), t.param("error", "RecorderErrorCode"))),
+  "onRecorderInfoUpdated": t.opt(t.func("void", t.param("channelId", "string"), t.param("uid", "number"), t.param("info", "RecorderInfo"))),
 });
 
 const exportedTypeSuite: t.ITypeSuite = {
+  IAudioPcmFrameSink,
   IAudioFrameObserverBase,
   IAudioFrameObserver,
   IAudioSpectrumObserver,

package/ts/Private/ti/IAgoraMediaPlayer-ti.ts

@@ -4,16 +4,11 @@
 import * as t from "ts-interface-checker";
 // tslint:disable:object-literal-key-quotes
 
-export const IMediaPlayerAudioFrameObserver = t.iface([], {
-  "onFrame": t.opt(t.func("void", t.param("frame", "AudioPcmFrame"))),
-});
-
 export const IMediaPlayerVideoFrameObserver = t.iface([], {
   "onFrame": t.opt(t.func("void", t.param("frame", "VideoFrame"))),
 });
 
 const exportedTypeSuite: t.ITypeSuite = {
-  IMediaPlayerAudioFrameObserver,
   IMediaPlayerVideoFrameObserver,
 };
 export default exportedTypeSuite;

package/{js/Private/ti/AgoraMediaPlayerTypes-ti.d.ts → ts/Private/ti/IAgoraMediaStreamingSource-ti.ts}

@@ -1,6 +1,11 @@
-/**
- * This module was automatically generated by `ts-interface-builder`
- */
-import * as t from "ts-interface-checker";
-declare const exportedTypeSuite: t.ITypeSuite;
-export default exportedTypeSuite;
+/**
+ * This module was automatically generated by `ts-interface-builder`
+ */
+import * as t from "ts-interface-checker";
+// tslint:disable:object-literal-key-quotes
+
+
+
+const exportedTypeSuite: t.ITypeSuite = {
+};
+export default exportedTypeSuite;

package/ts/Private/ti/IAgoraMusicContentCenter-ti.ts

@@ -5,10 +5,10 @@ import * as t from "ts-interface-checker";
 // tslint:disable:object-literal-key-quotes
 
 export const IMusicContentCenterEventHandler = t.iface([], {
-  "onMusicChartsResult": t.opt(t.func("void", t.param("requestId", "string"), t.param("status", "MusicContentCenterStatusCode"), t.param("result", t.array("MusicChartInfo")))),
-  "onMusicCollectionResult": t.opt(t.func("void", t.param("requestId", "string"), t.param("status", "MusicContentCenterStatusCode"), t.param("result", "MusicCollection"))),
-  "onLyricResult": t.opt(t.func("void", t.param("requestId", "string"), t.param("lyricUrl", "string"))),
-  "onPreLoadEvent": t.opt(t.func("void", t.param("songCode", "number"), t.param("percent", "number"), t.param("status", "PreloadStatusCode"), t.param("msg", "string"), t.param("lyricUrl", "string", true))),
+  "onMusicChartsResult": t.opt(t.func("void", t.param("requestId", "string"), t.param("result", t.array("MusicChartInfo")), t.param("errorCode", "MusicContentCenterStatusCode"))),
+  "onMusicCollectionResult": t.opt(t.func("void", t.param("requestId", "string"), t.param("result", "MusicCollection"), t.param("errorCode", "MusicContentCenterStatusCode"))),
+  "onLyricResult": t.opt(t.func("void", t.param("requestId", "string"), t.param("lyricUrl", "string"), t.param("errorCode", "MusicContentCenterStatusCode"))),
+  "onPreLoadEvent": t.opt(t.func("void", t.param("songCode", "number"), t.param("percent", "number"), t.param("lyricUrl", "string"), t.param("status", "PreloadStatusCode"), t.param("errorCode", "MusicContentCenterStatusCode"))),
 });
 
 const exportedTypeSuite: t.ITypeSuite = {