/***************************************************************************
 *
 * Copyright 2015-2019 BES.
 * All rights reserved. All unpublished rights reserved.
 *
 * No part of this work may be used or reproduced in any form or by any
 * means, or stored in a database or retrieval system, without prior written
 * permission of BES.
 *
 * Use of this work is governed by a license granted by BES.
 * This work contains confidential and proprietary information of
 * BES. which is protected by copyright, trade secret,
 * trademark and other intellectual property rights.
 *
 ****************************************************************************/

#include "hal_aud.h"
#include "hal_chipid.h"
#include "hal_trace.h"
#include "apps.h"
#include "app_thread.h"
#include "app_status_ind.h"
#include "bluetooth.h"
#include "nvrecord.h"
#include "besbt.h"
#include "besbt_cfg.h"
#include "me_api.h"
#include "mei_api.h"
#include "a2dp_api.h"
#include "hci_api.h"
#include "l2cap_api.h"
#include "hfp_api.h"
#include "dip_api.h"
#include "btapp.h"
#include "app_bt.h"
#include "app_hfp.h"
#include "app_bt_func.h"
#include "bt_drv_interface.h"
#include "os_api.h"
#include "bt_drv_reg_op.h"
#include "app_a2dp.h"
#include "app_dip.h"
#include "app_ai_manager_api.h"
#include "app_bt.h"

#if defined(IBRT)
#include "app_tws_ibrt.h"
#include "app_ibrt_ui.h"
#include "app_ibrt_if.h"
#include "app_ibrt_a2dp.h"
#endif

#ifdef __THIRDPARTY
#include "app_thirdparty.h"
#endif

#include "app_ble_mode_switch.h"

#ifdef GFPS_ENABLED
#include "app_gfps.h"
#endif

#ifdef __AI_VOICE__
#include "ai_spp.h"
#include "ai_thread.h"
#include "ai_manager.h"
#endif

#ifdef __INTERCONNECTION__
#include "app_interconnection.h"
#include "app_interconnection_ble.h"
#include "spp_api.h"
#include "app_interconnection_ccmp.h"
#include "app_spp.h"
#include "app_interconnection_spp.h"
#endif

#ifdef __INTERACTION__
#include "app_interaction.h"
#endif

#ifdef BISTO_ENABLED
#include "gsound_custom_bt.h"
#endif

#if defined(__EARPHONE_STAY_BCR_SLAVE__) && defined(__BT_ONE_BRING_TWO__)
#error can not defined at the same time.
#endif

#ifdef GFPS_ENABLED
#include "app_gfps.h"
#endif

#ifdef TILE_DATAPATH
#include "tile_target_ble.h"
#include "rwip_config.h"
#endif

#if (A2DP_DECODER_VER >= 2)
#include "a2dp_decoder.h"
#endif
extern "C"
{
#include "ddbif.h"
}
extern struct BT_DEVICE_T  app_bt_device;
extern "C" bool app_anc_work_status(void);
extern uint8_t avrcp_get_media_status(void);
void avrcp_set_media_status(uint8_t status);

#ifdef GFPS_ENABLED
extern "C" void app_gfps_handling_on_mobile_link_disconnection(btif_remote_device_t* pRemDev);
#endif

static btif_remote_device_t *connectedMobile = NULL;
static btif_remote_device_t *sppOpenMobile = NULL;

U16 bt_accessory_feature_feature = BTIF_HF_CUSTOM_FEATURE_SUPPORT;

#ifdef __BT_ONE_BRING_TWO__
btif_device_record_t record2_copy;
uint8_t record2_avalible;
#endif

enum bt_profile_reconnect_mode
{
    bt_profile_reconnect_null,
    bt_profile_reconnect_openreconnecting,
    bt_profile_reconnect_reconnecting,
    bt_profile_reconnect_reconnect_pending,
};

enum bt_profile_connect_status
{
    bt_profile_connect_status_unknow,
    bt_profile_connect_status_success,
    bt_profile_connect_status_failure,
};

struct app_bt_profile_manager
{
    bool has_connected;
    enum bt_profile_connect_status hfp_connect;
    enum bt_profile_connect_status hsp_connect;
    enum bt_profile_connect_status a2dp_connect;
    bt_bdaddr_t rmt_addr;
    bt_profile_reconnect_mode reconnect_mode;
    bt_profile_reconnect_mode saved_reconnect_mode;
    a2dp_stream_t *stream;
    //HfChannel *chan;
    hf_chan_handle_t chan;
#if defined (__HSP_ENABLE__)
    HsChannel * hs_chan;
#endif
    uint16_t reconnect_cnt;
    osTimerId connect_timer;
    void (* connect_timer_cb)(void const *);

    APP_BT_CONNECTING_STATE_E connectingState;
};

//reconnect = (INTERVAL+PAGETO)*CNT = (3000ms+5000ms)*15 = 120s
#define APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS (3000)
#define APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT   (2)
#define APP_BT_PROFILE_RECONNECT_RETRY_LIMIT_CNT (15)
#define APP_BT_PROFILE_CONNECT_RETRY_MS (10000)

static struct app_bt_profile_manager bt_profile_manager[BT_DEVICE_NUM];

static int8_t app_bt_profile_reconnect_pending_process(void);
void app_bt_connectable_mode_stop_reconnecting(void);

btif_accessible_mode_t g_bt_access_mode = BTIF_BAM_NOT_ACCESSIBLE;

#define APP_BT_PROFILE_BOTH_SCAN_MS (11000)
#define APP_BT_PROFILE_PAGE_SCAN_MS (4000)

osTimerId app_bt_accessmode_timer = NULL;
btif_accessible_mode_t app_bt_accessmode_timer_argument = BTIF_BAM_NOT_ACCESSIBLE;
static int app_bt_accessmode_timehandler(void const *param);
osTimerDef (APP_BT_ACCESSMODE_TIMER, (void (*)(void const *))app_bt_accessmode_timehandler);                      // define timers

#define A2DP_CONN_CLOSED   10

#ifdef __IAG_BLE_INCLUDE__
#define APP_FAST_BLE_ADV_TIMEOUT_IN_MS 30000
osTimerId app_fast_ble_adv_timeout_timer = NULL;
static int app_fast_ble_adv_timeout_timehandler(void const *param);
osTimerDef(APP_FAST_BLE_ADV_TIMEOUT_TIMER, ( void (*)(void const *) )app_fast_ble_adv_timeout_timehandler);  // define timers

/*---------------------------------------------------------------------------
 *            app_start_fast_connectable_ble_adv
 *---------------------------------------------------------------------------
 *
 *Synopsis:
 *    start fast connectable BLE adv
 *
 * Parameters:
 *    advInterval - adv interval
 *
 * Return:
 *    void
 */
static void app_start_fast_connectable_ble_adv(uint16_t advInterval);
#endif


#if defined(__INTERCONNECTION__)
btif_accessible_mode_t app_bt_get_current_access_mode(void)
{
    return g_bt_access_mode;
}

bool app_bt_is_connected()
{
    uint8_t i=0;
    bool connceted_value=false;
    for(i=0; i<BT_DEVICE_NUM; i++)
    {
        if(bt_profile_manager[i].has_connected)
        {
            connceted_value = true;
            break;
        }
    }

    TRACE(1,"bt_is_connected is %d", connceted_value);
    return connceted_value;
}
#endif

bool app_device_bt_is_connected()
{
    uint8_t i=0;
    bool connceted_value=false;
    for(i=0;i<BT_DEVICE_NUM;i++)
    {
        if(bt_profile_manager[i].has_connected)
        {
            connceted_value = true;
            break;
        }
    }

 //   TRACE("bt_is_connected : %d, a2dp : %d, hfp : %d", connceted_value,bt_profile_manager[i].a2dp_connect,bt_profile_manager[i].hfp_connect);
    return connceted_value;
}

static void app_bt_precheck_before_starting_connecting(uint8_t isBtConnected);

static void app_bt_accessmode_handler(btif_accessible_mode_t accMode)
{
    const btif_access_mode_info_t info = { BTIF_BT_DEFAULT_INQ_SCAN_INTERVAL,
                                           BTIF_BT_DEFAULT_INQ_SCAN_WINDOW,
                                           BTIF_BT_DEFAULT_PAGE_SCAN_INTERVAL,
                                           BTIF_BT_DEFAULT_PAGE_SCAN_WINDOW
                                         };

    osapi_lock_stack();
    if (accMode == BTIF_BAM_CONNECTABLE_ONLY)
    {
        app_bt_accessmode_timer_argument = BTIF_BAM_GENERAL_ACCESSIBLE;
        osTimerStart(app_bt_accessmode_timer, APP_BT_PROFILE_PAGE_SCAN_MS);
    }
    else if(accMode == BTIF_BAM_GENERAL_ACCESSIBLE)
    {
        app_bt_accessmode_timer_argument = BTIF_BAM_CONNECTABLE_ONLY;
        osTimerStart(app_bt_accessmode_timer, APP_BT_PROFILE_BOTH_SCAN_MS);
    }
    app_bt_ME_SetAccessibleMode(accMode, &info);
    TRACE(1,"app_bt_accessmode_timehandler accMode=%x",accMode);
    osapi_unlock_stack();
}

static int app_bt_accessmode_timehandler(void const *param)
{
    btif_accessible_mode_t accMode = *(btif_accessible_mode_t*)(param);
    app_bt_start_custom_function_in_bt_thread((uint32_t)accMode,
            0, (uint32_t)app_bt_accessmode_handler);
    return 0;
}


void app_bt_accessmode_set(btif_accessible_mode_t mode)
{
    const btif_access_mode_info_t info = { BTIF_BT_DEFAULT_INQ_SCAN_INTERVAL,
                                           BTIF_BT_DEFAULT_INQ_SCAN_WINDOW,
                                           BTIF_BT_DEFAULT_PAGE_SCAN_INTERVAL,
                                           BTIF_BT_DEFAULT_PAGE_SCAN_WINDOW
                                         };
#if defined(IBRT)
    return;
#endif
    TRACE(2,"%s %d",__func__, mode);
    osapi_lock_stack();
    g_bt_access_mode = mode;
    if (g_bt_access_mode == BTIF_BAM_GENERAL_ACCESSIBLE)
    {
        app_bt_accessmode_timehandler(&g_bt_access_mode);
    }
    else
    {
        osTimerStop(app_bt_accessmode_timer);
        app_bt_ME_SetAccessibleMode(g_bt_access_mode, &info);
        TRACE(1,"app_bt_accessmode_set access_mode=%x",g_bt_access_mode);
    }
    osapi_unlock_stack();
}


#ifdef FPGA
void app_bt_accessmode_set_for_test(btif_accessible_mode_t mode)
{
    const btif_access_mode_info_t info = { BTIF_BT_DEFAULT_INQ_SCAN_INTERVAL,
                                           BTIF_BT_DEFAULT_INQ_SCAN_WINDOW,
                                           BTIF_BT_DEFAULT_PAGE_SCAN_INTERVAL,
                                           BTIF_BT_DEFAULT_PAGE_SCAN_WINDOW
                                         };

    TRACE(2,"%s %d",__func__, mode);
    app_bt_ME_SetAccessibleMode_Fortest(mode, &info);
}

void app_bt_adv_mode_set_for_test(uint8_t en)
{

    TRACE(2,"%s %d",__func__, en);
    app_bt_ME_Set_Advmode_Fortest(en);
}

void app_start_ble_adv_for_test(void)
{
    TRACE(1,"%s",__func__);

    U8 adv_data[31];
    U8 adv_data_len = 0;
    U8 scan_rsp_data[31];
    U8 scan_rsp_data_len = 0;

    adv_data[adv_data_len++] = 2;
    adv_data[adv_data_len++] = 0x01;
    adv_data[adv_data_len++] = 0x1A;

    adv_data[adv_data_len++] = 17;
    adv_data[adv_data_len++] = 0xFF;

    adv_data[adv_data_len++] = 0x9A;
    adv_data[adv_data_len++] = 0x07;

    adv_data[adv_data_len++] = 0x10;
    adv_data[adv_data_len++] = 0x04;
    adv_data[adv_data_len++] = 0x06;

    adv_data[adv_data_len++] = 0x07;
    adv_data[adv_data_len++] = 0x00;

    adv_data[adv_data_len++] = 0x01;
    adv_data[adv_data_len++] = 0x98;

    adv_data[adv_data_len++] = 1;

    adv_data[adv_data_len++] = 0xFF;
    adv_data[adv_data_len++] = 0xFF;
    adv_data[adv_data_len++] = 0xFF;
    adv_data[adv_data_len++] = 0xFF;
    adv_data[adv_data_len++] = 0xFF;
    adv_data[adv_data_len++] = 0xFF;

    // Get default Device Name (No name if not enough space)
    const char* ble_name_in_nv = BLE_DEFAULT_NAME;
    uint32_t nameLen = strlen(ble_name_in_nv);
    // Get remaining space in the Advertising Data - 2 bytes are used for name length/flag
    int8_t avail_space = 31-adv_data_len;
    if(avail_space - 2 >= (int8_t)nameLen)
    {
        // Check if data can be added to the adv Data
        adv_data[adv_data_len++] = nameLen + 1;
        // Fill Device Name Flag
        adv_data[adv_data_len++] = '\x09';
        // Copy device name
        memcpy(&adv_data[adv_data_len], ble_name_in_nv, nameLen);
        // Update adv Data Length
        adv_data_len += nameLen;
        btif_me_ble_set_adv_data(adv_data_len, adv_data);

        btif_adv_para_struct_t adv_para;
        adv_para.interval_min = 32;
        adv_para.interval_max = 32;
        adv_para.adv_type = 0;
        adv_para.own_addr_type = 0;
        adv_para.peer_addr_type = 0;
        adv_para.adv_chanmap = 0x07;
        adv_para.adv_filter_policy = 0;
        btif_me_ble_set_adv_parameters(&adv_para);
        btif_me_set_ble_bd_address(ble_addr);
        btif_me_ble_set_adv_en(1);
    }
    else
    {
        nameLen = avail_space - 2;
        // Check if data can be added to the adv Data
        adv_data[adv_data_len++] = nameLen + 1;
        // Fill Device Name Flag
        adv_data[adv_data_len++] = '\x08';
        // Copy device name
        memcpy(&adv_data[adv_data_len], ble_name_in_nv, nameLen);
        // Update adv Data Length
        adv_data_len += nameLen;
        btif_me_ble_set_adv_data(adv_data_len, adv_data);

        btif_adv_para_struct_t adv_para;
        adv_para.interval_min = 256;
        adv_para.interval_max = 256;
        adv_para.adv_type = 0;
        adv_para.own_addr_type = 0;
        adv_para.peer_addr_type = 0;
        adv_para.adv_chanmap = 0x07;
        adv_para.adv_filter_policy = 0;
        btif_me_ble_set_adv_parameters(&adv_para);
        btif_me_set_ble_bd_address(ble_addr);

        avail_space = 31;
        nameLen = strlen(ble_name_in_nv);
        if(avail_space - 2 < (int8_t)nameLen)
            nameLen = avail_space - 2;

        scan_rsp_data[scan_rsp_data_len++] = nameLen + 1;
        // Fill Device Name Flag
        scan_rsp_data[scan_rsp_data_len++] = '\x09';
        // Copy device name
        memcpy(&scan_rsp_data[scan_rsp_data_len], ble_name_in_nv, nameLen);
        // Update Scan response Data Length
        scan_rsp_data_len += nameLen;
        btif_me_ble_set_scan_rsp_data(scan_rsp_data_len, scan_rsp_data);
        btif_me_ble_set_adv_en(1);
    }
}

void app_bt_write_controller_memory_for_test(uint32_t addr,uint32_t val,uint8_t type)
{
    TRACE(2,"%s addr=0x%x val=0x%x type=%d",__func__, addr,val,type);
    app_bt_ME_Write_Controller_Memory_Fortest(addr,val,type);
}

void app_bt_read_controller_memory_for_test(uint32_t addr,uint32_t len,uint8_t type)
{
    TRACE(2,"%s addr=0x%x len=%x type=%d",__func__, addr,len,type);
    app_bt_ME_Read_Controller_Memory_Fortest(addr,len,type);
}
#endif

