/*----------------------------------------------------------------------------
 * Copyright (c) TJD Technologies Co., Ltd. 2025. All rights reserved.
 *
 * Description: TjdPhoneService.cpp
 *
 * Author: luziquan@ss-tjd.com
 *
 * Create: 2025-08-16
 *--------------------------------------------------------------------------*/

#include "TjdPhoneService.h"
#include "TjdPhoneAudio.h"
#include "TjdPhoneContacts.h"
#include "TjdUiMsgCenter.h"
#include "TjdUiSettingCenter.h"
#include "audio_base_type.h"
#include "bts_pbap.h"
#include "graphic_service.h"
#include "service_bt.h"
#include "sys_config.h"
#include "thread_adapter.h"
#include "ui_screennotify.h"
#include <dirent.h>
#include <securec.h>
#include <stdio.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

extern "C"
{
#include "power_display_service.h"
}

#define ENABLE_PRINT_INFO 1
#if ENABLE_PRINT_INFO
#define static_print_warn(...) sys_phone_log_w(__VA_ARGS__)  // 警告信息打印一般常开
#define static_print_error(...) sys_phone_log_e(__VA_ARGS__) // 错误信息打印一般常开
#define static_print_debug(...) sys_phone_log_d(__VA_ARGS__) // 调试信息打印一般常开
#else
#define static_print_warn(...)
#define static_print_error(...)
#define static_print_debug(...)
#endif

typedef enum
{
    AUDIO_UNKNOW = 0,
    AUDIO_ACT_INTERRUPT_WATCH_RING, // 手表铃声焦点
    AUDIO_ACT_INTERRUPT_BT_SCO,     // 蓝牙通话焦点
    AUDIO_CONN_IN_BT_SCO,
    AUDIO_CONN_OUT_BT_SCO,
    AUDIO_STREAM_INIT,
    AUDIO_STREAM_START_SCO,
    AUDIO_STREAM_START_DN,
    AUDIO_STREAM_START_UP,
} AudioState;

#define TJD_CALL_LOG_DIR "/user/tjd_phone"
#define TJD_CALL_LOG_PATH (TJD_CALL_LOG_DIR "/calllog.bin")
#define TJD_CALL_TMP_LOG_PATH (TJD_CALL_LOG_DIR "/calltmplog.bin")
#define INVALID_PHONE_SERVICE_VALUE (-1)

static uint32_t g_scoFlag = HFP_SCO_STATE_DISCONNECTED; // sco连接状态，同时也表示通话在手表还是在手机
static uint32_t g_btConnState = PROFILE_STATE_DISCONNECTED;   // 蓝牙连接状态
static uint32_t g_currCallState = HFP_HF_CALL_STATE_FINISHED; // 电话呼叫状态类型。
static bool g_completeCallFlag = false; // 完整通话流程：从incoming、dialing或alerting开始才算完整
static uint32_t g_call_codec = mSBC;    // 通话编解码类型
static bd_addr_t g_bdAddr;              // 设备的蓝牙地址
static uint32 g_currCallNum = 0;        // 当前通话路数
static MutexId g_audioMutex;
static ContactsInfo g_callList[MULTI_CALL_MAX_NUME];
static uint32_t g_finishOperate = OPERATE_NON_WATCH_FINISH;
static uint32_t g_audioState = AUDIO_UNKNOW;
static uint32_t g_interval = 5;

static int g_hdlUpMic = INVALID_PHONE_SERVICE_VALUE;
static int g_hdlUpSco = INVALID_PHONE_SERVICE_VALUE;
static int g_hdlDnSpk = INVALID_PHONE_SERVICE_VALUE;
static int g_hdlDnSco = INVALID_PHONE_SERVICE_VALUE;

bd_addr_t *GetHfpBdAddr(void) { return &g_bdAddr; }

static void PostGraphicEvent(void (*fun)(void))
{
    static_print_debug("[PostGraphicEvent] start");
    GraphicService::GetInstance()->PostGraphicEvent(*fun);
}

static PhoneServiceCb g_callChanged;
int RegisterPhoneCallChangedCb(PhoneServiceCb *phoneServiceFun)
{
    if (phoneServiceFun == nullptr) {
        return OHOS_FAILURE;
    }
    (void)memcpy_s(&g_callChanged, sizeof(g_callChanged), phoneServiceFun, sizeof(g_callChanged));
    return OHOS_SUCCESS;
}

static void ScreenTurnOn(int32_t timeout)
{
#if defined(SUPPORT_POWER_MANAGER)
    g_interval = get_back_to_home_interval();
    set_back_to_home_interval(0xFFFFFFFF);
    const power_display_svr_api_t *display_api = power_display_svr_get_api();
    if (display_api->get_screen_state() != SCREEN_ON) {
        display_api->turn_on_screen();
    }
    display_api->set_screen_set_keepon_timeout(timeout);
#endif
    return;
}

static void ScreenTurnOff(void)
{
#if defined(SUPPORT_POWER_MANAGER)
    set_back_to_home_interval(g_interval);
    const power_display_svr_api_t *display_api = power_display_svr_get_api();
    display_api->set_screen_set_keepon_timeout(0);
#endif
    return;
}

static void PhoneServiceScreenCtr(bool turnOnFlag)
{
    if (turnOnFlag) {
        ScreenTurnOn(-1);
    } else {
        ScreenTurnOff();
    }
}

// 手表主动拨打电话
int DialCallOut(const unsigned char *number, unsigned char len)
{
    int ret;
    unsigned char *tel = nullptr;
    static_print_debug("[DialCall] start");
    if (g_btConnState != PROFILE_STATE_CONNECTED) {
        static_print_error("[DialCall] BT connStatus: 0x%X", g_btConnState);
        return OHOS_FAILURE;
    }

    // 有通话时，不允许拨出电话
    if (g_currCallNum > 0 || len > MAX_PHONE_NUM || number == nullptr) {
        static_print_error("[DialCall] g_currCallNum:%d", g_currCallNum);
        return OHOS_FAILURE;
    }

    tel = (unsigned char *)malloc(len + 1);
    if (tel == nullptr) {
        static_print_error("[DialCall] malloc tel error");
        return OHOS_FAILURE;
    }
    (void)memcpy_s(tel, len, number, len);
    *(tel + len) = '\0';
    ret = hfp_hf_start_dial(&g_bdAddr, tel, len);
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_error("[DialCall] hfp_hf_start_dial ret %d", ret);
        free(tel);
        return OHOS_FAILURE;
    }
    static_print_debug("[DialCall] success!");
    free(tel);
    return OHOS_SUCCESS;
}

// 手表主动接听
int AnswerCallIn(void)
{
    static_print_debug("[AcceptIncomingCall] start");
    int32_t ret;
    ContactsInfo *phoneCall = nullptr;
    ContactsInfo *tmp = g_callList;

    if (g_btConnState != PROFILE_STATE_CONNECTED) {
        static_print_error("[AcceptIncomingCall] BT connStatus: 0x%X", g_btConnState);
        return OHOS_FAILURE;
    }

    for (int32_t i = 0; i < MULTI_CALL_MAX_NUME; i++) {
        if (tmp->lastStatus == HFP_HF_CALL_STATE_INCOMING || tmp->lastStatus == HFP_HF_CALL_STATE_WAITING) {
            phoneCall = tmp;
            break;
        }
        tmp++;
    }

    if (phoneCall == nullptr) {
        static_print_error("[AcceptIncomingCall] no incoming");
        return OHOS_FAILURE;
    }

    phoneCall->operate = OPERATE_WATCH_ACTIVE;

    if (g_currCallNum > 1) {
        // 正在通话，有人呼入，接听呼入电话，挂起当前通话
        ret = hfp_hf_accept_incoming_call(&g_bdAddr, HFP_HF_ACCEPT_CALL_ACTION_HOLD);
    } else {
        // 无人通话，有人呼入，接听呼入电话
        ret = hfp_hf_accept_incoming_call(&g_bdAddr, HFP_HF_ACCEPT_CALL_ACTION_NONE);
    }
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_error("[AcceptIncomingCall] ret:%d", ret);
        phoneCall->operate = OPERATE_NO_OPE;
        return OHOS_FAILURE;
    }
    static_print_debug("[AcceptIncomingCall] success!");
    return OHOS_SUCCESS;
}

