AICC - TiCloudRTC 开发指南

    maven { url=uri("https://www.jitpack.io") }
    maven { url = uri("https://mvnrepo.jiagouyun.com/repository/maven-releases") }

    maven { url 'https://www.jitpack.io'}
    maven { url "https://mvnrepo.jiagouyun.com/repository/maven-releases"}

    // TiCloudRtc SDK
    implementation("com.github.ti-net:TiCloud-RTC-Android:"版本号"@aar")

    // 依赖 1.0.0 版本 TiCloudRtc SDK 样例
    // implementation("com.github.ti-net:TiCloud-RTC-Android:1.0.0@aar")

    // kotlin 协程
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")

    // kotlin 反射
    implementation("org.jetbrains.kotlin:kotlin-reflect:1.9.24")

    // retrofit2 gson 转换库
    implementation("com.squareup.retrofit2:converter-gson:2.11.0")

    // json 解析库
    api("com.google.code.gson:gson:2.11.0")

    // 网络请求库
    api("com.squareup.okhttp3:okhttp:4.12.0")
    api("com.squareup.retrofit2:retrofit:2.11.0")

    // 观测云(可选, 不添加则无法上报日志)
    implementation("com.cloudcare.ft.mobile.sdk.tracker.agent:ft-sdk:1.5.0")
    implementation("com.cloudcare.ft.mobile.sdk.tracker.agent:ft-native:1.1.0")

    @JvmStatic
    fun createClient(
        context: Context,
        createClientOption:CreateClientOption?,
        resultCallback:CreateResultCallback?,
    ){}

/** 创建客户端所需的参数配置 */
data class CreateClientOption(
    /** 平台地址 */
    var rtcEndpoint: String? = "",

    /** 企业 ID*/
    var enterpriseId: String? = "",

    /** 用户 ID */
    var userId: String? = "",

    /**
    * 外部私有服务端登录接口返回的 accessToken.
    *
    * 注: 生成 accessToken 时,有效时间至少设置为 10 分钟以上, 设置极端的 10 分钟有可能因为
    * 网络延迟导致 SDK 认为 accessToken 有效期小于 10 分钟而导致无法初始化. 建议设置 15 分钟以上.
    */
    var accessToken: String? = ""
) {

    /** 预留高级参数配置 */
    var advancedParams = mutableMapOf<String, String>()

    /** 调试标识，true 为输出调试信息，false 为不输出调试信息 */
    var isDebug = false

    /** 默认的主叫真实号码，用于接听回呼的电话 */
    var callerNumber: String = ""

    /** 输出日志到文件标识, true 为输出日志到文件里, false 为不输出日志到文件 */
    var isLogToFile = true

    /**
     * 启用观测云上传日志标识
     *
     * true: 启用观测云上传日志
     * false: 不启用观测云上传日志
     *
     * 注:
     * 1. 当设置该标识为 false 时, 当前SDK 不影响 APP 的观测云 SDK 的初始化, 且不会上传日志到观测云.
     * 2. 当设置该标识为 true 时, 如果 APP 先于当前 SDK 初始化观测云 SDK,则当前 SDK 不再初始化观测云 SDK. 当前 SDK 的日志将上传到 APP 的观测云 app_id 下, 日志携带 log_tag 属性, 属性值为 TiCloudRTC.
     * 3. 当设置该标识为 true 时, 如果 APP 后于当前 SDK 初始化观测云, 则观测云 SDK 的配置最终为 APP 初始化观测云的配置. 当前 SDK 的日志将上传到 APP 的观测云 app_id 下, 日志携带 log_tag 属性, 属性值为 TiCloudRTC.
     * 4. 只有当前标识设置为 true, 且 APP 未使用观测云 SDK 时,当前 SDK 的日志才会上传到当前 SDK 初始化的观测云 app_id 下, 日志携带 log_tag 属性, 属性值为 TiCloudRTC.
     */
    var isStartFTMobile = true

    /**
     * 是否显示通话中的通知栏
     *
     * true: 显示通话中的通知栏(默认)
     * false: 不显示通话中的通知栏
     */
    var isShowCallingNotification = true

    /**
     * 是否在对端挂断时播放预置挂机音频(注:通话错误导致的挂机不会播放音频)
     *
     * true: 播放音频(默认)
     * false: 不播放音频
     */
    var isPlayHangupAudio = true
}

/**
 * 创建 RTC 客户端的结果回调
 */
interface CreateResultCallback {

    /**
     * 成功创建 rtc 客户端，返回实例 [rtcClient]
     */
    fun onSuccess(rtcClient: TiCloudRTC)

    /**
     * 创建 rtc 客户端失败，返回错误码 [errorCode] 和错误描述 [errorMessage]
     *
     * errorCode 可能的值为:
     *      10xxx 类错误码
     *      11xxx 类错误码
     *      19999
     *      4xxxx 类错误码
     */
    fun onFailed(errorCode: Int, errorMessage: String)
}

    TiCloudRTC.createClient(
        context = context,
        createClientOption = CreateClientOption(
            rtcEndpoint = rtcEndpoint,
            enterpriseId = enterpriseId,
            userId = userId,
            accessToken = accessToken,
        ),
        resultCallback = object : CreateResultCallback {

            override fun onSuccess(rtcClient: TiCloudRTC) {
                // 创建成功,保存客户端
                this@MainActivityViewModel.rtcClient = rtcClient

                // 设置事件监听
                rtcClient.setEventListener(CustomEventListener())
            }

            override fun onFailed(errorCode: Int, errorMessage: String) {
                // 创建失败
            }
        }
    )

    CreateClientOption option = new CreateClientOption(
            rtcEndPoint,
            enterpriseId,
            userId,
            accessToken
    );

    TiCloudRTC.createClient(context, option, new CreateResultCallback() {
        @Override
        public void onSuccess(@NonNull TiCloudRTC rtcClient) {
            // 创建成功,保存客户端
            myViewModel.rtcClient = rtcClient;

            // 设置事件监听
            rtcClient.setEventListener(new CustomEventListener());
        }

        @Override
        public void onFailed(int errorCode, @NonNull String errorMessage) {
            // 创建失败
        }
    });

    abstract fun setEventListener(eventListener: TiCloudRTCEventListener?)