extern "C" uint8_t app_bt_get_act_cons(void)
{
    int activeCons;

    osapi_lock_stack();
    activeCons = btif_me_get_activeCons();
    osapi_unlock_stack();
    TRACE(2,"%s %d",__func__,activeCons);
    return activeCons;
}
enum
{
    INITIATE_PAIRING_NONE = 0,
    INITIATE_PAIRING_RUN = 1,
};
static uint8_t initiate_pairing = INITIATE_PAIRING_NONE;
void app_bt_connectable_state_set(uint8_t set)
{
    initiate_pairing = set;
}
bool is_app_bt_pairing_running(void)
{
    return (initiate_pairing == INITIATE_PAIRING_RUN)?(true):(false);
}
#define APP_DISABLE_PAGE_SCAN_AFTER_CONN
#ifdef APP_DISABLE_PAGE_SCAN_AFTER_CONN
osTimerId disable_page_scan_check_timer = NULL;
static void disable_page_scan_check_timer_handler(void const *param);
osTimerDef (DISABLE_PAGE_SCAN_CHECK_TIMER, (void (*)(void const *))disable_page_scan_check_timer_handler);                      // define timers
static void disable_page_scan_check_timer_handler(void const *param)
{
#ifdef __BT_ONE_BRING_TWO__
    if((btif_me_get_activeCons() > 1) && (initiate_pairing == INITIATE_PAIRING_NONE))
    {
#else
    if((btif_me_get_activeCons() > 0) && (initiate_pairing == INITIATE_PAIRING_NONE))
    {
#endif
        app_bt_accessmode_set_req(BTIF_BAM_NOT_ACCESSIBLE);
    }
}

static void disable_page_scan_check_timer_start(void)
{
    if(disable_page_scan_check_timer == NULL)
    {
        disable_page_scan_check_timer = osTimerCreate(osTimer(DISABLE_PAGE_SCAN_CHECK_TIMER), osTimerOnce, NULL);
    }
    osTimerStart(disable_page_scan_check_timer, 4000);
}

#endif
void PairingTransferToConnectable(void)
{
    int activeCons;
    osapi_lock_stack();
    activeCons = btif_me_get_activeCons();
    osapi_unlock_stack();
    TRACE(1,"%s",__func__);

    app_bt_connectable_state_set(INITIATE_PAIRING_NONE);
    if(activeCons == 0)
    {
        TRACE(0,"!!!PairingTransferToConnectable  BAM_CONNECTABLE_ONLY\n");
        app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
    }
}
int app_bt_get_audio_up_id(void)
{
    uint8_t i;
    btif_remote_device_t *remDev = NULL;
    btif_cmgr_handler_t    *cmgrHandler;
    for (i=0; i<BT_DEVICE_NUM; i++)
    {
        remDev = btif_me_enumerate_remote_devices(i);
        if (remDev != NULL)
        {
            cmgrHandler = btif_cmgr_get_acl_handler(remDev);
            if(btif_cmgr_is_audio_up(cmgrHandler) == true)
                break;
        }
    }

    return i;
}
#define HFP_DEBUG
void hfp_call_state_checker(void);

#if defined(IBRT)
int app_bt_ibrt_profile_checker(const char *str,
                                btif_remote_device_t *remDev, btif_cmgr_handler_t *cmgrHandler,
                                a2dp_stream_t * a2dp_stream, hf_chan_handle_t hf_channel)
{
    if (remDev && cmgrHandler)
    {
        TRACE(6,"checker: %s remDev state:%d mode:%d role:%d sniffInterval:%d/%d",
              str,
              btif_me_get_remote_device_state(remDev),
              btif_me_get_remote_device_mode(remDev),
              btif_me_get_remote_device_role(remDev),
              btif_cmgr_get_cmgrhandler_sniff_Interval(cmgrHandler),
              btif_cmgr_get_cmgrhandler_sniff_info(cmgrHandler)->maxInterval);

        TRACE(2,"checker: %s remDev:%p remote_dev_address:", str,remDev);
        DUMP8("0x%02x ", btif_me_get_remote_device_bdaddr(remDev)->address, BTIF_BD_ADDR_SIZE);
    }
    else
    {
        TRACE(3,"checker: %s remDev:%p cmgrHandler:%p", str, remDev, cmgrHandler);
    }

    if (a2dp_stream)
    {
        TRACE(1,"a2dp State:%d", btif_a2dp_get_stream_state(a2dp_stream));
        if (btif_a2dp_get_stream_state(a2dp_stream) > BTIF_AVDTP_STRM_STATE_IDLE)
        {
            TRACE(1,"a2dp cmgrHandler remDev:%p", btif_a2dp_get_stream_devic_cmgrHandler_remdev(a2dp_stream));
        }
    }
    else
    {
        TRACE(1,"%s a2dp stream NULL", str);
    }
    if (hf_channel)
    {
        TRACE(4,"hf_channel Connected:%d IsAudioUp:%d/%d remDev:%p", btif_hf_is_acl_connected(hf_channel),
              app_bt_device.hf_audio_state[0],
              btif_hf_check_AudioConnect_status(hf_channel),
              btif_hf_cmgr_get_remote_device(hf_channel));
    }
    else
    {
        TRACE(1,"%s hf_channel NULL", str);
    }
    return 0;
}
#endif

int app_bt_state_checker(void)
{
    btif_remote_device_t *remDev = NULL;
    btif_cmgr_handler_t *cmgrHandler;

    osapi_lock_stack();

#if defined(IBRT)
    ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();

    if (app_tws_ibrt_mobile_link_connected())
    {
        TRACE(1,"checker: IBRT_MASTER activeCons:%d", btif_me_get_activeCons());
        remDev = p_ibrt_ctrl->p_tws_remote_dev;
        if (remDev != NULL)
        {
            cmgrHandler = btif_cmgr_get_acl_handler(remDev);
            if (cmgrHandler)
            {
                app_bt_ibrt_profile_checker("tws peers", remDev, cmgrHandler, NULL, NULL);
            }
            else
            {
                TRACE(0,"checker: cmgrhandler not handle p_tws_remote_dev!");
            }
        }
        else
        {
            TRACE(0,"checker: tws_remote_dev is NULL!");
        }

        remDev = p_ibrt_ctrl->p_mobile_remote_dev;
        if (remDev != NULL)
        {
            cmgrHandler = btif_cmgr_get_acl_handler(remDev);
            if (cmgrHandler)
            {
                app_bt_ibrt_profile_checker("master mobile", remDev, cmgrHandler, app_bt_device.a2dp_connected_stream[0],
                                            app_bt_device.hf_conn_flag[0] ? app_bt_device.hf_channel[0] : NULL);
            }
            else
            {
                TRACE(0,"checker: cmgrhandler not handle mobile_remote_dev");
            }
        }
        else
        {
            TRACE(0,"checker: mobile_remote_dev is NULL!");
        }
    }
    else if (app_tws_ibrt_slave_ibrt_link_connected())
    {
        TRACE(1,"checker: IBRT_SLAVE activeCons:%d", btif_me_get_activeCons());
        remDev = p_ibrt_ctrl->p_tws_remote_dev;
        if (remDev != NULL)
        {
            cmgrHandler = btif_cmgr_get_acl_handler(remDev);
            if (cmgrHandler)
            {
                app_bt_ibrt_profile_checker("tws peers", remDev, cmgrHandler, NULL, NULL);
            }
            else
            {
                TRACE(0,"checker: cmgrhandler not handle p_tws_remote_dev!");
            }
        }
        else
        {
            TRACE(0,"checker: tws_remote_dev is NULL!");
        }
        if (app_ibrt_ui_is_profile_exchanged())
        {
            app_bt_ibrt_profile_checker("ibrt mobile", NULL, NULL, app_bt_device.a2dp_connected_stream[0],
                                        app_bt_device.hf_conn_flag[0] ? app_bt_device.hf_channel[0] : NULL);
        }
    }
    else
    {
        TRACE(1,"checker: IBRT_UNKNOW activeCons:%d", btif_me_get_activeCons());
    }
    app_ibrt_if_ctx_checker();
#if defined(ENHANCED_STACK)
    btif_me_cobuf_state_dump();
    btif_me_hcibuff_state_dump();
#endif
    //BT controller state checker
    ASSERT(bt_drv_reg_op_check_bt_controller_state(), "BT controller dead!");
#else
    for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
    {
        remDev = btif_me_enumerate_remote_devices(i);
        if (remDev != NULL)
        {
            cmgrHandler = btif_cmgr_get_acl_handler(remDev);
            if (cmgrHandler)
            {
                TRACE(8,"checker: id:%d state:%d mode:%d role:%d cmghdl:%p sniffInterva:%d/%d IsAudioUp:%d",
                      i,
                      btif_me_get_remote_device_state(remDev),
                      btif_me_get_remote_device_mode(remDev),
                      btif_me_get_remote_device_role(remDev),
                      cmgrHandler,
                      btif_cmgr_get_cmgrhandler_sniff_Interval(cmgrHandler),
                      btif_cmgr_get_cmgrhandler_sniff_info(cmgrHandler)->maxInterval,
                      app_bt_device.hf_audio_state[i]);
                DUMP8("0x%02x ", btif_me_get_remote_device_bdaddr(remDev)->address, BTIF_BD_ADDR_SIZE);
                TRACE(4,"remDev:%p a2dp State:%d hf_channel Connected:%d remDev:%p ",
                      remDev,
                      app_bt_device.a2dp_connected_stream[i] ?  btif_a2dp_get_stream_state(app_bt_device.a2dp_connected_stream[i]):BTIF_A2DP_STREAM_STATE_CLOSED,
                      app_bt_device.hf_conn_flag[i],
                      app_bt_device.hf_conn_flag[i] ? (btif_remote_device_t *)btif_hf_cmgr_get_remote_device(app_bt_device.hf_channel[i]):NULL);
            }
        }
        else
        {
            TRACE(1,"checker: id:%d remDev is NULL!",  i);
        }

#ifdef __AI_VOICE__
        TRACE(1,"ai_setup_complete %d", app_ai_is_setup_complete());
#endif
#ifdef IS_MULTI_AI_ENABLED
        TRACE(1,"current_spec %d", app_ai_manager_get_current_spec());
#endif
#if defined (__HSP_ENABLE__)
        TRACE(2,"hs_channel Connected:%d remDev:%p ",
              app_bt_device.hs_conn_flag[i],
              app_bt_device.hs_channel[i].cmgrHandler.remDev);
#endif
        TRACE(2,"%s btif_me_get_activeCons = %d",__func__,btif_me_get_activeCons());
#ifdef HFP_DEBUG
        hfp_call_state_checker();
#endif
    }
#if defined(ENHANCED_STACK)
    btif_me_cobuf_state_dump();
    btif_me_hcibuff_state_dump();
#endif
#endif
    osapi_unlock_stack();

    return 0;
}

static uint8_t app_bt_get_devId_from_RemDev(  btif_remote_device_t* remDev)
{
    uint8_t connectedDevId = 0;
    for (uint8_t devId = 0; devId < BT_DEVICE_NUM; devId++)
    {
        if ( btif_me_enumerate_remote_devices(devId) == remDev)
        {
            TRACE(2, "%s %d", __func__, devId);
            connectedDevId = devId;
            break;
        }
    }

    return connectedDevId;
}
void app_bt_accessible_manager_process(const btif_event_t *Event)
{
#if defined(IBRT)
    //IBRT device's access mode will be controlled by UI
    return;
#else
    btif_event_type_t etype = btif_me_get_callback_event_type(Event);
#ifdef __BT_ONE_BRING_TWO__
    static uint8_t opening_reconnect_cnf_cnt = 0;
    //uint8_t disconnectedDevId = app_bt_get_devId_from_RemDev(btif_me_get_callback_event_rem_dev( Event));

    if (app_bt_profile_connect_openreconnecting(NULL))
    {
        if (etype == BTIF_BTEVENT_LINK_CONNECT_CNF)
        {
            opening_reconnect_cnf_cnt++;
        }
        if (record2_avalible)
        {
            if (opening_reconnect_cnf_cnt<2)
            {
                return;
            }
        }
    }
#endif
    switch (etype)
    {
        case BTIF_BTEVENT_LINK_CONNECT_CNF:
        case BTIF_BTEVENT_LINK_CONNECT_IND:
            TRACE(1,"BTEVENT_LINK_CONNECT_IND/CNF activeCons:%d",btif_me_get_activeCons());
#if defined(__BTIF_EARPHONE__)   && !defined(FPGA)
            app_stop_10_second_timer(APP_PAIR_TIMER_ID);
#endif
#ifdef __BT_ONE_BRING_TWO__
            if(btif_me_get_activeCons() == 0)
            {
#ifdef __EARPHONE_STAY_BOTH_SCAN__
                app_bt_accessmode_set_req(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
#else
                app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
#endif
            }
            else if(btif_me_get_activeCons() == 1)
            {
                app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
            }
            else if(btif_me_get_activeCons() >= 2)
            {
                app_bt_accessmode_set_req(BTIF_BAM_NOT_ACCESSIBLE);
            }
#else
            if(btif_me_get_activeCons() == 0)
            {
#ifdef __EARPHONE_STAY_BOTH_SCAN__
                app_bt_accessmode_set_req(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
#else
                app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
#endif
            }
            else if(btif_me_get_activeCons() >= 1)
            {
                app_bt_accessmode_set_req(BTIF_BAM_NOT_ACCESSIBLE);
            }
#endif
            break;
        case BTIF_BTEVENT_LINK_DISCONNECT:
            TRACE(1,"DISCONNECT activeCons:%d",btif_me_get_activeCons());
#ifdef __EARPHONE_STAY_BOTH_SCAN__
#ifdef __BT_ONE_BRING_TWO__
            if(btif_me_get_activeCons() == 0)
            {
                app_bt_accessmode_set_req(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
            }
            else if(btif_me_get_activeCons() == 1)
            {
                app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
            }
            else if(btif_me_get_activeCons() >= 2)
            {
                app_bt_accessmode_set_req(BTIF_BAM_NOT_ACCESSIBLE);
            }
#else
            app_bt_accessmode_set_req(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
#endif
#else
            app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
#endif
            break;
#ifdef __BT_ONE_BRING_TWO__
        case BTIF_BTEVENT_SCO_CONNECT_IND:
        case BTIF_BTEVENT_SCO_CONNECT_CNF:
            if(btif_me_get_activeCons() == 1)
            {
                app_bt_accessmode_set_req(BTIF_BAM_NOT_ACCESSIBLE);
            }
            break;
        case BTIF_BTEVENT_SCO_DISCONNECT:
            if(btif_me_get_activeCons() == 1)
            {
                app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
            }
            break;
#endif
        default:
            break;
    }
#endif
}

#define APP_BT_SWITCHROLE_LIMIT (2)
//#define __SET_OUR_AS_MASTER__

void app_bt_role_manager_process(const btif_event_t *Event)
{
#if defined(IBRT) || defined(APP_LINEIN_A2DP_SOURCE) || defined(APP_I2S_A2DP_SOURCE) || defined(__APP_A2DP_SOURCE__)
    return;
#else
    static btif_remote_device_t *opRemDev = NULL;
    static uint8_t switchrole_cnt = 0;
    btif_remote_device_t *remDev = NULL;
    btif_event_type_t etype = btif_me_get_callback_event_type(Event);
    //on phone connecting
    switch (etype)
    {
        case BTIF_BTEVENT_LINK_CONNECT_IND:
            if(  btif_me_get_callback_event_err_code(Event) == BTIF_BEC_NO_ERROR)
            {
                if (btif_me_get_activeCons() == 1)
                {
                    switch ( btif_me_get_callback_event_rem_dev_role (Event))
                    {
#if defined(__SET_OUR_AS_MASTER__)
                        case BTIF_BCR_SLAVE:
                        case BTIF_BCR_PSLAVE:
#else
                        case BTIF_BCR_MASTER:
                        case BTIF_BCR_PMASTER:
#endif
                            TRACE(1,"CONNECT_IND try to role %p\n",   btif_me_get_callback_event_rem_dev( Event));
                            //curr connectrot try to role
                            opRemDev =btif_me_get_callback_event_rem_dev( Event);
                            switchrole_cnt = 0;
                            app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_MASTER_SLAVE_SWITCH|BTIF_BLP_SNIFF_MODE);
                            break;
#if defined(__SET_OUR_AS_MASTER__)
                        case BTIF_BCR_MASTER:
                        case BTIF_BCR_PMASTER:
#else
                        case BTIF_BCR_SLAVE:
                        case BTIF_BCR_PSLAVE:
#endif
                        case BTIF_BCR_ANY:
                        case BTIF_BCR_UNKNOWN:
                        default:
                            TRACE(1,"CONNECT_IND disable role %p\n",btif_me_get_callback_event_rem_dev( Event));
                            //disable roleswitch when 1 connect
                            app_bt_Me_SetLinkPolicy  (   btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_SNIFF_MODE);
                            break;
                    }
                    //set next connector to master
                    app_bt_ME_SetConnectionRole(BTIF_BCR_MASTER);
                }
                else if (btif_me_get_activeCons() > 1)
                {
                    switch (btif_me_get_callback_event_rem_dev_role (Event))
                    {
                        case BTIF_BCR_MASTER:
                        case BTIF_BCR_PMASTER:
                            TRACE(1,"CONNECT_IND disable role %p\n",btif_me_get_callback_event_rem_dev( Event));
                            //disable roleswitch
                            app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_SNIFF_MODE);
                            break;
                        case BTIF_BCR_SLAVE:
                        case BTIF_BCR_PSLAVE:
                        case BTIF_BCR_ANY:
                        case BTIF_BCR_UNKNOWN:
                        default:
                            //disconnect slave
                            TRACE(1,"CONNECT_IND disconnect slave %p\n",btif_me_get_callback_event_rem_dev( Event));
                            app_bt_MeDisconnectLink(btif_me_get_callback_event_rem_dev( Event));
                            break;
                    }
                    //set next connector to master
                    app_bt_ME_SetConnectionRole(BTIF_BCR_MASTER);
                }
            }
            break;
        case BTIF_BTEVENT_LINK_CONNECT_CNF:
            if (btif_me_get_activeCons() == 1)
            {
                switch (btif_me_get_callback_event_rem_dev_role (Event))
                {
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_SLAVE:
                    case BTIF_BCR_PSLAVE:
#else
                    case BTIF_BCR_MASTER:
                    case BTIF_BCR_PMASTER:
#endif
                        TRACE(1,"CONNECT_CNF try to role %p\n",btif_me_get_callback_event_rem_dev( Event));
                        //curr connectrot try to role
                        opRemDev =btif_me_get_callback_event_rem_dev( Event);
                        switchrole_cnt = 0;
                        app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_MASTER_SLAVE_SWITCH|BTIF_BLP_SNIFF_MODE);
                        app_bt_ME_SwitchRole(btif_me_get_callback_event_rem_dev( Event));
                        break;
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_MASTER:
                    case BTIF_BCR_PMASTER:
#else
                    case BTIF_BCR_SLAVE:
                    case BTIF_BCR_PSLAVE:
#endif
                    case BTIF_BCR_ANY:
                    case BTIF_BCR_UNKNOWN:
                    default:
                        TRACE(1,"CONNECT_CNF disable role %p\n",btif_me_get_callback_event_rem_dev( Event));
                        //disable roleswitch
                        app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_SNIFF_MODE);
                        break;
                }
                //set next connector to master
                app_bt_ME_SetConnectionRole(BTIF_BCR_MASTER);
            }
            else if (btif_me_get_activeCons() > 1)
            {
                switch (btif_me_get_callback_event_rem_dev_role (Event))
                {
                    case BTIF_BCR_MASTER:
                    case BTIF_BCR_PMASTER :
                        TRACE(1,"CONNECT_CNF disable role %p\n",btif_me_get_callback_event_rem_dev( Event));
                        //disable roleswitch
                        app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_SNIFF_MODE);
                        break;
                    case BTIF_BCR_SLAVE:
                    case BTIF_BCR_ANY:
                    case BTIF_BCR_UNKNOWN:
                    default:
                        //disconnect slave
                        TRACE(1,"CONNECT_CNF disconnect slave %p\n",btif_me_get_callback_event_rem_dev( Event));
                        app_bt_MeDisconnectLink(btif_me_get_callback_event_rem_dev( Event));
                        break;
                }
                //set next connector to master
                app_bt_ME_SetConnectionRole(BTIF_BCR_MASTER);
            }
            break;
        case BTIF_BTEVENT_LINK_DISCONNECT:
            if (opRemDev ==btif_me_get_callback_event_rem_dev( Event))
            {
                opRemDev = NULL;
                switchrole_cnt = 0;
            }
            if (btif_me_get_activeCons() == 0)
            {
                for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
                {
                    if(app_bt_device.a2dp_connected_stream[i])
                        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_connected_stream[i], FALSE);
                    app_bt_HF_SetMasterRole(app_bt_device.hf_channel[i], FALSE);
                }
                app_bt_ME_SetConnectionRole(BTIF_BCR_ANY);
            }
            else if (btif_me_get_activeCons() == 1)
            {
                //set next connector to master
                app_bt_ME_SetConnectionRole(BTIF_BCR_MASTER);
            }
            break;
        case BTIF_BTEVENT_ROLE_CHANGE:
            if (opRemDev ==btif_me_get_callback_event_rem_dev( Event))
            {
                switch ( btif_me_get_callback_event_role_change_new_role(Event))
                {
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_SLAVE:
#else
                    case BTIF_BCR_MASTER:
#endif
                        if (++switchrole_cnt<=APP_BT_SWITCHROLE_LIMIT)
                        {
                            app_bt_ME_SwitchRole(btif_me_get_callback_event_rem_dev( Event));
                        }
                        else
                        {
#if defined(__SET_OUR_AS_MASTER__)
                            TRACE(2,"ROLE TO MASTER FAILED remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#else
                            TRACE(2,"ROLE TO SLAVE FAILED remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#endif
                            opRemDev = NULL;
                            switchrole_cnt = 0;
                        }
                        break;
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_MASTER:
                        TRACE(2,"ROLE TO MASTER SUCCESS remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#else
                    case BTIF_BCR_SLAVE:
                        TRACE(2,"ROLE TO SLAVE SUCCESS remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#endif
                        opRemDev = NULL;
                        switchrole_cnt = 0;
                        app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event),BTIF_BLP_SNIFF_MODE);
                        break;
                    case BTIF_BCR_ANY:
                        break;
                    case BTIF_BCR_UNKNOWN:
                        break;
                    default:
                        break;
                }
            }

            if (btif_me_get_activeCons() > 1)
            {
                uint8_t slave_cnt = 0;
                for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
                {
                    remDev = btif_me_enumerate_remote_devices(i);
                    if ( btif_me_get_current_role(remDev) == BTIF_BCR_SLAVE)
                    {
                        slave_cnt++;
                    }
                }
                if (slave_cnt>1)
                {
                    TRACE(1,"ROLE_CHANGE disconnect slave %p\n",btif_me_get_callback_event_rem_dev( Event));
                    app_bt_MeDisconnectLink(btif_me_get_callback_event_rem_dev( Event));
                }
            }
            break;
        default:
            break;
    }
#endif
}

void app_bt_role_manager_process_dual_slave(const btif_event_t *Event)
{
#if defined(IBRT) || defined(APP_LINEIN_A2DP_SOURCE) || defined(APP_I2S_A2DP_SOURCE) || defined(__APP_A2DP_SOURCE__)
    return;
#else
    static btif_remote_device_t *opRemDev = NULL;
    static uint8_t switchrole_cnt = 0;
    //btif_remote_device_t *remDev = NULL;
    //on phone connecting
    switch ( btif_me_get_callback_event_type(Event))
    {
        case BTIF_BTEVENT_LINK_CONNECT_IND:
        case BTIF_BTEVENT_LINK_CONNECT_CNF:
            if(btif_me_get_callback_event_err_code(Event) == BTIF_BEC_NO_ERROR)
            {
                switch (btif_me_get_callback_event_rem_dev_role (Event))
                {
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_SLAVE:
                    case BTIF_BCR_PSLAVE:
#else
                    case BTIF_BCR_MASTER:
                    case BTIF_BCR_PMASTER:
#endif
                        TRACE(1,"CONNECT_IND/CNF try to role %p\n",btif_me_get_callback_event_rem_dev( Event));
                        opRemDev =btif_me_get_callback_event_rem_dev( Event);
                        switchrole_cnt = 0;
                        app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_MASTER_SLAVE_SWITCH|BTIF_BLP_SNIFF_MODE);
                        app_bt_ME_SwitchRole(btif_me_get_callback_event_rem_dev( Event));
                        break;
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_MASTER:
                    case BTIF_BCR_PMASTER:
#else
                    case BTIF_BCR_SLAVE:
                    case BTIF_BCR_PSLAVE:
#endif
                    case BTIF_BCR_ANY:
                    case BTIF_BCR_UNKNOWN:
                    default:
                        TRACE(1,"CONNECT_IND disable role %p\n",btif_me_get_callback_event_rem_dev( Event));
                        app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_SNIFF_MODE);
                        break;
                }
                app_bt_ME_SetConnectionRole(BTIF_BCR_SLAVE);
            }
            break;
        case BTIF_BTEVENT_LINK_DISCONNECT:
            if (opRemDev ==btif_me_get_callback_event_rem_dev( Event))
            {
                opRemDev = NULL;
                switchrole_cnt = 0;
            }
            if (  btif_me_get_activeCons() == 0)
            {
                for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
                {
                    if(app_bt_device.a2dp_connected_stream[i])
                        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_connected_stream[i], FALSE);
                    app_bt_HF_SetMasterRole(app_bt_device.hf_channel[i], FALSE);
                }
                app_bt_ME_SetConnectionRole(BTIF_BCR_ANY);
            }
            else if (btif_me_get_activeCons() == 1)
            {
                app_bt_ME_SetConnectionRole(BTIF_BCR_SLAVE);
            }
            break;
        case BTIF_BTEVENT_ROLE_CHANGE:
            if (opRemDev ==btif_me_get_callback_event_rem_dev( Event))
            {
                switch (btif_me_get_callback_event_role_change_new_role(Event))
                {
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_SLAVE:
#else
                    case BTIF_BCR_MASTER:
#endif
                        if (++switchrole_cnt<=APP_BT_SWITCHROLE_LIMIT)
                        {
                            TRACE(1,"ROLE_CHANGE try to role again: %d", switchrole_cnt);
                            app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event), BTIF_BLP_MASTER_SLAVE_SWITCH|BTIF_BLP_SNIFF_MODE);
                            app_bt_ME_SwitchRole(btif_me_get_callback_event_rem_dev( Event));
                        }
                        else
                        {
#if defined(__SET_OUR_AS_MASTER__)
                            TRACE(2,"ROLE TO MASTER FAILED remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#else
                            TRACE(2,"ROLE TO SLAVE FAILED remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#endif
                            opRemDev = NULL;
                            switchrole_cnt = 0;
                        }
                        break;
#if defined(__SET_OUR_AS_MASTER__)
                    case BTIF_BCR_MASTER:
                        TRACE(2,"ROLE TO MASTER SUCCESS remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#else
                    case BTIF_BCR_SLAVE:
                        TRACE(2,"ROLE TO SLAVE SUCCESS remDev %p cnt:%d\n",btif_me_get_callback_event_rem_dev( Event), switchrole_cnt);
#endif
                        opRemDev = NULL;
                        switchrole_cnt = 0;
                        //workaround for power reset opening reconnect sometime unsuccessfully in sniff mode,
                        //only after authentication completes, enable sniff mode.
                        opRemDev =btif_me_get_callback_event_rem_dev( Event);
                        if (btif_me_get_remote_device_auth_state(opRemDev) == BTIF_BAS_AUTHENTICATED)
                        {
                            app_bt_Me_SetLinkPolicy(opRemDev,BTIF_BLP_SNIFF_MODE);
                        }
                        else
                        {
                            app_bt_Me_SetLinkPolicy(opRemDev,BTIF_BLP_DISABLE_ALL);
                        }
                        break;
                    case BTIF_BCR_ANY:
                        break;
                    case BTIF_BCR_UNKNOWN:
                        break;
                    default:
                        break;
                }
            }
            break;
    }
#endif
}

static int app_bt_sniff_manager_init(void)
{
    btif_sniff_info_t sniffInfo;
    btif_remote_device_t *remDev = NULL;

    for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
    {
        remDev = btif_me_enumerate_remote_devices(i);
        sniffInfo.maxInterval = BTIF_CMGR_SNIFF_MAX_INTERVAL;
        sniffInfo.minInterval = BTIF_CMGR_SNIFF_MIN_INTERVAL;
        sniffInfo.attempt = BTIF_CMGR_SNIFF_ATTEMPT;
        sniffInfo.timeout =BTIF_CMGR_SNIFF_TIMEOUT;
        app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&sniffInfo, remDev);
        app_bt_HF_EnableSniffMode(app_bt_device.hf_channel[i], FALSE);
#if defined (__HSP_ENABLE__)
        app_bt_HS_EnableSniffMode(&app_bt_device.hs_channel[i], FALSE);
#endif
    }

    return 0;
}

void app_bt_sniff_config(btif_remote_device_t *remDev)
{
    btif_sniff_info_t sniffInfo;
    sniffInfo.maxInterval = BTIF_CMGR_SNIFF_MAX_INTERVAL;
    sniffInfo.minInterval = BTIF_CMGR_SNIFF_MIN_INTERVAL;
    sniffInfo.attempt = BTIF_CMGR_SNIFF_ATTEMPT;
    sniffInfo.timeout = BTIF_CMGR_SNIFF_TIMEOUT;
    app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&sniffInfo, remDev);
#if !defined(IBRT)
    if (btif_me_get_activeCons() > 1)
    {
        btif_remote_device_t* tmpRemDev = NULL;
        btif_cmgr_handler_t    *currbtif_cmgr_handler_t = NULL;
        btif_cmgr_handler_t    *otherbtif_cmgr_handler_t = NULL;
        currbtif_cmgr_handler_t = btif_cmgr_get_conn_ind_handler(remDev);
        for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
        {
            tmpRemDev = btif_me_enumerate_remote_devices(i);
            if (remDev != tmpRemDev && tmpRemDev != NULL)
            {
                otherbtif_cmgr_handler_t = btif_cmgr_get_acl_handler(tmpRemDev);
                if (otherbtif_cmgr_handler_t && currbtif_cmgr_handler_t)
                {
                    if ( btif_cmgr_get_cmgrhandler_sniff_info(otherbtif_cmgr_handler_t)->maxInterval == btif_cmgr_get_cmgrhandler_sniff_info(currbtif_cmgr_handler_t)->maxInterval)
                    {
                        sniffInfo.maxInterval = btif_cmgr_get_cmgrhandler_sniff_info(otherbtif_cmgr_handler_t)->maxInterval -20;
                        sniffInfo.minInterval = btif_cmgr_get_cmgrhandler_sniff_info(otherbtif_cmgr_handler_t)->minInterval - 20;
                        sniffInfo.attempt = BTIF_CMGR_SNIFF_ATTEMPT;
                        sniffInfo.timeout = BTIF_CMGR_SNIFF_TIMEOUT;
                        app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&sniffInfo, remDev);
                    }
                }
                break;
            }
            else
            {
                TRACE(3,"%s:enumerate i:%d remDev is NULL, param remDev:%p, this may cause error!", __func__, i, remDev);
            }
        }
    }
#endif
}

