@rongcloud/plugin-call 5.2.3 → 5.2.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { ConversationType, IReceivedMessage, EventEmitter, RTCPluginContext, IRuntime, ILogger, RTCJoinType, LogLevel, LogL, BasicLogger, IRTCJoinedInfo, IPluginGenerator } from '@rongcloud/engine';
+import { ILogger, ConversationType, RTCJoinType, LogLevel, LogL, IPushConfig as IPushConfig$1, IReceivedMessage, EventEmitter, RTCPluginContext, IRuntime, BasicLogger, IRTCJoinedInfo, IPluginGenerator } from '@rongcloud/engine';
 import { RCRTCClient, IMicphoneAudioProfile, RCTrack, RCRTCCode, IRCRTCStateReport, RCRTCPingResult, RCLocalTrack, ICameraVideoProfile } from '@rongcloud/plugin-rtc';
 export { IRCRTCStateReport } from '@rongcloud/plugin-rtc';
 
@@ -84,7 +84,11 @@ declare enum RCCallErrorCode {
     /**
     * 不在room中禁用音视频
     */
-    NOT_IN_ROOM_ERROR = 53312
+    NOT_IN_ROOM_ERROR = 53312,
+    /**
+     * 参数错误
+     */
+    PARAM_ERROR = 53313
 }
 
 /**
@@ -280,1248 +284,1222 @@ declare enum RCCallUserState {
     KEEPING = 2
 }
 
-interface IEndSummary {
+/**
+ * 产生session的场景
+ */
+declare enum ProduceTypes {
     /**
-     * 通话类型
+     * 主叫
      */
-    conversationType: ConversationType;
+    CALLER = 1,
     /**
-     * 多组织 ID
+     * 被叫
      */
-    channelId: string;
+    CALLEE = 2
+}
+
+declare class RCCallSession {
     /**
-     * 目标 ID
+     * 状态机实例
      */
-    targetId: string;
+    private _stateMachine;
     /**
-     * 通话媒体类型
+     * rtc实例
      */
-    mediaType: RCCallMediaType;
+    private readonly _rtcClient;
+    private readonly _logger;
     /**
-     * 通话开始时间戳
+     * session的其它选项
      */
-    beginTimestamp: number;
+    private _options;
     /**
-     * 通话结束时间戳
+     * RTC房间实例
      */
-    endTimestamp: number;
+    private _room;
     /**
-     * 通话时间
+     * 用户传进来的 对session的监听 (要在RCCallClient的_onInvite里判断，要求执行完onSession必须注册session的监听，所以这里是public)
      */
-    duration: number;
+    _listener: ISessionListener | null;
     /**
-     * 通话结束原因
+     * RTC订阅、发布重试的次数
      */
-    endReason: RCCallEndReason;
-}
-interface IUserProfile {
+    private readonly _RETRYCOUNT;
     /**
-     * 用户名
+     * 加入房间定时器
      */
-    name?: string;
+    private joinRoomTimer;
+    constructor(
     /**
-     * 用户头像地址
+     * 状态机实例
      */
-    portraitUri?: string;
+    _stateMachine: RCCallStateMachine, 
     /**
-     * user info 中附加信息
+     * rtc实例
      */
-    extra?: string;
-}
-/**
- * 通话发起者信息
- */
-interface ISenderInfo extends IUserProfile {
+    _rtcClient: RCRTCClient, _logger: ILogger, 
     /**
-     * 发起者 userId
+     * session的其它选项
      */
-    userId: string;
-}
-interface IUserData extends IUserProfile {
+    _options?: IRCCallSessionOptions);
     /**
-     * 用户 ID
+     *  加入房间
      */
-    userId: string;
+    private _joinRoom;
     /**
-     * 用户 状态
+     * (初始化房间的时候) 订阅远程的流，把远程的流抛给用户
      */
-    state: RCCallUserState;
+    private _subscribeInRoomRemoteTrack;
     /**
-     * 是否是通话发起者
+     * 可以重试的订阅
+     * @param params.tracks tracks
+     * @param params.isAllowSubscribeRetry 是否允许重试
+     * @param params.count 允许重试的次数
      */
-    isCaller: boolean;
+    private _subscribeRetry;
     /**
-     * 是否是远端用户
+     * 发布本地资源的逻辑
+     *
      */
-    isRemote: boolean;
+    private _publish;
     /**
-     * 用户 deviceId
-     * 主要用于记录远端的用户的 deviceId, 用于处理多端消息
+     * 可以重试的发布
+     * @param params.tracks tracks
+     * @param params.isAllowPublishRetry 是否允许重试
+     * @param params.count 允许重试的次数
      */
-    deviceId?: string;
-}
-interface IUserStateChangeInfo {
+    private _publishRetry;
     /**
-     * 用户数据
+     * 退出房间
      */
-    user: IUserData;
+    private _leaveRoom;
     /**
-     * 挂断原因（ user.state 为 RCCallUserState.NONE 时返回）
+     * 出现异常后要处理的逻辑,
+     * @param endReason 原因
      */
-    reason?: RCCallEndReason;
-}
-interface IStateChangeInfo {
+    private _exceptionClose;
     /**
-     * 状态
+     * 用户调用的，注册session上的监听
      */
-    state: RCCallSessionState;
+    registerSessionListener(listener: ISessionListener): void;
     /**
-     * state 为 RCCallSessionState.END 时返回
+     * 调RTC API 获得本地流
      */
-    reason?: RCCallEndReason;
-}
-declare type IInvitedUsers = ISenderInfo;
-interface IMemberModifyInfo {
+    private _getLocalTrackCore;
+    private _getLocalTrack;
     /**
-     * 发起者信息
+     * 通话中更换音频设备
      */
-    sender: ISenderInfo;
+    changeAudioDevice(audioConstraints?: IMicphoneAudioProfile): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 被邀请用户 ID 列表
+     * 群呼叫中继续邀请
+     * @param userIds 被邀请用户 ID 列表
+     * @param options.extra 消息的扩展信息
+     * @deprecated 5.1.2 废弃 options.pushTitle 通知的标题
+     * @deprecated 5.1.2 废弃 options.pushContent 通知内容
      */
-    invitedUsers: IInvitedUsers[];
-}
-interface IMediaModifyInfo {
+    invite(userIds: string[], options?: IInviteOptions): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 发起者信息
+     * 同意接听
      */
-    sender: ISenderInfo;
+    accept(constraints?: IMediaStreamConstraints): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 修改后的媒体类型
+     * 挂断
      */
-    mediaType: RCCallMediaType;
-}
-interface ICallStateMachineWatchers {
+    hungup(): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 用户状态变更
-     * @param info
+     * 通话媒体变更
+     *  @param mediaType RCCallMediaType.AUDIO 改为音频通话 | RCCallMediaType.AUDIO_VIDEO 改为音视频通话
      */
-    onUserStateChange: (info: IUserStateChangeInfo) => void;
+    _changeMediaType(mediaType: RCCallMediaType): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 房间状态变更
-     * @param info
+     * 获得本地视频
      */
-    onStateChange: (info: IStateChangeInfo) => void;
+    private _getLocalVideoTracks;
     /**
-     * 收到响铃
-     * @param sender 发起用户信息
+     * 获得本地音频
      */
-    onRinging: (sender: ISenderInfo) => void;
+    private _getLocalAudioTracks;
     /**
-     * 收到接听
-     * @param sender 发起用户信息
+     * 把通话的MediaType升级到音视频
      */
-    onAccept: (sender: ISenderInfo) => void;
+    private _setMediaTypeToAudioAndVideo;
     /**
-     * 收到挂断
+     * 把通话的MediaType降级到音频
+     * @param isSendMesssage 是否需要发消息, 默认发消息
      */
-    onHungup: (sender: ISenderInfo, reason: RCCallEndReason) => void;
+    private _setMediaTypeToAudio;
     /**
-     * 收到人员变更
-     * @param sender 发起用户信息
+     * 通话降级，目前需求只做通话降级，音视频可以降级为音频，音频不能升到音视频, 发消息成功才算降级成功
+     *
      */
-    onMemberModify: (info: IMemberModifyInfo) => void;
+    descendAbility(): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 收到通话类型变更
-     * @param sender 发起用户信息
+     * 禁用视频track
      */
-    onMediaModify: (info: IMediaModifyInfo) => void;
+    disableVideoTrack(): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 是否跨appkey
-     * @param ifCross 是否为跨appkey通信
+     * 启用视频track
      */
-    crossAppkey: (ifCross: boolean) => void;
-}
-/**
- * 发送邀请时的可选项
- */
-interface IInviteOptions {
+    enableVideoTrack(): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 消息的扩展信息
+     * 禁用音频track
      */
-    extra?: string;
+    disableAudioTrack(): Promise<{
+        code: RCCallErrorCode;
+    } | undefined>;
     /**
-     * 对方显示通知的标题
+     * 启用音频track
      */
-    pushTitle?: string;
+    enableAudioTrack(): Promise<{
+        code: RCCallErrorCode;
+    } | undefined>;
     /**
-     * 对方显示的通知内容
+     * 销毁本地流
      */
-    pushContent?: string;
-}
-
-/**
- * 注释
- * TODO
- */
-declare enum MsgCallStatus {
-    OUTGOING = 1,
-    INCOMING = 2,
-    RINGING = 3,
-    CONNECTED = 4,
-    IDLE = 5,
-    ACCEPTED = 6
-}
-
-interface IOfflineRecord {
-    channelId: string;
-    conversationType: ConversationType;
-    targetId: string;
-    mediaType: RCCallMediaType;
-    callId: string;
-    inviterId: string;
-    endReason: RCCallEndReason;
-    beginTimestamp: number;
-    endTimestamp: number;
-    duration: number;
-}
-
-interface ISendBaseOptions {
+    private _destroyTracks;
     /**
-     * 组织 ID
+     * 向外抛出本地流
      */
-    channelId: string;
+    private _notifyTrackReady;
     /**
-     * 会话类型
+     * 房间上注册事件
      */
-    conversationType: ConversationType;
+    private _registerRoomEventListener;
     /**
-     * 目标 ID (单聊：对方 Id;群聊： 群组 Id)
+     * 注册房间质量数据监听器
      */
-    targetId: string;
-}
-interface IExistedUserPofiles {
+    private _registerReportListener;
     /**
-     * 用户 ID
+     *  通话唯一标识
      */
-    userId: string;
+    getSessionId(): string;
     /**
-     * 通话类型
+     *  获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新，(用户录制资源用的)
      */
-    mediaType: RCCallMediaType;
+    getRTCSessionId(): string | null;
     /**
-     * 与移动端一致的通话状态
+     *  目标 ID，单呼对方人员 Id, 群呼群组 Id
      */
-    callStatus: MsgCallStatus;
+    getTargetId(): string;
     /**
-     * PC 端 mediaId 直接传 userId, mediaId iOS 需要解出来渲染视图用。
+     *  获取会话类型
      */
-    mediaId?: string;
-}
-interface IMsgListener {
-    onInvite?: (msg: IReceivedMessage) => void;
-    onRinging?: (msg: IReceivedMessage) => void;
-    onAccept?: (msg: IReceivedMessage) => void;
-    onMemberModify?: (msg: IReceivedMessage) => void;
-    onMediaModify?: (msg: IReceivedMessage) => void;
-    onHungup?: (msg: IReceivedMessage) => void;
-    sendAccept?: (info: {
-        callId: string;
-    }) => void;
-    onOfflineRecord?: (record: IOfflineRecord) => void;
-}
-interface IInviteMsgOptions extends ISendBaseOptions {
+    getConversationType(): ConversationType;
     /**
-     * 呼叫 ID（ RTC 房间 ID ）
+     *  组织 ID
      */
-    callId: string;
+    getChannelId(): string;
     /**
-     * 通话媒体类型
+     * 房间人员列表，不包含本端信息
      */
-    mediaType: RCCallMediaType;
+    getRemoteUsers(): IUserData[];
     /**
-     * 被邀请人用户 ID 列表
+   * 房间人员列表，不包含本端信息
+   */
+    getUsers(): IUserData[];
+    /**
+     * 获取人员状态
      */
-    inviteUserIds: string[];
+    getUserState(userId: string): RCCallUserState;
     /**
-     * 扩展信息
+     * 获取session状态
      */
-    extra: string;
+    getState(): RCCallSessionState;
     /**
-     * 对方显示通知的标题
+     * 获得会话发起者id
      */
-    pushTitle?: string;
+    getCallerId(): string;
+    /**
+     * 获得mediaType
+     */
+    getMediaType(): RCCallMediaType;
+}
+
+interface ISender {
+    userId: string;
     /**
-    * 对方显示的通知内容
+    * 用户名
     */
-    pushContent?: string;
+    name?: string;
     /**
-      * 跨appkey参数
-      */
-    roomType?: number;
+    * 用户头像地址
+    */
+    portraitUri?: string;
+    /**
+    * user info 中附加信息
+    */
+    extra?: string;
 }