/**
 * TiCloudRTC 事件监听
 */
abstract class TiCloudRTCEventListener {

    /**
     * 引擎内部错误信息事件，返回错误码 [errorCode] 和错误描述 [errorMessage]
     *
     * errorCode 可能的值为:
     *      10xxx 类错误码
     *      11xxx 类错误码
     *      12005
     *      12006
     *      19999
     *      4xxxx 类错误码
     */
    open fun onError(errorCode:Int, errorMessage:String){}

    /** 开始通话，[requestUniqueId] 为当前呼叫的唯一标识 */
    open fun onCallingStart(requestUniqueId:String){}

    /** 播放铃声中 */
    open fun onRinging(){}

    /** 通话在会话邀请阶段被取消 */
    open fun onCallCancelled(){}

    /** 呼叫被拒绝 */
    open fun onCallRefused(){}

    /** 通话中 */
    open fun onCalling(){}

    /** 通话结束，[isPeerHangup] 为 true 表示对方挂断，false 表示己方挂断*/
    @Deprecated(
        message = "当前接口返回的 isPeerHangup 参数并不能准确描述是否是真正的被叫挂断,因此废弃,请使用新的 onCallingEnd 接口替代,当前回调将在 5.0.0 版本移除",
        replaceWith = ReplaceWith("onCallingEnd(errorCode,errorMessage,sipCode)"),
        level = DeprecationLevel.WARNING
    )
    open fun onCallingEnd(isPeerHangup:Boolean){}

    /**
     * 通话结束
     *
     * [errorCode] 为通话结束的错误码
     * [errorMessage] 为通话结束的错误信息
     * [sipCode] 为 sip 错误码, 默认为 0 , 表示无返回
     *
     * errorCode 可能的值为:
     *      10009
     *      11001
     *      14xxx 类错误码
     *      19999
     *      2xxxx 类错误码
     *      3xxxx 类错误码
     *
     * 注:
     *  1. SDK 对 sipCode 无定义
     *  2. 只有当 errorCode 为 14003 和 39999 时,需要关注 sipCode 值,
     *      此时技术支持人员同时需要 errorCode 和 sipCode 排查具体问题
     */
    open fun onCallingEnd(
        errorCode: Int,
        errorMessage: String,
        sipCode: Int
    ){}

    /**
     * SDK 未正常发起通话，返回错误码 [errorCode] 和失败信息 [failureMessage]
     *
     * errorCode 可能的值为:
     *      10000
     *      10001
     *      10002
     *      10003
     *      10009
     *      11001
     *      12xxx 类错误码
     *      19999
     */
    open fun onCallFailure(errorCode:Int,failureMessage:String){}

    /**
     * 调用 SDK hangup 接口引发挂断
     *
     * 注: 对应原 ErrorCode.SELF_HANGUP(14001) 错误码
     */
    open fun onLocalHangup(){}

    /**
     * 对方接起后挂断
     *
     * 注: 对应原 ErrorCode.REMOTE_HANGUP(14002) 错误码
     */
    open fun onRemoteHangup(){}

    /**
     * 接收到远端的会话邀请及高级字段 [fields]
     *
     * 目前 fields 包含如下字段信息：
     *
     * requestUniqueId：     通话唯一标识
     * customerNumber：      呼入的号码
     */
    open fun onRemoteInviteReceived(fields: HashMap<String, String>) {}

    /**
     * 远端会话邀请被本地拒绝, [fields] 为 SDK 内部返回的高级字段
     *
     * 目前 fields 包含如下字段信息：
     *
     * isCalling:           标识当前邀请是否由于本地处于通话中而被自动拒绝.
     *                      true: 由于本地处于通话中而被自动拒绝会话邀请
     *                      false：本地主动拒绝会话邀请
     * requestUniqueId：     通话唯一标识
     * customerNumber：      呼入的号码
     */
    open fun onInviteRefuseByLocal(fields: HashMap<String, String>) {}

    /**
     * 远端取消会话邀请, [fields] 为 SDK 内部返回的高级字段
     *
     * 目前 fields 包含如下字段信息：
     *
     * requestUniqueId：     通话唯一标识
     * customerNumber：      呼入的号码
     */
    open fun onRemoteInvitationCancel(fields: HashMap<String, String>) {}

    /** 远端邀请会话失败，返回错误码 [errorCode] 和失败信息 [failureMessage] */
    open fun onRemoteInviteFailure(errorCode: Int, failureMessage: String) {}

