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

5096 lines
179 KiB
C++
Raw Blame History

/***************************************************************************
*
* 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 "app_bt.h"
#include "a2dp_api.h"
#include "app_a2dp.h"
#include "app_ai_manager_api.h"
#include "app_bt.h"
#include "app_bt_func.h"
#include "app_dip.h"
#include "app_hfp.h"
#include "app_status_ind.h"
#include "app_thread.h"
#include "apps.h"
#include "besbt.h"
#include "besbt_cfg.h"
#include "bluetooth.h"
#include "bt_drv_interface.h"
#include "bt_drv_reg_op.h"
#include "btapp.h"
#include "dip_api.h"
#include "hal_aud.h"
#include "hal_chipid.h"
#include "hal_trace.h"
#include "hci_api.h"
#include "hfp_api.h"
#include "l2cap_api.h"
#include "me_api.h"
#include "mei_api.h"
#include "nvrecord.h"
#include "os_api.h"
#if defined(IBRT)
#include "app_ibrt_a2dp.h"
#include "app_ibrt_if.h"
#include "app_ibrt_ui.h"
#include "app_tws_ibrt.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_manager.h"
#include "ai_spp.h"
#include "ai_thread.h"
#endif
#ifdef __INTERCONNECTION__
#include "app_interconnection.h"
#include "app_interconnection_ble.h"
#include "app_interconnection_ccmp.h"
#include "app_interconnection_spp.h"
#include "app_spp.h"
#include "spp_api.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 "rwip_config.h"
#include "tile_target_ble.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();
}
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__)
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__)
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__)
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) {
// 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);
} else {
// app_status_indication_set(APP_STATUS_INDICATION_PAGESCAN);
}
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;
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 {
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);
nv_record_touch_cause_flush();
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);
nv_record_touch_cause_flush();
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);
nv_record_touch_cause_flush();
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;
}
#else
uint32_t app_bt_restore_hid_app_ctx(uint8_t *buf) { return 4; }
uint32_t app_bt_save_hid_app_ctx(uint8_t *buf) {
buf[0] = 0;
buf[1] = 0;
buf[2] = 0;
buf[3] = 0;
return 4;
}
#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
Reference in New Issue View Git Blame Copy Permalink