// 手表拒接呼入来电，成功：0，失败：错误码
int RejectCallIn(void)
{
    static_print_debug("[RejectIncomingCall] start");
    ContactsInfo *phoneCall = nullptr;
    ContactsInfo *tmp = g_callList;

    if (g_btConnState != PROFILE_STATE_CONNECTED) {
        static_print_error("[RejectIncomingCall] BT connStatus: 0x%X", g_btConnState);
        return OHOS_FAILURE;
    }

    for (int32_t i = 0; i < MULTI_CALL_MAX_NUME; i++) {
        if (tmp->lastStatus == HFP_HF_CALL_STATE_INCOMING || tmp->lastStatus == HFP_HF_CALL_STATE_WAITING) {
            phoneCall = tmp;
        }
        tmp++;
    }

    if (phoneCall == nullptr) {
        static_print_error("[AcceptIncomingCall] no incoming");
        return OHOS_SUCCESS;
    }

    int32_t ret = hfp_hf_reject_incoming_call(&g_bdAddr);
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_error("[RejectIncomingCall] ret:%d", ret);
        return OHOS_FAILURE;
    }
    g_finishOperate = OPERATE_WATCH_REJECT;
    static_print_debug("[RejectIncomingCall] success!");
    return OHOS_SUCCESS;
}

// 手表结束通话
int DialCallFinish(void)
{
    if (g_btConnState != PROFILE_STATE_CONNECTED) {
        static_print_error("[FinishCall] BT connStatus: 0x%X", g_btConnState);
        return OHOS_FAILURE;
    }
    if (g_currCallState != HFP_HF_CALL_STATE_ACTIVE && g_currCallState != HFP_HF_CALL_STATE_HELD &&
        g_currCallState != HFP_HF_CALL_STATE_DIALING && g_currCallState != HFP_HF_CALL_STATE_ALERTING) {
        static_print_error("[FinishCall] g_currCallState:%d", g_currCallState);
        return OHOS_FAILURE;
    }
    int ret = hfp_hf_finish_call(&g_bdAddr);
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_error("[FinishCall] ret:%d", ret);
        return OHOS_FAILURE;
    }
    g_finishOperate = OPERATE_WATCH_FINISH;
    static_print_debug("FinishCall");
    return OHOS_SUCCESS;
}

// 获取当前正在通话路数
int GetCurCallNumber(void) { return g_currCallNum; }

static void CallChangedCb(const ContactsInfo *phoneCall)
{
    if (g_callChanged.callChanged != nullptr) {
        g_callChanged.callChanged(phoneCall);
    }
}

static void ScoStatusCb(hfp_sco_connect_state_t state)
{
    if (g_callChanged.scoStatusCb != nullptr) {
        g_callChanged.scoStatusCb(state);
    }
}

static void PhoneServiceErrorCallback(PhoneServiceErrorType type, int volume)
{
    if (g_callChanged.phoneServiceErrorCb != nullptr) {
        g_callChanged.phoneServiceErrorCb(type, volume);
    }
}

static void CopyBdAddr(const bd_addr_t *bdAddr)
{
    unsigned char addr[BD_ADDR_LEN] = {0};
    if (strncmp((const char *)g_bdAddr.addr, (const char *)addr, BD_ADDR_LEN) == 0) {
        (void)memcpy_s(g_bdAddr.addr, BD_ADDR_LEN, bdAddr->addr, BD_ADDR_LEN);
    }
}

static void HfpIncomingEventPublish(uint16 topic, hfp_hf_calls_info_t callsInfo)
{
    int32_t ret;
    uint32_t size = sizeof(hfp_hf_calls_info_t);
    static_print_debug("HfpIncomingEventPublish topic=%u!!", topic);

    TjdUiMsgEventPublish(topic, &callsInfo, size);
}

#pragma region 通话记录
// 获取当前通话记录
std::vector<CallLogInfo> ReadCallLogs(void)
{
    std::vector<CallLogInfo> callLogs;
    FILE *fp = fopen(TJD_CALL_LOG_PATH, "rb");
    if (fp == nullptr) {
        static_print_error("[ReadCallLogs] fopen %s failed!", TJD_CALL_LOG_PATH);
        return callLogs;
    }

    CallLogInfo info;
    while (fread(&info, sizeof(CallLogInfo), 1, fp) == 1) {
        static_print_debug("[ReadCallLogs] name %s, tel %s", info.name, info.tel);
        callLogs.push_back(info);
    }

    if (ferror(fp)) {
        static_print_error("[ReadCallLogs] fread failed!");
    }

    fclose(fp);
    return callLogs;
}

// 通话记录初始化
static void CallListInit(void)
{
    int i;
    g_currCallNum = 0;
    (void)memset_s(g_callList, sizeof(g_callList), 0, sizeof(g_callList));
    for (i = 0; i < MULTI_CALL_MAX_NUME; i++) {
        (void)memset_s(g_callList[i].name, NAME_SIZE, '\0', NAME_SIZE);
        (void)memset_s(g_callList[i].tel, MAX_PHONE_NUM, '\0', MAX_PHONE_NUM);
        g_callList[i].lastStatus = HFP_HF_CALL_STATE_FINISHED;
    }
}

// 获取通话记录文件大小
static int GetCallLogFileSize(void)
{
    int len = 0;
    FILE *fp = fopen(TJD_CALL_LOG_PATH, "rb");
    if (fp == nullptr) {
        static_print_error("[GetCallLogFileSize] fopen %s failed", TJD_CALL_LOG_PATH);
        return 0;
    }

    fseek(fp, 0, SEEK_END);
    len = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    fclose(fp);

    static_print_debug("[GetCallLogFileSize] len:%d", len);
    return len;
}

// 清空通话记录
static int ClearCallLogInfoFile(void)
{
    FILE *fp = fopen(TJD_CALL_LOG_PATH, "wb");
    if (fp == nullptr) {
        static_print_error("[ClearCallLogFile] fopen %s failed!", TJD_CALL_LOG_PATH);
        return OHOS_FAILURE;
    }

    fclose(fp);
    return OHOS_SUCCESS;
}

static ContactsInfo *FindCallInfoInCallList(const unsigned char *number, unsigned char numberLen)
{
    int i;
    const char *str1 = nullptr;
    const char *str2 = nullptr;
    if (g_currCallNum == 0) {
        return nullptr;
    }
    for (i = 0; i < MULTI_CALL_MAX_NUME; i++) {
        if (numberLen != g_callList[i].telLen) {
            continue;
        } else {
            str1 = (const char *)number;
            str2 = (const char *)g_callList[i].tel;

            if (strncmp(str1, str2, numberLen) == 0) {
                return &g_callList[i];
            }
        }
    }
    return nullptr;
}

// 通话记录添加
static void AddCurrCallToCallList(const hfp_hf_calls_info_t *call)
{
    static_print_debug("[AddCurrCallToCallList] state:%d", call->state);
    if (call == nullptr || g_currCallNum >= MULTI_CALL_MAX_NUME ||
        (call->state != HFP_HF_CALL_STATE_ACTIVE && call->state != HFP_HF_CALL_STATE_HELD &&
         call->state != HFP_HF_CALL_STATE_ALERTING)) {
        return;
    }

    g_currCallNum++;
    int32_t tmp = g_currCallNum - 1;
    ContactsInfo *phoneCall = &g_callList[tmp];
    if (call->state == HFP_HF_CALL_STATE_ACTIVE) { // 正在通话
        phoneCall->operate = OPERATE_PHONE_ACTIVE;
        phoneCall->activeTime = time(nullptr);
    } else if (call->state == HFP_HF_CALL_STATE_HELD) { // 挂起
        phoneCall->operate = OPERATE_PHONE_HOLD;
        phoneCall->activeTime = time(nullptr);
    } else if (call->state == HFP_HF_CALL_STATE_ALERTING) { // 呼出，对方响铃
        phoneCall->operate = OPERATE_ALERTING;
    }

    // 使用通讯录接口获取当前电话对应的备注人名(通讯录待开发)

    phoneCall->lastStatus = call->state;
    phoneCall->creationTime = time(nullptr);

    int32_t ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
    if (ret != EOK) {
        static_print_error("[AddCurrCallToCallList] copy tel ret:%d", ret);
    }
    phoneCall->telLen = call->number_len;
    (void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));
    static_print_debug("[AddCurrCallToCallList] end");

    static_print_debug("[AddCurrCallToCallList] name:%s, tel:%s, telLen:%d", phoneCall->name, phoneCall->tel,
                       phoneCall->telLen);

    // 通知手表电话呼入
    CallChangedCb(phoneCall);
}