    /** [accessToken] 将在 10 分钟后过期 */
    open fun onAccessTokenWillExpire(accessToken:String){
        // 当前回调返回的 accessToken 不可用于 renewAccessToken 接口,
        // 此处的 accessToken 一般用于日志打印

        // 当此事件回调执行时, app 应该调用部署了 accessToken 生成工具的自建服务端提供的接口
        // 生成新的 accessToken, 并使用新的 accessToken 作为参数调用 SDK 的 renewAccessToken 接口
    }

    /** accessToken 已过期 */
    open fun onAccessTokenHasExpired(){}

    /**
     * 回调当前 userId 的通话网络上行质量 [txQuality]
     *
     * txQuality 取值及含义
     * 0:    质量未知
     * 1：   网络质量较好
     * 2：   网络质量一般
     * 3：   网络质量较差
     *
     * 注: 当前回调只有在 txQuality 改变时触发
     * */
    open fun onNetworkQuality(txQuality: Int) {}

    /**
     * 返回通话中所有 userId 的通话上下行质量 [txQuality] 和 [rxQuality]
     *
     * txQuality ---- 该用户的上行网络质量，基于上行视频的发送码率、上行丢包率、平均往返时延和网络抖动计算
     *      0:质量未知
     *      1:质量极好
     *      2:用户主观感觉和极好差不多，但码率可能略低于极好
     *      3:用户主观感受有瑕疵但不影响沟通
     *      4:勉强能沟通但不顺畅
     *      5:网络质量非常差，基本不能沟通
     *      6:网络连接断开，完全无法沟通
     *      8:SDK 正在探测网络质量
     *
     * rxQuality ---- 该用户的下行网络质量，基于下行网络的丢包率、平均往返延时和网络抖动计算
     *      0:质量未知
     *      1:质量极好
     *      2:用户主观感觉和极好差不多，但码率可能略低于极好
     *      3:用户主观感受有瑕疵但不影响沟通
     *      4:勉强能沟通但不顺畅
     *      5:网络质量非常差，基本不能沟通
     *      6:网络连接断开，完全无法沟通
     *      8:SDK 正在探测网络质量
     *
     * 注:
     *  1. 当 uid == 0 时为当前 userId
     *  2. 该回调每 2 秒会被触发一次, 当通话中有多个用户时, 会多次触发
     *  3. 当相应 uid 不发流时,txQuality 为 0; 当相应 uid 不收流时,rxQuality 为 0
     *
     */
    open fun onNetworkQuality(uid: Int, txQuality: Int, rxQuality: Int) {}

    /** 回调对端音频数据二进制数据流 [data] 及数据流大小 [bufSize] */
    open fun onReceiveStreamData(data: ByteArray, bufSize : Int) {}

    /** 回调特定频道 [channels] 的对端音频采样率信息 [sampleRate] */
    open fun onReceiveStreamSample(sampleRate: Int, channels : Int) {}

    /** 当前 userId 在其他端登录,当前引擎已销毁 */
    open fun onRemoteLogin() {}

    /** 会话时检测到长达 5 秒时间未成功发送本地语音流 */
    open fun onLocalNoVoiceStreamSent() {}

    /**
     * SDK 根据平台配置对 userField 外呼参数里的特殊字符进行了移除处理
     *
     * @param removedCharList 被移除的特殊字符列表
     * @param srcUserField 原始的 userField
     * @param finalUserField 处理后的 userField
     * */
    open fun onUserFieldModifiedByConfig(
        removedCharList: List<String>,
        srcUserField: String,
        finalUserField: String
    ) {}

    /**
     * 通话中本地音频流的统计信息回调
     *
     * 该回调描述本地设备发送音频流的统计信息. SDK 每 2 秒触发该回调一次.
     *
     * stats 成员变量说明:
     *      stats?.numChannels: 声道数
     *      stats?.sentSampleRate: 发送的采样率，单位为 Hz
     *      stats?.sentBitrate: 发送码率的 2 秒平均值，单位为 Kbps
     *      stats?.txPacketLossRate: 音频丢包率
     */
    open fun onLocalAudioStats(stats: IRtcEngineEventHandler.LocalAudioStats?) {}

    /**
     * 通话中远端音频流的统计信息回调
     *
     * 该回调描述远端用户在通话中端到端的音频流统计信息. SDK 每 2 秒触发该回调一次.
     *
     * stats 成员变量说明:
     *       stats?.uid: 用户 ID
     *       stats?.quality: 质量 (0:质量未知; 1:质量极好; 2:用户主观感觉和极好差不多 ，但码率可能略低于极好; 3:用户主观感受有瑕疵，但不影响沟通; 4:勉强能沟通但不顺畅; 5:网络质量非常差，基本不能沟通; 6:网络连接已断开，完全无法沟通; 8:网络质量探测中;)
     *       stats?.networkTransportDelay: 音频发送端到接收端的网络延迟（（ms）
     *       stats?.jitterBufferDelay: 接收端到网络抖动缓冲的网络延迟（ms）
     *       stats?.audioLossRate: 统计周期内的远端音频流的丢帧率
     *       stats?.numChannels: 声道数
     *       stats?.receivedSampleRate: 统计周期内接收到的远端音频采样率（Hz）
     *       stats?.receivedBitrate: 接收流在统计周期内的平均码率（Kbps）
     *       stats?.totalFrozenTime: 远端用户在加入频道后发生音频卡顿的累计时长 (一个统计周期内，音频丢帧率达到 4% 即记为一次音频卡顿,单位: ms)
     *       stats?.frozenRate: 远端用户在加入频道后发生音频卡顿的累计时长占音频总有效时长的百分比
     *       stats?.totalActiveTime: 远端用户在音频通话开始到本次回调之间的有效时长（ms）
     *       stats?.publishDuration: 远端音频流的累计发布时长（ms）
     *       stats?.qoeQuality: 接收远端音频时，本地用户的主观体验质量 (0:好; 1:坏)
     *       stats?.qualityChangedReason: 接收远端音频时，本地用户主观体验质量较差的原因 (0:无原因,说明主观体验质量较好; 1:远端用户的网络较差; 2:本地用户的网络较差; 4:本地用户的 Wi-Fi 或者移动数据网络信号弱; 8:本地用户同时开启 Wi-Fi 和蓝牙，二者信号互相干扰，导致音频传输质量下降;)
     *       stats?.mosValue: MOS (平均主观意见分)
     *
     * MOS 评分参考:
     *   大于 4 分: 音频质量佳，清晰流畅
     *   3.5-4 分: 音频质量较好，偶有音质损伤，但依然清晰
     *   3-3.5 分: 音频质量一般，偶有卡顿，不是非常流畅，需要一点注意力才能听清
     *   2.5-3 分: 音频质量较差，卡顿频繁，需要集中精力才能听清
     *   2-2.5 分: 音频质量很差，偶有杂音，部分语义丢失，难以交流
     *   小于 2 分: 音频质量非常差，杂音频现，大量语义丢失，完全无法交流
     */
    open fun onRemoteAudioStats(stats: IRtcEngineEventHandler.RemoteAudioStats?) {}

