agora-rte-sdk 2.8.21 → 2.8.40

package/lib/core/processor/type.d.ts

@@ -0,0 +1,200 @@
+import Immutable from 'immutable';
+import { AgoraRteAudioSourceType, AgoraRteMediaPublishState, AgoraRteVideoSourceType } from '../media/track';
+import { AgoraRteMediaSourceState } from '../rtc/type';
+export declare type AgoraFromUser = {
+    userUuid: string;
+    userName: string;
+    role: string;
+};
+export declare type MessageExt = {
+    range: number;
+    userName: string;
+    userUuid: string;
+};
+export interface IAgoraUserData {
+    userName: string;
+    role: string;
+    userUuid: string;
+    userProperties: any;
+}
+export declare class AgoraUser {
+    static fromData(data: any): AgoraUser;
+    userUuid: string;
+    userName: string;
+    userRole: string;
+    userProperties: Immutable.Map<any, any>;
+    constructor(data: IAgoraUserData);
+    setUserProperties(userProperties: any): void;
+    toString(): string;
+}
+export interface IAgoraStreamData {
+    streamUuid: string;
+    streamName: string;
+    fromUser: AgoraFromUser;
+    videoSourceType: AgoraRteVideoSourceType;
+    audioSourceType: AgoraRteAudioSourceType;
+    videoState: AgoraRteMediaPublishState;
+    audioState: AgoraRteMediaPublishState;
+    videoSourceState: AgoraRteMediaSourceState;
+    audioSourceState: AgoraRteMediaSourceState;
+    playUrl?: string;
+    flvPlayUrl?: string;
+    rtmpPlayUrl?: string;
+}
+export declare class AgoraStream {
+    static fromData(data: IAgoraStreamData): AgoraStream;
+    streamUuid: string;
+    streamName: string;
+    fromUser: AgoraFromUser;
+    videoSourceType: AgoraRteVideoSourceType;
+    audioSourceType: AgoraRteAudioSourceType;
+    videoState: AgoraRteMediaPublishState;
+    audioState: AgoraRteMediaPublishState;
+    videoSourceState: AgoraRteMediaSourceState;
+    audioSourceState: AgoraRteMediaSourceState;
+    playUrl?: string;
+    flvPlayUrl?: string;
+    rtmpPlayUrl?: string;
+    previous?: AgoraStream;
+    constructor(data: IAgoraStreamData);
+    toString(): string;
+}
+export interface IAgoraRoomStateData {
+    total: number;
+}
+export interface IAgoraRoomData {
+    roomName: string;
+    roomUuid: string;
+    roomScenario: string;
+}
+export declare class AgoraRoom {
+    static fromData(data: any): AgoraRoom;
+    roomName: string;
+    roomUuid: string;
+    roomScenario: string;
+    constructor(data: IAgoraRoomData);
+}
+export declare class AgoraRoomState {
+    static fromData(data: IAgoraRoomStateData): AgoraRoomState;
+    total: number;
+    constructor(data: IAgoraRoomStateData);
+}
+export interface IAgoraChatMessage {
+    fromUser: AgoraFromUser;
+    message: string;
+    type: number;
+    sendTime: number;
+    sensitiveWords: string[];
+    messageId?: string;
+    peerMessageId?: string;
+    ext?: MessageExt;
+}
+export declare class AgoraChatMessage {
+    static fromData(data: IAgoraChatMessage): AgoraChatMessage;
+    fromUser: AgoraFromUser;
+    message: string;
+    type: number;
+    sendTime: number;
+    sensitiveWords: string[];
+    messageId?: string;
+    ext?: MessageExt;
+    constructor(data: IAgoraChatMessage);
+    toString(): string;
+}
+export interface AgoraRteOperator {
+    userUuid: string;
+    userName: string;
+    role: string;
+}
+export interface AgoraRteMessageBatch {
+    id: number;
+    total: number;
+    progress: number;
+}
+export interface AgoraRteMessageBatchDetail {
+    cause: {
+        cmd: number;
+    };
+    operator: AgoraRteOperator;
+    version: number;
+    sequence: number;
+    ts: number;
+}
+export interface AgoraRteSequenceMessage {
+    cmd: number;
+    operator: AgoraRteOperator;
+    sequence: number;
+    data: any;
+    timestamp: number;
+    batch?: AgoraRteMessageBatch;
+    list?: AgoraRteMessageBatchDetail[];
+}
+export interface AgoraRteMessagePacket {
+    total: number;
+    startSequence: number;
+    list: AgoraRteSequenceMessage[];
+}
+export interface AgoraRteMessageHandle {
+    on(evt: AgoraRteEventType, ...args: any[]): this;
+    off(evt: AgoraRteEventType, ...args: any[]): this;
+    handleSnapshot(snapshot: AgoraRteSyncSnapshotData): void;
+    handleSeqMessage(message: AgoraRteSequenceMessage): void;
+    handleNonSeqMessage(message: unknown): void;
+}
+export declare class AgoraRteSyncSnapshotData {
+    static fromData(data: any): AgoraRteSyncSnapshotData;
+    sequence: number;
+    users: Map<string, AgoraUser>;
+    streams: Map<string, AgoraStream>;
+    roomProperties: Immutable.Map<unknown, unknown>;
+    room: AgoraRoom;
+    roomState: AgoraRoomState;
+    constructor(data: any);
+}
+export declare enum AgoraRteChannelMessageCmd {
+    Chat = 3,
+    RoomProperty = 4,
+    RoomProperties = 5,
+    UserInOut = 20,
+    UserInfo = 21,
+    UserProperty = 22,
+    UserProperties = 23,
+    UserSubscribeInOut = 24,
+    StreamInOut = 40,
+    StreamsInOut = 41,
+    MessageExtension = 99
+}
+export declare enum AgoraRtePeerMessageCmd {
+    PeerChat = 1
+}
+export declare enum AgoraRteEventType {
+    SnapshotUpdated = "snapshot-updated",
+    ChatReceived = "chat-received",
+    UserAdded = "user-added",
+    UserUpdated = "user-updated",
+    UserRemoved = "user-removed",
+    UserCountUpdated = "user-count-updated",
+    RoomPropertyUpdated = "room-property-updated",
+    UserPropertyUpdated = "user-property-updated",
+    LocalStreamAdded = "local-stream-added",
+    LocalStreamUpdate = "local-stream-update",
+    LocalStreamRemove = "local-stream-removed",
+    RemoteStreamAdded = "remote-stream-added",
+    RemoteStreamUpdate = "remote-stream-update",
+    RemoteStreamRemove = "remote-stream-removed",
+    ChatUserMessage = "user-chat-message",
+    ChatRoomMessage = "room-chat-message",
+    NetworkStats = "network-stats",
+    LocalAudioVolume = "local-audio-volume",
+    AudioVolumes = "audio-volumes",
+    LocalVideoCameraListChanged = "local-video-camera-list-changed",
+    LocalAudioRecordingListChanged = "local-audio-recording-list-changed",
+    LocalAudioPlaybackListChanged = "local-audio-playback-list-changed",
+    LocalVideoTrackStateChanged = "local-video-track-state-changed",
+    LocalAudioTrackStateChanged = "local-audio-track-state-changed",
+    RtcConnectionStateChanged = "rtc-connection-state-changed",
+    RtmConnectionStateChanged = "rtm-connection-state-changed",
+    RteConnectionStateChanged = "rte-connection-state-changed",
+    TimeStampGapUpdate = "timestamp-gap-update",
+    UserPropertyListUpdated = "user-property-list-updated"
+}