-interface IMemberModifyMsgOptions extends ISendBaseOptions {
+interface IMuteUser extends ISender {
     /**
-     * 呼叫 ID（ RTC 房间 ID ）
+     * 是否禁用
      */
-    callId: string;
+    muted: boolean;
     /**
-     * 通话媒体类型
+     * track类型
      */
-    mediaType: RCCallMediaType;
+    kind: string;
     /**
-     * 被邀请人用户 ID 列表
+     * trackId
      */
-    inviteUserIds: string[];
+    trackId: string;
+}
+/**
+ * CallLib 初始化参数
+ */
+interface IRCCallInitOptions {
     /**
-     * 获取会话发起者 Id
+     * RTC实例
      */
-    callerId: string;
+    rtcClient: RCRTCClient;
     /**
-     * 当前通话中的所有人，包含未接听用户
+     * 收到邀请后，产生新的session
      */
-    existedUserPofiles: IExistedUserPofiles[];
+    onSession: (session: RCCallSession, extra?: string) => void;
     /**
-     * 当前通话中的所有人，包含未接听用户
+     * session已关闭
      */
-    directionalUserIdList: string[];
+    onSessionClose: (session: RCCallSession, summary?: IEndSummary) => void;
     /**
-     * 扩展信息
+     * 离线期间收到的呼叫记录
+     * @param record
+     * @returns
      */
-    extra: string;
+    onOfflineRecord?: (record: IOfflineRecord) => void;
     /**
-     * 对方显示通知的标题
+     * 是否允许接听新呼叫，当前正在通话，如果收到新的邀请，是直接挂断，还是允许选择, 默认值false,直接挂断新的session
+     *
+     * 暂不对外暴露
      */
-    pushTitle?: string;
     /**
-     * 对方显示的通知内容
-     */
-    pushContent?: string;
-}
-interface IRingingMsgOptions extends ISendBaseOptions {
+    * 是否允许订阅重试， 默认为false
+    */
+    isAllowSubscribeRetry?: boolean;
     /**
-     * 呼叫 ID（ RTC 房间 ID ）
+     * 是否允许发布重试， 默认为false
      */
-    callId: string;
+    isAllowPublishRetry?: boolean;
     /**
-     * 群呼中需要接收响铃的用户 ID 列表
+     * 禁用视频时关摄像头, 默认false
      */
-    userIds?: string[];
-}
-interface IAcceptMsgOptions extends ISendBaseOptions {
+    isOffCameraWhenVideoDisable?: boolean;
     /**
-     * 呼叫 ID（ RTC 房间 ID ）
+     * RTC 房间加入类型
      */
-    callId: string;
+    joinType?: RTCJoinType;
     /**
-     * 通话媒体类型
+     * 允许降级获得流，获得音视频不成功 ，降级获得音频
      */
-    mediaType: RCCallMediaType;
+    isAllowDemotionGetStream?: boolean;
     /**
-     * 群呼中需要接收接听消息的用户 ID 列表
+     * 该参数已废弃，请使用 `logOutputLevel` 替代
+     * @deprecated - version 5.2.2
      */
-    userIds: string[];
-}
-interface IHungupMsgOptions extends ISendBaseOptions {
+    logLevel?: LogLevel;
     /**
-     * 呼叫 ID（ RTC 房间 ID ）
+     * 日志输出等级
+     * @since version 5.2.2
      */
-    callId: string;
+    logOutputLevel?: LogL.DEBUG | LogL.INFO | LogL.WARN | LogL.ERROR;
     /**
-     * 挂断原因
+     * 该参数已废弃
+     * @deprecated - version 5.2.0
      */
-    reason: RCCallEndReason;
+    logStdout?: (logLevel: LogLevel, content: string) => void;
     /**
-     * 群呼中需要接收挂断消息的用户 ID 列表
+     * 语言设置 (推送), 不传默认为中文
      */
-    userIds: string[];
+    lang?: RCCallLanguage;
+}
+/**
+ * 呼叫、挂断推送信息
+ */
+interface IPushConfig extends Partial<IPushConfig$1> {
+}
+/**
+ * session上的监听
+ */
+interface ISessionListener {
     /**
-     * 对方显示通知的标题
+     * 当对方已响铃
      */
-    pushTitle?: string;
+    onRinging: (sender: ISender, session: RCCallSession) => void;
     /**
-     * 对方显示的通知内容
+     * 当对方已同意
      */
-    pushContent?: string;
-}
-interface IMediaModifyMsgOptions extends ISendBaseOptions {
+    onAccept: (sender: ISender, session: RCCallSession) => void;
     /**
-     * 呼叫 ID（ RTC 房间 ID ）
+     * 当对方已挂断
      */
-    callId: string;
+    onHungup: (sender: ISender, reason: RCCallEndReason, session: RCCallSession) => void;
     /**
-     * 通话媒体类型
+     * 群组通话，人员改变
      */
-    mediaType: RCCallMediaType;
+    onMemberModify: (sender: ISender, invitedUsers: IInvitedUsers[], session: RCCallSession) => void;
     /**
-     * 群呼中需要媒体变更消息的用户 ID 列表
+     * 通话降级
      */
-    userIds: string[];
-}
-
-declare type MsgListenerKeys = keyof IMsgListener;
-/**
- * 消息接收处理: 在线消息、离线消息
- * 发送消息处理: 发送不同类型消息封装
- */
-declare class CallMessageHandler extends EventEmitter {
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _logger;
+    onMediaModify: (sender: ISender, mediaType: RCCallMediaType, session: RCCallSession) => void;
     /**
-     * 离线消息处理时间间隔
+     * 当接到流
      */
-    private readonly _offlineMsgItv;
-    private readonly _getStateMachine;
-    private _watchers;
-    private _userInfo;
-    private _msgBufferList;
-    private _hadHandleMsgTimer;
-    private _offlineRecorder;
-    private _deviceId;
-    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: ILogger, 
+    onTrackReady: (track: RCTrack, session?: RCCallSession) => void;
     /**
-     * 离线消息处理时间间隔
+     * 关闭 或 开启 音频
      */
-    _offlineMsgItv: number, _getStateMachine: (callId: string) => RCCallStateMachine | null);
-    private _onMessage;
+    onAudioMuteChange: (muteUser: IMuteUser, session: RCCallSession) => void;
     /**
-     * 在线消息抛给状态机处理
+     * 关闭 或 开启 视频
      */
-    private _onRecvOnlineCallMsg;
+    onVideoMuteChange: (muteUser: IMuteUser, session: RCCallSession) => void;
     /**
-     * 消息 buffer 列表处理逻辑
-     * 1、每 20ms 检查一次 buffer list
-     * 2、取出已经延迟 200 的消息列表进行消费 | 无延迟 200ms 内消息直接递归
-     * 3、消费分为 离线消息消费逻辑、在线消息消费逻辑，消费后递归
+    * 资源订阅失败
     */
-    private _handleBufferMsgs;
-    registerEventListener(listener: IMsgListener): void;
-    registerStateMachineEvent(callId: string, funcName: MsgListenerKeys, event: (...args: any[]) => void): void;
-    unregisterStateMachineEvent(callId: string): void;
-    registerUserInfo(userInfo: IUserProfile): void;
+    onTrackSubscribeFail?: (code: RCRTCCode, session: RCCallSession) => void;
     /**
-     * 发送 IM 消息
-     */
-    private _sendCallMessage;
+    * 资源发布失败
+    */
+    onTrackPublishFail?: (code: RCRTCCode, session: RCCallSession) => void;
     /**
-     * 发送邀请消息
+     * 用于接收RTC状态数据报告
      */
-    sendInvite(options: IInviteMsgOptions): Promise<{
-        code: RCCallErrorCode;
-        message?: IReceivedMessage | undefined;
-    }>;
+    onRTCStateReport?: (report: IRCRTCStateReport, session: RCCallSession) => void;
     /**
-     * 发送人员变更消息
+     * RTC 每次 Ping 结果
      */
-    sendMemeberModify(options: IMemberModifyMsgOptions): Promise<{
-        code: RCCallErrorCode;
-        message?: IReceivedMessage | undefined;
-    }>;
+    onPing?: (result: RCRTCPingResult, session: RCCallSession) => void;
     /**
-     * 发送响铃消息
+     * ~ICE 连接状态变更通知~
+     * @since version 5.1.5
      */
-    sendRinging(options: IRingingMsgOptions): Promise<{
-        code: RCCallErrorCode;
-        message?: IReceivedMessage | undefined;
-    }>;
+    onICEConnectionStateChange?: (state: RTCIceConnectionState, session: RCCallSession) => void;
+}
+/**
+ * 创建session的options
+ */
+interface IRCCallSessionOptions {
     /**
-     * 发送同意接听消息
+     * 本地资源,用户主动发起会话的时候，会先获得本地资源
      */
-    sendAccept(options: IAcceptMsgOptions): Promise<{
-        code: RCCallErrorCode;
-        message?: IReceivedMessage | undefined;
-    }>;
+    localTracks?: RCLocalTrack[];
     /**
-     * 发送挂断消息
+     * 是否允许订阅重试， 默认为false
      */
-    sendHungup(options: IHungupMsgOptions): Promise<{
-        code: RCCallErrorCode;
-        message?: IReceivedMessage | undefined;
-    }>;
+    isAllowSubscribeRetry?: boolean;
     /**
-     * 发送媒体变更消息
+     * 是否允许发布重试， 默认为false
      */
-    sendMediaModify(options: IMediaModifyMsgOptions): Promise<{
-        code: RCCallErrorCode;
-        message?: IReceivedMessage | undefined;
-    }>;
-}
-
-declare class RCCallStateMachine {
-    private readonly _context;
-    private readonly _runtime;
-    private readonly _logger;
-    private readonly _callMsgHandler;
-    private readonly _channelId;
-    private readonly _conversationType;
-    private readonly _targetId;
-    private _mediaType;
-    private readonly _callId;
+    isAllowPublishRetry?: boolean;
     /**
-     * 房间状态
+     * 禁用视频时关摄像头, 默认false
      */
-    private _sessionState;
+    isOffCameraWhenVideoDisable?: boolean;
     /**
-     * 用户状态及信息
+     * RTC 房间加入类型
      */
-    private _userInfo;
+    joinType?: RTCJoinType;
     /**
-     * 用户计时器映射
+     * 允许降级获得流，获得音视频不成功 ，降级获得音频
      */
-    private _userTimers;
+    isAllowDemotionGetStream?: boolean;
     /**
-     * 监听器
+     * 产生session的场景，是主叫产生 或 被叫产生
      */
-    private _watchers;
+    produceType?: ProduceTypes;
+    isCrossAppkey?: boolean;
     /**
-     * 呼叫超时时间 (单位：毫秒)
+     * 呼叫推送配置
      */
-    private _callTimeout;
+    callPushConfig?: IPushConfig;
     /**
-     * 通话建立开始时间
+     * 挂断推送配置
      */
-    private _beginTimestamp;
+    hungupPushConfig?: IPushConfig;
+}
+interface IRCTrackBitrate {
     /**
-     * 通话结束时间
+     * 最大码率
      */
-    private _endTimestamp;
+    max: number;
     /**
-     * 通话结束原因
+     * 最小码率
      */
-    private _endReason;
+    min: number;
     /**
-     * 主叫 ID
-     * 发起邀请为当前用户 ID
-     * 收到邀请为 senderUserId
-     * 收到人员变更邀请为消息体中 callerId
+     * 上行起始码率
      */
-    private _callerId;
+    start?: number;
+}
+/**
+ * RCCallClient call方法的传参
+ */
+interface IRCCallParams {
+    targetId: string;
     /**
-     * 当次通话邀请者 ID
-     * 发起邀请为当前用户 ID、收到邀请为 senderUserId、收到人员变更邀请为消息体中 senderUserId
+     * 音频 or 音视频, 默认音频
      */
-    private _inviterId;
+    mediaType: RCCallMediaType;
     /**
-     * 是否是跨 appkey
+     * session上要注册的监听事件
      */
-    private _isCrossAppkey;
-    private _hungupPushTitle;
-    private _hungupPushContent;
-    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: ILogger, _callMsgHandler: CallMessageHandler, _channelId: string, _conversationType: ConversationType, _targetId: string, _mediaType: RCCallMediaType, _callId: string);
+    listener: ISessionListener;
     /**
-     * 获取校正后超时时间
+     * 组织 Id，可选
      */