    /**
     * 本地音频状态发生改变回调
     *
     * 本地音频的状态发生改变时（包括本地麦克风采集状态和音频编码状态），SDK 会触发该回调报告当前的本地音频状态。 在本地音频出现故障时，该回调可以帮助你了解当前音频的状态以及出现故障的原因，方便你排查问题
     *
     * state ---- 当前的本地音频状态
     *   0:本地音频默认初始状态
     *   1:本地音频采集设备启动成功
     *   2:本地音频首帧编码成功
     *   3:本地音频启动失败
     *
     * error ---- 本地音频出错原因
     *   0:本地音频状态正常
     *   1:本地音频出错原因不明确
     *   2:没有权限启动本地音频采集设备
     *   3:本地音频采集设备已经在使用中
     *   4:本地音频采集失败
     *   5:本地音频编码失败
     *   8:本地音频采集被系统来电、闹钟中断
     */
    open fun onLocalAudioStateChanged(state: Int, error: Int) {}

    /**
     * 远端音频状态发生改变回调
     *
     * 远端用户音频状态发生改变时,SDK 会触发该回调向本地用户报告当前的远端音频流状态
     *
     * uid    ---- 发生音频状态改变的远端用户 ID
     *
     * state  ---- 远端音频流状
     *   0:远端音频流默认初始状态. 在 reason 为 3、5、7 的情况下，会报告该状态
     *   1:本地用户已接收远端音频首包
     *   2:远端音频流正在解码，正常播放. 在 reason 为 2、4、6 的情况下，会报告该状态
     *   3:远端音频流卡顿. 在 reason 为 1 的情况下，会报告该状态
     *   4:远端音频流播放失败. 在 reason 为 0 的情况下，会报告该状态
     *
     * reason ---- 远端音频流状态改变的具体原因
     *   0:音频状态发生改变时，会报告该原因
     *   1:远端用户的网络阻塞
     *   2:远端用户的网络恢复正常
     *   3:本地用户停止接收远端音频流或本地用户禁用音频模块
     *   4:本地用户恢复接收远端音频流或本地用户启用音频模块
     *   5:远端用户停止发送音频流或远端用户禁用音频模块
     *   6:远端用户恢复发送音频流或远端用户启用音频模块
     *   7:远端用户离开频道
     *
     * elapsed ---- 从本地用户调用 joinChannel 方法直至发生音频状态改变的延迟（毫秒）
     */
    open fun onRemoteAudioStateChanged(uid: Int, state: Int, reason: Int, elapsed: Int) {}
}

class CustomEventListener: TiCloudRTCEventListener() {
    // 按需重写回调事件方法
}

rtcClient?.setEventListener(CustomEventListener())

public class CustomEventListener extends TiCloudRTCEventListener{
    // 按需重写回调事件方法
}

rtcClient.setEventListener(new CustomEventListener());

    abstract fun call(callOption:CallOption?)