package/lib/core/rc/index.js

@@ -597,8 +597,12 @@ var AgoraRemoteControlContext = (_dec = _decorator.Log.attach({
     key: "cleanup",
     value: function cleanup() {
       AgoraRemoteControlContext._channelUsers.clear();
-      _electron.RtcAdapterElectron.rtcEngine.off('userJoined', AgoraRemoteControlContext.handleRTCUserJoined);
-      _electron.RtcAdapterElectron.rtcEngine.off('removeStream', AgoraRemoteControlContext.handleRTCUserLeft);
+      if (_electron.RtcAdapterElectron.rtcEngine) {
+        _electron.RtcAdapterElectron.rtcEngine.off('userJoined', AgoraRemoteControlContext.handleRTCUserJoined);
+      }
+      if (_electron.RtcAdapterElectron.rtcEngine) {
+        _electron.RtcAdapterElectron.rtcEngine.off('removeStream', AgoraRemoteControlContext.handleRTCUserLeft);
+      }
     }
   }]);
   return AgoraRemoteControlContext;

package/lib/core/rtc/adapter/base.d.ts

@@ -1,11 +1,11 @@
-import { RemoteStreamType } from 'agora-rtc-sdk-ng';
 import { AgoraLatencyLevel } from '../../../configs';
 import { AgoraRteAudioSourceType, AgoraRteVideoSourceType } from '../../media/track';
 import { AGEventEmitter } from '../../utils/events';
 import { AgoraRtcVideoCanvas } from '../canvas';
 import { AGRtcConnectionType } from '../channel';
 import { IBaseProcessor } from 'agora-rte-extension';
