@rongcloud/plugin-call-plus
Version:
@rongcloud/plugin-call-plus
2,545 lines (2,518 loc) • 99.2 kB
TypeScript
import { RCConnectionStatus, EventEmitter, BasicLogger, PluginContext, IRuntime, EnableLogL, IReceivedMessage, IPluginGenerator } from '@rongcloud/engine';
import { RCRemoteTrack, RCTrack, ISubscribeAttr, RCRTCCode, RCLocalAudioTrack, RCRemoteAudioTrack, RCRTCClient, RCRTCRoom, RCLocalTrack, IPublishAttrs, IPubSuccessRes, RCFrameRate, RCResolution } from '@rongcloud/plugin-rtc';
export { RCFrameRate as RCCallPlusFrameRate, RCResolution as RCCallPlusResolution } from '@rongcloud/plugin-rtc';
/**
* 对话动作
*/
declare enum DialogAction {
/**
* 请求
*/
REQUEST = "request",
/**
* 接受
*/
ACCEPT = "accept",
/**
* 拒绝
*/
REFUSE = "refuse",
/**
* 请求取消
*/
CANCEL = "cancel",
/**
* 通知
*/
NOTICE = "notice",
/**
* 超时
*/
TIMEOUT = "timeout"
}
/**
* 呼叫媒体类型
*/
declare enum RCCallPlusMediaType {
/**
* 音频
*/
AUDIO = 0,
/**
* 音视频
*/
AUDIO_VIDEO = 1,
/**
* 视频
*/
VIDEO = 2
}
/**
* 通话状态
*/
declare enum RCCallPlusCallState {
/**
* 初始状态
*/
IDLE = 0,
/**
* 正在呼叫
*/
CALLING = 100,
/**
* 被邀请
*/
INVITED = 101,
/**
* 响铃
*/
RINGING = 102,
/**
* 忙线响铃
*/
BUSYLINE_RINGING = 103,
/**
* 忙线等待
*/
BUSYLINE_WAIT = 104,
/**
* 通话连接中
*/
CONNECTING = 200,
/**
* 通话中
*/
ONCALL = 300,
/**
* 通话结束
*/
ENDED = 1000,
/**
* 远端未接听
*/
NOANSWER = 1001,
/**
* 己端未接听
*/
MISSED = 1002,
/**
* 己端取消通话
*/
CANCELED = 1003,
/**
* 远端拒绝
*/
DECLINED = 1004,
ERROR = 2000
}
/**
* 呼叫类型
*/
declare enum RCCallPlusType {
/**
* 单呼
*/
SINGLE = 0,
/**
* 多人呼叫
*/
MULTI = 1
}
declare enum RCCallDirection {
/**
* 呼出
*/
OUT = -1,
/**
* 群呼
*/
GROUP = 0,
/**
* 呼入
*/
IN = 1
}
/**
* 事件类型
*/
declare enum CallServerEventType {
/**
* 提示窗口
*/
PROMPT = 0,
/**
* CallServer 下发通话时长变更类型
*/
CALL_DURATION = 10,
/**
* 收到远端第一帧时间
*/
FIRST_FRAME = 20
}
/**
* 对话类型
*/
declare enum DialogType {
SWITCH_MEDIA_TYPE = 1
}
declare enum RCCallStage {
/**
* 闲置
*/
NONE = 0,
/**
* 呼叫中
*/
CALLING = 1,
/**
* 通话中
*/
ONCALL = 2
}
declare enum RCCallUserType {
/**
* 普通用户
*/
NORMAL = 0,
/**
* 观察者（只订阅其他人的资源，不发流）
*/
OBSERVER = 1
}
/**
* 通话额外类型（移动端特有）
*/
declare enum SecretCallType {
/**
* 普通通话
*/
NORMAL = 0,
/**
* 密聊
*/
SECRET = 1
}
declare enum RCCallPlusSessionUserState {
/**
* IDLE
*/
IDLE = 0,
/**
* 发起呼叫
*/
CALLING = 100,
/**
* 被邀请
*/
INVITED = 101,
/**
* 响铃
*/
RINGING = 102,
/**
* 己方忙碌直接挂断
*/
BUSYLINE_RINGING = 103,
/**
* 己方忙碌等待接听其他通话
*/
BUSYLINE_WAIT = 104,
/**
* 通话连接中
*/
CONNECTING = 200,
/**
* 正在通话中
*/
ONCALL = 300,
/**
* 正在系统通话中
*/
ONPHONE = 301,
/**
* 通话结束
*/
ENDED = 1000,
/**
* 远端未接听
*/
NO_ANSWER = 1001,
/**
* 己端超时未接听
*/
MISSED = 1002,
/**
* 通话取消
*/
CANCELLED = 1003,
/**
* 通话拒绝
*/
DECLINED = 1004,
/**
* 异常
*/
ERROR = 2000
}
declare enum RCCallTargetType {
SIGNAL = 0,
GROUP = 1,
DEPARTMENT = 2
}
declare enum ForwardType {
/**
* 通过下一次人员状态 userState 的下发同步带下去
*/
SOON_AFETER = 0,
/**
* 立即转发
*/
CURRENT = 1
}
declare enum RCCallPlusReason {
IDLE = 0,
CALLING = 100,
INVITED = 101,
RINGING = 102,
BUSYLINE_RINGING = 103,
BUSYLINE_WAIT = 104,
CONNECTING = 200,
ONCALL = 300,
ON_PHONE = 301,
ON_PHONE_END = 302,
/**
* 输入设备不可用
*/
ON_DEVICE_DISABLE = 303,
/**
* 输入设备可用
*/
ON_DEVICE_ENABLE = 304,
/**
* 本端异常离开
*/
ABNORMAL_END = 999,
/**
* 通话结束
*/
ENDED = 1000,
/**
* 远端未接听
*/
NO_ANSWER = 1001,
/**
* 己端未接听
*/
MISSED = 1002,
/**
* 己端通话取消
*/
CANCELLED = 1003,
/**
* 远端拒绝
*/
DECLINED = 1004,
/**
* 其他端呼出(当前端被踢)
*/
OTHER_CLIENT_CALLING = 1010,
/**
* 其他端已接听
*/
OTHER_CLIENT_ACCEPT = 1011,
/**
* 加入 RTC 房间失败
*/
JOIN_ROOM_ERR = 1105,
/**
* 发布资源失败
*/
PUBLISH_ERR = 1106,
/**
* 订阅资源失败
*/
SUBSCRIBE_ERR = 1107,
/**
* 接听系统通话
*/
ACCEPT_CARRIER = 1108,
/**
* 被禁止通话
*/
KICKED_BY_SERVER = 1109,
/**
* RTC Ping 失败被踢出房间
*/
CONNECTION_ERR = 1110,
/**
* 用户退出登录被踢出房间
*/
LOGOUT = 1111,
/**
* 用户被其他端登录挤下线
*/
OTHER_CLIENT_LOGIN = 1112,
/**
* 其他端加入新通话
*/
OTHER_CLIENT_JOINED = 1113,
/**
* 其他端已在其他通话中（己端 A1 其他端正在通话中，A2 多端又加入房间被拒绝后通话结束 A2 的状态）
*/
OTHER_CLIENT_IN_ROOM = 1114,
/**
* 其他端已挂断
*/
OTHER_CLIENT_HANGUP = 1151,
/**
* 远端用户加入房间失败
*/
REMOTE_JOIN_RTC_ERROR = 1205,
/**
* 远端用户发布资源失败
*/
REMOTE_PUBLISH_ERROR = 1206,
/**
* 远端用户订阅资源失败
*/
REMOTE_SUBSCRIBE_ERROR = 1207,
/**
* 远端用户已被(封禁)禁止通话
*/
REMOTE_KICKED_BY_SERVER = 1209,
/**
* 远端用户UDP连接断开
*/
REMOTE_CONNECTION_ERROR = 1210,
/**
* 远端用户退出IM登录
*/
REMOTE_LOGOUT = 1211,
/**
* 远端用户被其他端登录挤下线
*/
REMOTE_OTHER_CLIENT_LOGIN = 1212,
/**
* 远端用户被其他端加入房间 joinRoom 踢出
*/
REMOTE_OTHER_JOINED_RTC = 1213,
/**
* 远端用户的其他端已经在房间中，不允许 joinRoom 进行音视频通话
*/
REMOTE_OTHER_CLIENT_IN_RTC = 1214
}
/**
* 用户信息
*/
interface IUser {
/**
* 用户 ID
*/
userId: string;
/**
* 用户类型 （0：正常用户 1：观察者）
*/
userType?: RCCallUserType;
/**
* 来源对象类型
*/
targetType?: RCCallTargetType;
/**
* 来源对象 ID
*/
targetId?: string;
/**
* 用户昵称（可传手机号）
*/
nickName?: string;
/**
* 组织ID
*/
orgId?: string;
}
/**
* 忙线用户列表
*/
interface IBusylineUser {
/**
* 用户 ID
*/
userId: string;
/**
* 用户状态
*/
sessionStatus: RCCallPlusSessionUserState;
}
/**
* base singal content
*/
interface IBaseSingalCon {
/**
* 服务返回的呼叫 ID
*/
callId: string;
}
/**
* 开始呼叫信令内容
*/
interface IStartCallCon {
/**
* 用户生成 callId
*/
clientCallId: string;
/**
* 目标用户信息列表
*/
toUsers: IUser[];
/**
* 呼叫类型
*/
callType: RCCallPlusType;
/**
* 通话媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 是否密聊
*/
secretChat: SecretCallType;
/**
* 当前用户的来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 当前用户的来源组 ID
*/
targetId?: string;
/**
* 发起人用户昵称(可为手机号)
*/
nickName?: string;
/**
* 正在通话中的老版房间 ID (老版 call 或 meeting)
*/
oldRoomId?: string;
/**
* 服务端接收的推送扩展
*/
pushExt?: string;
/**
* 推送内容
*/
pushContent?: string;
/**
* 附加信息，服务器透传
*/
extra?: string;
}
/**
* 单呼信令内容
*/
interface IStartSingleCon {
/**
* 用户生成 callId
*/
clientCallId: string;
/**
* 被叫用户 ID
*/
toUserId: string;
/**
* 媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 用户来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 来源组 ID
*/
targetId?: string;
/**
* 是否密聊(0: 否；1: 是)
* PC 目前无密聊，写死 0
*/
secretChat: SecretCallType;
/**
* 单聊加密 key
*/
secretChatKey?: string;
/**
* 正在通话中的老版房间 ID (老版 call 或 meeting)
*/
oldRoomId?: string;
/**
* 组织ID
*/
toOrgId?: string;
/**
* 附加信息，服务器透传
*/
extra?: string;
/**
* 服务端接收的推送扩展
*/
pushExt?: string;
/**
* 推送内容
*/
pushContent?: string;
}
/**
* 群呼信令内容
*/
interface IStartGroupCon {
/**
* 用户生成 callId
*/
clientCallId: string;
/**
* 目标用户列表
*/
toUsers: IUser[];
/**
* 通话媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 用户来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 来源组 ID
*/
targetId?: string;
/**
* 发起人用户昵称(可为手机号)
*/
nickName?: string;
/**
* 正在通话中的老版房间 ID (老版 call 或 meeting)
*/
oldRoomId?: string;
/**
* 附加信息，服务器透传
*/
extra?: string;
/**
* 服务端接收的推送扩展
*/
pushExt?: string;
/**
* 推送内容
*/
pushContent?: string;
}
/**
* 开始呼叫 Server 返回
*/
interface IStartCallRes extends IBaseSingalCon {
/**
* 传入的 clientCallId
*/
clientCallId: string;
/**
* 人员支持情况，后期可能废弃谨慎使用
*/
toUsersSupport?: {
[userId: string]: 0 | 1;
};
/**
* 占线用户列表
*/
busylineUsers?: IBusylineUser[];
}
/**
* 邀请好友加入信令内容
*/
interface IInviteCallCon extends IBaseSingalCon {
/**
* 目标用户列表
*/
toUsers: IUser[];
/**
* 附加信息，服务器透传
*/
extra?: string;
/**
* 服务端接收的推送扩展
*/
pushExt?: string;
/**
* 推送内容
*/
pushContent?: string;
}
/**
* 邀请好友加入信令结果
*/
interface IInviteCallRes extends IBaseSingalCon {
/**
* 呼叫类型
*/
callType: RCCallPlusType;
/**
* 占线用户列表
*/
busylineUsers?: IBusylineUser[];
}
/**
* server 通话用户列表
*/
interface ICallSessionUser {
/**
* 用户 ID
*/
userId: string;
/**
* 用户状态
*/
sessionStatus: RCCallPlusSessionUserState;
/**
* 状态发生时间
*/
statusTime: number;
/**
* 通话时长（单位：s）群组各人通话时长不同
*/
duration: number;
/**
* 是否变化（否：0、是：1）
*/
changed: 0 | 1;
/**
* 邀请 userId 的用户 ID
*/
inviteUserId: string;
/**
* 用户系统状态
*/
sysStatus: RCCallPlusReason;
/**
* 当前用户的来源组 ID 类型 (来源用户的群组、通讯录等等)
*/
targetType?: RCCallTargetType;
/**
* 当前用户的来源组 ID
*/
targetId?: string;
}
/**
* 通话邀请下发信令内容
*/
interface IPubInviteCon extends IBaseSingalCon {
/**
* deviceId
*/
toDeviceId: string;
/**
* 通话发起人
*/
callingUserId: string;
/**
* 本次邀请人
*/
inviteUserId: string;
/**
* 呼叫类型
*/
callType: RCCallPlusType;
/**
* 媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 是否密聊
*/
secretChat?: SecretCallType;
/**
* 通话用户列表
*/
callSessionUsers: ICallSessionUser[];
/**
* 来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 来源组 ID
*/
targetId?: string;
/**
* 附加信息
*/
extra?: string;
}
/**
* 通话响铃信令内容
*/
interface IRingingCallCon extends IBaseSingalCon {
}
/**
* 通话接听信令内容
*/
interface IAcceptCallCon extends IBaseSingalCon {
/**
* 服务端接收的推送扩展
*/
pushExt?: string;
}
/**
* 直接加入通话信令内容
*/
interface IJoinCallCon extends IBaseSingalCon {
}
/**
* 通话挂断信令内容
*/
interface IHangupCallCon extends IBaseSingalCon {
sysStatus?: RCCallPlusReason;
/**
* 服务端接收的推送扩展
*/
pushExt?: string;
/**
* 推送内容
*/
pushContent?: string;
}
/**
* 通话状态上报信令内容
*/
interface IStatusUpCon extends IBaseSingalCon {
/**
* call server 用户状态
*/
sessionStatus: RCCallPlusSessionUserState;
}
/**
* 通话状态下发信令内容
*/
interface IStatusDownCont extends IBaseSingalCon {
/**
* deviceId
*/
toDeviceId: string;
/**
* server 通话状态
*/
callStatus: RCCallPlusCallState;
/**
* 通话时长
*/
duration: number;
/**
* call server 用户信息列表
*/
callSessionUsers: ICallSessionUser[];
/**
* 通话开始时间
*/
startTime?: number;
/**
* 同步服务端时间
*/
syncTime?: number;
}
/**
* 通话事件上报
*/
interface IEventUpCallCon extends IBaseSingalCon {
/**
* 事件类型，10 打开摄像头、11 关闭摄像头
*/
eventType: CallServerEventType;
/**
* 目标用户 Id 列表
*/
toUserIds?: string[];
/**
* 事件参数
*/
eventArgs?: Object;
/**
* 事件发生时间戳
*/
eventTime: number;
}
/**
* 通话事件下发
*/
interface IEventDownCallCon extends IBaseSingalCon {
/**
* 事件类型，10 打开摄像头、11 关闭摄像头
*/
eventType: CallServerEventType;
/**
* 事件参数
*/
eventArgs?: Object;
/**
* 事件发起用户 ID
*/
fromUserId: string;
/**
* 事件发生时间戳
*/
eventTime: number;
}
/**
* 对话数据上行
*/
interface IDialogUpCallCon extends IBaseSingalCon {
/**
* 事务 ID
*/
transactionId?: string;
/**
* 对话类型
*/
dialogType: DialogType;
/**
* 对话动作
*/
action: DialogAction;
/**
* 附加数据，上传为可选
*/
extraKeyVal?: {
mediaType: RCCallPlusMediaType.AUDIO | RCCallPlusMediaType.AUDIO_VIDEO;
reason?: DialogAction;
} | {
cameraOn: 0 | 1;
};
/**
* 目标用户 Id
*/
toUserIds?: string[];
}
/**
* 对话数据下行信令内容
*/
interface IDialogDownCallCon extends IDialogUpCallCon {
/**
* 操作者 ID
*/
promoterId: string;
/**
* 同步时间戳
*/
syncTime: number;
/**
* 附加数据
*/
extraKeyVal: {
mediaType: RCCallPlusMediaType.AUDIO | RCCallPlusMediaType.AUDIO_VIDEO;
reason?: DialogAction;
};
}
/**
* 日志记录获取
*/
interface ISyncCallLogCon {
/**
* 要获取的 userId
*/
userId: string;
/**
* 同步时间戳
*/
syncTime: number;
/**
* 每页记录数 默认 30
*/
count?: number;
/**
* 正序或倒序
*/
order?: 0 | 1;
}
interface ISyncCallLogRes extends IBaseSingalCon {
callType: RCCallPlusType;
callDir: RCCallDirection;
mediaType: RCCallPlusMediaType;
/**
* 是否为密聊： 否 0、是 1
*/
secretChat: 0 | 1;
/**
* 用户 ID
*/
userId: string;
/**
* 目标 ID
*/
targetId: string;
/**
* 呼叫发起者 ID
*/
callingUserId: string;
/**
* 参与者 ID 列表
*/
callUserIds: string[];
/**
* 通话状态
*/
callStatus: RCCallPlusCallState;
/**
* 用户通话状态
*/
sessionStatus: RCCallPlusSessionUserState;
/**
* 用户系统状态
*/
sysStatus: RCCallPlusReason;
startTime: number;
endTime: number;
duration: number;
/**
* 通话创建时间
*/
crtTime: number;
/**
* 同步数据
*/
syncTime: number;
}
interface ISyncCallLogResList {
hasMore: 0 | 1;
callLogList: ISyncCallLogRes[];
/**
* 列表中最大时间戳
*/
maxTime: number;
/**
* 通话记录列表中最小的时间戳
*/
minTime: number;
/**
* 删除的列表
*/
delLogList: {
callId: string;
/**
* 当前用户 ID
*/
userId: string;
}[];
/**
* 最后已读的 callId
*/
lastReadedCallId: string;
}
/**
* 日志记录下发信令内容
*/
interface IPubCallLog extends ISyncCallLogRes {
}
interface ISignalTransporterListener {
/**
* 收到 call 邀请
* @param isDirectly 是否为直发信令
*/
onInvite(data: IPubInviteCon, isDirectly: boolean, traceId: string): void;
/**
* 收到通话状态变更
*/
onStatusDown(data: IStatusDownCont, traceId: string, sessionId?: string): void;
/**
* 其他端通话状态变更
*/
onOtherClientStatusDown(data: IStatusDownCont, traceId: string): void;
/**
* 收到设备变更相关事件
*/
onEventDown(data: IEventDownCallCon, traceId: string): void;
/**
* 收到通话结束日志
*/
onRecvCallEndLog(data: IPubCallLog, traceId: string): void;
/**
* 收到媒体类型变更
*/
onSwitchMediaType(data: IDialogDownCallCon, traceId: string): void;
/**
* IM 状态变更
*/
onIMStateChange(state: RCConnectionStatus): void;
}
interface IQryUserHasCallRes extends IBaseSingalCon {
/**
* 通话阶段
*/
hasCallStage: RCCallStage;
}
interface IGetUserCallStateListRes {
callStateList: {
callId: string;
callType: RCCallPlusType;
mediaType: RCCallPlusMediaType;
/**
* 呼叫发起者 ID
*/
callingUserId: string;
/**
* 通话参与用户 ID 列表
*/
callUserIds: string[];
/**
* 通话状态
*/
callStatus: RCCallPlusCallState;
/**
* 用户会话状态
*/
userSessionStatus: RCCallPlusSessionUserState;
/**
* 生成时间
*/
crtTime: number;
/**
* 最后一次变更时间
*/
syncTime: number;
/**
* 来源对象类型
*/
targetType: RCCallTargetType;
/**
* 来源对象ID(根据targetType分别指定个人，群组ID，默认值为userId)
*/
targetId: string;
startTime: number;
}[];
}
interface IClearCallLogRes {
/**
* 删除数量
*/
rowCount: number;
}
interface IGetCallSessionServerRes extends IBaseSingalCon {
/**
* 发起人
*/
callingUserId: string;
/**
* callType
*/
callType: RCCallPlusType;
/**
* 媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 通话状态
*/
callStatus: RCCallPlusCallState;
/**
* 通话用户人员列表信息
*/
callSessionUsers: {
userId: string;
sessionStatus: RCCallPlusSessionUserState;
statusReason: string;
statusTime: number;
sysStatus: RCCallPlusReason;
targetType: RCCallTargetType;
targetId: string;
}[];
/**
* 开始通话时间戳
*/
startTime: number;
/**
* 通话时长（单位：s）
*/
duration: number;
/**
* 同步时间戳
*/
syncTime: number;
}
interface IGetCallTimeInfoRes extends IBaseSingalCon {
/**
* 开始通话时间戳
*/
startTime: number;
/**
* 服务器当前时间
*/
syncTime: number;
/**
* 通话时长（单位：s）
*/
duration: number;
/**
* 首帧时间
*/
firstFrametime: number;
}
interface ISysStatusUpOpts extends IBaseSingalCon {
/**
* 人员系统状态
*/
sysStatus: RCCallPlusReason;
/**
* 是否立即转发（0：否 1是）
* 否的话会通过下一次人员状态 userState 的下发同步带下去
*/
forward: ForwardType;
}
interface IEndAbnormalCallOpts {
/**
* 0 当前端；1 所有端
*/
allDevice: 0 | 1;
/**
* 异常的 callId 列表
*/
callIds: string[];
}
interface IGetDelayTimeInfoRes {
/**
* 获取 CallServer 与用户本地时间的差值，用于矫正与 CallServer 的时间
*/
delayTime: number;
/**
* callServer 接口返回时间
*/
rtt: number;
}
interface ICallId {
/**
* 通话唯一 ID
*/
callId: string;
}
interface ISessionUser {
/**
* 成员 ID
*/
userId: string;
/**
* 成员状态
*/
userState: RCCallPlusSessionUserState;
/**
* 成员系统状态
*/
systemState: RCCallPlusReason;
/**
* 来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 来源组 ID
*/
targetId?: string;
/**
* 用户类型 （0：正常用户 1：观察者）
*/
userType?: RCCallUserType;
/**
* 状态时间
*/
stateTime?: number;
}
interface IRCCallPlusCallRecord {
/**
* 呼叫 ID
*/
callId: string;
/**
* 通话类型
*/
callType: RCCallPlusType;
/**
* 呼叫方向
*/
callDirection: RCCallDirection;
/**
* 通话媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 呼叫发起者 ID
*/
callerUserId: string;
/**
* 参与者 ID
*/
callUserIds: string[];
/**
* 通话状态
*/
sessionState: RCCallPlusCallState;
/**
* 用户状态
*/
userState: RCCallPlusSessionUserState;
/**
* 通话开始时间戳
*/
startTimestamp: number;
/**
* 通话结束时间戳
*/
endTimestamp: number;
/**
* 通话时长（单位：s）
*/
duration: number;
/**
* 同步时间戳
*/
syncTimestamp: number;
/**
* 用户系统状态
*/
systemState: RCCallPlusReason;
/**
* 创建时间
*/
createTimestamp: number;
}
interface IUserInfo {
/**
* 用户 ID
*/
userId: string;
/**
* 用户类型 （0：正常用户 1：观察者）
*/
userType?: RCCallUserType;
/**
* 来源对象类型
*/
targetType?: RCCallTargetType;
/**
* 来源对象 ID
*/
targetId?: string;
/**
* 组织 ID
*/
orgId?: string;
}
interface IStartCallOpts extends ICallId {
/**
* 被邀请人信息
*/
toUsers: IUserInfo[];
/**
* 通话类型
*/
callType: RCCallPlusType;
/**
* 通话媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 当前用户来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 当前用户来源组 ID
*/
targetId?: string;
/**
* 正在通话中的老版房间 ID (老版 call 或 meeting)
* 传入后，会将此房间中的多端中的自己直接踢掉
*/
oldRoomId?: string;
/**
* 推送扩展
*/
pushConfig?: IRCCallPlusPushConfig;
/**
* 附加信息，服务器透传
*/
extra?: string;
}
interface IStartCallResult {
/**
* 通话唯一 ID
*/
callId: string;
/**
* 传入的 clientCallId
*/
clientCallId: string;
/**
* 人员支持情况，后期可能废弃谨慎使用
*/
toUsersSupport?: {
[userId: string]: 0 | 1;
};
/**
* 占线用户列表
*/
busylineUsers?: IBusylineUser[];
}
interface IInviteOpts {
/**
* 被邀请人信息
*/
toUsers: IUserInfo[];
/**
* 来源组 ID 类型
*/
targetType?: RCCallTargetType;
/**
* 来源组 ID
*/
targetId?: string;
/**
* 推送扩展
*/
pushConfig?: IRCCallPlusPushConfig;
/**
* 附加信息，服务器透传
*/
extra?: string;
}
interface IInviteRes extends ICallId {
callType: RCCallPlusType;
busylineUsers?: IBusylineUser[];
}
interface IAcceptOpts extends ICallId {
/**
* 推送扩展
*/
pushConfig?: IRCCallPlusPushConfig;
}
interface IHangupForBusyOpts extends ICallId {
/**
* 用户系统状态
*/
systemState: RCCallPlusReason;
/**
* 推送扩展
*/
pushConfig?: IRCCallPlusPushConfig;
}
interface IJoinCallOpts {
callId: string;
mediaType: RCCallPlusMediaType;
}
interface IGetCallLogListOpts {
/**
* 获取时间戳之后的数据
*/
timestamp: number;
/**
* 获取数量
*/
count?: number;
/**
* 正序或倒序
*/
order?: 0 | 1;
}
interface IRCCallPlusGetCallRecordRes {
/**
* 是否有更多通话记录
*/
hasMore: boolean;
/**
* 通话记录列表
*/
list: IRCCallPlusCallRecord[];
/**
* hasMore 为 true 时，继续获取通话记录需传入的时间戳
*/
syncTime: number;
}
interface IReqChangeMediaTypeOpts {
/**
* 通话媒体类型
*/
mediaType: RCCallPlusMediaType.AUDIO | RCCallPlusMediaType.AUDIO_VIDEO;
/**
* 需要接收的用户 ID 列表
*/
toUserIds: string[];
}
interface IResChangeMediaTypeOpts {
/**
* 事务 ID
*/
transactionId: string;
/**
* 是否同意
*/
agree: boolean;
}
interface ICancelChangeMediaTypeOpts {
/**
* 事务 ID
*/
transactionId: string;
}
interface IReqChangeMediaTypeRes {
/**
* 事务 ID
*/
transactionId: string;
}
interface IGetCallSessionRes extends ICallId {
/**
* 呼叫发起者
*/
startCallerId: string;
/**
* callType
*/
callType: RCCallPlusType;
/**
* 媒体类型
*/
mediaType: RCCallPlusMediaType;
/**
* 通话状态
*/
sessionState: RCCallPlusCallState;
/**
* 通话用户人员列表
*/
callSessionUsers: ISessionUser[];
/**
* 开始通话时间戳
*/
startTime: number;
/**
* 通话时长（单位：s）
*/
duration: number;
/**
* 同步时间戳
*/
syncTime: number;
}
declare enum CallTimerEventType {
INVITER = "inviter",
INVITEE = "invitee"
}
interface IOldDialogData {
transactionId?: string;
action: DialogAction;
mediaType: RCCallPlusMediaType;
}
/**
* SDK 内部使用 Session 实例
*/
declare class RCCallInnerSession extends EventEmitter {
/**
* Call ID
*/
private readonly _callId;
/**
* session 状态
*/
private _state;
/**
* 通话类型
*/
private _callType;
/**
* 通话媒体类型
*/
private _mediaType;
/**
* session 呼叫发起者
*/
private _startCallerId;
/**
* 本次 session 的邀请者
*/
private _callerId;
/**
* 当前 session 人员信息列表
*/
private _callUsers;
private readonly _logger;
/**
* 请求更新的 mediaType
*/
private _reqMediaType;
/**
* 邀请者超时计时器
*/
private _inviterTimerId;
/**
* 被邀请者超时计时器
*/
private _inviteeTimerId;
/**
* 当前 session 人员信息列表
*/
/**
* 旧 dialog 数据，用于对比
*/
private _oldDialogData;
/**
* 记录是否本地有挂断
*/
private isLocalClientHangup;
/**
* 构造器
*/
constructor(
/**
* Call ID
*/
_callId: string,
/**
* session 状态
*/
_state: RCCallPlusCallState,
/**
* 通话类型
*/
_callType: RCCallPlusType,
/**
* 通话媒体类型
*/
_mediaType: RCCallPlusMediaType,
/**
* session 呼叫发起者
*/
_startCallerId: string,
/**
* 本次 session 的邀请者
*/
_callerId: string,
/**
* 当前 session 人员信息列表
*/
_callUsers: ISessionUser[], _logger: BasicLogger);
/**
* 获取 CallID
*/
getCallId(): string;
/**
* 获取状态
*/
getSessionState(): RCCallPlusCallState;
/**
* 获取通话类型
*/
getCallType(): RCCallPlusType;
/**
* 获取媒体类型
*/
getMediaType(): RCCallPlusMediaType;
/**
* 获取 session 发起者
*/
getStartCallerId(): string;
/**
* 本次 session 邀请者
*/
getCallerId(): string;
/**
* 获取 session user list
*/
getUserList(): ISessionUser[];
/**
* 请求更新的 mediaType
*/
getReqMediaType(): RCCallPlusMediaType | null;
/**
* inviterTimerId
*/
getInviterTimerId(): number;
/**
* inviteeTimerId
*/
getInviteeTimerId(): number;
getAllTimerIds(): number[];
/**
* 更新人员列表, 并返回更新的人员列表
* 根据人员状态去添加、删除、更新
* 根据状态时间，判断是否更新，无时间戳的为本地状态调整，直接更新
*/
updateUserList(users: ISessionUser[], traceId: string): ISessionUser[];
setOldDialogData(data: IOldDialogData): void;
/** ======私有方法============================================================================================= */
/**
* 更新 session 状态
*/
updateSessionState(state: RCCallPlusCallState): void;
/**
* 更新通话类型（升降级设置）
*/
updateCallType(callType: RCCallPlusType): void;
/**
* 更新媒体类型（升降级）
*/
updateMediaType(mediaType: RCCallPlusMediaType): void;
/**
* 更新请求的媒体类型（升降级）
*/
updateReqMediaType(mediaType: RCCallPlusMediaType | null): void;
/**
* 更新 invter timer id
*/
updateTimerId(type: CallTimerEventType, timerId: number): void;
/**
* 获取
*/
getOldDialogData(): IOldDialogData;
/**
* 设置是否是己端挂断
*/
setIsLocalClientHangup(isLocalClientHangup: boolean): void;
getIsLocalClientHangup(): boolean;
}
declare enum CallServerAction {
/**
* 开始单人呼叫
*/
START_SINGLE_CALL = "startSingleCall",
/**
* 开始多人呼叫
*/
START_GROUP_CALL = "startGroupCall",
/**
* 邀请好友加入通话
*/
INVITE_CALL = "inviteCall",
/**
* 下发邀请通话数据
*/
PUB_INVITE_CALL = "pubInviteCall",
/**
* 通话响铃
*/
RINGING_CALL = "ringCall",
/**
* 接受通话
*/
ACCEPT_CALL = "acceptCall",
/**
* 加入通话
*/
JOIN_CALL = "joinCall",
/**
* 挂断通话
*/
HANGUP_CALL = "hangupCall",
/**
* 通话状态上报
*/
STATUS_UP_CALL = "statusUpCall",
/**
* 通话状态下发
*/
STATUS_DOWN_CALL = "statusDownCall",
/**
* 通话事件上报
*/
EVENT_UP_CALL = "eventUpCall",
/**
* 通话事件下发
*/
EVENT_DOWN_CALL = "eventDownCall",
/**
* 对话数据上行
*/
DIALOG_UP_CALL = "dialogUpCall",
/**
* 对话数据下行
*/
DIALOG_DOWN_CALL = "dialogDownCall",
/**
* 获取用户会话数据列表
*/
GET_CALL_USER_SESSION_LIST = "getCallUSerSessionList",
/**
* 日志记录同步
*/
SYNC_CALL_LOG = "syncCallLog",
/**
* 日志记录下发
*/
PUB_CALL_LOG = "pubCallLog",
/**
* 批量删除通话记录
*/
DEL_CALL_LOG = "deleteCallLog",
/**
* 查询当前用户已有的 call 状态
*/
QRY_CALL_STATE = "queryUserHasCall",
/**
* 查询 callServer 当前时间戳
*/
QRY_SRV_TIMESTAMP = "getCallSrvTimeStamp",
/**
* 获取当前用户进行的 call 列表
*/
GET_CALL_STATE_LIST = "getUserCallStateList",
/**
* 清除当前用户通话记录
*/
CLEAR_CALL_LOG = "cleanCallLog",
/**
* 获取 call 会话信息
*/
GET_CALL_SESSION = "getCallSession",
/**
* 获取 call 时间信息
*/
GET_CALL_TIME_INFO = "getCallTimeInfo",
/**
* 结束当前用户异常的callSession(包含各个阶段)，主要用于应用异常退出再启动、各种通话异常当中。酌情调用
*/
END_ABNORMAL_CALL = "endUserAbnormalCalls",
/**
* 用户系统状态上报
*/
SYS_STATUS_UP = "sysStatusUp",
/**
* 上报通话记录已读状态
*/
UP_CALL_LOG_READED = "upCallLogReaded",
/**
* 下发通话记录已读状态
*/
PUB_CALL_LOG_READED = "pubCallLogReaded",
/**
* 下发下行信令数据序号Id （弱网补偿方法，移动端已实现，PC 未实现）
*/
PUB_NACK_SEQ_ID = "pubNACKSeqId",
/**
* 查询当前用户参与的未结束的callSession的CallId列表，group专用，可在groupcall结束时，补偿各端的快捷入口是否消失的判断
*/
GET_USER_CALL_SESSION_ID_LIST = "getUserCallSessionIdList"
}
declare enum RCCallPlusInnerCode {
SUCCESS = 0,
/**
* 无效的响应时间（接口响应时间过长）
*/
INVALID_RESPONSE_TIME = 80170,
/**
* 非最优响应时间
*/
NONOPTIMAL_RES_TIME = 80171
}
/**
* 校时模块
*/
declare class TimeCorrectioner {
private readonly _callEngine;
private readonly _logger;
private readonly _singleCallDurationEv;
/**
* 接口响应时间
*/
private _RTT;
/**
* 可用的接口响应时间下限（单位: ms）
*/
private _validMinRTT;
/**
* 可用的接口响应时间上限（单位: ms）
*/
private _validMaxRTT;
/**
* 与 callServer 的时间偏差时间（单位: ms）
*/
private _deltaTime;
/**
* timerId
*/
private _timerId;
/**
* 轮训时间间隔（单位: ms）
*/
private readonly _interval;
/**
* 最大重试次数
*/
private readonly _maxRetryTimes;
constructor(_callEngine: RCCallEngine, _logger: BasicLogger, _singleCallDurationEv: (callId: string, clientStartTime: number, clientFirstFrameTime: number, traceId: string) => void);
/**
* 从服务端获取通话时长、通话开始时间
*/
getCallClientTimeByServer(callId: string, traceId: string): Promise<{
code: number;
duration?: number;
clientStartTime?: number;
}>;
/**
* 直接计算客户端开始时间
*/
calcClientStartTime(callId: string, startTime: number, traceId: string): {
code: RCCallPlusInnerCode;
clientStartTime?: number;
};
private _startTimes;
/**
* 开始定时递归获取与 CallServer 的时间偏差值
*/
start(traceId: string): void;
/**
* 停止定时轮训
*/
stop(traceId: string): void;
/**
* 重新定时轮训
*/
restart(traceId: string): void;
getLocalDelayTime(): number;
getRTT(): number;
/**
* 获取与 CallServer 的时间偏差值，非通话中的计算
*/
private _getDeltaTime;
/**
* 通话中获取开始时间
*/
private _getDeltaTimeInCall;
private _retryTimesInCall;
private readonly _maxRetryTimesInCall;
/**
* 多次校正抛给业务层的通话开始时间、首帧时间
*/
private _loopCorrectClientTime;
}
declare enum RCCallPlusMediaTypeChangeResult {
/**
* 请求方取消媒体类型变更
*/
CANCEL_CHANGE_MEDIA_TYPE = 0,
/**
* 应答方拒绝媒体类型切换
*/
REFUSE_CHANGE_MEDIA_TYPE = 1,
/**
* 服务仲裁允许媒体类型切换
*/
SERVER_ALLOW_MEDIA_TYPE = 2,
/**
* 媒体类型切换超时
*/
CHANGE_MEDIA_TYPE_TIMEOUT = 3
}
declare class RCCallPlusReportModule {
private readonly _logger;
private _listener;
constructor(_logger: BasicLogger);
/**
* 状态机事件注册
*/
registerEventListener(listener: ICallPlusEventListener): void;
/**
* 回调应用层事件
* @param eventName
* @param attrs
* @returns
*/
private _callAppListener;
onReceivedCall(session: RCCallPlusSession, traceId: string, extra?: string): void;
onRemoteUserInvited(inviteeUserList: string[], inviterUserId: string, callId: string): void;
onCallConnected(session: RCCallPlusSession): void;
onCallTypeChanged(callType: RCCallPlusType, callId: string, traceId: string): void;
/**
* 增量上报远端人员状态变化
*/
onRemoteUserStateChanged(data: {
callId: string;
userId: string;
userState: RCCallPlusSessionUserState;
reason?: RCCallPlusReason;
}, traceId: string): void;
onCallEnded(session: RCCallPlusSession, reason: RCCallPlusReason, traceId: string): void;
onRemoteCameraStateChanged(callId: string, track: RCRemoteTrack): void;
onRemoteMicrophoneStateChanged(callId: string, track: RCRemoteTrack): void;
onReceivedCallRecord(record: IRCCallPlusCallRecord, traceId: string): void;
onReceivedChangeMediaTypeRequest(userId: string, transactionId: string, mediaType: RCCallPlusMediaType, traceId: string): void;
onReceivedChangeMediaTypeResult(info: {
userId: string;
transactionId: string;
mediaType: RCCallPlusMediaType;
code: RCCallPlusMediaTypeChangeResult;
}, traceId: string): void;
onReceivedCallStartTime(info: {
callId: string;
callStartTime: number;
}, traceId: string): void;
onReceivedCallFirstFrameTime(callId: string, callFirstFrameTime: number, traceId: string): void;
onUserMediaAvailable(tracks: RCTrack[], traceId?: string): void;
onFetchRemoteMediaError(tracks: ISubscribeAttr[], code: RCRTCCode): void;
onUserAudioLevelChanged(audioLevelReportList: {
track: RCLocalAudioTrack | RCRemoteAudioTrack;
audioLevel: number;
}[]): void;
onReceivedCallPlusSummaryMessage(message: IRCCallPlusReceivedSummaryMessage): void;
onReceivedGroupCallStatusMessage(message: IReceivedGroupCallStatusMessage): void;
}
declare class SignalTransporter extends EventEmitter {
private readonly _context;
private readonly _runtime;
private readonly _initOpts;
private readonly _timeCorrectioner;
private readonly _logger;
private readonly _reportAppEventModule;
/**
* 监听对象
*/
_listener: ISignalTransporterListener;
/**
* 需要重试的 action
*/
_needRetryActions: CallServerAction[];
_sessionId: string;
/**
* constructor
*/
constructor(_context: PluginContext, _runtime: IRuntime, _initOpts: ICallPlusInitOpts, _timeCorrectioner: TimeCorrectioner, _logger: BasicLogger, _reportAppEventModule: RCCallPlusReportModule);
private _onMessage;
private _dealMissMessage;
private _dealGroupCallMessage;
getSessionId(): string;
getDeviceId(): string;
registerListener(listener: ISignalTransporterListener): void;
startCall(msg: IStartCallCon, traceId: string): Promise<{
code: number;
data?: IStartCallRes;
}>;
startSingleCall(msg: IStartSingleCon, traceId: string): Promise<{
code: number;
data?: IStartCallRes;
}>;
startGroupCall(msg: IStartGroupCon, traceId: string): Promise<{
code: number;
data?: IStartCallRes;
}>;
inviteCall(msg: IInviteCallCon, traceId: string): Promise<{
code: number;
data?: IInviteCallRes;
}>;
ringingCall(msg: IRingingCallCon, traceId: string): Promise<{
code: number;
}>;
acceptCall(msg: IAcceptCallCon, traceId: string): Promise<{
code: number;
}>;
joinCall(msg: IJoinCallCon, traceId: string): Promise<{
code: number;
}>;
hangupCall(msg: IHangupCallCon, traceId: string): Promise<{
code: number;
}>;
statusUpCall(msg: IStatusUpCon, traceId: string): Promise<{
code: number;
}>;
eventUpCall(msg: IEventUpCallCon, traceId: string): Promise<{
code: number;
}>;
dialogUpCall(msg: IDialogUpCallCon, traceId: string): Promise<{
code: number;
}>;
deleteCallRecord(userId: string, callIds: string[], traceId: string): Promise<{
code: number;
}>;
syncCallLog(msg: ISyncCallLogCon, traceId: string): Promise<{
code: number;
data?: ISyncCallLogResList;
}>;
queryUserHasCall(): Promise<{
code: number;
data?: IQryUserHasCallRes;
}>;
getCallServerTimestamp(traceId: string): Promise<{
code: number;
data?: {
syncTime: number;
};
}>;
getCallTimeInfo(callId: string, traceId: string): Promise<{
code: number;
data?: IGetCallTimeInfoRes;
}>;
getUserCallStateList(traceId: string): Promise<{
code: number;
data?: IGetUserCallStateListRes;
}>;
clearCallRecord(traceId: string): Promise<{
code: number;
data?: IClearCallLogRes;
}>;
getCallSession(opts: IBaseSingalCon, traceId: string): Promise<{
code: number;
data?: IGetCallSessionServerRes;
}>;
sysStatusUp(opts: ISysStatusUpOpts, traceId: string): Promise<{
code: number;
}>;
upCallLogReaded(opts: IBaseSingalCon): Promise<{
code: number;
}>;
/**
* 清除用户正在呼叫中的通话会话（*非暴露接口，供调试酌情调用）
*/
endUserAbnormalCalls(opts: IEndAbnormalCallOpts): Promise<{
code: number;
}>;
/** ======私有方法============================================================================================= */
private _onIMConnectionStateChange;
/**
* call 信令发送
* @param targetId 获取 call log (syncCallLog) 时传 userId, 其他 action 传 callId
* @param key call server 定义 action
* @param options action 携带参数，无参数传空字符串
*/
private _sendCallSignal;
/**
* call 信令接收
*/
private _onRecvCallSignal;
/**
* 根据 deviceId 判断数据是否应该下发
* deviceId 为空字符串或 null 直接下发
* deviceId 有具体的值，根据 deviceId 判断是否是己端的 deviceId
*/
isValidData(toDeviceId: string | null): boolean;
/**
* 收到邀请
* @param isDirectly 是否为直发信令
*/
private _onPubInviteCall;
/**
* 收到状态变更：响铃、忙碌、通话等待、对方未接听、己方未接听
*/
private _onStatusDownCall;
/**
* 收到通话事件变更：打开|关闭 摄像头
*/
private _onEventDownCall;
/**
* 收到通话调整事件及结果
* 事件：媒体类型切换
* 动作：请求、接受、拒绝、取消
*/
private _onDialogDownCall;
/**
* 通话结束后，日志下发
*/
private _onPubCallLog;
/**
* 补偿数据处理
*/
private _onConpensationData;
}
/**
* 异常结束 call 处理存储类
* 在呼出或呼入阶段的 call 进行本地存储，正常结束后清除
* 异常结束后，本地取未清除的 callId, 通过服务接口清除异常结束的 call ,防止无法呼出或呼入
*/
declare class AbnormalCall {
private readonly _logger;
private _localStore;
private static _STORAGE_KEY;
constructor(runtime: IRuntime, _logger: BasicLogger);
/**
* 添加异常 callId
*/
addAbnormallCallId(userId: string, callId: string): void;
/**
* 删除异常 callId
*/
removeAbnormalCallIds(userId: string, callIds: string[]): void;
/**
* 获取异常结束的 callId 列表
*/
getAbnormalCallIds(userId: string): Promise<string[] | null>;
}
declare class RTCModule extends EventEmitter {
private readonly _context;
private readonly _runtime;
private readonly _initOpts;
private readonly _logger;
private readonly _callEngine;
private readonly _reportAppEventModule;
static __INNER_RTC_PROCESS_FAILED__: string;
static __INNER_RTC_PEERCONNECTION_ABNORMAL_CLOSE__: string;
static __INNER_ON_SELF_JOINED__: string;
static __INNER_ON_OTHER_JOINED__: string;
static __INNER_RECEIVE_FIRST_FRAME__: string;
static __INNER_ON_KICKOFF__: string;
/**
* RCRTC 实例
*/
_rtcClient: RCRTCClient;
/**
* 己方的音视频 tracks
*/
private _localTracks;
/**
* RCRTCRoom 实例
*/
_room: RCRTCRoom | null;
private _callId;
private _callMediaType;
private _videoConfig;
private _audioConfig;
private _isPubTiny;
private _audioOutputDeviceId;
/**
* 视频配置是否变更
*/
private _videoConfigIsChange;
/**
* 音频配置是否变更
*/
private _audioConfigIsChange;
/**
* 存储设置的人员和视图
*/
private _userViewMap;
private _callPlusStatusReportListener;
private _remoteAudioEnable;
private _preHangupCallId;
constructor(_context: PluginContext, _runtime: IRuntime, _initOpts: ICallPlusInitOpts, _logger: BasicLogger, _callEngine: RCCallEngine, _reportAppEventModule: RCCallPlusReportModule);
setCallPlusStatusReportListener(listener: IStatusReportListener): void;
/**
* 取摄像头资源
* 内存中有时，返回内存中的视轨
*/
getCameraVideoTrack(traceId: string): Promise<{
code: number;
track?: RCLocalTrack;
}>;
/**
* 取麦克风资源
* 内存中有时，返回内存中的音轨
*/
getMicrophoneAudioTrack(traceId: string): Promise<{
code: number;
track?: RCLocalTrack;
}>;
/**
* 根据通话类型创建音、视频资源
* @param mediaType 音频或音视频
*/
createCallMediaTracks(mediaType: RCCallPlusMediaType, traceId: string): Promise<{
code: number;
}>;
setVideoConfig(videoConfig: IVideoConfig): void;
setAudioConfig(audioConfig: IAudioConfig): void;
setAudioOutputDeviceId(deviceId: string): Promise<{
code: number;
}>;
destroyAllTracks(traceId: string): void;
setAllRemoteAudioEnable(enable: boolean, traceId: string): {
code: 80001;
} | {
code: 0;
};
destroyTrack(track: RCLocalTrack): Promise<void>;
/**
* session 连接
*/
sessionConnected(callId: string, traceId: string): Promise<void>;
sessionClose(callId: string, traceId: string): Promise<void>;
/**
* 禁用视频 track
*/
disableVideoTrack(): Promise<{
code: number | RCRTCCode;
track?: RCLocalTrack;
}>;
/**
* 启用视频track
* 1. 启用前应用层需先创建视频 track
*/
enableVideoTrack(traceId: string): Promise<{
code: number | RCRTCCode;
}>;
/**
* 通话中切换视频设备
*/
changeVideoDevice(traceId: string): Promise<{
code: number;
track?: RCLocalTrack;
}>;
/**
* 通话中更换音频设备
*/
changeAudioDevice(traceId: string): Promise<{
code: number;
}>;
/**
* 禁用音频 track
*/
disableAudioTrack(): Promise<{
code: number | RCRTCCode;
track?: RCLocalTrack;
}>;
/**
* 媒体类型升、降
*/
changeMediaType(mediaType: RCCallPlusMediaType, traceId: string): Promise<void>;
/**
* 升级 音频 -> 音视频
* 1. 业务层需要先通过 createLocalTracks 创建本地视频 track
* 2. SDK 只处理发布视频 track
*/
private _upgradeMediaType;
/**
* 降级处理
*/
private _downgradeMediaType;
/**
* 加入 RTC 房间
*/
joinRTCRoom(callId: string, traceId: string): Promise<{
code: number;
room?: RCRTCRoom;
tracks?: RCRemoteTrack[];
}>;
/**
* RTC 订阅
*/
subscribeTracks(tracks: (ISubscribeAttr)[], traceId: string): Promise<{
code: number;
}>;
/**
* RTC 取消订阅
*/
unsubscribeTracks(tracks: RCRemoteTrack[], traceId: string): Promise<{
code: number;
}>;
private _releaseStoredData;
getRemoteTracks(): {
[userId: string]: RCRemoteTrack[];
};
getRemoteTrack(userId: string, mediaType: RCCallPlusMediaType): RCRemoteTrack | undefined;
getRTCSessionId(): string | null;
/** ======私有方法============================================================================================= */
/**
* RTC 事件监听注册
*/
private _regRTCListeners;
private _onLocalTrackReady;
private _onRemoteTrackReady;
private _onKickOff;
/**
* RTC Peer 异常关闭
* 移动端未处理此回调，定义 sysStatus 为 CONNECTION_ERR
*/
private _onRTCPeerConnectionCloseByException;
private _onSelfJoined;
private _onRemoteTrackPublish;
private _onTrackUnpublish;
private _onAudioMuteChange;
private _onVideoMuteChagne;
private _onRTCStateReport;
/**
* RTC 接收最终失败后需要调用 hangup 挂断的情况
*/
private _onRTCMethodFail;
private _onOtherMemJoined;
/**
* 创建本地音频 track, 创建成功后保存本地并回调通知
*/
private _createAudioTrack;
/**
* 创建本地视频 track, 创建成功后保存本地并回调通知
*/
private _createVideoTrack;
/**
* 获得本地缓存视频 track
*/
getLocalVideoTrack(): RCLocalTrack | undefined;
/**
* 获得本地缓存音频 track
*/
getLocalAudioTrack(): RCLocalTrack | undefined;
/**
* 发布本地资源的逻辑
*/
publish(tracks: (RCLocalTrack | IPublishAttrs)[], traceId: string): Promise<{
code: number;
}>;
publishVideoTrack(): Promise<IPubSuccessRes>;
setVideoView(list: {
userId: string;
videoElement: HTMLVideoElement;
isTiny?: boolean;
}[], traceId: string): void;
/**
* 删除视图时，取消订阅资源
*/
removeVideoView(userIds: string[], traceId: string): void;
/**
* 获取存储的人员和 video 元素数据
*/
getUserViewMap(): {
[userId: string]: {
videoView: HTMLVideoElement;
isTiny: boolean;
};
};
/**
* 播放媒体资源
*/
playMedia(userId: string, mediaType: RCCallPlusMediaType, videoView: HTMLVideoElement, traceId: string): Promise<{
code: 80104;
} | {
code: 80102;
} | {
code: RCRTCCode.PB_ERROR | RCRTCCode.SIGNAL_DISCONNECTED | RCRTCCode.PARAMS_ERROR | RCRTCCode.REPERT_JOIN_ROOM | RCRTCCode.NOT_IN_ROOM | RCRTCCode.SERVICE_INVALID | RCRTCCode.RTC_TOKEN_INVALID | RCRTCCode.SIGNAL_ERROR | RCRTCCode.CREATE_OFFER_FAILED | RCRTCCode.REQUEST_FAILED | RCRTCCode.MCU_SERVER_NOT_FOUND | RCRTCCode.BROADCAST_SUB_LIST_NOT_EMPTY | RCRTCCode.ROOM_HAS_BEEN_DESTROYED | RCRTCCode.NOT_OPEN_VIDEO_AUDIO_SERVER | RCRTCCode.GET_USER_MEDIA_FAILED | RCRTCCode.GET_DISPLAY_MEDIA_FAILED | RCRTCCode.BROWSER_PERMISSION_DENIED | RCRTCCode.CREATE_CUSTOM_TRACK_FAILED | RCRTCCode.INVALID_TAGS | RCRTCCode.INVALID_USER_ID | RCRTCCode.CREATE_FILE_TRACK_FAILED | RCRTCCode.INVALID_FILE_INSTANCE | RCRTCCode.SET_REMOTE_DESCRIPTION_FAILED | RCRTCCode.BROWSER_NOT_SUPPORT | RCRTCCode.TRACK_NOT_READY | RCRTCCode.VIDEO_TRACK_MISS_MEDIA_ELEMENT | RCRTCCode.TRACK_PLAY_ERROR | RCRTCCode.SIGNAL_AUDIENCE_JOIN_ROOM_FAILED | RCRTCCode.SIGNAL_ROOM_CHANGE_IDENTITY_FAILED | RCRTCCode.PACKAGE_ENVIRONMENT_ERROR | RCRTCCode.PUBLISH_TRACK_LIMIT_EXCEEDED | RCRTCCode.CDN_RESOURCE_IS_EMPTY | RCRTCCode.SIGNAL_JOIN_RTC_ROOM_REFUSED | RCRTCCode.NO_PERMISSION_TO_USE_REQUESTED_DEVICE | RCRTCCode.THE_FUNCTION_IS_DISABLED_IN_PKROOM | RCRTCCode.SOME_TRACKS_PUBLISH_FAILED | RCRTCCode.MAC_IN_ELECTRON_NOT_SUPPORT_SCREEN_SHARE_WITH_AUDIO | RCRTCCode.JWT_TIME_OUT | RCRTCCode.SYSTEM_PERMISSION_DENIED | RCRTCCode.PUBLISH_TRACKS_IS_INVALID | RCRTCCode.TRACK_READYSTATE_IS_ENDED | RCRTCCode.APPLY_3A_NOISE_WORKLET_BEFORE_PUBLISH | RCRTCCode.LOAD_3A_MODULE_FAILED;
} | {
code: 0;
}>;
}
declare class RCCallEngine extends EventEmitter {
private readonly _context;
private readonly _runtime;
private readonly _initOpts;
private readonly _logger;
private readonly _reportAppEventModule;
static __INNER_SESSION_CLOSE__: string;
static __INNER_SESSION_CONNECT__: string;
static __INNER_CHANGE_MEDIA_TYPE__: string;
static __INNER_INVITE__: string;
/**
* 主 session
*/
private _mainSession;
/**
* 在通话中收到的 邀请 session
*/
private _holdSessions;
/**
* 信令模块
*/
_signalModule: SignalTransporter;
/**
* 异常结束 call 处理器
*/
_abnormalModule: AbnormalCall;
/**
* 记录单呼中，是否上报过第一帧
* 置 true 时机：收到远端第一帧，成功上报 Server
* 置 false 时机：通话结束
*/
private _isUpFirstFrameTime;
/**
* 通话为 ONCALL 时，SDK 需给业务层上报通话开始计时事件
* 会收到多次 ONCALL，所以需要标识是否已抛过事件
*/
private _callStartMap;
/**
* 校时器
*/
_timeCorrectioner: TimeCorrectioner;
/**
* client callId
*/
private _clientCallId;
/**
* session 需使用 rtc 模块取设备状态
*/
private _rtcModule;
/**
* 构造器
*/
constructor(_context: PluginContext, _runtime: IRuntime, _initOpts: ICallPlusInitOpts, _logger: BasicLogger, _reportAppEventModule: RCCallPlusReportModule);
/**
* 发起呼叫
*/
startCall(opts: IStartCallOpts, traceId: string): Promise<{
code: number;
data?: IStartCallResult;
}>;
/**
* 通话中邀请
*/
invite(opts: IInviteOpts, traceId: string): Promise<{
code: number;
data?: IInviteRes;
}>;
/**
* beforeHangup
*/
clearAllTimer(callId: string, traceId: string): void;
/**
* 挂断
* 通话请求取消、通话拒绝
*/
hangup(opts: IHangupForBusyOpts, traceId: string): Promise<{
code: number;
}>;
/**
* 接收邀请
* 通话中又收到新来电后，接听新来电时，必须先挂断之前的通话（mainSession）
*/
accept(opts: IAcceptOpts, traceId: string): Promise<{
code: number;
}>;
/**
* 直接加入
*/
joinCall(opts: IJoinCallOpts, traceId: string): Promise<{
code: number;
}>;
/**
* 通话媒体变更请求
*/
requestChangeMediaType(opts: IReqChangeMediaTypeOpts, traceId: string): Promise<{
code: number;
data?: IReqChangeMediaTypeRes;
}>;
/**
* 通话媒体类型变更请求响应
*/
responseChangeMediaType(opts: IResChangeMediaTypeOpts, traceId: string): Promise<{
code: number;
}>;
/**
* 取消通话媒体类型切换请求
*/
cancelChangeMediaType(opts: ICancelChangeMediaTypeOpts, traceId: string): Promise<{
code: number;
}>;
/**
* 获取 call log 列表
*/
getCallLogList(opts: IGetCallLogListOpts, traceId: string): Promise<{
code: number;
data?: IRCCallPlusGetCallRecordRes;
}>;
/**
* 批量删除通话日志
*/
deleteCallLog(callIds: string[], traceId: string): Promise<{
code: number;
}>;
/**
* 获取 call server 当前时间戳
*/
getCallServerTimestamp(traceId: string): Promise<{
code: number;
data?: number;
}>;
/**
* 获取 call 时间信息
*/
getCallTimeInfo(callId: string, traceId: string): Promise<{
code: number;
data?: IGetCallTimeInfoRes;
}>;
/**
* 获取未结束的通话列表
*/
getOpenCallList(traceId: string): Promise<{
code: number;
data?: IRCCallPlusCallRecord[];
}>;
/**
* 清除当前用户的 call log