-    private _getTimeout;
-    private _clearTimerById;
+    channelId?: string;
     /**
-     * 通知 call 层房间状态变更及原因
+     * 用于获取己方媒体资源的参数
      */
-    private _notifyStateChange;
+    constraints?: {
+        video?: ICameraVideoProfile;
+        audio: IMicphoneAudioProfile;
+    };
     /**
-     * 通知 call 层人员状态变更及原因
+     * 消息的扩展信息
      */
-    private _notifyUserStateChange;
-    private _otherClientHandle;
+    extra?: string;
     /**
-     * 正在通话中，且不是当前已接通用户设备（deviceId）发来的消息
+    * 对方显示通知的标题
     */
-    private _isRemoteInvalidMsg;
-    private _onRinging;
-    private _onAccept;
-    private _onMediaModify;
-    private _onHungup;
+    pushTitle?: string;
     /**
-     * 注册事件监听
-     * @params watchers
+     * 对方显示的通知内容
      */
-    registerEventListener(watchers: ICallStateMachineWatchers): void;
+    pushContent?: string;
     /**
-     * 收到 invite 消息时状态机更新（CallEngine 内部调用）
-     * @param message 接收消息
+     * 设置码率
      */
-    __onInvite(message: IReceivedMessage): void;
+    bitrate?: {
+        video?: IRCTrackBitrate;
+        audio?: number;
+    };
     /**
-     * 收到 memberModify 消息时状态机更新（CallEngine 内部调用）
-     * @param message 接收消息
+     * 是否为跨 appkey 通话
      */