static int CopyPhoneLogToTmpLog(void)
{
    FILE *fp = nullptr;
    FILE *ftp = nullptr;
    CallLogInfo *info = nullptr;

    int retLen;
    int fileSize = GetCallLogFileSize();
    if (fileSize == OHOS_FAILURE || fileSize == 0) {
        return fileSize;
    }

    retLen = fileSize - sizeof(CallLogInfo);
    if (retLen == 0) {
        return ClearCallLogInfoFile(); // 只有一条记录，清空通话记录
    }

    fp = fopen(TJD_CALL_LOG_PATH, "rb");
    if (fp == nullptr) {
        return OHOS_FAILURE;
    }
    ftp = fopen(TJD_CALL_TMP_LOG_PATH, "wb+");
    if (ftp == nullptr) {
        fclose(fp);
        return OHOS_FAILURE;
    }

    info = (CallLogInfo *)malloc(fileSize);
    if (info == nullptr) {
        fclose(fp);
        fclose(ftp);
        return OHOS_FAILURE;
    }

    (void)memset_s(info, fileSize, 0, fileSize);
    if (fread(info, fileSize, 1, fp) != 1) {
        retLen = OHOS_FAILURE;
        goto END;
    }

    if (fwrite((info + 1), retLen, 1, ftp) != 1) {
        retLen = OHOS_FAILURE;
        goto END;
    }

END:
    fclose(fp);
    fclose(ftp);
    free(info);
    info = nullptr;
    return retLen;
}

// 删除第一条通话记录
static int RemoveFirstCallLog(void)
{
    FILE *fp = nullptr;
    FILE *ftp = nullptr;
    CallLogInfo *info = nullptr;

    int ret = OHOS_SUCCESS;
    int fileSize = CopyPhoneLogToTmpLog();
    if (fileSize == OHOS_FAILURE || fileSize == 0) {
        return fileSize;
    }

    fp = fopen(TJD_CALL_LOG_PATH, "wb+");
    if (fp == nullptr) {
        return OHOS_FAILURE;
    }
    ftp = fopen(TJD_CALL_TMP_LOG_PATH, "rb");
    if (ftp == nullptr) {
        fclose(fp);
        return OHOS_FAILURE;
    }

    info = (CallLogInfo *)malloc(fileSize);
    if (info == nullptr) {
        fclose(fp);
        fclose(ftp);
        return OHOS_FAILURE;
    }
    (void)memset_s(info, fileSize, 0, fileSize);
    if (fread(info, fileSize, 1, ftp) != 1) {
        ret = OHOS_FAILURE;
        goto END;
    }

    if (fwrite(info, fileSize, 1, fp) != 1) {
        ret = OHOS_FAILURE;
        goto END;
    }

END:
    fclose(fp);
    fclose(ftp);
    free(info);
    info = nullptr;
    return ret;
}

static void AddToCallLog(CallLogInfo *info)
{
    FILE *fp = nullptr;
    size_t ret;

    fp = fopen(TJD_CALL_LOG_PATH, "ab");
    if (fp == nullptr) {
        static_print_error("[AddToCallLog] fopen %s failed!", TJD_CALL_LOG_PATH);
        return;
    }

    ret = fwrite(info, sizeof(CallLogInfo), 1, fp);
    if (ret != 1) {
        static_print_error("[AddToCallLog] fwrite failed! ret:%d", ret);
    }
    static_print_debug("[AddToCallLog] fwrite :%d", ret);

    fclose(fp);
    static_print_debug("[AddToCallLog] success! name:%s, tel:%s, telLen:%d", info->name, info->tel, info->telLen);
}

// 添加通话记录
static void AddToCallLogPro(ContactsInfo *callInfo)
{
    if (callInfo == nullptr) {
        return;
    }

    int fileSize = GetCallLogFileSize();
    int num = fileSize / sizeof(CallLogInfo);
    if (num >= CALL_LOG_MAX_NUM) {
        int ret = RemoveFirstCallLog();
        if (ret == OHOS_FAILURE) {
            static_print_error("[AddToCallLogPro] RemoveFirstCallLog error");
            return;
        }
    }

    CallLogInfo info;
    (void)memset_s(info.name, NAME_SIZE, '\0', NAME_SIZE);
    (void)memset_s(info.tel, MAX_PHONE_NUM, '\0', MAX_PHONE_NUM);
    int ret = memcpy_s(info.name, NAME_SIZE, callInfo->name, callInfo->nameLen);
    if (ret != EOK) {
        info.nameLen = 0;
    } else {
        info.nameLen = callInfo->nameLen;
    }

    ret = memcpy_s(info.tel, MAX_PHONE_NUM, callInfo->unitCalls.number, callInfo->unitCalls.number_len);
    if (ret != EOK) {
        info.telLen = 0;
    } else {
        info.telLen = callInfo->unitCalls.number_len;
    }

    info.creationTime = callInfo->creationTime;
    if (callInfo->lastStatus == HFP_HF_CALL_STATE_ACTIVE || callInfo->lastStatus == HFP_HF_CALL_STATE_HELD ||
        callInfo->lastStatus == HFP_HF_CALL_STATE_RESPONSE_HELD) {
        info.callDurTime = time(nullptr) - callInfo->activeTime;
    } else {
        info.callDurTime = 0;
    }

    if (callInfo->lastStatus == HFP_HF_CALL_STATE_INCOMING || callInfo->lastStatus == HFP_HF_CALL_STATE_WAITING) {
        info.status = CALL_MISSED;
    } else if (callInfo->unitCalls.outgoing == 1) {
        info.status = CALL_OUTGOING;
    } else {
        info.status = CALL_INCOMING;
    }

    AddToCallLog(&info);
}

#pragma endregion

static void BtDisconnectedPro(void)
{
    g_btConnState = PROFILE_STATE_DISCONNECTED;
    (void)memset_s(g_bdAddr.addr, BD_ADDR_LEN, 0, BD_ADDR_LEN);

    // 通知APP蓝牙断开连接
    PhoneServiceErrorCallback(ERROR_BT, PROFILE_STATE_DISCONNECTED);
    CallListInit();

    if (g_currCallState == HFP_HF_CALL_STATE_INCOMING) {
        /* 处理呼入阶段，取消手表配对 */
        hfp_hf_calls_info_t call = {};
        HfpIncomingEventPublish(TOPIC_EVENT_HFP_FINISHED, call);
    }

    g_currCallState = HFP_HF_CALL_STATE_FINISHED;
    g_scoFlag = HFP_SCO_STATE_DISCONNECTED;
    g_completeCallFlag = false;
}

static bool IsCompleteCallFlow(void) { return g_completeCallFlag; }

// 获取当前通话音量大小 (0 - 15)
// hfp音量范围 0-15, media 音量范围 0-100
unsigned char GetHFPCallCurrVolume(void)
{
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();
    int32_t volume = audio.PhoneAudioGetVolume();
    int32_t minVolume = audio.PhoneAudioGetMinVolume();
    int32_t maxVolume = audio.PhoneAudioGetMaxVolume();
    unsigned char hfpVolume = (unsigned char)((volume * CALL_VOLUME_MAX) / (maxVolume - minVolume)); // 转换

    if (volume != 0 && hfpVolume == 0) {
        hfpVolume = 1;
    }
    static_print_debug("[GetHFPCallCurrVolume] volume:%d, minVolume:%d, maxVolume:%d, hfpVolume:%d", volume, minVolume,
                       maxVolume, hfpVolume);
    return hfpVolume;
}