void app_bt_sniff_manager_process(const btif_event_t *Event)
{
    static btif_remote_device_t *opRemDev = NULL;
    btif_remote_device_t *remDev = NULL;
    btif_cmgr_handler_t    *currbtif_cmgr_handler_t = NULL;
    btif_cmgr_handler_t    *otherbtif_cmgr_handler_t = NULL;

    btif_sniff_info_t sniffInfo;

    if (!besbt_cfg.sniff)
        return;

    switch (btif_me_get_callback_event_type(Event))
    {
        case BTIF_BTEVENT_LINK_CONNECT_IND:
            break;
        case BTIF_BTEVENT_LINK_CONNECT_CNF:
            break;
        case BTIF_BTEVENT_LINK_DISCONNECT:
            if (opRemDev ==btif_me_get_callback_event_rem_dev( Event))
            {
                opRemDev = NULL;
            }
            sniffInfo.maxInterval = BTIF_CMGR_SNIFF_MAX_INTERVAL;
            sniffInfo.minInterval = BTIF_CMGR_SNIFF_MIN_INTERVAL;
            sniffInfo.attempt = BTIF_CMGR_SNIFF_ATTEMPT;
            sniffInfo.timeout = BTIF_CMGR_SNIFF_TIMEOUT;
            app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&sniffInfo,btif_me_get_callback_event_rem_dev( Event));
            break;
        case BTIF_BTEVENT_MODE_CHANGE:

            /*
            if(Event->p.modeChange.curMode == BLM_SNIFF_MODE){
                currbtif_cmgr_handler_t = btif_cmgr_get_acl_handler(btif_me_get_callback_event_rem_dev( Event));
                if (Event->p.modeChange.interval > CMGR_SNIFF_MAX_INTERVAL){
                        if (!opRemDev){
                            opRemDev = currbtif_cmgr_handler_t->remDev;
                        }
                        currbtif_cmgr_handler_t->sniffInfo.maxInterval = CMGR_SNIFF_MAX_INTERVAL;
                        currbtif_cmgr_handler_t->sniffInfo.minInterval = CMGR_SNIFF_MIN_INTERVAL;
                        currbtif_cmgr_handler_t->sniffInfo.attempt = CMGR_SNIFF_ATTEMPT;
                        currbtif_cmgr_handler_t->sniffInfo.timeout = CMGR_SNIFF_TIMEOUT;
                        app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&currbtif_cmgr_handler_t->sniffInfo,btif_me_get_callback_event_rem_dev( Event));
                        app_bt_ME_StopSniff(currbtif_cmgr_handler_t->remDev);
                }else{
                    if (currbtif_cmgr_handler_t){
                        currbtif_cmgr_handler_t->sniffInfo.maxInterval = Event->p.modeChange.interval;
                        currbtif_cmgr_handler_t->sniffInfo.minInterval = Event->p.modeChange.interval;
                        currbtif_cmgr_handler_t->sniffInfo.attempt = CMGR_SNIFF_ATTEMPT;
                        currbtif_cmgr_handler_t->sniffInfo.timeout = CMGR_SNIFF_TIMEOUT;
                        app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&currbtif_cmgr_handler_t->sniffInfo,btif_me_get_callback_event_rem_dev( Event));
                    }
                    if (btif_me_get_activeCons() > 1){
                        for (uint8_t i=0; i<BT_DEVICE_NUM; i++){
                            remDev = btif_me_enumerate_remote_devices(i);
                            if (btif_me_get_callback_event_rem_dev( Event) != remDev){
                                otherbtif_cmgr_handler_t = btif_cmgr_get_acl_handler(remDev);
                                if (otherbtif_cmgr_handler_t){
                                    if (otherbtif_cmgr_handler_t->sniffInfo.maxInterval == currbtif_cmgr_handler_t->sniffInfo.maxInterval){
                                        if (btif_me_get_current_mode(remDev) == BLM_ACTIVE_MODE){
                                            otherbtif_cmgr_handler_t->sniffInfo.maxInterval -= 20;
                                            otherbtif_cmgr_handler_t->sniffInfo.minInterval -= 20;
                                            otherbtif_cmgr_handler_t->sniffInfo.attempt = CMGR_SNIFF_ATTEMPT;
                                            otherbtif_cmgr_handler_t->sniffInfo.timeout = CMGR_SNIFF_TIMEOUT;
                                            app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&otherbtif_cmgr_handler_t->sniffInfo, remDev);
                                            TRACE(1,"reconfig sniff other RemDev:%x\n", remDev);
                                        }else if (btif_me_get_current_mode(remDev) == BLM_SNIFF_MODE){
                                            need_reconfig = true;
                                        }
                                    }
                                }
                                break;
                            }
                        }
                    }
                    if (need_reconfig){
                        opRemDev = remDev;
                        if (currbtif_cmgr_handler_t){
                            currbtif_cmgr_handler_t->sniffInfo.maxInterval -= 20;
                            currbtif_cmgr_handler_t->sniffInfo.minInterval -= 20;
                            currbtif_cmgr_handler_t->sniffInfo.attempt = CMGR_SNIFF_ATTEMPT;
                            currbtif_cmgr_handler_t->sniffInfo.timeout = CMGR_SNIFF_TIMEOUT;
                            app_bt_CMGR_SetSniffInfoToAllHandlerByRemDev(&currbtif_cmgr_handler_t->sniffInfo, currbtif_cmgr_handler_t->remDev);
                        }
                        app_bt_ME_StopSniff(currbtif_cmgr_handler_t->remDev);
                        TRACE(1,"reconfig sniff setup op opRemDev:%x\n", opRemDev);
                    }
                }
            }
            if (Event->p.modeChange.curMode == BLM_ACTIVE_MODE){
                if (opRemDev ==btif_me_get_callback_event_rem_dev( Event)){
                    TRACE(1,"reconfig sniff op opRemDev:%x\n", opRemDev);
                    opRemDev = NULL;
                    currbtif_cmgr_handler_t = btif_cmgr_get_acl_handler(btif_me_get_callback_event_rem_dev( Event));
                    if (currbtif_cmgr_handler_t){
                        app_bt_CMGR_SetSniffTimer(currbtif_cmgr_handler_t, NULL, CMGR_SNIFF_TIMER);
                    }
                }
            }
            */
            break;
        case BTIF_BTEVENT_ACL_DATA_ACTIVE:
            btif_cmgr_handler_t    *cmgrHandler;
            /* Start the sniff timer */
            cmgrHandler = btif_cmgr_get_acl_handler(btif_me_get_callback_event_rem_dev( Event));
            if (cmgrHandler)
                app_bt_CMGR_SetSniffTimer(cmgrHandler, NULL, BTIF_CMGR_SNIFF_TIMER);
            break;
        case BTIF_BTEVENT_SCO_CONNECT_IND:
        case BTIF_BTEVENT_SCO_CONNECT_CNF:
            TRACE(1,"BTEVENT_SCO_CONNECT_IND/CNF cur_remDev = %p",btif_me_get_callback_event_rem_dev( Event));
            currbtif_cmgr_handler_t = btif_cmgr_get_conn_ind_handler(btif_me_get_callback_event_rem_dev( Event));
            app_bt_Me_SetLinkPolicy( btif_me_get_callback_event_sco_connect_rem_dev(Event), BTIF_BLP_DISABLE_ALL);
            if (btif_me_get_activeCons() > 1)
            {
                for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
                {
                    remDev = btif_me_enumerate_remote_devices(i);
                    TRACE(1,"other_remDev = %p",remDev);
                    if (btif_me_get_callback_event_rem_dev( Event) == remDev)
                    {
                        continue;
                    }

                    otherbtif_cmgr_handler_t = btif_cmgr_get_conn_ind_handler(remDev);
                    if (otherbtif_cmgr_handler_t)
                    {
                        if (btif_cmgr_is_link_up(otherbtif_cmgr_handler_t))
                        {
                            if ( btif_me_get_current_mode(remDev) == BTIF_BLM_ACTIVE_MODE)
                            {
                                TRACE(0,"other dev disable sniff");
                                app_bt_Me_SetLinkPolicy(remDev, BTIF_BLP_DISABLE_ALL);
                            }
                            else if (btif_me_get_current_mode(remDev) == BTIF_BLM_SNIFF_MODE)
                            {
                                TRACE(0," ohter dev exit & disable sniff");
                                app_bt_ME_StopSniff(remDev);
                                app_bt_Me_SetLinkPolicy(remDev, BTIF_BLP_DISABLE_ALL);
                            }
                        }
                    }

#if defined (HFP_NO_PRERMPT)
                    TRACE(2,"cur_audio = %d other_audio = %d",btif_cmgr_is_audio_up(currbtif_cmgr_handler_t),
                          btif_cmgr_is_audio_up(otherbtif_cmgr_handler_t));
                    if((btif_cmgr_is_audio_up(otherbtif_cmgr_handler_t) == true) &&
                       (btif_cmgr_is_audio_up(currbtif_cmgr_handler_t) == true)
                       /*(btapp_hfp_get_call_active()!=0)*/)
                    {
                        btif_cmgr_remove_audio_link(currbtif_cmgr_handler_t);
                        app_bt_Me_switch_sco(btif_cmgr_get_sco_connect_sco_Hcihandler(otherbtif_cmgr_handler_t));
                    }
#endif
                }
            }
            break;
        case BTIF_BTEVENT_SCO_DISCONNECT:
            app_bt_profile_reconnect_pending_process();
            if (a2dp_is_music_ongoing())
            {
                break;
            }
            if (btif_me_get_activeCons() == 1)
            {
                app_bt_Me_SetLinkPolicy( btif_me_get_callback_event_sco_connect_rem_dev(Event), BTIF_BLP_SNIFF_MODE);
            }
            else
            {
                uint8_t i;
                for (i=0; i<BT_DEVICE_NUM; i++)
                {
                    remDev = btif_me_enumerate_remote_devices(i);
                    if (btif_me_get_callback_event_rem_dev( Event) == remDev)
                    {
                        break;
                    }
                }
                /*
                                if(i==0)
                                    remDev = btif_me_enumerate_remote_devices(1);
                                else if(i==1)
                                    remDev = btif_me_enumerate_remote_devices(0);
                                else
                                    ASSERT(0,"error other remotedevice!!!");     */
                otherbtif_cmgr_handler_t = btif_cmgr_get_conn_ind_handler(remDev);
                currbtif_cmgr_handler_t = btif_cmgr_get_conn_ind_handler(btif_me_get_callback_event_rem_dev( Event));

                TRACE(4,"SCO_DISCONNECT:%d/%d %p/%p\n", btif_cmgr_is_audio_up(currbtif_cmgr_handler_t), btif_cmgr_is_audio_up(otherbtif_cmgr_handler_t),
                      btif_cmgr_get_cmgrhandler_remdev(currbtif_cmgr_handler_t),btif_me_get_callback_event_rem_dev( Event));
                if (otherbtif_cmgr_handler_t)
                {
                    if (!btif_cmgr_is_audio_up(otherbtif_cmgr_handler_t))
                    {
                        TRACE(0,"enable sniff to all\n");
                        app_bt_Me_SetLinkPolicy(  btif_me_get_callback_event_sco_connect_rem_dev(Event), BTIF_BLP_SNIFF_MODE);
                        app_bt_Me_SetLinkPolicy( btif_cmgr_get_cmgrhandler_remdev(otherbtif_cmgr_handler_t), BTIF_BLP_SNIFF_MODE);
                    }
                }
                else
                {
                    app_bt_Me_SetLinkPolicy( btif_me_get_callback_event_sco_connect_rem_dev(Event), BTIF_BLP_SNIFF_MODE);
                }
            }
            break;
        default:
            break;
    }
}

APP_BT_GOLBAL_HANDLE_HOOK_HANDLER app_bt_global_handle_hook_handler[APP_BT_GOLBAL_HANDLE_HOOK_USER_QTY] = {0};
void app_bt_global_handle_hook(const btif_event_t *Event)
{
    uint8_t i;
    for (i=0; i<APP_BT_GOLBAL_HANDLE_HOOK_USER_QTY; i++)
    {
        if (app_bt_global_handle_hook_handler[i])
            app_bt_global_handle_hook_handler[i](Event);
    }
}

int app_bt_global_handle_hook_set(enum APP_BT_GOLBAL_HANDLE_HOOK_USER_T user, APP_BT_GOLBAL_HANDLE_HOOK_HANDLER handler)
{
    app_bt_global_handle_hook_handler[user] = handler;
    return 0;
}

APP_BT_GOLBAL_HANDLE_HOOK_HANDLER app_bt_global_handle_hook_get(enum APP_BT_GOLBAL_HANDLE_HOOK_USER_T user)
{
    return app_bt_global_handle_hook_handler[user];
}

extern uint8_t once_event_case;
extern bool IsMobileLinkLossing;
extern void startonce_event(int ms,uint8_t once_event_pram);

extern void a2dp_update_music_link(void);
/////There is a device connected, so stop PAIR_TIMER and POWEROFF_TIMER of earphone.
btif_handler app_bt_handler;
void app_bt_global_handle(const btif_event_t *Event)
{
    switch (btif_me_get_callback_event_type(Event))
    {
        case BTIF_BTEVENT_HCI_INITIALIZED:
            break;
#if defined(IBRT)
        case BTIF_BTEVENT_HCI_COMMAND_SENT:
            return;
#else
        case BTIF_BTEVENT_HCI_COMMAND_SENT:
        case BTIF_BTEVENT_ACL_DATA_NOT_ACTIVE:
            return;
        case BTIF_BTEVENT_ACL_DATA_ACTIVE:
            btif_cmgr_handler_t    *cmgrHandler;
            /* Start the sniff timer */
            cmgrHandler = btif_cmgr_get_acl_handler(btif_me_get_callback_event_rem_dev( Event));
            if (cmgrHandler)
                app_bt_CMGR_SetSniffTimer(cmgrHandler, NULL, BTIF_CMGR_SNIFF_TIMER);
            return;
#endif
        case BTIF_BTEVENT_AUTHENTICATED:
            TRACE(1,"[BTEVENT] HANDER AUTH error=%x", btif_me_get_callback_event_err_code(Event));
            //after authentication completes, re-enable sniff mode.
            if(btif_me_get_callback_event_err_code(Event) == BTIF_BEC_NO_ERROR)
            {
                app_bt_Me_SetLinkPolicy(btif_me_get_callback_event_rem_dev( Event),BTIF_BLP_SNIFF_MODE);
            }
            else if (btif_me_get_callback_event_err_code(Event) == BTIF_BEC_AUTHENTICATE_FAILURE)
            {
                //auth failed should clear nv record link key
                bt_bdaddr_t *bd_ddr = btif_me_get_callback_event_rem_dev_bd_addr(Event);
                btif_device_record_t record;

                if (ddbif_find_record(bd_ddr, &record) == BT_STS_SUCCESS)
                {
                    ddbif_delete_record(&record.bdAddr);
#if defined(IBRT)
                    ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
                    if (!p_ibrt_ctrl->mobile_pair_canceled)
#endif
                    {
                        memset(&record, 0, sizeof(record));
                        record.bdAddr = *bd_ddr;
                        ddbif_add_record(&record);
                    }
                    nv_record_flash_flush();
                }
            }
            break;
    }
    // trace filter
    switch (btif_me_get_callback_event_type(Event))
    {
        case BTIF_BTEVENT_HCI_COMMAND_SENT:
        case BTIF_BTEVENT_ACL_DATA_NOT_ACTIVE:
        case BTIF_BTEVENT_ACL_DATA_ACTIVE:
            break;
        default:
            TRACE(1,"[BTEVENT] evt = %d", btif_me_get_callback_event_type(Event));
            break;
    }

    switch (btif_me_get_callback_event_type(Event))
    {
        case BTIF_BTEVENT_LINK_CONNECT_IND:
            hfp_reconnecting_timer_stop_callback(Event);
        case BTIF_BTEVENT_LINK_CONNECT_CNF:
#ifdef __BT_ONE_BRING_TWO__
            if(bt_drv_reg_op_get_reconnecting_flag())
            {
                bt_drv_reg_op_clear_reconnecting_flag();
                if(a2dp_is_music_ongoing())
                    a2dp_update_music_link();
            }
#endif

            if (BTIF_BEC_NO_ERROR == btif_me_get_callback_event_err_code(Event))
            {
                connectedMobile = btif_me_get_callback_event_rem_dev( Event);
                uint8_t connectedDevId = app_bt_get_devId_from_RemDev(connectedMobile);
                app_bt_set_connecting_profiles_state(connectedDevId);
                TRACE(1,"MEC(pendCons) is %d", btif_me_get_pendCons());

                app_bt_stay_active_rem_dev(btif_me_get_callback_event_rem_dev( Event));
#ifdef __BT_ONE_BRING_TWO__
                btif_remote_device_t *remote_dev = btif_me_get_callback_event_rem_dev(Event);
                uint16_t conn_handle = btif_me_get_remote_device_hci_handle(remote_dev);
                btif_me_qos_set_up(conn_handle);
#endif

#if (defined(__AI_VOICE__) || defined(BISTO_ENABLED))
                app_ai_if_mobile_connect_handle(btif_me_get_callback_event_rem_dev_bd_addr(Event));
#endif
            }

            TRACE(4,"[BTEVENT] CONNECT_IND/CNF evt:%d errCode:0x%0x newRole:%d activeCons:%d",btif_me_get_callback_event_type(Event),
                  btif_me_get_callback_event_err_code(Event),btif_me_get_callback_event_rem_dev_role (Event), btif_me_get_activeCons());
            DUMP8("%02x ", btif_me_get_callback_event_rem_dev_bd_addr(Event), BTIF_BD_ADDR_SIZE);

#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__)  && !defined(FPGA)
            if (btif_me_get_activeCons() == 0)
            {
                app_start_10_second_timer(APP_POWEROFF_TIMER_ID);
            }
            else
            {
                app_stop_10_second_timer(APP_POWEROFF_TIMER_ID);
            }
#endif
#if defined(__BT_ONE_BRING_TWO__)||defined(IBRT)
            if (btif_me_get_activeCons() > 2)
            {
                TRACE(1,"CONNECT_IND/CNF activeCons:%d so disconnect it", btif_me_get_activeCons());
                app_bt_MeDisconnectLink(btif_me_get_callback_event_rem_dev( Event));
            }
#else
            if (btif_me_get_activeCons() > 1)
            {
                TRACE(1,"CONNECT_IND/CNF activeCons:%d so disconnect it", btif_me_get_activeCons());
                app_bt_MeDisconnectLink(btif_me_get_callback_event_rem_dev( Event));
            }
#endif
            break;
        case BTIF_BTEVENT_LINK_DISCONNECT:
        {
            connectedMobile = btif_me_get_callback_event_rem_dev( Event);
            uint8_t disconnectedDevId = app_bt_get_devId_from_RemDev(connectedMobile);
            connectedMobile = NULL;
            app_bt_clear_connecting_profiles_state(disconnectedDevId);

            btif_remote_device_t *remote_dev = btif_me_get_callback_event_disconnect_rem_dev(Event);
            if(remote_dev)
            {
                uint16_t conhdl = btif_me_get_remote_device_hci_handle(remote_dev);
                bt_drv_reg_op_acl_tx_silence_clear(conhdl);
                bt_drv_hwspi_select(conhdl-0x80, 0);
            }

            TRACE(5,"[BTEVENT] DISCONNECT evt = %d encryptState:%d reason:0x%02x/0x%02x activeCons:%d",
                  btif_me_get_callback_event_type(Event),
                  btif_me_get_remote_sevice_encrypt_state(btif_me_get_callback_event_rem_dev( Event)),
                  btif_me_get_remote_device_disc_reason_saved(btif_me_get_callback_event_rem_dev( Event)),
                  btif_me_get_remote_device_disc_reason(btif_me_get_callback_event_rem_dev( Event)),
                  btif_me_get_activeCons());
            DUMP8("%02x ", btif_me_get_callback_event_rem_dev_bd_addr(Event), BTIF_BD_ADDR_SIZE);
#ifdef CHIP_BEST2000
            bt_drv_patch_force_disconnect_ack();
#endif
            //disconnect from reconnect connection, and the HF don't connect successful once
            //(whitch will release the saved_reconnect_mode ). so we are reconnect fail with remote link key loss.
            // goto pairing.
            //reason 07 maybe from the controller's error .
            //05  auth error
            //16  io cap reject.

#if defined(__BTIF_EARPHONE__) && defined(__BTIF_AUTOPOWEROFF__) && !defined(FPGA)
            if (btif_me_get_activeCons() == 0)
            {
                app_start_10_second_timer(APP_POWEROFF_TIMER_ID);
            }
#endif

#if defined(BISTO_ENABLED)
            gsound_custom_bt_link_disconnected_handler(btif_me_get_callback_event_rem_dev_bd_addr(Event)->address);
#endif
#if defined(__AI_VOICE__)
            app_ai_mobile_disconnect_handle(btif_me_get_callback_event_rem_dev_bd_addr(Event));
#endif
#ifdef  __IAG_BLE_INCLUDE__
            // start BLE adv
            app_ble_force_switch_adv(BLE_SWITCH_USER_BT_CONNECT, true);
#endif

#ifdef BTIF_DIP_DEVICE
            btif_dip_clear(remote_dev);
#endif

            app_bt_active_mode_reset(disconnectedDevId);

#ifdef GFPS_ENABLED
            app_gfps_handling_on_mobile_link_disconnection(
                btif_me_get_callback_event_rem_dev(Event));
#endif
#if  !defined(IBRT) && defined( BT_XTAL_SYNC_NO_RESET)
                bt_term_xtal_sync_default();
#endif

            break;
        }
        case BTIF_BTEVENT_ROLE_CHANGE:
            TRACE(3,"[BTEVENT] ROLE_CHANGE eType:0x%x errCode:0x%x newRole:%d activeCons:%d", btif_me_get_callback_event_type(Event),
                  btif_me_get_callback_event_err_code(Event), btif_me_get_callback_event_role_change_new_role(Event), btif_me_get_activeCons());
            break;
        case BTIF_BTEVENT_MODE_CHANGE:
            TRACE(4,"[BTEVENT] MODE_CHANGE evt:%d errCode:0x%0x curMode=0x%0x, interval=%d ",btif_me_get_callback_event_type(Event),
                  btif_me_get_callback_event_err_code(Event), btif_me_get_callback_event_mode_change_curMode(Event),
                  btif_me_get_callback_event_mode_change_interval(Event));
            DUMP8("%02x ", btif_me_get_callback_event_rem_dev_bd_addr(Event), BTIF_BD_ADDR_SIZE);
            break;
        case BTIF_BTEVENT_ACCESSIBLE_CHANGE:
            TRACE(3,"[BTEVENT] ACCESSIBLE_CHANGE evt:%d errCode:0x%0x aMode=0x%0x", btif_me_get_callback_event_type(Event),
                  btif_me_get_callback_event_err_code(Event),
                  btif_me_get_callback_event_a_mode(Event));
#if !defined(IBRT)
            if (app_is_access_mode_set_pending())
            {
                app_set_pending_access_mode();
            }
            else
            {
                if (BTIF_BEC_NO_ERROR != btif_me_get_callback_event_err_code(Event))
                {
                    app_retry_setting_access_mode();
                }
            }
#endif
            break;
        case BTIF_BTEVENT_LINK_POLICY_CHANGED:
        {
            BT_SET_LINKPOLICY_REQ_T* pReq = app_bt_pop_pending_set_linkpolicy();
            if (NULL != pReq)
            {
                app_bt_Me_SetLinkPolicy(pReq->remDev, pReq->policy);
            }
            break;
        }
        case BTIF_BTEVENT_DEFAULT_LINK_POLICY_CHANGED:
        {
            TRACE(0,"[BTEVENT] DEFAULT_LINK_POLICY_CHANGED-->BT_STACK_INITIALIZED");
            app_notify_stack_ready(STACK_READY_BT);
            break;
        }
        case BTIF_BTEVENT_NAME_RESULT:
        {
            uint8_t* ptrName;
            uint8_t nameLen;
            nameLen = btif_me_get_callback_event_remote_dev_name(Event, &ptrName);
            TRACE(1,"[BTEVENT] NAME_RESULT name len %d", nameLen);
            if (nameLen > 0)
            {
                TRACE(1,"remote dev name: %s", ptrName);
            }
            //return;
        }
        default:
            break;
    }

#ifdef MULTIPOINT_DUAL_SLAVE
    app_bt_role_manager_process_dual_slave(Event);
#else
    app_bt_role_manager_process(Event);
#endif
    app_bt_accessible_manager_process(Event);
#if !defined(IBRT)
    app_bt_sniff_manager_process(Event);
#endif
    app_bt_global_handle_hook(Event);
#if defined(IBRT)
    app_tws_ibrt_global_callback(Event);
#endif
}

#include "app_bt_media_manager.h"
osTimerId bt_sco_recov_timer = NULL;
static void bt_sco_recov_timer_handler(void const *param);
osTimerDef (BT_SCO_RECOV_TIMER, (void (*)(void const *))bt_sco_recov_timer_handler);                      // define timers
void hfp_reconnect_sco(uint8_t flag);
static void bt_sco_recov_timer_handler(void const *param)
{
    TRACE(1,"%s",__func__);
    hfp_reconnect_sco(0);
}
static void bt_sco_recov_timer_start()
{
    osTimerStop(bt_sco_recov_timer);
    osTimerStart(bt_sco_recov_timer, 2500);
}


enum
{
    SCO_DISCONNECT_RECONN_START,
    SCO_DISCONNECT_RECONN_RUN,
    SCO_DISCONNECT_RECONN_NONE,
};

static uint8_t sco_reconnect_status =  SCO_DISCONNECT_RECONN_NONE;

void hfp_reconnect_sco(uint8_t set)
{
    TRACE(3,"%s cur_chl_id=%d reconnect_status =%d",__func__,app_bt_device.curr_hf_channel_id,
          sco_reconnect_status);
    if(set == 1)
    {
        sco_reconnect_status = SCO_DISCONNECT_RECONN_START;
    }
    if(sco_reconnect_status == SCO_DISCONNECT_RECONN_START)
    {
        app_audio_manager_sendrequest(APP_BT_STREAM_MANAGER_STOP,BT_STREAM_VOICE, app_bt_device.curr_hf_channel_id,MAX_RECORD_NUM);
        app_bt_HF_DisconnectAudioLink(app_bt_device.hf_channel[app_bt_device.curr_hf_channel_id]);
        sco_reconnect_status = SCO_DISCONNECT_RECONN_RUN;
        bt_sco_recov_timer_start();
    }
    else if(sco_reconnect_status == SCO_DISCONNECT_RECONN_RUN)
    {
        app_bt_HF_CreateAudioLink(app_bt_device.hf_channel[app_bt_device.curr_hf_channel_id]);
        sco_reconnect_status = SCO_DISCONNECT_RECONN_NONE;
    }
}


void app_bt_global_handle_init(void)
{
    btif_event_mask_t mask = BTIF_BEM_NO_EVENTS;
    btif_me_init_handler(&app_bt_handler);
    app_bt_handler.callback = app_bt_global_handle;
    btif_me_register_global_handler(&app_bt_handler);
#if defined(IBRT)
    btif_me_register_accept_handler(&app_bt_handler);
#endif
#ifdef IBRT_SEARCH_UI
    app_bt_global_handle_hook_set(APP_BT_GOLBAL_HANDLE_HOOK_USER_0,app_bt_manager_ibrt_role_process);
#endif

    mask |= BTIF_BEM_ROLE_CHANGE | BTIF_BEM_SCO_CONNECT_CNF | BTIF_BEM_SCO_DISCONNECT | BTIF_BEM_SCO_CONNECT_IND;
    mask |= BTIF_BEM_AUTHENTICATED;
    mask |= BTIF_BEM_LINK_CONNECT_IND;
    mask |= BTIF_BEM_LINK_DISCONNECT;
    mask |= BTIF_BEM_LINK_CONNECT_CNF;
    mask |= BTIF_BEM_ACCESSIBLE_CHANGE;
    mask |= BTIF_BEM_ENCRYPTION_CHANGE;
    mask |= BTIF_BEM_SIMPLE_PAIRING_COMPLETE;
#if (defined(__BT_ONE_BRING_TWO__)||defined(IBRT))
    mask |= BTIF_BEM_MODE_CHANGE;
#endif
    mask |= BTIF_BEM_LINK_POLICY_CHANGED;

    app_bt_ME_SetConnectionRole(BTIF_BCR_ANY);
    for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
    {
        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_stream[i]->a2dp_stream, FALSE);
#if defined(A2DP_LHDC_ON)
        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_lhdc_stream[i]->a2dp_stream, FALSE);
