agora-rte-sdk 2.1.2 → 2.3.0

package/lib/configs/index.d.ts

@@ -36,6 +36,7 @@ export interface AgoraRteOptions {
     language?: RteLanguage;
     region?: AgoraRegion;
     rtcConfigs?: Partial<AGRtcConfig>;
+    rtcSDKParameters?: any[];
 }
 export declare class AgoraRteEngineConfig {
     private static _config?;
@@ -45,6 +46,7 @@ export declare class AgoraRteEngineConfig {
     service: AgoraRteServiceConfig;
     rtcConfigs: AGRtcConfig;
     logFilePath?: string;
+    rtcSDKParameters: any[];
     static logLevel: AgoraRteLogLevel;
     static get platform(): AgoraRteRuntimePlatform;
     userId: string;

package/lib/core/engine/index.d.ts

@@ -2,25 +2,24 @@ import { AGEventEmitter } from '../utils/events';
 import { AgoraRteEngineConfig } from '../../configs';
 import { AgoraRteScene } from '../../scene';
 import { AgoraMediaControl } from '../media/control';
-import { AgoraRteService } from '../services/api';
 import { TagInfo } from '../services/oss';
 export declare class AgoraRteEngine extends AGEventEmitter {
     private _mediaControl;
-    private _apiService;
     private _logService;
     private _rtmManager;
     private _rtcManager;
     private static _engine?;
+    private _apiServicePathPrefix;
     static get engine(): AgoraRteEngine;
     constructor(config: AgoraRteEngineConfig);
     static createWithConfig(config: AgoraRteEngineConfig): AgoraRteEngine;
     static destroy(): void;
+    get apiServicePathPrefix(): string;
     login(rtmToken: string, userId: string): Promise<void>;
     logout(): void;
     static getVersion(): string;
     static getRtcVersion(): string;
     createAgoraRteScene(sceneId: string): AgoraRteScene;
     getAgoraMediaControl(): AgoraMediaControl;
-    getApiService(): AgoraRteService;
     uploadSDKLogToAgoraService(tagInfo: TagInfo): Promise<void>;
 }

package/lib/core/logger/index.d.ts

@@ -7,9 +7,10 @@ export declare class Logger {
     static debug(...args: any[]): void;
     static info(...args: any[]): void;
     static error(...args: any[]): void;
-    private static log;
     static originConsole: Console;
+    private static log;
     static setupConsoleHijack(): void;
+    static restoreConsoleHijack(): void;
     collectConsoleLogs(): Promise<File>;
     cleanupConsoleLogs(): Promise<void>;
     private _addLocalFolderAsync;

package/lib/core/media/control.d.ts

@@ -1,7 +1,7 @@
 import { AGEventEmitter } from '../utils/events';
 import { AGRtcManager } from '../rtc';
 import { AgoraRteCameraVideoTrack, AgoraRteMicrophoneAudioTrack, AgoraRteScreenShareTrack } from './track';
-import { AGRtcDeviceInfo, AGScreenShareDevice, BeautyEffect } from '../../';
+import { AGRtcDeviceInfo, AGScreenShareDevice, BeautyEffect, FcrAudioRawDataConfig } from '../../';
 export declare enum AgoraMediaControlEventType {
     cameraListChanged = "camera-list-changed",
     localAudioVolume = "local-audio-volume",
@@ -12,7 +12,8 @@ export declare enum AgoraMediaControlEventType {
     playbackDeviceListChanged = "playback-device-list-changed",
     recordingDeviceListChanged = "recording-device-list-changed",
     localAudioPlaybackVolumeIndicator = "start-test-audio-playback-volume-indicator",
-    audioPlaybackStateChanged = "audio-playback-state-changed"
+    audioPlaybackStateChanged = "audio-playback-state-changed",
+    localAudioFrame = "local-audio-frame"
 }
 export declare class AgoraMediaControl extends AGEventEmitter {
     camera?: AgoraRteCameraVideoTrack;
@@ -35,5 +36,8 @@ export declare class AgoraMediaControl extends AGEventEmitter {
     stopAudioRecordingDeviceTest(): number;
     startAudioPlaybackDeviceTest(url: string): number;
     stopAudioPlaybackDeviceTest(): number;
+    setAudioFrameCallback(): number;
+    stopAudioFrameCallback(): number;
     setBeautyEffectOptions(enable: boolean, options: BeautyEffect): number;
+    setAudioRawDataConfig(config: FcrAudioRawDataConfig): number;
 }

package/lib/core/processor/channel-msg/handler.d.ts

@@ -13,7 +13,8 @@ export declare enum AgoraRteChannelMessageCmd {
     UserSubscribeInOut = 24,
     StreamInOut = 40,
     StreamsInOut = 41,
-    MessageExtension = 99
+    MessageExtension = 99,
+    BatchUserProperties = 25
 }
 export declare enum AgoraRtePeerMessageCmd {
     PeerChat = 1
@@ -26,6 +27,7 @@ export declare enum AgoraRteEventType {
     UserRemoved = "user-removed",
     RoomPropertyUpdated = "room-property-updated",
     UserPropertyUpdated = "user-property-updated",
+    BatchUserPropertyUpdated = "batch-user-property-updated",
     LocalStreamAdded = "local-stream-added",
     LocalStreamUpdate = "local-stream-update",
     LocalStreamRemove = "local-stream-removed",
@@ -44,7 +46,8 @@ export declare enum AgoraRteEventType {
     LocalAudioTrackStateChanged = "local-audio-track-state-changed",
     RtcConnectionStateChanged = "rtc-connection-state-changed",
     RtmConnectionStateChanged = "rtm-connection-state-changed",
-    RteConnectionStateChanged = "rte-connection-state-changed"
+    RteConnectionStateChanged = "rte-connection-state-changed",
+    TimeStampGapUpdate = "timestamp-gap-update"
 }
 export interface AgoraRteChannelMessageHandle {
     on(evt: AgoraRteEventType, ...args: any[]): this;
@@ -53,6 +56,7 @@ export interface AgoraRteChannelMessageHandle {
 export declare class AgoraRteChannelMessageHandle extends AGEventEmitter {
     protected logger: Injectable.Logger;
     private _dataStore;
+    private _timestampGap;
     sceneId: string;
     userUuid: string;
     streamUuid: string;
@@ -73,8 +77,10 @@ export declare class AgoraRteChannelMessageHandle extends AGEventEmitter {
     private _handleUserInfo;
     private _handleUserProperty;
     private _handleUserProperties;
+    private _handleBatchUserProperties;
     private _processStreamEvent;
     private _handleStreamInOut;
     private _handleStreamsInOut;
     private _handleMessageExtension;
+    private _syncTsGapWithServerAndLocal;
 }

package/lib/core/processor/channel-msg/struct.d.ts

@@ -20,12 +20,19 @@ export interface AgoraRteOperator {
     userName: string;
     role: string;
 }
+export interface AgoraRteMessageBatch {
+    id: number;
+    total: number;
+    current: number;
+}
 export interface AgoraRteMessageHandleTask {
     sequence: {
         cmd: number;
         operator: AgoraRteOperator;
         sequence: number;
         data: any;
+        batch: AgoraRteMessageBatch;
+        timestamp: number;
     };
 }
 export interface AgoraRtePeerMessageHandleTask {

package/lib/core/processor/channel-msg/synchronizer.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
+import { AgoraRteScene } from '../../../scene';
 import { Injectable } from '../../decorator/type';
 import { AGRtmManager } from '../../rtm';
 import { AgoraRteSyncDataStore } from './data';
@@ -7,7 +8,7 @@ import { AgoraRteChannelMessageHandle } from './handler';
 import { AgoraRteMessageHandleTask, AgoraRteSyncSnapshotData } from './struct';
 export declare class AgoraRteSynchronizer {
     protected logger: Injectable.Logger;
-    sceneId: string;
+    private _scene;
     userUuid: string;
     streamUuid: string;
     private _channelObserver;
@@ -19,8 +20,8 @@ export declare class AgoraRteSynchronizer {
     private _handleChannelMessage;
     private _handlePeerMessage;
     handle: AgoraRteChannelMessageHandle;
-    constructor(dataStore: AgoraRteSyncDataStore, { sceneId, userUuid, streamUuid, channelObserver, rtm, }: {
-        sceneId: string;
+    constructor(dataStore: AgoraRteSyncDataStore, { scene, userUuid, streamUuid, channelObserver, rtm, }: {
+        scene: AgoraRteScene;
         userUuid: string;
         streamUuid: string;
         channelObserver: EventEmitter;

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

@@ -1,9 +1,10 @@
+import { LowStreamParameter, RemoteStreamType, UID } from 'agora-rtc-sdk-ng';
 import { ClientRole } from '../../../type';
 import { AgoraRteAudioSourceType, AgoraRteVideoSourceType } from '../../media/track';
 import { AGEventEmitter } from '../../utils/events';
 import { AgoraRtcVideoCanvas } from '../canvas';
 import { AGRtcConnectionType } from '../channel';
-import { AgoraRteMediaSourceState, AGRtcDeviceInfo, AGScreenShareDevice, AGScreenShareType, BeautyEffect, NetworkStats, RtcState } from '../type';
+import { AgoraRteMediaSourceState, AGRtcDeviceInfo, AGScreenShareDevice, AGScreenShareType, BeautyEffect, FcrAudioRawDataConfig, NetworkStats, RtcState } from '../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;
@@ -23,11 +24,15 @@ 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>;
     abstract getSessionId(): string;
     abstract leave(connectionType?: AGRtcConnectionType): Promise<void>;
+    abstract enableDualStream(enable: boolean, connectionType?: AGRtcConnectionType): Promise<void>;
+    abstract setLowStreamParameter(streamParameter: LowStreamParameter, connectionType?: AGRtcConnectionType): number;
+    abstract setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType, 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;
@@ -65,6 +70,9 @@ export declare abstract class RtcAdapterBase extends AGEventEmitter {
     abstract onLocalScreenShareTrackStateChanged(cb: LocalVideoTrackStateEvent): number;
     abstract destroy(): number;
     abstract setBeautyEffectOptions(enable: boolean, options: BeautyEffect): number;
+    abstract setAudioRawDataConfig(config: FcrAudioRawDataConfig): number;
+    abstract setAudioFrameCallback(): number;
+    abstract stopAudioFrameCallback(): number;
     static getRtcVersion(): string;
     abstract hasScreenSharePermission(): boolean;
 }

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

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

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

@@ -2,11 +2,12 @@ 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, BeautyEffect, NetworkStats, RtcState } from '../../type';
+import { AGScreenShareDevice, AGScreenShareType, BeautyEffect, FcrAudioRawDataConfig, NetworkStats, RtcState } from '../../type';
 import { LocalVideoTrackStateEvent, LocalAudioTrackStateEvent, RtcAdapterBase, RtcAudioDeviceManagerBase, RtcChannelAdapterBase, RtcVideoDeviceManagerBase, LocalAudioPlaybackVolumeIndicatorEvent } from '../base';
 import { AgoraRteElectronCameraThread } from './thread';
 import { ChannelProfile, ClientRole } from '../../../../type';
 import { Injectable } from '../../../decorator/type';
+import { LowStreamParameter, RemoteStreamType, UID } from 'agora-rtc-sdk-ng';
 declare global {
     interface Window {
         main_pid: string;
@@ -56,7 +57,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: BeautyEffect): number;
+    setAudioFrameCallback(): number;
+    stopAudioFrameCallback(): number;
+    setAudioRawDataConfig(config: FcrAudioRawDataConfig): number;
     hasScreenSharePermission(): boolean;
     destroy(): number;
     static getRtcVersion(): string;
@@ -75,6 +80,9 @@ export declare class RtcChannelAdapterElectron extends RtcChannelAdapterBase {
     private get _channelProfile();
     constructor(channelName: string, configs: RtcAdapterElectronConfig, base: RtcAdapterBase);
     getSessionId(): string;
+    enableDualStream(enable: boolean): Promise<void>;
+    setLowStreamParameter(_streamParameter: LowStreamParameter): number;
+    setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType): Promise<void>;
     onConnectionStateChanged(cb: (state: RtcState, connectionType: AGRtcConnectionType) => void): number;
     leave(connectionType?: AGRtcConnectionType): Promise<void>;
     setChannelProfile(profile: ChannelProfile): number;

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

@@ -1,4 +1,4 @@
-import { IAgoraRTCClient } from 'agora-rtc-sdk-ng';
+import { IAgoraRTCClient, LowStreamParameter, RemoteStreamType, UID } from 'agora-rtc-sdk-ng';
 import { RtcAdapterWeb, RtcAdapterWebConfig } from '.';
 import { AGEventEmitter } from '../../../utils/events';
 import { RtcAdapterBase } from '../base';
@@ -18,6 +18,7 @@ export declare class AgoraRteWebClientBase extends AGEventEmitter {
     private _connectionState;
     protected readonly channelName: string;
     readonly connectionType: AGRtcConnectionType;
+    private _networkStats;
     constructor(channelName: string, configs: RtcAdapterWebConfig, base: RtcAdapterBase, connectionType: AGRtcConnectionType);
     get ready(): boolean;
     protected setConnectionState(state: RtcState): void;
@@ -32,7 +33,6 @@ export declare class AgoraRteWebClientBase extends AGEventEmitter {
     private _getEncryptionMode;
 }
 export declare class AgoraRteWebClientMain extends AgoraRteWebClientBase {
-    private _networkStats;
     private _remoteRtcUsers;
     private _muteRemoteVideo;
     private _muteRemoteAudio;
@@ -46,6 +46,13 @@ export declare class AgoraRteWebClientMain extends AgoraRteWebClientBase {
     protected setConnectionState(state: RtcState): void;
     muteRemoteVideo(streamUuid: string, mute: boolean): number;
     muteRemoteAudio(streamUuid: string, mute: boolean): number;
+    enableDualStream(enable: boolean): Promise<void>;
+    setLowStreamParameter(streamParameter: LowStreamParameter): number;
+    setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType): Promise<void>;
+    leave(): Promise<void>;
 }
 export declare class AgoraRteWebClientSub extends AgoraRteWebClientBase {
+    setLowStreamParameter(streamParameter: LowStreamParameter): number;
+    setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType): Promise<void>;
+    enableDualStream(enable: boolean): Promise<void>;
 }

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

@@ -22,6 +22,7 @@ export declare class RtcAudioDeviceManagerWeb extends RtcAudioDeviceManagerBase
     private _playbackDeviceIds;
     constructor(adapter: RtcAdapterWeb, noDevicePermission?: boolean);
     onLocalAudioPlaybackTestVolumeChanged(cb: LocalAudioPlaybackVolumeIndicatorEvent): number;
+    onAudioFrame(cb: (buffer: ArrayBuffer) => void): number;
     onLocalAudioTrackStateChanged(cb: LocalAudioTrackStateEvent): number;
     onLocalAudioVolume(cb: (volume: number) => void): number;
     onLocalRecordingDeviceListChanged(cb: (addNewDevice: boolean, newDevices: AGRtcDeviceInfo[], allDevices: AGRtcDeviceInfo[]) => void): number;

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

@@ -1,12 +1,12 @@
 import { LocalVideoTrackStateEvent, LocalAudioTrackStateEvent, LocalAudioPlaybackVolumeIndicatorEvent } from '../base';
 import { RtcAdapterBase, RtcAudioDeviceManagerBase, RtcChannelAdapterBase, RtcVideoDeviceManagerBase } from '../base';
-import { SDK_CODEC, SDK_MODE } from 'agora-rtc-sdk-ng';
+import { LowStreamParameter, RemoteStreamType, SDK_CODEC, SDK_MODE, UID } from 'agora-rtc-sdk-ng';
 import { AgoraRteCameraThread, AgoraRteMicrophoneThread, AgoraRteScreenShareThread } from './thread';
 import { AgoraRtcVideoCanvas } from '../../canvas';
 import { AgoraRteVideoSourceType } from '../../../media/track';
 import { AgoraRteWebClientMain, AgoraRteWebClientSub } from './client';
 import { AGRtcConnectionType } from '../../channel';
-import { AGScreenShareDevice, AGScreenShareType, NetworkStats, RtcState } from '../../type';
+import { AGScreenShareDevice, AGScreenShareType, FcrAudioRawDataConfig, NetworkStats, RtcState } from '../../type';
 import { Injectable } from '../../../decorator/type';
 import { ClientRole } from '../../../../type';
 export interface RtcAdapterWebConfig {
@@ -51,7 +51,11 @@ export declare class RtcAdapterWeb extends RtcAdapterBase {
     onLocalAudioTrackStateChanged(cb: LocalAudioTrackStateEvent): number;
     onLocalScreenShareTrackStateChanged(cb: LocalVideoTrackStateEvent): number;
     onLocalAudioVolume(cb: (volume: number) => void): number;
+    onAudioFrame(cb: (buffer: ArrayBuffer) => void): number;
     setBeautyEffectOptions(enable: boolean, options: object): number;
+    setAudioFrameCallback(): number;
+    stopAudioFrameCallback(): number;
+    setAudioRawDataConfig(config: FcrAudioRawDataConfig): number;
     hasScreenSharePermission(): boolean;
     destroy(): number;
     static getRtcVersion(): string;
@@ -66,6 +70,9 @@ export declare class RtcChannelAdapterWeb extends RtcChannelAdapterBase {
     private client;
     join(token: string, streamUuid: string, connectionType: AGRtcConnectionType): Promise<void>;
     leave(connectionType?: AGRtcConnectionType): Promise<void>;
+    enableDualStream(enable: boolean, connectionType: AGRtcConnectionType): Promise<void>;
+    setLowStreamParameter(streamParameter: LowStreamParameter, connectionType: AGRtcConnectionType): number;
+    setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType, connectionType: AGRtcConnectionType): Promise<void>;
     setClientRole(role: ClientRole): number;
     muteLocalVideo(mute: boolean, connectionType: AGRtcConnectionType): number;
     muteLocalAudio(mute: boolean, connectionType: AGRtcConnectionType): number;

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

@@ -1,6 +1,6 @@
 import { AgoraRteThread } from '../../../utils/thread';
 import { AgoraRtcVideoCanvas } from '../../canvas';
-import { AgoraRteMediaSourceState } from '../../type';
+import { AgoraRteMediaSourceState, FcrAudioRawDataConfig } from '../../type';
 import { IAgoraRTCClient, IAgoraRTCRemoteUser, ILocalTrack, IRemoteAudioTrack } from 'agora-rtc-sdk-ng';
 export declare class AgoraRteMediaTrackThread extends AgoraRteThread {
     track?: ILocalTrack;
@@ -21,8 +21,12 @@ export declare class AgoraRteMicrophoneThread extends AgoraRteMediaTrackThread {
     private _recordingDeviceChanged;
     trackState: AgoraRteMediaSourceState;
     private _volumePollingTask?;
+    private _audioRawConfig;
     setMicTrackState(state: AgoraRteMediaSourceState, reason?: string): void;
     setRecordingDevice(deviceId: string): void;
+    setAudioRawDataConfig(config: FcrAudioRawDataConfig): void;
+    setAudioFrameCallback(): void;
+    stopAudioFrameCallback(): void;
     onExecution(): Promise<void>;
 }
 export declare class AgoraRteScreenShareThread extends AgoraRteMediaTrackThread {

package/lib/core/rtc/channel.d.ts

@@ -1,3 +1,4 @@
+import { LowStreamParameter, RemoteStreamType, UID } from 'agora-rtc-sdk-ng';
 import { ClientRole } from '../../type';
 import { RtcChannelAdapterBase } from './adapter/base';
 import { NetworkStats, RtcState } from './type';
@@ -10,6 +11,9 @@ export declare class AGRtcChannel {
     private _adapter;
     constructor(channelName: string, adapter: RtcChannelAdapterBase);
     private connectionType;
+    enableDualStream(enable: boolean, connectionType?: AGRtcConnectionType): Promise<void>;
+    setLowStreamParameter(streamParameter: LowStreamParameter, connectionType?: AGRtcConnectionType): number;
+    setRemoteVideoStreamType(uid: UID, streamType: RemoteStreamType, connectionType?: AGRtcConnectionType): Promise<void>;
     getRtcSid(): string;
     join(token: string, streamUuid: string, connectionType?: AGRtcConnectionType): Promise<void>;
     leave(connectionType?: AGRtcConnectionType): Promise<void>;

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

@@ -3,7 +3,7 @@ import { AGRtcConfig } from './adapter';
 import { LocalAudioTrackStateEvent, LocalVideoTrackStateEvent, RtcAudioDeviceManagerBase, RtcVideoDeviceManagerBase } from './adapter/base';
 import { AgoraRtcVideoCanvas } from './canvas';
 import { AGRtcChannel } from './channel';
-import { AGRtcDeviceInfo, AGScreenShareDevice, AGScreenShareType, BeautyEffect } from './type';
+import { AGRtcDeviceInfo, AGScreenShareDevice, AGScreenShareType, BeautyEffect, FcrAudioRawDataConfig } from './type';
 export declare class AGRtcManager {
     private _adapter;
     private _channels;
@@ -28,6 +28,8 @@ export declare class AGRtcManager {
     stopAudioRecordingDeviceTest(): number;
     startAudioPlaybackDeviceTest(url: string): number;
     stopAudioPlaybackDeviceTest(): number;
+    setAudioFrameCallback(): number;
+    stopAudioFrameCallback(): number;
     onLocalCameraListChanged(cb: (addNewDevice: boolean, newDevices: AGRtcDeviceInfo[], allDevices: AGRtcDeviceInfo[]) => void): number;
     onLocalRecordingDeviceListChanged(cb: (addNewDevice: boolean, newDevices: AGRtcDeviceInfo[], allDevices: AGRtcDeviceInfo[]) => void): number;
     onLocalPlaybackListChanged(cb: (addNewDevice: boolean, newDevices: AGRtcDeviceInfo[], allDevices: AGRtcDeviceInfo[]) => void): number;
@@ -35,6 +37,7 @@ export declare class AGRtcManager {
     onLocalAudioTrackStateChanged(cb: LocalAudioTrackStateEvent): number;
     onLocalAudioVolume(cb: (volume: number) => void): number;
     setBeautyEffectOptions(enable: boolean, options: BeautyEffect): number;
+    setAudioRawDataConfig(config: FcrAudioRawDataConfig): number;
     hasScreenSharePermission(): boolean;
     destroy(): number;
 }

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

@@ -1,3 +1,4 @@
+import { LowStreamParameter } from 'agora-rtc-sdk-ng';
 export declare enum AGNetworkQuality {
     unknown = 99,
     bad = 1,
@@ -106,3 +107,19 @@ export interface BeautyEffect {
     rednessLevel: number;
     smoothnessLevel: number;
 }
+export interface FcrAudioRawDataConfig {
+    frameSize: 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384;
+}
+export declare enum AgoraRteRemoteStreamType {
+    /**
+     * 0: High-quality video stream (high-bitrate, high-resolution).
+     */
+    HIGH_STREAM = 0,
+    /**
+     * 1: Low-quality video stream (low-bitrate, low-resolution).
+     */
+    LOW_STREAM = 1
+}
+export declare type AgoraRteStreamUID = string | number;
+export interface AgoraRteLowStreamParameter extends LowStreamParameter {
+}

package/lib/core/services/base.d.ts

@@ -13,6 +13,6 @@ export interface AgoraFetchParams {
 export declare class ApiBase {
     host?: string;
     pathPrefix?: string;
-    headers?: AgoraRteServiceConfig;
+    headers?: AgoraRteServiceConfig['headers'];
     fetch(params: AgoraFetchParams): Promise<any>;
 }

package/lib/core/utils/networkutils.d.ts

@@ -1,8 +1,21 @@
 import { AGNetworkQuality } from '../..';
+/**
+ * - 0: The network quality is unknown.
+ * - 1: The network quality is excellent.
+ * - 2: The network quality is quite good, but the bitrate may be slightly
+ * lower than excellent.
+ * - 3: Users can feel the communication slightly impaired.
+ * - 4: Users cannot communicate smoothly.
+ * - 5: The network is so bad that users can barely communicate.
+ * - 6: The network is down and users cannot communicate at all.
+ * - 7: Users cannot detect the network quality.
+ * - 8: Detecting the network quality.
+ */
 export declare class QualityCalc {
     private quality;
     private qualities;
     static MAX_QUALITY_NUMBER: number;
+    static QUALITY_THRESHOLD: number;
     private _updateQualities;
     private _resetQualities;
     toAGQuality(webquality?: number): AGNetworkQuality;