void SetHFPSpeakerVolume(unsigned char hfpVolume)
{
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();
    static_print_debug("[SetHFPSpeakerVolume] start, hfpVolume:%d", hfpVolume);
    int32_t minVolume = audio.PhoneAudioGetMinVolume();
    int32_t maxVolume = audio.PhoneAudioGetMaxVolume();
    int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换
    static_print_debug("[SetHFPSpeakerVolume] minVolume:%d, maxVolume:%d, volume:%d", minVolume, maxVolume, volume);
    int32_t ret = audio.PhoneAudioSetVolume(volume);
    if (!ret) {
        static_print_error("[SetHFPSpeakerVolume] PhoneAudioSetVolume ret:%d", ret);
        return;
    }
    ret = hfp_hf_set_volume(&g_bdAddr, HFP_VOLUME_SPEAKER, hfpVolume);
    if (ret != ERRCODE_BT_SUCCESS) {
        static_print_error("[SetHFPSpeakerVolume] set_volume ret:%d, hfpVolume:%d", ret, hfpVolume);
        return;
    }
    static_print_debug("[SetHFPSpeakerVolume] success!");
}

// 通话状态变化--接听流程处理
static void CallChangeActivePro(const hfp_hf_calls_info_t *call)
{
    if (call == nullptr) {
        return;
    }

    // 如果通话记录中没有该通话，添加到通话记录中，然后通知通话转移到手机
    ContactsInfo *phoneCall = nullptr;
    phoneCall = FindCallInfoInCallList((const unsigned char *)call->number, call->number_len);
    if (phoneCall == nullptr) {
        static_print_debug("[CallChangeActivePro] Active no this call");
        AddCurrCallToCallList(call);
        // TransCallToMobilePhone();
        return;
    }

    if (phoneCall->lastStatus == HFP_HF_CALL_STATE_HELD && IsCompleteCallFlow()) { // 挂起状态切换到接听状态
        phoneCall->operate = OPERATE_WATCH_ACTIVE;
    } else if (phoneCall->lastStatus == HFP_HF_CALL_STATE_HELD && (!IsCompleteCallFlow())) {
        phoneCall->operate = OPERATE_PHONE_ACTIVE;
    } else if (phoneCall->operate == OPERATE_WATCH_ACTIVE) { // 手表接听
        // 不做操作
    } else {
        if (phoneCall->unitCalls.outgoing == 1 && (phoneCall->lastStatus == HFP_HF_CALL_STATE_DIALING ||
                                                   phoneCall->lastStatus == HFP_HF_CALL_STATE_ALERTING)) {
            phoneCall->operate = OPERATE_PEER_ACTIVE; // 对方接听
        } else {
            // 手机接听
            phoneCall->operate = OPERATE_PHONE_ACTIVE;
            static_print_debug("[CallChangeActivePro] phone active!");
        }
    }

    if (phoneCall->activeTime == 0 &&
        (phoneCall->lastStatus == HFP_HF_CALL_STATE_DIALING || phoneCall->lastStatus == HFP_HF_CALL_STATE_ALERTING ||
         phoneCall->lastStatus == HFP_HF_CALL_STATE_INCOMING || phoneCall->lastStatus == HFP_HF_CALL_STATE_WAITING)) {
        phoneCall->activeTime = time(nullptr);
    }

    phoneCall->lastStatus = call->state;
    (void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));
    if (phoneCall->operate == OPERATE_PHONE_ACTIVE) {
        // 发布电话接听事件，手表关闭来电通知
        HfpIncomingEventPublish(TOPIC_EVENT_HFP_PHONE_ACTIVE, phoneCall->unitCalls);
    } else if (phoneCall->operate == OPERATE_WATCH_ACTIVE && g_scoFlag == HFP_SCO_STATE_CONNECTED) {
        // 发布手表接听事件，通知切换接听界面
        HfpIncomingEventPublish(TOPIC_EVENT_HFP_WATCH_ACTIVE, phoneCall->unitCalls);
    }
    // 通知手表触发接听
    CallChangedCb(phoneCall);
}

// 通话状态变化--挂起通话（当前只有手机挂起触发（并且手表不需感知），手表不支持挂起触发，对方挂起不感知）
static void CallChangeHeldPro(const hfp_hf_calls_info_t *call)
{
    if (call == nullptr) {
        return;
    }

    ContactsInfo *phoneCall = FindCallInfoInCallList((const unsigned char *)call->number, call->number_len);
    if (phoneCall == nullptr) {
        static_print_debug("[CallChangeHeldPro] Held no this call");
        AddCurrCallToCallList(call);
        return;
    }

    // 手机挂起通话
    phoneCall->operate = OPERATE_PHONE_HOLD;
    if (phoneCall->lastStatus == HFP_HF_CALL_STATE_INCOMING || phoneCall->lastStatus == HFP_HF_CALL_STATE_WAITING) {
        phoneCall->activeTime = time(nullptr);
    }
    phoneCall->lastStatus = call->state;
    (void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));

    // 通知手表触发挂起
    CallChangedCb(phoneCall);
}

// 通话状态变化--呼出，正在拨号处理
static void CallChangeDialPro(const hfp_hf_calls_info_t *call)
{
    if (call == nullptr) {
        return;
    }

    g_currCallNum++;
    int32_t tmp = g_currCallNum - 1;
    ContactsInfo *phoneCall = &g_callList[tmp];

    // 使用通讯录接口获取当前电话对应的备注人名(通讯录待开发)

    phoneCall->operate = OPERATE_DIALING;
    phoneCall->lastStatus = call->state;
    phoneCall->creationTime = time(nullptr);

    int32_t ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
    if (ret != EOK) {
        static_print_error("[CallChangeDialPro] copy tel ret:%d", ret);
    }
    phoneCall->telLen = call->number_len;

    (void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));

    // 通知手表正在拨号
    CallChangedCb(phoneCall);
}

// 通话状态变化--呼出，对方响铃
static void CallChangeAlertPro(const hfp_hf_calls_info_t *call)
{
    ContactsInfo *phoneCall = nullptr;
    if (call == nullptr) {
        return;
    }
    phoneCall = FindCallInfoInCallList((const unsigned char *)call->number, call->number_len);
    if (phoneCall == nullptr) {
        static_print_debug("[CallChangeAlertPro] Alert no this call");
        AddCurrCallToCallList(call);
        return;
    }
    phoneCall->operate = OPERATE_ALERTING;
    phoneCall->lastStatus = call->state;

    (void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));

    // 通知手表正对方响铃
    CallChangedCb(phoneCall);
}

// 通话状态变化--呼入处理
static void CallChangeIncomePro(const hfp_hf_calls_info_t *call)
{
    if (call == nullptr || g_currCallNum >= MULTI_CALL_MAX_NUME ||
        (call->state != HFP_HF_CALL_STATE_INCOMING && call->state != HFP_HF_CALL_STATE_WAITING)) {
        return;
    }

    ContactsInfo *phoneCall = FindCallInfoInCallList((const unsigned char *)call->number, call->number_len);
    if (phoneCall != nullptr) {
        // 通话状态由呼入等待转换成呼入情况
    } else {
        g_currCallNum++;
        int32_t tmp = g_currCallNum - 1;
        phoneCall = &g_callList[tmp];
    }

    // 使用通讯录接口获取当前电话对应的备注人名(通讯录待开发)

    if (call->state == HFP_HF_CALL_STATE_INCOMING) {
        phoneCall->operate = OPERATE_INCOMING;
    } else {
        phoneCall->operate = OPERATE_WAITING;
    }
    phoneCall->lastStatus = call->state;
    phoneCall->creationTime = time(nullptr);

    int32_t ret = memcpy_s(phoneCall->tel, MAX_PHONE_NUM, call->number, call->number_len);
    if (ret != EOK) {
        static_print_error("[CallChangeIncomePro] copy tel ret:%d", ret);
    }
    phoneCall->telLen = call->number_len;

    (void)memcpy_s(&phoneCall->unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));

    // 发布电话呼入事件
    HfpIncomingEventPublish(TJDUI_TOPIC_EVENT_HFP_INCOMMING, phoneCall->unitCalls);
    // 通知手表电话呼入
    CallChangedCb(phoneCall);
}