#endif
#if defined(A2DP_AAC_ON)
        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_aac_stream[i]->a2dp_stream, FALSE);
#endif
#if defined(A2DP_SCALABLE_ON)
        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_scalable_stream[i]->a2dp_stream, FALSE);
#endif
#if defined(A2DP_LDAC_ON)
        app_bt_A2DP_SetMasterRole(app_bt_device.a2dp_ldac_stream[i]->a2dp_stream, FALSE);
#endif

        app_bt_HF_SetMasterRole(app_bt_device.hf_channel[i], FALSE);
#if defined (__HSP_ENABLE__)
        HS_SetMasterRole(&app_bt_device.hs_channel[i], FALSE);
#endif
    }
    btif_me_set_event_mask(&app_bt_handler, mask);
    app_bt_sniff_manager_init();
    app_bt_accessmode_timer = osTimerCreate (osTimer(APP_BT_ACCESSMODE_TIMER), osTimerOnce, &app_bt_accessmode_timer_argument);
    bt_sco_recov_timer = osTimerCreate (osTimer(BT_SCO_RECOV_TIMER), osTimerOnce, NULL);
}

void app_bt_send_request(uint32_t message_id, uint32_t param0, uint32_t param1, uint32_t ptr)
{
    APP_MESSAGE_BLOCK msg;

    msg.mod_id = APP_MODUAL_BT;
    msg.msg_body.message_id = message_id;
    msg.msg_body.message_Param0 = param0;
    msg.msg_body.message_Param1 = param1;
    msg.msg_body.message_ptr = ptr;
    app_mailbox_put(&msg);
}

extern void app_start_10_second_timer(uint8_t timer_id);

static int app_bt_handle_process(APP_MESSAGE_BODY *msg_body)
{
    btif_accessible_mode_t old_access_mode;

    switch (msg_body->message_id)
    {
        case APP_BT_REQ_ACCESS_MODE_SET:
            old_access_mode = g_bt_access_mode;
            app_bt_accessmode_set(msg_body->message_Param0);
            if (msg_body->message_Param0 == BTIF_BAM_GENERAL_ACCESSIBLE &&
                old_access_mode != BTIF_BAM_GENERAL_ACCESSIBLE)
            {
#ifndef FPGA
                //app_status_indication_set(APP_STATUS_INDICATION_BOTHSCAN);
#ifdef MEDIA_PLAYER_SUPPORT
                app_voice_report(APP_STATUS_INDICATION_BOTHSCAN, 0);
#endif
                app_start_10_second_timer(APP_PAIR_TIMER_ID);
#endif
            }
            else
            {
#ifndef FPGA
                //app_status_indication_set(APP_STATUS_INDICATION_PAGESCAN);
#endif
            }
            break;
        default:
            break;
    }

    return 0;
}

void *app_bt_profile_active_store_ptr_get(uint8_t *bdAddr)
{
    static btdevice_profile device_profile = {true, false, true,0};
    btdevice_profile *ptr;

#ifndef FPGA
    nvrec_btdevicerecord *record = NULL;
    if (!nv_record_btdevicerecord_find((bt_bdaddr_t *)bdAddr,&record))
    {
        uint32_t lock = nv_record_pre_write_operation();
        ptr = &(record->device_plf);
        DUMP8("0x%02x ", bdAddr, BTIF_BD_ADDR_SIZE);
        TRACE(5,"%s hfp_act:%d hsp_act:%d a2dp_act:0x%x codec_type=%x", __func__, ptr->hfp_act, ptr->hsp_act, ptr->a2dp_act,ptr->a2dp_codectype);
        /* always need connect a2dp and hfp */
        ptr->hfp_act = true;
        ptr->a2dp_act = true;
        nv_record_post_write_operation(lock);
    }
    else
#endif
    {
        ptr = &device_profile;
        TRACE(1,"%s default", __func__);
    }
    return (void *)ptr;
}

static void app_bt_profile_reconnect_timehandler(void const *param);
extern void startonce_delay_event_Timer_(int ms);
osTimerDef (BT_PROFILE_CONNECT_TIMER0, app_bt_profile_reconnect_timehandler);                      // define timers
#ifdef __BT_ONE_BRING_TWO__
osTimerDef (BT_PROFILE_CONNECT_TIMER1, app_bt_profile_reconnect_timehandler);
#endif

#ifdef __AUTO_CONNECT_OTHER_PROFILE__
static void app_bt_profile_connect_hf_retry_handler(void)
{
    struct app_bt_profile_manager *bt_profile_manager_p = (struct app_bt_profile_manager *)param;
    if (MEC(pendCons) > 0)
    {
        TRACE(1,"Former link is not down yet, reset the timer %s.", __FUNCTION__);
        osTimerStart(bt_profile_manager_p->connect_timer, APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
    }
    else
    {
        app_bt_precheck_before_starting_connecting(bt_profile_manager_p->has_connected);
        if (bt_profile_manager_p->hfp_connect != bt_profile_connect_status_success)
        {
            app_bt_HF_CreateServiceLink(bt_profile_manager_p->chan, &bt_profile_manager_p->rmt_addr);
        }
    }
}

static void app_bt_profile_connect_hf_retry_timehandler(void const *param)
{
    app_bt_start_custom_function_in_bt_thread(0, 0,
            (uint32_t)app_bt_profile_connect_hf_retry_handler);
}

#if defined (__HSP_ENABLE__)
static void app_bt_profile_connect_hs_retry_timehandler(void const *param)
{
    struct app_bt_profile_manager *bt_profile_manager_p = (struct app_bt_profile_manager *)param;
    if (MEC(pendCons) > 0)
    {
        if (bt_profile_manager_p->reconnect_cnt < APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT)
        {
            bt_profile_manager_p->reconnect_cnt++;
        }
        TRACE(1,"Former link is not down yet, reset the timer %s.", __FUNCTION__);
        osTimerStart(bt_profile_manager_p->connect_timer,
                     BTIF_BT_DEFAULT_PAGE_TIMEOUT_IN_MS+APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
    }
    else
    {
        if (bt_profile_manager_p->hsp_connect != bt_profile_connect_status_success)
        {
            app_bt_HS_CreateServiceLink(bt_profile_manager_p->hs_chan, &bt_profile_manager_p->rmt_addr);
        }
    }
}
#endif

static bool app_bt_profile_manager_connect_a2dp_filter_connected_a2dp_stream(BT_BD_ADDR bd_addr)
{
    uint8_t i =0;
    BtRemoteDevice *StrmRemDev;
    A2dpStream * connected_stream;

    for(i =0; i<BT_DEVICE_NUM; i++)
    {
        if((app_bt_device.a2dp_stream[i].stream.state == AVDTP_STRM_STATE_STREAMING ||
            app_bt_device.a2dp_stream[i].stream.state == AVDTP_STRM_STATE_OPEN))
        {
            connected_stream = &app_bt_device.a2dp_stream[i];
            StrmRemDev = A2DP_GetRemoteDevice(connected_stream);
            if(memcmp(StrmRemDev->bdAddr.addr,bd_addr.addr,BD_ADDR_SIZE) == 0)
            {
                return true;
            }
        }
    }
    return false;
}

static void app_bt_profile_connect_a2dp_retry_handler(void)
{
    struct app_bt_profile_manager *bt_profile_manager_p = (struct app_bt_profile_manager *)param;
    TRACE(1,"%s reconnect_cnt = %d",__func__,bt_profile_manager_p->reconnect_cnt);

    if (MEC(pendCons) > 0)
    {
        if (bt_profile_manager_p->reconnect_cnt < APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT)
        {
            bt_profile_manager_p->reconnect_cnt++;
        }
        TRACE(1,"Former link is not down yet, reset the timer %s.", __FUNCTION__);
        osTimerStart(bt_profile_manager_p->connect_timer,
                     BTIF_BT_DEFAULT_PAGE_TIMEOUT_IN_MS+APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
    }
    else
    {
        if(app_bt_profile_manager_connect_a2dp_filter_connected_a2dp_stream(bt_profile_manager_p->rmt_addr) == true)
        {
            TRACE(0,"has been connected , no need to init connect again");
            return ;
        }
        app_bt_precheck_before_starting_connecting(bt_profile_manager_p->has_connected);
        if (bt_profile_manager_p->a2dp_connect != bt_profile_connect_status_success)
        {
            app_bt_A2DP_OpenStream(bt_profile_manager_p->stream, &bt_profile_manager_p->rmt_addr);
        }
    }
}

static void app_bt_profile_connect_a2dp_retry_timehandler(void const *param)
{
    app_bt_start_custom_function_in_bt_thread(0, 0,
            (uint32_t)app_bt_profile_connect_a2dp_retry_handler);
}
#endif

void app_bt_reset_reconnect_timer(bt_bdaddr_t *pBdAddr)
{
    uint8_t devId = 0;
    for (uint8_t i = 0; i < BT_DEVICE_NUM; i++)
    {
        if (pBdAddr == &(bt_profile_manager[i].rmt_addr))
        {
            devId = i;
            break;
        }
    }

    TRACE(1,"Resart the reconnecting timer of dev %d", devId);
    osTimerStart(bt_profile_manager[devId].connect_timer,
                 BTIF_BT_DEFAULT_PAGE_TIMEOUT_IN_MS+APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
}

static void app_bt_profile_reconnect_handler(void const *param)
{
#if !defined(IBRT)
    struct app_bt_profile_manager *bt_profile_manager_p = (struct app_bt_profile_manager *)param;
    TRACE(1,"%s reconnect_cnt = %d",__FUNCTION__,bt_profile_manager_p->reconnect_cnt);

    if ( btif_me_get_pendCons() > 0)
    {
        if (bt_profile_manager_p->reconnect_cnt < APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT)
        {
            bt_profile_manager_p->reconnect_cnt++;
        }
        TRACE(1,"Former link is not down yet, reset the timer %s.", __FUNCTION__);
        osTimerStart(bt_profile_manager_p->connect_timer,
                     BTIF_BT_DEFAULT_PAGE_TIMEOUT_IN_MS+APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
    }
    else
    {
        btdevice_profile *btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(bt_profile_manager_p->rmt_addr.address);
#ifdef __BT_ONE_BRING_TWO__
        if(a2dp_is_music_ongoing()&&(bt_profile_manager_p->has_connected == false))
        {
            bt_drv_reg_op_set_reconnecting_flag();
            a2dp_update_music_link();
        }
#endif

        if (bt_profile_manager_p->connect_timer_cb)
        {
            bt_profile_manager_p->connect_timer_cb(param);
            bt_profile_manager_p->connect_timer_cb = NULL;
        }
        else
        {
            if ((btdevice_plf_p->hfp_act)
                &&(bt_profile_manager_p->hfp_connect != bt_profile_connect_status_success))
            {
                TRACE(0,"try connect hf");
                app_bt_precheck_before_starting_connecting(bt_profile_manager_p->has_connected);
                app_bt_HF_CreateServiceLink(bt_profile_manager_p->chan, (bt_bdaddr_t *)&bt_profile_manager_p->rmt_addr);
            }
#if defined (__HSP_ENABLE__)
            else if(btdevice_plf_p->hsp_act)
                &&(bt_profile_manager_p->hsp_connect != bt_profile_connect_status_success))
            {
                TRACE(0,"try connect hs");
                app_bt_precheck_before_starting_connecting(bt_profile_manager_p->has_connected);
                app_bt_HS_CreateServiceLink(bt_profile_manager_p->hs_chan, &bt_profile_manager_p->rmt_addr);
            }
#endif
            else if((btdevice_plf_p->a2dp_act)
                        &&(bt_profile_manager_p->a2dp_connect != bt_profile_connect_status_success))
            {
                TRACE(0,"try connect a2dp");
                app_bt_precheck_before_starting_connecting(bt_profile_manager_p->has_connected);
                app_bt_A2DP_OpenStream(bt_profile_manager_p->stream, &bt_profile_manager_p->rmt_addr);
            }
        }
    }
#else
    TRACE(0,"ibrt_ui_log:app_bt_profile_reconnect_timehandler called");
#endif
}

static void app_bt_profile_reconnect_timehandler(void const *param)
{
    app_bt_start_custom_function_in_bt_thread((uint32_t)param, 0,
            (uint32_t)app_bt_profile_reconnect_handler);
}

bool app_bt_is_in_connecting_profiles_state(void)
{
    for (uint8_t devId = 0; devId < BT_DEVICE_NUM; devId++)
    {
        if (APP_BT_IN_CONNECTING_PROFILES_STATE == bt_profile_manager[devId].connectingState)
        {
            return true;
        }
    }

    return false;
}

void app_bt_clear_connecting_profiles_state(uint8_t devId)
{
    TRACE(1,"Dev %d exists connecting profiles state", devId);

    bt_profile_manager[devId].connectingState = APP_BT_IDLE_STATE;
    if (!app_bt_is_in_connecting_profiles_state())
    {
#ifdef __IAG_BLE_INCLUDE__
        app_start_fast_connectable_ble_adv(BLE_FAST_ADVERTISING_INTERVAL);
#endif
    }
}

void app_bt_set_connecting_profiles_state(uint8_t devId)
{
    TRACE(1,"Dev %d enters connecting profiles state", devId);

    bt_profile_manager[devId].connectingState = APP_BT_IN_CONNECTING_PROFILES_STATE;
}

void app_bt_profile_connect_manager_open(void)
{
    uint8_t i=0;
    for (i=0; i<BT_DEVICE_NUM; i++)
    {
        bt_profile_manager[i].has_connected = false;
        bt_profile_manager[i].hfp_connect = bt_profile_connect_status_unknow;
        bt_profile_manager[i].hsp_connect = bt_profile_connect_status_unknow;
        bt_profile_manager[i].a2dp_connect = bt_profile_connect_status_unknow;
        memset(bt_profile_manager[i].rmt_addr.address, 0, BTIF_BD_ADDR_SIZE);
        bt_profile_manager[i].reconnect_mode = bt_profile_reconnect_null;
        bt_profile_manager[i].saved_reconnect_mode = bt_profile_reconnect_null;
        bt_profile_manager[i].stream = NULL;
        bt_profile_manager[i].chan = NULL;
#if defined (__HSP_ENABLE__)
        bt_profile_manager[i].hs_chan = NULL;
#endif
        bt_profile_manager[i].reconnect_cnt = 0;
        bt_profile_manager[i].connect_timer_cb = NULL;
        bt_profile_manager[i].connectingState = APP_BT_IDLE_STATE;
    }

    bt_profile_manager[BT_DEVICE_ID_1].connect_timer = osTimerCreate (osTimer(BT_PROFILE_CONNECT_TIMER0), osTimerOnce, &bt_profile_manager[BT_DEVICE_ID_1]);
#ifdef __BT_ONE_BRING_TWO__
    bt_profile_manager[BT_DEVICE_ID_2].connect_timer = osTimerCreate (osTimer(BT_PROFILE_CONNECT_TIMER1), osTimerOnce, &bt_profile_manager[BT_DEVICE_ID_2]);
#endif
}

BOOL app_bt_profile_connect_openreconnecting(void *ptr)
{
    bool nRet = false;
    uint8_t i;

    /*
     * If launched from peer device,stop reconnecting and accept connection
     */
    if ((ptr != NULL) && (btif_me_get_remote_device_initiator((btif_remote_device_t *)ptr) == FALSE))
    {
        //Peer device launch reconnet,then we give up reconnect procedure
        TRACE(0,"give up reconnecting");
        app_bt_connectable_mode_stop_reconnecting();
        return false;
    }

    for (i=0; i<BT_DEVICE_NUM; i++)
    {
        nRet |= bt_profile_manager[i].reconnect_mode == bt_profile_reconnect_openreconnecting ? true : false;
        if(nRet)
        {
            TRACE(2,"io cap rj [%d]: %d", i, bt_profile_manager[i].reconnect_mode);
        }
    }

    return nRet;
}

bool app_bt_is_in_reconnecting(void)
{
    uint8_t devId;
    for (devId = 0; devId < BT_DEVICE_NUM; devId++)
    {
        if (bt_profile_reconnect_null != bt_profile_manager[devId].reconnect_mode)
        {
            return true;
        }
    }

    return false;
}

void app_bt_profile_connect_manager_opening_reconnect(void)
{
    int ret;
    btif_device_record_t record1;
    btif_device_record_t record2;
    btdevice_profile *btdevice_plf_p;
    int find_invalid_record_cnt;
#if defined(APP_LINEIN_A2DP_SOURCE)||defined(APP_I2S_A2DP_SOURCE)
    if(app_bt_device.src_or_snk==BT_DEVICE_SRC)
    {
        return ;
    }
#endif
    osapi_lock_stack();

#ifndef __BT_ONE_BRING_TWO__
    if(btif_me_get_activeCons() != 0)
    {
        osapi_unlock_stack();
        TRACE(0,"bt link disconnect not complete,ignore this time reconnect");
        return;
    }
#endif

    do
    {
        find_invalid_record_cnt = 0;
        ret = nv_record_enum_latest_two_paired_dev(&record1,&record2);
        if(ret == 1)
        {
            btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(record1.bdAddr.address);
            if (!(btdevice_plf_p->hfp_act)&&!(btdevice_plf_p->a2dp_act))
            {
                nv_record_ddbrec_delete((bt_bdaddr_t *)&record1.bdAddr);
                find_invalid_record_cnt++;
            }
        }
        else if(ret == 2)
        {
            btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(record1.bdAddr.address);
            if (!(btdevice_plf_p->hfp_act)&&!(btdevice_plf_p->a2dp_act))
            {
                nv_record_ddbrec_delete((bt_bdaddr_t *)&record1.bdAddr);
                find_invalid_record_cnt++;
            }
            btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(record2.bdAddr.address);
            if (!(btdevice_plf_p->hfp_act)&&!(btdevice_plf_p->a2dp_act))
            {
                nv_record_ddbrec_delete((bt_bdaddr_t *)&record2.bdAddr);
                find_invalid_record_cnt++;
            }
        }
    }
    while(find_invalid_record_cnt);

    TRACE(0,"!!!app_bt_opening_reconnect:\n");
    DUMP8("%02x ", &record1.bdAddr, 6);
    DUMP8("%02x ", &record2.bdAddr, 6);


    if(ret > 0)
    {
        TRACE(0,"!!!start reconnect first device\n");

        if(  btif_me_get_pendCons() == 0)
        {
            bt_profile_manager[BT_DEVICE_ID_1].reconnect_mode = bt_profile_reconnect_openreconnecting;
            bt_profile_manager[BT_DEVICE_ID_1].reconnect_cnt = 0;
            memcpy(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr.address, record1.bdAddr.address, BTIF_BD_ADDR_SIZE);
            btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr.address);

#if defined(A2DP_LHDC_ON)
            if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
                bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream;
            else
#endif
#if defined(A2DP_AAC_ON)
            if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_MPEG2_4_AAC)
                bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream;
            else
#endif
#if defined(A2DP_LDAC_ON)  //workaround for mate10 no a2dp issue when link back
            if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
            {
                //bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream;
                //btdevice_plf_p->a2dp_codectype = BTIF_AVDTP_CODEC_TYPE_MPEG2_4_AAC;
                bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream;
                btdevice_plf_p->a2dp_codectype = BTIF_AVDTP_CODEC_TYPE_NON_A2DP;
            }
            else
#endif

#if defined(A2DP_SCALABLE_ON)
            if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
                bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream;
            else
#endif
            {
                bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream;
            }

            btif_a2dp_reset_stream_state(bt_profile_manager[BT_DEVICE_ID_1].stream);

            bt_profile_manager[BT_DEVICE_ID_1].chan = app_bt_device.hf_channel[BT_DEVICE_ID_1];
#if defined (__HSP_ENABLE__)
            bt_profile_manager[BT_DEVICE_ID_1].hs_chan = &app_bt_device.hs_channel[BT_DEVICE_ID_1];
#endif
            if (btdevice_plf_p->hfp_act)
            {
                TRACE(0,"try connect hf");
                app_bt_precheck_before_starting_connecting(bt_profile_manager[BT_DEVICE_ID_1].has_connected);
                app_bt_HF_CreateServiceLink(bt_profile_manager[BT_DEVICE_ID_1].chan, (bt_bdaddr_t *)&bt_profile_manager[BT_DEVICE_ID_1].rmt_addr);
            }
            else if(btdevice_plf_p->a2dp_act)
            {
                TRACE(0,"try connect a2dp");
                app_bt_precheck_before_starting_connecting(bt_profile_manager[BT_DEVICE_ID_1].has_connected);
                app_bt_A2DP_OpenStream(bt_profile_manager[BT_DEVICE_ID_1].stream, &bt_profile_manager[BT_DEVICE_ID_1].rmt_addr);
            }

#if defined (__HSP_ENABLE__)
            else if (btdevice_plf_p->hsp_act)
            {
                TRACE(0,"try connect hs");
                app_bt_precheck_before_starting_connecting(bt_profile_manager[BT_DEVICE_ID_1].has_connected);
                app_bt_HS_CreateServiceLink(bt_profile_manager[BT_DEVICE_ID_1].hs_chan, &bt_profile_manager[BT_DEVICE_ID_1].rmt_addr);
            }
#endif

        }
#ifdef __BT_ONE_BRING_TWO__
        if(ret > 1)
        {
            TRACE(0,"!!!need reconnect second device\n");
            bt_profile_manager[BT_DEVICE_ID_2].reconnect_mode = bt_profile_reconnect_openreconnecting;
            bt_profile_manager[BT_DEVICE_ID_2].reconnect_cnt = 0;
            memcpy(bt_profile_manager[BT_DEVICE_ID_2].rmt_addr.address, record2.bdAddr.address, BTIF_BD_ADDR_SIZE);
            btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(bt_profile_manager[BT_DEVICE_ID_2].rmt_addr.address);

#if defined(A2DP_LHDC_ON)
            if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
                bt_profile_manager[BT_DEVICE_ID_2].stream = app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_2]->a2dp_stream;
            else
#endif
#if defined(A2DP_AAC_ON)
                if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_MPEG2_4_AAC)
                    bt_profile_manager[BT_DEVICE_ID_2].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_2]->a2dp_stream;
                else
#endif
#if defined(A2DP_SCALABLE_ON)
                    if(btdevice_plf_p->a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
                        bt_profile_manager[BT_DEVICE_ID_2].stream = app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_2]->a2dp_stream;
                    else
#endif
                    {
                        bt_profile_manager[BT_DEVICE_ID_2].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_2]->a2dp_stream;
                    }

            btif_a2dp_reset_stream_state(bt_profile_manager[BT_DEVICE_ID_2].stream);

            bt_profile_manager[BT_DEVICE_ID_2].chan = app_bt_device.hf_channel[BT_DEVICE_ID_2];
#if defined (__HSP_ENABLE__)
            bt_profile_manager[BT_DEVICE_ID_2].hs_chan = &app_bt_device.hs_channel[BT_DEVICE_ID_2];
#endif
        }
#endif
    }

    else
    {
        TRACE(0,"!!!go to pairing\n");
#ifdef __EARPHONE_STAY_BOTH_SCAN__
        app_bt_accessmode_set_req(BTIF_BT_DEFAULT_ACCESS_MODE_PAIR);
#else
        app_bt_accessmode_set_req(BTIF_BAM_CONNECTABLE_ONLY);
#endif

    }
    osapi_unlock_stack();
}