-import { AgoraRteMediaSourceState, AGRtcDeviceInfo, AGScreenShareDevice, AGScreenShareType, AGBeautyEffect, AGAudioRawDataConfig, AGSnapshotInfo, AGNetworkStats, AGRtcState, AGLowStreamParameter } from '../type';
+import { AgoraRteMediaSourceState, AGRtcDeviceInfo, AGScreenShareDevice, AGScreenShareType, AGBeautyEffect, AGSnapshotInfo, AGNetworkStats, AGRtcState, AGLowStreamParameter, AGRemoteVideoStreamType } from '../type';
+import { AgoraRteAudioRawDataConfig, AgoraRteAudioRawDataObserver, AgoraRteAudioRawDataPosition } from '../../media/type';
 export declare type LocalVideoTrackStateEvent = (state: AgoraRteMediaSourceState, type: AgoraRteVideoSourceType) => void;
 export declare type LocalAudioTrackStateEvent = (state: AgoraRteMediaSourceState, type: AgoraRteAudioSourceType) => void;
 export declare type LocalCameraDeviceListEvent = (addNewDevice: boolean, newDevices: AGRtcDeviceInfo[], allDevices: AGRtcDeviceInfo[]) => void;
@@ -25,7 +25,6 @@ export declare abstract class RtcAudioDeviceManagerBase extends AGEventEmitter {
     abstract onLocalAudioTrackStateChanged(cb: LocalAudioTrackStateEvent): number;
     abstract onLocalAudioVolume(cb: (volume: number) => void): number;
     abstract onLocalAudioPlaybackTestVolumeChanged(cb: LocalAudioPlaybackVolumeIndicatorEvent): number;
-    abstract onAudioFrame(cb: (buffer: ArrayBuffer) => void): number;
 }
 export declare abstract class RtcChannelAdapterBase extends AGEventEmitter {
     abstract join(token: string, streamUuid: string, connectionType: AGRtcConnectionType): Promise<void>;
@@ -33,7 +32,7 @@ export declare abstract class RtcChannelAdapterBase extends AGEventEmitter {
     abstract leave(connectionType?: AGRtcConnectionType): Promise<void>;
     abstract enableDualStream(enable: boolean, connectionType?: AGRtcConnectionType): Promise<void>;
     abstract setLowStreamParameter(streamParameter: AGLowStreamParameter, connectionType?: AGRtcConnectionType): number;
-    abstract setRemoteVideoStreamType(streamUuid: string, streamType: RemoteStreamType, connectionType: AGRtcConnectionType): Promise<void>;
+    abstract setRemoteVideoStreamType(streamUuid: string, streamType: AGRemoteVideoStreamType, connectionType: AGRtcConnectionType): Promise<void>;
     abstract muteLocalVideo(mute: boolean, connectionType: AGRtcConnectionType): number;
     abstract muteLocalAudio(mute: boolean, connectionType: AGRtcConnectionType): number;
     abstract muteLocalScreenShare(mute: boolean, connectionType: AGRtcConnectionType): number;
@@ -79,9 +78,9 @@ export declare abstract class RtcAdapterBase extends AGEventEmitter {
     abstract onLocalScreenShareTrackStateChanged(cb: LocalVideoTrackStateEvent): number;
     abstract destroy(): number;
     abstract setBeautyEffectOptions(enable: boolean, options: AGBeautyEffect): number;
-    abstract setAudioRawDataConfig(config: AGAudioRawDataConfig): number;
-    abstract setAudioFrameCallback(): number;
-    abstract stopAudioFrameCallback(): number;
+    abstract setAudioRawDataConfig(config: AgoraRteAudioRawDataConfig, position: AgoraRteAudioRawDataPosition): number;
+    abstract addAudioRawDataObserver(observer: AgoraRteAudioRawDataObserver, position: AgoraRteAudioRawDataPosition): number;
+    abstract removeAudioRawDataObserver(observer: AgoraRteAudioRawDataObserver, position: AgoraRteAudioRawDataPosition): number;
     static getRtcVersion(): string;
     abstract hasScreenSharePermission(): boolean;
     abstract takeSnapshot(channel: string, streamUuid: number, filePath: string): Promise<AGSnapshotInfo | void>;

package/lib/core/rtc/adapter/electron/device.d.ts

@@ -35,5 +35,4 @@ export declare class RtcAudioDeviceManagerElectron extends RtcAudioDeviceManager
     private _emitRecordingListChanged;
     private _fetchPlaybackDeviceList;
     private _fetchRecordingDeviceList;
-    onAudioFrame(cb: (buffer: ArrayBuffer) => void): number;
 }

package/lib/core/rtc/adapter/electron/device.js

@@ -268,11 +268,6 @@ var RtcAudioDeviceManagerElectron = /*#__PURE__*/function (_RtcAudioDeviceManage
       });
       this._emitRecordingListChanged(true, newDevices, this.microphoneList);
     }