// 通话状态变化--拒接/结束流程处理
static void CallChangeFinishPro(const hfp_hf_calls_info_t *call)
{
    ContactsInfo *phoneCall = nullptr;
    ContactsInfo tmp;

    static_print_debug("[CallChangeFinishPro] start scoFlag:%d, CallNum:%d", g_scoFlag, g_currCallNum);
    if (call == nullptr || g_currCallNum == 0) {
        return;
    }

    phoneCall = FindCallInfoInCallList((const unsigned char *)call->number, call->number_len);
    if (phoneCall == nullptr) {
        static_print_debug("[CallChangeFinishPro] Finish no this call");
        return;
    }
    if (g_finishOperate == OPERATE_WATCH_FINISH) {
        phoneCall->operate = OPERATE_WATCH_FINISH;
    } else if (g_finishOperate == OPERATE_WATCH_REJECT) {
        phoneCall->operate = OPERATE_WATCH_REJECT;
    } else {
        phoneCall->operate = OPERATE_NON_WATCH_FINISH;
    }
    g_finishOperate = OPERATE_NON_WATCH_FINISH;
    g_currCallNum--;

    phoneCall->lastStatus = HFP_HF_CALL_STATE_FINISHED;
    const ContactInfo *contactInfo = FindContactOfNumber((const unsigned char *)call->number, call->number_len);
    if (contactInfo != nullptr) {
        (void)memcpy_s(phoneCall->name, NAME_SIZE, contactInfo->name.c_str(), contactInfo->name.size());
    }

    (void)memcpy_s(&tmp, sizeof(ContactsInfo), phoneCall, sizeof(ContactsInfo));
    (void)memcpy_s(&tmp.unitCalls, sizeof(hfp_hf_calls_info_t), call, sizeof(hfp_hf_calls_info_t));
    (void)memset_s(phoneCall, sizeof(ContactsInfo), 0, sizeof(ContactsInfo));
    (void)memset_s(phoneCall->name, NAME_SIZE, '\0', NAME_SIZE);
    (void)memset_s(phoneCall->tel, MAX_PHONE_NUM, '\0', MAX_PHONE_NUM);

    // 添加通话记录
    AddToCallLogPro(&tmp);

    // 发布电话结束事件
    HfpIncomingEventPublish(TOPIC_EVENT_HFP_FINISHED, phoneCall->unitCalls);
    // 通知手表通话结束
    CallChangedCb(&tmp);
    static_print_debug("[CallChangeFinishPro] end  activeTime:%d, creation_time:%d", tmp.activeTime,
                       tmp.unitCalls.creation_time);

    static_print_debug("[CallChangeFinishPro] end  scoFlag:%d, CallNum:%d", g_scoFlag, g_currCallNum);
}

// 蓝牙状态连接
static void ConnStateChanged(const bd_addr_t *bdAddr, profile_connect_state_t state)
{
    int ret = 0;
    switch (state) {
    case PROFILE_STATE_CONNECTING: // 蓝牙正在连接
        static_print_debug("[ConnStateChanged] BT connecting");
        break;
    case PROFILE_STATE_CONNECTED: // 蓝牙连接成功
        static_print_debug("[ConnStateChanged] BT connected");
        g_btConnState = PROFILE_STATE_CONNECTED;
        CopyBdAddr(bdAddr);
        // SendMsgToUIService(BT_CONNECTED_TO_UI, 0, nullptr, 0);
        // SendMsgToMsgCenterService(BT_CONNECTED_TO_MSGCENTER, 0, nullptr, 0);
        break;
    case PROFILE_STATE_DISCONNECTING: // 蓝牙连接断连
        static_print_debug("[ConnStateChanged] BT disconnecting");
        break;
    case PROFILE_STATE_DISCONNECTED: // 蓝牙断开连接
        static_print_debug("[ConnStateChanged] BT disconnected");
        BtDisconnectedPro();
        // SendMsgToUIService(BT_DISCONNECTED_TO_UI, 0, nullptr, 0);
        // SendMsgToMsgCenterService(BT_DISCONNECTED_TO_MSGCENTER, 0, nullptr, 0);
        break;
    default:
        break;
    }
}

// 释放音频焦点
static void AudioDeactInterrupt(AudioStreamType type)
{
    static_print_debug("[AudioDeactInterrupt] start type:0x%x, audioState:0x%x", type, g_audioState);
    if ((type == AUDIO_STREAM_VOICE_CALL_BT_SCO && g_audioState >= AUDIO_ACT_INTERRUPT_BT_SCO) ||
        (type == AUDIO_STREAM_RING && g_audioState == AUDIO_ACT_INTERRUPT_WATCH_RING)) {
        TjdPhoneAudio::GetInstance().PhoneAudioManagerDeactInterrupt();
    }
}

// 申请音频焦点
static void AudioActInterrupt(AudioStreamType type)
{
    int ret = OHOS_SUCCESS;
    static_print_debug("[AudioActInterrupt] start type:0x%x, audioState:0x%x", type, g_audioState);
    if (type != AUDIO_STREAM_VOICE_CALL_BT_SCO && type != AUDIO_STREAM_RING) {
        static_print_error("[AudioActInterrupt] failed! type:0x%x, audioState:0x%x", type, g_audioState);
        return;
    }

    MUTEX_Lock(g_audioMutex);
    // 申请蓝牙通话焦点
    if (type == AUDIO_STREAM_VOICE_CALL_BT_SCO && g_audioState < AUDIO_ACT_INTERRUPT_BT_SCO) {
        if (g_audioState == AUDIO_ACT_INTERRUPT_WATCH_RING) {
            AudioDeactInterrupt(AUDIO_STREAM_RING);
        }

        ret = TjdPhoneAudio::GetInstance().PhoneAudioManagerActInterrupt(type);
        if (ret == OHOS_SUCCESS) {
            g_audioState = AUDIO_ACT_INTERRUPT_BT_SCO;
        }
    } else if (type == AUDIO_STREAM_RING && g_audioState < AUDIO_ACT_INTERRUPT_WATCH_RING) {
        ret = TjdPhoneAudio::GetInstance().PhoneAudioManagerActInterrupt(type);
        if (ret == OHOS_SUCCESS) {
            g_audioState = AUDIO_ACT_INTERRUPT_WATCH_RING;
        }
    }

    if (ret != OHOS_SUCCESS) {
        static_print_error("[AudioActInterrupt] failed! type:0x%x, audioState:0x%x", type, g_audioState);
    }

    MUTEX_Unlock(g_audioMutex);
}

