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

#include "TjdUiAppPlayerModel.h"
#include "TjdUiAppPlayerView.h"
#include "audio_manager.h"
#include "bt_audio.h"
#include "bts_avrcp_controller.h"
#include "bts_avrcp_target.h"
#include "bts_br_gap.h"
#include "bts_def.h"
#include "graphic_service.h"
#include "sys_config.h"
#include "td_type.h"

using namespace OHOS;
using namespace ::Audio;

namespace TJD {

#define ENABLE_PRINT_INFO 1
#define ENABLE_DEBUG 1
#if ENABLE_PRINT_INFO
#define static_print_info(...) sys_ui_log_i(__VA_ARGS__)  // 一般信息打印宏控制
#define static_print_warn(...) sys_ui_log_w(__VA_ARGS__)  // 警告信息打印一般常开
#define static_print_error(...) sys_ui_log_e(__VA_ARGS__) // 错误信息打印一般常开
#if ENABLE_DEBUG
#define static_print_debug(...) sys_ui_log_d(__VA_ARGS__) // 调试信息打印一般常开
#else
#define static_print_debug(...)
#endif
#else
#define static_print_info(...)
#define static_print_warn(...)
#define static_print_error(...)
#endif

static void UsingPressButtonStatusCallback(td_u32 keyOperation, td_u32 keyValue);
static void MediaStatusCallback(bt_avrcp_tg_evt_status_param *eventStatusParam);
static void PressButtonStatusCallback(td_u32 keyOperation, td_u32 keyValue);
static void ConnCtStateChangedCallback(const bd_addr_t *bdAddr, profile_connect_state_t state);
static void ConnectTgStateChangedCallback(const bd_addr_t *bdAddr, profile_connect_state_t state);

enum AVRCP_SRV_STATE
{
    AVRCP_SRV_PRESS_VALUE,
    AVRCP_SRV_RELEASED_VALUE,
    AVRCP_SRV_INIT_VALUE
};

#define AVRCP_CT_AUTO_REG_TYPE 1
static uint8_t g_avrcp_tg_local_media_vol = AVRCP_ABSOLUTE_VOLUME_INVALID;
#define BT_A2DP_MEDIA_VOL_LEVEL 100

static bt_avrcp_tg_bts_cbk g_avrcp_tg_audio_cb = {};
static avrcp_ct_callbacks_t g_avrcp_ct_cb = {};
static avrcp_tg_callbacks_t g_avrcp_tg_cb = {};
static BtAvrcpTgInf g_avrcp_srv_inf;

BtAvrcpTgInf *GetAvrcpTgInf(void)
{
    return &g_avrcp_srv_inf;
}

void BtAvrcpVolumeChangedSyncMedia(uint8_t a2dp_volume)
{
    static_print_info("[BtAvrcpVolumeChangedSyncMedia]::a2dp_volume = 0x%x", a2dp_volume);
    int32_t audio_volume = a2dp_volume * BT_A2DP_MEDIA_VOL_LEVEL / AVRCP_ABSOLUTE_VOLUME_PERCENTAGE_100;
    AudioManager::GetInstance().SetVolume(AUDIO_STREAM_A2DP_MUSIC, audio_volume); /* 设置增益音量 */
    g_avrcp_tg_local_media_vol = a2dp_volume;
    avrcp_tg_notify_volume_changed(a2dp_volume);
    TjdUiAppPlayerView *view = TjdUiAppPlayerView::GetInstance();
    if (view != nullptr) {
        if (view->GetCurrentView() == PlayerViewIndex::VOLUME_VIEW) {
            view->ChangedVolume(audio_volume);
        }
    }
}

/* tg通知媒体状态 */
static void BtAvrcpTgNotifyMeidaStatus(bt_avrcp_tg_evt_status_param *notifyEventStatusParam)
{
    if (notifyEventStatusParam == nullptr || notifyEventStatusParam->event_id >= AVRCP_NOTIFY_EVENT_RESERVED) {
        static_print_error("[BtAvrcpTgNotifyMeidaStatus] param is error");
        return;
    }
    switch (notifyEventStatusParam->event_id) {
    case AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED:
        avrcp_tg_notify_playback_status_changed(*(td_u8 *)notifyEventStatusParam->event_status);
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_CHANGED:
        avrcp_tg_notify_track_changed(*(unsigned long long *)notifyEventStatusParam->event_status);
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_END:
        avrcp_tg_notify_track_reached_end();
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_START:
        avrcp_tg_notify_track_reached_start();
        break;
    case AVRCP_NOTIFY_EVENT_PLAYBACK_POS_CHANGED:
        avrcp_tg_notify_playback_pos_changed(*(td_u32 *)notifyEventStatusParam->event_status);
        break;
    case AVRCP_NOTIFY_EVENT_BATT_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_SYSTEM_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_NOW_PLAYING_CONTENT_CHANGED:
        avrcp_tg_notify_now_playing_content_changed();
        break;
    case AVRCP_NOTIFY_EVENT_AVAILABLE_PLAYERS_CHANGED:
        avrcp_tg_notify_available_players_changed();
        break;
    case AVRCP_NOTIFY_EVENT_ADDRESSED_PLAYER_CHANGED:
        avrcp_tg_notify_addressed_players_changed(*(td_u16 *)notifyEventStatusParam->event_status,
                                                  *(td_u16 *)(notifyEventStatusParam->event_status + sizeof(td_u16)));
        break;
    case AVRCP_NOTIFY_EVENT_UIDS_CHANGED:
        avrcp_tg_notify_uid_changed(*(td_u16 *)notifyEventStatusParam->event_status);
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        BtAvrcpVolumeChangedSyncMedia(notifyEventStatusParam->event_status[0]);
        break;
    case AVRCP_NOTIFY_EVENT_RESERVED:
        break;
    default:
        break;
    }
}

void PressButtonStatusCallback(td_u32 keyOperation, td_u32 keyValue)
{
    static_print_debug("[PressButtonStatusCallback]::keyValue = 0x%x  keyOperation = 0x%x", keyValue, keyOperation);
    GraphicService::GetInstance()->PostGraphicEvent(std::bind(UsingPressButtonStatusCallback, keyOperation, keyValue));
}

void BtAvrcpTgNotifyVolumeChangedProc(uint8_t a2dp_volume)
{
    int32_t audio_volume = a2dp_volume * BT_A2DP_MEDIA_VOL_LEVEL / AVRCP_ABSOLUTE_VOLUME_PERCENTAGE_100;
    static_print_info("NotifyVolume = %d", audio_volume);
    AudioManager::GetInstance().SetVolume(AUDIO_STREAM_MUSIC, audio_volume); // 耳机连接手表场景调节手表音量
}

void UsingPressButtonStatusCallback(td_u32 keyOperation, td_u32 keyValue)
{
    bt_avrcp_tg_evt_status_param event;
    switch (keyOperation) {
    case AVRCP_KEY_VOLUME_UP:   // 耳机控制手表加减音量不走key_operation事件
    case AVRCP_KEY_VOLUME_DOWN: // 减小音量
        break;
    case AVRCP_KEY_MUTE: // 静音
        event.event_status[0] = AVRCP_ABSOLUTE_VOLUME_PERCENTAGE_0;
        event.event_id = AVRCP_NOTIFY_EVENT_VOLUME_CHANGED;
        break;
    case AVRCP_KEY_PLAY: // 播放
        // (void)TjdUiAppPlayerModel::GetInstance()->PlayerPlay();
        event.event_status[0] = AVRCP_PLAY_STATUS_PLAYING;
        event.event_id = AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED;
        break;
    case AVRCP_KEY_STOP: // 停止
        // (void)TjdUiAppPlayerModel::GetInstance()->PlayerStop();
        event.event_status[0] = AVRCP_PLAY_STATUS_STOPPED;
        event.event_id = AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED;
        break;
    case AVRCP_KEY_PAUSE: // 暂停
        // (void)TjdUiAppPlayerModel::GetInstance()->PlayerPause();
        event.event_status[0] = AVRCP_PLAY_STATUS_PAUSED;
        event.event_id = AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED;
        break;
    case AVRCP_KEY_FORWARD: // 下一曲
        // TjdUiAppPlayerModel::GetInstance()->LoopingPlayout();
        event.event_status[0] = AVRCP_PLAY_STATUS_FWD_SEEK;
        event.event_id = AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED;
        break;
    case AVRCP_KEY_BACKWARD: // 上一曲
        // TjdUiAppPlayerModel::GetInstance()->PreviousPlayout();
        event.event_status[0] = AVRCP_PLAY_STATUS_REV_SEEK;
        event.event_id = AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED;
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        /* 手机连接手表场景，控制手表喇叭声音 */
        event.event_status[0] = keyValue;
        event.event_id = AVRCP_NOTIFY_EVENT_VOLUME_CHANGED;
        BtAvrcpTgNotifyVolumeChangedProc((uint8_t)keyValue);
    default:
        break;
    }

    BtAvrcpTgNotifyMeidaStatus(&event);
}

uint8_t BtAvrcpTgGetLocMediaVolume(void)
{
    if (g_avrcp_tg_local_media_vol == AVRCP_ABSOLUTE_VOLUME_INVALID) {
        int32_t audio_volume = AudioManager::GetInstance().GetVolume(AUDIO_STREAM_A2DP_MUSIC);
        uint8_t a2dp_volume = (uint8_t)(audio_volume * AVRCP_ABSOLUTE_VOLUME_PERCENTAGE_100 / BT_A2DP_MEDIA_VOL_LEVEL);
        static_print_info("audio_volume 0x%x, a2dp_volume 0x%x", audio_volume, a2dp_volume);
        g_avrcp_tg_local_media_vol = a2dp_volume;
    }

    static_print_info("get local media volume, a2dp_volume = 0x%x", g_avrcp_tg_local_media_vol);
    return g_avrcp_tg_local_media_vol;
}

void MediaStatusCallback(bt_avrcp_tg_evt_status_param *eventStatusParam)
{
    if (eventStatusParam == nullptr) {
        static_print_error("eventStatusParam is nullptr");
        return;
    }

    int32_t playerStatus = TjdUiAppPlayerModel::GetInstance()->GetPlayerStatus();
    static_print_debug("playerStatus = %d", playerStatus);

    switch (eventStatusParam->event_id) {
    case AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED:
        eventStatusParam->event_status[0] = playerStatus;
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_CHANGED:
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_END:
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_START:
        break;
    case AVRCP_NOTIFY_EVENT_PLAYBACK_POS_CHANGED:
        eventStatusParam->event_status[0] = 0xFF;
        break;
    case AVRCP_NOTIFY_EVENT_BATT_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_SYSTEM_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_NOW_PLAYING_CONTENT_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_AVAILABLE_PLAYERS_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_ADDRESSED_PLAYER_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_UIDS_CHANGED:
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        eventStatusParam->event_status[0] = BtAvrcpTgGetLocMediaVolume();
        break;
    case AVRCP_NOTIFY_EVENT_RESERVED:
        break;
    default:
        break;
    }
}

void ConnCtStateChangedCallback(const bd_addr_t *bdAddr, profile_connect_state_t state)
{
    static_print_debug("avrcp ct update conn stat:%u", state);
    if (bdAddr == nullptr) {
        static_print_error("bdaddr nullptr");
        return;
    }
    static_print_debug("ConnCtStateChangedCallback addr: %02x%02x%02x%02x%02x%02x ", bdAddr->addr[5], bdAddr->addr[4],
                       bdAddr->addr[3],                                    /* 5 4 3 idx */
                       bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* 2 1 0 idx */
    (void)memcpy_s(g_avrcp_srv_inf.bd_addr.addr, BD_ADDR_LEN, bdAddr->addr, BD_ADDR_LEN);
    g_avrcp_srv_inf.avrcp_srv_conn_stat = state;
}

static bd_addr_t *BtAvrcpSrvGetActiveAddr(void) { return &g_avrcp_srv_inf.bd_addr; }

void ConnectTgStateChangedCallback(const bd_addr_t *bdAddr, profile_connect_state_t state)
{
    static_print_info("avrcp tg update conn stat:%u", state);
    if (bdAddr == nullptr) {
        static_print_error("bdaddr nullptr");
        return;
    }

    static_print_debug("ConnCtStateChangedCallback addr: %02x%02x%02x%02x%02x%02x ", bdAddr->addr[5], bdAddr->addr[4],
                       bdAddr->addr[3],                                    /* 5 4 3 idx */
                       bdAddr->addr[2], bdAddr->addr[1], bdAddr->addr[0]); /* 2 1 0 idx */
    (void)memcpy_s(g_avrcp_srv_inf.bd_addr.addr, BD_ADDR_LEN, bdAddr->addr, BD_ADDR_LEN);
    g_avrcp_srv_inf.avrcp_srv_conn_stat = state;

    /* 手表耳机链接场景时，耳机控制音量是一个事件而非key_operation，故需要在手表侧向耳机注册音量变更事件 */
    if (state == PROFILE_STATE_CONNECTED) {
        (void)avrcp_ct_get_supported_events(BtAvrcpSrvGetActiveAddr());
    }
}

static void BtAvrcpCtPressButtonRspCallback(const bd_addr_t *bd_addr, int32_t key_operation)
{
    if (bd_addr == nullptr) {
        static_print_error("null pointer");
        return;
    }
    if (g_avrcp_srv_inf.avrcp_button_flag == AVRCP_SRV_RELEASED_VALUE) {
        static_print_debug("avrcp ct press button button_flag change:%u->%u", g_avrcp_srv_inf.avrcp_button_flag,
                           AVRCP_SRV_PRESS_VALUE);
        g_avrcp_srv_inf.avrcp_button_flag = AVRCP_SRV_PRESS_VALUE;
    }
    static_print_debug("avrcp ct press button cbk key:%d button_flag:%u", key_operation,
                       g_avrcp_srv_inf.avrcp_button_flag);
}

static void BtAvrcpPressReleaseButtonLog(uint32_t key_operation)
{
    switch (key_operation) {
    case AVRCP_KEY_VOLUME_UP:
        static_print_debug("AVRCP_KEY_VOLUME_UP");
        break;
    case AVRCP_KEY_VOLUME_DOWN:
        static_print_debug("AVRCP_KEY_VOLUME_DOWN");
        break;
    case AVRCP_KEY_MUTE:
        static_print_debug("AVRCP_KEY_VOLUME_MUTE");
        break;
    case AVRCP_KEY_PLAY:
        static_print_debug("AVRCP_KEY_PLAY");
        break;
    case AVRCP_KEY_STOP:
        static_print_debug("AVRCP_KEY_STOP");
        break;
    case AVRCP_KEY_PAUSE:
        static_print_debug("AVRCP_KEY_PAUSE");
        break;
    case AVRCP_KEY_FORWARD:
        static_print_debug("AVRCP_KEY_FORWARD");
        break;
    case AVRCP_KEY_BACKWARD:
        static_print_debug("AVRCP_KEY_BACKWARD");
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        static_print_debug("AVRCP_EVENT_VOLUME_CHANGED");
        break;
    default:
        static_print_debug("invalid");
        break;
    }
}

static void BtAvrcpCtReleaseButtonRspCallback(const bd_addr_t *bd_addr, int32_t key_operation)
{
    UNUSED(bd_addr);
    static_print_debug("avrcp ct release button cbk key:%d", key_operation);
    if (g_avrcp_srv_inf.avrcp_button_flag == AVRCP_SRV_PRESS_VALUE) {
        static_print_debug("avrcp ct released button button_flag change:%u->%u", g_avrcp_srv_inf.avrcp_button_flag,
                           AVRCP_SRV_RELEASED_VALUE);
        g_avrcp_srv_inf.avrcp_button_flag = AVRCP_SRV_RELEASED_VALUE;
    }
    BtAvrcpPressReleaseButtonLog((uint32_t)key_operation);
}

static void BtAvrcpCtSupportCompanyCallback(const bd_addr_t *bd_addr, avrcp_ct_support_company_para_t *company)
{
    if (bd_addr == nullptr || company == nullptr || company->company_id == nullptr) {
        static_print_error("null pointer");
        return;
    }
    static_print_debug("get company list:");
    for (uint8_t i = 0; i < company->company_num; i++) {
        static_print_debug(" 0x%x ", *company->company_id);
    }
}

static void BtAvrcpCtSupportEventCallback(const bd_addr_t *bd_addr, avrcp_ct_support_event_para_t *event)
{
    if (bd_addr == nullptr || event == nullptr || event->event_id == nullptr) {
        static_print_debug("null pointer");
        return;
    }

    for (uint8_t i = 0; i < event->event_num; i++) {
        if (event->event_id[i] == AVRCP_NOTIFY_EVENT_VOLUME_CHANGED) {
            int ret = avrcp_ct_register_notification(bd_addr, event->event_id[i], 0);
            static_print_info("register event_id: 0x%x, ret = 0x%x", event->event_id[i], ret);
        }
    }

    for (uint8_t i = 0; i < event->event_num; i++) {
        if (event->event_id[i] != AVRCP_NOTIFY_EVENT_VOLUME_CHANGED) {
            int ret = avrcp_ct_register_notification(bd_addr, event->event_id[i], 0);
            static_print_info("register event_id: 0x%x, ret = 0x%x", event->event_id[i], ret);
        }
    }
}

static void BtAvrcpCtGetElementAttriCallback(const bd_addr_t *bd_addr, avrcp_ct_element_attr_para_cb_t *attr_cb_para)
{
    if (bd_addr == nullptr || attr_cb_para == nullptr || attr_cb_para->attr_value == nullptr) {
        static_print_error("null pointer");
        return;
    }

    static_print_debug("attr_cb_para->attr_num = %u", attr_cb_para->attr_num);

    for (uint8_t i = 0; i < attr_cb_para->attr_num; i++) {
        static_print_debug("attrId-charaId-valLen: 0x%x-0x%x-%u ", attr_cb_para->attr_value[i].attr_id,
                           attr_cb_para->attr_value[i].character_set_id, attr_cb_para->attr_value[i].value_len);
        switch (attr_cb_para->attr_value[i].attr_id) {
        case AVRCP_CT_ELEMENT_ATTR_TITLE:
            static_print_debug("Attr Title:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_ARTIST_NAME:
            static_print_debug("Attr Name:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_ALBUM_NAME:
            static_print_debug("Attr Album:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TRACK_NUMBER:
            static_print_debug("Attr Track Number:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TOTAL_NUMBER_OF_TRACKS:
            static_print_debug("Attr Total Number Of Track:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TRACK_GENRE:
            static_print_debug("Attr Track GENRE:");
            break;
        case AVRCP_CT_ELEMENT_ATTR_TRACK_PLAYING_TIME:
            static_print_debug("Attr Track Playing Time_ms:");
            break;
        default:
            static_print_debug("Other:");
            break;
        }

        uint8_t *value = (uint8_t *)(void *)malloc(attr_cb_para->attr_value[i].value_len + 1);
        if (attr_cb_para->attr_value[i].value_len > 0 && attr_cb_para->attr_value[i].value != nullptr) {
            if (memcpy_s(value, attr_cb_para->attr_value[i].value_len, attr_cb_para->attr_value[i].value,
                         attr_cb_para->attr_value[i].value_len) != EOK) {
                free(value);
                static_print_error("memcpy_s fail.");
                return;
            }
        }
        value[attr_cb_para->attr_value[i].value_len] = '\0';
        static_print_debug(" %s ", value);
        free(value);
    }
}

static void BtAvrcpCtGetPlayStatusCallback(const bd_addr_t *bd_addr, avrcp_ct_play_status_cb_t *status)
{
    if (bd_addr == nullptr || status == nullptr) {
        static_print_error("null pointer");
        return;
    }
    static_print_debug("test get play status songlen:%u, songpos:%u, playstatus:%u:", status->song_length,
                       status->song_position, status->play_status);
}

static void BtAvrcpCtHdlNotifyVolumeRspCbk(avrcp_ct_notification_value_cb_t *notification)
{
    static_print_info("Set local volume: 0x%x", notification->volume); /* 注册事件后通知的音量 */
    BtAvrcpTgNotifyVolumeChangedProc((uint8_t)notification->volume);
}

static void BtAvrcpCtNotificationCallback(const bd_addr_t *bd_addr, avrcp_notify_event_t event_id,
                                          avrcp_ct_notification_value_cb_t *notification)
{
    if (bd_addr == nullptr || notification == nullptr) {
        static_print_error("null pointer");
        return;
    }

    // static_print_debug("ct notification cbk event_id:0x%x", event_id);
    bool notify_flag = true;
    switch (event_id) {
    case AVRCP_NOTIFY_EVENT_PLAYBACK_STATUS_CHANGED:
        static_print_debug("tg notify ct playback status changed :%u", notification->play_status);
        // TODO:手机音乐状态改变
        TjdUiAppPlayerModel::GetInstance()->AvrcpCtStatusNotification(notification->play_status); // 播放状态改变
        break;
    case AVRCP_NOTIFY_EVENT_VOLUME_CHANGED:
        BtAvrcpCtHdlNotifyVolumeRspCbk(notification);
        break;
    case AVRCP_NOTIFY_EVENT_NOW_PLAYING_CONTENT_CHANGED:
        static_print_debug("play conent changed event_id:0x%x", event_id);
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_CHANGED:
        static_print_debug("track changed event_id:0x%x", event_id);
        break;
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_END:
    case AVRCP_NOTIFY_EVENT_TRACK_REACHED_START:
    case AVRCP_NOTIFY_EVENT_PLAYBACK_POS_CHANGED:
    case AVRCP_NOTIFY_EVENT_BATT_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_SYSTEM_STATUS_CHANGED:
    case AVRCP_NOTIFY_EVENT_PLAYER_APPLICATION_SETTING_CHANGED:
    case AVRCP_NOTIFY_EVENT_AVAILABLE_PLAYERS_CHANGED:
    case AVRCP_NOTIFY_EVENT_ADDRESSED_PLAYER_CHANGED:
    case AVRCP_NOTIFY_EVENT_UIDS_CHANGED:
    case AVRCP_NOTIFY_EVENT_RESERVED:
    default:
        notify_flag = false;
        // static_print_info("invalid event id event_id:0x%x", event_id);
        break;
    }
    if (notify_flag) {
        static_print_debug("notify reg event_id: 0x%x", event_id);
        avrcp_ct_register_notification(bd_addr, event_id, 0); /* TG通知变化后CT重新注册事件 */
    }
}

void TjdUiAppPlayerModel::InitBtHeadsetEvent()
{
    g_avrcp_tg_audio_cb.notify_pass_through_status_cbk = PressButtonStatusCallback;
    g_avrcp_tg_audio_cb.get_media_status_cbk = MediaStatusCallback;

    g_avrcp_tg_cb.conn_state_changed_cb = ConnectTgStateChangedCallback;

    g_avrcp_ct_cb.conn_state_changed_cb = ConnCtStateChangedCallback;
    g_avrcp_ct_cb.press_button_cb = BtAvrcpCtPressButtonRspCallback;
    g_avrcp_ct_cb.release_button_cb = BtAvrcpCtReleaseButtonRspCallback;
    g_avrcp_ct_cb.supported_companies_cb = BtAvrcpCtSupportCompanyCallback;
    g_avrcp_ct_cb.supported_event_cb = BtAvrcpCtSupportEventCallback;
    g_avrcp_ct_cb.element_attr_cb = BtAvrcpCtGetElementAttriCallback;
    g_avrcp_ct_cb.play_status_cb = BtAvrcpCtGetPlayStatusCallback;
    g_avrcp_ct_cb.notification_cb = BtAvrcpCtNotificationCallback;

    avrcp_tg_register_callbacks(&g_avrcp_tg_cb);
    avrcp_ct_register_callbacks(&g_avrcp_ct_cb);
    bt_avrcp_tg_register_audio_cbk(&g_avrcp_tg_audio_cb);
}

} // namespace TJD