/** 外呼所需的参数配置 */
data class CallOption(
    /** 被呼叫的号码, 注:在客服场景 tel 传空字符串 */
    var tel: String? = "",

    /** 外显号码*/
    var clid: String? = "",

    /** 通话唯一标识, 不填则由 SDK 内部自动生成*/
    var requestUniqueId: String? = "",

    /**
     * 自定义字段
     *
     * 注：
     *      1. userField 有字符长度限制，默认 userField 字符总数最大为 512B
     *      2. userField 中的所有空格将被清除
     */
    var userField: String? = "",

    /** 外呼场景，1：客服场景，6：外呼场景*/
    var type: Int = 6
){
    /** 主叫真实号码，用于接听回呼的电话，不传则使用创建客户端时所设置的默认 callerNumber */
    var callerNumber: String = ""

    /** 绑定的座席号 */
    var cno: String = ""

    /** 外显号码区号 */
    var obClidAreaCode: String = ""

    /** 外显号码组 */
    var obClidGroup: String = ""

    /**
     * 参数签名
     *
     * 注: 在加密模式下用到,不使用加密则不需要传入
     *
     * 签名规则:
     *  1. 将参数 tel、callerNumber、clid、obClidAreaCode、obClidGroup、userField、type、timestamp 按照字典顺序排序，
     *      然后按照 key=value&key2=value2 的规则进行拼接(注意：如果没有传对应字段则不用参与拼接，requestUniqueId 不参与签名)
     *  2. 将企业 ID 拼接到拼接串开头，将企业 Token 拼接到拼接串结尾
     *  3. 将拼接串进行 SHA256 加密，最终得到的值就是签名(sign)
     *
     * 签名示例:
     *  假设企业 ID 为 7000002 , 企业 Token 为 token123456
     *  请求参数为
     *      tel: 13000000000
     *      callerNumber: 14000000000
     *      obClidGroup: 号码池1
     *      type: 6
     *      timestamp: 1735192796
     *
     *
     *  按照步骤开始计算签名
     *
     *  经过第一步计算之后得到  callerNumber=14000000000&obClidGroup=号码池1&tel=13000000000&timestamp=1735192796&type=6
     *
     *  经过第二步计算之后得到  7000002callerNumber=14000000000&obClidGroup=号码池1&tel=13000000000&timestamp=1735192796&type=6token123456
     *
     *  经过第三步计算之后得到  398db99bf641dbc489a61204257ea7e91ce2dd490a3f37862dc6c4992168c5dd
     *
     */
    var sign: String = ""

    /**
     * 签名时间戳
     *
     * 注: 在加密模式下用到,不使用加密则不需要传入
     */
    var timestamp: Int? = null
}

    val userField = """
          {
              "id":"90007573",
              "workNum":"1026658",
              "depId":"340179",
          }
      """.trimIndent()
    rtcClient.call(CallOption("156xxxx1200","","",userField,6))

    String userField = "{"+
          \"id\",:\"90007573\","+
          \"workNum\":\"1026658\","+
          \"depId\":\"340179\""+
      "}";
    rtcClient.call(new CallOption("156xxxx1200","","",userField,6));

    abstract fun acceptCall()

    rtcClient?.acceptCall()

    rtcClient.acceptCall();

    abstract fun refuseCall()

    rtcClient?.refuseCall()

    rtcClient.refuseCall();

    abstract fun dtmf(digits:String?)

    rtcClient.dtmf("8")

    rtcClient.dtmf("8");

    abstract fun renewAccessToken(accessToken:String?)

    rtcClient.renewAccessToken("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")

    abstract fun hangup()

    rtcClient.hangup()

    rtcClient.hangup();

    abstract fun destroyClient(resultCallback: DestroyResultCallback?)

/**
 * 销毁 RTC 客户端的结果回调
 */
interface DestroyResultCallback {

    /** 成功销毁 rtc 客户端 */
    fun onSuccess()

    /**
     * 销毁客户端失败，返回错错误码 [errorCode] 和错误描述 [errorMessage]
     *
     * errorCode 可能的值为:
     *      10000
     */
    fun onFailed(errorCode:Int,errorMessage:String)
}

    rtcClient?.destroyClient(object :DestroyResultCallback {

        override fun onSuccess() {
            // 销毁成功
            rtcClient = null
        }

        override fun onFailed(errorCode: Int, errorMessage: String) {
            // 销毁失败
        }

    })

    rtcClient.destroyClient(new DestroyResultCallback() {
            @Override
            public void onSuccess() {
                // 销毁成功
                rtcClient = null;
            }

            @Override
            public void onFailed(int errorCode, @NonNull String errorMessage) {
                // 销毁失败
            }
        });

    abstract fun setEnableSpeakerphone(isEnable:Boolean)

    rtcClient.setEnableSpeakerphone(true)

    rtcClient.setEnableSpeakerphone(true);

    abstract fun isSpeakerphoneEnabled():Boolean

    rtcClient.isSpeakerphoneEnabled()

    rtcClient.isSpeakerphoneEnabled();

    abstract fun setEnableLocalAudio(isEnable: Boolean)

    rtcClient.setEnableLocalAudio(true)

    rtcClient.setEnableLocalAudio(true);

    @JvmStatic
    fun getVersion():String

    TiCloudRTC.getVersion()

    TiCloudRTC.getVersion();

pod 'TiCloudRTC'

+ (TiCloudRTCEngine * _Nonnull)createClient:(TiCloudRTCEngineConfig *_Nonnull)config success:(void (^)( NSDictionary *data))successBlock error:(void (^)(TiCloudRtcErrCode nErrorCode, NSString *errorDes))errorBlock;

@interface TiCloudRTCEngineConfig : NSObject

// 平台地址
@property(nonatomic, copy, nonnull) NSString *rtcEndpoint;

// 企业ID
@property(nonatomic, assign) NSInteger enterpriseId;

// 用户ID
@property(nonatomic, copy, nonnull) NSString *userId;

// 登录接口返回的 accessToken
@property(nonatomic, copy, nonnull) NSString *accessToken;

// 预留扩展参数
@property(nonatomic, copy, nullable) NSDictionary<NSString *, NSString *> *advancedConnectConfig;

// 调试标识，true 为输出调试信息，false 为不输出调试信息
@property(nonatomic, assign) BOOL isDebug;

/**
 * 启动SDK端观测云，true 为启动观测云，false 为不启动观测云
 *
 * 注:
 * 1. 当设置该标识为 false 时, 关闭 SDK 的观测云初始化.
 *
 * 2. 当设置该标识为 true 时, 开启 SDK 的观测云初始化.
 *
 * 3. 如果 APP 端使用观测云, 则 isStartFTMobile 需要设置为 false.
 */