// 媒体连接SCO设备
static void AudioConnectScoDevInit(void)
{
    int ret;
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();
    static_print_debug("[AudioConnectScoDevInit] start scoFlag:0x%x, audioState:0x%x", g_scoFlag, g_audioState);
    if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_ACT_INTERRUPT_BT_SCO) {
        return;
    }

    MUTEX_Lock(g_audioMutex);
    if (g_audioState < AUDIO_STREAM_INIT) {
        if (g_audioState < AUDIO_CONN_IN_BT_SCO) {
            // 配置媒体连接SCO设配状态（下行），只有在SCO连接后才能设置
            ret = audio.PhoneAudioManagerSetDeviceConnState(IN_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED);
            if (ret != OHOS_SUCCESS) {
                static_print_error("[AudioConnectScoDevInit] sco in ret:%d", ret);
                MUTEX_Unlock(g_audioMutex);
                return;
            } else {
                g_audioState = AUDIO_CONN_IN_BT_SCO;
            }
        }
        if (g_audioState < AUDIO_CONN_OUT_BT_SCO) {
            // 配置媒体连接SCO设配状态（上行），只有在SCO连接后才能设置
            ret = audio.PhoneAudioManagerSetDeviceConnState(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_CONNECTED);
            if (ret != OHOS_SUCCESS) {
                static_print_error("[AudioConnectScoDevInit] sco out ret:%d", ret);
                MUTEX_Unlock(g_audioMutex);
                return;
            } else {
                g_audioState = AUDIO_CONN_OUT_BT_SCO;
            }
        }
        if (g_hdlUpSco == INVALID_PHONE_SERVICE_VALUE) {
            g_hdlUpSco = audio.PhoneAudioStreamOutInit(AUDIO_UP_LINK);
        }
        if (g_hdlDnSco == INVALID_PHONE_SERVICE_VALUE) {
            g_hdlDnSco = audio.PhoneAudioStreamInInit(AUDIO_DOWN_LINK);
        }
        if (g_hdlUpSco != INVALID_PHONE_SERVICE_VALUE && g_hdlDnSco != INVALID_PHONE_SERVICE_VALUE) {
            g_audioState = AUDIO_STREAM_INIT;
        }
    }
    static_print_debug("[AudioConnectScoDevInit] end audioState:%d, hdlUpSco:%d, hdlDnSco:%d", g_audioState, g_hdlUpSco,
                       g_hdlDnSco);
    MUTEX_Unlock(g_audioMutex);
}

// 建立上行通路
static void AudioUpStart(void)
{
    int ret = OHOS_SUCCESS;
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();
    uint32 micShmId = 0;
    static_print_debug("[AudioUpStart] start scoFlag:%d, audioState:%d", g_scoFlag, g_audioState);
    if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_STREAM_INIT) {
        return;
    }
    MUTEX_Lock(g_audioMutex);
    if (g_audioState < AUDIO_STREAM_START_UP) {
        if (g_hdlUpMic == INVALID_PHONE_SERVICE_VALUE) {
            g_hdlUpMic = audio.PhoneAudioStreamInInit(AUDIO_UP_LINK);
        }
        if (g_audioState < AUDIO_STREAM_START_SCO) {
            ret = audio.PhoneAudioStreamInStart(g_hdlDnSco);
            if (ret != OHOS_SUCCESS) {
                static_print_error("[AudioUpStart] dn_sco ret:%d", ret);
            }
            ret |= audio.PhoneAudioStreamOutStart(g_hdlUpSco);
            if (ret != OHOS_SUCCESS) {
                static_print_error("[AudioUpStart] up_sco ret:%d", ret);
            }
            if (ret == OHOS_SUCCESS) {
                g_audioState = AUDIO_STREAM_START_SCO;
            }
        }

        ret |= audio.PhoneAudioStreamInStart(g_hdlUpMic);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpStart] up_mic ret:%d", ret);
        }

        ret |= audio.PhoneAudioStreamInGetChannelId(g_hdlUpMic, &micShmId);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpStart] up_mic shm ret:%d", ret);
        }

        ret |= audio.PhoneAudioStreamOutAttachFrontend(g_hdlUpSco, micShmId);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpStart] up_sco attach ret:%d", ret);
        }

        if (ret == OHOS_SUCCESS) {
            g_audioState = AUDIO_STREAM_START_UP;
        }
    }
    static_print_debug("[AudioUpStart] end audioState:%d, hdlUpMic:%d, hdlUpSco:%d, micShmId:0x%x", g_audioState,
                       g_hdlUpMic, g_hdlUpSco, micShmId);
    MUTEX_Unlock(g_audioMutex);
}

// 建立下行通路
static void AudioDnStart(void)
{
    int ret = OHOS_SUCCESS;
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();
    uint32 spkShmId = 0;
    static_print_debug("[AudioDnStart] start scoFlag:%d, audioState:%d", g_scoFlag, g_audioState);

    if (g_scoFlag != HFP_SCO_STATE_CONNECTED || g_audioState < AUDIO_STREAM_INIT) {
        return;
    }
    MUTEX_Lock(g_audioMutex);
    if (g_audioState < AUDIO_STREAM_START_DN) {
        if (g_hdlDnSpk == INVALID_PHONE_SERVICE_VALUE) {
            g_hdlDnSpk = audio.PhoneAudioStreamOutInit(AUDIO_DOWN_LINK);
        }
        if (g_audioState < AUDIO_STREAM_START_SCO) {
            ret = audio.PhoneAudioStreamOutStart(g_hdlUpSco);
            if (ret != OHOS_SUCCESS) {
                static_print_error("[AudioDnStart] up_sco ret:%d", ret);
            }
            ret |= audio.PhoneAudioStreamInStart(g_hdlDnSco);
            if (ret != OHOS_SUCCESS) {
                static_print_error("[AudioDnStart] dn_sco ret:%d", ret);
            }
            if (ret == OHOS_SUCCESS) {
                g_audioState = AUDIO_STREAM_START_SCO;
            }
        }

        ret |= audio.PhoneAudioStreamOutStart(g_hdlDnSpk);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnStart] dn_spk ret:%d", ret);
        }
        ret |= audio.PhoneAudioStreamOutGetChannelId(g_hdlDnSpk, &spkShmId);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnStart] dn_spk shm ret:%d", ret);
        }
        ret |= audio.PhoneAudioStreamInAttachBackend(g_hdlDnSco, spkShmId);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnStart] dn_sco attach ret:%d", ret);
        }
        if (ret == OHOS_SUCCESS) {
            g_audioState = AUDIO_STREAM_START_DN;
        }
    }
    static_print_debug("[AudioDnStart] end audioState:%d, hdlDnSpk:%d, hdlDnSco:%d, spkShmId:0x%x", g_audioState,
                       g_hdlDnSpk, g_hdlDnSco, spkShmId);
    MUTEX_Unlock(g_audioMutex);
}

// 同步音量
static void SyncVolume(void)
{
    unsigned char volume;
    volume = GetHFPCallCurrVolume();
    SetHFPSpeakerVolume(volume);
}

// 蓝牙通话上行
static void AudioUp(void)
{
    // 申请蓝牙通话音频焦点
    AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_BT_SCO);
    // 媒体连接SCO设备
    AudioConnectScoDevInit();
    // 建立音频上行通路
    AudioUpStart();
    static_print_debug("[AudioUp] audioState:%d", g_audioState);
}

// 蓝牙通话下行
static void AudioDn(void)
{
    AudioActInterrupt(AUDIO_STREAM_VOICE_CALL_BT_SCO);

    // 媒体连接SCO设备
    AudioConnectScoDevInit();

    // 建立音频下行通路
    AudioDnStart();
    if (g_audioState == AUDIO_STREAM_START_DN) {
        // 同步音量
        SyncVolume();
    }
    static_print_debug("[AudioDn] audioState:%d", g_audioState);
}

static void AudioSetup(void)
{
    if (g_audioState < AUDIO_STREAM_START_DN) {
        AudioDn();
    }

    if (g_audioState != AUDIO_STREAM_START_UP) {
        AudioUp();
    }
}

static void PlayWatchRing(void) { static_print_debug("[PlayWatchRing] start"); }

static void AudioUpRelease(void)
{
    int ret;
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();
    if (g_hdlUpSco != INVALID_PHONE_SERVICE_VALUE) {
        ret = audio.PhoneAudioStreamOutStop(g_hdlUpSco);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpRelease] [OutStop] hdlUpSco ret:%d", ret);
        }
        ret = audio.PhoneAudioStreamOutDeinit(g_hdlUpSco);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpRelease] [OutDeinit] hdlUpSco ret:%d", ret);
        }
    }

    if (g_hdlUpMic != INVALID_PHONE_SERVICE_VALUE) {
        ret = audio.PhoneAudioStreamInStop(g_hdlUpMic);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnRelease] [InStop] hdlUpMic ret:%d", ret);
        }
        ret = audio.PhoneAudioStreamInDeinit(g_hdlUpMic);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnRelease] [InDeinit] hdlUpMic ret:%d", ret);
        }
    }

    if (g_audioState >= AUDIO_CONN_OUT_BT_SCO) {
        ret = audio.PhoneAudioManagerSetDeviceConnState(OUT_BLUETOOTH_SCO, AUDIO_DEVICE_DISCONNECTED);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnRelease] sco out ret:%d", ret);
        }
    }

    g_hdlUpSco = INVALID_PHONE_SERVICE_VALUE;
    g_hdlUpMic = INVALID_PHONE_SERVICE_VALUE;
}