void app_bt_resume_sniff_mode(uint8_t deviceId)
{
    if (bt_profile_connect_status_success == bt_profile_manager[deviceId].a2dp_connect||
        bt_profile_connect_status_success == bt_profile_manager[deviceId].hfp_connect||
        bt_profile_connect_status_success == bt_profile_manager[deviceId].hsp_connect)
    {
        app_bt_allow_sniff(deviceId);
        btif_remote_device_t* currentRemDev = app_bt_get_remoteDev(deviceId);
        app_bt_sniff_config(currentRemDev);
    }
}
#if !defined(IBRT)
static int8_t app_bt_profile_reconnect_pending(enum BT_DEVICE_ID_T id)
{
    if(btapp_hfp_is_dev_call_active(id) == true)
    {
        bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_reconnect_pending;
        return 0;
    }
    return -1;
}
#endif
static int8_t app_bt_profile_reconnect_pending_process(void)
{
    uint8_t i =BT_DEVICE_NUM;

    btif_remote_device_t *remDev = NULL;
    btif_cmgr_handler_t    *cmgrHandler;


    for (i=0; i<BT_DEVICE_NUM; i++)
    {
        remDev = btif_me_enumerate_remote_devices(i);
        if (remDev != NULL)
        {
            cmgrHandler = btif_cmgr_get_acl_handler(remDev);
            if(btif_cmgr_is_audio_up(cmgrHandler) == 1)
                return -1;
        }
    }
    for(i = 0; i < BT_DEVICE_NUM; i++)
    {
        if(bt_profile_manager[i].reconnect_mode == bt_profile_reconnect_reconnect_pending)
            break;
    }

    if(i == BT_DEVICE_NUM)
        return -1;

    bt_profile_manager[i].reconnect_mode = bt_profile_reconnect_reconnecting;
#ifdef __IAG_BLE_INCLUDE__
    app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
#endif
    osTimerStart(bt_profile_manager[i].connect_timer, APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
    return 0;
}

uint8_t app_bt_get_num_of_connected_dev(void)
{
    uint8_t num_of_connected_dev = 0;
    uint8_t deviceId;

    for (deviceId = 0; deviceId < BT_DEVICE_NUM; deviceId++)
    {
        if (bt_profile_manager[deviceId].has_connected)
        {
            num_of_connected_dev++;
        }
    }

    return num_of_connected_dev;
}

static uint8_t recorded_latest_connected_service_device_id = BT_DEVICE_ID_1;
void app_bt_record_latest_connected_service_device_id(uint8_t device_id)
{
    recorded_latest_connected_service_device_id = device_id;
}

uint8_t app_bt_get_recorded_latest_connected_service_device_id(void)
{
    return recorded_latest_connected_service_device_id;
}


static void app_bt_precheck_before_starting_connecting(uint8_t isBtConnected)
{
#ifdef __IAG_BLE_INCLUDE__
    if (!isBtConnected)
    {
        app_ble_force_switch_adv(BLE_SWITCH_USER_BT_CONNECT, false);
    }
#endif
}

static void app_bt_restore_reconnecting_idle_mode(uint8_t deviceId)
{
    bt_profile_manager[deviceId].reconnect_mode = bt_profile_reconnect_null;
#ifdef __IAG_BLE_INCLUDE__
    app_start_fast_connectable_ble_adv(BLE_FAST_ADVERTISING_INTERVAL);
#endif
}

#ifdef __BT_ONE_BRING_TWO__
static void app_bt_update_connectable_mode_after_connection_management(void)
{
    uint8_t deviceId;
    bool isEnterConnetableOnlyState = true;
    for (deviceId = 0; deviceId < BT_DEVICE_NUM; deviceId++)
    {
        // assure none of the device is in reconnecting mode
        if (bt_profile_manager[deviceId].reconnect_mode != bt_profile_reconnect_null)
        {
            isEnterConnetableOnlyState = false;
            break;
        }
    }

    if (isEnterConnetableOnlyState)
    {
        for (deviceId = 0; deviceId < BT_DEVICE_NUM; deviceId++)
        {
            if (!bt_profile_manager[deviceId].has_connected)
            {
                app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                return;
            }
        }
    }
}
#endif

static void app_bt_connectable_mode_stop_reconnecting_handler(void)
{
    uint8_t deviceId;
    btif_remote_device_t*remDev;
    btif_cmgr_handler_t * cmgrHandler;
    for (deviceId = 0; deviceId < BT_DEVICE_NUM; deviceId++)
    {
        if (bt_profile_manager[deviceId].reconnect_mode != bt_profile_reconnect_null)
        {
            bt_profile_manager[deviceId].hfp_connect = bt_profile_connect_status_failure;
            bt_profile_manager[deviceId].reconnect_mode = bt_profile_reconnect_null;
            bt_profile_manager[deviceId].saved_reconnect_mode = bt_profile_reconnect_null;
            bt_profile_manager[deviceId].reconnect_cnt = 0;
            if(bt_profile_manager[deviceId].connect_timer !=NULL)
                osTimerStop(bt_profile_manager[deviceId].connect_timer);
            remDev = btif_me_enumerate_remote_devices(deviceId);
            if (remDev != NULL)
            {
                cmgrHandler = btif_cmgr_get_acl_handler(remDev);
                btif_me_cancel_create_link( btif_cmgr_get_cmgrhandler_remdev_bthandle(cmgrHandler),remDev);
            }
        }
    }
}

void app_bt_connectable_mode_stop_reconnecting(void)
{
    app_bt_start_custom_function_in_bt_thread(0, 0,
            (uint32_t)app_bt_connectable_mode_stop_reconnecting_handler);
}

#if defined (__HSP_ENABLE__)
void app_bt_profile_connect_manager_hs(enum BT_DEVICE_ID_T id, HsChannel *Chan, HsCallbackParms *Info)
{
    btdevice_profile *btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get((uint8_t *)Info->p.remDev->bdAddr.address);

    osTimerStop(bt_profile_manager[id].connect_timer);
    bt_profile_manager[id].connect_timer_cb = NULL;
    bool profile_reconnect_enable = false;

    if (Chan&&Info)
    {
        switch(Info->event)
        {
            case HF_EVENT_SERVICE_CONNECTED:
                TRACE(1,"%s HS_EVENT_SERVICE_CONNECTED",__func__);
                nv_record_btdevicerecord_set_hsp_profile_active_state(btdevice_plf_p, true);
#ifndef FPGA
                nv_record_touch_cause_flush();
#endif
                bt_profile_manager[id].hsp_connect = bt_profile_connect_status_success;
                bt_profile_manager[id].reconnect_cnt = 0;
                bt_profile_manager[id].hs_chan = &app_bt_device.hs_channel[id];
                memcpy(bt_profile_manager[id].rmt_addr.address, Info->p.remDev->bdAddr.address, BTIF_BD_ADDR_SIZE);
                if (false == bt_profile_manager[id].has_connected)
                {
                    app_bt_resume_sniff_mode(id);
                }
                if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    //do nothing
                }
                else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
                {
                    if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success)
                    {
                        TRACE(0,"!!!continue connect a2dp\n");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                        app_bt_A2DP_OpenStream(bt_profile_manager[id].stream, &bt_profile_manager[id].rmt_address);
                    }
                }
#ifdef __AUTO_CONNECT_OTHER_PROFILE__
                else
                {
                    if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success)
                    {
                        bt_profile_manager[id].connect_timer_cb = app_bt_profile_connect_a2dp_retry_timehandler;
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_CONNECT_RETRY_MS);
                    }
                }
#endif
                break;
            case HF_EVENT_SERVICE_DISCONNECTED:
                TRACE(2,"%s HS_EVENT_SERVICE_DISCONNECTED discReason:%d",__func__, Info->p.remDev->discReason);
                bt_profile_manager[id].hsp_connect = bt_profile_connect_status_failure;
                if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    if (++bt_profile_manager[id].reconnect_cnt < APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT)
                    {
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        profile_reconnect_enable = true;
                        bt_profile_manager[id].hfp_connect = bt_profile_connect_status_unknow;
                    }
                }
                else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
                {
                    if (++bt_profile_manager[id].reconnect_cnt < APP_BT_PROFILE_RECONNECT_RETRY_LIMIT_CNT)
                    {
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        profile_reconnect_enable = true
                    }
                    else
                    {
                        app_bt_restore_reconnecting_idle_mode(id);
                        //bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
                    }
                    TRACE(2,"%s try to reconnect cnt:%d",__func__, bt_profile_manager[id].reconnect_cnt);
#if !defined(IBRT)
                }
                else if(Info->p.remDev->discReason == 0x8)
                {
                    bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_reconnecting;
                    app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                    TRACE(1,"%s try to reconnect",__func__);
                    if(app_bt_profile_reconnect_pending(id) != 0)
                    {
                        profile_reconnect_enable = true;
                    }
#endif
                }
                else
                {
                    bt_profile_manager[id].hsp_connect = bt_profile_connect_status_unknow;
                }

                if (profile_reconnect_enable)
                {
#ifdef __IAG_BLE_INCLUDE__
                    app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
#endif
                    osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
                }
                break;
            default:
                break;
        }
    }

    if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
    {
        bool reconnect_hsp_proc_final = true;
        bool reconnect_a2dp_proc_final = true;
        if (bt_profile_manager[id].hsp_connect == bt_profile_connect_status_failure)
        {
            reconnect_hsp_proc_final = false;
        }
        if (bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_failure)
        {
            reconnect_a2dp_proc_final = false;
        }
        if (reconnect_hsp_proc_final && reconnect_a2dp_proc_final)
        {
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            app_bt_restore_reconnecting_idle_mode(id);
            // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
        }
    }
    else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
    {
        bool opening_hsp_proc_final = false;
        bool opening_a2dp_proc_final = false;

        if (btdevice_plf_p->hsp_act && bt_profile_manager[id].hsp_connect == bt_profile_connect_status_unknow)
        {
            opening_hsp_proc_final = false;
        }
        else
        {
            opening_hsp_proc_final = true;
        }

        if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_unknow)
        {
            opening_a2dp_proc_final = false;
        }
        else
        {
            opening_a2dp_proc_final = true;
        }

        if ((opening_hsp_proc_final && opening_a2dp_proc_final) ||
            (bt_profile_manager[id].hsp_connect == bt_profile_connect_status_failure))
        {
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            app_bt_restore_reconnecting_idle_mode(id);
            // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
        }

        if (btdevice_plf_p->hsp_act && bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success)
        {
            if (btdevice_plf_p->a2dp_act && !opening_a2dp_proc_final)
            {
                TRACE(0,"!!!continue connect a2dp\n");
                app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                app_bt_A2DP_OpenStream(bt_profile_manager[id].stream, &bt_profile_manager[id].rmt_addr);
            }
        }

        if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_null)
        {
            for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
            {
                if (bt_profile_manager[i].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    TRACE(0,"!!!hs->start reconnect second device\n");
                    if ((btdevice_plf_p->hfp_act)&&(!bt_profile_manager[i].hfp_connect))
                    {
                        TRACE(0,"try connect hf");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[i].has_connected);
                        app_bt_HF_CreateServiceLink(bt_profile_manager[i].chan, &bt_profile_manager[i].rmt_addr);
                    }
                    else if ((btdevice_plf_p->hsp_act)&&(!bt_profile_manager[i].hsp_connect))
                    {
                        TRACE(0,"try connect hs");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[i].has_connected);
                        app_bt_HS_CreateServiceLink(bt_profile_manager[i].hs_chan, &bt_profile_manager[i].rmt_addr);

                    }
                    else if((btdevice_plf_p->a2dp_act)&&(!bt_profile_manager[i].a2dp_connect))
                    {
                        TRACE(0,"try connect a2dp");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[i].has_connected);
                        app_bt_A2DP_OpenStream(bt_profile_manager[i].stream, &bt_profile_manager[i].rmt_addr);
                    }
                    break;
                }
            }
        }
    }

#ifdef  __IAG_BLE_INCLUDE__
    if (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success &&
        bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success&&
        bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success)
    {
        app_ble_force_switch_adv(BLE_SWITCH_USER_BT_CONNECT, true);
    }
#endif

    if (!bt_profile_manager[id].has_connected &&
        (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success ||
         bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success||
         bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success))
    {

        bt_profile_manager[id].has_connected = true;
        TRACE(0,"BT connected!!!");

#ifndef IBRT
        btif_me_get_remote_device_name(&(ctx->remote_dev_bdaddr), app_bt_global_handle);
#endif
#if defined(MEDIA_PLAYER_SUPPORT)&& !defined(IBRT)
        app_voice_report(APP_STATUS_INDICATION_CONNECTED, id);
#endif
#ifdef __INTERCONNECTION__
        app_interconnection_start_disappear_adv(INTERCONNECTION_BLE_ADVERTISING_INTERVAL,
                                                APP_INTERCONNECTION_DISAPPEAR_ADV_IN_MS);

        if (btif_me_get_activeCons() <= 2)
        {
            app_interconnection_spp_open(btif_me_enumerate_remote_devices(id));
        }
#endif
#ifdef __INTERACTION__
        // app_interaction_spp_open();
#endif
    }

    if (bt_profile_manager[id].has_connected &&
        (bt_profile_manager[id].hfp_connect != bt_profile_connect_status_success &&
         bt_profile_manager[id].hsp_connect != bt_profile_connect_status_success &&
         bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success))
    {

        bt_profile_manager[id].has_connected = false;
        TRACE(0,"BT disconnected!!!");

#ifdef GFPS_ENABLED
        if (app_gfps_is_last_response_pending())
        {
            app_gfps_enter_connectable_mode_req_handler(app_gfps_get_last_response());
        }
#endif

#if defined(MEDIA_PLAYER_SUPPORT)&& !defined(IBRT)
        app_voice_report(APP_STATUS_INDICATION_DISCONNECTED, id);
#endif
#ifdef __INTERCONNECTION__
        app_interconnection_disconnected_callback();
#endif

        app_set_disconnecting_all_bt_connections(false);
    }

#ifdef __BT_ONE_BRING_TWO__
    app_bt_update_connectable_mode_after_connection_management();
#endif
}
#endif

void hfp_reconnecting_timer_stop_callback(const btif_event_t *event)
{
    uint8_t i =0;
    uint8_t id =BT_DEVICE_NUM;
    bt_bdaddr_t *remote = NULL;
    bt_bdaddr_t *hfp_remote = NULL;
    remote = btif_me_get_callback_event_rem_dev_bd_addr(event);
    if(remote != NULL){
        for(i = 0; i<BT_DEVICE_NUM;i++){
            hfp_remote= &bt_profile_manager[i].rmt_addr;
            if(!strcmp((char*)hfp_remote,(char*)remote)){
                id=i;
                TRACE(2,"%s: find bt device num = %d",__func__,id);
                break;
            }
        }
    }
    if(i<BT_DEVICE_NUM){
        TRACE(3,"%s: hfp_connect=%d,reconnect_mode=%d,reconnect_cnt=%d",__func__,bt_profile_manager[id].hfp_connect,bt_profile_manager[id].reconnect_mode,bt_profile_manager[id].reconnect_cnt);
        if((bt_profile_manager[id].reconnect_mode != bt_profile_reconnect_null)&& bt_profile_manager[id].reconnect_cnt != 0){
            bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
            bt_profile_manager[id].saved_reconnect_mode = bt_profile_reconnect_null;
            bt_profile_manager[id].reconnect_cnt = 0;
            if(bt_profile_manager[id].connect_timer !=NULL)
                osTimerStop(bt_profile_manager[id].connect_timer);

            TRACE(1,"%s: stop success",__func__);
        }
    }
    else{
        TRACE(1,"%s: not find bt device",__func__);
    }
}

void app_audio_switch_flash_flush_req(void);

extern uint8_t once_event_case;
extern bool IsMobileLinkLossing;
//void app_bt_profile_connect_manager_hf(enum BT_DEVICE_ID_T id, HfChannel *Chan, HfCallbackParms *Info)
void app_bt_profile_connect_manager_hf(enum BT_DEVICE_ID_T id, hf_chan_handle_t Chan, struct hfp_context *ctx)
{
static ibrt_ctrl_t *p_ibrt_ctrl = app_ibrt_if_get_bt_ctrl_ctx();
    //btdevice_profile *btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get((uint8_t *)Info->p.remDev->bdAddr.address);
    btdevice_profile *btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get((uint8_t *)ctx->remote_dev_bdaddr.address);
    bool profile_reconnect_enable = false;

    osTimerStop(bt_profile_manager[id].connect_timer);
    bt_profile_manager[id].connect_timer_cb = NULL;
    //if (Chan&&Info){
    if (Chan)
    {
        switch(ctx->event)
        {
            case BTIF_HF_EVENT_SERVICE_CONNECTED:
                TRACE(1,"%s HF_EVENT_SERVICE_CONNECTED",__func__);
                nv_record_btdevicerecord_set_hfp_profile_active_state(btdevice_plf_p, true);
#ifndef FPGA
                nv_record_touch_cause_flush();
#endif
                bt_profile_manager[id].hfp_connect = bt_profile_connect_status_success;
                bt_profile_manager[id].saved_reconnect_mode =bt_profile_reconnect_null;
                bt_profile_manager[id].reconnect_cnt = 0;
                bt_profile_manager[id].chan = app_bt_device.hf_channel[id];
                memcpy(bt_profile_manager[id].rmt_addr.address, ctx->remote_dev_bdaddr.address, BTIF_BD_ADDR_SIZE);
                if (false == bt_profile_manager[id].has_connected)
                {
                    app_bt_resume_sniff_mode(id);
                }

#ifdef BTIF_DIP_DEVICE
                btif_dip_get_remote_info(app_bt_get_remoteDev(id));
#endif

                if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    //do nothing
                }
#if defined(IBRT)
                else if (app_bt_ibrt_reconnect_mobile_profile_flag_get())
                {
                    app_bt_ibrt_reconnect_mobile_profile_flag_clear();
#else
                else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
                {
#endif
                    TRACE(2,"app_bt: a2dp_act in NV =%d,a2dp_connect=%d",btdevice_plf_p->a2dp_act,bt_profile_manager[id].a2dp_connect);
                    if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success)
                    {
                        TRACE(0,"!!!continue connect a2dp\n");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                        app_bt_A2DP_OpenStream(bt_profile_manager[id].stream, &bt_profile_manager[id].rmt_addr);
                    }
                }
#ifdef __AUTO_CONNECT_OTHER_PROFILE__
                else
                {
                    //befor auto connect a2dp profile, check whether a2dp is supported
                    if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success)
                    {
                        bt_profile_manager[id].connect_timer_cb = app_bt_profile_connect_a2dp_retry_timehandler;
                        app_bt_accessmode_set(BAM_CONNECTABLE_ONLY);
                        osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_CONNECT_RETRY_MS);
                    }
                }
#endif
                break;
            case BTIF_HF_EVENT_SERVICE_DISCONNECTED:
		if(((ctx->disc_reason == 0)||(ctx->disc_reason == 19))&&(p_ibrt_ctrl->current_role != IBRT_SLAVE))
		{
			once_event_case = 2;
			startonce_delay_event_Timer_(1000);
		}
                //TRACE(3,"%s HF_EVENT_SERVICE_DISCONNECTED discReason:%d/%d",__func__, Info->p.remDev->discReason, Info->p.remDev->discReason_saved);
                TRACE(3,"%s HF_EVENT_SERVICE_DISCONNECTED discReason:%d/%d",__func__, ctx->disc_reason, ctx->disc_reason_saved);
                bt_profile_manager[id].hfp_connect = bt_profile_connect_status_failure;
                if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    if (++bt_profile_manager[id].reconnect_cnt < APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT)
                    {
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        profile_reconnect_enable = true;
                        bt_profile_manager[id].hfp_connect = bt_profile_connect_status_unknow;
                    }
                }
                else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
                {
                    if (++bt_profile_manager[id].reconnect_cnt < APP_BT_PROFILE_RECONNECT_RETRY_LIMIT_CNT)
                    {
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        profile_reconnect_enable = true;
                    }
                    else
                    {
                        app_bt_restore_reconnecting_idle_mode(id);
                        // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
                    }
                    TRACE(2,"%s try to reconnect cnt:%d",__func__, bt_profile_manager[id].reconnect_cnt);
                    /*
                    }else if ((Info->p.remDev->discReason == 0x8)||
                          (Info->p.remDev->discReason_saved == 0x8)){
                          */
                }
#if !defined(IBRT)
#if defined(ENHANCED_STACK)
                else if ((ctx->disc_reason == 0x8)||
                         (ctx->disc_reason_saved == 0x8) ||
                         (ctx->disc_reason == 0x4)||
                         (ctx->disc_reason_saved == 0x4))
#else
                else if ((ctx->disc_reason == 0x8)||
                         (ctx->disc_reason_saved == 0x8) ||
                         (ctx->disc_reason == 0x0)||
                         (ctx->disc_reason_saved == 0x0))
#endif
                {
                    bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_reconnecting;
                    app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                    TRACE(2,"%s try to reconnect reason =%d",__func__,ctx->disc_reason);
                    if(app_bt_profile_reconnect_pending(id) != 0)
                    {
                        profile_reconnect_enable = true;
                    }
                }
#endif
                else
                {
                    bt_profile_manager[id].hfp_connect = bt_profile_connect_status_unknow;
                }

                if (profile_reconnect_enable)
                {
#ifdef  __IAG_BLE_INCLUDE__
                    app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
#endif
                    osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
                }
                break;
            default:
                break;
        }
    }
    DUMP8("%02x ", &bt_profile_manager[id].rmt_addr.address, 6);
    btdevice_profile *btdevice_plf_p1 = (btdevice_profile *)app_bt_profile_active_store_ptr_get((uint8_t *)&bt_profile_manager[id].rmt_addr.address);

    if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
    {
        bool reconnect_hfp_proc_final = false;
        bool reconnect_a2dp_proc_final = false;

        if (bt_profile_manager[id].hfp_connect != bt_profile_connect_status_success)
        {
            reconnect_hfp_proc_final = false;
        }
        else
        {
            reconnect_hfp_proc_final = true;
        }
        if (bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success)
        {
            if(btdevice_plf_p1->hfp_act && btdevice_plf_p1->a2dp_act)
            {
                reconnect_a2dp_proc_final = false;
            }
            else
            {
                reconnect_a2dp_proc_final = true;
            }
        }
        if (reconnect_hfp_proc_final && reconnect_a2dp_proc_final)
        {
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            app_bt_restore_reconnecting_idle_mode(id);
            // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
        }
    }
    else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
    {
        bool opening_hfp_proc_final = false;
        bool opening_a2dp_proc_final = false;

        if (btdevice_plf_p1->hfp_act && bt_profile_manager[id].hfp_connect == bt_profile_connect_status_unknow)
        {
            opening_hfp_proc_final = false;
        }
        else
        {
            opening_hfp_proc_final = true;
        }

        if (btdevice_plf_p1->a2dp_act && bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_unknow)
        {
            opening_a2dp_proc_final = false;
        }
        else
        {
            opening_a2dp_proc_final = true;
        }

        if(opening_hfp_proc_final && opening_a2dp_proc_final)
        {
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            bt_profile_manager[id].saved_reconnect_mode =  bt_profile_reconnect_openreconnecting;
            app_bt_restore_reconnecting_idle_mode(id);
        }
        else if(bt_profile_manager[id].hfp_connect == bt_profile_connect_status_failure)
        {
            TRACE(3,"reconnect_mode888:%d",bt_profile_manager[0].reconnect_mode);
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            bt_profile_manager[id].saved_reconnect_mode =  bt_profile_reconnect_openreconnecting;
            if ((bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                &&(bt_profile_manager[id].reconnect_cnt >= APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT))
            {
                app_bt_restore_reconnecting_idle_mode(id);
            }
        }

        if (btdevice_plf_p1->hfp_act && bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success)
        {
            if (btdevice_plf_p1->a2dp_act && !opening_a2dp_proc_final)
            {
                TRACE(1,"!!!continue connect a2dp %p\n", bt_profile_manager[id].stream);
                app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                app_bt_A2DP_OpenStream(bt_profile_manager[id].stream, &bt_profile_manager[id].rmt_addr);
            }
        }

        if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_null)
        {
            for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
            {
                btdevice_profile *btdevice_plf_p_temp = (btdevice_profile *)app_bt_profile_active_store_ptr_get((uint8_t *)bt_profile_manager[i].rmt_addr.address);
                TRACE(3,"reconnect_mode:%d",bt_profile_manager[i].reconnect_mode);
                if (bt_profile_manager[i].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    TRACE(0,"!!!hf->start reconnect second device\n");
                    if ((btdevice_plf_p_temp->hfp_act)&&(!bt_profile_manager[i].hfp_connect))
                    {
                        TRACE(0,"try connect hf");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                        app_bt_HF_CreateServiceLink(bt_profile_manager[i].chan, (bt_bdaddr_t *)&bt_profile_manager[i].rmt_addr);
                    }
#if defined (__HSP_ENABLE__)
                    else if((btdevice_plf_p_temp->hsp_act)&&(!bt_profile_manager[i].hsp_connect))
                    {
                        TRACE(0,"try connect hs");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                        app_bt_HS_CreateServiceLink(bt_profile_manager[i].hs_chan, &bt_profile_manager[i].rmt_addr);
                    }
#endif
                    else if((btdevice_plf_p_temp->a2dp_act)&&(!bt_profile_manager[i].a2dp_connect))
                    {
                        TRACE(0,"try connect a2dp");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                        app_bt_A2DP_OpenStream(bt_profile_manager[i].stream, &bt_profile_manager[i].rmt_addr);
                    }
                    break;
                }
            }
        }
    }
#ifdef __INTERCONNECTION__
    if (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success &&
        bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success)
    {
        app_interconnection_start_disappear_adv(INTERCONNECTION_BLE_ADVERTISING_INTERVAL,
                                                APP_INTERCONNECTION_DISAPPEAR_ADV_IN_MS);

        if (btif_me_get_activeCons() <= 2)
        {
            app_interconnection_spp_open(btif_me_enumerate_remote_devices(id));
        }
    }
#endif

#ifdef  __IAG_BLE_INCLUDE__
    TRACE(3, "%s hfp %d a2dp %d", __func__, bt_profile_manager[id].hfp_connect, bt_profile_manager[id].a2dp_connect);
    if (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success &&
#ifdef __HSP_ENABLE__
        bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success&&
#endif
        bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success)
    {
        app_ble_force_switch_adv(BLE_SWITCH_USER_BT_CONNECT, true);
    }