@property(nonatomic, assign) BOOL isStartFTMobile;

// 主叫号码（用于回呼）
@property(nonatomic, copy, nullable) NSString *callerNumber;

/**
 * 是否在对端挂断时播放预置挂机音频(注:通话错误导致的挂机不会播放音频)
 *
 * true: 播放音频(默认)
 * false: 不播放音频
 */
@property(nonatomic, assign) BOOL isPlayHangupAudio;

+ (instancetype _Nonnull)defaultConfig;

@end

-(void)setEventListener:(nullable id<TiCloudRTCEventDelegate>)delegate;

@protocol TiCloudRTCEventDelegate <NSObject>

/**
 * 引擎全局内错误信息事件回调
 *
 * @param errorCode         错误码
 * @param errorMessage   错误描述
 */
- (void)onError:(TiCloudRtcErrCode)errorCode errorMessage:(nonnull NSString *)errorMessage;

/**
 * 开始外呼
 *
 * @param requestUniqueId      为当前呼叫的唯一标识
 */
- (void)onCallingStart:(nonnull NSString *)requestUniqueId;

/**
 * 播放铃声中
 *
 */
- (void)onRinging;

/**
 * 外呼已取消
 *
 */
- (void)onCallCancelled;

/**
 * 呼叫被拒绝
 *
 */
- (void)onCallRefused;

/**
 * 呼叫中
 *
 */
- (void)onCalling;

/**
 * 调用 SDK hangup 接口引发挂断
 *
 */
- (void)onLocalHangup;

/**
 * 对方接起后挂断
 *
 */
- (void)onRemoteHangup;

/**
 * 外呼结束
 * @param errorCode         错误码
 * @param errorMessage   错误描述
 * @param sipCode           sip错误码
 *
 */
- (void)onCallingEnd:(TiCloudRtcErrCode)errorCode errorMessage:(nonnull NSString *)errorMessage sipCode:(NSInteger)sipCode;

/**
 * 外呼失败
 *
 * @param errorCode         错误码
 * @param errorMessage   错误描述
 */
- (void)onCallFailure:(TiCloudRtcErrCode)errorCode errorMessage:(nonnull NSString *)errorMessage;

/**
 *  token即将过期提醒
 *
 * @param accessToken       将在 10 分钟后过期
 *
 * 注：
 * 当前回调返回的 accessToken 不可用于 renewAccessToken 方法
 * 此处的 accessToken 一般用于日志打印。当此事件回调执行时,
 * app 应该调用部署了 accessToken 生成工具的自建服务端提供的接口，生成新的 accessToken,
 * 并使用新的 accessToken 作为参数调用 SDK 的 renewAccessToken 方法
 *
 */
- (void)onAccessTokenWillExpire:(nonnull NSString *)accessToken;

/**
 *  token已过期
 *
 */
- (void)onAccessTokenHasExpired;

/**
 * 拉取到的对方的数据流
 *
 * @param data 对方原始数据
 * @param size 数据大小
 */
- (void)receiveStreamDataFromOther:(void *_Nonnull)data size:(int)size;

/**
 * 拉取的对端的音频格式
 *
 * @param samples 采样率
 * @param channels 声道数
 */
- (void)receiveStreamSample:(int)samples channels:(int)channels;

/**
 *  检测本端网络质量
 */
- (void)networkQuality:(TiCloudRtcNetwotkQuality)netwotkQuality;

/**
* 接收到远端呼叫
*
*  @param fields 包含如下数据：
*
* customerNumber：主叫号码
* requestUniqueId：通话唯一标识
*
*/
- (void)onRemoteInvitationReceived:(nonnull NSDictionary *)fields;

/**
* 远端呼叫已拒绝
*
* @param fields 包含如下数据：
*
* customerNumber：主叫号码
* requestUniqueId：通话唯一标识
* isCalling：标识本次邀请是否因正处于通话中而自动拒绝 YES：是，NO：否
*
*/
- (void)onInvitationRefusedByLocal:(nonnull NSDictionary *)fields;

/**
* 远端呼叫已取消
*
* @param fields 包含如下数据：
*
* customerNumber：主叫号码
* requestUniqueId：通话唯一标识
*
*/
- (void)onRemoteInvitationCanceled:(nonnull NSDictionary *)fields;

/**
* 接收回呼失败
*
* errorCode：错误码
* errorMessage：通话唯一标识
*
*/
- (void)onRemoteInviteFailure:(TiCloudRtcErrCode)errorCode errorMessage:(nonnull NSString *)errorMessage

/**
 * 当前 userId 在其他设备登录，此时引擎已销毁
 */
- (void)onRemoteLogin;

/**
 * 本地监测无发送语音流时间间隔5秒时回调
 */
- (void)onLocalNoVoiceStreamSent;

/**
 * SDK 根据平台配置对 userField 外呼参数里的特殊字符进行了移除处理
 *
 * @param removedCharList 被移除的特殊字符列表
 * @param srcUserField 原始的 userField
 * @param finalUserField 处理后的 userField
 * */
- (void)onUserFieldModifiedByConfig:(nonnull NSArray *)removedCharList srcUserField:(nonnull NSString *)srcUserField finalUserField:(nonnull NSString *)finalUserField;