-    __onMemberModify(message: IReceivedMessage): void;
+    isCrossAppkey?: boolean;
+}
+interface IMediaStreamConstraints {
+    video?: ICameraVideoProfile;
+    audio?: IMicphoneAudioProfile;
+}
+/**
+ * RCCallClient callInGroup方法的传参
+ */
+interface IRCCallInGroupParams {
+    targetId: string;
+    userIds: string[];
+    mediaType: RCCallMediaType;
     /**
-     * 处理已有 session ，不允许再接听新会话情况
+     * session上要注册的监听事件
      */
-    __handleInviteInSession(): void;
+    listener: ISessionListener;
     /**
-     * 主动呼叫 (CallEngine 内部调用)
-     * @param userIds 被邀请用户 ID 列表
-     * @param extra 消息的扩展信息
-     * @param pushTitle 通知的标题
-     * @param pushContent 通知的内容
+     * 组织 Id，可选
      */
-    __call(userIds: string[], extra?: string, pushTitle?: string, pushContent?: string, isCrossAppkey?: boolean): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    channelId?: string;
     /**
-     * 接听
+     * 用于获取己方媒体资源的参数
      */
-    accept(): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    constraints?: IMediaStreamConstraints;
     /**
-     * 群呼叫中继续邀请
-     * @param userIds 被邀请用户 ID 列表
+     * 消息的扩展信息
      */
-    invite(userIds: string[], options?: IInviteOptions): Promise<{
-        code: RCCallErrorCode;
-    }>;
-    private _hungupHandle;
+    extra?: string;
     /**
-     * 挂断
+     * 对方显示通知的标题
      */
-    hungup(pushTitle?: string, pushContent?: string): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    pushTitle?: string;
     /**
-     * 修改通话媒体类型
-     * @param mediaType RCCallMediaType.AUDIO 改为音频通话 | RCCallMediaType.AUDIO_VIDEO 改为音视频通话
-     */
-    changeMediaType(mediaType: RCCallMediaType): Promise<{
-        code: RCCallErrorCode;
-    }>;
+      * 对方显示的通知内容
+      */
+    pushContent?: string;
     /**
-     * 用户加入通话补偿机制（rtc userJoin 事件触发）
-     * 主叫呼叫后，未收到被叫 accept 消息，但收到了 userJoin 同样补偿更新用户、房间状态、呼叫计时器
+     * 设置码率
      */
-    userJoin(userIds: string[]): void;
+    bitrate?: {
+        video?: IRCTrackBitrate;
+        audio?: number;
+    };
+}
+interface IDeviceChangeParams {
+    audio?: IMicphoneAudioProfile;
+    video?: ICameraVideoProfile;
+}
+
+interface IEndSummary {
     /**
-     * 用户离开通话补偿机制（rtc userLeave、kickOff 事件触发）
-     * 通话中远端用户挂断，挂断消息未到，但是监听到 rtc userLeave 同样补偿更新用户、房间状态
+     * 通话类型
      */
-    userLeave(userIds: string[]): void;
+    conversationType: ConversationType;
     /**
-     * Call 层己方异常失败后调用的方法
-     * 触发时机：音视频服务异常、获取资源失败、加入 RTC 房间失败、发布|订阅失败
+     * 多组织 ID
      */
-    close(reason: RCCallEndReason): void;
-    setHungupPushConfig(pushConfig?: string, pushContent?: string): void;
+    channelId: string;
     /**
-     * 通话唯一标识
+     * 目标 ID
      */
-    getCallId(): string;
+    targetId: string;
     /**
-     * 多组织 ID
+     * 通话媒体类型
      */
-    getChannelId(): string;
+    mediaType: RCCallMediaType;
     /**
-     * 目标 ID，单呼对方人员 Id, 群呼群组 Id
+     * 通话开始时间戳
      */
-    getTargetId(): string;
+    beginTimestamp: number;
     /**
-     * 获取会话类型
+     * 通话结束时间戳
      */
-    getConversationType(): ConversationType;
+    endTimestamp: number;
     /**
-     * 获取远端成员 ID 列表
+     * 通话时间
      */
-    getRemoteUserIds(): string[];
-    /**
-     * 获取远端成员信息列表
-     */
-    getRemoteUsers(): IUserData[];
+    duration: number;
     /**
-     * 获取房间状态
+     * 通话结束原因
      */
-    getState(): RCCallSessionState;
+    endReason: RCCallEndReason;
+}
+interface IUserProfile {
     /**
-     * 获取人员状态
+     * 用户名
      */
-    getUserState(userId: string): RCCallUserState;
+    name?: string;
     /**
-     * 获取会话发起者 Id
+     * 用户头像地址
      */
-    getCallerId(): string;
+    portraitUri?: string;
     /**
-     * 获取当次会话邀请者 Id
+     * user info 中附加信息
      */
-    getInviterId(): string;
+    extra?: string;
+}
+/**
+ * 通话发起者信息
+ */
+interface ISenderInfo extends IUserProfile {
     /**
-     * 获取当前通话媒体类型
+     * 发起者 userId
      */
-    getMediaType(): RCCallMediaType;
+    userId: string;
+}
+interface IUserData extends IUserProfile {
     /**
-     * 通话挂断后可调用
+     * 用户 ID
      */
-    getSummary(): IEndSummary;
-}
-
-declare enum RCCallLanguage {
-    ZH = "zh",
-    EN = "en"
-}
-
-/**
- * 产生session的场景
- */
-declare enum ProduceTypes {
+    userId: string;
     /**
-     * 主叫
+     * 用户 状态
      */
-    CALLER = 1,
+    state: RCCallUserState;
     /**
-     * 被叫
+     * 是否是通话发起者
      */
-    CALLEE = 2
-}
-
-declare class RCCallSession {
+    isCaller: boolean;
     /**
-     * 状态机实例
+     * 是否是远端用户
      */
-    private _stateMachine;
+    isRemote: boolean;
     /**
-     * rtc实例
+     * 用户 deviceId
+     * 主要用于记录远端的用户的 deviceId, 用于处理多端消息
      */
-    private readonly _rtcClient;
-    private readonly _logger;
+    deviceId?: string;
+}
+interface IUserStateChangeInfo {
     /**
-     * session的其它选项
+     * 用户数据
      */
-    private _options;
+    user: IUserData;
     /**
-     * RTC房间实例
+     * 挂断原因（ user.state 为 RCCallUserState.NONE 时返回）
      */
-    private _room;
+    reason?: RCCallEndReason;
+}
+interface IStateChangeInfo {
     /**
-     * 用户传进来的 对session的监听 (要在RCCallClient的_onInvite里判断，要求执行完onSession必须注册session的监听，所以这里是public)
+     * 状态
      */
-    _listener: ISessionListener | null;
+    state: RCCallSessionState;
     /**
-     * RTC订阅、发布重试的次数
+     * state 为 RCCallSessionState.END 时返回
      */
-    private readonly _RETRYCOUNT;
+    reason?: RCCallEndReason;
+}
+declare type IInvitedUsers = ISenderInfo;
+interface IMemberModifyInfo {
     /**
-     * 加入房间定时器
+     * 发起者信息
      */
-    private joinRoomTimer;
-    constructor(
+    sender: ISenderInfo;
     /**
-     * 状态机实例
+     * 被邀请用户 ID 列表
      */
-    _stateMachine: RCCallStateMachine, 
+    invitedUsers: IInvitedUsers[];
+}
+interface IMediaModifyInfo {
     /**
-     * rtc实例
+     * 发起者信息
      */
-    _rtcClient: RCRTCClient, _logger: ILogger, 
+    sender: ISenderInfo;
     /**
-     * session的其它选项
+     * 修改后的媒体类型
      */
-    _options?: IRCCallSessionOptions);
+    mediaType: RCCallMediaType;
+}
+interface ICallStateMachineWatchers {
     /**
-     *  加入房间
+     * 用户状态变更
+     * @param info
      */
-    private _joinRoom;
+    onUserStateChange: (info: IUserStateChangeInfo) => void;
     /**
-     * (初始化房间的时候) 订阅远程的流，把远程的流抛给用户
+     * 房间状态变更
+     * @param info
      */
-    private _subscribeInRoomRemoteTrack;
+    onStateChange: (info: IStateChangeInfo) => void;
     /**
-     * 可以重试的订阅
-     * @param params.tracks tracks
-     * @param params.isAllowSubscribeRetry 是否允许重试
-     * @param params.count 允许重试的次数
+     * 收到响铃
+     * @param sender 发起用户信息
      */
-    private _subscribeRetry;
+    onRinging: (sender: ISenderInfo) => void;
     /**
-     * 发布本地资源的逻辑
-     *
+     * 收到接听
+     * @param sender 发起用户信息
      */
-    private _publish;
+    onAccept: (sender: ISenderInfo) => void;
     /**
-     * 可以重试的发布
-     * @param params.tracks tracks
-     * @param params.isAllowPublishRetry 是否允许重试
-     * @param params.count 允许重试的次数
+     * 收到挂断
      */
-    private _publishRetry;
+    onHungup: (sender: ISenderInfo, reason: RCCallEndReason) => void;
     /**
-     * 退出房间
+     * 收到人员变更
+     * @param sender 发起用户信息
      */
-    private _leaveRoom;
+    onMemberModify: (info: IMemberModifyInfo) => void;
     /**
-     * 出现异常后要处理的逻辑,
-     * @param endReason 原因
+     * 收到通话类型变更
+     * @param sender 发起用户信息
      */
-    private _exceptionClose;
+    onMediaModify: (info: IMediaModifyInfo) => void;
     /**
-     * 用户调用的，注册session上的监听
+     * 是否跨appkey
+     * @param ifCross 是否为跨appkey通信
      */
-    registerSessionListener(listener: ISessionListener): void;
+    crossAppkey: (ifCross: boolean) => void;
+}
+/**
+ * 发送邀请时的可选项
+ */
+interface IInviteOptions {
     /**
-     * 调RTC API 获得本地流
+     * 消息的扩展信息
      */
-    private _getLocalTrackCore;
-    private _getLocalTrack;
+    extra?: string;
     /**
-     * 通话中更换音频设备
+     * 移动端推送配置
      */
-    changeAudioDevice(audioConstraints?: IMicphoneAudioProfile): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    pushConfig?: IPushConfig;
+}
+
+/**
+ * 注释
+ * TODO
+ */
+declare enum MsgCallStatus {
+    OUTGOING = 1,
+    INCOMING = 2,
+    RINGING = 3,
+    CONNECTED = 4,
+    IDLE = 5,
+    ACCEPTED = 6
+}
+
+interface IOfflineRecord {
+    channelId: string;
+    conversationType: ConversationType;
+    targetId: string;
+    mediaType: RCCallMediaType;
+    callId: string;
+    inviterId: string;
+    endReason: RCCallEndReason;
+    beginTimestamp: number;
+    endTimestamp: number;
+    duration: number;
+}
+
+interface ISendBaseOptions {
     /**
-     * 群呼叫中继续邀请
-     * @param userIds 被邀请用户 ID 列表
-     * @param options.extra 消息的扩展信息
-     * @deprecated 5.1.2 废弃 options.pushTitle 通知的标题
-     * @deprecated 5.1.2 废弃 options.pushContent 通知内容
+     * 组织 ID
      */
-    invite(userIds: string[], options?: IInviteOptions): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    channelId: string;
     /**
-     * 同意接听
+     * 会话类型
      */
-    accept(constraints?: IMediaStreamConstraints): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    conversationType: ConversationType;
     /**
-     * 挂断
+     * 目标 ID (单聊：对方 Id;群聊： 群组 Id)
      */
-    hungup(): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    targetId: string;
+}
+interface IExistedUserPofiles {
     /**
-     * 通话媒体变更
-     *  @param mediaType RCCallMediaType.AUDIO 改为音频通话 | RCCallMediaType.AUDIO_VIDEO 改为音视频通话
+     * 用户 ID
      */
-    _changeMediaType(mediaType: RCCallMediaType): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    userId: string;
     /**
-     * 获得本地视频
+     * 通话类型
      */
-    private _getLocalVideoTracks;
+    mediaType: RCCallMediaType;
     /**
-     * 获得本地音频
+     * 与移动端一致的通话状态
      */
-    private _getLocalAudioTracks;
+    callStatus: MsgCallStatus;
     /**
-     * 把通话的MediaType升级到音视频
+     * PC 端 mediaId 直接传 userId, mediaId iOS 需要解出来渲染视图用。
      */
-    private _setMediaTypeToAudioAndVideo;
+    mediaId?: string;
+}
+interface IMsgListener {
+    onInvite?: (msg: IReceivedMessage) => void;
+    onRinging?: (msg: IReceivedMessage) => void;
+    onAccept?: (msg: IReceivedMessage) => void;
+    onMemberModify?: (msg: IReceivedMessage) => void;
+    onMediaModify?: (msg: IReceivedMessage) => void;
+    onHungup?: (msg: IReceivedMessage) => void;
+    sendAccept?: (info: {
+        callId: string;
+    }) => void;
+    onOfflineRecord?: (record: IOfflineRecord) => void;
+}
+interface IInviteMsgOptions extends ISendBaseOptions {
     /**
-     * 把通话的MediaType降级到音频
-     * @param isSendMesssage 是否需要发消息, 默认发消息
+     * 呼叫 ID（ RTC 房间 ID ）
      */
-    private _setMediaTypeToAudio;
+    callId: string;
     /**
-     * 通话降级，目前需求只做通话降级，音视频可以降级为音频，音频不能升到音视频, 发消息成功才算降级成功
-     *
+     * 通话媒体类型
      */
-    descendAbility(): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    mediaType: RCCallMediaType;
     /**
-     * 禁用视频track
+     * 被邀请人用户 ID 列表
      */
-    disableVideoTrack(): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    inviteUserIds: string[];
     /**
-     * 启用视频track
+     * 扩展信息
      */
-    enableVideoTrack(): Promise<{
-        code: RCCallErrorCode;
-    }>;
+    extra: string;
     /**
-     * 禁用音频track
+     * 移动端推送配置
      */
-    disableAudioTrack(): Promise<{
-        code: RCCallErrorCode;
-    } | undefined>;
+    pushConfig?: IPushConfig;
     /**
-     * 启用音频track
-     */
-    enableAudioTrack(): Promise<{
-        code: RCCallErrorCode;
-    } | undefined>;
+      * 跨appkey参数
+      */
+    roomType?: number;
+}
+interface IMemberModifyMsgOptions extends ISendBaseOptions {
     /**
-     * 销毁本地流
+     * 呼叫 ID（ RTC 房间 ID ）
      */
-    private _destroyTracks;
+    callId: string;
     /**
-     * 向外抛出本地流
+     * 通话媒体类型
      */
-    private _notifyTrackReady;
+    mediaType: RCCallMediaType;
     /**
-     * 房间上注册事件
+     * 被邀请人用户 ID 列表
      */
-    private _registerRoomEventListener;
+    inviteUserIds: string[];
     /**
-     * 注册房间质量数据监听器
+     * 获取会话发起者 Id
      */
-    private _registerReportListener;
+    callerId: string;
     /**
-     *  通话唯一标识
+     * 当前通话中的所有人，包含未接听用户
      */
-    getSessionId(): string;
+    existedUserPofiles: IExistedUserPofiles[];
     /**
-     *  获取房间当前会话 Id，当房间内已无成员时房间会回收，重新加入时 sessionId 将更新，(用户录制资源用的)
+     * 当前通话中的所有人，包含未接听用户
      */
-    getRTCSessionId(): string | null;
+    directionalUserIdList: string[];
     /**
-     *  目标 ID，单呼对方人员 Id, 群呼群组 Id
+     * 扩展信息
      */
-    getTargetId(): string;
+    extra: string;
     /**
-     *  获取会话类型
+     * 移动端推送配置
      */
-    getConversationType(): ConversationType;
+    pushConfig?: IPushConfig;
+}
+interface IRingingMsgOptions extends ISendBaseOptions {
     /**
-     *  组织 ID
+     * 呼叫 ID（ RTC 房间 ID ）
      */
-    getChannelId(): string;
+    callId: string;
     /**
-     * 房间人员列表，不包含本端信息
+     * 群呼中需要接收响铃的用户 ID 列表
      */
-    getRemoteUsers(): IUserData[];
-    /**
-   * 房间人员列表，不包含本端信息
-   */
-    getUsers(): IUserData[];
+    userIds?: string[];
+}
+interface IAcceptMsgOptions extends ISendBaseOptions {
     /**
-     * 获取人员状态
+     * 呼叫 ID（ RTC 房间 ID ）
      */
-    getUserState(userId: string): RCCallUserState;
+    callId: string;
     /**
-     * 获取session状态
+     * 通话媒体类型
      */
-    getState(): RCCallSessionState;
+    mediaType: RCCallMediaType;
     /**
-     * 获得会话发起者id
+     * 群呼中需要接收接听消息的用户 ID 列表
      */
-    getCallerId(): string;
+    userIds: string[];
+}
+interface IHungupMsgOptions extends ISendBaseOptions {
     /**
-     * 获得mediaType
+     * 呼叫 ID（ RTC 房间 ID ）
      */
-    getMediaType(): RCCallMediaType;
-}
-
-interface ISender {
-    userId: string;
+    callId: string;
     /**
-    * 用户名
-    */
-    name?: string;
+     * 挂断原因
+     */
+    reason: RCCallEndReason;
     /**
-    * 用户头像地址
-    */
-    portraitUri?: string;
+     * 群呼中需要接收挂断消息的用户 ID 列表
+     */
+    userIds: string[];
     /**
-    * user info 中附加信息
-    */
-    extra?: string;
+     * 移动端推送配置
+     */
+    pushConfig?: IPushConfig;
 }
