/** This function forces to close the connection to a remote device and
* optionaly remove the device from security database if required. */
void bta_dm_close_acl(const RawAddress& bd_addr, bool remove_dev,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
uint8_t index;
APPL_TRACE_DEBUG("bta_dm_close_acl");
/** Bonds with peer device */
void bta_dm_bond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
- tBTA_TRANSPORT transport, int device_type) {
+ tBT_TRANSPORT transport, int device_type) {
tBTA_DM_SEC sec_event;
char* p_name;
******************************************************************************/
static void bta_dm_discover_device(const RawAddress& remote_bd_addr) {
tBT_TRANSPORT transport = BT_TRANSPORT_BR_EDR;
- if (bta_dm_search_cb.transport == BTA_TRANSPORT_UNKNOWN) {
+ if (bta_dm_search_cb.transport == BT_TRANSPORT_UNKNOWN) {
tBT_DEVICE_TYPE dev_type;
tBLE_ADDR_TYPE addr_type;
}
/* Reset transport state for next discovery */
- bta_dm_search_cb.transport = BTA_TRANSPORT_UNKNOWN;
+ bta_dm_search_cb.transport = BT_TRANSPORT_UNKNOWN;
VLOG(1) << __func__ << " BDA: " << remote_bd_addr;
}
/**This function to encrypt the link */
-void bta_dm_set_encryption(const RawAddress& bd_addr, tBTA_TRANSPORT transport,
+void bta_dm_set_encryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
tBTA_DM_ENCRYPT_CBACK* p_callback,
tBTM_BLE_SEC_ACT sec_act) {
uint8_t i;
/** This function initiates a bonding procedure with a peer device */
void BTA_DmBond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
- tBTA_TRANSPORT transport, int device_type) {
+ tBT_TRANSPORT transport, int device_type) {
do_in_main_thread(FROM_HERE, base::Bind(bta_dm_bond, bd_addr, addr_type,
transport, device_type));
}
static void bta_dm_discover_send_msg(const RawAddress& bd_addr,
tBTA_SERVICE_MASK_EXT* p_services,
tBTA_DM_SEARCH_CBACK* p_cback,
- bool sdp_search,
- tBTA_TRANSPORT transport) {
+ bool sdp_search, tBT_TRANSPORT transport) {
const size_t len =
p_services
? (sizeof(tBTA_DM_API_DISCOVER) + sizeof(Uuid) * p_services->num_uuid)
void BTA_DmDiscoverByTransport(const RawAddress& bd_addr,
tBTA_SERVICE_MASK_EXT* p_services,
tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport);
}
* Returns void
*
******************************************************************************/
-void BTA_DmSetEncryption(const RawAddress& bd_addr, tBTA_TRANSPORT transport,
+void BTA_DmSetEncryption(const RawAddress& bd_addr, tBT_TRANSPORT transport,
tBTA_DM_ENCRYPT_CBACK* p_callback,
tBTM_BLE_SEC_ACT sec_act) {
APPL_TRACE_API("%s", __func__);
*
******************************************************************************/
void BTA_DmCloseACL(const RawAddress& bd_addr, bool remove_dev,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
do_in_main_thread(
FROM_HERE, base::Bind(bta_dm_close_acl, bd_addr, remove_dev, transport));
}
tBTA_SERVICE_MASK services;
tBTA_DM_SEARCH_CBACK* p_cback;
bool sdp_search;
- tBTA_TRANSPORT transport;
+ tBT_TRANSPORT transport;
uint8_t num_uuid;
bluetooth::Uuid* p_uuid;
bluetooth::Uuid uuid;
uint8_t peer_scn;
bool sdp_search;
bool cancel_pending; /* inquiry cancel is pending */
- tBTA_TRANSPORT transport;
+ tBT_TRANSPORT transport;
tBTA_DM_SEARCH_CBACK* p_scan_cback;
tGATT_IF client_if;
uint8_t num_uuid;
extern void bta_dm_set_visibility(tBTA_DM_DISC, tBTA_DM_CONN, uint8_t, uint8_t);
extern void bta_dm_set_scan_config(tBTA_DM_MSG* p_data);
extern void bta_dm_vendor_spec_command(tBTA_DM_MSG* p_data);
-extern void bta_dm_bond(const RawAddress&, tBLE_ADDR_TYPE, tBTA_TRANSPORT, int);
+extern void bta_dm_bond(const RawAddress&, tBLE_ADDR_TYPE, tBT_TRANSPORT, int);
extern void bta_dm_bond_cancel(const RawAddress&);
extern void bta_dm_pin_reply(std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg);
extern void bta_dm_add_device(std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg);
extern void bta_dm_remove_device(const RawAddress& bd_addr);
-extern void bta_dm_close_acl(const RawAddress&, bool, tBTA_TRANSPORT);
+extern void bta_dm_close_acl(const RawAddress&, bool, tBT_TRANSPORT);
extern void bta_dm_pm_btm_status(const RawAddress&, tBTM_PM_STATUS, uint16_t,
uint8_t);
extern void bta_dm_ble_get_energy_info(tBTA_BLE_ENERGY_INFO_CBACK*);
-extern void bta_dm_set_encryption(const RawAddress&, tBTA_TRANSPORT,
+extern void bta_dm_set_encryption(const RawAddress&, tBT_TRANSPORT,
tBTA_DM_ENCRYPT_CBACK*, tBTM_BLE_SEC_ACT);
extern void bta_dm_confirm(const RawAddress&, bool);
if (p_clcb->p_rcb) {
/* there is no RM for GATT */
- if (p_clcb->transport == BTA_TRANSPORT_BR_EDR)
+ if (p_clcb->transport == BT_TRANSPORT_BR_EDR)
bta_sys_conn_open(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda);
bta_gattc_send_open_cback(p_clcb->p_rcb, GATT_SUCCESS, p_clcb->bda,
cb_data.close.status = p_clcb->status;
cb_data.close.remote_bda = p_clcb->bda;
- if (p_clcb->transport == BTA_TRANSPORT_BR_EDR)
+ if (p_clcb->transport == BT_TRANSPORT_BR_EDR)
bta_sys_conn_close(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda);
bta_gattc_clcb_dealloc(p_clcb);
p_clcb->p_srcb->update_count = 0;
p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC_ACT;
- if (p_clcb->transport == BTA_TRANSPORT_LE)
+ if (p_clcb->transport == BT_TRANSPORT_LE)
L2CA_EnableUpdateBleConnParams(p_clcb->p_srcb->server_bda, false);
/* set all srcb related clcb into discovery ST */
VLOG(1) << __func__ << ": conn_id=" << loghex(p_clcb->bta_conn_id);
- if (p_clcb->transport == BTA_TRANSPORT_LE)
+ if (p_clcb->transport == BT_TRANSPORT_LE)
L2CA_EnableUpdateBleConnParams(p_clcb->p_srcb->server_bda, true);
p_clcb->p_srcb->state = BTA_GATTC_SERV_IDLE;
p_clcb->disc_active = false;
LOG(ERROR) << __func__ << ": to handle=" << loghex(handle) << " failed";
} else {
/* if over BR_EDR, inform PM for mode change */
- if (p_clcb->transport == BTA_TRANSPORT_BR_EDR) {
+ if (p_clcb->transport == BT_TRANSPORT_BR_EDR) {
bta_sys_busy(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda);
bta_sys_idle(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda);
}
tBTA_GATTC_NOTIFY notify;
RawAddress remote_bda;
tGATT_IF gatt_if;
- tBTA_TRANSPORT transport;
+ tBT_TRANSPORT transport;
if (!GATT_GetConnectionInfor(conn_id, &gatt_if, remote_bda, &transport)) {
LOG(ERROR) << __func__ << ": indication/notif for unknown app";
}
/* if over BR_EDR, inform PM for mode change */
- if (p_clcb->transport == BTA_TRANSPORT_BR_EDR) {
+ if (p_clcb->transport == BT_TRANSPORT_BR_EDR) {
bta_sys_busy(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda);
bta_sys_idle(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda);
}
tBTA_GATTC_CLCB* p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id);
if (!p_clcb) return GATT_ERROR;
- if (p_clcb->transport == BTA_TRANSPORT_LE) {
+ if (p_clcb->transport == BT_TRANSPORT_LE) {
return GATTC_Discover(conn_id, disc_type, 0x0001, 0xFFFF);
}
#include <base/logging.h>
#include <base/strings/stringprintf.h>
+#include "types/bt_transport.h"
/*****************************************************************************
* Constants and data types
RawAddress remote_bda;
tGATT_IF client_if;
bool is_direct;
- tBTA_TRANSPORT transport;
+ tBT_TRANSPORT transport;
uint8_t initiating_phys;
bool opportunistic;
} tBTA_GATTC_API_OPEN;
typedef struct {
uint16_t bta_conn_id; /* client channel ID, unique for clcb */
RawAddress bda;
- tBTA_TRANSPORT transport; /* channel transport */
+ tBT_TRANSPORT transport; /* channel transport */
tBTA_GATTC_RCB* p_rcb; /* pointer to the registration CB */
tBTA_GATTC_SERV* p_srcb; /* server cache CB */
tBTA_GATTC_DATA* p_q_cmd; /* command in queue waiting for execution */
extern void bta_gattc_send_open_cback(tBTA_GATTC_RCB* p_clreg,
tGATT_STATUS status,
const RawAddress& remote_bda,
- uint16_t conn_id,
- tBTA_TRANSPORT transport, uint16_t mtu);
+ uint16_t conn_id, tBT_TRANSPORT transport,
+ uint16_t mtu);
extern void bta_gattc_process_api_refresh(const RawAddress& remote_bda);
extern void bta_gattc_cfg_mtu(tBTA_GATTC_CLCB* p_clcb, tBTA_GATTC_DATA* p_data);
extern void bta_gattc_listen(tBTA_GATTC_DATA* p_msg);
/* utility functions */
extern tBTA_GATTC_CLCB* bta_gattc_find_clcb_by_cif(uint8_t client_if,
const RawAddress& remote_bda,
- tBTA_TRANSPORT transport);
+ tBT_TRANSPORT transport);
extern tBTA_GATTC_CLCB* bta_gattc_find_clcb_by_conn_id(uint16_t conn_id);
extern tBTA_GATTC_CLCB* bta_gattc_clcb_alloc(tGATT_IF client_if,
const RawAddress& remote_bda,
- tBTA_TRANSPORT transport);
+ tBT_TRANSPORT transport);
extern void bta_gattc_clcb_dealloc(tBTA_GATTC_CLCB* p_clcb);
extern tBTA_GATTC_CLCB* bta_gattc_find_alloc_clcb(tGATT_IF client_if,
const RawAddress& remote_bda,
- tBTA_TRANSPORT transport);
+ tBT_TRANSPORT transport);
extern tBTA_GATTC_RCB* bta_gattc_cl_get_regcb(uint8_t client_if);
extern tBTA_GATTC_SERV* bta_gattc_find_srcb(const RawAddress& bda);
extern tBTA_GATTC_SERV* bta_gattc_srcb_alloc(const RawAddress& bda);
******************************************************************************/
tBTA_GATTC_CLCB* bta_gattc_find_clcb_by_cif(uint8_t client_if,
const RawAddress& remote_bda,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
tBTA_GATTC_CLCB* p_clcb = &bta_gattc_cb.clcb[0];
uint8_t i;
******************************************************************************/
tBTA_GATTC_CLCB* bta_gattc_clcb_alloc(tGATT_IF client_if,
const RawAddress& remote_bda,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
uint8_t i_clcb = 0;
tBTA_GATTC_CLCB* p_clcb = NULL;
******************************************************************************/
tBTA_GATTC_CLCB* bta_gattc_find_alloc_clcb(tGATT_IF client_if,
const RawAddress& remote_bda,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
tBTA_GATTC_CLCB* p_clcb;
p_clcb = bta_gattc_find_clcb_by_cif(client_if, remote_bda, transport);
******************************************************************************/
void bta_gattc_send_open_cback(tBTA_GATTC_RCB* p_clreg, tGATT_STATUS status,
const RawAddress& remote_bda, uint16_t conn_id,
- tBTA_TRANSPORT transport, uint16_t mtu) {
+ tBT_TRANSPORT transport, uint16_t mtu) {
tBTA_GATTC cb_data;
if (p_clreg->p_cback) {
tGATT_STATUS status = GATT_ILLEGAL_PARAMETER;
tGATT_IF gatt_if;
RawAddress remote_bda;
- tBTA_TRANSPORT transport;
+ tBT_TRANSPORT transport;
tBTA_GATTS cb_data;
p_srvc_cb =
p_msg->api_indicate.len, p_msg->api_indicate.value);
/* if over BR_EDR, inform PM for mode change */
- if (transport == BTA_TRANSPORT_BR_EDR) {
+ if (transport == BT_TRANSPORT_BR_EDR) {
bta_sys_busy(BTA_ID_GATTS, BTA_ALL_APP_ID, remote_bda);
bta_sys_idle(BTA_ID_GATTS, BTA_ALL_APP_ID, remote_bda);
}
p_rcb = bta_gatts_find_app_rcb_by_app_if(gatt_if);
if (p_rcb && p_rcb->p_cback) {
- if (transport == BTA_TRANSPORT_BR_EDR)
+ if (transport == BT_TRANSPORT_BR_EDR)
bta_sys_conn_close(BTA_ID_GATTS, BTA_ALL_APP_ID, remote_bda);
tBTA_GATTS bta_gatts;
if (p_rcb && p_rcb->p_cback) {
/* if over BR_EDR, inform PM for mode change */
- if (transport == BTA_TRANSPORT_BR_EDR) {
+ if (transport == BT_TRANSPORT_BR_EDR) {
bta_sys_busy(BTA_ID_GATTS, BTA_ALL_APP_ID, cb_data.req_data.remote_bda);
bta_sys_idle(BTA_ID_GATTS, BTA_ALL_APP_ID, cb_data.req_data.remote_bda);
}
if (p_reg && p_reg->p_cback) {
/* there is no RM for GATT */
- if (transport == BTA_TRANSPORT_BR_EDR) {
+ if (transport == BT_TRANSPORT_BR_EDR) {
if (connected)
bta_sys_conn_open(BTA_ID_GATTS, BTA_ALL_APP_ID, bdaddr);
else
void OnGattConnected(tGATT_STATUS status, uint16_t conn_id,
tGATT_IF client_if, RawAddress address,
- tBTA_TRANSPORT transport, uint16_t mtu) {
+ tBT_TRANSPORT transport, uint16_t mtu) {
VLOG(2) << __func__ << ": address=" << address << ", conn_id=" << conn_id;
HearingDevice* hearingDevice = hearingDevices.FindByAddress(address);
if (sec_flag & BTM_SEC_FLAG_LKEY_KNOWN) {
/* if bonded and link not encrypted */
sec_flag = BTM_BLE_SEC_ENCRYPT;
- BTM_SetEncryption(address, BTA_TRANSPORT_LE, encryption_callback, nullptr,
+ BTM_SetEncryption(address, BT_TRANSPORT_LE, encryption_callback, nullptr,
sec_flag);
return;
}
else if (sec_flag & BTM_SEC_FLAG_LKEY_KNOWN) {
sec_flag = BTM_BLE_SEC_ENCRYPT;
p_cb->status = BTA_HH_ERR_AUTH_FAILED;
- BTM_SetEncryption(p_cb->addr, BTA_TRANSPORT_LE, bta_hh_le_encrypt_cback,
+ BTM_SetEncryption(p_cb->addr, BT_TRANSPORT_LE, bta_hh_le_encrypt_cback,
NULL, sec_flag);
}
/* unbonded device, report security error here */
sec_flag = BTM_BLE_SEC_ENCRYPT_NO_MITM;
p_cb->status = BTA_HH_ERR_AUTH_FAILED;
bta_hh_clear_service_cache(p_cb);
- BTM_SetEncryption(p_cb->addr, BTA_TRANSPORT_LE, bta_hh_le_encrypt_cback,
+ BTM_SetEncryption(p_cb->addr, BT_TRANSPORT_LE, bta_hh_le_encrypt_cback,
NULL, sec_flag);
}
/* otherwise let it go through */
/* Encryption callback*/
typedef void(tBTA_DM_ENCRYPT_CBACK)(const RawAddress& bd_addr,
- tBTA_TRANSPORT transport,
+ tBT_TRANSPORT transport,
tBTA_STATUS result);
#define BTA_DM_BLE_SEC_NONE BTM_BLE_SEC_NONE
*
******************************************************************************/
extern void BTA_DmBond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
- tBTA_TRANSPORT transport, int device_type);
+ tBT_TRANSPORT transport, int device_type);
/*******************************************************************************
*
*
******************************************************************************/
extern void BTA_DmCloseACL(const RawAddress& bd_addr, bool remove_dev,
- tBTA_TRANSPORT transport);
+ tBT_TRANSPORT transport);
/* BLE related API functions */
/*******************************************************************************
extern void BTA_DmDiscoverByTransport(const RawAddress& bd_addr,
tBTA_SERVICE_MASK_EXT* p_services,
tBTA_DM_SEARCH_CBACK* p_cback,
- bool sdp_search,
- tBTA_TRANSPORT transport);
+ bool sdp_search, tBT_TRANSPORT transport);
/*******************************************************************************
*
*
******************************************************************************/
extern void BTA_DmSetEncryption(const RawAddress& bd_addr,
- tBTA_TRANSPORT transport,
+ tBT_TRANSPORT transport,
tBTA_DM_ENCRYPT_CBACK* p_callback,
tBTM_BLE_SEC_ACT sec_act);
uint16_t conn_id;
tGATT_IF client_if;
RawAddress remote_bda;
- tBTA_TRANSPORT transport;
+ tBT_TRANSPORT transport;
uint16_t mtu;
} tBTA_GATTC_OPEN;
static btif_dm_pairing_cb_t pairing_cb;
static btif_dm_oob_cb_t oob_cb;
static void btif_dm_cb_create_bond(const RawAddress bd_addr,
- tBTA_TRANSPORT transport);
+ tBT_TRANSPORT transport);
static void btif_update_remote_properties(const RawAddress& bd_addr,
BD_NAME bd_name, DEV_CLASS dev_class,
tBT_DEVICE_TYPE dev_type);
}
invoke_bond_state_changed_cb(BT_STATUS_SUCCESS, address, bond_state);
- btif_dm_get_remote_services_by_transport(&address, BTA_TRANSPORT_UNKNOWN);
+ btif_dm_get_remote_services_by_transport(&address, BT_TRANSPORT_UNKNOWN);
}
void btif_dm_init(uid_set_t* set) {
*
******************************************************************************/
static void btif_dm_cb_create_bond(const RawAddress bd_addr,
- tBTA_TRANSPORT transport) {
+ tBT_TRANSPORT transport) {
bool is_hid = check_cod(&bd_addr, COD_HID_POINTING);
bond_state_changed(BT_STATUS_SUCCESS, bd_addr, BT_BOND_STATE_BONDING);
BTIF_TRACE_WARNING("%s() - Pairing timeout; retrying (%d) ...",
__func__, pairing_cb.timeout_retries);
--pairing_cb.timeout_retries;
- btif_dm_cb_create_bond(bd_addr, BTA_TRANSPORT_UNKNOWN);
+ btif_dm_cb_create_bond(bd_addr, BT_TRANSPORT_UNKNOWN);
return;
}
FALLTHROUGH_INTENDED; /* FALLTHROUGH */
/* Create the Bond once again */
BTIF_TRACE_WARNING("%s() auto pair failed. Reinitiate Bond",
__func__);
- btif_dm_cb_create_bond(bd_addr, BTA_TRANSPORT_UNKNOWN);
+ btif_dm_cb_create_bond(bd_addr, BT_TRANSPORT_UNKNOWN);
return;
} else {
/* if autopair attempts are more than 1, or not attempted */
}
static void btif_gatt_set_encryption_cb(UNUSED_ATTR const RawAddress& bd_addr,
- UNUSED_ATTR tBTA_TRANSPORT transport,
+ UNUSED_ATTR tBT_TRANSPORT transport,
tBTA_STATUS result) {
if (result != BTA_SUCCESS && result != BTA_BUSY) {
BTIF_TRACE_WARNING("%s() - Encryption failed (%d)", __func__, result);
tBTM_STATUS Btm::CreateBond(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
tBT_TRANSPORT transport, int device_type) {
- if (transport == BTA_TRANSPORT_UNKNOWN) {
+ if (transport == BT_TRANSPORT_UNKNOWN) {
if (device_type & BT_DEVICE_TYPE_BLE) {
- transport = BTA_TRANSPORT_LE;
+ transport = BT_TRANSPORT_LE;
} else if (device_type & BT_DEVICE_TYPE_BREDR) {
- transport = BTA_TRANSPORT_BR_EDR;
+ transport = BT_TRANSPORT_BR_EDR;
}
LOG_DEBUG("%s guessing transport as %02x ", __func__, transport);
}