Crash_Override/OVMS3-idf
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

component/bt: modify BT GAP structure

Browse source 
1. Separate the upward and the downward
2. Cancel use of msg.aid when call btc_transfer_context
This commit is contained in:
baohongde 2018-05-16 18:58:13 +08:00
parent c54a679a41
commit 174501ff35
4 changed files with 187 additions and 137 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
components/bt/bluedroid/bta/include/bta/bta_api.h
View file

@ -1022,7 +1022,7 @@ typedef struct {
/* If the device name is known to application BTA skips the remote name request */
BOOLEAN is_limited; /* TRUE, if the limited inquiry bit is set in the CoD */
INT8 rssi; /* The rssi value */
UINT8 *p_eir; /* received EIR */
UINT8 *p_eir; /* Received EIR */
#if (BLE_INCLUDED == TRUE)
UINT8 inq_result_type;
UINT8 ble_addr_type;
@ -1054,7 +1054,7 @@ typedef struct {
tBTA_SERVICE_MASK services; /* Services found on peer device. */
// btla-specific ++
UINT8 *p_raw_data; /* Raw data for discovery DB */
UINT32 raw_data_size; /* size of raw data */
UINT32 raw_data_size; /* Size of raw data */
tBT_DEVICE_TYPE device_type; /* device type in case it is BLE device */
UINT32 num_uuids;
UINT8 *p_uuid_list;
@ -1075,11 +1075,17 @@ typedef union {
tBTA_DM_INQ_RES inq_res; /* Inquiry result for a peer device. */
tBTA_DM_INQ_CMPL inq_cmpl; /* Inquiry complete. */
tBTA_DM_DISC_RES disc_res; /* Discovery result for a peer device. */
tBTA_DM_DISC_BLE_RES disc_ble_res; /* discovery result for GATT based service */
tBTA_DM_DISC_BLE_RES disc_ble_res; /* Discovery result for GATT based service */
tBTA_DM_DI_DISC_CMPL di_disc; /* DI discovery result for a peer device */
} tBTA_DM_SEARCH;
/* Structure of search callback event and structures */
typedef struct {
tBTA_DM_SEARCH_EVT event; /* Search callback events */
UINT16 len; /* Length of p_data */
tBTA_DM_SEARCH *p_data; /* Union of all search callback structures */
} tBTA_DM_SEARCH_PARAM;
/* Search callback */
typedef void (tBTA_DM_SEARCH_CBACK)(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data);
@ -1089,7 +1095,7 @@ typedef void (tBTA_DM_EXEC_CBACK) (void *p_param);
/* Encryption callback*/
typedef void (tBTA_DM_ENCRYPT_CBACK) (BD_ADDR bd_addr, tBTA_TRANSPORT transport, tBTA_STATUS result);
/* relate to ESP_BLE_SEC_xxx in esp_gatt_defs.h */
/* Relate to ESP_BLE_SEC_xxx in esp_gatt_defs.h */
#if BLE_INCLUDED == TRUE
#define BTA_DM_BLE_SEC_NONE BTM_BLE_SEC_NONE
#define BTA_DM_BLE_SEC_ENCRYPT BTM_BLE_SEC_ENCRYPT

22
components/bt/bluedroid/btc/core/btc_dm.c
View file

@ -32,14 +32,6 @@
#if (BTC_GAP_BT_INCLUDED == TRUE)
#include "btc_gap_bt.h"
static inline void btc_gap_bt_cb_to_app(esp_bt_gap_cb_event_t event, esp_bt_gap_cb_param_t *param)
{
esp_bt_gap_cb_t cb = (esp_bt_gap_cb_t)btc_profile_cb_get(BTC_PID_GAP_BT);
if (cb) {
cb(event, param);
}
}
#endif /* BTC_GAP_BT_INCLUDED == TRUE */
/******************************************************************************
** Constants & Macros
@ -360,10 +352,22 @@ static void btc_dm_auth_cmpl_evt (tBTA_DM_AUTH_CMPL *p_auth_cmpl)
}
#if (BTC_GAP_BT_INCLUDED == TRUE)
esp_bt_gap_cb_param_t param;
bt_status_t ret;
btc_msg_t msg;
msg.sig = BTC_SIG_API_CB;
msg.pid = BTC_PID_GAP_BT;
msg.act = BTC_GAP_BT_AUTH_CMPL_EVT;
param.auth_cmpl.stat = status;
memcpy(param.auth_cmpl.bda, p_auth_cmpl->bd_addr, ESP_BD_ADDR_LEN);
memcpy(param.auth_cmpl.device_name, p_auth_cmpl->bd_name, ESP_BT_GAP_MAX_BDNAME_LEN + 1);
btc_gap_bt_cb_to_app(ESP_BT_GAP_AUTH_CMPL_EVT, &param);
ret = btc_transfer_context(&msg, &param,
sizeof(esp_bt_gap_cb_param_t), NULL);
if (ret != BT_STATUS_SUCCESS) {
BTC_TRACE_DEBUG("%s btc_transfer_context failed\n", __func__);
}
#endif /* BTC_GAP_BT_INCLUDED == TRUE */
(void) status;
}

271
components/bt/bluedroid/btc/profile/std/gap/btc_gap_bt.c
View file

@ -138,31 +138,35 @@ static void btc_gap_bt_get_remote_service_record(btc_gap_bt_args_t *arg)
*******************************************************************************/
static void search_devices_copy_cb(btc_msg_t *msg, void *p_dest, void *p_src)
{
tBTA_DM_SEARCH *p_dest_data = (tBTA_DM_SEARCH *) p_dest;
tBTA_DM_SEARCH *p_src_data = (tBTA_DM_SEARCH *) p_src;
tBTA_DM_SEARCH_PARAM *p_dest_data = (tBTA_DM_SEARCH_PARAM *) p_dest;
tBTA_DM_SEARCH_PARAM *p_src_data = (tBTA_DM_SEARCH_PARAM *) p_src;
if (!p_src) {
return;
}
p_dest_data->p_data = (void *)osi_malloc(p_dest_data->len);
memset(p_dest_data->p_data, 0x00, p_dest_data->len);
memcpy(p_dest_data->p_data, p_src_data->p_data, p_dest_data->len);
switch (msg->aid) {
case BTA_DM_INQ_RES_EVT: {
if (p_src_data->inq_res.p_eir) {
p_dest_data->inq_res.p_eir = (UINT8 *)(p_dest + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->inq_res.p_eir, p_src_data->inq_res.p_eir, HCI_EXT_INQ_RESPONSE_LEN);
if ( p_dest_data->len > sizeof(tBTA_DM_SEARCH)){
switch (p_dest_data->event) {
case BTA_DM_INQ_RES_EVT: {
if (p_src_data->p_data->inq_res.p_eir) {
p_dest_data->p_data->inq_res.p_eir = (UINT8 *)(p_dest_data->p_data + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->p_data->inq_res.p_eir, p_src_data->p_data->inq_res.p_eir, HCI_EXT_INQ_RESPONSE_LEN);
}
}
}
break;
break;
case BTA_DM_DISC_RES_EVT: {
if (p_src_data->disc_res.raw_data_size && p_src_data->disc_res.p_raw_data) {
p_dest_data->disc_res.p_raw_data = (UINT8 *)(p_dest + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->disc_res.p_raw_data,
p_src_data->disc_res.p_raw_data,
p_src_data->disc_res.raw_data_size);
case BTA_DM_DISC_RES_EVT: {
if (p_src_data->p_data->disc_res.raw_data_size && p_src_data->p_data->disc_res.p_raw_data) {
p_dest_data->p_data->disc_res.p_raw_data = (UINT8 *)(p_dest_data->p_data + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->p_data->disc_res.p_raw_data,
p_src_data->p_data->disc_res.p_raw_data,
p_src_data->p_data->disc_res.raw_data_size);
}
}
break;
}
}
break;
}
}
@ -177,26 +181,30 @@ static void search_devices_copy_cb(btc_msg_t *msg, void *p_dest, void *p_src)
*******************************************************************************/
static void search_service_record_copy_cb(btc_msg_t *msg, void *p_dest, void *p_src)
{
tBTA_DM_SEARCH *p_dest_data = (tBTA_DM_SEARCH *) p_dest;
tBTA_DM_SEARCH *p_src_data = (tBTA_DM_SEARCH *) p_src;
tBTA_DM_SEARCH_PARAM *p_dest_data = (tBTA_DM_SEARCH_PARAM *) p_dest;
tBTA_DM_SEARCH_PARAM *p_src_data = (tBTA_DM_SEARCH_PARAM *) p_src;
if (!p_src) {
return;
}
switch (msg->aid) {
case BTA_DM_DISC_RES_EVT: {
if (p_src_data->disc_res.p_raw_data && p_src_data->disc_res.raw_data_size > 0) {
p_dest_data->disc_res.p_raw_data = (UINT8 *)(p_dest + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->disc_res.p_raw_data,
p_src_data->disc_res.p_raw_data,
p_src_data->disc_res.raw_data_size);
p_dest_data->p_data = osi_malloc(p_dest_data->len);
memset(p_dest_data->p_data, 0x00, p_dest_data->len);
memcpy(p_dest_data->p_data, p_src_data->p_data, p_dest_data->len);
if ( p_dest_data->len > sizeof(tBTA_DM_SEARCH)){
switch (p_dest_data->event) {
case BTA_DM_DISC_RES_EVT: {
if (p_src_data->p_data->disc_res.p_raw_data && p_src_data->p_data->disc_res.raw_data_size > 0) {
p_dest_data->p_data->disc_res.p_raw_data = (UINT8 *)(p_dest_data->p_data + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->p_data->disc_res.p_raw_data,
p_src_data->p_data->disc_res.p_raw_data,
p_src_data->p_data->disc_res.raw_data_size);
}
}
}
break;
default:
break;
default:
break;
}
}
}
@ -255,6 +263,10 @@ static BOOLEAN check_eir_remote_name(tBTA_DM_SEARCH *p_search_data,
*******************************************************************************/
static void bte_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
{
tBTA_DM_SEARCH_PARAM search;
search.event = event;
search.p_data = p_data;
UINT16 param_len = 0;
if (p_data) {
@ -282,31 +294,30 @@ static void bte_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_d
p_data->inq_res.remt_name_not_required = check_eir_remote_name(p_data, NULL, NULL);
}
search.len = param_len;
do {
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
msg.sig = BTC_SIG_API_CB;
msg.pid = BTC_PID_GAP_BT;
msg.act = BTC_GAP_BT_ACT_SEARCH_DEVICES;
msg.aid = event;
msg.act = BTC_GAP_BT_SEARCH_DEVICES_EVT;
btc_transfer_context(&msg, p_data, param_len,
(param_len > sizeof(tBTA_DM_SEARCH)) ? search_devices_copy_cb : NULL);
btc_transfer_context(&msg, &search, sizeof(tBTA_DM_SEARCH_PARAM), search_devices_copy_cb);
} while (0);
}
static void btc_gap_bt_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
static void btc_gap_bt_search_devices_evt(tBTA_DM_SEARCH_PARAM *p_data)
{
switch (event) {
switch (p_data->event) {
case BTA_DM_DISC_RES_EVT: {
/* remote name update */
uint32_t bdname_len = strlen((const char *)p_data->disc_res.bd_name);
uint32_t bdname_len = strlen((const char *)p_data->p_data->disc_res.bd_name);
if (bdname_len) {
esp_bt_gap_dev_prop_t prop[1];
BTC_STORAGE_FILL_PROPERTY(&prop[0], ESP_BT_GAP_DEV_PROP_BDNAME, bdname_len + 1, p_data->disc_res.bd_name);
BTC_STORAGE_FILL_PROPERTY(&prop[0], ESP_BT_GAP_DEV_PROP_BDNAME, bdname_len + 1, p_data->p_data->disc_res.bd_name);
esp_bt_gap_cb_param_t param;
bdcpy(param.disc_res.bda, p_data->disc_res.bd_addr);
bdcpy(param.disc_res.bda, p_data->p_data->disc_res.bd_addr);
param.disc_res.num_prop = 1;
param.disc_res.prop = prop;
btc_gap_bt_cb_to_app(ESP_BT_GAP_DISC_RES_EVT, &param);
@ -315,7 +326,7 @@ static void btc_gap_bt_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEAR
}
case BTA_DM_INQ_RES_EVT: {
/* inquiry result */
uint32_t cod = devclass2uint (p_data->inq_res.dev_class);
uint32_t cod = devclass2uint (p_data->p_data->inq_res.dev_class);
if (cod == 0) {
BTC_TRACE_DEBUG("%s cod is 0, set as unclassified", __func__);
@ -330,17 +341,17 @@ static void btc_gap_bt_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEAR
BTC_STORAGE_FILL_PROPERTY(&prop[0], ESP_BT_GAP_DEV_PROP_COD, sizeof(cod), &cod);
num_prop++;
BTC_STORAGE_FILL_PROPERTY(&prop[1], ESP_BT_GAP_DEV_PROP_RSSI, 1, &(p_data->inq_res.rssi));
BTC_STORAGE_FILL_PROPERTY(&prop[1], ESP_BT_GAP_DEV_PROP_RSSI, 1, &(p_data->p_data->inq_res.rssi));
num_prop++;
if (p_data->inq_res.p_eir) {
BTC_STORAGE_FILL_PROPERTY(&prop[2], ESP_BT_GAP_DEV_PROP_EIR, HCI_EXT_INQ_RESPONSE_LEN, p_data->inq_res.p_eir);
if (p_data->p_data->inq_res.p_eir) {
BTC_STORAGE_FILL_PROPERTY(&prop[2], ESP_BT_GAP_DEV_PROP_EIR, HCI_EXT_INQ_RESPONSE_LEN, p_data->p_data->inq_res.p_eir);
num_prop++;
}
/* Callback to notify upper layer of device */
esp_bt_gap_cb_param_t param;
bdcpy(param.disc_res.bda, p_data->inq_res.bd_addr);
bdcpy(param.disc_res.bda, p_data->p_data->inq_res.bd_addr);
param.disc_res.num_prop = num_prop;
param.disc_res.prop = prop;
btc_gap_bt_cb_to_app(ESP_BT_GAP_DISC_RES_EVT, &param);
@ -382,18 +393,18 @@ static void btc_gap_bt_search_devices_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEAR
** Returns void
**
*******************************************************************************/
static void btc_gap_bt_search_service_record(UINT16 event, char *p_param)
static void btc_gap_bt_search_service_record(char *p_param)
{
tBTA_DM_SEARCH *p_data = (tBTA_DM_SEARCH *)p_param;
tBTA_DM_SEARCH_PARAM *p_data = (tBTA_DM_SEARCH_PARAM *)p_param;
switch (event) {
switch (p_data->event) {
case BTA_DM_DISC_RES_EVT: {
esp_bt_gap_cb_param_t param;
memcpy(param.rmt_srvcs.bda, p_data->disc_res.bd_addr, BD_ADDR_LEN);
if (p_data->disc_res.p_raw_data && p_data->disc_res.raw_data_size > 0) {
memcpy(param.rmt_srvcs.bda, p_data->p_data->disc_res.bd_addr, BD_ADDR_LEN);
if (p_data->p_data->disc_res.p_raw_data && p_data->p_data->disc_res.raw_data_size > 0) {
param.rmt_srvc_rec.stat = ESP_BT_STATUS_SUCCESS;
// param.rmt_srvc_rec.raw_data_size = p_data->disc_res.raw_data_size;
// param.rmt_srvc_rec.raw_data = p_data->disc_res.p_raw_data;
// param.rmt_srvc_rec.raw_data_size = p_data->p_data->disc_res.raw_data_size;
// param.rmt_srvc_rec.raw_data = p_data->p_data->disc_res.p_raw_data;
} else {
param.rmt_srvc_rec.stat = ESP_BT_STATUS_FAIL;
// param.rmt_srvc_rec.raw_data_size = 0;
@ -421,6 +432,9 @@ static void btc_gap_bt_search_service_record(UINT16 event, char *p_param)
*******************************************************************************/
static void bte_dm_remote_service_record_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
{
tBTA_DM_SEARCH_PARAM search;
search.event = event;
search.p_data = p_data;
UINT16 param_len = 0;
if (p_data) {
@ -432,17 +446,13 @@ static void bte_dm_remote_service_record_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_S
param_len += p_data->disc_res.raw_data_size;
}
}
search.len = param_len;
do {
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
msg.sig = BTC_SIG_API_CB;
msg.pid = BTC_PID_GAP_BT;
msg.act = BTC_GAP_BT_ACT_SEARCH_SERVICE_RECORD;
msg.aid = event;
btc_transfer_context(&msg, p_data, param_len,
(param_len > sizeof(tBTA_DM_SEARCH)) ? search_service_record_copy_cb : NULL);
msg.act = BTC_GAP_BT_SEARCH_SERVICE_RECORD_EVT;
btc_transfer_context(&msg, &search, sizeof(tBTA_DM_SEARCH_PARAM), search_service_record_copy_cb);
} while (0);
}
@ -456,27 +466,27 @@ static void bte_dm_remote_service_record_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_S
** Returns void
**
*******************************************************************************/
static void btc_gap_bt_search_services(UINT16 event, char *p_param)
static void btc_gap_bt_search_services(char *p_param)
{
tBTA_DM_SEARCH *p_data = (tBTA_DM_SEARCH *)p_param;
tBTA_DM_SEARCH_PARAM *p_data = (tBTA_DM_SEARCH_PARAM *)p_param;
switch (event) {
switch (p_data->event) {
case BTA_DM_DISC_RES_EVT: {
esp_bt_gap_cb_param_t param;
esp_bt_uuid_t *uuid_list = NULL;
memcpy(param.rmt_srvcs.bda, p_data->disc_res.bd_addr, BD_ADDR_LEN);
memcpy(param.rmt_srvcs.bda, p_data->p_data->disc_res.bd_addr, BD_ADDR_LEN);
param.rmt_srvcs.stat = ESP_BT_STATUS_FAIL;
if (p_data->disc_res.result == BTA_SUCCESS) {
uuid_list = malloc(sizeof(esp_bt_uuid_t) * p_data->disc_res.num_uuids);
if (p_data->p_data->disc_res.result == BTA_SUCCESS) {
uuid_list = malloc(sizeof(esp_bt_uuid_t) * p_data->p_data->disc_res.num_uuids);
if (uuid_list) {
param.rmt_srvcs.stat = ESP_BT_STATUS_SUCCESS;
param.rmt_srvcs.num_uuids = p_data->disc_res.num_uuids;
param.rmt_srvcs.num_uuids = p_data->p_data->disc_res.num_uuids;
param.rmt_srvcs.uuid_list = uuid_list;
// copy UUID list
uint8_t *i_uu = (uint8_t *)p_data->disc_res.p_uuid_list;
uint8_t *i_uu = (uint8_t *)p_data->p_data->disc_res.p_uuid_list;
esp_bt_uuid_t *o_uu = uuid_list;
for (int i = 0; i < p_data->disc_res.num_uuids; i++, i_uu += ESP_UUID_LEN_128, o_uu++) {
for (int i = 0; i < p_data->p_data->disc_res.num_uuids; i++, i_uu += ESP_UUID_LEN_128, o_uu++) {
uuid128_be_to_esp_uuid(o_uu, i_uu);
}
}
@ -513,6 +523,10 @@ static void btc_gap_bt_search_services(UINT16 event, char *p_param)
*******************************************************************************/
static void bte_dm_search_services_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
{
tBTA_DM_SEARCH_PARAM search;
search.event = event;
search.p_data = p_data;
UINT16 param_len = 0;
if (p_data) {
param_len += sizeof(tBTA_DM_SEARCH);
@ -525,46 +539,46 @@ static void bte_dm_search_services_evt(tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH
}
} break;
}
/* TODO: The only other member that needs a deep copy is the p_raw_data. But not sure
* if raw_data is needed. */
search.len = param_len;
do {
btc_msg_t msg;
msg.sig = BTC_SIG_API_CALL;
msg.sig = BTC_SIG_API_CB;
msg.pid = BTC_PID_GAP_BT;
msg.act = BTC_GAP_BT_ACT_SEARCH_SERVICES;
msg.aid = event;
btc_transfer_context(&msg, p_data, param_len,
(param_len > sizeof(tBTA_DM_SEARCH)) ? search_services_copy_cb : NULL);
msg.act = BTC_GAP_BT_SEARCH_SERVICES_EVT;
btc_transfer_context(&msg, &search, sizeof(tBTA_DM_SEARCH_PARAM), search_services_copy_cb);
} while (0);
}
static void search_services_copy_cb(btc_msg_t *msg, void *p_dest, void *p_src)
{
tBTA_DM_SEARCH *p_dest_data = (tBTA_DM_SEARCH *) p_dest;
tBTA_DM_SEARCH *p_src_data = (tBTA_DM_SEARCH *) p_src;
tBTA_DM_SEARCH_PARAM *p_dest_data = (tBTA_DM_SEARCH_PARAM *) p_dest;
tBTA_DM_SEARCH_PARAM *p_src_data = (tBTA_DM_SEARCH_PARAM *) p_src;
if (!p_src) {
return;
}
p_dest_data->p_data = osi_malloc(p_dest_data->len);
memset(p_dest_data->p_data, 0x00, p_dest_data->len);
memcpy(p_dest_data->p_data, p_src_data->p_data, p_dest_data->len);
switch (msg->aid) {
case BTA_DM_DISC_RES_EVT: {
if (p_src_data->disc_res.result == BTA_SUCCESS) {
if (p_src_data->disc_res.num_uuids > 0) {
p_dest_data->disc_res.p_uuid_list = (UINT8 *)(p_dest + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->disc_res.p_uuid_list, p_src_data->disc_res.p_uuid_list,
p_src_data->disc_res.num_uuids * MAX_UUID_SIZE);
osi_free(p_src_data->disc_res.p_uuid_list);
p_src_data->disc_res.p_uuid_list = NULL;
}
if (p_src_data->disc_res.p_raw_data != NULL) {
osi_free(p_src_data->disc_res.p_raw_data);
p_src_data->disc_res.p_raw_data = NULL;
if ( p_dest_data->len > sizeof(tBTA_DM_SEARCH)){
switch (p_dest_data->event) {
case BTA_DM_DISC_RES_EVT: {
if (p_src_data->p_data->disc_res.result == BTA_SUCCESS) {
if (p_src_data->p_data->disc_res.num_uuids > 0) {
p_dest_data->p_data->disc_res.p_uuid_list = (UINT8 *)(p_dest_data->p_data + sizeof(tBTA_DM_SEARCH));
memcpy(p_dest_data->p_data->disc_res.p_uuid_list, p_src_data->p_data->disc_res.p_uuid_list,
p_src_data->p_data->disc_res.num_uuids * MAX_UUID_SIZE);
osi_free(p_src_data->p_data->disc_res.p_uuid_list);
p_src_data->p_data->disc_res.p_uuid_list = NULL;
}
if (p_src_data->p_data->disc_res.p_raw_data != NULL) {
osi_free(p_src_data->p_data->disc_res.p_raw_data);
p_src_data->p_data->disc_res.p_raw_data = NULL;
}
}
} break;
}
} break;
}
}
@ -603,7 +617,7 @@ static void btc_gap_bt_read_rssi_delta_cmpl_callback(void *p_data)
btc_msg_t msg;
msg.sig = BTC_SIG_API_CB;
msg.pid = BTC_PID_GAP_BT;
msg.act = ESP_BT_GAP_READ_RSSI_DELTA_EVT;
msg.act = BTC_GAP_BT_READ_RSSI_DELTA_EVT;
memcpy(param.read_rssi_delta.bda, result->rem_bda, sizeof(BD_ADDR));
param.read_rssi_delta.stat = btc_btm_status_to_esp_status(result->status);
param.read_rssi_delta.rssi_delta = result->rssi;
@ -612,7 +626,7 @@ static void btc_gap_bt_read_rssi_delta_cmpl_callback(void *p_data)
sizeof(esp_bt_gap_cb_param_t), NULL);
if (ret != BT_STATUS_SUCCESS) {
LOG_ERROR("%s btc_transfer_context failed\n", __func__);
BTC_TRACE_ERROR("%s btc_transfer_context failed\n", __func__);
}
}
@ -645,10 +659,6 @@ void btc_gap_bt_call_handler(btc_msg_t *msg)
btc_gap_bt_start_discovery(msg->arg);
break;
}
case BTC_GAP_BT_ACT_SEARCH_DEVICES: {
btc_gap_bt_search_devices_evt(msg->aid, msg->arg);
break;
}
case BTC_GAP_BT_ACT_CANCEL_DISCOVERY: {
btc_gap_bt_cancel_discovery();
break;
@ -657,18 +667,10 @@ void btc_gap_bt_call_handler(btc_msg_t *msg)
btc_gap_bt_get_remote_services(msg->arg);
break;
}
case BTC_GAP_BT_ACT_SEARCH_SERVICES: {
btc_gap_bt_search_services(msg->aid, msg->arg);
break;
}
case BTC_GAP_BT_ACT_GET_REMOTE_SERVICE_RECORD: {
btc_gap_bt_get_remote_service_record(msg->arg);
break;
}
case BTC_GAP_BT_ACT_SEARCH_SERVICE_RECORD: {
btc_gap_bt_search_service_record(msg->aid, msg->arg);
break;
}
case BTC_GAP_BT_ACT_SET_COD: {
btc_gap_bt_set_cod(msg->arg);
break;
@ -704,15 +706,50 @@ void btc_gap_bt_busy_level_updated(uint8_t bl_flags)
}
}
void btc_gap_bt_cb_deep_free(btc_msg_t *msg)
{
switch (msg->act) {
case BTC_GAP_BT_SEARCH_DEVICES_EVT:
case BTC_GAP_BT_SEARCH_SERVICES_EVT:
case BTC_GAP_BT_SEARCH_SERVICE_RECORD_EVT:
osi_free(((tBTA_DM_SEARCH_PARAM *) (msg->arg)) ->p_data);
break;
case BTC_GAP_BT_READ_RSSI_DELTA_EVT:
case BTC_GAP_BT_AUTH_CMPL_EVT:
break;
default:
BTC_TRACE_ERROR("%s: Unhandled event (%d)!\n", __FUNCTION__, msg->act);
break;
}
}
void btc_gap_bt_cb_handler(btc_msg_t *msg)
{
esp_bt_gap_cb_param_t *param = (esp_bt_gap_cb_param_t *)msg->arg;
if (msg->act < ESP_BT_GAP_EVT_MAX) {
btc_gap_bt_cb_to_app(msg->act, param);
} else {
LOG_ERROR("%s, unknow msg->act = %d", __func__, msg->act);
switch (msg->act) {
case BTC_GAP_BT_SEARCH_DEVICES_EVT: {
btc_gap_bt_search_devices_evt(msg->arg);
break;
}
case BTC_GAP_BT_SEARCH_SERVICES_EVT: {
btc_gap_bt_search_services(msg->arg);
break;
}
case BTC_GAP_BT_SEARCH_SERVICE_RECORD_EVT: {
btc_gap_bt_search_service_record(msg->arg);
break;
}
case BTC_GAP_BT_READ_RSSI_DELTA_EVT:{
btc_gap_bt_cb_to_app(ESP_BT_GAP_READ_RSSI_DELTA_EVT, (esp_bt_gap_cb_param_t *)msg->arg);
break;
}
case BTC_GAP_BT_AUTH_CMPL_EVT:{
btc_gap_bt_cb_to_app(ESP_BT_GAP_AUTH_CMPL_EVT, (esp_bt_gap_cb_param_t *)msg->arg);
break;
}
default:
BTC_TRACE_ERROR("%s: Unhandled event (%d)!\n", __FUNCTION__, msg->act);
break;
}
btc_gap_bt_cb_deep_free(msg);
}
#endif /* (BTC_GAP_BT_INCLUDED == TRUE) */

15
components/bt/bluedroid/btc/profile/std/include/btc_gap_bt.h
View file

@ -22,17 +22,20 @@
#include "bta/utl.h"
#if (BTC_GAP_BT_INCLUDED == TRUE)
typedef enum {
BTC_GAP_BT_SEARCH_DEVICES_EVT = 0,
BTC_GAP_BT_SEARCH_SERVICES_EVT,
BTC_GAP_BT_SEARCH_SERVICE_RECORD_EVT,
BTC_GAP_BT_READ_RSSI_DELTA_EVT,
BTC_GAP_BT_AUTH_CMPL_EVT,
}btc_gap_bt_evt_t;
typedef enum {
BTC_GAP_BT_ACT_SET_SCAN_MODE = 0,
BTC_GAP_BT_ACT_REG_CB,
BTC_GAP_BT_ACT_START_DISCOVERY,
BTC_GAP_BT_ACT_SEARCH_DEVICES,
BTC_GAP_BT_ACT_CANCEL_DISCOVERY,
BTC_GAP_BT_ACT_GET_REMOTE_SERVICES,
BTC_GAP_BT_ACT_SEARCH_SERVICES,
BTC_GAP_BT_ACT_GET_REMOTE_SERVICE_RECORD,
BTC_GAP_BT_ACT_SEARCH_SERVICE_RECORD,
BTC_GAP_BT_ACT_SET_COD,
BTC_GAP_BT_ACT_READ_RSSI_DELTA,
BTC_GAP_BT_ACT_REMOVE_BOND_DEVICE,
@ -52,10 +55,10 @@ typedef union {
uint8_t num_rsps;
} start_disc;
// BTC_BT_GAP_ACT_GET_REMOTE_SERVICES
// BTC_GAP_BT_ACT_GET_REMOTE_SERVICES
bt_bdaddr_t bda;
// BTC_BT_GAP_ACT_GET_REMTOE_SERVICE_RECORD
// BTC_GAP_BT_ACT_GET_REMOTE_SERVICE_RECORD
struct get_rmt_srv_rcd_args {
bt_bdaddr_t bda;
esp_bt_uuid_t uuid;