///
import { default as default_2 } from 'https://esm.d8d.fun/eventemitter3@5.0.1/index.d.ts';
import { default as default_3 } from 'https://esm.d8d.fun/@aliyun-sls/web-track-browser@0.3.9/dist/web-track-browser.d.ts';
import { IAudioConstraints } from 'https://esm.d8d.fun/media-device@1.3.0/dist/index.d.ts';
import { IProfile } from 'https://esm.d8d.fun/aliyun-rts-sdk@2.12.3/dist/index.d.ts';
import { IStreamConfig } from 'https://esm.d8d.fun/aliyun-rts-sdk@2.12.3/dist/index.d.ts';
import { IVideoConstraints } from 'https://esm.d8d.fun/media-device@1.3.0/dist/index.d.ts';
import { LocalStream } from 'https://esm.d8d.fun/aliyun-rts-sdk@2.12.3/dist/index.d.ts';
import { RemoteStream } from 'https://esm.d8d.fun/aliyun-rts-sdk@2.12.3/dist/index.d.ts';
declare interface AliEngineCameraCapturerConfiguration {
width?: number;
height?: number;
frameRate?: number;
maxSendFrameRate?: number;
bitrate?: number;
cameraDirection?: AliRtcCameraDirection;
deviceId?: string;
}
declare enum AliRtcAudioTrack {
/** 无麦克风 */
AliRtcAudioTrackNo = 0,
/** 麦克风 */
AliRtcAudioTrackMic = 1,
/** 第二音频流 */
AliRtcAudioTrackDual = 2
}
export declare interface AliRtcAuthInfo {
/** 频道ID */
channelId: string;
/** 用户ID */
userId: string;
/** 应用ID */
appId: string;
/** 随机串 */
nonce?: string;
/** 时间戳 */
timestamp: number;
/** 令牌 */
token: string;
/** 会议id */
sessionId?: string;
/** 角色鉴权值 */
role?: AliRtcSdkTokenRole;
}
declare interface AliRtcBeautyConfig {
whiteningLevel: number;
/*! 磨皮等级[0-1.0] */
smoothnessLevel: number;
}
declare enum AliRtcCameraDirection {
/** 无效 */
CAMERA_INVALID = -1,
/** 后置 */
CAMERA_REAR = 0,
/** 前置 */
CAMERA_FRONT = 1
}
export declare interface AliRtcCheckResult {
support: boolean;
detail: {
isWebRTCSupported: boolean;
isH264EncodeSupported: boolean;
isH264DecodeSupported: boolean;
isBrowserSupported: boolean;
isScreenShareSupported: boolean;
isSendMediaExtensionMsgSupported: boolean;
};
}
export declare enum AliRtcConnectionStatus {
/** 初始化完成 */
AliRtcConnectionStatusInit = 0,
/** 网络连接断开 */
AliRtcConnectionStatusDisconnected = 1,
/** 建立网络连接中 */
AliRtcConnectionStatusConnecting = 2,
/** 网络已连接 */
AliRtcConnectionStatusConnected = 3,
/** 重新建立网络连接中 */
AliRtcConnectionStatusReconnecting = 4,
/** 网络连接失败 */
AliRtcConnectionStatusFailed = 5
}
export declare enum AliRtcConnectionStatusChangeReason {
/** 未知原因 */
AliRtcConnectionChangedDummyReason = 0,
/** 媒体通道变更 */
AliRtcConnectionMediaPathChanged = 1,
/** 心跳超时 */
AliRtcConnectionSignalingHeartbeatTimeout = 2,
/** 心跳恢复 */
AliRtcConnectionSignalingHeartbeatAlive = 3,
/** DNS解析成功 */
AliRtcConnectionSignalingHttpDnsResolved = 4,
/** DNS解析失败 */
AliRtcConnectionSignalingHttpDnsFailure = 5,
/** GSLB请求失败 */
AliRtcConnectionSignalingGslbFailure = 6,
/** GSLB请求成功 */
AliRtcConnectionSignalingGslbSuccess = 7,
/** 加入频道失败 */
AliRtcConnectionSignalingJoinRoomFailure = 8,
/** 加入频道成功 */
AliRtcConnectionSignalingJoinRoomSuccess = 9,
/** 离开频道 */
AliRtcConnectionSignalingLeaveRoom = 10,
/** 信令建立连接 */
AliRtcConnectionSignalingConnecting = 11,
/** 网络连接中断 */
AliRtcConnectionChangedNetworkInterrupted = 12
}
export declare class AliRtcDataChannelMsg {
data: ArrayBuffer;
networkTime: number;
futureOrProgress: number;
type: AliRtcDataMsgType;
constructor(data: ArrayBuffer, type?: AliRtcDataMsgType, networkTime?: number, progress?: number);
toBuffer(): ArrayBuffer;
static parse(buffer: ArrayBuffer): AliRtcDataChannelMsg | undefined;
}
export declare enum AliRtcDataMsgType {
AliEngineDataMsgNone = 0,
AliEngineDataMsgMusicProgress = 1,
AliEngineDataMsgCustom = 2
}
declare type AliRtcDualVideoPluginOptions = VideoScalerOptions;
declare class AliRtcEngine_2 extends default_2 {
/**
* @ignore
*/
static logName: string;
/**
* @ignore
*/
static logError: boolean;
/**
* 检查浏览器是否支持 WebRTC
* @param {string} direction
* @returns {Promise}
*/
static isSupported: (direction?: "sendonly" | "recvonly" | "sendrecv" | undefined) => Promise;
/**
* 检查浏览器是否支持开启大小流
* @returns {boolean}
*/
static isDualVideoStreamSupported: typeof VideoScalerFactory.isSupport;
/**
* 获取摄像头列表
* @returns {Promise}
*/
static getCameraList: () => Promise;
static getMicrophoneList: () => Promise;
static getSpeakerList: () => Promise;
static getSdkVersion(): string;
/**
* 设置日志等级
* @param level
*/
static setLogLevel(level: AliRtcLogLevel): void;
private static _instance?;
/**
* @brief 获取AliRtcEngine实例
* @param key key 可选参与，用于创建多个实例
* @details 该方法为同步调用，以单例的形式提供对象创建。
*/
static getInstance(config?: AliRtcEngineConfig): AliRtcEngine_2;
static AliRtcSdkChannelProfile: typeof AliRtcSdkChannelProfile;
static AliRtcSdkClientRole: typeof AliRtcSdkClientRole;
static AliRtcVideoStreamType: typeof AliRtcVideoStreamType;
static AliRtcVideoTrack: typeof AliRtcVideoTrack;
static AliRtcAudioTrack: typeof AliRtcAudioTrack;
static AliRtcPublishState: typeof AliRtcPublishState;
static AliRtcSubscribeState: typeof AliRtcSubscribeState;
static AliRtcRawDataStreamType: typeof AliRtcRawDataStreamType;
static AliRtcLogLevel: typeof AliRtcLogLevel;
static AliRtcEngineLocalDeviceType: typeof AliRtcEngineLocalDeviceType;
static AliRtcEngineLocalDeviceExceptionType: typeof AliRtcEngineLocalDeviceExceptionType;
static AliRtcConnectionStatus: typeof AliRtcConnectionStatus;
static AliRtcConnectionStatusChangeReason: typeof AliRtcConnectionStatusChangeReason;
static AliRtcPlugin: typeof AliRtcPlugin;
static AliRtcPluginTrackType: typeof AliRtcPluginTrackType;
static AliRtcLiveTranscodingParam: typeof AliRtcLiveTranscodingParam;
static AliRtcLiveTranscodingEncodeParam: typeof AliRtcLiveTranscodingEncodeParam;
static AliRtcLiveTranscodingMixParam: typeof AliRtcLiveTranscodingMixParam;
static AliRtcLiveTranscodingSingleParam: typeof AliRtcLiveTranscodingSingleParam;
static AliRtcTranscodingClockWidget: typeof AliRtcTranscodingClockWidget;
static AliRtcTranscodingImage: typeof AliRtcTranscodingImage;
static AliRtcTranscodingText: typeof AliRtcTranscodingText;
static AliRtcTranscodingUser: typeof AliRtcTranscodingUser;
static AliRtcLiveTranscodingMixMode: typeof AliRtcLiveTranscodingMixMode;
static AliRtcLiveTranscodingStreamType: typeof AliRtcLiveTranscodingStreamType;
static AliRtcLiveTranscodingSourceType: typeof AliRtcLiveTranscodingSourceType;
static AliRtcLiveTranscodingTaskProfile: typeof AliRtcLiveTranscodingTaskProfile;
static AliRtcLiveTranscodingAudioSampleRate: typeof AliRtcLiveTranscodingAudioSampleRate;
static AliRtcLiveTranscodingSegmentType: typeof AliRtcLiveTranscodingSegmentType;
static AliRtcLiveTranscodingFontType: typeof AliRtcLiveTranscodingFontType;
static AliRtcLiveTranscodingCropMode: typeof AliRtcLiveTranscodingCropMode;
static AliRtcLiveTranscodingMediaProcessMode: typeof AliRtcLiveTranscodingMediaProcessMode;
static AliRtcLiveTranscodingState: typeof AliRtcLiveTranscodingState;
static AliRtcLiveTranscodingErrorCode: typeof AliRtcLiveTranscodingErrorCode;
static AliRtcTrascodingPublishTaskStatus: typeof AliRtcTrascodingPublishTaskStatus;
static AliRtcDataChannelMsg: typeof AliRtcDataChannelMsg;
static AliRtcDataMsgType: typeof AliRtcDataMsgType;
/**
* @brief 销毁 {@link AliRtcEngine}实例
* @details 调用该方法将会释放所有内部使用的资源,当完成音视频通信之后都建议调用该方法释放实例.调用该方法后，你将不能再使用 {@link AliRtcEngine} 的其他方法和任何回调，如需要再次使用需要重新调用 {@link AliRtcEngine.getInstance} 方法创建一个新的实例。
* @note 该方法为同步调用,需要等待内部资源释放之后才能执行其他方法
*/
destroy(): Promise;
protected channelProfile: AliRtcSdkChannelProfile;
protected clientRole: AliRtcSdkClientRole;
protected signalingManager: SignalingManager;
protected bizControl: BizControl;
protected liveTranscoding: AliRtcLiveTranscoding;
protected maxSignalingConnectRetryCount?: number;
protected slsReporter: SLSReporter;
protected connectState: AliRtcConnectionStatus;
protected networkError: boolean;
private _audioOnlyMode;
private _authInfoWillExpireTimer;
private _authInfoExpiredTimer;
private _serverCheckAuthInfoTimestamp;
private _localCheckAuthInfoTimestamp;
constructor(config?: AliRtcEngineConfig);
/**
* 获取当前频道号，已经入会成功返回频道号，否则返回undefined
*/
get channel(): string | undefined;
/**
* 获取当前用户的 userId，已经入会成功返回自己的 userId，否则返回 undefined
*/
get userId(): string | undefined;
get remoteUsers(): RemoteUser[];
get publisher(): LocalUser | undefined;
get publishAudioStream(): LocalStream | undefined;
get isPublishing(): boolean;
private get currentRoleCanPublish();
/**
* 监听 Publisher 事件
*/
private addPublisherListeners;
private occurError;
/**
* 监听 UM 事件
*/
private addBizControlListeners;
/**
* 添加信令处理
* @returns {void}
*/
private addSignalingManagerListeners;
private backToUnpublishStatus;
/**
* 处理入会远程的用户
* @param {JoinInfo[]} users
* @returns {void}
*/
private handleUsersJoin;
/**
* 本地用户设备状态变化，通过信令发送给其他人
* @param {string} status
* @returns {void}
*/
protected onLocalDeviceStatusChange(status: string): void;
/**
* 网络恢复后，重推；
*/
private resumePublishForNetworkRecovery;
/**
* 处理房间信令重连成功/心跳恢复
* @returns {void}
*/
protected onNetworkRecovery(users?: JoinInfo[]): Promise;
private resumeSubList;
/**
* 重新订阅远端用户
* @param {string} userId
* @returns {Promise}
*/
retrySubscribe(userId: string): Promise;
/**
* 处理网络异常
* @param {AliRtcError} err
* @returns {void}
*/
protected onNetworkError(): void;
/**
* 处理错误
* @param {AliRtcError} err
* @returns {void}
*/
protected onError(err: AliRtcError): void;
/**
* 是否开启大小流
* @param {boolean} enabled
* @param {AliRtcDualVideoPluginOptions} [options]
*/
setEnableDualVideoStream(enabled: boolean, options?: AliRtcDualVideoPluginOptions): void;
/**
* 对本地流的操作预检查
*/
private hadPushStream;
/**
* 获取当前使用的麦克风 deviceId
* @returns {string | undefined}
*/
getCurrentMicDeviceId(): string | undefined;
/**
* 设置频道模式
* @param {AliRtcSdkChannelProfile} channelProfile 频道类型，默认值为 AliEngineCommunication
* @note 该接口只可以在加入频道之前调用，会议中不可以重新设置，离开频道后可以重新设置
*/
setChannelProfile(channelProfile: AliRtcSdkChannelProfile): void;
// private startAndPublishDefaultDevices;
/**
* 自动启动并发布默认设备
* @param options 配置选项
* @param options.audioOnly 是否仅音频模式，为true时不会启动摄像头
* @returns Promise
* @description
* 1. 自动检测并启动默认摄像头(非仅音频模式时)
* 2. 自动启动默认麦克风
* 3. 预览所有设备
* 4. 自动发布所有流
* 注意：如果设备已启动，会跳过相应步骤
*/
startAndPublishDefaultDevices: (options?: { audioOnly?: boolean }) => Promise;
/**
* 设置用户角色
* @param {AliRtcSdkClientRole} clientRole 用户角色类型，默认值为 {@link AliRtcSdkClientRole.AliRtcSdkLive}（观众角色）
* @note 非通信模式下角色类型才有效
*/
setClientRole(clientRole: AliRtcSdkClientRole): Promise;
/**
* 获取用户角色
* @returns {AliRtcSdkClientRole}
*/
getCurrentClientRole(): AliRtcSdkClientRole;
/**
* 是否开启纯音频模式
* @param {boolean} audioOnly
* - true：只有音频推流和拉流
* - false（默认值）：音视频都支持
* @note 只可以在 {@link joinChannel} 之前设置
*/
setAudioOnlyMode(audioOnly: boolean): void;
setAudioRedEnabled(audioRedEnabled: boolean): void;
/**
* 设定鉴权信息过期事件定时器
* @param expireTimestamp 鉴权信息过期时间
* @param serverTimestamp 入会时服务端时间
*/
private setCheckAuthInfoTimer;
/**
* 清除鉴权信息过期事件定时器
*/
private clearCheckAuthInfoTimer;
/**
* @brief 加入频道
* @details 该方法让用户加入频道，一个频道内可以加入多个用户进行互相通话。
* @details 一般在调用该方法前会根据场景先选择频道模式，通过调用 {@link setChannelProfile} 实现，默认频道模式为通信模式 {@link AliRtcSdkChannelProfile.AliRtcSdkCommunication}
* ``` javascript
* // 设置频道为互动模式
* engine.setChannelProfile(AliRtcSdkChannelProfile.AliRtcInteractivelive);
* // 设置角色为主播角色
* engine.setClientRole(AliRtcSdkClientRole.AliRtcSdkInteractive);
* ```
* @param {AliRtcAuthInfo | string} authInfoOrToken (多参数/单参数) 认证信息，从App Server获取。
* @param {string} userName 任意用于显示的用户名称。不是User ID
* @note
* - 异步接口，方法执行成功则为成功入会
* - 正常情况一个Appid对应一个App，只有同一个AppId的应用可进行互相童话,不同AppId和channelID不同都不能互通
* - 当入会成功后，会触发远端用户收到 {@link AliRtcEngineEventListener.remoteUserOnLineNotify} 回调
* - 如果已在会中想重新入会，需要先调用 {@link leaveChannel} 离会，且确保方法执行成功
* - 用户加入频道后，默认订阅频道内所有其他用户的音视频流，默认推送音视频流到远端，因此将会产生计费，如果想要取消默认订阅可以 {@link joinChannel} 前调用 {@link setDefaultSubscribeAllRemoteAudioStreams} 和 {@link setDefaultSubscribeAllRemoteVideoStreams}
*/
joinChannel(authInfoOrToken: AliRtcAuthInfo | string, userName?: string): Promise;
/**
* 离开频道
* @note 如果当前不在频道内，调用 leaveChannel 不会对实例产生任何影响，但会产生消息，通知频道内其他用户
*/
leaveChannel(): Promise;
/**
* 检查当前是否在频道中
* @returns {boolean}
* - true：在频道中
* - false：不在频道中
*/
isInCall(): boolean;
/**
* 刷新鉴权信息
* @param {AliRtcRefreshAuthInfo | string} authInfoOrToken
*/
refreshAuthInfo(authInfoOrToken: AliRtcRefreshAuthInfo | string): Promise;
/**
* 检查当前是否纯音频模式
* @returns {boolean}
* - true：纯音频模式
* - false：音视频模式
*/
isAudioOnly(): boolean;
/**
* @brief 是否推送音频流
* @param enabled 是否开启/关闭本地音频流推送
* - true: 开启音频流推送
* - false: 关闭音频流推送
* @note SDK默认设置推送音频流，在加入频道前也可以调用此接口修改默认值，并在加入频道成功时生效
* @note 加入频道后调用不会停止本地音频采集
*/
publishLocalAudioStream(enabled: boolean): Promise;
/**
* @brief 查询是否设置推送音频流
* @return
* - true: 已设置推送
* - false: 未设置推送
* @note SDK默认设置推送音频流，如果需要取消推送音频流，可以通过 {@link publishLocalAudioStream}方法设置为不推送
*/
isLocalAudioStreamPublished(): boolean;
/**
* 设置是否默认接收音频流
* @param sub
* - true: 接收用户的音频流
* - false: 停止接收用户的音频流
* @note 入会前入会后均可调用。如果在加入频道后调用 setDefaultSubscribeAllRemoteAudioStreams(false)，会接收不到设置后加入频道的用户的音频流。
* @note 停止接收音频流后，如果想要恢复接收，请调用 {@link subscribeRemoteAudioStream}，并指定你想要接收的远端用户ID；
* @note 如果想恢复接收多个用户的音频流，则需要多次调用 {@link subscribeRemoteAudioStream}。setDefaultSubscribeAllRemoteAudioStreams(true) 只能恢复接收后面加入频道的用户的音频流。
*/
setDefaultSubscribeAllRemoteAudioStreams(sub: boolean): void;
/**
* 停止/恢复接收所有远端音频流
* @param sub
* - true: 接收所有用户的音频流
* - false: 停止接收所有用户的音频流
* @note 该接口作为订阅远端音频流的总开关，如果设置为false，则不仅当前会议中所有远端音频流都会停止订阅，后续入会的新用户也将不再订阅（即使设置了setDefaultSubscribeAllRemoteAudioStreams(true))
*/
subscribeAllRemoteAudioStreams(sub: boolean): void;
/**
* 手动拉音频流
* @param uid uid
* @param sub，默认为 true
* - true: 接收指定用户的音频流
* - false: 停止接收指定用户的音频流
* @note 如果之前有调用过 subscribeAllRemoteAudioStreams(false) 对所有远端音频进行静音，在调用本 API 之前请确保你已调用 subscribeAllRemoteAudioStreams(true)。
* @note {@link subscribeAllRemoteAudioStreams} 是全局控制，{@link subscribeRemoteAudioStream} 是精细控制。
*/
subscribeRemoteAudioStream(uid: string, sub: boolean): void;
/**
* 手动恢复远端用户音频流
* @param uid
* 用于在自动播放失败等场景恢复播放
*/
resumeRemoteAudioStream(uid: string): void;
stopRemoteAudioPlay(uid: string): void;
/**
* @brief 是否推送本地视频流
* @param enabled 是否开启/关闭本地视频流推送
* - true: 开启视频流推送
* - false: 关闭视频流推送
* @note SDK默认设置推送视频流，在加入频道前也可以调用此接口修改默认值，并在加入频道成功时生效
* @note 加入频道后调用不会停止本地视频采集
*/
publishLocalVideoStream(enabled: boolean): Promise;
/**
* @brief 查询是否设置推送视频流
* @return
* - true: 已设置推送
* - false: 未设置推送
* @note SDK默认设置推送视频流，如果需要取消推送视频流，可以通过 {@link publishLocalVideoStream} 方法设置为不推送
*/
isLocalVideoStreamPublished(): boolean;
/**
* 设置默认订阅的相机流格式，大流或小流，会覆盖单人的大小流设置
* @param {AliRtcVideoStreamType} streamType 流类型
* @note 仅支持传入 1 （默认大流）、2（默认小流），传入其他无效
* @note 当无默认类型的相机流，但有另一个，将拉取另一个
*/
setRemoteDefaultVideoStreamType(streamType: AliRtcVideoStreamType): void;
/**
* 设置某一用户默认订阅的相机流格式，大流或小流
* @param userId 远端用户ID
* @param {AliRtcVideoStreamType} streamType 流类型
* @note 仅支持传入 1 （默认大流）、2（默认小流），传入其他无效
* @note 当无默认类型的相机流，但有另一个，将拉取另一个
*/
setRemoteUserVideoStreamType(userId: string, streamType: AliRtcVideoStreamType): void;
/**
* 设置是否默认接收视频流
* @param sub
* - true: 接收用户的视频流
* - false: 不接收用户的视频流
* @note 入会前入会后均可调用。如果在加入频道后调用 setDefaultSubscribeAllRemoteVideoStreams(false)，会接收不到设置后加入频道的用户的视频流。
* @note 停止接收视频流后，如果想要恢复接收，请调用 {@link subscribeRemoteVideoStream}，并指定你想要接收的远端用户ID；
* @note 如果想恢复接收多个用户的视频流，则需要多次调用 {@link subscribeRemoteVideoStream}；setDefaultSubscribeAllRemoteVideoStreams(true) 只能恢复接收后面加入频道的用户的视频流。
*/
setDefaultSubscribeAllRemoteVideoStreams(sub: boolean): void;
/**
* 停止/恢复接收所有远端视频流
* @param sub
* - true: 接收所有用户的视频流
* - false: 停止接收所有用户的视频流
* @note 该接口作为订阅远端视频流的总开关，如果设置为false，则不仅当前会议中所有远端视频流都会停止订阅，后续入会的新用户也将不再订阅（即使设置了setDefaultSubscribeAllRemoteVideoStreams(true)）
*/
subscribeAllRemoteVideoStreams(sub: boolean): void;
/**
* 合并订阅远端音视频流
* @param uid uid
* @param videoTrack 视频流类型
* @param subVideo 是否订阅视频
* @param subAudio 是否订阅音频
* @return
*/
subscribeRemoteMediaStream(uid: string, videoTrack: AliRtcVideoTrack, subVideo: boolean, subAudio: boolean): void;
/**
* @brief 手动恢复远端用户视频流
* @param uid
* @param videoTrack
* 用于在自动播放失败等场景恢复播放
*/
resumeRemoteMediaStream(uid: string, videoTrack: AliRtcVideoTrack): void;
/**
* @brief 订阅目标频道，指定用户的流
* @param channelId 目标频道
* @param uid 用户ID，从App server分配的唯一标示符
* @param track 订阅的视频流类型
* @param sub_audio 是否订阅远端用户的音频流
* - true:订阅指定用户的音频流
* - false:停止订阅指定用户的音频流
* @param sub 是否订阅远端用户的流
* - true:订阅指定用户的流
* - false:停止订阅指定用户的流
*/
/**
* @brief 获取远端在线用户列表
* @return 当前频道内所有在线用户userid列表
* @note 若当前频道ChannelProfile设置为 {@link AliRtcSdkChannelProfile.AliRtcSdkInteractiveLive} 模式，只有设置角色为 {@link AliRtcSdkClientRole.AliRtcSdkInteractive} 的用户为在线用户，本方法不返回角色为 {@link AliRtcSdkClientRole.AliRtcSdkLive} 的用户
*/
getOnlineRemoteUsers(): string[];
/**
* @brief 查询远端用户状态
* @details 通过 uid 查询指定远端用户的状态信息.
* @param uid 用户ID。从App server分配的唯一标示符
* @return 返回一个远端用户对象。详见{@link RemoteUser}
*/
getUserInfo(uid: string): AliRtcRemoteUserInfo | undefined;
/**
* @brief 查询用户是否在线
* @param uid 用户ID，从App server分配的唯一标示符。不可为NULL
* @return
* - true: 用户在线
* - false: 用户不在线
* @note 根据特定的UserID，查询该用户是否在线。
*/
isUserOnline(uid: string): boolean;
/**
* @brief 开始屏幕共享
* @param config 开启屏幕共享的配置
* @note 可以通过 config 选择是否开启音频或使用外部自定义 MediaStream
* @note 自定义 MediaStream 仅支持一个视频流和一个音频流
*/
startScreenShare(config?: AliRtcScreenShareStartConfig): Promise;
/**
* @brief 停止屏幕共享
*/
stopScreenShare(): Promise;
/**
* @brief 设置屏幕流视频编码属性
* @details 该方法用于设置屏幕流视频编码属性对应的视频参数，如分辨率、帧率、码率、等 所有设置的参数都有相应的范围限制，如果设置的参数不在有效范围内，SDK会自动调节
* @param config 预定义的屏幕共享编码属性，
* @note
* - 该方法在入会前和入会后都可以调用，如果每次入会只需要设置一次屏幕流视频编码属性，建议在入会前调用
*/
setScreenShareConfiguration(config: AliRtcScreenShareConfiguration): Promise;
/**
* @breif 设置屏幕流采集内容提示
* @param contentHint 设置屏幕流内容提示，用于提升在不同内容场景下的视频编码质量 [参考文档](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/contentHint)
*/
setScreenShareContentHint(contentHint: string): Promise;
/**
* @brief 是否推送屏幕分享
* @param enabled 是否开启/关闭本地屏幕分享推送
* - true: 开启屏幕分享推送
* - false: 关闭屏幕分享推送
* @param config 开启屏幕共享的配置
* @note SDK默认设置推送屏幕分享，在加入频道前也可以调用此接口修改默认值，并在加入频道成功时生效
* @note 加入频道后调用不会停止本地屏幕采集
*/
publishLocalScreenShareStream(enabled: boolean, config?: AliRtcScreenShareStartConfig): Promise;
/**
* @brief 查询是否设置推送屏幕分享
* @return
- true: 已设置推送
- false: 未设置推送
* @note SDK默认设置不推送屏幕分享，如果需要推送屏幕共享，可以通过{@link startScreenShare}方法开启屏幕共享推送
*/
isScreenSharePublished(): boolean;
/**
* @brief 设置共享音频的音量大小
* @param volume 共享音频音量大小,取值范围[0, 100]
*/
setAudioShareVolume(volume: number): void;
/**
* 开启音量检测功能
* @param {number} interval 检测间隔，单位: ms
* @note 建议设置为300ms~500ms,取值 ≤0 表示不启用音量检测功能
*/
enableAudioVolumeIndication(interval: number): void;
/**
* 停止/恢复本地音频数据发送
* @param {boolean} mute 停止或恢复本地音频数据发送
* - true：静音本地音频
* - false（默认值）：取消静音
*/
muteLocalMic(mute?: boolean): void;
/**
* 停止/恢复远端指定用户的音频流的播放
* @param {string} uid 用户ID, 从 App server 分配的唯一标示符
* @param {boolean} mute 停止或恢复远端的音频播放
* - true：停止播放
* - false（默认值）：恢复播放
* @note 拉流和解码不受影响，支持 {@link joinChannel} 之前和之后设置
*/
muteRemoteAudioPlaying(uid: string, mute?: boolean): void;
/**
* 停止/恢复远端的所有音频流的播放
* @param {boolean} mute 停止或恢复远端的音频播放
* - true：停止播放
* - false（默认值）：恢复播放
* @note 拉流和解码不受影响，支持 {@link joinChannel} 之前和之后设置
*/
muteAllRemoteAudioPlaying(mute?: boolean): void;
/**
* @brief 开启音频采集
* @details 此接口可以控制提前打开音频采集，如果不设置，则SDK会自动控制音频采集设备：
* - 如果打开推送音频流{@link publishLocalAudioStream}，SDK在入会后会打开音频采集
* - 如果关闭推送音频流{@link publishLocalAudioStream}，SDK在入会后不会打开音频采集
* @param {IAudioConstraints} audioConstraints 音频采集参数
*/
startAudioCapture(audioConstraints?: IAudioConstraints): Promise;
/**
* @brief 设置音频采集参数
* @param constraints 音频采集参数
*/
setAudioConstraints(constraints: IAudioConstraints): Promise;
/**
* 关闭音频采集
* @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
*/
stopAudioCapture(): void;
/**
* 切换麦克风
* @param {string} deviceId 麦克风设备ID
* @param {MediaStreamAudioTrack} audioTrack 音频轨道
* @note 传入 audioTrack 则会使用传入的音频轨道
*/
switchMicrophone(deviceId: string, audioTrack?: MediaStreamAudioTrack): Promise;
/**
* 设置录音音量
* @param {VolumeSettings} volumeSettings 录音音量，取值范围[0,100]
* - 0：静音
* - <100：减小音量
* - >100：放大音量
*/
setRecordingVolume(volume: number): void;
/**
* @brief 设置播放音量
* @param volume 播放音量，取值范围[0,100], 0：静音；100：原始音量
* @note 注意此方法与 {@link setRemoteAudioVolume} 相互影响，以后调用的一个为准
*/
setPlayoutVolume(volume: number): void;
/**
* @brief 设置播放音量
* @param userId 用户ID
* @param volume 播放音量，取值范围[0,100], 0：静音；100：原始音量
* @note 注意此方法与 {@link setPlayoutVolume} 相互影响，以后调用的一个为准
*/
setRemoteAudioVolume(userId: string, volume: number): void;
/**
* 设置麦克风 profile
*
* @param {AudioProfileKey} profileKey
* @return {Promise}
*/
setAudioProfile(profileKey: AudioProfileKey): Promise;
/**
* @brief 获取当前用户或远端用户的音频轨道
* @param {string} userId 远端用户 userId
* @return {MediaStreamTrack} 音频轨道
*
*/
getAudioTrack(userId?: string): Promise;
/**
* 为本地预览设置渲染元素和视频流
* @param {AliRtcLocalView} view 渲染元素，null 则为停止显示
* @param {AliRtcVideoTrack} track 视频流类型
*/
setLocalViewConfig(view: AliRtcLocalView, track: AliRtcVideoTrack): Promise;
/**
* @brief 采集偏好设置
* @param cameraCapturerConfiguration 偏好设置
* - width: 设置采集分辨率宽度 默认 1280
* - height: 设置采集分辨率高度 默认 720
* - frameRate: 设置采集帧率 默认 30
* - bitrate: 设置采集码率 默认 2000
* - cameraDirection: 设置采集方向，前置或后置摄像头
* - deviceId: 设置采集相机ID
*/
setCameraCapturerConfiguration(cameraCapturerConfiguration: AliEngineCameraCapturerConfiguration): Promise;
/**
* @breif 设置摄像头采集内容提示
* @param contentHint 设置视频内容提示，用于提升在不同内容场景下的视频编码质量 [参考文档](https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/contentHint)
*/
setCameraCapturerContentHint(contentHint: string): Promise;
/**
* 禁用或启用摄像头采集
* @param enabled
* - true : 启用摄像头采集
* - false : 禁用摄像头采集
*/
enableLocalVideo(enabled?: boolean): Promise;
/**
* 是否将停止摄像头流数据发送
* @param mute
* - true：停止发送摄像头流数据
* - false：表示恢复正常
*/
muteLocalCamera(mute: boolean): Promise;
/**
* 是否将停止屏幕共享流数据发送
* @param mute
* - true：停止发送屏幕共享流数据
* - false：表示恢复正常
*/
muteLocalScreen(mute: boolean): Promise;
/**
* 设置远端视频显示视图
* @param {AliRtcLocalView} view 渲染元素
* @param {AliRtcVideoTrack} track 视频流类型
* @param {string} uid 用户ID, 从App server分配的唯一标示符
* @note 支持joinChannel之前和之后切换窗口。如果 view 传入 null，则停止显示
*/
setRemoteViewConfig(view: AliRtcLocalView, uid: string, track: AliRtcVideoTrack): void;
/**
* 检查camera是否打开
* @return {boolean}
* - true: 摄像头已打开
* - false: 摄像头没有打开
* @note 该接口用于检查当前camera的状态
*/
isCameraOn(): boolean;
/**
* 切换摄像头
* @param {string} deviceId 摄像头设备ID
* @param {MediaStreamVideoTrack} videoTrack 视频流
* @note 若不传 deviceId 则前后摄像头切换，传入 videoTrack 则会使用传入的 videoTrack
*/
switchCamera(deviceId?: string, videoTrack?: MediaStreamVideoTrack): Promise;
/**
* 获取摄像头设备ID
* @return {string} 摄像头设备ID
*/
getCurrentCameraDeviceId(): string | undefined;
/**
* @brief 开启摄像头预览
* @details 开启摄像头预览并自动打开摄像头
* @note 如果没有调用{@link setLocalViewConfig}设置显示的view，则无法预览，但不影响推流。
* 可以在{@link joinChannel}之前就开启预览会自动打开摄像头。
*/
startPreview(): Promise;
/**
* @brief 开启屏幕共享预览
* @details 开启屏幕共享预览并自动打开屏幕共享
* @param config 开启屏幕共享的配置
* @note 如果没有调用{@link setLocalViewConfig}设置显示的view，则无法预览，但不影响推流。
* 可以在{@link joinChannel}之前就开启预览会自动打开屏幕共享。
*/
startPreviewScreen(config?: AliRtcScreenShareStartConfig): Promise;
/**
* @brief 停止本地视频预览
*/
stopPreview(): Promise;
/**
* @brief 停止本地屏幕共享预览
*/
stopPreviewScreen(): Promise;
/**
* @brief 获取当前用户或远端用户的视频轨道
* @param {AliRtcVideoTrackConfig} config 视频轨道配置
* @return {MediaStreamTrack} 视频轨道
*
*/
getVideoTrack(config: AliRtcVideoTrackConfig): Promise;
/**
* @brief 开启旁路直播
* @details SDK提供了开启旁路直播的功能，可以把实时音视频流经过混流、混音处理转为标准直播流并推送至指定CDN供应商
* @param streamUrl 推流地址
* @param transcoding 推流所需参数, 详细定义见{@link AliRtcLiveTranscodingParam}
*/
startPublishLiveStream(streamUrl: string, transcoding: AliRtcLiveTranscodingParam): Promise;
/**
* @brief 更新旁路直播相关参数
* @details SDK提供了更新旁路直播的功能，用于实时更新旁路直播参数
* @param streamUrl 推流地址
* @param transcoding 推流所需参数, 详细定义见{@link AliRtcLiveTranscodingParam}
*/
updatePublishLiveStream(streamUrl: string, transcoding: AliRtcLiveTranscodingParam): Promise;
/**
* @brief 更新旁路直播相关参数
* @details SDK提供了更新旁路直播的功能，用于实时更新旁路直播参数
* @param taskId 任务Id
* @param transcoding 推流所需参数, 详细定义见{@link AliRtcLiveTranscodingParam}
* @return
* - 0 : 成功
* - 非0 : 失败
* - ERR_INNER(-1) : SDK内部错误，可能的情况为SDK未初始化或者SDK销毁后调用
* - 其他 : 返回值参考官网错误码
*/
updatePublishLiveStreamWithTaskId(taskId: string, transcoding: AliRtcLiveTranscodingParam): Promise;
/**
* @brief 停止旁路直播
* @details SDK提供了停止旁路直播的功能
* @param streamUrl 推流地址
*/
stopPublishLiveStream(streamUrl: string): Promise;
/**
* @brief 停止旁路直播
* @details SDK提供了停止旁路直播的功能
* @param taskId 任务Id
*/
stopPublishLiveStreamWithTaskId(taskId: string): Promise;
/**
* 获取旁路直播状态
* @param streamUrl 推流地址
* @return 路直播状态
*/
/**
* @brief 设置是否启用媒体扩展信息
* @param enabled 是否启用媒体扩展，需要在加入房间之前调用
*/
setEnableMediaExtensionMsg(enabled: boolean): void;
/**
* @brief 发送媒体扩展信息
* @details SDK提供了发送和接收媒体扩展信息的功能，接收端参考 {@link AliRtcEngineEventListener.mediaExtensionMsgReceived}，使用场景：
* - 使用媒体扩展信息传递时间戳，计算端到端的网络延迟，或者跟自身其他业务做数据同步
* - 使用媒体扩展信息传递描述信息。目前可以传递最多 4k Byte数据，可以用来传输少量数据，建议使用Json或者纯字符串；
* - 内部使用SEI扩展协议来实现；
*
* @param message 媒体扩展信息，长度限制为最大4K字节
* @param repeatCount 重复次数，代表消息冗余度，用于防止网络丢包导致的消息丢失，-1为无限传输
*
* @note 启用此能力会增加客户端性能开销，如有需求需要在加入房间之前调用 setEnableMediaExtensionMsg
* @note 使用媒体扩展信息时需要复用音视频数据通道，因此必须控制自定义消息的发送频率和消息数据长度，使用限制如下：
* - 每秒最多发送profile条消息，因为sei信息是放到h264/h265流中传输，有视频帧编码才能附加扩展信息；
* - 为了不影响媒体数据的传输质量，自定义消息体长度限制为4k Byte，可以用来传输少量信息；
* - sendMediaExtensionMsg函数中repeatCount参数为自定义消息冗余度，若大于1，则会发送多次，
* - 防止网络丢包导致的消息丢失，此时房间里的其他人也会收到多次相同的消息，需要去重
* - 发送的自定义消息，在旁路直播时，房间里的订阅者也一样会收到
* - 同一时间只有一条MediaExtensionMsg在传输，多次调用sendMediaExtensionMsg，新调用的数据会覆盖前一次的数据；
*/
sendMediaExtensionMsg(message: ArrayBuffer, repeatCount: number): Promise;
/**
* @brief 发送媒体扩展信息
* @details SDK提供了发送和接收媒体扩展信息的功能，接收端参考 {@link AliRtcEngineEventListener.mediaExtensionMsgReceived}，使用场景：
* - 使用媒体扩展信息传递时间戳，计算端到端的网络延迟，或者跟自身其他业务做数据同步
* - 使用媒体扩展信息传递描述信息。目前可以传递最多 4k Byte数据，可以用来传输少量数据，建议使用Json或者纯字符串；
* - 内部使用SEI扩展协议来实现；
*
* @param message 媒体扩展信息，长度限制为最大4K字节
* @param repeatCount 重复次数，代表消息冗余度，用于防止网络丢包导致的消息丢失，-1为无限传输
* @param payloadType [5, 100..254]范围 payloadType=5等于使用sendMediaExtensionMsg 接口
*
* @note 启用此能力会增加客户端性能开销，如有需求需要在加入房间之前调用 setEnableMediaExtensionMsg
* @note 使用媒体扩展信息时需要复用音视频数据通道，因此必须控制自定义消息的发送频率和消息数据长度，使用限制如下：
* - 每秒最多发送profile条消息，因为sei信息是放到h264/h265流中传输，有视频帧编码才能附加扩展信息；
* - 为了不影响媒体数据的传输质量，自定义消息体长度限制为4k Byte，可以用来传输少量信息；
* - sendMediaExtensionMsg函数中repeatCount参数为自定义消息冗余度，若大于1，则会发送多次，
* - 防止网络丢包导致的消息丢失，此时房间里的其他人也会收到多次相同的消息，需要去重
* - 发送的自定义消息，在旁路直播时，房间里的订阅者也一样会收到
* - 同一时间只有一条MediaExtensionMsg在传输，多次调用sendMediaExtensionMsg，新调用的数据会覆盖前一次的数据；
*/
sendMediaExtensionMsgEx(message: ArrayBuffer, repeatCount: number, payloadType: number): Promise;
static Plugin: typeof AliRtcPlugin;
/**
* @brief 开启音视频处理算法插件
* @details RTC采用插件件形式提供音视频增强及特效能力，可通过[官网组件文档](https://help.aliyun.com/document_detail/261183.html) 进行组件下载，参考插件集成文档集成进RTC引擎；
* @param plugin 插件库
* @param option 插件初始化参数值，请阅读插件库接入文档
* @note
* - 入会前入会后均可调用；
* - 如果重复调用会报错；
*/
enablePlugin(plugin: AliRtcPlugin, options?: any): void;
/**
* @brief 关闭音视频处理算法插件
* @param name 插件名称，通过 plugin.name 获取
* @note
* - 入会前入会后均可调用；
* - 重复调用返回错误；
*/
removePlugin(name: string): void;
/**
* @brief 根据插件ID设置插件
* @param name 插件名称，通过 plugin.name 获取
* @param option 插件初始化参数值，请阅读插件库接入文档
*/
setPluginOption(name: string, option: any): void;
/**
* @brief 根据插件ID获取插件内部信息
* @param name 插件名称，通过 plugin.name 获取
*/
getPluginOption(name: string): any;
/**
* 美颜功能是否有效
* @return
* - true: 美颜功能有效
* - false: 无效
*/
isBeautyAvailable(): boolean;
/**
* 美颜功能是否开启
* @return
* - true: 美颜功能已开启
* - false: 已关闭
*/
isBeautyEnabled(): boolean;
/**
* @brief 开启或关闭美颜功能, 并设置美颜效果参数
* @param enable
* - true: 开启美颜功能
* - false: 关闭美颜功能
* @param config 美颜效果参数
*/
setBeautyEffect(enable: boolean, config: AliRtcBeautyConfig): void;
/**
* @brief 开启/关闭虚拟背景替换功能
* @details 需要集成美颜插件；
* @param enable 是否开启；
* @param path 虚拟背景本地图片路径，支持JPG，PNG 格式；
*
* @note
* - 与背景虚化为替换关系，如开启虚拟背景开关后再次开启背景虚化，则只有背景虚化效果；
*/
enableBackgroundExchange(enable: boolean, path: string): void;
/**
* @brief 开启/关闭虚拟背景虚化功能
* @details 需要集成美颜插件；
* 需要集成美颜插件，背景替换与背景虚化不可同时使用，如开启虚拟背景开关后再次开启背景虚化，则只有背景虚化效果；
* @param enable 是否开启；
*
* @note
* - 与虚拟背景为替换关系，如开启背景虚化开关后再次开启虚拟背景，则只有虚拟背景效果；
*/
enableBackgroundBlur(enable: boolean): void;
setParameter(parameter: string): void;
getParameter(): string;
/**
* @brief 发送 DataChannel 消息
* @param dataChannelMsg 伴奏控制消息
*/
sendDataChannelMessage(dataChannelMsg: AliRtcDataChannelMsg): void;
}
declare interface AliRtcEngineConfig {
env?: AliRtcEnv;
webTrack?: boolean | AliRtcWebTrackConfig;
maxSignalingConnectRetryCount?: number;
}
declare interface AliRtcEngineEventListener {
/**
* @brief 网络连接状态改变
* @param status 连接状态
* @param reason 连接状态变化原因
*/
connectionStatusChange: (status: AliRtcConnectionStatus, reason: AliRtcConnectionStatusChangeReason) => void;
/**
* @brief 本地设备异常回调
* @param deviceType 设备类型, 参考{@link AliRtcEngine.AliRtcEngineLocalDeviceType}
* @param exceptionType 设备异常类型, 参考{@link AliRtcEngine.AliRtcEngineLocalDeviceExceptionType}
* @param msg 异常时携带的信息
* @note 此回调标识了内部无法恢复了设备异常，收到此回调时用户需要检查设备是否可用
*/
localDeviceException: (localDeviceType: AliRtcEngineLocalDeviceType, localDeviceExceptionType: AliRtcEngineLocalDeviceExceptionType, description: string) => void;
/**
* @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
* @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo}
*/
/**
* 被服务器踢出/会议结束频道的消息
* @param code 原因参考{@link AliRtcEngine.AliRtcOnByeType}
*/
bye: (code: AliRtcOnByeType) => void;
/**
* @brief 远端用户（通信模式）/（互动模式，主播角色）加入频道回调
* @details 该回调在以下场景会被触发
* - 通信模式：远端用户加入频道会触发该回调，如果当前用户在加入频道前已有其他用户在频道中，当前用户加入频道后也会收到已加入频道用户的回调
* - 互动模式：
* - 远端主播角色用户加入频道会触发该回调，如果当前用户在加入频道前已有其他主播在频道中，当前用户加入频道后也会收到已加入频道主播的回调
* - 远端观众角色调用 {@link AliRtcEngine.setClientRole} 切换为主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive}，同时设置了推流时，会触发该回调
*
* @param uid 用户ID，从App server分配的唯一标示符
* @param elapsed 用户加入频道时的耗时
* @note 互动模式下回调行为
* - 主播间可以互相收到加入频道回调
* - 观众可以收到主播加入频道回调
* - 主播无法收到观众加入频道回调
*/
remoteUserOnLineNotify: (uid: string, elapsed: number) => void;
/**
* @brief 远端用户（通信模式）/（互动模式，主播角色）离开频道回调
* @details 该回调在以下场景会被触发
* - 通信模式：远端用户离开频道会触发该回调
* - 互动模式：
* - 远端主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive} 离开频道
* - 远端主播切换调用 {@link AliRtcEngine.setClientRole} 切换为观众角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkLive}，会触发该回调
* - 通信模式和互动模式主播角色情况下，当长时间收不到远端用户数据，超时掉线时，会触发该回调
*
* @param uid 用户ID，从App server分配的唯一标示符
* @param reason 用户离线的原因，详见 {@link AliRtcEngine.AliRtcUserOfflineReason}
*/
remoteUserOffLineNotify: (uid: string, aliRtcUserOfflineReason: AliRtcUserOfflineReason) => void;
/**
* @brief 远端用户的音视频流发生变化回调
* @details 该回调在以下场景会被触发
* - 当远端用户从未推流变更为推流（包括音频和视频）
* - 当远端用户从已推流变更为未推流（包括音频和视频）
* - 互动模式下，调用 {@link AliRtcEngine.setClientRole} 切换为主播角色 {@link AliRtcEngine.AliRtcSdkClientRole.AliRtcSdkInteractive}，同时设置了推流时，会触发该回调
*
* @param uid 用户ID，从App server分配的唯一标示符
* @param audioTrack 音频流类型，详见 {@link AliRtcEngine.AliRtcAudioTrack}
* @param videoTrack 视频流类型，详见 {@link AliRtcEngine.AliRtcVideoTrack}
* @note 该回调仅在通信模式用户和互动模式下的主播角色才会触发
*/
remoteTrackAvailableNotify: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
/**
* @brief 远端用户静音/取消静音回调
* @param uid 远端用户ID
* @param isMute 该用户是否静音
* - true: 静音
* - false: 取消静音
*/
userAudioMuted: (uid: string, isMute: boolean) => void;
/**
* @brief 对端用户发送视频黑帧数据发送通知
* @param uid 执行muteVideo的用户ID
* @param isMute
* - true: 推流黑帧
* - false: 正常推流
* @note 该接口用于对端用户发送视频黑帧数据时的回调
*/
userVideoMuted: (uid: string, isMute: boolean) => void;
/**
* @brief 对端用户发送屏幕黑帧数据发送通知
* @param uid 执行muteVideo的用户ID
* @param isMute
* - true: 推流黑帧
* - false: 正常推流
* @note 该接口用于对端用户发送屏幕黑帧数据时的回调
*/
userScreenMuted: (uid: string, isMute: boolean) => void;
/**
* 音量反馈
* @param {Array} speakers 用户音量对象数组
* @param {string} speaker.userId 用户ID
* @param {number} speaker.volume 音量
* @note userId 为空字符串时代表是本地麦克风采集的音量
*/
audioVolume: (speakers: {
userId: string;
volume: number;
}[]) => void;
/**
* 发布视频流的数据统计
* @param aliRtcStats 统计信息
*/
aliRtcStats: (aliRtcStats: any) => void;
/**
* 音频推流变更回调
* @param track 流标识
* @param oldState 之前的推流状态
* @param newState 当前的推流状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
audioPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
/**
* 音频订阅情况变更回调
* @param uid 用户ID
* @param oldState 之前的订阅状态
* @param newState 当前的订阅状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
/**
* 视频推流变更回调
* @param oldState 之前的推流状态
* @param newState 当前的推流状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
videoPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
/**
* 次要流推流变更回调
* @param oldState 之前的推流状态
* @param newState 当前的推流状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
dualStreamPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
/**
* 屏幕分享推流变更回调
* @param oldState 之前的推流状态
* @param newState 当前的推流状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
screenSharePublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
/**
* DataChannel 推流变更回调
* @param oldState 之前的推流状态
* @param newState 当前的推流状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
dataPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number, channel: string) => void;
/**
* 相机流订阅情况变更回调
* @param uid 用户ID
* @param oldState 之前的订阅状态
* @param newState 当前的订阅状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
/**
* 大小流订阅情况变更回调
* @param uid 用户ID
* @param oldStreamType 之前的订阅状态
* @param newStreamType 当前的订阅状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
subscribeStreamTypeChanged: (uid: string, oldStreamType: AliRtcVideoStreamType, newStreamType: AliRtcVideoStreamType, elapseSinceLastState: number, channel: string) => void;
/**
* 屏幕分享流订阅情况变更回调
* @param uid 用户ID
* @param oldState 之前的订阅状态
* @param newState 当前的订阅状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
screenShareSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
/**
* DataChannel 订阅情况变更回调
* @param uid 用户ID
* @param oldState 之前的订阅状态
* @param newState 当前的订阅状态
* @param elapseSinceLastState 状态变更时间间隔(毫秒)
* @param channel 当前频道
*/
dataSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
/**
* 收到媒体扩展信息回调
* @param uid 用户ID，媒体信息发送用户的ID
* @param message 媒体扩展信息
* @param payloadType payload类型，sendMediaExtensionMsg返回5，sendMediaExtensionMsgEx发送的会返回具体类型
* @note 当一端通过 {@link AliRtcEngine.sendMediaExtensionMsg} 发送信息后，其他端通过该回调接收数据
*/
mediaExtensionMsgReceived: (uid: string, message: ArrayBuffer, payloadType: number) => void;
/**
* @brief 用户鉴权信息即将过期通知，收到后30秒鉴权过期
* @note 该回调在鉴权信息30秒前触发，收到该回调后应该及时更新鉴权信息，参考 {@link AliRtcEngine.refreshAuthInfo:}
*/
authInfoWillExpire: () => void;
/**
* @brief 用户调用需要鉴权的接口，服务端返回信息过期
* @note 该回调触发代表鉴权信息已过期，想要继续在会中，需要重新入会，参考 {@link AliRtcEngine.joinChannel:name:onResultWithUserId:}
*/
authInfoExpired: () => {};
/**
* 远程用户的音频自动播放失败
* @param uid
* @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
*/
remoteAudioAutoPlayFail: (uid: string) => void;
/**
* 远程用户的视频自动播放失败
* @param uid
* @note 应该在收到该回调时弹出弹窗引导用户点击页面进行播放，用户点击页面后 SDK 会自动尝试播放
*/
remoteVideoAutoPlayFail: (uid: string, videoTrack: AliRtcVideoTrack) => void;
/**
* 远程用户的音频播放出错
* @param uid 用户ID
* @param reason 出错原因，可选
*/
remoteAudioPlayError: (uid: string, reason: string | undefined) => void;
/**
* 远程用户的视频播放出错
* @param uid 用户ID
* @param reason 出错原因，可选
*/
remoteVideoPlayError: (uid: string, reason: string | undefined) => void;
/**
* rtc 传输数据统计
* @param stats 统计信息
*/
rtcStats: (stats: any) => void;
/**
* 发布视频流的数据统计
* @param aliRtcStats 统计信息
*/
rtcLocalVideoStats: (stats: AliRtcLocalVideoStats[]) => void;
/**
* 发布音频流的数据统计
* @param aliRtcStats 统计信息
*/
rtcLocalAudioStats: (stats: AliRtcLocalAudioStats[]) => void;
/**
* 订阅视频流的数据统计
* @param aliRtcStats 统计信息
*/
rtcRemoteVideoStats: (stats: AliRtcRemoteVideoStats[]) => void;
/**
* 订阅远端音频流的数据统计
* @param aliRtcStats 统计信息
*/
rtcRemoteAudioStats: (stats: AliRtcRemoteAudioStats[]) => void;
/**
* @brief 错误通知
* @deprecated 请使用 occurError
* @details 如果engine出现error，通过这个回调通知app
* @param error 错误类型，参考 {@link AliRtcError}
* @param uid 用户 Id，不一定存在
*/
onOccurError: (error: AliRtcError, uid?: string) => void;
/**
* @brief 错误通知
* @details 如果engine出现error，通过这个回调通知app
* @param error 错误类型，参考 {@link AliRtcError}
* @param uid 用户 Id，不一定存在
*/
occurError: (error: AliRtcError, uid?: string) => void;
/**
* @brief 收到数据通道消息
* @param uid 用户ID
* @param message 消息
*/
dataChannelMsg: (uid: string, message: AliRtcDataChannelMsg) => void;
}
export declare enum AliRtcEngineLocalDeviceExceptionType {
/** 未知异常类型 */
AliEngineLocalDeviceExceptionTypeUnknown = 0,
/** 麦克风打开失败 */
AliEngineLocalDeviceExceptionTypeMicOpenFail = 1,
/** 麦克风被打断 */
AliEngineLocalDeviceExceptionTypeMicInterrupt = 2,
/** 麦克风无权限 */
AliEngineLocalDeviceExceptionTypeMicAuthFail = 3,
/** 无可用麦克风 */
AliEngineLocalDeviceExceptionTypeMicNotAvailable = 4,
/** 扬声器打开失败 */
AliEngineLocalDeviceExceptionTypeSpeakerOpenFail = 5,
/** 扬声器被打断 */
AliEngineLocalDeviceExceptionTypeSpeakerInterrupt = 6,
/** 无可用扬声器 */
AliEngineLocalDeviceExceptionTypeSpeakerNotAvailable = 7,
/** 音频设备异常 */
AliEngineLocalDeviceExceptionTypeAudioDeviceException = 8,
/** 摄像头打开失败 */
AliEngineLocalDeviceExceptionTypeCameraOpenFail = 9,
/** 摄像头被打断 */
AliEngineLocalDeviceExceptionTypeCameraInterrupt = 10,
/** 摄像头无权限 */
AliEngineLocalDeviceExceptionTypeCameraAuthFail = 11,
/** 显示设备异常 */
AliEngineLocalDeviceExceptionTypeDisplayException = 12,
/** 视频设备异常 */
AliEngineLocalDeviceExceptionTypeVideoDeviceException = 13
}
export declare enum AliRtcEngineLocalDeviceType {
/** 未知设备类型 */
AliEngineLocalDeviceTypeUnknown = 0,
/** 麦克风设备 */
AliEngineLocalDeviceTypeMic = 1,
/** 扬声器设备 */
AliEngineLocalDeviceTypeSpeaker = 2,
/** 音频设备 */
AliEngineLocalDeviceTypeAudioDevice = 3,
/** 摄像头设备 */
AliEngineLocalDeviceTypeCamera = 4,
/** 显示设备 */
AliEngineLocalDeviceTypeDisplay = 5,
/** 视频设备 */
AliEngineLocalDeviceTypeVideoDevice = 6
}
declare enum AliRtcEnv {
pre = "pre",
prod = "prod"
}
declare class AliRtcError extends Error {
_code: number;
_extra?: any;
static fromRtsError(error: any): AliRtcError;
static fromError(error: any, code?: number, fallbackMessage?: string): AliRtcError;
constructor(code: number, message: string, extra?: any);
get code(): number;
set code(code: number);
get reason(): string;
get extra(): any;
}
export declare enum AliRtcErrorCode {
/****************************************************
* 入会错误码
****************************************************/
/** 已经加入频道 */
ERR_JOIN_ALREADY_JOINED = 16843521,
/** AppId不存在，请在控制台创建应用 */
ERR_JOIN_BAD_APPID = 33620481,
/** AppId已失效，请在控制台重新启用应用 */
ERR_JOIN_INVALID_APPID = 33620482,
/**
* 频道不存在，请尝试重新加入频道
* 如会议发起者入会后又很快离会，第二个人随后入会，发现会议已经不存在了。
*/
ERR_JOIN_BAD_CHANNEL = 33620484,
/** 频道已经失效（目前频道有效期为48小时），请重新生成频道鉴权令牌（Token） */
ERR_JOIN_INVALID_CHANNEL = 33620483,
/** Token无效。 请重新生成频道鉴权令牌（Token） */
ERR_JOIN_BAD_TOKEN = 33620485,
/** 加入频道超时，请检查网络连接是否正常 */
ERR_JOIN_TIMEOUT = 16908804,
/** 参数错误，{@link AliRtcAuthInfo}中的字段为空或者timestamp<=0，请检查字段是否完整 */
ERR_JOIN_ERR_JOIN_BAD_PARAMBAD = 16974081,
/** 加入频道失败 */
ERR_JOIN_CHANNEL_FAILED = 16974338,
/****************************************************
* 日志模块错误码
****************************************************/
/** 日志模块已经初始化 */
ERR_LOG_ALREADY_INIT = 16974085,
/** 日志模块根路径错误，请检查路径是否存在或路径是否具有写入权限 */
ERR_LOG_ROOT_PATH_ERROR = 16974086,
/****************************************************
* 音频设备错误码
****************************************************/
/**
* 采集设备初始化失败、采集设备媒体服务异常、音频设备被占用。
* - Mac端和Windows端查看系统设置中音频设备是否有能量条
* - iOS端和Android端确认是否被其他应用占用
* - 如果都正常，请重启设备
*/
ERR_MIC_OPEN_FAIL = 17040388,
/**
* 播放设备初始化失败、播放设备媒体服务异常、音频设备被占用。
* - Mac端和Windows端查看系统设置中音频设备是否有能量条
* - iOS端和Android端确认是否被其他应用占用
* - 如果都正常，请重启设备
*/
ERR_SPEAKER_OPEN_FAIL = 17040389,
/** 系统性能不足、采集设备媒体服务异常、音频设备被占用。建议重启应用或重启设备 */
ERR_MIC_INTERRUPT = 17040390,
/** 系统性能不足，播放设备媒体服务异常，音频设备被占用。建议重启应用或重启设备 */
ERR_SPEAKER_INTERRUPT = 17040391,
/** 麦克风设备未授权，建议去系统设置中，打开麦克风授权，并且重新加入频道 */
ERR_MIC_AUTH_FAIL = 17040392,
/** 无可用的音频采集设备，检查是否接入了可用的麦克风，并检查系统设置中，该设备是否被禁用 */
ERR_MIC_NOT_AVAILABLE = 17040393,
/** 无可用的音频播放设备，检查是否接入了可用的扬声器或耳机，并检查系统设置中，该设备是否被禁用 */
ERR_SPEAKER_NOT_AVAILABLE = 17040400,
/****************************************************
* 视频设备错误码
****************************************************/
/** 采集设备初始化失败，检查系统相机是否可用，移动端App是否占用了相机 */
ERR_CAMERA_OPEN_FAIL = 17039620,
/** 采集设备未授权，建议去系统设置中，打开摄像头授权，并且重新加入频道 */
ERR_CAMERA_AUTH_FAIL = 17039621,
/** 采集过程中出现异常，Mac、Winodows电脑相机采集灯熄灭，设备被强制中断。建议重新加入频道或者重启App */
ERR_CAMERA_INTERRUPT = 17039622,
/** 无可用的视频采集设备，检查是否接入了可用的摄像头，并检查系统设置中，该设备是否被禁用 */
ERR_CAMERA_NOT_AVAILABLE = 17039623,
/** 渲染设备初始化失败，检查Windows端显卡驱动是否需要升级，移动端手机型号或者Android平板盒子等外设是否支持OpenGL */
ERR_VIDEO_DISPLAY_OPEN_FAIL = 17039873,
/** 渲染过程中出现异常，系统异常错误导致渲染引擎报错，重新加入频道或者重启App */
ERR_VIDEO_DISPLAY_INTERRUPT = 1064992,
/****************************************************
* 网络错误码
****************************************************/
/** 媒体通道建立失败，检查网络连接是否正常 */
ERR_ICE_CONNECTION_CONNECT_FAIL = 17105409,
/** 媒体通道重连失败，检查网络连接是否正常 */
ERR_ICE_CONNECTION_RECONNECT_FAI = 17105410,
/** 媒体通道mobility失败，应用层需要重走入会流程 */
ERR_ICE_CONNECTION_MOBILITY_FAIL = 17105411,
/** 信令心跳超时，检查网络连接是否正常 */
ERR_ICE_CONNECTION_HEARTBEAT_TIMEOUT = 16908812,
/**
* 低延时互动直播模式相关错误码
*/
/** 低延时互动直播信令失败 */
ERR_LATENCY_LIVE_COMMUNICATION_FAILED = 17235971,
/** 低延时互动直播媒体设置错误 */
ERR_LATENCY_LIVE_MEIDASETTING_FAILED = 17235972,
/** 低延时互动直播当前房间没有主播推流 */
ERR_LATENCY_LIVE_NONE_BROADCASTER = 17235973,
/** 低延时互动直播错误，应用层需要重新创建新的SDK实例 */
ERR_LATENCY_LIVE_NEED_RESTART = 17235974,
/** 低延时互动直播错误，应用层需要稍等一定时间（自定义间隔）重新创建新的SDK实例 */
ERR_LATENCY_LIVE_NEED_RESTART_AGAIN_LATER = 17235975,
/** 低延迟互动直播服务不可用或者服务降级，客户端应该选择其它方式拉超大方会流，即不从cdn sfu拉流 */
ERR_LATENCY_LIVE_SERVICE_UNAVAILABLE = 17235976,
/** 低延迟互动直播网络中断错误，销毁当前sdk实例重新创建sdk后重新走订阅流程 */
ERR_LATENCY_LIVE_MEDIACONNECTION_INTERRUPTION = 17235977,
/****************************************************
* 推流相关错误码
****************************************************/
/** 推流无效 */
ERR_SDK_PUBLISH_INVAILD = 16974597,
/** 未进入频道推流失败 */
ERR_SDK_PUBLISH_NOT_JOIN_CHANNEL = 16843782,
/** 推送音频流失败 */
ERR_SDK_PUBLISH_AUDIO_STREAM_FAILED = 16843856,
/** 推送视频流失败 */
ERR_SDK_PUBLISH_VIDEO_STREAM_FAILED = 16843857,
/** 推送小流失败 */
ERR_SDK_PUBLISH_DUAL_STREAM_FAILED = 16843858,
/** 推送屏幕共享失败 */
ERR_SDK_PUBLISH_SCEEN_SHARE_FAILED = 16843859,
/** 屏幕共享配置错误 */
ERR_SDK_PUBLISH_SCREEN_SHARE_CONFIG_ERROR = 16843860,
/****************************************************
* 订阅相关错误码
****************************************************/
/** 订阅无效 */
ERR_SDK_SUBSCRIBE_INVAILD = 16974852,
/** 未进入频道订阅错误 */
ERR_SDK_SUBSCRIBE_NOT_JOIN_CHANNEL = 16844112,
/** 订阅音频流失败 */
ERR_SDK_SUBSCRIBE_AUDIO_STREAM_FAILED = 16844113,
/** 订阅视频流失败 */
ERR_SDK_SUBSCRIBE_VIDEO_STREAM_FAILED = 16844114,
/** 订阅小流失败 */
ERR_SDK_SUBSCRIBE_DUAL_STREAM_FAILED = 16844115,
/** 订阅屏幕共享失败 */
ERR_SDK_SUBSCRIBE_SCREEN_SHARE_FAILED = 16844116,
/** 订阅 DataChannel 失败 */
ERR_SDK_SUBSCRIBE_DATA_FAILED = 16844117,
/** 订阅 DataChannel 过程中报错 */
ERR_SDK_SUBSCRIBE_DATA_ERROR = 16844118,
/****************************************************
* 其他错误码
****************************************************/
/** SDK状态错误，建议销毁SDK重新创建实例。 */
ERR_SDK_INVALID_STATE = 16974340,
/** 参数不匹配 */
ERR_INVALID_ARGUMENTS = 16974083,
/** Session已经被移除，建议销毁实例之后重新创建实例并加入频道。 */
ERR_SESSION_REMOVED = 33620229,
/** 互动模式下设置角色错误 */
ERR_SDK_UPDATE_ROLE_CHANNEL = 16908801,
/** SDK内部错误 */
ERR_INNER = -1,
/************************************************************************************/
/******************************** 旁路直播错误码 start ********************************/
/************************************************************************************/
/**
* MPU任务发布成功
*/
ERR_SDK_MPU_TASK_PUBLISH_OK = 0,
/**
* MPU任务流未找到
*/
ERR_SDK_MPU_TASK_STREAM_NOT_FOUND = 17825793,
/**
* MPU任务流已存在
*/
ERR_SDK_MPU_TASK_STREAM_ALREADY_EXIST = 17825794,
/**
* MPU任务无效参数
*/
ERR_SDK_MPU_TASK_INVALID_PARAM = 17825795,
/**
* MPU任务内部错误
*/
ERR_SDK_MPU_TASK_INTERNAL_ERROR = 17825796,
/**
* MPU任务rtmp服务错误
*/
ERR_SDK_MPU_TASK_RTMP_SERVER_ERROR = 17825797,
/**
* MPU任务rtmp流地址错误
*/
ERR_SDK_MPU_TASK_RTMP_STREAM_URL_ERROR = 17825798,
/**
* MPU任务发布超时
*/
ERR_SDK_MPU_TASK_PUBLISH_TIMEOUT = 17825799,
/**
* MPU任务发布成功
*/
ERR_SDK_MPU_TASK_NOT_AUTHORIZED = 17825800,
/************************************************************************************/
/******************************** 旁路直播错误码 end ********************************/
/************************************************************************************/
/************************************************************************************/
/******************************** 跨频道转推错误码 start ******************************/
/************************************************************************************/
/**
* 检测到本地状态不对，没入会，角色错误，频道模式错误
*/
ERR_SDK_CHANNEL_RELAY_STATE_ERROR = 18874369,
/**
* 服务端返回436，源通道模式不匹配
*/
ERR_SDK_CHANNEL_RELAY_SRC_NOT_ALLOW = 18874370,
/**
* 服务端返回437，目标通道不存在或者模式不匹配
*/
ERR_SDK_CHANNEL_RELAY_JOIN_DEST_FAILED = 18874371,
/**
* 服务端返回438，token无效
*/
ERR_SDK_CHANNEL_RELAY_TOKEN_INVALID = 18874372,
/**
* 服务端返651，session不是主播
*/
ERR_SDK_CHANNEL_RELAY_ROLE_ERROR = 18874373,
/**
* 服务端400，参数错误
*/
ERR_SDK_CHANNEL_RELAY_INVALID_PARAM = 18874374,
/**
* 服务端返回440，不能转推到本频道
*/
ERR_SDK_CHANNEL_RELAY_TO_SELF_ERROR = 18874375
}
declare class AliRtcLiveTranscoding {
authInfo?: AliRtcAuthInfo;
private slsReporter;
constructor(slsReporter: SLSReporter);
private doRequest;
setAuthInfo(authInfo: AliRtcAuthInfo): void;
clear(): void;
startPublishLiveStream(streamUrl: string, transcodingParam: AliRtcLiveTranscodingParam): Promise;
startPublishLiveStreamWithTaskId(taskId: string, transcodingParam: AliRtcLiveTranscodingParam): Promise;
updatePublishLiveStream(streamUrl: string, transcodingParam: AliRtcLiveTranscodingParam): Promise;
updatePublishLiveStreamWithTaskId(taskId: string, transcodingParam: AliRtcLiveTranscodingParam): Promise;
stopPublishLiveStream(streamUrl: string): Promise;
stopPublishLiveStreamWithTaskId(taskId: string): Promise;
refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): void;
}
export declare enum AliRtcLiveTranscodingAudioSampleRate {
LiveTranscoding_HZ_48000 = 48000,
LiveTranscoding_HZ_44100 = 44100,
LiveTranscoding_HZ_32000 = 32000,
LiveTranscoding_HZ_16000 = 16000,
LiveTranscoding_HZ_8000 = 8000
}
export declare enum AliRtcLiveTranscodingCropMode {
/*! 缩放模式 */
LiveTranscodingOrigin = 0,
/*! 剪裁 */
LiveTranscodingCrop = 1,
/*! 填充 */
LiveTranscodingFill = 2
}
export declare class AliRtcLiveTranscodingEncodeParam {
videoWidth: number;
videoHeight: number;
videoFramerate: number;
videoBitrate: number;
videoGop: number;
audioSamplerate: AliRtcLiveTranscodingAudioSampleRate;
audioBitrate: number;
audioChannels: number;
constructor(videoWidth: number, videoHeight: number, videoFramerate?: number, videoBitrate?: number, videoGop?: number, audioSamplerate?: AliRtcLiveTranscodingAudioSampleRate, audioBitrate?: number, audioChannels?: number);
}
export declare enum AliRtcLiveTranscodingErrorCode {
LiveTranscodingErrorPublishOk = 0,
LiveTranscodingErrorStreamNotFound = 17825793,
LiveTranscodingErrorStreamAlreadyExist = 17825794,
LiveTranscodingErrorInvalidParam = 17825795,
LiveTranscodingErrorInternalError = 17825796,
LiveTranscodingErrorRtmpServerError = 17825797,
LiveTranscodingErrorRtmpStreamUrlError = 17825798,
LiveTranscodingErrorPublishTimeout = 17825799,
LiveTranscodingErrorNotAuthorized = 17825800
}
export declare enum AliRtcLiveTranscodingFontType {
NOTO_SERIF_CJKSC_REGULAR = 0,
ALIBABA_PUHUITI_REGULAR = 1,
ALIBABA_PUHUITI_BOLD = 2,
ALIBABA_PUHUITI_Heavy = 3,
ALIBABA_PUHUITI_LIGHT = 4,
ALIBABA_PUHUITI_MEDIUM = 5
}
export declare enum AliRtcLiveTranscodingMediaProcessMode {
/*! 通用模式 */
LiveTranscodingNormal = 0,
/*! 虚拟背景模式 */
LiveTranscodingVirtualBackground = 1
}
export declare enum AliRtcLiveTranscodingMixMode {
/*! 单路模式 */
LiveTranscodingSingle = 0,
/*! 混流模式 */
LiveTranscodingMix = 1
}
export declare class AliRtcLiveTranscodingMixParam {
taskProfile: AliRtcLiveTranscodingTaskProfile;
encodeParam?: AliRtcLiveTranscodingEncodeParam;
users: AliRtcTranscodingUser[];
backgroundColor: number;
backgrounds: AliRtcTranscodingImage[];
watermarks: AliRtcTranscodingImage[];
clockWidgets: AliRtcTranscodingClockWidget[];
cropMode?: AliRtcLiveTranscodingCropMode;
mediaProcessMode?: AliRtcLiveTranscodingMediaProcessMode;
constructor(taskProfile: AliRtcLiveTranscodingTaskProfile);
}
export declare class AliRtcLiveTranscodingParam {
/*! 旁路模式 */
mixMode: AliRtcLiveTranscodingMixMode;
/*! 路模式单路参数 */
singleParam?: AliRtcLiveTranscodingSingleParam;
/*! 旁路模式混流参数 */
mixParam?: AliRtcLiveTranscodingMixParam;
constructor(mixMode?: AliRtcLiveTranscodingMixMode, singleParam?: AliRtcLiveTranscodingSingleParam, mixParam?: AliRtcLiveTranscodingMixParam);
toJson(type: MPU_TASK_TRANSACTION_TYPE, authInfo: AliRtcAuthInfo, taskId: string, streamUrl?: string, messageId?: string): {
[key: string]: any;
};
}
export declare enum AliRtcLiveTranscodingSegmentType {
/*! 无人像分割 */
LiveTranscodingNoBody = 0,
/*! 人像分割 */
LiveTranscodingBody = 1
}
export declare class AliRtcLiveTranscodingSingleParam {
userId?: string;
streamType?: AliRtcLiveTranscodingStreamType;
sourceType?: AliRtcLiveTranscodingSourceType;
constructor(uid?: string, streamType?: AliRtcLiveTranscodingStreamType, sourceType?: AliRtcLiveTranscodingSourceType);
}
export declare enum AliRtcLiveTranscodingSourceType {
/*! 相机流 */
LiveTranscodingCamera = 0,
/*! 屏幕流 */
LiveTranscodingShareScreen = 1
}
export declare enum AliRtcLiveTranscodingState {
LiveTranscodingState_IDLE = 0,
LiveTranscodingState_CONNNECT = 1,
LiveTranscodingState_RUNNING = 2,
LiveTranscodingState_RECOVERING = 3,
LiveTranscodingState_FAILURE = 4,
LiveTranscodingState_END = 5
}
export declare enum AliRtcLiveTranscodingStreamType {
/*! 原始流 */
LiveTranscodingOrigin = 0,
/*! 音频 */
LiveTranscodingAudio = 1,
/*! 视频 */
LiveTranscodingVideo = 2
}
export declare enum AliRtcLiveTranscodingTaskProfile {
LiveTranscoding_Profile_1IN_1080P = 0,
LiveTranscoding_Profile_1IN_720P = 1,
LiveTranscoding_Profile_1IN_360P = 2,
LiveTranscoding_Profile_2IN_1080P = 3,
LiveTranscoding_Profile_2IN_720P = 4,
LiveTranscoding_Profile_2IN_360P = 5,
LiveTranscoding_Profile_4IN_1080P = 6,
LiveTranscoding_Profile_4IN_720P = 7,
LiveTranscoding_Profile_4IN_360P = 8,
LiveTranscoding_Profile_9IN_1080P = 9,
LiveTranscoding_Profile_9IN_720P = 10,
LiveTranscoding_Profile_9IN_360P = 11,
LiveTranscoding_Profile_12IN_1080P = 12,
LiveTranscoding_Profile_12IN_720P = 13,
LiveTranscoding_Profile_12IN_360P = 14,
LiveTranscoding_Profile_16IN_1080P = 15,
LiveTranscoding_Profile_16IN_720P = 16,
LiveTranscoding_Profile_16IN_360P = 17,
LiveTranscoding_Profile_Mixed = 9999
}
declare interface AliRtcLocalAudioStats {
track: AliRtcAudioTrack;
stats: any;
}
export declare class AliRtcLocalStreamInfo extends default_2 {
type: AliRtcRawDataStreamType;
originVideoTrack?: MediaStreamTrack;
videoSource?: VideoStreamSource;
private _videoMuted;
originAudioTrack?: MediaStreamTrack;
audioSource?: AudioStreamSource;
private _audioMuted;
private _targetVideoTrack?;
private _targetDualVideoTrack?;
private _targetAudioTrack?;
private _publishVideoStream?;
private _publishDualVideoStream?;
private _publishAudioStream?;
private _previewStream?;
plugins: AliRtcPlugin[];
private _profileManager?;
cameraVideoConstraints?: IVideoConstraints;
micAudioConstraints?: IAudioConstraints;
private get profileManager();
get audioProfile(): AudioProfileKey | undefined;
constructor(type: AliRtcRawDataStreamType);
private onVideoTrackEnded;
private onAudioTrackEnded;
updateSource(newStream: LocalStream, newVideoSource?: VideoStreamSource, newAudioSource?: AudioStreamSource): Promise;
get currentProfile(): string | undefined;
get currentVideoTrack(): MediaStreamTrack | undefined;
get currentDualVideoTrack(): MediaStreamTrack | undefined;
get publishVideoStream(): LocalStream | undefined;
get publishDualVideoStream(): LocalStream | undefined;
get currentAudioTrack(): MediaStreamTrack | undefined;
get publishAudioStream(): LocalStream | undefined;
get previewStream(): LocalStream | undefined;
/**
* 更新 VideoTrack
* @param videoTrack
*/
updateVideoTrack(videoTrack?: MediaStreamTrack, force?: boolean): Promise;
/**
* 更新 DualVideoTrack
* @param videoTrack
* @param force
*/
updateDualVideoTrack(videoTrack?: MediaStreamTrack, force?: boolean): Promise;
/**
* 更新 AudioTrack
* @param audioTrack
*/
updateAudioTrack(audioTrack?: MediaStreamTrack, force?: boolean): Promise;
/**
* 设置音频流静音
* @param muted
*/
setAudioMuted(muted: boolean): void;
get isAudioMuted(): boolean;
/**
* 设置视频流静音
* @param muted
*/
setVideoMuted(muted: boolean): void;
get isVideoMuted(): boolean;
process(localStreamInfos: AliRtcLocalStreamInfo[]): Promise;
/**
* 停止视频流
*/
stopVideo(): void;
/**
* 停止音频流
*/
stopAudio(): void;
/**
* 停止视频流和音频流
*/
stop(): void;
/**
* 应该在执行完 plugin 后调用
* @param profileName
* @param profileValue
*/
updateVideoProfile(profileName?: string, profileValue?: Partial, skipConstraints?: boolean): Promise;
get videoProfile(): string | undefined;
setVideoContentHint(hint?: string): void;
/**
* 应该在执行完 plugin 后调用
* @param profileName
*/
updateAudioProfile(profileKey: AudioProfileKey): Promise;
/**
* 复制视频 profile 到指定 LocalStream
* @param publishStream
*/
cloneVideoProfile(publishStream: LocalStream): Promise;
addPlugin(plugin: AliRtcPlugin): void;
removePlugin(plugin: AliRtcPlugin): boolean;
}
declare interface AliRtcLocalStreamListener {
videotrackended: () => void;
audiotrackended: () => void;
}
declare interface AliRtcLocalVideoStats {
track: AliRtcVideoTrack;
streamType?: AliRtcVideoStreamType;
stats: any;
}
declare type AliRtcLocalView = string | HTMLVideoElement | string[] | HTMLVideoElement[] | null;
export declare enum AliRtcLogLevel {
DEBUG = 0,
INFO = 1,
API = 2,
WARNING = 3,
ERROR = 4,
NONE = 5
}
/**
* @brief OnBye类型枚举
*/
declare enum AliRtcOnByeType {
/** 当前user被踢出channel */
AliRtcOnByeBeKickedOut = 1,
/** channel已结束，需要离开会议 */
AliRtcOnByeChannelTerminated = 2,
/** 相同userID在其他设备joinChannel，当前设备被下线 */
AliRtcOnByeUserReplaced = 3
}
export declare abstract class AliRtcPlugin extends default_2 {
name: string;
options: any;
type: AliRtcPluginType;
streamType: AliRtcRawDataStreamType;
trackType: AliRtcPluginTrackType;
zIndex: number;
private _isEnable;
lastInputAudioTrack?: MediaStreamTrack;
lastOutputAudioTrack?: MediaStreamTrack;
lastInputVideoTrack?: MediaStreamTrack;
lastOutputVideoTrack?: MediaStreamTrack;
private _hasCleared;
constructor(name: string, streamType?: AliRtcRawDataStreamType, trackType?: AliRtcPluginTrackType);
get initOptions(): {};
getOptions(): any;
abstract setOptions(options: any): void;
abstract isSupported(version: string): boolean;
init(): Promise;
enable(): void;
disable(): void;
get isEnable(): boolean;
protected audioUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
protected videoUpdated(streamInfo: AliRtcLocalStreamInfo): boolean;
execute(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): Promise;
abstract shouldUpdate(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): boolean;
abstract process(streamInfo: AliRtcLocalStreamInfo, streamInfos: AliRtcLocalStreamInfo[]): Promise;
clear(_streamInfo?: AliRtcLocalStreamInfo): void;
}
declare interface AliRtcPluginListener {
enabled: () => void;
disabled: () => void;
updated: () => void;
ready: () => void;
overload: (info: any) => void;
error: (error: any) => void;
unsupported: () => void;
}
export declare enum AliRtcPluginTrackType {
AUDIO = 0,
VIDEO = 1,
BOTH = 2
}
export declare enum AliRtcPluginType {
PRE_PROCESSOR = 0,
POST_PROCESSOR = 1
}
export declare enum AliRtcPublishState {
/** 0: SDK初始推流状态 */
AliRtcStatePublishIdle = 0,
/** 1: 未推流状态，可能是因为:
* - 已设置停止推送媒体流
* - 推送媒体流失败
*/
AliRtcStateNoPublish = 1,
/** 2: 推流链接建立过程中 */
AliRtcStatePublishing = 2,
/** 3: 推流成功 */
AliRtcStatePublished = 3
}
export declare enum AliRtcRawDataStreamType {
/** 相机流 */
AliRtcSdkStreamTypeCapture = 0,
/** 屏幕共享流 */
AliRtcSdkStreamTypeScreen = 1
}
export declare type AliRtcRefreshAuthInfo = Pick;
declare interface AliRtcRemoteAudioStats {
uid: string;
track: AliRtcAudioTrack;
stats: any;
}
export declare class AliRtcRemoteUserInfo {
private remoteUser;
constructor(remoteUser: RemoteUser);
get userId(): string;
get displayName(): string;
get isMuteAudioPlaying(): boolean;
get hasAudio(): boolean;
get hasCamera(): boolean;
get hasCameraLarge(): boolean;
get hasCameraSmall(): boolean;
get hasScreenShare(): boolean;
get isAudioSubscribing(): boolean;
get isVideoSubscribing(): boolean;
get isVideoLargeSubscribing(): boolean;
get isVideoSmallSubscribing(): boolean;
get isScreenSubscribing(): boolean;
get audioElement(): HTMLAudioElement | undefined;
}
declare interface AliRtcRemoteVideoStats {
uid: string;
track: AliRtcVideoTrack;
streamType?: AliRtcVideoStreamType;
stats: any;
}
declare interface AliRtcScreenShareConfiguration {
frameRate?: number;
bitrate?: number;
}
declare interface AliRtcScreenShareStartConfig {
audio?: boolean;
videoTrack?: MediaStreamVideoTrack;
audioTrack?: MediaStreamAudioTrack;
}
export declare enum AliRtcSdkChannelProfile {
/** 普通通信模式 */
AliRtcSdkCommunication = "communication",
/** 直播模式(大方会模式) */
AliRtcSdkInteractiveLive = "interactive_live",
/** 低延迟互动直播模式 */
AliRtcSdkInteractiveWithLowLatencyLive = "cdn_live"
}
export declare enum AliRtcSdkClientRole {
/** 互动角色 */
AliRtcSdkInteractive = "interactive",
/** 观众角色 */
AliRtcSdkLive = "live"
}
/** 角色鉴权 主播pub｜观众sub｜转推流鉴权（跨房间转推中使用）relay */
declare type AliRtcSdkTokenRole = 'pub' | 'sub' | 'relay';
export declare enum AliRtcSubscribeState {
/** 初始状态 */
AliRtcStateSubscribeIdle = 0,
/** 未订阅 */
AliRtcStateNoSubscribe = 1,
/** 订阅中 */
AliRtcStateSubscribing = 2,
/** 已订阅 */
AliRtcStateSubscribed = 3
}
export declare class AliRtcTranscodingClockWidget {
x: number;
y: number;
fontSize: number;
zOrder: number;
fontColor: number;
fontType: AliRtcLiveTranscodingFontType;
constructor(x: number, y: number, fontSize: number);
constructor(x: number, y: number, fontSize: number, zOrder: number);
constructor(x: number, y: number, fontSize: number, zOrder: number, fontColor: number);
constructor(x: number, y: number, fontSize: number, zOrder: number, fontColor: number, fontType: AliRtcLiveTranscodingFontType);
toJson(videoWidth: number, videoHeight: number): {
x: number;
y: number;
fonttype: AliRtcLiveTranscodingFontType;
fontsize: number;
fontcolor: number;
zorder: number;
};
}
export declare class AliRtcTranscodingImage {
static DisplayType: typeof DisplayType;
url: string;
x: number;
y: number;
width: number;
height: number;
alpha: number;
display: DisplayType;
zOrder: number;
constructor(url: string, x: number, y: number, width: number, height: number);
constructor(url: string, x: number, y: number, width: number, height: number, zOrder: number);
constructor(url: string, x: number, y: number, width: number, height: number, zOrder: number, alpha: number);
constructor(url: string, x: number, y: number, width: number, height: number, zOrder: number, alpha: number, display: DisplayType);
toJson(videoWidth: number, videoHeight: number): {
url: string;
alpha: number;
display: DisplayType;
x: number;
y: number;
width: number;
height: number;
zorder: number;
};
}
export declare class AliRtcTranscodingText {
text: string;
x: number;
y: number;
fontSize: number;
zOrder: number;
fontColor: number;
fontType: AliRtcLiveTranscodingFontType;
constructor(text: string, x: number, y: number, fontSize: number);
constructor(text: string, x: number, y: number, fontSize: number, zOrder: number);
constructor(text: string, x: number, y: number, fontSize: number, zOrder: number, fontColor: number);
constructor(text: string, x: number, y: number, fontSize: number, zOrder: number, fontColor: number, fontType: AliRtcLiveTranscodingFontType);
toJson(videoWidth: number, videoHeight: number): {
text: string;
x: number;
y: number;
fonttype: AliRtcLiveTranscodingFontType;
fontsize: number;
fontcolor: number;
zorder: number;
};
}
export declare class AliRtcTranscodingUser {
userId: string;
x: number;
y: number;
width: number;
height: number;
zOrder?: number;
sourceType?: AliRtcLiveTranscodingSourceType;
segmentType: AliRtcLiveTranscodingSegmentType;
images: AliRtcTranscodingImage[];
texts: AliRtcTranscodingText[];
constructor(userId: string, x: number, y: number, width: number, height: number);
constructor(userId: string, x: number, y: number, width: number, height: number, zOrder: number);
constructor(userId: string, x: number, y: number, width: number, height: number, zOrder: number, sourceType: AliRtcLiveTranscodingSourceType);
toJson(index: number, videoWidth: number, videoHeight: number, mediaProcessMode?: AliRtcLiveTranscodingMediaProcessMode): {
[key: string]: any;
};
}
export declare enum AliRtcTrascodingPublishTaskStatus {
/*! 任务开始 */
TrascodingPublishTaskStatusStart = 0,
/*! 任务更新 */
TrascodingPublishTaskStatusUpdate = 1,
/*! 任务已停止 */
TrascodingPublishTaskStatusStop = 2
}
declare enum AliRtcUserOfflineReason {
/** 用户主动离开 */
AliRtcUserOfflineQuit = 0,
/** 因过长时间收不到对方数据包，超时掉线 */
AliRtcUserOfflineDropped = 1,
/** 用户身份从主播切换为观众时触发 */
AliRtcUserOfflineBecomeAudience = 2
}
export declare enum AliRtcVideoStreamType {
/** 无，在OnSubscribeStreamTypeChanged回调表示当前未订阅 */
AliRtcVideoStreamTypeNone = 0,
/** 高码率，高分辨率流（大流） */
AliRtcVideoStreamTypeHigh = 1,
/** 低码率，低分辨率流（小流） */
AliRtcVideoStreamTypeLow = 2
}
export declare enum AliRtcVideoTrack {
/** 无视频流 **/
AliRtcVideoTrackNo = 0,
/** 相机流 **/
AliRtcVideoTrackCamera = 1,
/** 屏幕共享流 **/
AliRtcVideoTrackScreen = 2,
/** 相机流和屏幕共享流 **/
AliRtcVideoTrackBoth = 3
}
declare interface AliRtcVideoTrackConfig {
userId?: string;
streamType: AliRtcRawDataStreamType;
}
declare interface AliRtcWebTrackConfig {
biz: string;
extraParams?: string;
}
declare class AudioLevelMonitor extends default_2 {
private audioContext;
private stream;
private sourceNode?;
private analyser?;
constructor();
getLevel(): number;
/**
* 开启监听 audio level 的变化
*
* @param {MediaStreamTrack} track 音频轨
* @param {number} [interval=1000] 检测间隔，单位毫秒，默认 1000ms
*/
start(track: MediaStreamTrack, interval?: number): void;
stop(): void;
dispose(): void;
}
declare interface AudioLevelMonitorListener {
audioLevel: (level: number) => void;
}
declare interface AudioMixerPluginOptions {
audio?: number;
screen?: number;
}
/**
* ------------------ 模式 ----- 采样率 ----- 声道 ----- 码率（kbps） -----
*
* standard: 标准音质 48000 单声道 64
*
* high: 高音质 48000 单声道 128
*
* standard-stereo: 立体声音质 48000 双声道 80
*
* high-stereo: 立体声高音质 48000 双声道 192
*/
declare type AudioProfileKey = 'standard' | 'high' | 'standard-stereo' | 'high-stereo';
declare enum AudioStreamSource {
Microphone = 0,
Screen = 1,
Mixed = 2
}
declare class BizControl extends default_2 {
/**
* @ignore
*/
static logName: string;
protected self: LocalUser;
protected userMap: RemoteUserMap;
private usersViewMap;
rtsManager: RtsManager;
protected localStreamManager: LocalStreamManager;
protected authInfo?: AliRtcAuthInfo;
protected signalingManager: SignalingManager;
pluginManager: PluginManager;
private audioMixerPlugin?;
private dualVideoPlugin?;
private blankAudioPlugin?;
protected slsReporter: SLSReporter;
private statsMonitorId?;
private autoSubAudio;
private autoSubVideo;
private autoSubScreen;
private wantSubAudio;
private wantSubVideo;
private wantSubScreen;
private defaultStreamType;
private audioMuted;
private playoutVolume;
private refreshUrlTimer?;
private audioVolumeIndicationInterval;
private indicationTimer;
private parameter;
constructor(config: BizControlConfig);
private addSignalingManagerListener;
isAutoSubAudio(): boolean;
setAutoSubAudio(value: boolean): void;
isAutoSubVideo(): boolean;
setAutoSubVideo(value: boolean): void;
isAutoSubScreen(): boolean;
setAutoSubScreen(value: boolean): void;
isWantSubAudio(): boolean;
setWantSubAudio(value: boolean): void;
isWantSubVideo(): boolean;
setWantSubVideo(value: boolean): void;
isWantSubScreen(): boolean;
setWantSubScreen(value: boolean): void;
setRemoteDefaultVideoStreamType(type: AliRtcVideoStreamType): void;
setRemoteUserVideoStreamType(userId: string, type: AliRtcVideoStreamType): void;
setAudioMuted(mute: boolean): void;
setLocalViewConfig(view: AliRtcLocalView, track: AliRtcVideoTrack): void;
setRemoteViewConfig(uid: string, view: AliRtcLocalView, track: AliRtcVideoTrack): void;
get channel(): string | undefined;
get userId(): string | undefined;
get remoteUsers(): RemoteUser[];
/**
* 获取推流对象，只能是自己
*/
get publisher(): LocalUser | undefined;
get isSubscribing(): boolean;
/**
* 处理远端用户推流状态变化
* @param {string} userId
* @param {string} displayname
* @param {string} callid
* @param {string} pullStreamUrl
* @param {TrackInfo[]} tracks
* @returns {void}
*/
onRemotePublishStateChange(publishInfo: PublishUser): void;
/** 定期更新所有人的推拉流地址，便于重连
* @param pushStreamUrl 已有的推流地址，根据地址中的过期时间来设置定时器
* @private
*/
private setTimeoutToUpdateAllStreamUrls;
/**
* 登陆成功后初始化用户管理，创建自己
* @param {AliRtcAuthInfo} authInfo
* @param {JoinResult} data
* @returns {Promise}
*/
init(authInfo: AliRtcAuthInfo, data: JoinResult): void;
leave(): Promise;
/**
* 离会后清除所有数据
* @returns {Promise}
*/
clear(): Promise;
private startStatsMonitor;
private stopStatsMonitor;
/**
* 添加远端用户
* @param {string} userId
* @param {string} displayName
* @returns {void}
*/
addUser(userId: string, displayName: string, reason: SubscribeReason): RemoteUser;
/**
* 执行添加远端用户
* @param {string} userId
* @param {string} displayName
* @returns {RemoteUser}
*/
private executeAddUser;
/**
* 远端用户设备状态变化
* @param {DeviceStatusChangeType} event
* @param {string} userId
*/
private onRemoteDeviceStatusChange;
/**
* 远端流数据采集上报
* @param {any} stat
*/
private onRemoteStatReport;
/**
* rts 单 PC 订阅超限
*/
private onSubscribeExceeds;
/**
* 移除远端用户
* @param {LeaveInfo} user
* @returns {Promise}
*/
removeLeftUser(user: LeaveInfo): Promise;
/**
* 更新远端用户数据
* @param {JoinInfo[]} users
* @returns {{joinList: JoinInfo[], leaveList: LeaveInfo[], presentList: JoinInfo[]}}
*/
updateUsers(users: JoinInfo[]): {
joinList: JoinInfo[];
leaveList: LeaveInfo[];
presentList: JoinInfo[];
};
/**
* 根据 userId 获取 RemoteUser
* @param {string} userId
* @returns {RemoteUser | undefined}
*/
getRemoteUser(userId: string): RemoteUser | undefined;
/**
* 更新远端用户设备信息
* @param {RemoteUserStatus} user
* @returns {boolean} true: 用户状态改变 false: 用户状态没有改变
*/
updateRemoteUserDeviceStatus(user: RemoteUserStatus): void;
updateAudioWant(uid: string, sub: boolean): void;
updateVideoWant(uid: string, sub: boolean): void;
updateScreenWant(uid: string, sub: boolean): void;
private stopIndication;
private startIndication;
setEnableDualVideoStream(enabled: boolean, options?: AliRtcDualVideoPluginOptions): void;
setAudioVolume(options: AudioMixerPluginOptions): void;
enableAudioVolumeIndication(interval: number): void;
setPlayoutVolume(volume: number): void;
refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): void;
setEnableMediaExtensionMsg(enable: boolean): void;
setAudioRedEnabled(enable: boolean): void;
setParameter(parameter: string): void;
getParameter(): string;
sendDataChannelMessage(message: AliRtcDataChannelMsg): Promise;
}
declare interface BizControlConfig {
slsReporter: SLSReporter;
signalingManager: SignalingManager;
}
declare interface BizControlListener {
[ClientEventType.RtsSubscribeExceeds]: (userId: string, options?: SubscribeOptions) => void;
[DeviceStatusChange.Remote]: (event: DeviceStatusChangeType, userId: string) => void;
[ClientEventType.PullStreamStats]: (userId: string, stat: any, pullStreamUrl: string) => void;
remoteTrackAvailableChange: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
screenSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
dataSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number, channel: string) => void;
userAudioMuted: (uid: string, isMute: boolean) => void;
userVideoMuted: (uid: string, isMute: boolean) => void;
userScreenMuted: (userId: string, isMute: boolean) => void;
audioVolume: (speakers: {
userId: string;
volume: number;
}[]) => void;
rtcLocalVideoStats: (stats: AliRtcLocalVideoStats[]) => void;
rtcLocalAudioStats: (stats: AliRtcLocalAudioStats[]) => void;
rtcRemoteVideoStats: (stats: AliRtcRemoteVideoStats[]) => void;
rtcRemoteAudioStats: (stats: AliRtcRemoteAudioStats[]) => void;
rtcStats: (stats: any) => void;
remoteAudioAutoPlayFail: (uid: string) => void;
remoteVideoAutoPlayFail: (uid: string, track: AliRtcVideoTrack) => void;
remoteAudioPlayError: (uid: string, reason?: string) => void;
remoteVideoPlayError: (uid: string, reason?: string) => void;
remoteSubscribeError: (error: AliRtcError, uid?: string) => void;
occurError: (error: AliRtcError, uid?: string) => void;
remoteDataChannelMessage: (uid: string, message: AliRtcDataChannelMsg) => void;
}
declare enum ClientEventType {
PullStreamStats = "remoteStat",
RtsSubscribeExceeds = "rtsSubscribeExceeds",
UserJoined = "userJoined",
UserLeft = "userLeft",
Bye = "bye",
MuteAudio = "muteAudio",
UnmuteAudio = "unmuteAudio",
MuteVideo = "muteVideo",
UnmuteVideo = "unmuteVideo",
MuteScreen = "muteScreen",
UnmuteScreen = "unmuteScreen",
Error = "error"
}
declare enum CmdType {
Add = 0,
Del = 1,
Update = 2,
None = 100
}
declare enum CodecType {
OPUS = "opus",
H264 = "H264",
UNKNOWN = ""
}
declare enum ConnectionLatencyStage {
CREATE_ENGINE = "create_engine",
JOIN = "join",
WANT_INSERT_PUB_TASK = "wantInsertPubTask",
INSERT_PUB_TASK = "InsertPubTask",
HANDLE_PUB_TASK = "HandlePubTask",
RECV_NOTIFY_PUBLISH = "RecvNotifyPublish",
INSERT_SUB_TASK = "InsertSubTask",
HANDLE_SUB_TASK = "HandleSubTask",
FIRST_REMOTE = "first_remote"
}
declare enum ConnectionLatencyStatus {
START = "start",
SEND_SIG = "send_sig",
RECV_RST = "recv_rst",
END = "end",
RECEIVED = "received",
DECODED = "decoded",
PLAYED = "played"
}
/**
* websocket链接状态
*/
declare enum CONNECTSTATUS {
DISCONNECTED = 0,
CONNECTING = 1,
CONNECTED = 2
}
declare interface DeviceStatus {
micOpen: boolean;
micInterrupted: boolean;
cameraOpen: boolean;
screenShare: boolean;
audioDisable: boolean;
videoDisable: boolean;
screenDisable: boolean;
backgroundMode: boolean;
accompanyPlaying: boolean;
}
declare enum DeviceStatusChange {
Local = "local-device-status-change",
Remote = "remote-device-status-change"
}
declare type DeviceStatusChangeType = ClientEventType.MuteAudio | ClientEventType.UnmuteAudio | ClientEventType.MuteScreen | ClientEventType.UnmuteScreen | ClientEventType.MuteVideo | ClientEventType.UnmuteVideo;
declare enum DisplayType {
NOT_DISPLAY = 0,
ALWAYS = 1,
WHEN_NO_VIDEO = 2
}
declare interface IResponse {
version: number;
code: number;
msgtype: MessageType;
tid: string;
isproxy?: boolean;
}
declare interface ISendPackage {
version: number;
msgtype: MessageType;
tid: string;
header: {
appid: string;
channelid: string;
sessionid: string;
userid: string;
displayName?: string;
clientversion?: string;
platform?: string;
};
data: {
seq: number;
l1ip?: string;
status?: string;
clientrole?: string;
configure?: {
clientrole?: AliRtcSdkClientRole;
channelprofile: AliRtcSdkChannelProfile;
};
auth?: SendPackageAuthInfo;
sessionid?: string;
pushstreamurl?: string;
users?: any[];
};
}
/**
* 服务端通知的远端用户信息
*/
declare interface JoinInfo {
displayname: string;
session: string;
userid: string;
callid: string;
clientrole?: string;
subscribe?: {
pullstreamurl: string;
};
tracks?: TrackInfo[];
}
declare interface JoinResult {
pushstreamurl: string;
tid: string;
users: JoinInfo[];
timestamp: number;
}
declare interface LeaveInfo {
userid: string;
leavecode: AliRtcUserOfflineReason;
reason: string;
}
declare class LocalProfileManager {
private defaultProfile;
profile?: string;
profileMap: Map;
audioProfile?: AudioProfileKey;
contentHint?: string;
constructor(defaultProfile?: IProfile);
updateProfile(profileKey: string, profileValue?: Partial): void;
get videoProfile(): string | undefined;
updateAudioProfile(profileKey: AudioProfileKey): void;
setContentHint(videoTrack: MediaStreamTrack | undefined, contentHint?: string): void;
/**
* 更新源流 Constraints
* 更新 PeerConnectiong Sender 相关配置
* @param stream
*/
setVideoProfile(originVideoTrack: MediaStreamTrack | undefined, target: LocalStream | undefined, skipConstraints?: boolean): Promise;
}
declare type LocalStreamConfig = Omit<_LocalStreamConfig, 'custom'>;
declare interface _LocalStreamConfig extends IStreamConfig {
videoProfile?: string;
screenProfile?: string;
}
declare class LocalStreamManager extends default_2 {
/**
* @ignore
*/
static logName: string;
private pluginManager;
private slsReporter;
private publishingCameraVideoStream;
private publishingScreenVideoStream;
cameraStreamInfo: AliRtcLocalStreamInfo;
screenStreamInfo: AliRtcLocalStreamInfo;
private streamInfos;
private _audioCaptureDisabled;
private _cameraCaptureDisabled;
private _publishLocalAudioStreamEnabled;
private _publishLocalVideoStreamEnabled;
private _publishLocalScreenStreamEnabled;
constructor(pluginManager: PluginManager, slsReporter: SLSReporter);
get hasCamera(): boolean;
get audioCaptureDisabled(): boolean;
set audioCaptureDisabled(closed: boolean);
get cameraCaptureDisabled(): boolean;
set cameraCaptureDisabled(closed: boolean);
setAudioMuted(muted: boolean): void;
get isAudioMuted(): boolean;
setCameraMuted(muted: boolean): void;
get isCameraMuted(): boolean;
setScreenMuted(muted: boolean): void;
get isScreenMuted(): boolean;
get publishLocalAudioStreamEnabled(): boolean;
set publishLocalAudioStreamEnabled(enable: boolean);
get publishLocalVideoStreamEnabled(): boolean;
set publishLocalVideoStreamEnabled(enable: boolean);
get publishLocalScreenStreamEnabled(): boolean;
set publishLocalScreenStreamEnabled(enable: boolean);
updateStreams(): Promise;
private setAvailableCameraDeviceId;
private setAvailableMicrophoneDeviceId;
/**
* 创建 LocalStream
* @param {LocalStreamConfig} params 创建 LocalStream 的配置
* @returns {LocalStream} 当前创建的 LocalStream
*/
createLocalStream(params: LocalStreamConfig): Promise;
/**
* 停止推流，底层调用 rts publishStop，不会导致 DC 马上关闭。适合暂时停推的场景
* @param {StopPublishOptions} options
* @returns {Promise} 如果返回了 audio，则表示需要更新音频流
*/
stopLocalStream(options: StopPublishOptions): Promise;
get publishStreams(): PublishStreamInfo;
createHTTPPublishStream(): Promise<{
publishStream: LocalStream | undefined;
videoSmallStream: LocalStream | undefined;
screenStream: LocalStream | undefined;
vMsid: string | undefined;
}>;
/**
* 停止所有流
*/
stop(): void;
/**
* 设置摄像头流 profile
* @param {LocalStream | null} stream
* @param {string} profileKey
* @param {IProfile} profile
*/
setVideoProfile(profileKey?: string, profile?: Partial, skipConstraints?: boolean): Promise;
/**
* 设置摄像头流 content hint
* @param {string} hint
* @note 不传则尝试复用之前的 hint
*/
setVideoContentHint(hint?: string): void;
/**
* 设置音频流 profile
* @param {string} profileKey
*/
setAudioProfile(profileKey: AudioProfileKey): Promise;
/**
* 设置屏幕共享流 profile
* @param {LocalStream} stream
* @param {string} profileKey
* @param {IProfile} profile
*/
setScreenProfile(profileKey?: string, profile?: Partial): Promise;
setScreenContentHint(hint?: string): void;
/**
* 设置 cameraVideoConstraints
* @param {IVideoConstraints} cameraVideoConstraints
*/
setCameraVideoConstraints(cameraVideoConstraints: IVideoConstraints): void;
/**
* 设置 micAudioConstraints
* @param {IAudioConstraints} micAudioConstraints
*/
setMicAudioConstraints(micAudioConstraints: IAudioConstraints): void;
}
declare interface LocalStreamManagerListener {
trackended: (type: TrackEvent_2) => {};
publishupdate: () => {};
}
declare class LocalUser extends User {
/**
* @ignore
*/
static logName: string;
private _url;
private joinTime;
private _isPublishing;
private publishPromise;
private previewElements;
private screenPreviewElements;
private streamManager;
private dc;
protected streamTracks?: TrackInfo[];
protected publishId: string;
protected signalingManager: SignalingManager;
traceId: string;
private monitorTimerId?;
private monitorDataCache;
private trackTraceIdMap;
private candidateDataCache;
private pcMediaStatsMap;
protected slsReporter: SLSReporter;
private audioPubState;
private videoPubState;
private videoSmallPubState;
private screenPubState;
private dataPubState;
private parameter;
constructor(config: LocalUserConfig);
get url(): string;
set url(value: string);
get joined(): boolean;
get isPublishing(): boolean;
get publishStreams(): PublishStreamInfo;
get cameraTrack(): MediaStreamTrack | undefined;
get screenTrack(): MediaStreamTrack | undefined;
get audioTrack(): MediaStreamTrack | undefined;
get hasCamera(): boolean;
get hasMicrophone(): boolean;
get hasScreenShare(): boolean;
get hasCameraTrackInMS(): boolean;
get hasCameraDualTrackInMS(): boolean;
get hasScreenTrackInMS(): boolean;
get hasAudioTrackInMS(): boolean;
get cameraDirection(): string | undefined;
get audioCaptureDisabled(): boolean;
get cameraCaptureDisabled(): boolean;
get publishLocalVideoStreamEnabled(): boolean;
get publishLocalAudioStreamEnabled(): boolean;
get publishLocalScreenStreamEnabled(): boolean;
setPublishLocalAudioStreamEnabled(enable: boolean): void;
setPublishLocalVideoStreamEnabled(enable: boolean): void;
setPublishLocalScreenStreamEnabled(enable: boolean): void;
initInfo(authInfo: AliRtcAuthInfo, pushStreamUrl: string): void;
setVideoProfile(profile?: VideoProfileWithSendFramerate): Promise;
setVideoContentHint(hint: string): void;
setScreenContentHint(hint: string): void;
setAudioProfile(profileKey: AudioProfileKey): Promise;
setScreenProfile(profile?: Partial): Promise;
setCameraDirection(direction: AliRtcCameraDirection): void;
setCameraDeviceId(deviceId: string): void;
muteLocalCamera(mute: boolean): void;
muteLocalMic(mute: boolean): void;
muteLocalScreen(mute: boolean): void;
setMicrophoneDeviceId(deviceId: string): void;
setMicrophoneConstraints(constraints: MediaTrackConstraints): void;
updatePubId(): void;
clearPublishState(): void;
leave(): Promise;
/**
* 销毁，停止推流
* @returns {Promise}
*/
clear(): Promise;
resetElement(element: HTMLVideoElement): void;
setPreviewElement(previewParams: PreviewConfig): void;
startDefaultCamera(audioOnly: boolean): Promise;
startDefaultAudio(): Promise;
/**
* 为本地预览设置渲染元素和视频流
* @param {AliRtcLocalView} view 渲染元素，null 则为停止显示
* @param {AliRtcVideoTrack} track 视频流类型
*/
setViewConfig(elements: null | HTMLVideoElement[], track: AliRtcVideoTrack): void;
/**
* 开启摄像头采集
* @param params
* @returns
*/
startCameraCapture(): Promise;
/**
* 关闭摄像头采集
* @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
*/
stopCameraCapture(): Promise;
/**
* 开启麦克风采集
* @param params
* @returns
*/
startAudioCapture(): Promise;
/**
* 关闭音频采集
* @note 调用此接口后，入会后、离会再入会，采集设备保持关闭状态
*/
stopAudioCapture(): Promise;
/**
* 预览本地流
* @param {PreviewConfig} previewParams
* @returns {Promise}
*/
preview(previewParams: PreviewConfig): Promise;
/**
* 在所有预览容器中预览当前流
* @param {boolean} screen 是否指定预览辅流
*/
previewAll(previewAllParams?: PreviewAllConfig): Promise;
/**
* 停止预览本地流
*/
stopPreview(previewParams?: StopPreviewConfig): void;
/**
* 恢复推流
* @returns {Promise}
*/
resumePublish(): Promise;
createLocalStream(params: LocalStreamConfig): Promise;
stopLocalStream(options: PublishOptions): Promise;
private compareAndPublish;
private reportAudioProfile;
private reportVideoProfile;
private reportScreenProfile;
private updateDataChannel;
private publishDataChannel;
/**
* 开始推流
* @param isResume 是否是恢复推流
* @returns
*/
startPublish(isResume?: boolean, reason?: PublishReason): Promise;
/**
* 重新执行 progress 并触发 publishupdate
*/
updateStreams(): Promise;
/**
* 对比本地流和正在推流，进行推流更新
* @param isResume 是否是恢复推流
*/
publishUpdate(reason?: PublishReason): Promise;
private syncPublishToRoomServer;
private refreshPushStreamUrl;
/**
* 推流，用于 rts subscribe/publish 被调用后，此时 DataChannel 已存在
* @param {LocalStream} stream
* @returns {Promise}
*/
publishAdd(stream: LocalStream, extra: PublishExtraParams, isResume?: boolean, retryTimes?: number): Promise;
/**
* 替换推流 Track（仅限于替换已存在的 Track 类型）
* @param {LocalStream} stream
* @returns {Promise}
*/
publishReplace(stream: LocalStream, extra?: PublishExtraParams): Promise;
/**
* 停止推某些轨，不销毁 DataChannel 和 LocalStream，用于非销毁场景
* @param {PublishOptions} options
* @returns {Promise}
*/
publishDeleteTracks(options: PublishOptions): Promise;
/**
* 停止推流，不销毁 LocalStream，用于非销毁场景
* @returns {Promise}
*/
publishStop(): Promise;
/**
* 停止推流，销毁 DataChannel，用于销毁的场景
* @returns {Promise}
*/
unPublish(): Promise;
/**
* 事件通知本地的设备使用状态
*/
reportSelfDeviceStatus(): void;
/**
* 从localStream 中获取当前的设备状态
* @returns {string}
*/
private getDeviceStatus;
private onTrackEnd;
private resetPreviewElements;
private resetSecondayPreviewElements;
getMediaStats(id: string): any;
private reportPublishMonitor;
private reportNetwork;
private startStreamMonitor;
/**
* 停止本地流数据采集
*/
private stopStreamMonitor;
/**
* 清除本地流
* @returns {void}
*/
clearStream(): void;
/**
* 获取当前使用的摄像头 deviceId
* @returns {string | undefined}
*/
getCurrentCameraDeviceId(): string | undefined;
/**
* 获取当前使用的摄像头 deviceId
* @returns {string | undefined}
*/
getCurrentMicDeviceId(): string | undefined;
enableAudioVolumeIndication(interval: number): void;
sendSEI(message: ArrayBuffer, repeatCount: number, payloadType: number): Promise;
sendDataChannelMessage(message: AliRtcDataChannelMsg): Promise;
getStats(): Promise<{
audio: AliRtcLocalAudioStats[];
video: AliRtcLocalVideoStats[];
candidate: any;
}>;
}
declare interface LocalUserConfig {
rtsManager: RtsManager;
localStreamManager: LocalStreamManager;
slsReporter: SLSReporter;
signalingManager: SignalingManager;
pluginManager: PluginManager;
audioVolumeIndicationInterval: number;
parameter: {
[key: string]: any;
};
}
/**
* 日志埋点类，调用LogReporter进行日志埋点
* 在入会之前，会将埋点缓存，入会后以每200ms一条的速度将缓存的埋点按顺序上报
*/
declare class LogClient {
protected tracker?: default_3;
protected param?: any;
protected msgCacheArr: any[];
protected index: number;
protected stsOpt?: any;
protected slsToken?: SLSSTSToken;
protected ossToken?: OSSSTSToken;
protected ntpClock: NTPClient;
constructor();
private createTracker;
start(info: AliRtcAuthInfo): void;
updateToken(slsToken: SLSSTSToken, ossToken?: OSSSTSToken): void;
/**
* 断开连接
*/
stop(): void;
/**
* 发送一条日志
* @param {any} log
*/
sendReport(log: any): void;
/**
* 初始化公共参数
*/
protected initParam(info: AliRtcAuthInfo): void;
}
declare interface LogInfo {
[key: string]: string | number;
}
declare interface MediaTrackInfo {
ssrc: string;
msid: string;
red: number;
codec: CodecType;
sample?: number;
pt: number;
type?: CmdType;
}
declare enum MessageType {
KEEPALIVE = "keepalive",
JOINCHANNEL = "joinchannel",
NOTIFYJOIN = "notifyjoin",
NOTIFYSTATUS = "notifystatus",
STATUSREPORT = "statusreport",
LEAVECHANNEL = "leavechannel",
NOTIFYLEAVE = "notifyleave",
NOTIFYPUBLISH = "notifypublish",
BYE = "bye",
RECONNECT = "reconnect",
PUBLISH = "publish",
REFRESHURL = "refreshurl",
UNSUBSCRIBE = "unsubscribe",
ROLEUPDATE = "roleupdate"
}
declare enum MPU_TASK_TRANSACTION_TYPE {
MPU_TASK_TRANSACTION_START = 0,
MPU_TASK_TRANSACTION_UPDATE = 1,
MPU_TASK_TRANSACTION_STOP = 2,
MPU_TASK_TRANSACTION_LIST = 3,
MPU_TASK_TRANSACTION_POLLING = 4,
MPU_TASK_TRANSACTION_ACKNOWLEDGE = 5,
MPU_TASK_TRANSACTION_END = 6
}
declare enum MsidType {
Audio = "sophon_audio",
VideoLarge = "sophon_video_camera_large",
VideoSmall = "sophon_video_camera_small",
Screen = "sophon_video_screen_share",
Data = "sophon_data"
}
declare class NTPClient {
private static instance;
private ntpClock;
private constructor();
static getInstance(): NTPClient;
now(): number;
}
declare interface OSSSTSToken {
access_key_id: string;
access_key_secret: string;
security_token: string;
region_endpoint: string;
bucket_name: string;
expiration: number;
}
declare interface OSSToken {
access_key_id: string;
access_key_secret: string;
security_token: string;
region_endpoint: string;
bucket_name: string;
expiration: number;
}
declare class PackageCreater {
protected authInfo: AliRtcAuthInfo;
protected userName: string;
protected seqIndex: number;
constructor(authInfo: AliRtcAuthInfo, userName: string);
get roleAuth(): SendPackageAuthInfo | undefined;
refreshAuthInfo(authInfo: AliRtcAuthInfo): void;
getSeqIndex(): number;
/**
* 创建一个心跳包
* @returns
*/
createKeepAlivePackage(): ISendPackage;
/**
* 创建一个用于发送入会消息的Package
* @returns
*/
createJoinPackage(): ISendPackage;
/**
* 创建一个用于发送离会消息的Package
* @returns
*/
crateLeavePackage(): ISendPackage;
createStatusPackage(status: string): ISendPackage;
/**
* 创建一个用于发送推流消息的Package
* @returns
*/
createPublishPackage(): ISendPackage;
createRoleUpdatePackage(): ISendPackage;
createReconnectPackage(data?: ReconnectData): ISendPackage;
createRefreshUrlPackage(): ISendPackage;
/**
* 创建一个Response包
* @param {string} tid Notify消息的tid
* @param {MessageType} msgType 消息类型
* @returns {IResponse}
*/
createResponsePackage(tid: string, msgType: MessageType): IResponse;
/**
*
* @param messageType
* @returns
*/
protected createBaseSendPackage(messageType: MessageType): ISendPackage;
}
declare type Parameter = {
[key: string]: any;
};
declare class PluginManager extends default_2 {
private plugins;
add(plugin: AliRtcPlugin, options?: any): void;
remove(name: string): void;
removeAll(): void;
get(name: string): AliRtcPlugin | undefined;
has(name: string): boolean;
getAll(): AliRtcPlugin[];
}
declare interface PluginManagerListener {
added: (plugin: AliRtcPlugin) => void;
removed: (plugin: AliRtcPlugin) => void;
updated: (plugin: AliRtcPlugin) => void;
}
declare interface PreviewAllConfig {
primary?: boolean;
screen?: boolean;
}
declare interface PreviewConfig {
videoElement: HTMLVideoElement;
screen?: boolean;
}
declare interface PublishExtraParams {
vMsid?: string;
aMsid?: string;
isVideoSmall?: boolean;
isScreen?: boolean;
isAudio?: boolean;
}
declare interface PublishInfo {
type: PublishType;
userid: string;
sessionid: string;
displayname: string;
pubid?: string;
resume?: boolean;
subscribe: {
signal: string;
pullstreamurl: string;
};
l1ip?: string;
callid: string;
tracks: TrackInfo[];
traceid?: string;
signaltid?: string;
}
declare type PublishOptions = StreamOptions & {
vMsid?: string;
};
declare enum PublishReason {
MANUAL = 0,
JOIN_CHANNEL = 1,
ROLE_CHANGE = 2,
RECONNECT = 3
}
declare interface PublishStreamInfo {
audio?: LocalStream;
video?: LocalStream;
videoSmall?: LocalStream;
screen?: LocalStream;
videoProfile?: LocalProfileManager;
screenProfile?: LocalProfileManager;
}
declare enum PublishType {
Add = "add",
Delete = "delete",
Replace = "replace",
Stop = "stop",
UnPublish = "unpublish"
}
declare interface PublishUser {
callid: string;
clientrole?: string;
displayname: string;
subscribe?: {
pullstreamurl: string;
};
pubid?: string;
tracks?: TrackInfo[];
userid: string;
sessionid?: string;
}
declare interface ReconnectData {
role?: RoleForReconnectData;
auth?: SendPackageAuthInfo;
publish?: {
users: [PublishInfo];
};
}
declare interface RefreshInfo {
pushstreamurl?: string;
users?: RefreshUser[];
}
declare interface RefreshUrlResult extends SignalingResult {
pushstreamurl?: string;
users?: RefreshUser[];
}
declare interface RefreshUser {
userid: string;
subscribe: {
pullstreamurl: string;
};
}
declare interface RemoteMediaTrackInfo extends MediaTrackInfo {
subscribeState?: RemoteTrackSubscribeState;
}
declare class RemoteStreamInfo extends default_2 {
/**
* @ignore
*/
static logName: string;
protected audioInfo: RemoteMediaTrackInfo;
protected videoLargeInfo: RemoteMediaTrackInfo;
protected videoSmallInfo: RemoteMediaTrackInfo;
protected screenInfo: RemoteMediaTrackInfo;
protected dataInfo: RemoteMediaTrackInfo;
protected audioVolume: number;
protected audioMuted: boolean;
protected userStatus?: DeviceStatus;
constructor();
/**
* 远端流音频轨道信息
* @returns
*/
getAudioInfo(): RemoteMediaTrackInfo;
/**
* 远端流视频轨道信息
* @returns
*/
getVideoSmallInfo(): RemoteMediaTrackInfo;
/**
* 远端流视频轨道信息
* @returns
*/
getVideoLargeInfo(): RemoteMediaTrackInfo;
/**
* 远端流屏幕共享轨道信息
* @returns
*/
getScreenInfo(): RemoteMediaTrackInfo;
getDataInfo(): RemoteMediaTrackInfo;
get subscribingInfos(): RemoteMediaTrackInfo[];
get hasTrack(): boolean;
/**
* 远端流是否包含音频轨道
* @returns
*/
get hasAudio(): boolean;
/**
* 远端流是否包含视频轨道
* @returns
*/
get hasVideo(): boolean;
/**
* 远端流是否包含视频大流轨道
* @returns
*/
get hasVideoLarge(): boolean;
/**
* 远端流是否包含视频小流轨道
* @returns
*/
get hasVideoSmall(): boolean;
/**
* 远端流是否包含屏幕共享轨道
* @returns
*/
get hasScreen(): boolean;
get hasData(): boolean;
/**
* 是否订阅远端流音频轨道
* @returns
*/
get isAudioSubscribed(): boolean;
get isAudioSubscribing(): boolean;
/**
* 是否订阅远端流视频轨道
* @returns
*/
get isVideoSubscribed(): boolean;
get isVideoSubscribing(): boolean;
/**
* 是否订阅远端流视频大流轨道
* @returns
*/
get isVideoLargeSubscribed(): boolean;
get isVideoLargeSubscribing(): boolean;
/**
* 是否订阅远端流视频小流轨道
* @returns
*/
get isVideoSmallSubscribed(): boolean;
get isVideoSmallSubscribing(): boolean;
/**
* 是否订阅远端流屏幕共享轨道
* @returns
*/
get isScreenSubscribed(): boolean;
get isScreenSubscribing(): boolean;
get isDataSubscribed(): boolean;
get isDataSubscribing(): boolean;
get audioCodec(): CodecType;
get videoCodec(): CodecType;
get audioTrackInfo(): AliRtcAudioTrack;
get videoTrackInfo(): AliRtcVideoTrack;
updateTracks(tracks?: TrackInfo[]): UpdateTracksResult;
protected updateRemoteTrackSsrc(audioSsrc: string, videoLargeSsrc: string, videoSmallSsrc: string, screenSsrc: string, dataSsrc: string): void;
markRemoteTrackSubscribing(option: SubscribeOptions): any;
updateRemoteTrackSubState(option: SubscribeOptions): any;
/**
* 更新远端用户设备状态
* @param status
* @returns {boolean} 状态改变返回true，否则返回false
*/
updateRemoteUserDeviceStatus(status: string): boolean;
}
declare interface RemoteSubscribeOptions {
remoteUser: RemoteUser;
options: SubscribeOptions;
}
declare enum RemoteTrackSubscribeState {
NotSubscribe = 0,
Subscribing = 1,
Subscribed = 2
}
declare class RemoteUser extends User {
/**
* @ignore
*/
static logName: string;
remoteCallid: string;
remoteUserInfo: AliRtcRemoteUserInfo;
protected localUser?: LocalUser;
protected lastPubId: string;
protected stream?: RemoteStream;
protected screenStream?: RemoteStream;
private viewMap;
private audioTrack?;
private audioElement?;
protected subscribed: boolean;
protected mediaStream?: MediaStream;
protected secondaryMediaStream?: MediaStream;
protected prevSubConfig?: SubConfig;
protected signalingManager: SignalingManager;
protected slsReporter: SLSReporter;
private wantSubAudio;
private wantSubVideo;
private wantSubScreen;
private defaultVideoStreamType;
private audioMuted;
private playoutVolume;
private playoutGainNode?;
private audioSubState;
private videoSubState;
private videoLargeSubState;
private videoSmallSubState;
private screenSubState;
private dataSubState;
private dc;
private dcMsgWaitingPieces;
streamInfo: RemoteStreamInfo;
private _streamUrl;
private parameter;
private monitorTimerId?;
private monitorDataCache;
private trackTraceIdMap;
constructor(config: RemoteUserConfig);
get streamUrl(): string;
set streamUrl(value: string);
isWantSubAudio(): boolean;
setWantSubAudio(value: boolean): void;
isWantSubVideo(): boolean;
setWantSubVideo(value: boolean): void;
isWantSubScreen(): boolean;
setWantSubScreen(value: boolean): void;
setRemoteDefaultVideoStreamType(type: AliRtcVideoStreamType): void;
setAudioMuted(value: boolean): void;
getAudioElement(): HTMLAudioElement | undefined;
private handleAudioContextSuspended;
setPlayoutVolume(value: number): void;
getAudioMuted(): boolean;
get hasAudioTrack(): boolean;
get hasVideoTrack(): boolean;
get hasVideoLargeTrack(): boolean;
get hasVideoSmallTrack(): boolean;
get hasScreenTrack(): boolean;
get isAudioSubscribing(): boolean;
get isVideoSubscribing(): boolean;
get isVideoLargeSubscribing(): boolean;
get isVideoSmallSubscribing(): boolean;
get isScreenSubscribing(): boolean;
get isDataSubscribing(): boolean;
get audioEnabled(): boolean;
get videoEnabled(): boolean;
get screenEnabled(): boolean;
get getAudioTrack(): MediaStreamAudioTrack | undefined;
get getCameraStream(): RemoteStream | undefined;
get getScreenStream(): RemoteStream | undefined;
setViewConfig(view: AliRtcLocalView, track: AliRtcVideoTrack): void;
/**
* 销毁
* @returns {Promise}
*/
clear(needStopSub?: boolean): Promise;
/**
* 更新远端用户的设备状态
* @param {string} status
* @returns {void}
*/
updateRemoteUserDeviceStatus(status: string): void;
/**
* 更新远端用户的推流状态，已经停止推流的 tracks 要 delete，或者整体 stop
* @param {string} callid
* @param {string} pullStreamUrl
* @param {TrackInfo[]} tracks
* @returns {Promise}
*/
updateRemoteTracks(callid: string, pullStreamUrl: string, _pubid: string, tracks?: TrackInfo[]): Promise;
/**
* 订阅远端流
* @param {SubscribeOptions} options
* @returns {Promise} 返回可播放的 MediaStream，可能为空。如果同时订阅了主流和辅流，只会返回主流对应的 MediaStream
*/
subscribe(options?: SubscribeOptions, reason?: SubscribeReason, startTs?: number): Promise;
/**
* 订阅远端流
* @param {SubscribeOptions} options 订阅配置
* @param {boolean} secondary 是否订阅辅流
* @returns {Promise}
*/
private subscribeProxy;
/**
* 移除对某些轨道的订阅
* @param {UnSubscribeOptions} options 取消订阅轨道配置
* @returns {Promise}
*/
private subscribeDeleteTracks;
/**
* 移除对某些轨道的订阅
* @param {Partial} deleteTrack 删除订阅配置
* @returns {Promise}
*/
private subscribeDeleteProxy;
/**
* 用保存的订阅参数恢复订阅
*/
restore(): void;
resumeAudio(): Promise;
resumeVideo(videoTrack?: AliRtcVideoTrack): Promise;
resumePlay(): void;
/**
* 停止订阅远端流
* @param {string} userId
* @param {UnSubscribeOptions} options
* @returns {Promise}
*/
stopSubscribe(options?: UnSubscribeOptions): Promise;
/**
* 停止对某个拉流 URL 的订阅
* @param {url} pullStreamUrl
* @returns {Promise}
*/
private doStopSubscribe;
private updateStream;
private updateScreenStream;
private clearStream;
private clearScreenStream;
private onDataChannelMessage;
private onDataChannelError;
private dataChannelConnected;
private subscribeDataChannel;
private subscribeStopDataChannel;
getRetryOptions(): RemoteSubscribeOptions | undefined;
/**
* 尝试更新订阅
* 1. 需要新增订阅的情况：想要订阅 & 没有正在订阅 & 远端有流
*/
updateSubscribe(reason: SubscribeReason): {
addOption: SubscribeOptions;
deleteOption: SubscribeOptions;
};
private handleAutoPlayFailed;
private handleAudioPaused;
private handleVideoPlayFailded;
private playAudio;
stopPlayAudio(): void;
playAll(isScreen?: boolean, isReplace?: boolean): void;
/**
* 播放
*/
private play;
stopPlayAll(isScreen?: boolean): void;
/**
* 是否开启声音
* @param {boolean} enable
* @returns {void}
*/
toggleAudio(enable?: boolean): void;
/**
* 是否开启画面
* @param {boolean} enable
* @returns {void}
*/
toggleVideo(enable?: boolean): void;
/**
* 是否开启画面
* @param {boolean} enable
* @returns {void}
*/
toggleScreen(enable?: boolean): void;
getStats(): Promise<{
audio: AliRtcRemoteAudioStats[];
video: AliRtcRemoteVideoStats[];
}>;
/**
* 开启音量检测
* @param {number} interval 时间间隔
*/
enableAudioVolumeIndication(interval: number): void;
private reportSubscribeMonitor;
private startStreamMonitor;
/**
* 停止本地流数据采集
*/
private stopStreamMonitor;
}
declare interface RemoteUserConfig {
userId: string;
displayName: string;
rtsManager: RtsManager;
usersViewMap: {
[key: string]: RemoteUserViewMap;
};
slsReporter: SLSReporter;
signalingManager: SignalingManager;
localUser?: LocalUser;
audioVolumeIndicationInterval: number;
playoutVolume: number;
parameter: {
[key: string]: any;
};
}
declare interface RemoteUserMap {
[userId: string]: RemoteUser;
}
declare interface RemoteUserStatus {
userid: string;
status: string;
}
declare interface RemoteUserViewMap {
cameraViews: HTMLVideoElement[];
screenViews: HTMLVideoElement[];
}
declare interface RoleForReconnectData {
channelprofile?: AliRtcSdkChannelProfile;
clientrole?: AliRtcSdkClientRole;
}
/**
* RoomServerMessageCenter支持的事件
*/
declare interface RoomServerListener {
onJoinChannelResult: (data: any) => void;
onPublishResult: (code: number, tid: string, description: string) => void;
onNotifyJoin: (users: JoinInfo[]) => void;
onNotifyStatus: (users: RemoteUserStatus[]) => void;
onLeaveResult: (code: number, tid: string) => void;
onRoleUpdateResult: (code: number, tid: string, description: string) => void;
onRefreshUrlResult: (data: any) => void;
onNotifyLeave: (users: LeaveInfo[]) => void;
onNotifyPublish: (users: PublishUser[]) => void;
onStatusReport: (code: number, tid: string, description: string) => void;
onBye: (reason: AliRtcOnByeType, description: string) => void;
onKeepAliveRsp: () => void;
onConnectFail: (err: AliRtcError) => void;
onNetworkError: (err: AliRtcError) => void;
onAuthInvalid: () => void;
onReconnectStart: () => void;
onReconnectFail: (err: AliRtcError) => void;
onReconnectSuccess: (users: JoinInfo[]) => void;
onError: (err: AliRtcError) => void;
}
/**
* RoomServer消息中心
* 负责发送和接收信令数据，消息重发、回复Response
*/
declare class RoomServerMessageCenter extends default_2 {
static logName: string;
protected authInfo: AliRtcAuthInfo;
protected userName: string;
protected channelProfile: AliRtcSdkChannelProfile;
protected clientRole: AliRtcSdkClientRole;
private slsReporter;
protected wsClient: Socket;
protected packageCreater: PackageCreater;
protected keepAliveTimer: number;
protected packageCache: Map;
protected isFirstConnect: boolean;
protected aliveChecker: number;
protected reconnectData?: ReconnectData;
constructor(authInfo: AliRtcAuthInfo, userName: string, channelProfile: AliRtcSdkChannelProfile, clientRole: AliRtcSdkClientRole, slsReporter: SLSReporter, maxConnectRetryCount?: number);
get retryCount(): number;
/**
* 开始连接信令
* @param roomserverurl
*/
start(roomserverurl: string): void;
/**
* 开始心跳计时器，并自动发送心跳包
*/
startKeepAlive(): void;
/**
* 停止心跳计时器
*/
stopKeepAlive(): void;
/**
* 发送入会、重连前所缓存信息
*/
sendPkgCache(): void;
/**
* 发送离开房间
*/
leave(): void;
/**
* 透明通道消息上报
* @param status
*/
reportStatus(status: string): void;
/**
* 发送推流消息
*/
publish(_pubInfo: PublishInfo): void;
/**
* 更新角色
*/
roleUpdate(role: string): void;
/**
* 更新推拉流地址
* @param {RefreshInfo} info
*/
refreshUrl(info: RefreshInfo): void;
refreshAuthInfo(authInfo: AliRtcAuthInfo): void;
/**
* 关闭websocket连接，并销毁
*/
close(): void;
/**
* 通过此方法发送数据到业务信令
* 此方法会自动保存发送的package，并做重发.
* response包不要通过此方法发送
* @param pkg
*/
protected sendPackage(pkg: ISendPackage): void;
/**
* 更新重连 payload
* @param {ReconnectData} reconnectData
*/
updateReconnectData(reconnectData?: ReconnectData): void;
/**
* 收到websocket连接成功的消息
* ws连接建立成功后立刻发送join消息
*/
protected onOpen(): void;
/**
* 收到业务信令消息
* @param event
*/
protected onMessage(event: MessageEvent): void;
/**
* 收到错误消息
* @param event
*/
protected onError(event: Event): void;
/**
* 连接失败
*/
protected onConnectFail(): void;
/**
* 鉴权失败
*/
protected onAuthInvalid(): void;
/**
* 网络异常
*/
protected onNetworkError(): void;
/**
* 收到websocket断开消息
* @param event
*/
protected onClose(event: CloseEvent): void;
protected onKeepAliveRsp(): void;
protected onReconnectStart(): void;
protected onReconnectFail(): void;
/**
* 处理 Keepalive 心跳，加速判断网络异常
*/
protected checkAlive(): void;
/**
* 处理收到的业务信令
* @param response
*/
protected onRecvMessage(response: any): void;
/**
* 收到入会消息的response
* @param response
*/
protected onJoinResult(response: any): void;
/**
* 收到离开消息的response
* @param response
*/
protected onLeaveResult(response: any): void;
/**
* 收到publish消息的response
* @param response
*/
protected onPublishResult(response: any): void;
/**
* 收到roleUpdate消息的response
* @param response
*/
protected onRoleUpdateResult(response: any): void;
/**
* 收到 refreshurl 消息的response
* @param response
*/
protected onRefreshUrlResult(response: any): void;
/**
* 收到重联消息的response
* @param response
*/
protected onReconnectResult(response: any): void;
/**
* 收到业务信令下发的消息
* @param response
*/
protected onNotifyJoin(response: any): void;
/**
* 收到业务信令下发的透明通道消息
* @param response
*/
protected onNotifyStatus(response: any): void;
/**
* 收到远端用户离开的通知
* @param response
*/
protected onNotifyLeave(response: any): void;
/**
* 收到远端用户推流的通知
* @param response
*/
protected onNotifyPublish(response: any): void;
/**
* 收到statusreport的response
* @param response
*/
protected onStatusReport(response: any): void;
/**
* 收到被踢出频道的消息
* @param {any} response
*/
protected onBye(response: any): void;
}
declare class RoomServerSignaling extends default_2 {
/**
* @ignore
*/
static logName: string;
protected messageCenter?: RoomServerMessageCenter;
protected authInfo?: AliRtcAuthInfo;
protected userName?: string;
protected channelProfile: AliRtcSdkChannelProfile;
protected clientRole: AliRtcSdkClientRole;
private slsReporter;
protected reconnectData?: ReconnectData;
protected roomServerUri: string;
constructor(channelProfile: AliRtcSdkChannelProfile, clientRole: AliRtcSdkClientRole, slsReporter: SLSReporter, env?: AliRtcEnv);
/**
* 更新重连数据
* @param {ReconnectData} reconnectData
*/
private updateReconnectData;
/**
* 释放资源
*/
reset(): void;
/**
* 加入频道
* @param {AliRtcAuthInfo} authInfo
* @returns
*/
join(authInfo: AliRtcAuthInfo, userName: string, maxConnectRetryCount?: number): Promise;
/**
* 离开频道
* @returns
*/
leave(): Promise;
/**
* 开始推流
* @param pubInfo
* @returns
*/
publish(pubInfo: PublishInfo): Promise;
roleUpdate(role: AliRtcSdkClientRole): Promise;
setChannelProfile(channelProfile: AliRtcSdkChannelProfile): void;
/**
* 更新推流地址
*/
refreshUrl(info: RefreshInfo): Promise;
/**
* 上报设备状态
* @param status
*/
reportStatus(status: string): Promise;
protected handleSignalError(code: number, description: string, errorCode?: AliRtcErrorCode): AliRtcError;
refreshAuthInfo(authInfo: AliRtcAuthInfo): Promise;
/**
* 初始化MessageCenter，增加事件监听
*/
protected initMessageCenter(): void;
}
declare class RtsManager extends default_2 {
/**
* @ignore
*/
static logName: string;
private rts;
private encodedInsertableStreams;
private audioRedEnabled;
private localStreamManager;
private slsReporter;
private _rtsReconnecting;
private _rtsPeerConnectionType;
private connecting;
private connected;
private _pcTraceId;
private _localJoinTime;
private connectionResolve?;
private connectingPromise?;
private dcResolve?;
private dcReject?;
private dcConnectingPromise?;
private _publishingTracks;
private parameter;
constructor(localStreamManager: LocalStreamManager, slsReporter: SLSReporter, parameter: Parameter);
private addRTSListener;
/**
* 更新鉴权信息，传入一个新的带鉴权的 URL，RTS 会去除鉴权信息做更新
* @param newUrlWithAuth
*/
updateAuth(newUrlWithAuth: string): void;
get pcTraceId(): string;
set localJoinTime(time: number);
setEncodedInsertableStreams(enable: boolean): void;
setAudioRedEnabled(enable: boolean): void;
clear(): void;
private startConnect;
private setConnected;
get isConnecting(): boolean;
get isConnected(): boolean;
get publishingTracks(): TrackInfo[];
private getPubMsid;
private updatePublishingTracks;
private httpPublish;
waitPublishSender(streamUrl: string, isAudio?: boolean, msid?: string): Promise;
getPublishVideoStats(streamUrl: string, msid?: string): Promise;
getPublishAudioStats(streamUrl: string, msid?: string): Promise;
publishAdd(streamUrl: string, stream: LocalStream, callId: string, extra?: PublishExtraParams, isResume?: boolean, waitSender?: boolean, reason?: PublishReason): Promise;
publishDelete(streamUrl: string, options: PublishOptions): Promise;
publishReplace(streamUrl: string, stream: LocalStream, extra?: PublishExtraParams): Promise;
publishStop(streamUrl: string): Promise;
publishAddDataChannel(streamUrl: string): Promise;
publishStopDataChannel(streamUrl: string, datachannel: any): Promise;
unpublish(): Promise;
/**
* 获取 sub/subAdd config
* @param {ISubscribeConfig | ISubConfigItem} options
* @returns {Omit}
*/
private getSubConfig;
private httpSubscribe;
private subscribeAdd;
subscribeDelete(subscribeOptions: RemoteSubscribeOptions): Promise<{
url: string;
stream: any;
} | undefined>;
subscibeStop(streamUrl: string): Promise;
subscribeAddDataChannel(streamUrl: string): Promise;
subscribeStopDatachannel(streamUrl: string, datachannel: any): Promise;
publish(streamUrl: string, callId: string, isResume?: boolean, reason?: PublishReason): Promise<{
traceId: string;
l1ip?: string;
}>;
private reportSubscribeLatency;
subscribe(remoteSubscribeOptions: RemoteSubscribeOptions, reason: SubscribeReason, callId: string, remoteCallId: string, startTs: number): Promise;
getSubscribeVideoStats(streamUrl: string, msid?: string): Promise;
getSubscribeAudioStats(streamUrl: string, msid?: string): Promise;
getStreamByMsid(config: any): LocalStream | RemoteStream;
getDatachannelByMsid(config: {
url: string;
msid?: string;
}): any;
getPCStats(): Promise;
sendSEI(streamUrl: string, data: ArrayBuffer, repeatCount: number, payloadType: number): Promise;
}
declare interface RtsManagerEventListener {
reconnecting: (type: RtsPeerConnectionType) => {};
disconnected: () => {};
connected: (isReconnected: boolean, type: RtsPeerConnectionType) => {};
subscribeexceeds: () => {};
seimessage: (url: string, payloadType: number, data: ArrayBuffer) => {};
}
declare enum RtsPeerConnectionType {
PUBLISH = "publish",
SUBSCRIBE = "subscribe"
}
declare interface SendPackageAuthInfo {
timestamp: number;
nonce?: string;
token: string;
tokenrole: AliRtcSdkTokenRole;
}
declare class SignalingManager extends default_2 {
/**
* @ignore
*/
static logName: string;
protected signaling?: RoomServerSignaling;
protected authInfo?: AliRtcAuthInfo;
protected userName?: string;
protected channelProfile: AliRtcSdkChannelProfile;
protected clientRole: AliRtcSdkClientRole;
protected env: AliRtcEnv;
protected maxConnectRetryCount?: number;
stsManager: StsManager;
private slsReporter;
constructor(channelProfile: AliRtcSdkChannelProfile, clientRole: AliRtcSdkClientRole, slsReporter: SLSReporter, env?: AliRtcEnv);
reset(): void;
/**
* 向业务信令发送入会
* @param {AliRtcAuthInfo} authInfo
* @returns
*/
join(authInfo: AliRtcAuthInfo, userName?: string, maxConnectRetryCount?: number, timeRecorder?: TimeRecorder): Promise;
retryJoin(): void;
/**
* 向业务信令发送离会
* @returns
*/
leave(): Promise;
/**
* 推流
* @param pubInfo
* @returns
*/
publish(pubInfo: PublishInfo): Promise;
/**
* 通过透明通道发送设备状态
* @param {string} status
* @returns
*/
reportStatus(status: string): Promise;
/**
* 切换角色
* @param {AliRtcSdkClientRole} role
* @returns
*/
setClientRole(role: AliRtcSdkClientRole): Promise;
/**
* 切换模式
* @param {AliRtcSdkChannelProfile} channelProfile
*/
setChannelProfile(channelProfile: AliRtcSdkChannelProfile): void;
/**
* 更新推流url
* @param {RefreshInfo} info
* @returns
*/
refreshUrl(info: RefreshInfo): Promise;
refreshAuthInfo(authInfo: AliRtcRefreshAuthInfo): Promise;
/**
* 监听业务信令相关的事件
*/
protected initSignaling(): void;
/**
* 收到心跳消息
*/
protected onKeepAliveRsp(): void;
/**
* 收到远端用户入会消息
* @param {JoinInfo[]} users
*/
protected onNotifyJoin(users: JoinInfo[]): void;
/**
* 收到远端用户的透明通道消息
* @param {RemoteUserStatus[]} users
*/
protected onNotifyStatus(users: RemoteUserStatus[]): void;
/**
* 收到远端用户的离会消息
* @param {LeaveInfo[]} users
*/
protected onNotifyLeave(users: LeaveInfo[]): void;
/**
* 收到远端用户推流状态变化消息
* @param {PublishInfo[]} users
*/
protected onNotifyPublish(users: PublishUser[]): void;
/**
* 收到被踢掉消息
* @param {string} reason
* @param {string} description
*/
protected onBye(reason: AliRtcOnByeType, description: string): void;
/**
* 收到连接失败消息
* @param {AliRtcError} err
*/
protected onConnectFail(err: AliRtcError): void;
/**
* 收到网络异常消息
* @param {AliRtcError} err
*/
protected onNetworkError(err: AliRtcError): void;
/**
* 收到网络异常消息
*/
protected onAuthInvalid(): void;
protected onReconnectStart(): void;
/**
* 收到重连成功消息
* @param {JoinInfo[]} users
*/
protected onReconnectSuccess(users: JoinInfo[]): void;
/**
* 收到重连失败消息
*/
protected onReconnectFail(err: AliRtcError): void;
/**
* 收到错误消息
* @param {AliRtcError} err
*/
protected onError(err: AliRtcError): void;
}
declare interface SignalingResult {
tid: string;
code?: number;
message?: string;
}
/**
* 日志埋点类
* 每个埋点暴露对应的接口
*/
declare class SLSReporter {
private engine;
protected logClient: LogClient;
protected authInfo?: AliRtcAuthInfo;
private ntpClock;
private static staticClient;
private static getLogClient;
static reportOSSUpload(sessionId: string, date: string, responseCode?: number): void;
constructor(engine: WrappedAliRtcEngine);
private customFields;
/**
* 设置通用字段
* @param fields 字段键值对
*/
setCustomFields(fields: {
[key: string]: any;
}): void;
/**
* 获取通用字段
* @param key 字段键
* @returns 字段值或undefined
*/
getCustomField(key: string): any;
/**
* 开始建立连接
* @param authInfo
*/
start(info: AliRtcAuthInfo): void;
updateToken(token: SLSSTSToken, ossToken?: OSSSTSToken): void;
/**
* 断开连接
*/
stop(): void;
reportPublishMonitor(callId: string, traceId: string, msid: string, track: MediaStreamTrack | undefined, stats: any[]): void;
reportSubscribeMonitor(callId: string, remoteId: string, traceId: string, msid: string, stats: any[]): void;
reportNetworkMonitor(candidates: any[]): void;
/**
* 加入房间成功埋点
* @param {number} joinTime
* @param {number} result
* @param {string} tid
*/
reportJoin(result: number, timeRecord: TimeRecorder, tid?: string): void;
/**
* Join 链接细节
*/
reportJoinConnection(logInfo: LogInfo): void;
/**
* 用户离开频道事件埋点
* @param {number} leaveTime
* @param {number} result
* @param {string} tid
*/
reportLeave(leaveTime: number, result: number, tid: string): void;
/**
* 推流事件上报
* @param {string} callid
* @param {boolean} isLargeVideo
* @param {boolean} isSmallVideo
* @param {boolean} isScreenShare
* @param {boolean} isAudio
* @param {number} result
* @param {string} tid
* @param {number} pubTime
*/
reportPublish(isRepublish: boolean, url: string, callid: string, isLargeVideo: boolean, isSmallVideo: boolean, isScreenShare: boolean, isAudio: boolean, result: number | undefined, pcTraceId: string, traceId: string, startTime: number): void;
/**
* 首包上报
* @param {string} callid
* @param {number} startTime
* @param {number} publishTime
* @param {number} joinTime
* @param {string} tckid
* @param {string} pcTraceId
* @param {string} traceId
* @param {PublishReason} reason
*/
reportPublishFirstPacket(isRepublish: boolean, callid: string, startTime: number, publishTime: number, joinTime: number, tckid: string, pcTraceId: string, traceId: string, reason: PublishReason): void;
/**
* 停止推流事件上报
* @param {string} callid
* @param {number} unpubTime
* @param {number} result
* @param {string} tid
*/
reportUnpublish(callid: string, unpubTime: number, result: number, tid: string): void;
/**
* 订阅事件埋点
* @param {string} callid
* @param {string} remoteid
* @param {boolean} isLargeVideo
* @param {boolean} isSmallVideo
* @param {boolean} isScreenShare
* @param {boolean} isAudio
* @param {number} result
* @param {string} tid
* @param {number} subTime
*/
reportSubscribe(callid: string, remoteid: string, isLargeVideo: boolean, isSmallVideo: boolean, isScreenShare: boolean, isAudio: boolean, result: number, tid: string, subTime: number, logInfo: LogInfo): void;
reportSubscribeFirstPacket(isResume: boolean, callid: string, remoteid: string, trackId: string, logInfo: LogInfo): void;
reportSubscribeFirstFrame(isResume: boolean, callid: string, remoteid: string, trackId: string, logInfo: LogInfo): void;
/**
* 停止订阅事件埋点
* @param {string} callid
* @param {string} remoteid
* @param {number} unsubTime
* @param {number} result
* @param {string} tid
*/
reportUnsubscribe(callid: string, remoteid: string, unsubTime: number, result: number, tid: string): void;
reportMute(callid: string, enable: boolean, type: 'audio' | 'video' | 'screen'): void;
/**
* 更新角色埋点
* @param {string|undefined} or 旧的角色
* @param {string} nr 新的角色
*/
reportRoleUpdate(or: string | undefined, nr: string): void;
/**
* 更新角色埋点
* @param {string|undefined} or 旧的角色
* @param {string} nr 新的角色
*/
reportRoleUpdateResult(or: string | undefined, nr: string, ctm: number, result: number): void;
/**
* 设置camera videoprofile
*/
reportVideoProfile(profile: string): void;
/**
* 设置screenshare videoprofile
*/
reportScreenProfile(profile: string): void;
/**
* 错误事件埋点
* @param err
*/
reportError(err: any): void;
/**
* 错误事件埋点
* @param err
*/
reportWarning(msg: string): void;
reportRoomServerEvent(isRequest: boolean, type: string, requestId: string, content: any): void;
reportTranscodingError(result: number, taskid: string): void;
reportBye(result: number): void;
reportAudio(error: any, cost: number, deviceName: string): void;
reportScreen(error: any, cost: number): void;
reportScreenStop(error: any): void;
reportSwitchCamera(deviceId: string): void;
reportPublishProfile(trackId: string, logInfo: LogInfo): void;
reportSDKCreated(startTs: number): void;
reportJoinInvoked(authInfo: AliRtcAuthInfo): void;
reportJoinResult(error: any): void;
reportSTSResult(code: number, startTs: number): void;
reportLeaveInvoked(): void;
reportSEIMessage(payloadType: number, length: number, repeatCount: number, delay: number, isKey: boolean): void;
/**
* 接通耗时事件（12001）
* 用stage和status来区分接通过程中各个时间节点。
* @param state
* @param status
* @param calid
* @param tckid
*/
reportConnectionLatencyEvent(stage: Stage, status: ValidStatusMap[Stage], calid: string, tckid: string, tm?: number, ntptm?: number, http?: boolean): void;
/**
* 日志埋点
* 在埋点中增加tm字段，表示发生埋点的客户端本地时间
* @param {any} param 埋点内容
*/
protected log(param: any): void;
/**
* 将Object转换成string
* @param {any} data
* @returns {string}
*/
protected data2String(data: any): string;
}
declare interface SLSSTSToken {
access_key_id: string;
access_key_secret: string;
expiration: number;
log_store_debug: string;
log_store_stats: string;
project: string;
region_endpoint: string;
security_token: string;
}
declare interface SLSToken {
access_key_id: string;
access_key_secret: string;
security_token: string;
region_endpoint: string;
project: string;
log_store_stats: string;
log_store_debug: string;
expiration: number;
}
/**
* Websocket类
*/
declare class Socket extends default_2 {
/**
* @ignore
*/
static logName: string;
protected ws?: WebSocket;
protected socketStatus: CONNECTSTATUS;
protected wsUrl: string;
protected lastConnectStartTime: number;
protected maxConnectRetryCount: number;
connectRetryCount: number;
protected gotErr: boolean;
protected closedByInvoke: boolean;
protected isReconnecting: boolean;
protected networkAvailableChecked: boolean;
private reconnectTimeoutId;
constructor(maxConnectRetryCount?: number);
get connectUrl(): string;
/**
* 返回websocket连接的状态
*/
get connectStatus(): CONNECTSTATUS;
/**
* 开始连接
* @param wsUrl
*/
start(wsUrl: string): void;
/**
* 发送消息
* @param pkg
*/
send(pkg: ISendPackage | IResponse): boolean;
/**
* 主动断开连接
*/
close(): void;
reconnect(): void;
/**
* 连接成功
* @param event
*/
protected onOpen(event: Event): void;
/**
* 收到消息
* @param event
*/
protected onMessage(event: MessageEvent): void;
/**
* 收到错误
* @param event
*/
protected onError(event: Event): void;
/**
* 连接断开
* @param event
*/
protected onClose(event: CloseEvent): Promise;
/**
* 初始化websocket
*/
protected initWebSocket(): void;
/**
* 反初始化websocket
*/
protected uninitWebsocket(): void;
}
/**
* Socket的支持的事件
*/
declare interface SocketListener {
onOpen: (event: Event) => void;
onMessage: (event: MessageEvent) => void;
onError: (event: Event) => void;
onClose: (event: CloseEvent) => void;
onConnectFail: () => void;
onAuthInvalid: () => void;
onNetworkError: () => void;
onReconnectStart: () => void;
onReconnectFail: (event: Event) => void;
}
declare interface StopPreviewConfig {
videoElement?: HTMLVideoElement;
primary?: boolean;
screen?: boolean;
}
declare type StopPublishOptions = StreamOptions;
declare interface StreamListener {
[DeviceStatusChange.Remote]: (event: DeviceStatusChangeType) => void;
error: (err: AliRtcError) => void;
}
declare interface StreamOptions {
audio?: boolean;
video?: boolean;
screen?: boolean;
data?: boolean;
}
declare class StsManager extends default_2 {
static logName: string;
private env;
private authInfo?;
private timer?;
private slsReporter;
private expiration;
private skipTime;
constructor(slsReporter: SLSReporter, env: AliRtcEnv);
refreshAuthInfo(authInfo: AliRtcAuthInfo): void;
private requestToken;
startSTSUpdate(authInfo: AliRtcAuthInfo): void;
clear(): void;
}
declare interface StsManagerListener {
onTokenUpdate: (ossToken: OSSToken, slsToken: SLSToken) => void;
}
declare interface SubConfig {
isAudioSubscribing: boolean;
isVideoSubscribing: boolean;
isScreenSubscribing: boolean;
audioEnabled: boolean;
videoEnabled: boolean;
screenEnabled: boolean;
}
declare type SubscribeOptions = StreamOptions & {
aMsid?: string;
vMsid?: string;
};
declare enum SubscribeReason {
InRoom = "inRoom",
Join = "join",
Publish = "publish",
User = "user",
Resume = "resume",
Retry = "retry",
Reconnect = "reconnect"
}
declare interface TimeRecorder {
start: number;
[key: string]: number;
}
declare enum TrackEvent_2 {
VideoTrackEnded = "videoTrackEnded",
AudioTrackEnded = "audioTrackEnded",
ScreenTrackEnded = "screenTrackEnded"
}
declare interface TrackInfo {
ssrc: string;
codec: string;
msid?: MsidType;
type: string;
from?: string | undefined;
userdata?: string;
trackId?: string;
attr?: Record;
pt?: number;
}
declare type UnSubscribeOptions = SubscribeOptions;
declare interface UpdateTracksResult {
restoreSub?: boolean;
}
declare class User extends default_2 {
protected uid: string;
protected name: string;
protected rtsManager: RtsManager;
callId: string;
protected audioLevelMonitor: AudioLevelMonitor;
protected audioVolumeIndicationInterval: number;
constructor(userId: string, displayname: string, rtsManager: RtsManager, interval: number);
get userId(): string;
get displayname(): string;
protected createCallId(): void;
setUserInfo(uid: string, displayName: string): void;
refreshUserInfo(uid: string): void;
/**
* 获取音频 level
*/
getAudioLevel(): number;
enableAudioVolumeIndication(interval: number): void;
/**
* 销毁用户，清空数据
*/
clear(): void;
}
declare interface UserListener {
[DeviceStatusChange.Local]: (status: string) => void;
[DeviceStatusChange.Remote]: (event: DeviceStatusChangeType, userId: string) => void;
[ClientEventType.PullStreamStats]: (userId: string, stat: any, pullStreamUrl: string) => void;
[ClientEventType.RtsSubscribeExceeds]: (userId: string, options?: SubscribeOptions) => void;
[TrackEvent_2.VideoTrackEnded]: () => void;
[TrackEvent_2.AudioTrackEnded]: () => void;
[TrackEvent_2.ScreenTrackEnded]: () => void;
remoteTrackAvailableChange: (uid: string, aliRtcAudioTrack: AliRtcAudioTrack, aliRtcVideoTrack: AliRtcVideoTrack) => void;
audioSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
videoSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
screenSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
dataSubscribeStateChanged: (uid: string, oldState: AliRtcSubscribeState, newState: AliRtcSubscribeState, elapseSinceLastState: number) => void;
audioPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
videoPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
dualStreamPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
screenPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
dataPublishStateChanged: (oldState: AliRtcPublishState, newState: AliRtcPublishState, elapseSinceLastState: number) => void;
localDeviceException: (localDeviceType: AliRtcEngineLocalDeviceType, localDeviceExceptionType: AliRtcEngineLocalDeviceExceptionType, description: string) => void;
publishDataError: (error: AliRtcError) => void;
remoteAudioAutoPlayFail: (uid: string) => void;
remoteVideoAutoPlayFail: (uid: string, track: AliRtcVideoTrack) => void;
remoteAudioPlayError: (uid: string, reason?: string) => void;
remoteVideoPlayError: (uid: string, reason?: string) => void;
remoteSubscribeError: (error: AliRtcError) => void;
occurError: (error: AliRtcError) => void;
remoteDataChannelMessage: (uid: string, message: AliRtcDataChannelMsg) => void;
}
declare type ValidStatusMap = {
[ConnectionLatencyStage.CREATE_ENGINE]: ConnectionLatencyStatus.START | ConnectionLatencyStatus.END;
[ConnectionLatencyStage.JOIN]: ConnectionLatencyStatus.START | ConnectionLatencyStatus.SEND_SIG | ConnectionLatencyStatus.RECV_RST | ConnectionLatencyStatus.END;
[ConnectionLatencyStage.FIRST_REMOTE]: ConnectionLatencyStatus.RECEIVED | ConnectionLatencyStatus.DECODED | ConnectionLatencyStatus.PLAYED;
[ConnectionLatencyStage.RECV_NOTIFY_PUBLISH]: any;
[ConnectionLatencyStage.HANDLE_PUB_TASK]: ConnectionLatencyStatus.START | ConnectionLatencyStatus.END;
[ConnectionLatencyStage.HANDLE_SUB_TASK]: ConnectionLatencyStatus.START | ConnectionLatencyStatus.END;
};
declare type VideoProfileWithSendFramerate = Partial;
declare interface VideoScaler {
getVideoTrack: () => MediaStreamTrack;
updateOptions: (options: VideoScalerOptions) => void;
dispose: () => void;
}
declare class VideoScalerFactory {
static isSupport(): boolean;
/**
* 获取实例
* @param {MediaStreamTrack} videoTrack
* @param {IProfile} profile
* @return {VideoScaler}
*/
static getInstance(videoTrack: MediaStreamTrack, options: VideoScalerOptions): VideoScaler;
}
declare interface VideoScalerOptions {
width: number;
height: number;
frameRate: number;
}
declare enum VideoStreamSource {
Camera = 0,
Screen = 1,
Image = 2
}
declare const WrappedAliRtcEngine: typeof AliRtcEngine_2;
declare type WrappedAliRtcEngine = InstanceType;
export { WrappedAliRtcEngine as AliRtcEngine }
export default WrappedAliRtcEngine;
export { }