-  }, {
-    key: "onAudioFrame",
-    value: function onAudioFrame(cb) {
-      return 0;
-    }
   }]);
   return RtcAudioDeviceManagerElectron;
 }(_base.RtcAudioDeviceManagerBase);

package/lib/core/rtc/adapter/electron/index.d.ts

@@ -3,13 +3,13 @@ import type AgoraRtcEngine from 'agora-electron-sdk/types/AgoraSdk';
 import { AgoraRteVideoSourceType } from '../../../media/track';
 import { AgoraRtcVideoCanvas } from '../../canvas';
 import { AGRtcConnectionType } from '../../channel';
-import { AGScreenShareDevice, AGScreenShareType, AGBeautyEffect, AGAudioRawDataConfig, AGSnapshotInfo, AGNetworkStats, AGRtcState, AGLowStreamParameter } from '../../type';
+import { AGScreenShareDevice, AGScreenShareType, AGBeautyEffect, AGSnapshotInfo, AGNetworkStats, AGRtcState, AGLowStreamParameter, AGRemoteVideoStreamType } from '../../type';
 import { LocalVideoTrackStateEvent, LocalAudioTrackStateEvent, RtcAdapterBase, RtcAudioDeviceManagerBase, RtcChannelAdapterBase, RtcVideoDeviceManagerBase, LocalAudioPlaybackVolumeIndicatorEvent } from '../base';
 import { AgoraRteElectronCameraThread } from './thread';
 import { AgoraLatencyLevel } from '../../../../configs';
 import { AGChannelProfile } from '../../../../type';
-import { RemoteStreamType } from 'agora-rtc-sdk-ng';
 import { Logger } from '../../../logger';