-interface IMuteUser extends ISender {
+interface IMediaModifyMsgOptions extends ISendBaseOptions {
     /**
-     * 是否禁用
+     * 呼叫 ID（ RTC 房间 ID ）
      */
-    muted: boolean;
+    callId: string;
     /**
-     * track类型
+     * 通话媒体类型
      */
-    kind: string;
+    mediaType: RCCallMediaType;
     /**
-     * trackId
+     * 群呼中需要媒体变更消息的用户 ID 列表
      */
-    trackId: string;
+    userIds: string[];
 }
+
+declare type MsgListenerKeys = keyof IMsgListener;
 /**
- * CallLib 初始化参数
+ * 消息接收处理: 在线消息、离线消息
+ * 发送消息处理: 发送不同类型消息封装
  */
-interface IRCCallInitOptions {
-    /**
-     * RTC实例
-     */
-    rtcClient: RCRTCClient;
-    /**
-     * 收到邀请后，产生新的session
-     */
-    onSession: (session: RCCallSession, extra?: string) => void;
+declare class CallMessageHandler extends EventEmitter {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _logger;
     /**
-     * session已关闭
+     * 离线消息处理时间间隔
      */
-    onSessionClose: (session: RCCallSession, summary?: IEndSummary) => void;
+    private readonly _offlineMsgItv;
+    private readonly _getStateMachine;
+    private _watchers;
+    private _userInfo;
+    private _msgBufferList;
+    private _hadHandleMsgTimer;
+    private _offlineRecorder;
+    private _deviceId;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: ILogger, 
     /**
-     * 离线期间收到的呼叫记录
-     * @param record
-     * @returns
+     * 离线消息处理时间间隔
      */
-    onOfflineRecord?: (record: IOfflineRecord) => void;
+    _offlineMsgItv: number, _getStateMachine: (callId: string) => RCCallStateMachine | null);
+    private _onMessage;
     /**
-     * 是否允许接听新呼叫，当前正在通话，如果收到新的邀请，是直接挂断，还是允许选择, 默认值false,直接挂断新的session
-     *
-     * 暂不对外暴露
+     * 在线消息抛给状态机处理
      */
+    private _onRecvOnlineCallMsg;
     /**
-    * 是否允许订阅重试， 默认为false
+     * 消息 buffer 列表处理逻辑
+     * 1、每 20ms 检查一次 buffer list
+     * 2、取出已经延迟 200 的消息列表进行消费 | 无延迟 200ms 内消息直接递归
+     * 3、消费分为 离线消息消费逻辑、在线消息消费逻辑，消费后递归
     */
-    isAllowSubscribeRetry?: boolean;
-    /**
-     * 是否允许发布重试， 默认为false
-     */
-    isAllowPublishRetry?: boolean;
+    private _handleBufferMsgs;
+    registerEventListener(listener: IMsgListener): void;
+    registerStateMachineEvent(callId: string, funcName: MsgListenerKeys, event: (...args: any[]) => void): void;
+    unregisterStateMachineEvent(callId: string): void;
+    registerUserInfo(userInfo: IUserProfile): void;
     /**
-     * 禁用视频时关摄像头, 默认false
+     * 发送 IM 消息
      */
-    isOffCameraWhenVideoDisable?: boolean;
+    private _sendCallMessage;
     /**
-     * RTC 房间加入类型
+     * 发送邀请消息
      */
-    joinType?: RTCJoinType;
+    sendInvite(options: IInviteMsgOptions): Promise<{
+        code: RCCallErrorCode;
+        message?: IReceivedMessage | undefined;
+    }>;
     /**
-     * 允许降级获得流，获得音视频不成功 ，降级获得音频
+     * 发送人员变更消息
      */
-    isAllowDemotionGetStream?: boolean;
+    sendMemeberModify(options: IMemberModifyMsgOptions): Promise<{
+        code: RCCallErrorCode;
+        message?: IReceivedMessage | undefined;
+    }>;
     /**
-     * 该参数已废弃，请使用 `logOutputLevel` 替代
-     * @deprecated - version 5.2.2
+     * 发送响铃消息
      */
-    logLevel?: LogLevel;
+    sendRinging(options: IRingingMsgOptions): Promise<{
+        code: RCCallErrorCode;
+        message?: IReceivedMessage | undefined;
+    }>;
     /**
-     * 日志输出等级
-     * @since version 5.2.2
+     * 发送同意接听消息
      */
-    logOutputLevel?: LogL.DEBUG | LogL.INFO | LogL.WARN | LogL.ERROR;
+    sendAccept(options: IAcceptMsgOptions): Promise<{
+        code: RCCallErrorCode;
+        message?: IReceivedMessage | undefined;
+    }>;
     /**
-     * 该参数已废弃
-     * @deprecated - version 5.2.0
+     * 发送挂断消息
      */
-    logStdout?: (logLevel: LogLevel, content: string) => void;
+    sendHungup(options: IHungupMsgOptions): Promise<{
+        code: RCCallErrorCode;
+        message?: IReceivedMessage | undefined;
+    }>;
     /**
-     * 语言设置 (推送), 不传默认为中文
+     * 发送媒体变更消息
      */
-    lang?: RCCallLanguage;
+    sendMediaModify(options: IMediaModifyMsgOptions): Promise<{
+        code: RCCallErrorCode;
+        message?: IReceivedMessage | undefined;
+    }>;
 }
-/**
- * 呼叫、挂断推送信息
- */
-interface IPushConfig {
+
+declare class RCCallStateMachine {
+    private readonly _context;
+    private readonly _runtime;
+    private readonly _logger;
+    private readonly _callMsgHandler;
+    private readonly _channelId;
+    private readonly _conversationType;
+    private readonly _targetId;
+    private _mediaType;
+    private readonly _callId;
     /**
-     * 推送标题
+     * 房间状态
      */
-    pushTitle?: string;
+    private _sessionState;
     /**
-     * 推送内容
+     * 用户状态及信息
      */
-    pushContent?: string;
-}
-/**
- * session上的监听
- */
-interface ISessionListener {
+    private _userInfo;
     /**
-     * 当对方已响铃
+     * 用户计时器映射
      */
-    onRinging: (sender: ISender, session: RCCallSession) => void;
+    private _userTimers;
     /**
-     * 当对方已同意
+     * 监听器
      */
-    onAccept: (sender: ISender, session: RCCallSession) => void;
+    private _watchers;
     /**
-     * 当对方已挂断
+     * 呼叫超时时间 (单位：毫秒)
      */
-    onHungup: (sender: ISender, reason: RCCallEndReason, session: RCCallSession) => void;
+    private _callTimeout;
     /**
-     * 群组通话，人员改变
+     * 通话建立开始时间
      */
-    onMemberModify: (sender: ISender, invitedUsers: IInvitedUsers[], session: RCCallSession) => void;
+    private _beginTimestamp;
     /**
-     * 通话降级
+     * 通话结束时间
      */
-    onMediaModify: (sender: ISender, mediaType: RCCallMediaType, session: RCCallSession) => void;
+    private _endTimestamp;
     /**
-     * 当接到流
+     * 通话结束原因
      */
-    onTrackReady: (track: RCTrack, session?: RCCallSession) => void;
+    private _endReason;
     /**
-     * 关闭 或 开启 音频
+     * 主叫 ID
+     * 发起邀请为当前用户 ID
+     * 收到邀请为 senderUserId
+     * 收到人员变更邀请为消息体中 callerId
      */
-    onAudioMuteChange: (muteUser: IMuteUser, session: RCCallSession) => void;
+    private _callerId;
     /**
-     * 关闭 或 开启 视频
+     * 当次通话邀请者 ID
+     * 发起邀请为当前用户 ID、收到邀请为 senderUserId、收到人员变更邀请为消息体中 senderUserId
      */
-    onVideoMuteChange: (muteUser: IMuteUser, session: RCCallSession) => void;
-    /**
-    * 资源订阅失败
-    */
-    onTrackSubscribeFail?: (code: RCRTCCode, session: RCCallSession) => void;
-    /**
-    * 资源发布失败
-    */
-    onTrackPublishFail?: (code: RCRTCCode, session: RCCallSession) => void;
+    private _inviterId;
     /**
-     * 用于接收RTC状态数据报告
+     * 是否是跨 appkey
      */
-    onRTCStateReport?: (report: IRCRTCStateReport, session: RCCallSession) => void;
+    private _isCrossAppkey;
+    private _hungupPushConfig?;
+    constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: ILogger, _callMsgHandler: CallMessageHandler, _channelId: string, _conversationType: ConversationType, _targetId: string, _mediaType: RCCallMediaType, _callId: string);
     /**
-     * RTC 每次 Ping 结果
+     * 获取校正后超时时间
      */
-    onPing?: (result: RCRTCPingResult, session: RCCallSession) => void;
+    private _getTimeout;
+    private _clearTimerById;
     /**
-     * ~ICE 连接状态变更通知~
-     * @since version 5.1.5
+     * 通知 call 层房间状态变更及原因
      */
-    onICEConnectionStateChange?: (state: RTCIceConnectionState, session: RCCallSession) => void;
-}
-/**
- * 创建session的options
- */
-interface IRCCallSessionOptions {
+    private _notifyStateChange;
     /**
-     * 本地资源,用户主动发起会话的时候，会先获得本地资源
+     * 通知 call 层人员状态变更及原因
      */
-    localTracks?: RCLocalTrack[];
+    private _notifyUserStateChange;
+    private _otherClientHandle;
     /**
-     * 是否允许订阅重试， 默认为false
-     */
-    isAllowSubscribeRetry?: boolean;
+     * 正在通话中，且不是当前已接通用户设备（deviceId）发来的消息
+    */
+    private _isRemoteInvalidMsg;
+    private _onRinging;
+    private _onAccept;
+    private _onMediaModify;
+    private _onHungup;
     /**
-     * 是否允许发布重试， 默认为false
+     * 注册事件监听
+     * @params watchers
      */
-    isAllowPublishRetry?: boolean;
+    registerEventListener(watchers: ICallStateMachineWatchers): void;
     /**
-     * 禁用视频时关摄像头, 默认false
+     * 收到 invite 消息时状态机更新（CallEngine 内部调用）
+     * @param message 接收消息
      */
-    isOffCameraWhenVideoDisable?: boolean;
+    __onInvite(message: IReceivedMessage): void;
     /**
-     * RTC 房间加入类型
+     * 收到 memberModify 消息时状态机更新（CallEngine 内部调用）
+     * @param message 接收消息
      */
-    joinType?: RTCJoinType;
+    __onMemberModify(message: IReceivedMessage): void;
     /**
-     * 允许降级获得流，获得音视频不成功 ，降级获得音频
+     * 处理已有 session ，不允许再接听新会话情况
      */
-    isAllowDemotionGetStream?: boolean;
+    __handleInviteInSession(): void;
     /**
-     * 产生session的场景，是主叫产生 或 被叫产生
+     * 主动呼叫 (CallEngine 内部调用)
+     * @param userIds 被邀请用户 ID 列表
+     * @param extra 消息的扩展信息
+     * @param pushConfig 移动端推送配置
      */
-    produceType?: ProduceTypes;
-    isCrossAppkey?: boolean;
+    __call(userIds: string[], extra: string | undefined, pushConfig: IPushConfig, isCrossAppkey?: boolean): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 呼叫推送配置
+     * 接听
      */
-    callPushConfig?: IPushConfig;
+    accept(): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 挂断推送配置
+     * 群呼叫中继续邀请
+     * @param userIds 被邀请用户 ID 列表
      */
-    hungupPushConfig?: IPushConfig;
-}
-interface IRCTrackBitrate {
+    invite(userIds: string[], options?: IInviteOptions): Promise<{
+        code: RCCallErrorCode;
+    }>;
+    private _hungupHandle;
     /**
-     * 最大码率
+     * 挂断
      */
-    max: number;
+    hungup(): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 最小码率
+     * 修改通话媒体类型
+     * @param mediaType RCCallMediaType.AUDIO 改为音频通话 | RCCallMediaType.AUDIO_VIDEO 改为音视频通话
      */
-    min: number;
+    changeMediaType(mediaType: RCCallMediaType): Promise<{
+        code: RCCallErrorCode;
+    }>;
     /**
-     * 上行起始码率
+     * 用户加入通话补偿机制（rtc userJoin 事件触发）
+     * 主叫呼叫后，未收到被叫 accept 消息，但收到了 userJoin 同样补偿更新用户、房间状态、呼叫计时器
      */
-    start?: number;
-}
-/**
- * RCCallClient call方法的传参
- */
-interface IRCCallParams {
-    targetId: string;
+    userJoin(userIds: string[]): void;
     /**
-     * 音频 or 音视频, 默认音频
+     * 用户离开通话补偿机制（rtc userLeave、kickOff 事件触发）
+     * 通话中远端用户挂断，挂断消息未到，但是监听到 rtc userLeave 同样补偿更新用户、房间状态
      */
-    mediaType: RCCallMediaType;
+    userLeave(userIds: string[]): void;
     /**
-     * session上要注册的监听事件
+     * Call 层己方异常失败后调用的方法
+     * 触发时机：音视频服务异常、获取资源失败、加入 RTC 房间失败、发布|订阅失败
      */
-    listener: ISessionListener;
+    close(reason: RCCallEndReason): void;
+    setHungupPushConfig(pushConfig: IPushConfig): void;
     /**
-     * 组织 Id，可选
+     * 通话唯一标识
      */
-    channelId?: string;
+    getCallId(): string;
     /**
-     * 用于获取己方媒体资源的参数
+     * 多组织 ID
      */
-    constraints?: {
-        video?: ICameraVideoProfile;
-        audio: IMicphoneAudioProfile;
-    };
+    getChannelId(): string;
     /**
-     * 消息的扩展信息
+     * 目标 ID，单呼对方人员 Id, 群呼群组 Id
      */
-    extra?: string;
-    /**
-    * 对方显示通知的标题
-    */
-    pushTitle?: string;
+    getTargetId(): string;
     /**
-     * 对方显示的通知内容
+     * 获取会话类型
      */
-    pushContent?: string;
+    getConversationType(): ConversationType;
     /**
-     * 设置码率
+     * 获取远端成员 ID 列表
      */
-    bitrate?: {
-        video?: IRCTrackBitrate;
-        audio?: number;
-    };
+    getRemoteUserIds(): string[];
     /**
-     * 是否为跨 appkey 通话
+     * 获取远端成员信息列表
      */
-    isCrossAppkey?: boolean;
-}
-interface IMediaStreamConstraints {
-    video?: ICameraVideoProfile;
-    audio?: IMicphoneAudioProfile;
-}
-/**
- * RCCallClient callInGroup方法的传参
- */
-interface IRCCallInGroupParams {
-    targetId: string;
-    userIds: string[];
-    mediaType: RCCallMediaType;
+    getRemoteUsers(): IUserData[];
     /**
-     * session上要注册的监听事件
+     * 获取房间状态
      */
-    listener: ISessionListener;
+    getState(): RCCallSessionState;
     /**
-     * 组织 Id，可选
+     * 获取人员状态
      */
-    channelId?: string;
+    getUserState(userId: string): RCCallUserState;
     /**
-     * 用于获取己方媒体资源的参数
+     * 获取会话发起者 Id
      */
-    constraints?: IMediaStreamConstraints;
+    getCallerId(): string;
     /**
-     * 消息的扩展信息
+     * 获取当次会话邀请者 Id
      */
-    extra?: string;
+    getInviterId(): string;
     /**
-     * 对方显示通知的标题
+     * 获取当前通话媒体类型
      */
-    pushTitle?: string;
-    /**
-      * 对方显示的通知内容
-      */
-    pushContent?: string;
+    getMediaType(): RCCallMediaType;
     /**
-     * 设置码率
+     * 通话挂断后可调用
      */
-    bitrate?: {
-        video?: IRCTrackBitrate;
-        audio?: number;
-    };
+    getSummary(): IEndSummary;
 }
-interface IDeviceChangeParams {
-    audio?: IMicphoneAudioProfile;
-    video?: ICameraVideoProfile;
+
+declare enum RCCallLanguage {
+    ZH = "zh",
+    EN = "en"
 }
 
 declare class RCCallClient {
@@ -1544,8 +1522,14 @@ declare class RCCallClient {
      * session列表
      */
     private _sessionList;
-    private _callPushConfig;
-    private _hungupPushConfig;
+    /**
+     * 移动端呼叫推送配置
+     */
+    private _callPushConfig?;
+    /**
+     * 移动端挂断推送配置
+     */
+    private _hungupPushConfig?;
     constructor(_context: RTCPluginContext, _runtime: IRuntime, _logger: BasicLogger, _options: IRCCallInitOptions);
     /**
      * 监听onInvite
@@ -1638,13 +1622,12 @@ declare class RCCallClient {
     /**
      * 设置呼叫、挂断推送数据
      * @param callPushConfig 呼叫推送配置
-     * @param callPushConfig.pushTitle 呼叫推送标题
-     * @param callPushConfig.pushContent 呼叫推送内容
      * @param hungupPushConfig 挂断推送配置
-     * @param hungupPushConfig.pushTitle 挂断推送标题
-     * @param hungupPushConfig.pushContent 挂断推送内容
+     * @description callLib 会内置 IPushConfig 中 pushData 的赋值，业务层无需关注 pushData 字段值
      */
-    setPushConfig(callPushConfig?: IPushConfig, hungupPushConfig?: IPushConfig): void;
+    setPushConfig(callPushConfig: IPushConfig, hungupPushConfig: IPushConfig): {
+        code: RCCallErrorCode.STATE_MACHINE_EXIT | RCCallErrorCode.SEND_MSG_ERROR | RCCallErrorCode.REJECTED_BY_BLACKLIST | RCCallErrorCode.NOT_IN_GROUP | RCCallErrorCode.GET_LOCAL_AUDIO_TRACK_ERROR | RCCallErrorCode.GET_LOCAL_VIDEO_TRACK_ERROR | RCCallErrorCode.GET_LOCAL_AUDIO_AND_VIDEO_TRACK_ERROR | RCCallErrorCode.JOIN_ROOM_ERROR | RCCallErrorCode.AUDIO_PUBLISH_ERROR | RCCallErrorCode.VIDEO_PUBLISH_ERROR | RCCallErrorCode.AUDIO_AND_VIDEO_PUBLISH_ERROR | RCCallErrorCode.QUERY_JOINED_USER_INFO_ERROR | RCCallErrorCode.MISSING_VIDEO_TRACK_ERROR | RCCallErrorCode.UNPUBLISH_VIDEO_ERROR | RCCallErrorCode.CONVERSATION_NOT_GROUP_ERROR | RCCallErrorCode.NOT_IN_ROOM_ERROR | RCCallErrorCode.PARAM_ERROR;
+    } | undefined;
 }
 
 declare const installer: IPluginGenerator<RCCallClient, IRCCallInitOptions>;