#endif

    if (!bt_profile_manager[id].has_connected &&
        (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success ||
#ifdef __HSP_ENABLE__
         bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success||
#endif
         bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success))
    {

        bt_profile_manager[id].has_connected = true;
        TRACE(0,"BT connected!!!");
	once_event_case = 1;
	/*if(IsMobileLinkLossing){
            startonce_delay_event_Timer_(3000);
	}
        else{
            startonce_delay_event_Timer_(1500);
        }*/
		app_voice_report(APP_STATUS_INDICATION_CONNECTED,0);
        IsMobileLinkLossing = FALSE;
#ifndef IBRT
        btif_me_get_remote_device_name(&(ctx->remote_dev_bdaddr), app_bt_global_handle);
#endif
#if defined(MEDIA_PLAYER_SUPPORT)&& !defined(IBRT)
        app_voice_report(APP_STATUS_INDICATION_CONNECTED, id);
#endif

#if 0 // #ifdef __INTERCONNECTION__
        app_interconnection_start_disappear_adv(BLE_ADVERTISING_INTERVAL, APP_INTERCONNECTION_DISAPPEAR_ADV_IN_MS);
        app_interconnection_spp_open();
#endif

#ifdef __INTERACTION__
        //    app_interaction_spp_open();
#endif
    }

    if (bt_profile_manager[id].has_connected &&
        (bt_profile_manager[id].hfp_connect != bt_profile_connect_status_success &&
#ifdef __HSP_ENABLE__
         bt_profile_manager[id].hsp_connect != bt_profile_connect_status_success &&
#endif
         bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success))
    {

        bt_profile_manager[id].has_connected = false;
        TRACE(0,"BT disconnected!!!");

#ifdef GFPS_ENABLED
        if (app_gfps_is_last_response_pending())
        {
            app_gfps_enter_connectable_mode_req_handler(app_gfps_get_last_response());
        }
#endif

#if defined(MEDIA_PLAYER_SUPPORT)&& !defined(IBRT)
        app_voice_report(APP_STATUS_INDICATION_DISCONNECTED, id);
#endif
#ifdef __INTERCONNECTION__
        app_interconnection_disconnected_callback();
#endif

        app_set_disconnecting_all_bt_connections(false);
    }

#ifdef __BT_ONE_BRING_TWO__
    app_bt_update_connectable_mode_after_connection_management();
#endif
}

void app_bt_profile_connect_manager_a2dp(enum BT_DEVICE_ID_T id, a2dp_stream_t *Stream, const   a2dp_callback_parms_t *info)
{
    btdevice_profile *btdevice_plf_p = NULL;
    btif_remote_device_t *remDev = NULL;
    btif_a2dp_callback_parms_t* Info = (btif_a2dp_callback_parms_t*)info;
    osTimerStop(bt_profile_manager[id].connect_timer);
    bt_profile_manager[id].connect_timer_cb = NULL;
    bool profile_reconnect_enable = false;

    remDev = btif_a2dp_get_stream_conn_remDev(Stream);
    if (remDev)
    {
        btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(btif_me_get_remote_device_bdaddr(remDev)->address);
    }
    else
    {
        btdevice_plf_p = (btdevice_profile *)app_bt_profile_active_store_ptr_get(NULL);
    }

    if (Stream&&Info)
    {

        switch(Info->event)
        {
            case BTIF_A2DP_EVENT_STREAM_OPEN:
                TRACE(4,"%s A2DP_EVENT_STREAM_OPEN,codec type=%x a2dp:%d mode:%d",
                      __func__, Info->p.configReq->codec.codecType,
                      bt_profile_manager[id].a2dp_connect,
                      bt_profile_manager[id].reconnect_mode);

                nv_record_btdevicerecord_set_a2dp_profile_active_state(btdevice_plf_p, true);
                nv_record_btdevicerecord_set_a2dp_profile_codec(btdevice_plf_p, Info->p.configReq->codec.codecType);
#ifndef FPGA
                nv_record_touch_cause_flush();
#endif
                if(bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success)
                {
                    TRACE(0,"!!!a2dp has opened   force return ");
                    return;
                }
                bt_profile_manager[id].a2dp_connect = bt_profile_connect_status_success;
                bt_profile_manager[id].reconnect_cnt = 0;
                bt_profile_manager[id].stream = app_bt_device.a2dp_connected_stream[id];
                memcpy(bt_profile_manager[id].rmt_addr.address,  btif_me_get_remote_device_bdaddr(btif_a2dp_get_stream_conn_remDev(Stream))->address, BTIF_BD_ADDR_SIZE);
                app_bt_record_latest_connected_service_device_id(id);
                if (false == bt_profile_manager[id].has_connected)
                {
                    app_bt_resume_sniff_mode(id);
                }

#ifdef BTIF_DIP_DEVICE
                btif_dip_get_remote_info(remDev);
#endif

                if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    //do nothing
                }

#if defined(IBRT)
                else if (app_bt_ibrt_reconnect_mobile_profile_flag_get())
                {
                    app_bt_ibrt_reconnect_mobile_profile_flag_clear();
#else
                else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
                {
#endif
                    TRACE(2,"app_bt: hfp_act in NV =%d,a2dp_connect=%d",btdevice_plf_p->hfp_act,bt_profile_manager[id].hfp_connect);
                    if (btdevice_plf_p->hfp_act&& bt_profile_manager[id].hfp_connect != bt_profile_connect_status_success)
                    {
                        if (btif_hf_check_rfcomm_l2cap_channel_is_creating(&bt_profile_manager[id].rmt_addr))
                        {
                            TRACE(0,"!!!remote is creating hfp after a2dp connected\n");
                        }
                        else
                        {
                            TRACE(0,"!!!continue connect hfp\n");
                            app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                            app_bt_HF_CreateServiceLink(bt_profile_manager[id].chan, (bt_bdaddr_t *)&bt_profile_manager[id].rmt_addr);
                        }
                    }
#if defined (__HSP_ENABLE__)
                    else if(btdevice_plf_p->hsp_act&& bt_profile_manager[id].hsp_connect != bt_profile_connect_status_success)
                    {
                        TRACE(0,"!!!continue connect hsp\n");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                        app_bt_HS_CreateServiceLink(bt_profile_manager[id].hs_chan, &bt_profile_manager[id].rmt_addr);
                    }
#endif
                }
#ifdef __AUTO_CONNECT_OTHER_PROFILE__
                else
                {
                    if(btdevice_plf_p->hfp_act && bt_profile_manager[id].hfp_connect != bt_profile_connect_status_success)
                    {
                        bt_profile_manager[id].connect_timer_cb = app_bt_profile_connect_hf_retry_timehandler;
                        app_bt_accessmode_set(BAM_CONNECTABLE_ONLY);
                        osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_CONNECT_RETRY_MS);
                    }
#if defined (__HSP_ENABLE__)
                    else if(btdevice_plf_p->hsp_act && bt_profile_manager[id].hsp_connect != bt_profile_connect_status_success)
                    {
                        bt_profile_manager[id].connect_timer_cb = app_bt_profile_connect_hs_retry_timehandler;
                        app_bt_accessmode_set(BAM_CONNECTABLE_ONLY);
                        osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_CONNECT_RETRY_MS);
                    }
#endif
                }
#endif
#ifdef APP_DISABLE_PAGE_SCAN_AFTER_CONN
                disable_page_scan_check_timer_start();
#endif
                break;
            case BTIF_A2DP_EVENT_STREAM_CLOSED:

                TRACE(2,"%s A2DP_EVENT_STREAM_CLOSED discReason1:%d",__func__, Info->discReason);

                if(Info->subevt != A2DP_CONN_CLOSED)
                {
                    TRACE(0,"do not need set access mode");
                    return ;
                }

                if(Stream!=NULL)
                {
                    if(btif_a2dp_get_remote_device(Stream)!=NULL)
                        TRACE(2,"%s A2DP_EVENT_STREAM_CLOSED discReason2:%d",__func__,btif_me_get_remote_device_disc_reason_saved(btif_a2dp_get_remote_device(Stream)));
                }

#if defined(IBRT)
                if (app_bt_ibrt_reconnect_mobile_profile_flag_get())
                {
                    app_bt_HF_CreateServiceLink(bt_profile_manager[id].chan, (bt_bdaddr_t *)&bt_profile_manager[id].rmt_addr);
                }
#endif

                bt_profile_manager[id].a2dp_connect = bt_profile_connect_status_failure;

                if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    if (++bt_profile_manager[id].reconnect_cnt < APP_BT_PROFILE_OPENNING_RECONNECT_RETRY_LIMIT_CNT)
                    {
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        profile_reconnect_enable = true;
                        bt_profile_manager[id].a2dp_connect = bt_profile_connect_status_unknow;
                    }
                }
                else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
                {
                    if (++bt_profile_manager[id].reconnect_cnt < APP_BT_PROFILE_RECONNECT_RETRY_LIMIT_CNT)
                    {
                        app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                        profile_reconnect_enable = true;
                    }
                    else
                    {
                        app_bt_restore_reconnecting_idle_mode(id);
                        // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
                    }
                    TRACE(2,"%s try to reconnect cnt:%d",__func__, bt_profile_manager[id].reconnect_cnt);
                }
#if !defined(IBRT)
#if defined(ENHANCED_STACK)
                else if(((Info->discReason == 0x08)||
                         (Info->discReason == 0x04)) &&
#else
                else if(((Info->discReason == 0x8)||
                         (Info->discReason_saved == 0x8)||
                         (Info->discReason_saved == 0x0)) &&
#endif
                        (btdevice_plf_p->a2dp_act)&&
                        (!btdevice_plf_p->hfp_act) &&
                        (!btdevice_plf_p->hsp_act))
                {
                    bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_reconnecting;
                    TRACE(2,"%s try to reconnect cnt:%d",__func__, bt_profile_manager[id].reconnect_cnt);
                    app_bt_accessmode_set(BTIF_BAM_CONNECTABLE_ONLY);
                    if(app_bt_profile_reconnect_pending(id) != 0)
                    {
                        profile_reconnect_enable = true;
                    }
                }
#endif
                else
                {
                    bt_profile_manager[id].a2dp_connect = bt_profile_connect_status_unknow;
                }

                if (profile_reconnect_enable)
                {
#ifdef __IAG_BLE_INCLUDE__
                    app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
#endif
                    osTimerStart(bt_profile_manager[id].connect_timer, APP_BT_PROFILE_RECONNECT_RETRY_INTERVAL_MS);
                }
                break;
            default:
                break;
        }
    }

    if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_reconnecting)
    {
        bool reconnect_hfp_proc_final = true;
        bool reconnect_a2dp_proc_final = true;
        if (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_failure)
        {
            reconnect_hfp_proc_final = false;
        }
#if defined (__HSP_ENABLE__)
        if(btdevice_plf_p->hsp_act !=0)     //has HSP
        {
            reconnect_hfp_proc_final = true;
            if (bt_profile_manager[id].hsp_connect == bt_profile_connect_status_failure)
            {
                reconnect_hfp_proc_final = false;
            }
        }
#endif
        if (bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_failure)
        {
            reconnect_a2dp_proc_final = false;
        }
        if (reconnect_hfp_proc_final && reconnect_a2dp_proc_final)
        {
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            app_bt_restore_reconnecting_idle_mode(id);
            // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
        }
    }
    else if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_openreconnecting)
    {
        bool opening_hfp_proc_final = false;
        bool opening_a2dp_proc_final = false;

        if (btdevice_plf_p->hfp_act && bt_profile_manager[id].hfp_connect == bt_profile_connect_status_unknow)
        {
            opening_hfp_proc_final = false;
        }
        else
        {
            opening_hfp_proc_final = true;
        }

        if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_unknow)
        {
            opening_a2dp_proc_final = false;
        }
        else
        {
            opening_a2dp_proc_final = true;
        }

        if ((opening_hfp_proc_final && opening_a2dp_proc_final) ||
            (bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_failure))
        {
            TRACE(3,"!!!reconnect success %d/%d/%d\n", bt_profile_manager[id].hfp_connect, bt_profile_manager[id].hsp_connect, bt_profile_manager[id].a2dp_connect);
            app_bt_restore_reconnecting_idle_mode(id);
            // bt_profile_manager[id].reconnect_mode = bt_profile_reconnect_null;
        }

        if (btdevice_plf_p->a2dp_act && bt_profile_manager[id].a2dp_connect== bt_profile_connect_status_success)
        {
            if (btdevice_plf_p->hfp_act && !opening_hfp_proc_final)
            {
                if (btif_hf_check_rfcomm_l2cap_channel_is_creating(&bt_profile_manager[id].rmt_addr))
                {
                    TRACE(0,"!!!remote is creating hf after a2dp connected\n");
                }
                else
                {
                    TRACE(0,"!!!continue connect hf\n");
                    app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                    app_bt_HF_CreateServiceLink(bt_profile_manager[id].chan, (bt_bdaddr_t *)&bt_profile_manager[id].rmt_addr);
                }
            }
#if defined (__HSP_ENABLE)
            else if(btdevice_plf_p->hsp_act && !opening_hfp_hsp_proc_final)
            {
                TRACE(0,"!!!continue connect hs\n");
                app_bt_precheck_before_starting_connecting(bt_profile_manager[id].has_connected);
                app_bt_HS_CreateServiceLink(bt_profile_manager[id].hs_chan, &bt_profile_manager[id].rmt_addr);
            }
#endif
        }

        if (bt_profile_manager[id].reconnect_mode == bt_profile_reconnect_null)
        {
            for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
            {
                if (bt_profile_manager[i].reconnect_mode == bt_profile_reconnect_openreconnecting)
                {
                    TRACE(1,"!!!a2dp->start reconnect device %d\n", i);
                    if ((btdevice_plf_p->hfp_act)&&(!bt_profile_manager[i].hfp_connect))
                    {
                        TRACE(0,"try connect hf");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[i].has_connected);
                        app_bt_HF_CreateServiceLink(bt_profile_manager[i].chan, (bt_bdaddr_t *)&bt_profile_manager[i].rmt_addr);
                    }
#if defined (__HSP_ENABLE__)
                    else if((btdevice_plf_p->hsp_act)&&(!bt_profile_manager[i].hsp_connect))
                    {
                        TRACE(0,"try connect hs");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[i].has_connected);
                        app_bt_HS_CreateServiceLink(bt_profile_manager[i].hs_chan, &bt_profile_manager[i].rmt_addr);
                    }
#endif
                    else if((btdevice_plf_p->a2dp_act)&&(!bt_profile_manager[i].a2dp_connect))
                    {
                        TRACE(0,"try connect a2dp");
                        app_bt_precheck_before_starting_connecting(bt_profile_manager[i].has_connected);
                        app_bt_A2DP_OpenStream(bt_profile_manager[i].stream, &bt_profile_manager[i].rmt_addr);
                    }
                    break;
                }
            }
        }
    }

#ifdef __INTERCONNECTION__
    if (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success &&
        bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success)
    {
        app_interconnection_start_disappear_adv(INTERCONNECTION_BLE_ADVERTISING_INTERVAL,
                                                APP_INTERCONNECTION_DISAPPEAR_ADV_IN_MS);

        if (btif_me_get_activeCons() <= 2)
        {
            app_interconnection_spp_open(remDev);
        }
    }
#endif

#ifdef  __IAG_BLE_INCLUDE__
    TRACE(3, "%s hfp %d a2dp %d", __func__, bt_profile_manager[id].hfp_connect, bt_profile_manager[id].a2dp_connect);
    if (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success &&
#ifdef __HSP_ENABLE__
        bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success &&
#endif
        bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success)
    {
        app_ble_force_switch_adv(BLE_SWITCH_USER_BT_CONNECT, true);
    }
#endif

    if (!bt_profile_manager[id].has_connected &&
        (bt_profile_manager[id].hfp_connect == bt_profile_connect_status_success ||
#ifdef __HSP_ENABLE__
         bt_profile_manager[id].hsp_connect == bt_profile_connect_status_success||
#endif
         bt_profile_manager[id].a2dp_connect == bt_profile_connect_status_success))
    {

        bt_profile_manager[id].has_connected = true;
        TRACE(0,"BT connected!!!");
	IsMobileLinkLossing = FALSE;
#ifndef IBRT
        btif_me_get_remote_device_name(&(bt_profile_manager[id].rmt_addr), app_bt_global_handle);
#endif
#if defined(MEDIA_PLAYER_SUPPORT)//&& !defined(IBRT)
        app_voice_report(APP_STATUS_INDICATION_CONNECTED, id);
#endif

#if 0 // #ifdef __INTERCONNECTION__
        app_interconnection_start_disappear_adv(BLE_ADVERTISING_INTERVAL, APP_INTERCONNECTION_DISAPPEAR_ADV_IN_MS);
        app_interconnection_spp_open();
#endif

#ifdef __INTERACTION__
        //    app_interaction_spp_open();
#endif
    }

    if (bt_profile_manager[id].has_connected &&
        (bt_profile_manager[id].hfp_connect != bt_profile_connect_status_success &&
#ifdef __HSP_ENABLE__
         bt_profile_manager[id].hsp_connect != bt_profile_connect_status_success &&
#endif
         bt_profile_manager[id].a2dp_connect != bt_profile_connect_status_success))
    {

        bt_profile_manager[id].has_connected = false;
        TRACE(0,"BT disconnected!!!");

#ifdef GFPS_ENABLED
        if (app_gfps_is_last_response_pending())
        {
            app_gfps_enter_connectable_mode_req_handler(app_gfps_get_last_response());
        }
#endif

#if defined(MEDIA_PLAYER_SUPPORT)&& !defined(IBRT)
        app_voice_report(APP_STATUS_INDICATION_DISCONNECTED, id);
#endif
#ifdef __INTERCONNECTION__
        app_interconnection_disconnected_callback();
#endif

        app_set_disconnecting_all_bt_connections(false);
    }

#ifdef __BT_ONE_BRING_TWO__
    app_bt_update_connectable_mode_after_connection_management();
#endif
}

#ifdef BTIF_HID_DEVICE
void hid_exit_shutter_mode(void);
#endif

static bool isDisconnectAllBtConnections = false;

bool app_is_disconnecting_all_bt_connections(void)
{
    return isDisconnectAllBtConnections;
}

void app_set_disconnecting_all_bt_connections(bool isEnable)
{
    isDisconnectAllBtConnections = isEnable;
}

bt_status_t LinkDisconnectDirectly(bool PowerOffFlag)
{
    app_set_disconnecting_all_bt_connections(true);
    //TRACE(1,"osapi_lock_is_exist:%d",osapi_lock_is_exist());
    if(osapi_lock_is_exist())
        osapi_lock_stack();
#ifdef __IAG_BLE_INCLUDE__
    TRACE(1,"ble_connected_state:%d", app_ble_is_any_connection_exist());
#endif

#if defined(IBRT)
    ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();
    if(true==PowerOffFlag)
        p_ibrt_ctrl->ibrt_in_poweroff= true;

    if (p_ibrt_ctrl->init_done)
    {
        if(IBRT_MASTER==p_ibrt_ctrl->current_role)
        {
            if(app_tws_ibrt_mobile_link_connected())
            {
                //should check return status
                app_tws_ibrt_disconnect_connection(btif_me_get_remote_device_by_handle(p_ibrt_ctrl->mobile_conhandle));
            }
        }
        if (app_tws_ibrt_tws_link_connected())
        {
            app_tws_ibrt_disconnect_connection(btif_me_get_remote_device_by_handle(p_ibrt_ctrl->tws_conhandle));
        }
    }

    if(osapi_lock_is_exist())
        osapi_unlock_stack();

    osDelay(500);

    return BT_STS_SUCCESS;
#endif

    TRACE(1,"activeCons:%d", btif_me_get_activeCons());

    uint8_t Tmp_activeCons = btif_me_get_activeCons();

    if(Tmp_activeCons)
    {
        //TRACE(3,"%s id1 hf:%d a2dp:%d",__func__, app_bt_device.hf_channel[BT_DEVICE_ID_1].state, btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream));
        TRACE(3,"%s id1 hf:%d a2dp:%d",__func__,  btif_get_hf_chan_state(app_bt_device.hf_channel[BT_DEVICE_ID_1]), btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream));
#ifdef BTIF_HID_DEVICE
        hid_exit_shutter_mode();
#endif
        if (btif_get_hf_chan_state(app_bt_device.hf_channel[BT_DEVICE_ID_1]) == BTIF_HF_STATE_OPEN)
        {
            app_bt_HF_DisconnectServiceLink(app_bt_device.hf_channel[BT_DEVICE_ID_1]);
        }
#if defined (__HSP_ENABLE__)
        if(app_bt_device.hs_channel[BT_DEVICE_ID_1].state == HS_STATE_OPEN)
        {
            app_bt_HS_DisconnectServiceLink(&app_bt_device.hs_channel[BT_DEVICE_ID_1]);
        }
#endif   //btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[device_id]->a2dp_stream)
        if(btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream);
        }
#if defined(A2DP_LHDC_ON)
        if(btif_a2dp_get_stream_state(app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream);
        }
#endif
#if defined(A2DP_LDAC_ON)
        if(btif_a2dp_get_stream_state(app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream);
        }
#endif

#if defined(A2DP_AAC_ON)
        if(btif_a2dp_get_stream_state( app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state( app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream);
        }
#endif
#if defined(A2DP_SCALABLE_ON)
        if(btif_a2dp_get_stream_state( app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream);
        }
#endif
        if( btif_avrcp_get_remote_device(app_bt_device.avrcp_channel[BT_DEVICE_ID_1]->avrcp_channel_handle))
        {
            btif_avrcp_disconnect(app_bt_device.avrcp_channel[BT_DEVICE_ID_1]->avrcp_channel_handle);
        }
#ifdef __BT_ONE_BRING_TWO__
        TRACE(3,"%s id2 hf:%d a2dp:%d",__func__, btif_get_hf_chan_state(app_bt_device.hf_channel[BT_DEVICE_ID_2]), btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_2]->a2dp_stream));
        //if(app_bt_device.hf_channel[BT_DEVICE_ID_2].state == HF_STATE_OPEN){
        if(btif_get_hf_chan_state(app_bt_device.hf_channel[BT_DEVICE_ID_2]) == BTIF_HF_STATE_OPEN)
        {
            app_bt_HF_DisconnectServiceLink(app_bt_device.hf_channel[BT_DEVICE_ID_2]);
        }

#if defined (__HSP_ENABLE__)
        if(app_bt_device.hs_channel[BT_DEVICE_ID_2].state == HS_STATE_OPEN)
        {
            app_bt_HS_DisconnectServiceLink(&app_bt_device.hs_channel[BT_DEVICE_ID_2]);
        }
#endif // __HSP_ENABLE__

        if( btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_2]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
            btif_a2dp_get_stream_state(app_bt_device.a2dp_stream[BT_DEVICE_ID_2]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_stream[BT_DEVICE_ID_2]->a2dp_stream);
        }
#if defined(A2DP_LHDC_ON)
        if(btif_a2dp_get_stream_state(app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_2]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_2]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_2]->a2dp_stream);
        }
#endif // A2DP_LHDC_ON
#if defined(A2DP_AAC_ON)
        if(btif_a2dp_get_stream_state(app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_2]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_2]->a2dp_stream)== BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_2]->a2dp_stream);
        }
#endif // A2DP_AAC_ON
#if defined(A2DP_SCALABLE_ON)
        if(btif_a2dp_get_stream_state(app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_2]->a2dp_stream)== BTIF_AVDTP_STRM_STATE_STREAMING ||
           btif_a2dp_get_stream_state(app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_2]->a2dp_stream) == BTIF_AVDTP_STRM_STATE_OPEN)
        {
            app_bt_A2DP_CloseStream(app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_2]->a2dp_stream);
        }
#endif // A2DP_SCALABLE_ON
        if( btif_avrcp_get_remote_device(app_bt_device.avrcp_channel[BT_DEVICE_ID_2]->avrcp_channel_handle))
        {
            btif_avrcp_disconnect(app_bt_device.avrcp_channel[BT_DEVICE_ID_2]->avrcp_channel_handle);
        }
#endif //__BT_ONE_BRING_TWO__

#ifdef BISTO_ENABLED
        gsound_custom_bt_disconnect_all_channel();
#endif
    }

#ifdef __IAG_BLE_INCLUDE__
    if(app_ble_is_any_connection_exist())
    {
#ifdef GFPS_ENABLED
        if (!app_gfps_is_last_response_pending())
#endif
            app_ble_disconnect_all();
    }
#endif

    if(osapi_lock_is_exist())
        osapi_unlock_stack();

    osDelay(500);

    if(Tmp_activeCons)
    {
        btif_remote_device_t* remDev = app_bt_get_remoteDev(BT_DEVICE_ID_1);
        if (NULL != remDev)
        {
            app_bt_MeDisconnectLink(remDev);
        }

#ifdef __BT_ONE_BRING_TWO__
        remDev = app_bt_get_remoteDev(BT_DEVICE_ID_2);
        if (NULL != remDev)
        {
            osDelay(200);
            app_bt_MeDisconnectLink(remDev);
        }
#endif
    }
    return BT_STS_SUCCESS;
}

void app_disconnect_all_bt_connections(void)
{
    LinkDisconnectDirectly(false);
}

static int app_custom_function_process(APP_MESSAGE_BODY *msg_body)
{
    APP_APPTHREAD_REQ_CUSTOMER_CALL_FN_T customer_call = (APP_APPTHREAD_REQ_CUSTOMER_CALL_FN_T)(msg_body->message_ptr);
    TRACE(4, "func:0x%08x,param0:0x%08x, param1:0x%08x",
                                                       msg_body->message_ptr,
                                                       msg_body->message_Param0,
                                                       msg_body->message_Param1);
    if (customer_call){
        customer_call((void *)msg_body->message_Param0, (void *)msg_body->message_Param1);
    }
    return 0;
}

int app_bt_start_custom_function_in_app_thread(
                                    uint32_t param0, uint32_t param1, uint32_t funcPtr)
{
    APP_MESSAGE_BLOCK msg;

    msg.mod_id = APP_MODUAL_CUSTOM_FUNCTION;
    msg.msg_body.message_id = 0;
    msg.msg_body.message_ptr = funcPtr;
    msg.msg_body.message_Param0 = param0;
    msg.msg_body.message_Param1 = param1;

    app_mailbox_put(&msg);
    return 0;
}

