rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/services/bt_app/app_bt.cpp

5284 lines
192 KiB
C++
Raw Normal View History

add first commit
2022-08-15 04:20:27 -05:00
/***************************************************************************
*
* 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;
}
Stubs for anc to build with keyboard off
2022-12-30 03:23:10 -06:00
#else
uint32_t app_bt_restore_hid_app_ctx(uint8_t *buf)
{return 0;}
uint32_t app_bt_save_hid_app_ctx(uint8_t *buf)
{return 0;}
add first commit
2022-08-15 04:20:27 -05:00
#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