+import { AgoraRteAudioRawDataConfig, AgoraRteAudioRawDataObserver, AgoraRteAudioRawDataPosition } from '../../../media/type';
 declare global {
     interface Window {
         main_pid: string;
@@ -71,12 +71,11 @@ export declare class RtcAdapterElectron extends RtcAdapterBase {
     onLocalAudioTrackStateChanged(cb: LocalAudioTrackStateEvent): number;
     onLocalAudioVolume(cb: (volume: number) => void): number;
     onLocalScreenShareTrackStateChanged(cb: LocalVideoTrackStateEvent): number;
-    onAudioFrame(cb: (buffer: ArrayBuffer) => void): number;
     setBeautyEffectOptions(enable: boolean, options: AGBeautyEffect): number;
-    setAudioFrameCallback(): number;
-    stopAudioFrameCallback(): number;
-    setAudioRawDataConfig(config: AGAudioRawDataConfig): number;
     hasScreenSharePermission(): boolean;
+    setAudioRawDataConfig(config: AgoraRteAudioRawDataConfig, position: AgoraRteAudioRawDataPosition): number;
+    addAudioRawDataObserver(observer: AgoraRteAudioRawDataObserver): number;
+    removeAudioRawDataObserver(observer: AgoraRteAudioRawDataObserver): number;
     takeSnapshot(channel: string, streamUuid: number, filePath: string): Promise<AGSnapshotInfo>;
     getCurrentFrameData(_channelName: string, _streamUuid: string, _isLocal: boolean): ImageData;
     addCameraProcessors(_processors: unknown[]): number;
@@ -108,7 +107,7 @@ export declare class RtcChannelAdapterElectron extends RtcChannelAdapterBase {
     enableDualStream(enable: boolean): Promise<void>;
     setLowStreamParameter(streamParameter: AGLowStreamParameter): number;
     getCurrentFrameData(_streamUuid: string): ImageData;
-    setRemoteVideoStreamType(streamUuid: string, streamType: RemoteStreamType): Promise<void>;
+    setRemoteVideoStreamType(streamUuid: string, streamType: AGRemoteVideoStreamType): Promise<void>;
     onConnectionStateChanged(cb: (state: AGRtcState, connectionType: AGRtcConnectionType) => void): number;
     leave(connectionType?: AGRtcConnectionType): Promise<void>;
     onNetworkStats(cb: (stats: AGNetworkStats) => void): number;

package/lib/core/rtc/adapter/electron/index.js

@@ -141,6 +141,10 @@ var RtcAdapterElectron = (_dec = _log.Log.attach({
       _logger.Logger.warn("no log path found, sdk logs will be put in default folder");
       res = _this.rtcEngine.initialize(_configs.AgoraRteEngineConfig.shared.appId, _this._region);
     }
+    var defaultRemoteVideoStreamType = _configs.AgoraRteEngineConfig.shared.rtcConfigs.defaultRemoteVideoStreamType;
+    if (typeof defaultRemoteVideoStreamType !== 'undefined') {
+      _this.rtcEngine.setRemoteDefaultVideoStreamType(defaultRemoteVideoStreamType);
+    }
     _this.rtcEngine.registerMediaMetadataObserver();
     if (res !== 0) {
       _error.RteErrorCenter.shared.handleThrowableError(_error.AGRteErrorCode.RTC_ERR_RTC_ENGINE_INITIALZIE_FAILED, new Error("rtc engine initialize failed ".concat(res)));
@@ -385,35 +389,11 @@ var RtcAdapterElectron = (_dec = _log.Log.attach({
       this._screenEventBus.on(_control.AgoraMediaControlEventType.trackStateChanged, cb);
       return 0;
     }
-  }, {
-    key: "onAudioFrame",
-    value: function onAudioFrame(cb) {
-      this.logger.warn("electron platform does not support this for now");
-      return 0;
-    }
   }, {
     key: "setBeautyEffectOptions",
     value: function setBeautyEffectOptions(enable, options) {
       return this.rtcEngine.setBeautyEffectOptions(enable, options);
     }
-  }, {
-    key: "setAudioFrameCallback",
-    value: function setAudioFrameCallback() {
-      this.logger.warn("electron platform does not support this for now");
-      return 0;
-    }
-  }, {
-    key: "stopAudioFrameCallback",
-    value: function stopAudioFrameCallback() {
-      this.logger.warn("electron platform does not support this for now");
-      return 0;
-    }
-  }, {
-    key: "setAudioRawDataConfig",
-    value: function setAudioRawDataConfig(config) {
-      this.logger.warn("electron platform does not support this for now");
-      return 0;
-    }
   }, {
     key: "hasScreenSharePermission",
     value: function hasScreenSharePermission() {
@@ -423,6 +403,24 @@ var RtcAdapterElectron = (_dec = _log.Log.attach({
       }
       return true;
     }
+  }, {
+    key: "setAudioRawDataConfig",
+    value: function setAudioRawDataConfig(config, position) {
+      this.logger.warn("electron platform does not support setAudioRawDataConfig for now");
+      return 1;
+    }
+  }, {
+    key: "addAudioRawDataObserver",
+    value: function addAudioRawDataObserver(observer) {
+      this.logger.warn("electron platform does not support addAudioRawDataObserver for now");
+      return 1;
+    }
+  }, {
+    key: "removeAudioRawDataObserver",
+    value: function removeAudioRawDataObserver(observer) {
+      this.logger.warn("electron platform does not support removeAudioRawDataObserver for now");
+      return 1;
+    }
   }, {
     key: "takeSnapshot",
     value: function takeSnapshot(channel, streamUuid, filePath) {

package/lib/core/rtc/adapter/web/client.d.ts

@@ -1,25 +1,27 @@
-import { IAgoraRTCClient, IAgoraRTCRemoteUser, RemoteStreamType } from 'agora-rtc-sdk-ng';
+import { IAgoraRTCClient, IAgoraRTCRemoteUser } from 'agora-rtc-sdk-ng';
 import { RtcAdapterWeb, RtcAdapterWebConfig } from '.';
 import { AGEventEmitter } from '../../../utils/events';
 import { RtcAdapterBase } from '../base';
 import { AgoraRteSubscribeThread } from './thread';
-import { AGLowStreamParameter, AGRtcState } from '../../type';
+import { AGLowStreamParameter, AGRemoteVideoStreamType, AGRtcState } from '../../type';
 import { AGRtcConnectionType } from '../../channel';
 import { AgoraLatencyLevel } from '../../../../configs';
 import { Logger } from '../../../logger';
+import { AGAudioRawDataDispatcher } from './dispatcher';
 export declare class AgoraRteWebClientBase extends AGEventEmitter {
     logger: Logger;
     protected _client: IAgoraRTCClient;
     private _base;
     get base(): RtcAdapterWeb;
     private readonly configs;
-    private _connectionState;
     protected readonly channelName: string;
-    readonly connectionType: AGRtcConnectionType;
+    protected readonly connectionType: AGRtcConnectionType;
+    protected readonly _audioRawDataDispatcher: AGAudioRawDataDispatcher;
+    private _connectionState;
     private _networkStats;
     private _recentLocalPacketStats;
     private _recentRemotePacketStats;
-    constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType);
+    constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType, audioRawDataDispatcher: AGAudioRawDataDispatcher);
     private _setPrivateParameter;
     private _getRecentPacketLoss;
     get ready(): boolean;
@@ -41,7 +43,7 @@ export declare class AgoraRteWebClientMain extends AgoraRteWebClientBase {
     private _subscribeVideoThreads;
     private _subscribeAudioThreads;
     videoSubscribeThread(streamUuid: string): AgoraRteSubscribeThread | undefined;
-    constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType);
+    constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType, audioRawDataDispatcher: AGAudioRawDataDispatcher);
     get remoteRtcUsers(): Map<string, IAgoraRTCRemoteUser>;
     private _notifyStreamVolumes;
     private _notifySubscribeThreads;
@@ -54,17 +56,17 @@ export declare class AgoraRteWebClientMain extends AgoraRteWebClientBase {
     muteRemoteVideoMass(streamUuids: string[], mute: boolean): Promise<string[]>;
     enableDualStream(enable: boolean): Promise<void>;
     setLowStreamParameter(streamParameter: AGLowStreamParameter): number;
-    setRemoteVideoStreamType(streamUuid: string, streamType: RemoteStreamType): Promise<void>;
+    setRemoteVideoStreamType(streamUuid: string, streamType: AGRemoteVideoStreamType): Promise<void>;
     leave(): Promise<void>;
 }
 export declare class AgoraRteWebClientSub extends AgoraRteWebClientBase {
     private _publishThread;
-    constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType);
+    constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType, audioRawDataDispatcher: AGAudioRawDataDispatcher);
     muteLocalVideo(mute: boolean): number;
     muteLocalAudio(mute: boolean): number;
     muteLocalScreenShare(mute: boolean): number;
     setLowStreamParameter(streamParameter: AGLowStreamParameter): number;
-    setRemoteVideoStreamType(streamUuid: string, streamType: RemoteStreamType): Promise<void>;
+    setRemoteVideoStreamType(streamUuid: string, streamType: AGRemoteVideoStreamType): Promise<void>;
     enableDualStream(enable: boolean): Promise<void>;
     protected setConnectionState(state: AGRtcState): void;
     leave(): Promise<void>;