static void AudioDnRelease(void)
{
    int ret;
    TjdPhoneAudio &audio = TjdPhoneAudio::GetInstance();

    if (g_hdlDnSco != INVALID_PHONE_SERVICE_VALUE) {
        ret = audio.PhoneAudioStreamInStop(g_hdlDnSco);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpRelease] [InStop] hdlDnSco ret:%d", ret);
        }
        ret = audio.PhoneAudioStreamInDeinit(g_hdlDnSco);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioUpRelease] [InDeinit] hdlDnSco ret:%d", ret);
        }
    }

    if (g_hdlDnSpk != INVALID_PHONE_SERVICE_VALUE) {
        ret = audio.PhoneAudioStreamOutStop(g_hdlDnSpk);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnRelease] [OutStop] hdlDnSpk ret:%d", ret);
        }
        ret = audio.PhoneAudioStreamOutDeinit(g_hdlDnSpk);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnRelease] [OutDeinit] hdlDnSpk ret:%d", ret);
        }
    }

    if (g_audioState >= AUDIO_CONN_IN_BT_SCO) {
        ret = audio.PhoneAudioManagerSetDeviceConnState(IN_BLUETOOTH_SCO, AUDIO_DEVICE_DISCONNECTED);
        if (ret != OHOS_SUCCESS) {
            static_print_error("[AudioDnRelease] sco in ret:%d", ret);
        }
    }

    g_hdlDnSco = INVALID_PHONE_SERVICE_VALUE;
    g_hdlDnSpk = INVALID_PHONE_SERVICE_VALUE;
}

/* 销毁上下行通路 释放音频焦点 */
void AudioRelease(void)
{
    if (g_audioState == AUDIO_UNKNOW) {
        return;
    }

    MUTEX_Lock(g_audioMutex);
    AudioUpRelease();
    AudioDnRelease();

    /* 释放音频焦点 */
    AudioDeactInterrupt(AUDIO_STREAM_VOICE_CALL_BT_SCO);
    AudioDeactInterrupt(AUDIO_STREAM_RING); // 适配某些机型不触发SCO
    g_audioState = AUDIO_UNKNOW;

    static_print_debug("[AudioRelease] audioState:%d,", g_audioState);
    MUTEX_Unlock(g_audioMutex);
}

// SCO连接处理
static void ScoConnectPro(void)
{
    // 通知sco建立连接(或通话转移：手机 -> 手表)
    ScoStatusCb(HFP_SCO_STATE_CONNECTED);
    if (g_currCallState == HFP_HF_CALL_STATE_ACTIVE && g_scoFlag == HFP_SCO_STATE_CONNECTED) {
        // The call is transferred from the phone to the watch. Need to show the call notification view.
        hfp_hf_calls_info_t call = {};
        HfpIncomingEventPublish(TOPIC_EVENT_HFP_PHONE_TO_WATCH, call);
    }
    PostGraphicEvent(AudioSetup);
}

// SCO断连处理
static void ScoDisconnectPro(void)
{
    static_print_debug("[ScoDisconnectPro] start CallState:%d", g_currCallState);
    ScoStatusCb(HFP_SCO_STATE_DISCONNECTED);
    if (g_currCallState == HFP_HF_CALL_STATE_ACTIVE && g_scoFlag == HFP_SCO_STATE_DISCONNECTED) {
        // The call is transferred from the watch to the phone. Need to close the call notification view.
        hfp_hf_calls_info_t call = {};
        HfpIncomingEventPublish(TOPIC_EVENT_HFP_WATCH_TO_PHONE, call);
    }
    AudioRelease(); // 为了保持时序，此处采取同步调用
    usleep(5000);   // 增加延时确保SCO断开AUDIO通路释放成功
}

// Sco连接状态变化回调函数，音频连接状态
static void ScoStateChanged(const bd_addr_t *bdAddr, hfp_sco_connect_state_t state)
{
    g_scoFlag = state;
    static_print_debug("[ScoStateChanged] hfpState:%d, ScoFlag:%d, CallNum:%d", state, g_scoFlag, g_currCallNum);

    switch (state) {
    case HFP_SCO_STATE_CONNECTING:
        PhoneServiceScreenCtr(1);
        if (g_scoFlag != HFP_SCO_STATE_CONNECTED) {
            g_scoFlag = HFP_SCO_STATE_CONNECTED;
            CopyBdAddr(bdAddr);
            ScoConnectPro();
            static_print_debug("[ScoStateChanged] SCO connecting!");
        }
        break;
    case HFP_SCO_STATE_CONNECTED:
        static_print_debug("[ScoStateChanged] SCO connected!");
        break;

    case HFP_SCO_STATE_DISCONNECTING:
        static_print_debug("[ScoStateChanged] SCO disconnecting!");
        break;

    case HFP_SCO_STATE_DISCONNECTED:
        static_print_debug("[ScoStateChanged] SCO disconnected!");
        ScoDisconnectPro();
        PhoneServiceScreenCtr(0);
        break;

    default:
        break;
    }
}

static void HfpBatteryChanged(const bd_addr_t *bdAddr, int batteryLevel)
{
    UNUSED(bdAddr);
    UNUSED(batteryLevel);
    static_print_debug("[HfpBatteryChanged] batteryLevel:%d", batteryLevel);
}

static void HfpSignalStrengthChanged(const bd_addr_t *bdAddr, int signalStrength)
{
    UNUSED(bdAddr);
    UNUSED(signalStrength);
    static_print_debug("[HfpSignalStrengthChanged] signalStrength:%d", signalStrength);
}

static void HfpRegistStatusChanged(const bd_addr_t *bdAddr, int status)
{
    UNUSED(bdAddr);
    UNUSED(status);
    static_print_debug("[HfpRegistStatusChanged] status:%d", status);
}

static void HfpRoamingStatusChanged(const bd_addr_t *bdAddr, int status)
{
    UNUSED(bdAddr);
    UNUSED(status);
    static_print_debug("[HfpRoamingStatusChanged] status:%d", status);
}

static void HfpOperatorSelection(const bd_addr_t *bdAddr, unsigned char *name, unsigned int len)
{
    UNUSED(bdAddr);
    UNUSED(name);
    UNUSED(len);
    static_print_debug("[HfpOperatorSelection] name: %s, len:%d", name, len);
}

static void HfpSubscriberNumber(const bd_addr_t *bdAddr, unsigned char *number, unsigned int len)
{
    UNUSED(bdAddr);
    UNUSED(number);
    UNUSED(len);
    static_print_debug("[HfpSubscriberNumber] number: %s, len:%d", number, len);
}

static void VoiceRecogStatusChanged(const bd_addr_t *bdAddr, int status)
{
    UNUSED(bdAddr);
    UNUSED(status);
    static_print_debug("[VoiceRecogStatusChanged] status:%d", status);
}

static void InbandRingtoneChanged(const bd_addr_t *bdAddr, int status)
{
    UNUSED(bdAddr);
    UNUSED(status);
    static_print_debug("[InbandRingtoneChanged] status:%d", status);
}