void app_bt_init(void)
{
    app_bt_mail_init();
    app_set_threadhandle(APP_MODUAL_BT, app_bt_handle_process);
    btif_me_sec_set_io_cap_rsp_reject_ext(app_bt_profile_connect_openreconnecting);
    app_bt_active_mode_manager_init();
    app_set_threadhandle(APP_MODUAL_CUSTOM_FUNCTION, app_custom_function_process);
}

extern "C" bool app_bt_has_connectivitys(void)
{
    int activeCons;
    osapi_lock_stack();
    activeCons = btif_me_get_activeCons();
    osapi_unlock_stack();

    if(activeCons > 0)
        return true;

    return false;
#if 0
    if(app_bt_device.hf_channel[BT_DEVICE_ID_1].cmgrHandler.remDev)
        return true;
    if(app_bt_device.a2dp_stream[BT_DEVICE_ID_1].device->cmgrHandler.remDev)
        return true;
#ifdef __BT_ONE_BRING_TWO__
    if(app_bt_device.hf_channel[BT_DEVICE_ID_2].cmgrHandler.remDev)
        return true;
    if(app_bt_device.a2dp_stream[BT_DEVICE_ID_2].device->cmgrHandler.remDev)
        return true;
#endif
    return false;
#endif
}


#ifdef __TWS_CHARGER_BOX__

extern "C" {
    bt_status_t ME_Ble_Clear_Whitelist(void);
    bt_status_t ME_Ble_Set_Private_Address(BT_BD_ADDR *addr);
    bt_status_t ME_Ble_Add_Dev_To_Whitelist(U8 addr_type,BT_BD_ADDR *addr);
    bt_status_t ME_Ble_SetAdv_data(U8 len, U8 *data);
    bt_status_t ME_Ble_SetScanRsp_data(U8 len, U8 *data);
    bt_status_t ME_Ble_SetAdv_parameters(adv_para_struct *para);
    bt_status_t ME_Ble_SetAdv_en(U8 en);
    bt_status_t ME_Ble_Setscan_parameter(scan_para_struct *para);
    bt_status_t ME_Ble_Setscan_en(U8 scan_en,  U8 filter_duplicate);
}


int8_t power_level=0;
#define TWS_BOX_OPEN 1
#define TWS_BOX_CLOSE 0
void app_tws_box_set_slave_adv_data(uint8_t power_level,uint8_t box_status)
{
    uint8_t adv_data[] =
    {
        0x02,0xfe, 0x00,
        0x02, 0xfd, 0x00  // manufacturer data
    };

    adv_data[2] = power_level;

    adv_data[5] = box_status;
    ME_Ble_SetAdv_data(sizeof(adv_data), adv_data);

}


void app_tws_box_set_slave_adv_para(void)
{
    uint8_t  peer_addr[BTIF_BD_ADDR_SIZE] = {0};
    adv_para_struct para;


    para.interval_min =             0x0040; // 20ms
    para.interval_max =             0x0040; // 20ms
    para.adv_type =                 0x03;
    para.own_addr_type =            0x01;
    para.peer_addr_type =           0x01;
    para.adv_chanmap =              0x07;
    para.adv_filter_policy =        0x00;
    memcpy(para.bd_addr.addr, peer_addr, BTIF_BD_ADDR_SIZE);

    ME_Ble_SetAdv_parameters(&para);

}


extern uint8_t bt_addr[6];
void app_tws_start_chargerbox_adv(void)
{
    app_tws_box_set_slave_adv_data(power_level,TWS_BOX_OPEN);
    ME_Ble_Set_Private_Address((BT_BD_ADDR *)bt_addr);
    app_tws_box_set_slave_adv_para();
    ME_Ble_SetAdv_en(1);

}



#endif

bool app_is_hfp_service_connected(void)
{
    return (bt_profile_manager[BT_DEVICE_ID_1].hfp_connect == bt_profile_connect_status_success);
}


btif_remote_device_t* app_bt_get_remoteDev(uint8_t deviceId)
{
    btif_remote_device_t* currentRemDev = NULL;

    if(btif_a2dp_get_stream_state( app_bt_device.a2dp_stream[deviceId]->a2dp_stream)
       == BTIF_AVDTP_STRM_STATE_STREAMING ||
       btif_a2dp_get_stream_state( app_bt_device.a2dp_stream[deviceId]->a2dp_stream)
       == BTIF_AVDTP_STRM_STATE_OPEN)
    {
        currentRemDev = btif_a2dp_get_stream_conn_remDev(app_bt_device.a2dp_stream[deviceId]->a2dp_stream);
    }
    else if (btif_get_hf_chan_state(app_bt_device.hf_channel[deviceId]) == BTIF_HF_STATE_OPEN)
    {
        currentRemDev = (btif_remote_device_t *)btif_hf_cmgr_get_remote_device(app_bt_device.hf_channel[deviceId]);
    }

    TRACE(2,"%s get current Remdev %p", __FUNCTION__, currentRemDev);

    return currentRemDev;
}

void app_bt_stay_active_rem_dev(btif_remote_device_t* pRemDev)
{
    if (pRemDev)
    {
        btif_cmgr_handler_t    *cmgrHandler;
        /* Clear the sniff timer */
        cmgrHandler = btif_cmgr_get_acl_handler(pRemDev);
        btif_cmgr_clear_sniff_timer(cmgrHandler);
        btif_cmgr_disable_sniff_timer(cmgrHandler);
        app_bt_Me_SetLinkPolicy(pRemDev, BTIF_BLP_MASTER_SLAVE_SWITCH);
    }
}

void app_bt_stay_active(uint8_t deviceId)
{
    btif_remote_device_t* currentRemDev = app_bt_get_remoteDev(deviceId);
    app_bt_stay_active_rem_dev(currentRemDev);
}

void app_bt_allow_sniff_rem_dev(btif_remote_device_t* pRemDev)
{
    if (pRemDev && (BTIF_BDS_CONNECTED ==  btif_me_get_remote_device_state(pRemDev)))
    {
        btif_cmgr_handler_t    *cmgrHandler;
        /* Enable the sniff timer */
        cmgrHandler = btif_cmgr_get_acl_handler(pRemDev);

        /* Start the sniff timer */
        btif_sniff_info_t sniffInfo;
        sniffInfo.minInterval = BTIF_CMGR_SNIFF_MIN_INTERVAL;
        sniffInfo.maxInterval = BTIF_CMGR_SNIFF_MAX_INTERVAL;
        sniffInfo.attempt = BTIF_CMGR_SNIFF_ATTEMPT;
        sniffInfo.timeout = BTIF_CMGR_SNIFF_TIMEOUT;
        if (cmgrHandler)
        {
            btif_cmgr_set_sniff_timer(cmgrHandler, &sniffInfo, BTIF_CMGR_SNIFF_TIMER);
        }
        app_bt_Me_SetLinkPolicy(pRemDev, BTIF_BLP_MASTER_SLAVE_SWITCH | BTIF_BLP_SNIFF_MODE);
    }
}

extern "C" uint8_t is_sco_mode (void);
void app_bt_allow_sniff(uint8_t deviceId)
{
    if (a2dp_is_music_ongoing() || is_sco_mode())
    {
        return;
    }
    btif_remote_device_t* currentRemDev = app_bt_get_remoteDev(deviceId);
    app_bt_allow_sniff_rem_dev(currentRemDev);
}

void app_bt_stop_sniff(uint8_t deviceId)
{
    btif_remote_device_t* currentRemDev = app_bt_get_remoteDev(deviceId);

    if (currentRemDev && (btif_me_get_remote_device_state(currentRemDev) == BTIF_BDS_CONNECTED))
    {
        if (btif_me_get_current_mode(currentRemDev) == BTIF_BLM_SNIFF_MODE)
        {
            TRACE(1,"!!! stop sniff currmode:%d\n", btif_me_get_current_mode(currentRemDev));
            app_bt_ME_StopSniff(currentRemDev);
        }
    }
}

bool app_bt_is_device_connected(uint8_t deviceId)
{
    if (deviceId < BT_DEVICE_NUM)
    {
        return bt_profile_manager[deviceId].has_connected;
    }
    else
    {
        // Indicate no connection is user passes invalid deviceId
        return false;
    }
}

#if defined(__BT_SELECT_PROF_DEVICE_ID__)
int8_t app_bt_a2dp_is_same_stream(a2dp_stream_t *src_Stream, a2dp_stream_t *dst_Stream)
{
    return btif_a2dp_is_register_codec_same(src_Stream, dst_Stream);
}
void app_bt_a2dp_find_same_unused_stream(a2dp_stream_t *in_Stream, a2dp_stream_t **out_Stream, uint32_t device_id)
{
    *out_Stream = NULL;
    if (app_bt_a2dp_is_same_stream(app_bt_device.a2dp_stream[device_id]->a2dp_stream, in_Stream))
        *out_Stream = app_bt_device.a2dp_stream[device_id]->a2dp_stream;
#if defined(A2DP_LHDC_ON)
    else if (app_bt_a2dp_is_same_stream(app_bt_device.a2dp_lhdc_stream[device_id]->a2dp_stream, in_Stream))
        *out_Stream = app_bt_device.a2dp_lhdc_stream[device_id]->a2dp_stream;
#endif
#if defined(A2DP_LDAC_ON)
    else if (app_bt_a2dp_is_same_stream(app_bt_device.a2dp_ldac_stream[device_id]->a2dp_stream, in_Stream))
        *out_Stream = app_bt_device.a2dp_ldac_stream[device_id]->a2dp_stream;
#endif
#if defined(A2DP_AAC_ON)
    else if (app_bt_a2dp_is_same_stream(app_bt_device.a2dp_aac_stream[device_id]->a2dp_stream, in_Stream))
        *out_Stream = app_bt_device.a2dp_aac_stream[device_id]->a2dp_stream;
#endif
#if defined(A2DP_SCALABLE_ON)
    else if (app_bt_a2dp_is_same_stream(app_bt_device.a2dp_scalable_stream[device_id]->a2dp_stream, in_Stream))
        *out_Stream = app_bt_device.a2dp_scalable_stream[device_id]->a2dp_stream;
#endif
}
int8_t app_bt_a2dp_is_stream_on_device_id(a2dp_stream_t *in_Stream, uint32_t device_id)
{
    if (app_bt_device.a2dp_stream[device_id]->a2dp_stream == in_Stream)
        return 1;
#if defined(A2DP_LHDC_ON)
    else if (app_bt_device.a2dp_lhdc_stream[device_id]->a2dp_stream == in_Stream)
        return 1;
#endif
#if defined(A2DP_LDAC_ON)
    else if (app_bt_device.a2dp_ldac_stream[device_id]->a2dp_stream == in_Stream)
        return 1;
#endif
#if defined(A2DP_AAC_ON)
    else if (app_bt_device.a2dp_aac_stream[device_id]->a2dp_stream == in_Stream)
        return 1;
#endif
#if defined(A2DP_SCALABLE_ON)
    else if (app_bt_device.a2dp_scalable_stream[device_id]->a2dp_stream == in_Stream)
        return 1;
#endif
    return 0;
}
int8_t app_bt_hfp_is_chan_on_device_id(hf_chan_handle_t chan, uint32_t device_id)
{
    if (app_bt_device.hf_channel[device_id] == chan)
        return 1;
    return 0;
}
int8_t app_bt_is_any_profile_connected(uint32_t device_id)
{
    // TODO avrcp?spp?hid?bisto?ama?dma?rfcomm?
    if ((bt_profile_manager[device_id].hfp_connect == bt_profile_connect_status_success)
        || (bt_profile_manager[device_id].hsp_connect == bt_profile_connect_status_success)
        || (bt_profile_manager[device_id].a2dp_connect == bt_profile_connect_status_success))
    {
        return 1;
    }

    return 0;
}
int8_t app_bt_is_a2dp_connected(uint32_t device_id)
{
    if (bt_profile_manager[device_id].a2dp_connect == bt_profile_connect_status_success)
    {
        return 1;
    }

    return 0;
}
btif_remote_device_t *app_bt_get_connected_profile_remdev(uint32_t device_id)
{
    if (bt_profile_manager[device_id].a2dp_connect == bt_profile_connect_status_success)
    {
        return (btif_remote_device_t *)btif_a2dp_get_remote_device(app_bt_device.a2dp_connected_stream[device_id]);
    }
    else if (bt_profile_manager[device_id].hfp_connect == bt_profile_connect_status_success)
    {
        return (btif_remote_device_t *)btif_hf_cmgr_get_remote_device(app_bt_device.hf_channel[device_id]);
    }
#if defined (__HSP_ENABLE__)
    else if (bt_profile_manager[device_id].hsp_connect == bt_profile_connect_status_success)
    {
        // TODO hsp support
        //return (btif_remote_device_t *)btif_hs_cmgr_get_remote_device(app_bt_device.hs_channel[i]);
    }
#endif

    return NULL;
}
#endif

bool app_bt_get_device_bdaddr(uint8_t deviceId, uint8_t* btAddr)
{
    bool ret = false;

    if (app_bt_is_device_connected(deviceId))
    {
        btif_remote_device_t* currentRemDev = app_bt_get_remoteDev(deviceId);

        if (currentRemDev)
        {
            memcpy(btAddr,  btif_me_get_remote_device_bdaddr(currentRemDev)->address, BTIF_BD_ADDR_SIZE);
            ret = true;
        }
    }

    return ret;
}

void fast_pair_enter_pairing_mode_handler(void)
{
#if defined(IBRT)
    app_ibrt_ui_judge_scan_type(IBRT_FASTPAIR_TRIGGER, MOBILE_LINK, 0);
#else
    app_bt_accessmode_set(BTIF_BAM_GENERAL_ACCESSIBLE);
#endif

#ifdef __INTERCONNECTION__
    clear_discoverable_adv_timeout_flag();
    app_interceonnection_start_discoverable_adv(INTERCONNECTION_BLE_FAST_ADVERTISING_INTERVAL,
            APP_INTERCONNECTION_FAST_ADV_TIMEOUT_IN_MS);
#endif
}

bool app_bt_is_hfp_audio_on(void)
{
    bool hfp_audio_is_on = false;
    for (uint8_t i=0; i<BT_DEVICE_NUM; i++)
    {
        if(BTIF_HF_AUDIO_CON == app_bt_device.hf_audio_state[i])
        {
            hfp_audio_is_on = true;
            break;
        }
    }
    return hfp_audio_is_on;
}

btif_remote_device_t* app_bt_get_connected_mobile_device_ptr(void)
{
    return connectedMobile;
}
void app_bt_set_spp_device_ptr(btif_remote_device_t* device)
{
    TRACE(2,"%s set sppOpenMobile is %p", __func__,device);
    sppOpenMobile = device;
    return;
}

btif_remote_device_t* app_bt_get_spp_device_ptr(void)
{
    TRACE(2,"%s sppOpenMobile %p", __func__,sppOpenMobile);
    ASSERT((sppOpenMobile != NULL), "sppOpenMobile is NULL!!!!!!!!!!!!");
    return sppOpenMobile;
}

#ifdef BT_USB_AUDIO_DUAL_MODE
#include "a2dp_api.h"
extern "C" a2dp_stream_t* app_bt_get_steam(enum BT_DEVICE_ID_T id)
{
    a2dp_stream_t* stream;

    stream = (a2dp_stream_t*)bt_profile_manager[id].stream;
    return stream;
}

extern "C" int app_bt_get_bt_addr(enum BT_DEVICE_ID_T id,bt_bdaddr_t *bdaddr)
{
    memcpy(bdaddr,&bt_profile_manager[id].rmt_addr,sizeof(bt_bdaddr_t));
    return 0;
}

extern "C" bool app_bt_a2dp_service_is_connected(void)
{
    return (bt_profile_manager[BT_DEVICE_ID_1].a2dp_connect == bt_profile_connect_status_success);
}
#endif


struct app_bt_search_t
{
    bool search_start;
    bool inquiry_pending;
    bool device_searched;
    bt_bdaddr_t address;
};

static bool app_bt_search_device_match(const bt_bdaddr_t* addr, const char* name)
{
    TRACE(7,"app_bt_search_callback found device %02x:%02x:%02x:%02x:%02x:%02x '%s'\n",
          addr->address[0], addr->address[1], addr->address[2], addr->address[3],
          addr->address[4], addr->address[5], name);

#if defined(HFP_MOBILE_AG_ROLE)
    bt_bdaddr_t test_device1 = {{0xd2, 0x53, 0x86, 0x42, 0x71, 0x31}};
    bt_bdaddr_t test_device2 = {{0xd3, 0x53, 0x86, 0x42, 0x71, 0x31}};
    return (memcmp(addr, test_device1.address, sizeof(bt_bdaddr_t)) == 0 ||
            memcmp(addr, test_device2.address, sizeof(bt_bdaddr_t)) == 0);
#else
    return false;
#endif
}

static struct app_bt_search_t g_bt_search;
static void app_bt_search_callback(const btif_event_t* event)
{
    TRACE(2,"%s event %d\n", __func__, btif_me_get_callback_event_type(event));

    switch(btif_me_get_callback_event_type(event))
    {
        case BTIF_BTEVENT_INQUIRY_RESULT:
        {
            bt_bdaddr_t *addr = btif_me_get_callback_event_inq_result_bd_addr(event);
            uint8_t mode = btif_me_get_callback_event_inq_result_inq_mode(event);
            const int NAME_MAX_LEN = 255;
            char device_name[NAME_MAX_LEN+1] = {0};
            int device_name_len = 0;
            uint8_t *eir = NULL;

            if ((mode == BTIF_INQ_MODE_EXTENDED) &&
                (eir = btif_me_get_callback_event_inq_result_ext_inq_resp(event)))
            {
                device_name_len = btif_me_get_ext_inq_data(eir, 0x09, (uint8_t *)device_name, NAME_MAX_LEN);
            }

            if (app_bt_search_device_match(addr, device_name_len > 0 ? device_name : ""))
            {
                g_bt_search.address = *addr;
                g_bt_search.device_searched = true;
                btif_me_cancel_inquiry();
            }
        }
        break;
        case BTIF_BTEVENT_INQUIRY_COMPLETE:
        case BTIF_BTEVENT_INQUIRY_CANCELED:
            btif_me_unregister_globa_handler((btif_handler *)btif_me_get_bt_handler());
            g_bt_search.search_start = false;
            g_bt_search.inquiry_pending = false;
            if (g_bt_search.device_searched)
            {
#if defined(HFP_MOBILE_AG_ROLE)
                bt_profile_manager[BT_DEVICE_ID_1].reconnect_mode = bt_profile_reconnect_null;
                bt_profile_manager[BT_DEVICE_ID_1].rmt_addr = g_bt_search.address;
                bt_profile_manager[BT_DEVICE_ID_1].chan = app_bt_device.hf_channel[BT_DEVICE_ID_1];
                app_bt_precheck_before_starting_connecting(bt_profile_manager[BT_DEVICE_ID_1].has_connected);
                app_bt_HF_CreateServiceLink(bt_profile_manager[BT_DEVICE_ID_1].chan, &bt_profile_manager[BT_DEVICE_ID_1].rmt_addr);
#endif
            }
            else
            {
                TRACE(1,"%s no device matched\n", __func__);
#if 0
                /* continue to search ??? */
                app_bt_start_search();
#endif
            }
            break;
        default:
            break;
    }
}

void app_bt_start_search(void)
{
    uint8_t max_search_time = 10; /* 12.8s */

    if (g_bt_search.search_start)
    {
        TRACE(1,"%s already started\n", __func__);
        return;
    }

    btif_me_set_handler(btif_me_get_bt_handler(), app_bt_search_callback);

    btif_me_set_event_mask(btif_me_get_bt_handler(),
                           BTIF_BEM_INQUIRY_RESULT | BTIF_BEM_INQUIRY_COMPLETE | BTIF_BEM_INQUIRY_CANCELED |
                           BTIF_BEM_LINK_CONNECT_IND | BTIF_BEM_LINK_CONNECT_CNF | BTIF_BEM_LINK_DISCONNECT |
                           BTIF_BEM_ROLE_CHANGE | BTIF_BEM_MODE_CHANGE);

    btif_me_register_global_handler(btif_me_get_bt_handler());

    g_bt_search.search_start = true;
    g_bt_search.device_searched = false;
    g_bt_search.inquiry_pending = false;

    if (BT_STS_PENDING != btif_me_inquiry(BTIF_BT_IAC_GIAC, max_search_time, 0))
    {
        TRACE(1,"%s start inquiry failed\n", __func__);
        g_bt_search.inquiry_pending = true;
    }
}

uint8_t app_bt_avrcp_get_notify_trans_id(void)
{
    return btif_a2dp_get_avrcpadvancedpdu_trans_id(app_bt_device.avrcp_notify_rsp[BT_DEVICE_ID_1]);
}

void app_bt_avrcp_set_notify_trans_id(uint8_t trans_id)
{
    TRACE(3,"%s %d %p\n", __func__, trans_id, app_bt_device.avrcp_notify_rsp[BT_DEVICE_ID_1]);
    btif_a2dp_set_avrcpadvancedpdu_trans_id(app_bt_device.avrcp_notify_rsp[BT_DEVICE_ID_1], trans_id);
}

uint8_t app_bt_avrcp_get_ctl_trans_id(void)
{
    return btif_avrcp_get_ctl_trans_id(app_bt_device.avrcp_channel[BT_DEVICE_ID_1]);
}

void app_bt_avrcp_set_ctl_trans_id(uint8_t trans_id)
{
    TRACE(3,"%s %d %p\n", __func__, trans_id, app_bt_device.avrcp_channel[BT_DEVICE_ID_1]);
    btif_avrcp_set_ctl_trans_id(app_bt_device.avrcp_channel[BT_DEVICE_ID_1], trans_id);
}

void app_bt_set_mobile_a2dp_stream(uint32_t deviceId,a2dp_stream_t *stream)
{
    bt_profile_manager[deviceId].stream = stream;
}

#if defined(IBRT)
#if defined(ENHANCED_STACK)
uint32_t app_bt_save_spp_app_ctx(uint32_t app_id,btif_remote_device_t *rem_dev, uint8_t *buf, uint32_t buf_len)
{
    bt_bdaddr_t *remote = NULL;
    uint32_t offset = 0;
    struct spp_device *device = (struct spp_device *)btif_spp_get_device(app_id);
    ASSERT(device, "%s NULL spp device app_id=0x%x",__func__, app_id);

    // save app_id
    buf[offset++] = app_id & 0xFF;
    buf[offset++] = (app_id >> 8) & 0xFF;
    buf[offset++] = (app_id >> 16) & 0xFF;
    buf[offset++] = (app_id >> 24) & 0xFF;

    // save port type
    buf[offset++] = device->portType;

    //save remote address
    remote = btif_me_get_remote_device_bdaddr(rem_dev);
    memcpy(buf+offset, remote, sizeof(bt_bdaddr_t));
    offset += sizeof(bt_bdaddr_t);

    //TRACE(7,"%s:%02x:%02x:%02x:%02x:%02x:%02x\r\n",
    //    __func__, remote->addr[5], remote->addr[4], remote->addr[3],
    //               remote->addr[2], remote->addr[1], remote->addr[0]);

    //spp device
    buf[offset++] = device->spp_connected_flag;

    return offset;
}

uint32_t app_bt_restore_spp_app_ctx(uint8_t *buf, uint32_t buf_len, uint32_t app_id)
{
    bt_bdaddr_t remote;
    uint32_t offset = 0;
    struct spp_device *device = NULL;
    uint8_t i = 0;
    uint8_t port_type = 0;
    uint32_t app_id_restore = 0;

    // restore app_id
    for (i=0; i<4; i++)
    {
        app_id_restore += (buf[offset+i]<<(8*i));
    }
    offset += 4;

    port_type = buf[offset++];

    ASSERT(app_id_restore == app_id,"%s,spp app id mismatch=%x,%x",__func__,app_id_restore,app_id);

    // restore remote address
    memcpy(&remote, buf+offset, sizeof(remote));
    offset += sizeof(remote);

    device = (struct spp_device *)btif_spp_get_device(app_id);

#ifdef __INTERCONNECTION__
    TRACE(1,"%s,%x,%x,%x", __func__,app_id,BTIF_APP_SPP_CLIENT_CCMP_ID,BTIF_APP_SPP_CLIENT_RED_ID);
#endif

    if (device == NULL)
    {
        /*
         * SPP client device may not be created in bt host initialized stage,so IBRT SLAVE will restore it
         */
        if (port_type == BTIF_SPP_CLIENT_PORT)
        {
            TRACE(1,"%s,spp client device null", __func__);
            switch (app_id)
            {
#ifdef __INTERCONNECTION__
                case BTIF_APP_SPP_CLIENT_CCMP_ID:
                    app_ccmp_client_open((uint8_t *)SppServiceSearchReq, app_interconnection_get_length(), 0, 1);
                    device = (struct spp_device *)btif_spp_get_device(BTIF_APP_SPP_CLIENT_CCMP_ID);
                    device->spp_callback = ccmp_callback;
                    //device->_channel = chnl; //restore in btif_spp_profile_restore_ctx
                    device->sppUsedFlag = 1;
                    break;

                case BTIF_APP_SPP_CLIENT_RED_ID:
                    app_spp_client_open((uint8_t*)SppServiceSearchReq, app_interconnection_get_length(),1);
                    device = (struct spp_device *)btif_spp_get_device(BTIF_APP_SPP_CLIENT_RED_ID);
                    device->spp_callback = spp_client_callback;
                    //device->_channel = chnl; //restore in btif_spp_profile_restore_ctx
                    device->sppUsedFlag = 1;
                    break;
#endif

                default:
                    ASSERT(device, "%s NULL spp client device app_id=0x%x", __func__, app_id);
                    break;
            }
        }
        else
        {
            ASSERT(device, "%s NULL spp server device app_id=0x%x", __func__, app_id);
        }
    }

#ifdef __INTERCONNECTION__
    if (app_id == BTIF_APP_SPP_CLIENT_RED_ID)
    {
        //btm_conn will NULL if only SPP profile since btm_conn restore later
        app_bt_set_spp_device_ptr((btif_remote_device_t *)btif_me_get_remote_device_by_bdaddr(&remote));
    }
#endif

    //restore spp device
    device->portType = port_type;
    device->spp_connected_flag = buf[offset++];

    return offset;

}