/// 远程音频状态改变
- (void)onRemoteAudioStateChangedOfUid:(NSUInteger)uid state:(AgoraAudioRemoteState)state reason:(AgoraAudioRemoteReason)reason elapsed:(NSInteger)elapsed;

/// 远程音频质量统计
- (void)onRemoteAudioStats:(AgoraRtcRemoteAudioStats * _Nonnull)stats;

/// 本地音频状态改变
- (void)onLocalAudioStateChanged:(AgoraAudioLocalState)state error:(AgoraAudioLocalError)error;

/// 本地音频质量统计
- (void)onLocalAudioStats:(AgoraRtcLocalAudioStats *_Nullable)stats;

/**
 *  检测全部用户网络质量
 *
 *  uid：用户id
 *
 *  txQuality：传输质量
 *  rxQuality：接受质量
 *
 */
- (void)networkQuality:(NSUInteger)uid txQuality:(AgoraNetworkQuality)txQuality rxQuality:(AgoraNetworkQuality)rxQuality;

@end

- (void)call:(TiCloudRTCCallConfig *_Nonnull)config success:(void (^)(void))successBlock error:(void (^)(TiCloudRtcErrCode nErrorCode, NSString *errorDes))errorBlock;

@interface TiCloudRTCCallConfig : NSObject

// 外呼号码
@property(nonatomic, copy, nonnull) NSString *tel;

// 外显号码
@property(nonatomic, copy, nullable) NSString *clid;

// 指定外显区号
@property(nonatomic, copy, nullable) NSString *obClidAreaCode;

// 指定外显号码池，使用此参数时obClid参数无效
@property (nonatomic, copy, nullable) NSString *obClidGroup;

// 坐席号
@property(nonatomic, copy, nullable) NSString *cno;

// 通话唯一标识 不填则有sdk内部生成
@property(nonatomic, copy, nullable) NSString *requestUniqueId;

// 自定义字段
@property(nonatomic, copy, nullable) NSString *userField;

// 呼叫场景 1:客服场景 6：外呼场景
@property(nonatomic, assign) TiCloudRtcScence type;

// 主叫号码（用于回呼,若不为空可覆盖初始化时传入的值）
@property(nonatomic, copy, nullable) NSString *callerNumber;

/**
 * 签名时间戳
 *
 * 注: 在加密模式下用到,不使用加密则不需要传入
 */
@property(nonatomic, assign) NSInteger timestamp;

/**
 * 参数签名
 *
 * 注: 在加密模式下用到,不使用加密则不需要传入
 *
 * 签名规则:
 *  1. 将参数 tel、callerNumber、clid、obClidAreaCode、obClidGroup、userField、type、timestamp 按照字典顺序排序，
 *      然后按照 key=value&key2=value2 的规则进行拼接(注意：如果没有传对应字段则不用参与拼接，requestUniqueId 不参与签名)
 *  2. 将企业 ID 拼接到拼接串开头，将企业 Token 拼接到拼接串结尾
 *  3. 将拼接串进行 SHA256 加密，最终得到的值就是签名(sign)
 *
 * 签名示例:
 *  假设企业 ID 为 7000002 , 企业 Token 为 token123456
 *  请求参数为
 *      tel: 13000000000
 *      callerNumber: 14000000000
 *      obClidGroup: 号码池1
 *      type: 6
 *      timestamp: 1735192796
 *
 *
 *  按照步骤开始计算签名
 *
 *  经过第一步计算之后得到  callerNumber=14000000000&obClidGroup=号码池1&tel=13000000000&timestamp=1735192796&type=6
 *
 *  经过第二步计算之后得到  7000002callerNumber=14000000000&obClidGroup=号码池1&tel=13000000000&timestamp=1735192796&type=6token123456
 *
 *  经过第三步计算之后得到  398db99bf641dbc489a61204257ea7e91ce2dd490a3f37862dc6c4992168c5dd
 *
 */
@property(nonatomic, copy, nullable) NSString *sign;

// 预留扩展参数
@property(nonatomic, copy, nullable) NSDictionary<NSString *, NSString *> *advancedConnectConfig;

+ (instancetype _Nonnull)defaultConfig;

@end

typedef NS_ENUM(NSInteger, TiCloudRtcScence)
{
    TiCloudRtcScence_AGENTSCENCE = 1,      // 客服场景
    TiCloudRtcScence_OUTCALLSCENCE = 6,    // 外呼场景
};

typedef NS_ENUM(NSInteger, TiCloudRtcNetwotkQuality)
{
    TiCloudRtcNetwotkQuality_Unknown,      // 网络质量未知
    TiCloudRtcNetwotkQuality_Good ,      // 网络质量较好
    TiCloudRtcNetwotkQuality_General ,    // 网络质量一般
    TiCloudRtcNetwotkQuality_Bad ,    // 网络质量较差
};

    NSString *userField = "["
    "{\"name\":\"id\",\"value\":\"90007573\",\"type\":1},"
      "{\"name\":\"workNum\",\"value\":\"1026658\",\"type\":1},"
      "{\"name\":\"depId\",\"value\":\"340179\",\"type\":1}"
    "]";

    TiCloudRTCCallConfig * callConf = [[TiCloudRTCCallConfig alloc] init];
    callConf.type = TiCloudRtcScence_AGENTSCENCE;
    callConf.userField = userField;

    [self.SDKEngine.tiCloudEngine call:callConf success:^{
    } error:^(TiCloudRtcErrCode nErrorCode, NSString * _Nonnull errorDes) {
    }];

