shengwang-electron-sdk 4.6.2-rc.1

package/ts/Private/internal/RtcEngineExInternal.ts

@@ -0,0 +1,720 @@
+import { createCheckers } from 'ts-interface-checker';
+
+import { AgoraElectronBridge } from '../../Private/internal/IrisApiEngine';
+import { AgoraEnv, logDebug, logError, parseIntPtr2Number } from '../../Utils';
+let RendererManager: any;
+let CapabilityManager: any;
+//@ts-ignore
+if (process.type === 'renderer') {
+  RendererManager = require('../../Renderer/RendererManager').RendererManager;
+  CapabilityManager =
+    require('../../Renderer/CapabilityManager').CapabilityManager;
+} else {
+  RendererManager = undefined;
+  CapabilityManager = undefined;
+}
+import {
+  AudioEncodedFrameObserverConfig,
+  ClientRoleOptions,
+  ClientRoleType,
+  ErrorCodeType,
+  IAudioEncodedFrameObserver,
+  RecorderStreamInfo,
+  SimulcastStreamConfig,
+  SimulcastStreamMode,
+  VideoCanvas,
+  VideoMirrorModeType,
+} from '../AgoraBase';
+import {
+  IAudioSpectrumObserver,
+  RenderModeType,
+  VideoSourceType,
+} from '../AgoraMediaBase';
+import { IH265Transcoder } from '../IAgoraH265Transcoder';
+import { IMediaEngine } from '../IAgoraMediaEngine';
+import { IMediaPlayer } from '../IAgoraMediaPlayer';
+import { IMediaRecorder } from '../IAgoraMediaRecorder';
+import { IMusicContentCenter } from '../IAgoraMusicContentCenter';
+import {
+  ChannelMediaOptions,
+  DirectCdnStreamingMediaOptions,
+  IDirectCdnStreamingEventHandler,
+  IMetadataObserver,
+  IRtcEngineEventHandler,
+  IVideoDeviceManager,
+  LeaveChannelOptions,
+  MetadataType,
+  RtcEngineContext,
+  SDKBuildInfo,
+  ScreenCaptureSourceInfo,
+  Size,
+} from '../IAgoraRtcEngine';
+import { RtcConnection } from '../IAgoraRtcEngineEx';
+import { ILocalSpatialAudioEngine } from '../IAgoraSpatialAudio';
+import { IAudioDeviceManager } from '../IAudioDeviceManager';
+import { IRtcEngineEvent } from '../extension/IAgoraRtcEngineExtension';
+import { IRtcEngineExImpl } from '../impl/IAgoraRtcEngineExImpl';
+import { IVideoDeviceManagerImpl } from '../impl/IAgoraRtcEngineImpl';
+import AgoraBaseTI from '../ti/AgoraBase-ti';
+import AgoraMediaBaseTI from '../ti/AgoraMediaBase-ti';
+import IAgoraRtcEngineTI from '../ti/IAgoraRtcEngine-ti';
+
+import { H265TranscoderInternal } from './AgoraH265TranscoderInternal';
+import { AudioDeviceManagerInternal } from './AudioDeviceManagerInternal';
+import {
+  DeviceEventEmitter,
+  EVENT_TYPE,
+  EventProcessor,
+  callIrisApi,
+} from './IrisApiEngine';
+import { LocalSpatialAudioEngineInternal } from './LocalSpatialAudioEngineInternal';
+import { MediaEngineInternal } from './MediaEngineInternal';
+import { MediaPlayerInternal } from './MediaPlayerInternal';
+import { MediaRecorderInternal } from './MediaRecorderInternal';
+import { MusicContentCenterInternal } from './MusicContentCenterInternal';
+
+const checkers = createCheckers(
+  AgoraBaseTI,
+  AgoraMediaBaseTI,
+  IAgoraRtcEngineTI
+);
+
+interface PerformanceCounter {
+  counters: {
+    counterId: number;
+    value: number;
+  }[];
+  uid: number;
+}
+
+export class RtcEngineExInternal extends IRtcEngineExImpl {
+  static _event_handlers: IRtcEngineEventHandler[] = [];
+  static _direct_cdn_streaming_event_handler: IDirectCdnStreamingEventHandler[] =
+    [];
+  static _metadata_observer: IMetadataObserver[] = [];
+  static _audio_encoded_frame_observers: IAudioEncodedFrameObserver[] = [];
+  static _audio_spectrum_observers: IAudioSpectrumObserver[] = [];
+  private _audio_device_manager: IAudioDeviceManager =
+    new AudioDeviceManagerInternal();
+  private _video_device_manager: IVideoDeviceManager =
+    new IVideoDeviceManagerImpl();
+  private _media_engine: IMediaEngine = new MediaEngineInternal();
+  private _music_content_center: IMusicContentCenter =
+    new MusicContentCenterInternal();
+  private _local_spatial_audio_engine: ILocalSpatialAudioEngine =
+    new LocalSpatialAudioEngineInternal();
+  private _h265_transcoder: IH265Transcoder = new H265TranscoderInternal();
+
+  private performanceInterval: number = 6000;
+  private performanceIntervalFunc: any;
+  private VideoRemoteRenderMeanFpsCounterId: number = 537;
+  private VideoRemoteRenderDrawCostCounterId: number = 576;
+  private VideoLocalRenderMeanFpsCounterId: number = 526;
+  private VideoLocalRenderDrawCostCounterId: number = 577;
+
+  override initialize(context: RtcEngineContext): number {
+    const ret = super.initialize(context);
+    callIrisApi.call(this, 'RtcEngine_setAppType', {
+      appType: 3,
+    });
+    if (AgoraEnv.webEnvReady) {
+      // @ts-ignore
+      window.AgoraEnv = AgoraEnv;
+      if (AgoraEnv.AgoraRendererManager === undefined && RendererManager) {
+        AgoraEnv.AgoraRendererManager = new RendererManager();
+      }
+      if (AgoraEnv.CapabilityManager === undefined && CapabilityManager) {
+        AgoraEnv.CapabilityManager = new CapabilityManager();
+      }
+      if (AgoraEnv.enableArgusCounters) {
+        try {
+          this.performanceIntervalFunc = setInterval(() => {
+            let rendererManager = AgoraEnv.AgoraRendererManager;
+            let counters: {
+              data: PerformanceCounter[];
+              connection: RtcConnection;
+            }[] = [];
+            if (rendererManager) {
+              rendererManager.getRendererCaches().forEach((cache) => {
+                const isRemote =
+                  cache.callbackContext.sourceType ===
+                  VideoSourceType.VideoSourceRemote;
+                if (
+                  cache.callbackContext.connection?.channelId &&
+                  (cache.callbackContext.connection?.localUid || isRemote)
+                ) {
+                  let counter = counters.find(
+                    (counter) =>
+                      counter.connection.channelId ===
+                        cache.callbackContext.connection.channelId &&
+                      counter.connection.localUid ===
+                        cache.callbackContext.connection.localUid
+                  );
+                  let data: PerformanceCounter = {
+                    counters: [
+                      {
+                        counterId: isRemote
+                          ? this.VideoRemoteRenderMeanFpsCounterId
+                          : this.VideoLocalRenderMeanFpsCounterId,
+                        value: Math.floor(cache.actualFps),
+                      },
+                      {
+                        counterId: isRemote
+                          ? this.VideoRemoteRenderDrawCostCounterId
+                          : this.VideoLocalRenderDrawCostCounterId,
+                        value: Math.floor(cache.avgFrameInterval),
+                      },
+                    ],
+                    uid: isRemote ? cache.cacheContext.uid! : 0,
+                  };
+                  if (!counter) {
+                    counters.push({
+                      data: [data],
+                      connection: cache.callbackContext.connection,
+                    });
+                  } else {
+                    counter.data.push(data);
+                  }
+                }
+              });
+            }
+            counters.forEach((counter) => {
+              this.setParameters(
+                JSON.stringify({ 'rtc.report.argus_counters': counter })
+              );
+            });
+          }, this.performanceInterval);
+        } catch (error) {
+          logDebug('argus counters report error', error);
+        }
+      }
+    }
+    return ret;
+  }
+
+  override release(sync: boolean = false) {
+    AgoraElectronBridge.ReleaseRenderer();
+    AgoraEnv.AgoraRendererManager?.release();
+    AgoraEnv.AgoraRendererManager = undefined;
+    this._media_engine.release();
+    this._local_spatial_audio_engine.release();
+    RtcEngineExInternal._event_handlers = [];
+    RtcEngineExInternal._event_handlers.map((it) => {
+      super.unregisterEventHandler(it);
+    });
+    RtcEngineExInternal._direct_cdn_streaming_event_handler = [];
+    RtcEngineExInternal._metadata_observer = [];
+    RtcEngineExInternal._audio_encoded_frame_observers = [];
+    RtcEngineExInternal._audio_spectrum_observers = [];
+    MediaPlayerInternal._source_observers.clear();
+    MediaPlayerInternal._audio_frame_observers.clear();
+    MediaPlayerInternal._video_frame_observers.clear();
+    MediaPlayerInternal._audio_spectrum_observers.clear();
+    MediaRecorderInternal._observers.clear();
+    this._h265_transcoder.release();
+    this.removeAllListeners();
+    AgoraEnv.CapabilityManager?.release();
+    AgoraEnv.CapabilityManager = undefined;
+    if (this.performanceIntervalFunc) {
+      clearInterval(this.performanceIntervalFunc);
+      this.performanceIntervalFunc = undefined;
+    }
+    super.release(sync);
+  }
+
+  _addListenerPreCheck<EventType extends keyof IRtcEngineEvent>(
+    eventType: EventType
+  ): boolean {
+    if (
+      checkers.IRtcEngineEventHandler?.strictTest({ [eventType]: undefined })
+    ) {
+      if (RtcEngineExInternal._event_handlers.length === 0) {
+        this.registerEventHandler({});
+      }
+    }
+    if (
+      checkers.IDirectCdnStreamingEventHandler?.strictTest({
+        [eventType]: undefined,
+      })
+    ) {
+      if (
+        RtcEngineExInternal._direct_cdn_streaming_event_handler.length === 0
+      ) {
+        logError(
+          'Please call `startDirectCdnStreaming` before you want to receive event by `addListener`'
+        );
+        return false;
+      }
+    }
+    if (
+      checkers.IMetadataObserver?.strictTest({
+        [eventType]: undefined,
+      })
+    ) {
+      if (RtcEngineExInternal._metadata_observer.length === 0) {
+        logError(
+          'Please call `registerMediaMetadataObserver` before you want to receive event by `addListener`'
+        );
+        return false;
+      }
+    }
+    if (
+      checkers.IAudioEncodedFrameObserver?.strictTest({
+        [eventType]: undefined,
+      })
+    ) {
+      if (RtcEngineExInternal._audio_encoded_frame_observers.length === 0) {
+        logError(
+          'Please call `registerAudioEncodedFrameObserver` before you want to receive event by `addListener`'
+        );
+        return false;
+      }
+    }
+    if (
+      checkers.IAudioSpectrumObserver?.strictTest({
+        [eventType]: undefined,
+      })
+    ) {
+      if (RtcEngineExInternal._audio_spectrum_observers.length === 0) {
+        this.registerAudioSpectrumObserver({});
+      }
+    }
+    return true;
+  }
+
+  addListener<EventType extends keyof IRtcEngineEvent>(
+    eventType: EventType,
+    listener: IRtcEngineEvent[EventType]
+  ) {
+    this._addListenerPreCheck(eventType);
+    const callback = (eventProcessor: EventProcessor<any>, data: any) => {
+      if (eventProcessor.type(data) !== EVENT_TYPE.IRtcEngine) {
+        return;
+      }
+      eventProcessor.func.map((it) => {
+        it({ [eventType]: listener }, eventType, data);
+      });
+    };
+    // @ts-ignore
+    listener!.agoraCallback = callback;
+    DeviceEventEmitter.addListener(eventType, callback);
+  }
+
+  removeListener<EventType extends keyof IRtcEngineEvent>(
+    eventType: EventType,
+    listener?: IRtcEngineEvent[EventType]
+  ) {
+    DeviceEventEmitter.removeListener(
+      eventType,
+      // @ts-ignore
+      listener?.agoraCallback ?? listener
+    );
+  }
+
+  removeAllListeners<EventType extends keyof IRtcEngineEvent>(
+    eventType?: EventType
+  ) {
+    DeviceEventEmitter.removeAllListeners(eventType);
+  }
+
+  override getVersion(): SDKBuildInfo {
+    const apiType = 'RtcEngine_getVersion_915cb25';
+    const jsonParams = {};
+    const jsonResults = callIrisApi.call(this, apiType, jsonParams);
+    return {
+      build: jsonResults.build,
+      version: jsonResults.result,
+    };
+  }
+
+  override registerEventHandler(eventHandler: IRtcEngineEventHandler): boolean {
+    // only call iris when no event handler registered
+    let callIris = RtcEngineExInternal._event_handlers.length === 0;
+    if (
+      !RtcEngineExInternal._event_handlers.find(
+        (value) => value === eventHandler
+      )
+    ) {
+      RtcEngineExInternal._event_handlers.push(eventHandler);
+    }
+    return callIris ? super.registerEventHandler(eventHandler) : true;
+  }
+
+  override unregisterEventHandler(
+    eventHandler: IRtcEngineEventHandler
+  ): boolean {
+    RtcEngineExInternal._event_handlers =
+      RtcEngineExInternal._event_handlers.filter(
+        (value) => value !== eventHandler
+      );
+    // only call iris when no event handler registered
+    let callIris = RtcEngineExInternal._event_handlers.length === 0;
+    return callIris ? super.unregisterEventHandler(eventHandler) : true;
+  }
+
+  override createMediaPlayer(): IMediaPlayer {
+    // @ts-ignore
+    const mediaPlayerId = super.createMediaPlayer() as number;
+    return new MediaPlayerInternal(mediaPlayerId);
+  }
+
+  override destroyMediaPlayer(mediaPlayer: IMediaPlayer): number {
+    const ret = super.destroyMediaPlayer(mediaPlayer);
+    mediaPlayer.release?.call(mediaPlayer);
+    return ret;
+  }
+
+  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
+  ): number {
+    if (
+      !RtcEngineExInternal._direct_cdn_streaming_event_handler.find(
+        (value) => value === eventHandler
+      )
+    ) {
+      RtcEngineExInternal._direct_cdn_streaming_event_handler.push(
+        eventHandler
+      );
+    }
+    return super.startDirectCdnStreaming(eventHandler, publishUrl, options);
+  }
+
+  override registerMediaMetadataObserver(
+    observer: IMetadataObserver,
+    type: MetadataType
+  ): number {
+    if (
+      !RtcEngineExInternal._metadata_observer.find(
+        (value) => value === observer
+      )
+    ) {
+      RtcEngineExInternal._metadata_observer.push(observer);
+    }
+    return super.registerMediaMetadataObserver(observer, type);
+  }
+
+  override unregisterMediaMetadataObserver(
+    observer: IMetadataObserver,
+    type: MetadataType
+  ): number {
+    RtcEngineExInternal._metadata_observer =
+      RtcEngineExInternal._metadata_observer.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterMediaMetadataObserver(observer, type);
+  }
+
+  protected override getApiTypeFromJoinChannel(
+    token: string,
+    channelId: string,
+    uid: number,
+    options: ChannelMediaOptions
+  ): string {
+    if (AgoraEnv.AgoraRendererManager) {
+      AgoraEnv.AgoraRendererManager.defaultChannelId = channelId;
+    }
+    return options === undefined
+      ? 'RtcEngine_joinChannel_f097389'
+      : 'RtcEngine_joinChannel_cdbb747';
+  }
+
+  protected override getApiTypeFromLeaveChannel(
+    options?: LeaveChannelOptions
+  ): string {
+    return options === undefined
+      ? 'RtcEngine_leaveChannel'
+      : 'RtcEngine_leaveChannel_2c0e3aa';
+  }
+
+  protected override getApiTypeFromLeaveChannelEx(
+    connection: RtcConnection,
+    options?: LeaveChannelOptions
+  ): string {
+    return options === undefined
+      ? 'RtcEngineEx_leaveChannelEx_c81e1a4'
+      : 'RtcEngineEx_leaveChannelEx_b03ee9a';
+  }
+
+  protected override getApiTypeFromSetClientRole(
+    role: ClientRoleType,
+    options?: ClientRoleOptions
+  ): string {
+    return options === undefined
+      ? 'RtcEngine_setClientRole_3426fa6'
+      : 'RtcEngine_setClientRole_b46cc48';
+  }
+
+  protected override getApiTypeFromEnableDualStreamMode(
+    enabled: boolean,
+    streamConfig?: SimulcastStreamConfig
+  ): string {
+    return streamConfig === undefined
+      ? 'RtcEngine_enableDualStreamMode_5039d15'
+      : 'RtcEngine_enableDualStreamMode_9822d8a';
+  }
+
+  protected override getApiTypeFromSetDualStreamMode(
+    mode: SimulcastStreamMode,
+    streamConfig?: SimulcastStreamConfig
+  ): string {
+    return streamConfig === undefined
+      ? 'RtcEngine_setDualStreamMode_3a7f662'
+      : 'RtcEngine_setDualStreamMode_b3a4f6c';
+  }
+
+  protected override getApiTypeFromJoinChannelWithUserAccount(
+    token: string,
+    channelId: string,
+    userAccount: string,
+    options?: ChannelMediaOptions
+  ): string {
+    if (AgoraEnv.AgoraRendererManager) {
+      AgoraEnv.AgoraRendererManager.defaultChannelId = channelId;
+    }
+    return options === undefined
+      ? 'RtcEngine_joinChannelWithUserAccount_0e4f59e'
+      : 'RtcEngine_joinChannelWithUserAccount_4685af9';
+  }
+
+  override getAudioDeviceManager(): IAudioDeviceManager {
+    return this._audio_device_manager;
+  }
+
+  override getVideoDeviceManager(): IVideoDeviceManager {
+    return this._video_device_manager;
+  }
+
+  override getMediaEngine(): IMediaEngine {
+    return this._media_engine;
+  }
+
+  override getMusicContentCenter(): IMusicContentCenter {
+    return this._music_content_center;
+  }
+
+  override getLocalSpatialAudioEngine(): ILocalSpatialAudioEngine {
+    return this._local_spatial_audio_engine;
+  }
+
+  override getH265Transcoder(): IH265Transcoder {
+    return this._h265_transcoder;
+  }
+
+  override getNativeHandle(): number {
+    let result = super.getNativeHandle();
+    return parseIntPtr2Number(result);
+  }
+
+  override registerAudioEncodedFrameObserver(
+    config: AudioEncodedFrameObserverConfig,
+    observer: IAudioEncodedFrameObserver
+  ): number {
+    if (
+      !RtcEngineExInternal._audio_encoded_frame_observers.find(
+        (value) => value === observer
+      )
+    ) {
+      RtcEngineExInternal._audio_encoded_frame_observers.push(observer);
+    }
+    return super.registerAudioEncodedFrameObserver(config, observer);
+  }
+
+  override unregisterAudioEncodedFrameObserver(
+    observer: IAudioEncodedFrameObserver
+  ): number {
+    RtcEngineExInternal._audio_encoded_frame_observers =
+      RtcEngineExInternal._audio_encoded_frame_observers.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterAudioEncodedFrameObserver(observer);
+  }
+
+  override registerAudioSpectrumObserver(
+    observer: IAudioSpectrumObserver
+  ): number {
+    if (
+      !RtcEngineExInternal._audio_spectrum_observers.find(
+        (value) => value === observer
+      )
+    ) {
+      RtcEngineExInternal._audio_spectrum_observers.push(observer);
+    }
+    return super.registerAudioSpectrumObserver(observer);
+  }
+
+  override unregisterAudioSpectrumObserver(
+    observer: IAudioSpectrumObserver
+  ): number {
+    RtcEngineExInternal._audio_spectrum_observers =
+      RtcEngineExInternal._audio_spectrum_observers.filter(
+        (value) => value !== observer
+      );
+    return super.unregisterAudioSpectrumObserver(observer);
+  }
+
+  override getScreenCaptureSources(
+    thumbSize: Size,
+    iconSize: Size,
+    includeScreen: boolean
+  ): ScreenCaptureSourceInfo[] {
+    const apiType = this.getApiTypeFromGetScreenCaptureSources(
+      thumbSize,
+      iconSize,
+      includeScreen
+    );
+    const jsonParams = {
+      thumbSize: thumbSize,
+      iconSize: iconSize,
+      includeScreen: includeScreen,
+      toJSON: () => {
+        return {
+          thumbSize: thumbSize,
+          iconSize: iconSize,
+          includeScreen: includeScreen,
+        };
+      },
+    };
+    const { result, sources } = callIrisApi.call(this, apiType, jsonParams);
+    const screenCaptureSources = result.map(
+      (value: ScreenCaptureSourceInfo) => {
+        if (!value.thumbImage?.buffer || !value.thumbImage?.length) {
+          value.thumbImage!.buffer = undefined;
+        } else {
+          value.thumbImage!.buffer = AgoraElectronBridge.GetBuffer(
+            value.thumbImage!.buffer as unknown as number,
+            value.thumbImage.length!
+          );
+        }
+        if (!value.iconImage?.buffer || !value.iconImage?.length) {
+          value.iconImage!.buffer = undefined;
+        } else {
+          value.iconImage.buffer = AgoraElectronBridge.GetBuffer(
+            value.iconImage!.buffer as unknown as number,
+            value.iconImage.length!
+          );
+        }
+        value.sourceDisplayId = parseIntPtr2Number(value.sourceDisplayId!);
+        return value;
+      }
+    );
+    callIrisApi.call(this, 'RtcEngine_releaseScreenCaptureSources', {
+      sources,
+    });
+    return screenCaptureSources;
+  }
+
+  override setupLocalVideo(canvas: VideoCanvas): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const renderer = AgoraEnv.AgoraRendererManager.addOrRemoveRenderer(canvas);
+    if (!renderer) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setupRemoteVideo(canvas: VideoCanvas): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const renderer = AgoraEnv.AgoraRendererManager.addOrRemoveRenderer(canvas);
+    if (!renderer) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setupRemoteVideoEx(
+    canvas: VideoCanvas,
+    connection: RtcConnection
+  ): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const renderer = AgoraEnv.AgoraRendererManager.addOrRemoveRenderer({
+      ...canvas,
+      ...connection,
+    });
+    if (!renderer) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setLocalRenderMode(
+    renderMode: RenderModeType,
+    mirrorMode: VideoMirrorModeType = VideoMirrorModeType.VideoMirrorModeAuto
+  ): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const result = AgoraEnv.AgoraRendererManager.setRendererContext({
+      sourceType: VideoSourceType.VideoSourceCamera,
+      renderMode,
+      mirrorMode,
+    });
+    if (!result) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setRemoteRenderMode(
+    uid: number,
+    renderMode: RenderModeType,
+    mirrorMode: VideoMirrorModeType
+  ): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const result = AgoraEnv.AgoraRendererManager.setRendererContext({
+      sourceType: VideoSourceType.VideoSourceRemote,
+      uid,
+      renderMode,
+      mirrorMode,
+    });
+    if (!result) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setRemoteRenderModeEx(
+    uid: number,
+    renderMode: RenderModeType,
+    mirrorMode: VideoMirrorModeType,
+    connection: RtcConnection
+  ): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const result = AgoraEnv.AgoraRendererManager.setRendererContext({
+      sourceType: VideoSourceType.VideoSourceRemote,
+      ...connection,
+      uid,
+      renderMode,
+      mirrorMode,
+    });
+    if (!result) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override setLocalVideoMirrorMode(mirrorMode: VideoMirrorModeType): number {
+    if (!AgoraEnv.AgoraRendererManager) return -ErrorCodeType.ErrNotInitialized;
+    const result = AgoraEnv.AgoraRendererManager.setRendererContext({
+      sourceType: VideoSourceType.VideoSourceCamera,
+      mirrorMode,
+    });
+    if (!result) return -ErrorCodeType.ErrFailed;
+    return ErrorCodeType.ErrOk;
+  }
+
+  override destroyRendererByView(view: Element) {
+    AgoraEnv.AgoraRendererManager?.removeRendererFromCache({ view });
+  }
+
+  override destroyRendererByConfig(
+    sourceType: VideoSourceType,
+    channelId?: string,
+    uid?: number
+  ) {
+    AgoraEnv.AgoraRendererManager?.removeRendererFromCache({
+      sourceType,
+      channelId,
+      uid,
+    });
+  }
+}