uint32_t app_bt_save_hfp_app_ctx(btif_remote_device_t *rem_dev, uint8_t *buf, uint32_t buf_len)
{
    BTIF_CTX_INIT(buf);

    BTIF_CTX_STR_BUF(btif_me_get_remote_device_bdaddr(rem_dev), BTIF_BD_ADDR_SIZE);

    BTIF_CTX_STR_VAL8(app_bt_device.hfchan_call[BT_DEVICE_ID_1]);
    BTIF_CTX_STR_VAL8(app_bt_device.hfchan_callSetup[BT_DEVICE_ID_1]);
    BTIF_CTX_STR_VAL8(app_bt_device.hf_callheld[BT_DEVICE_ID_1]);

    BTIF_CTX_SAVE_UPDATE_DATA_LEN();
    return BTIF_CTX_GET_TOTAL_LEN();
}

uint32_t app_bt_restore_hfp_app_ctx(uint8_t *buf, uint32_t buf_len)
{
    bt_bdaddr_t remote;
    uint8_t call, callsetup, callheld;
    BTIF_CTX_INIT(buf);

    BTIF_CTX_LDR_BUF(&remote, BTIF_BD_ADDR_SIZE);

    BTIF_CTX_LDR_VAL8(call);
    BTIF_CTX_LDR_VAL8(callsetup);
    BTIF_CTX_LDR_VAL8(callheld);

    app_bt_device.hfchan_call[BT_DEVICE_ID_1] = call;
    app_bt_device.hfchan_callSetup[BT_DEVICE_ID_1] = callsetup;
    app_bt_device.hf_callheld[BT_DEVICE_ID_1] = callheld;

    TRACE(4,"%s call %d callsetup %d callheld %d", __func__, call, callsetup, callheld);

    return BTIF_CTX_GET_TOTAL_LEN();
}
uint32_t app_bt_save_a2dp_app_ctx(btif_remote_device_t *rem_dev, uint8_t *buf, uint32_t buf_len)
{
    uint32_t offset = 0;
    unsigned char stream_enc = 0;
    uint32_t factor = 0;

    // TODO
    // more codecs, BT_DEVICE_ID_2
    if (bt_profile_manager[BT_DEVICE_ID_1].stream == app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream)
    {
        stream_enc = 0;
    }
#if defined(A2DP_AAC_ON)
    else if (bt_profile_manager[BT_DEVICE_ID_1].stream == app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream)
    {
        stream_enc = 1;
    }
#endif
#if defined(A2DP_LHDC_ON)
    else if (bt_profile_manager[BT_DEVICE_ID_1].stream == app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream)
    {
        stream_enc = 2;
    }
#endif
#if defined(A2DP_LDAC_ON)
    else if (bt_profile_manager[BT_DEVICE_ID_1].stream == app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream)
    {
        stream_enc = 2;
    }
#endif


    buf[offset++] = stream_enc;
    memcpy(buf+offset,btif_me_get_remote_device_bdaddr(rem_dev),BTIF_BD_ADDR_SIZE);
    offset += BTIF_BD_ADDR_SIZE;

    buf[offset++] = app_bt_device.a2dp_state[BT_DEVICE_ID_1];
    buf[offset++] = app_bt_device.a2dp_play_pause_flag;
    buf[offset++] = avrcp_get_media_status();

    //codec
    buf[offset++] = app_bt_device.codec_type[BT_DEVICE_ID_1];
    buf[offset++] = app_bt_device.sample_rate[BT_DEVICE_ID_1];
    buf[offset++] = app_bt_device.sample_bit[BT_DEVICE_ID_1];
#if defined(A2DP_LHDC_ON)
    buf[offset++] = app_bt_device.a2dp_lhdc_llc[BT_DEVICE_ID_1];
#endif

#if defined(__A2DP_AVDTP_CP__)
    buf[offset++] = app_bt_device.avdtp_cp[BT_DEVICE_ID_1];
#endif

    //volume
    buf[offset++] = (uint8_t)a2dp_volume_get(BT_DEVICE_ID_1);

    //latency factor
    factor =  (uint32_t)a2dp_audio_latency_factor_get();
    buf[offset++] = factor & 0xFF;
    buf[offset++] = (factor >> 8) & 0xFF;
    buf[offset++] = (factor >> 16) & 0xFF;
    buf[offset++] = (factor >> 24) & 0xFF;

    //a2dp session
    buf[offset++] = a2dp_ibrt_session_get() & 0xFF;
    buf[offset++] = (a2dp_ibrt_session_get() >> 8) & 0xFF;
    buf[offset++] = (a2dp_ibrt_session_get() >> 16) & 0xFF;
    buf[offset++] = (a2dp_ibrt_session_get() >> 24) & 0xFF;

    return offset;
}

uint32_t app_bt_restore_a2dp_app_ctx(uint8_t *buf, uint32_t buf_len)
{
    uint32_t offset = 0;
    bt_bdaddr_t remote;
    unsigned char stream_enc = 0;

    stream_enc = buf[offset++];

    memcpy(&remote,buf+offset,BTIF_BD_ADDR_SIZE);
    offset += BTIF_BD_ADDR_SIZE;


    app_bt_device.a2dp_state[BT_DEVICE_ID_1]  = buf[offset++];
    app_bt_device.a2dp_play_pause_flag = buf[offset++];
    avrcp_set_media_status(buf[offset++]);

    //codec info
    app_bt_device.codec_type[BT_DEVICE_ID_1] = buf[offset++];
    app_bt_device.sample_rate[BT_DEVICE_ID_1] = buf[offset++];
    app_bt_device.sample_bit[BT_DEVICE_ID_1] = buf[offset++];
#if defined(A2DP_LHDC_ON)
    app_bt_device.a2dp_lhdc_llc[BT_DEVICE_ID_1] = buf[offset++];
#endif

#if defined(__A2DP_AVDTP_CP__)
     app_bt_device.avdtp_cp[BT_DEVICE_ID_1] = buf[offset++];
#endif

    //volume
    a2dp_volume_set(BT_DEVICE_ID_1,  buf[offset++]);

    //latency factor
    a2dp_audio_latency_factor_set((float)(buf[offset] + (buf[offset+1] << 8) + (buf[offset+2] << 16) + (buf[offset+3] << 24)));
    offset += 4;

    //a2dp session
    a2dp_ibrt_session_set((buf[offset] + (buf[offset+1] << 8) + (buf[offset+2] << 16) + (buf[offset+3] << 24)));
    offset += 4;

    // TODO
    // more codecs, BT_DEVICE_ID_2
    if (stream_enc == 0)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
#if defined(A2DP_AAC_ON)
    else if (stream_enc == 1)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
#endif
#if defined(A2DP_LHDC_ON)
    else if (stream_enc == 2)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
#endif
#if defined(A2DP_LDAC_ON)
    else if (stream_enc == 2)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
#endif

    memcpy(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr.address, &remote, BTIF_BD_ADDR_SIZE);
    bt_profile_manager[BT_DEVICE_ID_1].a2dp_connect = bt_profile_connect_status_success;
    bt_profile_manager[BT_DEVICE_ID_1].hfp_connect = bt_profile_connect_status_success;
    bt_profile_manager[BT_DEVICE_ID_1].has_connected = true;

    return offset;
}

uint32_t app_bt_save_avrcp_app_ctx(btif_remote_device_t *rem_dev, uint8_t *buf, uint32_t buf_len)
{
    uint32_t offset = 0;

    buf[offset++] = app_bt_device.avrcp_state[BT_DEVICE_ID_1];
    buf[offset++] = app_bt_device.volume_report[BT_DEVICE_ID_1];

    if (app_bt_device.avrcp_notify_rsp[BT_DEVICE_ID_1])
    {
        buf[offset++] = true;
        buf[offset++] = app_bt_avrcp_get_notify_trans_id();
    }
    else
    {
        buf[offset++] = false;
        buf[offset++] = 0;
    }

    return offset;
}

uint32_t app_bt_restore_avrcp_app_ctx(uint8_t *buf, uint32_t buf_len)
{
    uint32_t offset = 0;
    uint8_t notify_rsp_exist = 0;
    uint8_t trans_id = 0;

    app_bt_device.avrcp_state[BT_DEVICE_ID_1] = buf[offset++];
    app_bt_device.volume_report[BT_DEVICE_ID_1] = buf[offset++];
    notify_rsp_exist = buf[offset++];
    trans_id = buf[offset++];

    TRACE(4,"app_bt_restore_avrcp_app_ctx state %d report %d notify %d %d\n",
          app_bt_device.avrcp_state[BT_DEVICE_ID_1], app_bt_device.volume_report[BT_DEVICE_ID_1], notify_rsp_exist, trans_id);

    if (notify_rsp_exist && app_bt_device.avrcp_notify_rsp[BT_DEVICE_ID_1] == NULL)
    {
        btif_app_a2dp_avrcpadvancedpdu_mempool_calloc(&app_bt_device.avrcp_notify_rsp[BT_DEVICE_ID_1]);
    }

    app_bt_avrcp_set_notify_trans_id(trans_id);

    return offset;
}

#ifdef __BTMAP_ENABLE__
uint32_t app_bt_save_map_app_ctx(btif_remote_device_t *rem_dev, uint8_t *buf, uint32_t buf_len)
{
    //struct bdaddr_t *remote = NULL;
    uint32_t offset = 0;

    memcpy((void *)buf, (void *)app_bt_device.map_session_handle, sizeof(app_bt_device.map_session_handle));
    offset += sizeof(app_bt_device.map_session_handle);

    return offset;
}

uint32_t app_bt_restore_map_app_ctx(uint8_t *buf, uint32_t buf_len)
{
    uint32_t offset = 0;

    memcpy((void *)app_bt_device.map_session_handle, (void *)buf, sizeof(btif_map_session_handle_t));
    offset += sizeof(btif_map_session_handle_t);

    return offset;
}
#endif

#if BTIF_HID_DEVICE
uint32_t app_bt_save_hid_app_ctx(uint8_t *buf)
{
    uint32_t offset = 0;

    if(app_bt_device.hid_channel == NULL)
    {
        TRACE(0, "app_bt_save_hid_app_ctx app_bt_device.hid_channel is NULL");
        return offset;
    }

    memcpy((void *)buf, (void *)app_bt_device.hid_channel, sizeof(app_bt_device.hid_channel));
    offset += sizeof(app_bt_device.hid_channel);

    return offset;
}

uint32_t app_bt_restore_hid_app_ctx(uint8_t *buf)
{
    uint32_t offset = 0;

    memcpy((void *)app_bt_device.hid_channel, (void *)buf, sizeof(hid_channel_t));
    offset += sizeof(hid_channel_t);

    return offset;
}
#endif
#endif /* ENHANCED_STACK */

a2dp_stream_t * app_bt_get_mobile_a2dp_stream(uint32_t deviceId)
{
    return bt_profile_manager[deviceId].stream;
}

void app_bt_update_bt_profile_manager(void)
{
    ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();

    memcpy(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr.address, p_ibrt_ctrl->mobile_addr.address, BTIF_BD_ADDR_SIZE);

#if defined(A2DP_AAC_ON)
    if(p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_MPEG2_4_AAC)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream;

    }
    else
#endif
#if defined(A2DP_SCALABLE_ON)
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
#endif
#if defined(A2DP_LHDC_ON)
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
#endif
#if defined(A2DP_LDAC_ON)
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
#endif
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_SBC)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
    {
        ASSERT(0, "%s err codec_type:%d ", __func__, p_ibrt_ctrl->a2dp_codec.codec_type);
    }

    bt_profile_manager[BT_DEVICE_ID_1].a2dp_connect = bt_profile_connect_status_success;
    bt_profile_manager[BT_DEVICE_ID_1].hfp_connect = bt_profile_connect_status_success;
    bt_profile_manager[BT_DEVICE_ID_1].has_connected = true;

    TRACE(3,"%s codec_type:%x if_a2dp_stream:%p", __func__, p_ibrt_ctrl->a2dp_codec.codec_type, bt_profile_manager[BT_DEVICE_ID_1].stream);
    DUMP8("%02x ", bt_profile_manager[BT_DEVICE_ID_1].rmt_addr.address, BTIF_BD_ADDR_SIZE);
}

void app_bt_update_bt_profile_manager_codec_type(uint8_t  codec_type)
{
    ibrt_ctrl_t *p_ibrt_ctrl = app_tws_ibrt_get_bt_ctrl_ctx();

    p_ibrt_ctrl->a2dp_codec.codec_type = codec_type;

#if defined(A2DP_AAC_ON)
    if(p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_MPEG2_4_AAC)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream;

    }
    else
#endif
#if defined(A2DP_SCALABLE_ON)
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
#endif
#if defined(A2DP_LHDC_ON)
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
#endif
#if defined(A2DP_LDAC_ON)
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
#endif
    if (p_ibrt_ctrl->a2dp_codec.codec_type == BTIF_AVDTP_CODEC_TYPE_SBC)
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream;
    }
    else
    {
        ASSERT(0, "%s err codec_type:%d ", __func__, p_ibrt_ctrl->a2dp_codec.codec_type);
    }

    bt_profile_manager[BT_DEVICE_ID_1].a2dp_connect = bt_profile_connect_status_success;
    bt_profile_manager[BT_DEVICE_ID_1].hfp_connect = bt_profile_connect_status_success;
    bt_profile_manager[BT_DEVICE_ID_1].has_connected = true;

    TRACE(3,"%s codec_type:%x if_a2dp_stream:%p", __func__, p_ibrt_ctrl->a2dp_codec.codec_type, bt_profile_manager[BT_DEVICE_ID_1].stream);
}

static bool ibrt_reconnect_mobile_profile_flag = false;
void app_bt_ibrt_reconnect_mobile_profile_flag_set(void)
{
    ibrt_reconnect_mobile_profile_flag = true;
}

void app_bt_ibrt_reconnect_mobile_profile_flag_clear(void)
{
    ibrt_reconnect_mobile_profile_flag = false;
}

bool app_bt_ibrt_reconnect_mobile_profile_flag_get(void)
{
    return ibrt_reconnect_mobile_profile_flag;
}

void app_bt_ibrt_reconnect_mobile_profile(bt_bdaddr_t mobile_addr)
{
    nvrec_btdevicerecord *mobile_record = NULL;

    bt_profile_manager[BT_DEVICE_ID_1].reconnect_mode = bt_profile_reconnect_null;
    bt_profile_manager[BT_DEVICE_ID_1].rmt_addr = mobile_addr;
    bt_profile_manager[BT_DEVICE_ID_1].chan = app_bt_device.hf_channel[BT_DEVICE_ID_1];

    if (!nv_record_btdevicerecord_find(&mobile_addr, &mobile_record))
    {
#if defined(A2DP_AAC_ON)
        if(mobile_record->device_plf.a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_MPEG2_4_AAC)
        {
            bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_aac_stream[BT_DEVICE_ID_1]->a2dp_stream;
        }
        else
#endif
#if defined(A2DP_SCALABLE_ON)
        if(mobile_record->device_plf.a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
        {
            bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_scalable_stream[BT_DEVICE_ID_1]->a2dp_stream;
        }
        else
#endif
#if defined(A2DP_LHDC_ON)
        if(mobile_record->device_plf.a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
        {
            bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_lhdc_stream[BT_DEVICE_ID_1]->a2dp_stream;
        }
        else
#endif
#if defined(A2DP_LDAC_ON)
        if(mobile_record->device_plf.a2dp_codectype == BTIF_AVDTP_CODEC_TYPE_NON_A2DP)
        {
            bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_ldac_stream[BT_DEVICE_ID_1]->a2dp_stream;
        }
        else
#endif
        {
            bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream;
        }
    }
    else
    {
        bt_profile_manager[BT_DEVICE_ID_1].stream = app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream;//default using SBC
    }

    btif_a2dp_reset_stream_state(bt_profile_manager[BT_DEVICE_ID_1].stream);

    TRACE(0,"ibrt_ui_log:start reconnect mobile, addr below:");
    DUMP8("0x%02x ",&(mobile_addr.address[0]),BTIF_BD_ADDR_SIZE);
    app_bt_ibrt_reconnect_mobile_profile_flag_set();
    app_bt_precheck_before_starting_connecting(bt_profile_manager[BT_DEVICE_ID_1].has_connected);

    app_ibrt_ui_t *p_ibrt_ui = app_ibrt_ui_get_ctx();
    if (p_ibrt_ui->config.profile_concurrency_supported)
    {
        app_bt_A2DP_OpenStream(bt_profile_manager[BT_DEVICE_ID_1].stream, &(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr));
        app_bt_HF_CreateServiceLink(bt_profile_manager[BT_DEVICE_ID_1].chan, &(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr));
    }
    else
    {
        app_bt_A2DP_OpenStream(bt_profile_manager[BT_DEVICE_ID_1].stream, &(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr));
        //app_bt_HF_CreateServiceLink(bt_profile_manager[BT_DEVICE_ID_1].chan, &(bt_profile_manager[BT_DEVICE_ID_1].rmt_addr));
    }
    //osTimerStart(bt_profile_manager[BT_DEVICE_ID_1].connect_timer, APP_IBRT_RECONNECT_TIMEOUT_MS);
}
#endif

#ifdef __IAG_BLE_INCLUDE__
static void app_start_fast_connectable_ble_adv(uint16_t advInterval)
{
    bool ret = FALSE;

    if (NULL == app_fast_ble_adv_timeout_timer)
    {
        app_fast_ble_adv_timeout_timer =
            osTimerCreate(osTimer(APP_FAST_BLE_ADV_TIMEOUT_TIMER),
                          osTimerOnce,
                          NULL);
    }

    osTimerStart(app_fast_ble_adv_timeout_timer, APP_FAST_BLE_ADV_TIMEOUT_IN_MS);

#ifdef IBRT
    ret = app_ibrt_ui_get_snoop_via_ble_enable();
#endif

    if (FALSE == ret)
    {
        app_ble_start_connectable_adv(advInterval);
    }
}

static int app_fast_ble_adv_timeout_timehandler(void const *param)
{
    bool ret = FALSE;

#ifdef IBRT
    ret = app_ibrt_ui_get_snoop_via_ble_enable();
#endif

    if (FALSE == ret)
    {
        app_ble_refresh_adv_state(BLE_ADVERTISING_INTERVAL);
    }

    return 0;
}

void app_stop_fast_connectable_ble_adv_timer(void)
{
    if (NULL != app_fast_ble_adv_timeout_timer)
    {
        osTimerStop(app_fast_ble_adv_timeout_timer);
    }
}
#endif


static uint32_t bt_link_active_mode_bits[MAX_ACTIVE_MODE_MANAGED_LINKS];

void app_bt_active_mode_manager_init(void)
{
    memset(bt_link_active_mode_bits, 0, sizeof(bt_link_active_mode_bits));
}

void app_bt_active_mode_reset(uint32_t linkIndex)
{
    bt_link_active_mode_bits[linkIndex] = 0;
}

void app_bt_active_mode_set(BT_LINK_ACTIVE_MODE_KEEPER_USER_E user, uint32_t linkIndex)
{
#if defined(IBRT)
    return;
#endif

    bool isAlreadyInActiveMode = false;
    if (linkIndex < MAX_ACTIVE_MODE_MANAGED_LINKS)
    {
        uint32_t lock = int_lock_global();
        if (bt_link_active_mode_bits[linkIndex] > 0)
        {
            isAlreadyInActiveMode = true;
        }
        else
        {
            isAlreadyInActiveMode = false;
        }
        bt_link_active_mode_bits[linkIndex] |= (1 << user);
        int_unlock_global(lock);

        if (!isAlreadyInActiveMode)
        {
            app_bt_stop_sniff(linkIndex);
            app_bt_stay_active(linkIndex);
        }

    }
    else if (MAX_ACTIVE_MODE_MANAGED_LINKS == linkIndex)
    {
        for (uint8_t devId = 0; devId < BT_DEVICE_NUM; devId++)
        {
            uint32_t lock = int_lock_global();
            if (bt_link_active_mode_bits[devId] > 0)
            {
                isAlreadyInActiveMode = true;
            }
            else
            {
                isAlreadyInActiveMode = false;
            }
            bt_link_active_mode_bits[devId] |= (1 << user);
            int_unlock_global(lock);

            if (!isAlreadyInActiveMode)
            {
                app_bt_stop_sniff(devId);
                app_bt_stay_active(devId);
            }
        }
    }

    TRACE(2,"set active mode for user %d, link %d, now state:", user, linkIndex);
    DUMP32("%08x", bt_link_active_mode_bits, MAX_ACTIVE_MODE_MANAGED_LINKS);
}

void app_bt_active_mode_clear(BT_LINK_ACTIVE_MODE_KEEPER_USER_E user, uint32_t linkIndex)
{
#if defined(IBRT)
    return;
#endif

    bool isAlreadyAllowSniff = false;
    if (linkIndex < MAX_ACTIVE_MODE_MANAGED_LINKS)
    {
        uint32_t lock = int_lock_global();

        if (0 == bt_link_active_mode_bits[linkIndex])
        {
            isAlreadyAllowSniff = true;
        }
        else
        {
            isAlreadyAllowSniff = false;
        }

        bt_link_active_mode_bits[linkIndex] &= (~(1 << user));

        int_unlock_global(lock);

        if (!isAlreadyAllowSniff)
        {
            app_bt_allow_sniff(linkIndex);
        }
    }
    else if (MAX_ACTIVE_MODE_MANAGED_LINKS == linkIndex)
    {
        for (uint8_t devId = 0; devId < BT_DEVICE_NUM; devId++)
        {
            uint32_t lock = int_lock_global();
            if (0 == bt_link_active_mode_bits[devId])
            {
                isAlreadyAllowSniff = true;
            }
            else
            {
                isAlreadyAllowSniff = false;
            }
            bt_link_active_mode_bits[devId] &= (~(1 << user));
            int_unlock_global(lock);

            if (!isAlreadyAllowSniff)
            {
                app_bt_allow_sniff(devId);
            }
        }
    }

    TRACE(2,"clear active mode for user %d, link %d, now state:", user, linkIndex);
    DUMP32("%08x ", bt_link_active_mode_bits, MAX_ACTIVE_MODE_MANAGED_LINKS);
}

int8_t app_bt_get_rssi(void)
{
    int8_t rssi=127;
    uint8_t i;
    btif_remote_device_t *remDev = NULL;
    rx_agc_t tws_agc = {0};

    for (i=0; i<BT_DEVICE_NUM; i++)
    {
        remDev = btif_me_enumerate_remote_devices(i);
        if (remDev)
        {
            if(btif_me_get_remote_device_hci_handle(remDev))
            {
                rssi = bt_drv_reg_op_read_rssi_in_dbm(btif_me_get_remote_device_hci_handle(remDev),&tws_agc);
                rssi = bt_drv_reg_op_rssi_correction(rssi);
                TRACE(1," headset to mobile RSSI:%d dBm",rssi);
            }
        }
    }
    return rssi;
}

#ifdef TILE_DATAPATH
int8_t app_tile_get_ble_rssi(void)
{
    int8_t rssi=127;
    uint8_t i;
    btif_remote_device_t *remDev = NULL;
    rx_agc_t tws_agc = {0};

    for (i=0; i<BT_DEVICE_NUM; i++)
    {
        remDev = btif_me_enumerate_remote_devices(i);
        if (remDev)
        {
            if(app_tile_ble_get_connection_index() != BLE_INVALID_CONNECTION_INDEX)
            {
                rssi = bt_drv_reg_op_read_ble_rssi_in_dbm(app_tile_ble_get_connection_index(),&tws_agc);
                rssi = bt_drv_reg_op_rssi_correction(rssi);
                TRACE(1," headset to mobile RSSI:%d dBm",rssi);
            }
        }
    }
    return rssi;
}
#endif

#ifdef __GMA_VOICE__
void app_bt_prepare_for_ota(void)
{
    app_ibrt_ui_t *p_ui_ctrl = app_ibrt_ui_get_ctx();
   
    p_ui_ctrl->config.disable_tws_switch = true;//disable role switch

    app_key_close();

    if(IBRT_MASTER == app_tws_ibrt_role_get_callback(NULL)){
        btif_hf_disconnect_service_link(app_bt_device.hf_channel[BT_DEVICE_ID_1]);
        btif_a2dp_suspend_stream(app_bt_device.a2dp_stream[BT_DEVICE_ID_1]->a2dp_stream);
    }
    TRACE(0,"app_bt_prepare_for_ota");
}
#endif