static void BtHfpVolumeChanged(int volumeType, unsigned char hfpVolume)
{
    // mic
    if (volumeType == HFP_VOLUME_MIC) {
        static_print_debug("VolumeChanged Type:%d, hfpVolume:%d", volumeType, hfpVolume);
    }

    // speak
    if (volumeType == HFP_VOLUME_SPEAKER) {
        int32_t minVolume = TjdPhoneAudio::GetInstance().PhoneAudioGetMinVolume();
        int32_t maxVolume = TjdPhoneAudio::GetInstance().PhoneAudioGetMaxVolume();
        int32_t volume = hfpVolume * (maxVolume - minVolume) / CALL_VOLUME_MAX; // 转换
        volume = (volume == 0) ? ((maxVolume - minVolume) / CALL_VOLUME_MAX) : volume;
        bool ret = TjdPhoneAudio::GetInstance().PhoneAudioSetVolume(volume);
        if (!ret) {
            static_print_error("VolumeChanged Type:%d, ret:%d", volumeType, ret);
        }
        static_print_debug("VolumeChanged Type:%d, min:%d, max:%d volume:%d ret:%d", volumeType, minVolume, maxVolume,
                           volume, ret);
    }
}

// 音量调节回调
static void VolumeChanged(const bd_addr_t *bdAddr, hfp_volume_type_t type, unsigned char volume)
{
    UNUSED(bdAddr);
    static_print_debug("[VolumeChanged] type:%d volume:%d", type, volume);
    GraphicService::GetInstance()->PostGraphicEvent(std::bind(BtHfpVolumeChanged, type, volume));
}

// 设置完整通话标志
static void SetCompleteCallFlag(const hfp_hf_calls_info_t *call)
{
    if (call->state == HFP_HF_CALL_STATE_INCOMING) { // 呼入
        g_completeCallFlag = true;
    } else if ((call->state == HFP_HF_CALL_STATE_DIALING || call->state == HFP_HF_CALL_STATE_ALERTING) &&
               (g_currCallNum == 1 || g_currCallNum == 0)) // 正在拨号或对方响铃
    {
        g_completeCallFlag = true;
    } else if (call->state == HFP_HF_CALL_STATE_ACTIVE) { // 正在通话
        g_completeCallFlag = true;
    }
}

static void CallAudioHandle(const hfp_hf_calls_info_t *call)
{
    int state = call->state;
    if (state == HFP_HF_CALL_STATE_INCOMING || state == HFP_HF_CALL_STATE_DIALING ||
        state == HFP_HF_CALL_STATE_ALERTING) { // 电话呼入，支持播放手机铃声
        if (call->in_band_ring) {
            // 播放手机端铃声
            PostGraphicEvent(AudioDn);
        } else {
            if (g_scoFlag != HFP_SCO_STATE_CONNECTED) {
                // 播放手表铃声
                PostGraphicEvent(PlayWatchRing);
            }
        }
    } else if (state == HFP_HF_CALL_STATE_FINISHED) {
        return;
    } else if (g_scoFlag == HFP_SCO_STATE_CONNECTED) {
        PostGraphicEvent(AudioSetup);
    }
}

static void CallShakeHandle(const hfp_hf_calls_info_t *call)
{
    int state = call->state;
    static_print_debug("[CallShakeHandle] state:%d", state);
    if (state == HFP_HF_CALL_STATE_INCOMING) { // 电话呼入，支持播放手机铃声
        TJD::TjdUiSettingCenter::GetInstance().PhoneShakeEvent();
    } else if (state == HFP_HF_CALL_STATE_FINISHED || state == HFP_HF_CALL_STATE_ACTIVE) {
        TJD::TjdUiSettingCenter::GetInstance().ShakeEndEvent();
    }
}

// 通话状态变化上报回调
static void CallStateChanged(const bd_addr_t *bdAddr, const hfp_hf_calls_info_t *call)
{
    CopyBdAddr(bdAddr);
    if (call == nullptr || g_btConnState != PROFILE_STATE_CONNECTED) {
        static_print_error("call is null or BT disconnected connStatus: 0x%X", g_btConnState);
        return;
    }

    SetCompleteCallFlag(call);
    CallAudioHandle(call);
    CallShakeHandle(call);

    static_print_debug("CallStateChanged state:%d", call->state);
    switch (call->state) {
    case HFP_HF_CALL_STATE_ACTIVE: // 0正在通话
        CallChangeActivePro(call);
        break;
    case HFP_HF_CALL_STATE_HELD: // 挂起
        CallChangeHeldPro(call);
        break;
    case HFP_HF_CALL_STATE_DIALING: // 2呼出，正在拨号
        PhoneServiceScreenCtr(1);
        CallChangeDialPro(call);
        break;
    case HFP_HF_CALL_STATE_ALERTING: // 3呼出，对方响铃
        PhoneServiceScreenCtr(1);
        CallChangeAlertPro(call);
        break;
    case HFP_HF_CALL_STATE_INCOMING: // 呼入
        PhoneServiceScreenCtr(1);
        CallChangeIncomePro(call);
        break;
    case HFP_HF_CALL_STATE_WAITING: // 呼入等待
        PhoneServiceScreenCtr(1);
        CallChangeIncomePro(call);
        break;
    case HFP_HF_CALL_STATE_FINISHED: // 7拒接/结束电话
        CallChangeFinishPro(call);
        PhoneServiceScreenCtr(0);
        break;
    default:
        break;
    }

    // 规避某些型号手机在电话呼入时重复断开和连接SCO
    if (call->state == HFP_HF_CALL_STATE_FINISHED) {
        if (g_currCallNum == 0) {
            g_currCallState = HFP_HF_CALL_STATE_FINISHED;
        }
    } else {
        g_currCallState = call->state;
    }

    if (g_currCallNum == 0) {
        g_completeCallFlag = false;
    }
}

// 拨号失败回调
static void DialErrorCode(const bd_addr_t *bdAddr, int code)
{
    UNUSED(bdAddr);
    static_print_debug("[DialErrorCode] code:%d", code);
    PhoneServiceErrorCallback(ERROR_DIAL, code);
}

static void CodecChanged(const bd_addr_t *bdAddr, int codec)
{
    UNUSED(bdAddr);
    if (codec == HFP_HF_CODEC_ID_CVSD) {
        g_call_codec = PCM;
    } else if (codec == HFP_HF_CODEC_ID_MSBC) {
        g_call_codec = mSBC;
    }
    static_print_debug("[CodecChanged] codec:%d, call_codec:%d", codec, g_call_codec);
}

static void RegisterHfpHfCallbacks(void)
{
    static_print_debug("[RegisterHfpHfCallbacks]");
    int ret;
    hfp_hf_callbacks_t callbacks = {
        ConnStateChanged,        ScoStateChanged,
        HfpBatteryChanged,       HfpSignalStrengthChanged,
        HfpRegistStatusChanged,  HfpRoamingStatusChanged,
        HfpOperatorSelection,    HfpSubscriberNumber,
        VoiceRecogStatusChanged, InbandRingtoneChanged,
        VolumeChanged,           CallStateChanged,
        DialErrorCode,           CodecChanged,
    };

    ret = hfp_hf_register_callbacks(&callbacks);
    if (ret != 0) {
        static_print_error("[RegisterHfpHfCallbacks] ret:%d", ret);
    }
}

static void ContactsSyncEvent() { ContactsGetCase(); }

void TjdPhoneServiceInit(void)
{
    static_print_debug("[PhoneServiceInit] start");
    g_scoFlag = HFP_SCO_STATE_DISCONNECTED;
    int32_t ret = TjdPhoneAudio::GetInstance().AudioInit();
    if (ret != OHOS_SUCCESS) {
        static_print_error("[AudioInit] failed!");
    }
    g_audioMutex = MUTEX_InitValue();

    DIR *dir = nullptr;
    dir = opendir(TJD_CALL_LOG_DIR);
    if (dir == nullptr) {
        mkdir(TJD_CALL_LOG_DIR, S_IREAD | S_IWRITE);
    } else {
        closedir(dir);
    }

    if (GetCallLogFileSize() == OHOS_FAILURE) { // 如果不存在文件，创建新文件
        (void)ClearCallLogInfoFile();
    }
    (void)memset_s(g_bdAddr.addr, BD_ADDR_LEN, 0, BD_ADDR_LEN);
    CallListInit();
    ContactsGetCase();
    tjd_service_bt_register_contacts_event(ContactsSyncEvent);
    RegisterHfpHfCallbacks();
    static_print_debug("[PhoneServiceInit] end");
}

uint32_t GetCallAudioCodec(void) { return g_call_codec; }