/**
 * 接受会话邀请
 */
- (void)acceptCall;

/**
 * 拒绝会话邀请
 */
- (void)refuseCall;

- (void)hangup;

- (void)destroyClient:(void (^)(void))onSuccess error:(void (^)(TiCloudRtcErrCode errorCode, NSString *errorMessage))onFailed;

- (void)renewAccessToken:(NSString *)accessToken;

- (void)dtmf:(NSString *)digits;

- (void)setEnableSpeakerphone:(BOOL)isEnable;

BOOL isEnable = [rtcClient isSpeakerphoneEnabled];

-(void)setMicrophoneMute:(BOOL)muted;

NSString *String = [rtcClient getVersion];

{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.MICROPHONE",
        "reason": "需要使用麦克风进行通话",//此处建议引用$string资源文件内容
        "usedScene": {
          "abilities": ["EntryAbility"],
          "when": "inuse"
        }
      },
      {
        "name": "ohos.permission.KEEP_BACKGROUND_RUNNING",
        "reason": "为了在后台使用语音通话",//此处建议引用$string资源文件内容
        "usedScene": {
          "abilities": [
            "EntryAbility"
          ],
          "when":"inuse"
        }
      },
      {
        "name": "ohos.permission.INTERNET"
      }
    ]
  }
}

TiCloudRTC.shared.CreateEngine(createClientOption, resultCallback);

// 创建配置选项
let createClientOption = new CreateClientOption()
createClientOption.rtcEndpoint = "YOUR_RTC_ENDPOINT"    // RTC服务地址
createClientOption.enterpriseId = "YOUR_ENTERPRISE_ID"  // 企业ID
createClientOption.userId = "YOUR_USER_ID"             // 用户ID
createClientOption.accessToken = "YOUR_ACCESS_TOKEN"   // 访问令牌
createClientOption.advancedConnectConfig = new Map()   // 高级配置
createClientOption.debug = true                        // 是否开启调试模式

// 初始化引擎
TiCloudRTC.shared.CreateEngine(createClientOption, {
  onSuccess: () => {
    console.info('引擎初始化成功');
  },
  onFailed: (errorCode: number, errorMessage: string) => {
    console.error('引擎初始化失败:', errorMessage);
  }
});

TiCloudRTC.shared.setEventListener(listener);

// 实现 TiCloudRTCEventListener 接口
class MyEventHandler implements TiCloudRTCEventListener {
  onError?(errorCode: number, errorMessage: string): void {
    console.error('发生错误:', errorMessage);
  }

  onCallingStart?(requestUniqueId: string): void {
    console.info('开始呼叫:', requestUniqueId);
  }

  onRinging?(): void {
    console.info('正在振铃');
  }

  onCalling?(): void {
    console.info('通话进行中');
  }

  // ... 实现其他需要的回调方法
}

// 设置事件监听
TiCloudRTC.shared.setEventListener(new MyEventHandler());

TiCloudRTC.shared.call(callOption);

let callOption = new CallOption();
callOption.tel = "PHONE_NUMBER"      // 被叫号码
callOption.type = 6                  // 呼叫类型
callOption.clid = "DISPLAY_NUMBER"   // 外显号码

TiCloudRTC.shared.call(callOption);

TiCloudRTC.shared.acceptCall();

// 接受回呼
TiCloudRTC.shared.acceptCall();

TiCloudRTC.shared.refuseCall();

// 拒绝回呼
TiCloudRTC.shared.refuseCall();

TiCloudRTC.shared.dtmf(digits);

// 发送 DTMF 按键信号
TiCloudRTC.shared.dtmf("1");

TiCloudRTC.shared.renewAccessToken(newAccessToken);

// 更新 AccessToken
TiCloudRTC.shared.renewAccessToken("NEW_ACCESS_TOKEN");

TiCloudRTC.shared.hangup();

// 挂断通话
TiCloudRTC.shared.hangup();

TiCloudRTC.shared.destroyClient(callback);

TiCloudRTC.shared.setEnableSpeakerphone(enable);

// 控制扬声器
TiCloudRTC.shared.setEnableSpeakerphone(true);  // 开启扬声器
TiCloudRTC.shared.setEnableSpeakerphone(false); // 关闭扬声器

const enabled = TiCloudRTC.shared.isSpeakerphoneEnabled();

TiCloudRTC.shared.setMicrophoneMute(mute);

// 控制麦克风
TiCloudRTC.shared.setMicrophoneMute(true);  // 静音
TiCloudRTC.shared.setMicrophoneMute(false); // 取消静音

const version = await TiCloudRTC.shared.getVersion();

// 获取版本号
const version = await TiCloudRTC.shared.getVersion();

    /**
     * 假设通过 userField 传递 3 个数据: id、workNum、depId,
     * 值分别为: 90007573、1026658、340179
     */
    let userField = encodeURIComponent(JSON.stringify({
      "id":"90007573",
      "workNum":"1026658",
      "depId":"340179",
    }))

    wx.navigateToMiniProgram({
      appId: 'wxae54af9eaf3f3982', // CTI-Cloud 小程序 appid
      path: `pages/calling/calling?token=${token}&enterpriseId=${enterpriseId}&cno=${cno}&called_number=${calledNumber}&clid=${clid}&requestUniqueId=${requestUniqueId}&userField=${userField}&callerNumber=${callerNumber}&platform=${platform}&type=${type}&enableSpeaker=${enableSpeaker}`,
      success(res) {
      // 打开成功
      }
    })