Replace BD_ADDR with bt_bdaddr_t in hf client related code (d2f32d5c) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/hf_client/bta_hf_client_act.cc

+19 −18

Original line number	Diff line number	Diff line
		@@ -63,9 +63,8 @@ void bta_hf_client_start_close(tBTA_HF_CLIENT_DATA* p_data) {
		}

		/* Take the link out of sniff and set L2C idle time to 0 */
		bta_dm_pm_active(from_BD_ADDR(client_cb->peer_addr));
		L2CA_SetIdleTimeoutByBdAddr(from_BD_ADDR(client_cb->peer_addr), 0,
		BT_TRANSPORT_BR_EDR);
		bta_dm_pm_active(client_cb->peer_addr);
		L2CA_SetIdleTimeoutByBdAddr(client_cb->peer_addr, 0, BT_TRANSPORT_BR_EDR);

		/* if SCO is open close SCO and wait on RFCOMM close */
		if (client_cb->sco_state == BTA_HF_CLIENT_SCO_OPEN_ST) {
		@@ -99,17 +98,18 @@ void bta_hf_client_start_open(tBTA_HF_CLIENT_DATA* p_data) {

		/* store parameters */
		if (p_data) {
		bdcpy(client_cb->peer_addr, p_data->api_open.bd_addr);
		client_cb->peer_addr = p_data->api_open.bd_addr;
		client_cb->cli_sec_mask = p_data->api_open.sec_mask;
		}

		/* Check if RFCOMM has any incoming connection to avoid collision. */
		BD_ADDR pending_bd_addr;
		if (PORT_IsOpening(pending_bd_addr)) {
		bt_bdaddr_t pending_bd_addr;
		if (PORT_IsOpening(to_BD_ADDR(pending_bd_addr))) {
		/* Let the incoming connection goes through. */
		/* Issue collision for now. */
		/* We will decide what to do when we find incoming connection later.*/
		bta_hf_client_collision_cback(0, BTA_ID_HS, 0, client_cb->peer_addr);
		bta_hf_client_collision_cback(0, BTA_ID_HS, 0,
		to_BD_ADDR(client_cb->peer_addr));
		return;
		}

		@@ -140,7 +140,7 @@ void bta_hf_client_rfc_open(tBTA_HF_CLIENT_DATA* p_data) {
		return;
		}

		bta_sys_conn_open(BTA_ID_HS, 1, client_cb->peer_addr);
		bta_sys_conn_open(BTA_ID_HS, 1, to_BD_ADDR(client_cb->peer_addr));

		/* start SLC procedure */
		bta_hf_client_slc_seq(client_cb, false);
		@@ -167,7 +167,7 @@ void bta_hf_client_rfc_acp_open(tBTA_HF_CLIENT_DATA* p_data) {
		}

		uint16_t lcid;
		BD_ADDR dev_addr;
		bt_bdaddr_t dev_addr;
		int status;

		/* set role */
		@@ -176,8 +176,9 @@ void bta_hf_client_rfc_acp_open(tBTA_HF_CLIENT_DATA* p_data) {
		APPL_TRACE_DEBUG("%s: conn_handle %d", __func__, client_cb->conn_handle);

		/* get bd addr of peer */
		if (PORT_SUCCESS != (status = PORT_CheckConnection(client_cb->conn_handle,
		dev_addr, &lcid))) {
		if (PORT_SUCCESS !=
		(status = PORT_CheckConnection(client_cb->conn_handle,
		to_BD_ADDR(dev_addr), &lcid))) {
		APPL_TRACE_DEBUG("%s: error PORT_CheckConnection returned status %d",
		__func__, status);
		}
		@@ -186,7 +187,7 @@ void bta_hf_client_rfc_acp_open(tBTA_HF_CLIENT_DATA* p_data) {
		if (alarm_is_scheduled(client_cb->collision_timer)) {
		alarm_cancel(client_cb->collision_timer);

		if (bdcmp(dev_addr, client_cb->peer_addr) == 0) {
		if (dev_addr == client_cb->peer_addr) {
		/* If incoming and outgoing device are same, nothing more to do. */
		/* Outgoing conn will be aborted because we have successful incoming conn.
		*/
		@@ -196,7 +197,7 @@ void bta_hf_client_rfc_acp_open(tBTA_HF_CLIENT_DATA* p_data) {
		}
		}

		bdcpy(client_cb->peer_addr, dev_addr);
		client_cb->peer_addr = dev_addr;

		/* do service discovery to get features */
		bta_hf_client_do_disc(client_cb);
		@@ -296,25 +297,25 @@ void bta_hf_client_rfc_close(tBTA_HF_CLIENT_DATA* p_data) {

		bta_hf_client_at_reset(client_cb);

		bta_sys_conn_close(BTA_ID_HS, 1, client_cb->peer_addr);
		bta_sys_conn_close(BTA_ID_HS, 1, to_BD_ADDR(client_cb->peer_addr));

		/* call close cback */
		tBTA_HF_CLIENT evt;
		memset(&evt, 0, sizeof(evt));
		bdcpy(evt.conn.bd_addr, client_cb->peer_addr);
		evt.conn.bd_addr = client_cb->peer_addr;

		/* if not deregistering reopen server */
		if (bta_hf_client_cb_arr.deregister == false) {
		/* Make sure SCO is shutdown */
		bta_hf_client_sco_shutdown(client_cb);

		bta_sys_sco_unuse(BTA_ID_HS, 1, client_cb->peer_addr);
		bta_sys_sco_unuse(BTA_ID_HS, 1, to_BD_ADDR(client_cb->peer_addr));
		}
		/* else close port and deallocate scb */
		else {
		tBTA_HF_CLIENT evt;
		memset(&evt, 0, sizeof(evt));
		bdcpy(evt.reg.bd_addr, client_cb->peer_addr);
		evt.reg.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_DISABLE_EVT, &evt);
		}
		}
		@@ -455,7 +456,7 @@ void bta_hf_client_svc_conn_open(tBTA_HF_CLIENT_DATA* p_data) {
		client_cb->svc_conn = true;

		/* call callback */
		bdcpy(evt.conn.bd_addr, client_cb->peer_addr);
		evt.conn.bd_addr = client_cb->peer_addr;
		evt.conn.peer_feat = client_cb->peer_features;
		evt.conn.chld_feat = client_cb->chld_features;

system/bta/hf_client/bta_hf_client_api.cc

+3 −2

Original line number	Diff line number	Diff line
		@@ -76,7 +76,8 @@ void BTA_HfClientDisable(void) { bta_hf_client_api_disable(); }
		* Returns void
		*
		******************************************************************************/
		void BTA_HfClientOpen(BD_ADDR bd_addr, tBTA_SEC sec_mask, uint16_t* p_handle) {
		void BTA_HfClientOpen(const bt_bdaddr_t& bd_addr, tBTA_SEC sec_mask,
		uint16_t* p_handle) {
		APPL_TRACE_DEBUG("%s", __func__);
		tBTA_HF_CLIENT_API_OPEN* p_buf =
		(tBTA_HF_CLIENT_API_OPEN*)osi_malloc(sizeof(tBTA_HF_CLIENT_API_OPEN));
		@@ -88,7 +89,7 @@ void BTA_HfClientOpen(BD_ADDR bd_addr, tBTA_SEC sec_mask, uint16_t* p_handle) {

		p_buf->hdr.event = BTA_HF_CLIENT_API_OPEN_EVT;
		p_buf->hdr.layer_specific = *p_handle;
		bdcpy(p_buf->bd_addr, bd_addr);
		p_buf->bd_addr = bd_addr;
		p_buf->sec_mask = sec_mask;

		bta_sys_sendmsg(p_buf);

system/bta/hf_client/bta_hf_client_at.cc

+9 −9

Original line number	Diff line number	Diff line
		@@ -573,7 +573,7 @@ void bta_hf_client_ind(tBTA_HF_CLIENT_CB* client_cb,
		evt.ind.type = type;
		evt.ind.value = value;

		bdcpy(evt.ind.bd_addr, client_cb->peer_addr);
		evt.ind.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_IND_EVT, &evt);
		}

		@@ -594,7 +594,7 @@ void bta_hf_client_evt_val(tBTA_HF_CLIENT_CB* client_cb,

		memset(&evt, 0, sizeof(evt));

		bdcpy(evt.val.bd_addr, client_cb->peer_addr);
		evt.val.bd_addr = client_cb->peer_addr;
		evt.val.value = value;

		bta_hf_client_app_callback(type, &evt);
		@@ -618,7 +618,7 @@ void bta_hf_client_operator_name(tBTA_HF_CLIENT_CB* client_cb, char* name) {
		strlcpy(evt.operator_name.name, name, BTA_HF_CLIENT_OPERATOR_NAME_LEN + 1);
		evt.operator_name.name[BTA_HF_CLIENT_OPERATOR_NAME_LEN] = '\0';

		bdcpy(evt.operator_name.bd_addr, client_cb->peer_addr);
		evt.operator_name.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_OPERATOR_NAME_EVT, &evt);
		}

		@@ -640,7 +640,7 @@ void bta_hf_client_clip(tBTA_HF_CLIENT_CB* client_cb, char* number) {
		strlcpy(evt.number.number, number, BTA_HF_CLIENT_NUMBER_LEN + 1);
		evt.number.number[BTA_HF_CLIENT_NUMBER_LEN] = '\0';

		bdcpy(evt.number.bd_addr, client_cb->peer_addr);
		evt.number.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_CLIP_EVT, &evt);
		}

		@@ -662,7 +662,7 @@ void bta_hf_client_ccwa(tBTA_HF_CLIENT_CB* client_cb, char* number) {
		strlcpy(evt.number.number, number, BTA_HF_CLIENT_NUMBER_LEN + 1);
		evt.number.number[BTA_HF_CLIENT_NUMBER_LEN] = '\0';

		bdcpy(evt.number.bd_addr, client_cb->peer_addr);
		evt.number.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_CCWA_EVT, &evt);
		}

		@@ -685,7 +685,7 @@ void bta_hf_client_at_result(tBTA_HF_CLIENT_CB* client_cb,
		evt.result.type = type;
		evt.result.cme = cme;

		bdcpy(evt.result.bd_addr, client_cb->peer_addr);
		evt.result.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_AT_RESULT_EVT, &evt);
		}

		@@ -717,7 +717,7 @@ void bta_hf_client_clcc(tBTA_HF_CLIENT_CB* client_cb, uint32_t idx,
		evt.clcc.number[BTA_HF_CLIENT_NUMBER_LEN] = '\0';
		}

		bdcpy(evt.clcc.bd_addr, client_cb->peer_addr);
		evt.clcc.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_CLCC_EVT, &evt);
		}

		@@ -741,7 +741,7 @@ void bta_hf_client_cnum(tBTA_HF_CLIENT_CB* client_cb, char* number,
		strlcpy(evt.cnum.number, number, BTA_HF_CLIENT_NUMBER_LEN + 1);
		evt.cnum.number[BTA_HF_CLIENT_NUMBER_LEN] = '\0';

		bdcpy(evt.cnum.bd_addr, client_cb->peer_addr);
		evt.cnum.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_CNUM_EVT, &evt);
		}

		@@ -763,7 +763,7 @@ void bta_hf_client_binp(tBTA_HF_CLIENT_CB* client_cb, char* number) {
		strlcpy(evt.number.number, number, BTA_HF_CLIENT_NUMBER_LEN + 1);
		evt.number.number[BTA_HF_CLIENT_NUMBER_LEN] = '\0';

		bdcpy(evt.number.bd_addr, client_cb->peer_addr);
		evt.number.bd_addr = client_cb->peer_addr;
		bta_hf_client_app_callback(BTA_HF_CLIENT_BINP_EVT, &evt);
		}

system/bta/hf_client/bta_hf_client_int.h

+5 −4

Original line number	Diff line number	Diff line
		@@ -105,7 +105,7 @@ enum {
		/* data type for BTA_HF_CLIENT_API_OPEN_EVT */
		typedef struct {
		BT_HDR hdr;
		BD_ADDR bd_addr;
		bt_bdaddr_t bd_addr;
		uint16_t* handle;
		tBTA_SEC sec_mask;
		} tBTA_HF_CLIENT_API_OPEN;
		@@ -162,7 +162,7 @@ typedef struct {
		// Fields useful for particular control block.
		uint8_t handle; /* Handle of the control block to be
		used by upper layer */
		BD_ADDR peer_addr; /* peer bd address */
		bt_bdaddr_t peer_addr; /* peer bd address */
		tSDP_DISCOVERY_DB* p_disc_db; /* pointer to discovery database */
		uint16_t conn_handle; /* RFCOMM handle of connected service */
		tBTA_SEC cli_sec_mask; /* client security mask */
		@@ -205,14 +205,15 @@ extern tBTA_HF_CLIENT_CB_ARR bta_hf_client_cb_arr;

		/* main functions */
		extern tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_handle(uint16_t handle);
		extern tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_bda(const BD_ADDR bd_addr);
		extern tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_bda(
		const bt_bdaddr_t& bd_addr);
		extern tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_rfc_handle(uint16_t handle);
		extern tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_sco_handle(uint16_t handle);
		extern bool bta_hf_client_hdl_event(BT_HDR* p_msg);
		extern void bta_hf_client_sm_execute(uint16_t event,
		tBTA_HF_CLIENT_DATA* p_data);
		extern void bta_hf_client_slc_seq(tBTA_HF_CLIENT_CB* client_cb, bool error);
		extern bool bta_hf_client_allocate_handle(const BD_ADDR bd_addr,
		extern bool bta_hf_client_allocate_handle(const bt_bdaddr_t& bd_addr,
		uint16_t* p_handle);
		extern void bta_hf_client_app_callback(uint16_t event, tBTA_HF_CLIENT* data);
		extern void bta_hf_client_collision_cback(tBTA_SYS_CONN_STATUS status,

system/bta/hf_client/bta_hf_client_main.cc

+20 −27

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		*
		******************************************************************************/

		#include <base/logging.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		@@ -366,7 +367,8 @@ static void bta_hf_client_collision_timer_cback(void* data) {
		void bta_hf_client_collision_cback(UNUSED_ATTR tBTA_SYS_CONN_STATUS status,
		uint8_t id, UNUSED_ATTR uint8_t app_id,
		BD_ADDR peer_addr) {
		tBTA_HF_CLIENT_CB* client_cb = bta_hf_client_find_cb_by_bda(peer_addr);
		tBTA_HF_CLIENT_CB* client_cb =
		bta_hf_client_find_cb_by_bda(from_BD_ADDR(peer_addr));
		if (client_cb != NULL && client_cb->state == BTA_HF_CLIENT_OPENING_ST) {
		if (id == BTA_ID_SYS) /* ACL collision */
		{
		@@ -482,19 +484,19 @@ tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_handle(uint16_t handle) {
		*
		* Description Finds the control block by handle provided
		*
		* bda: BD_ADDR of the device to find the handle for.
		* bda: address of the device to find the handle for.
		* Since there can only be one HF connection for a device
		* we should always find a unique block
		*
		* Returns Control block corresponding to the BD_ADDR and NULL if
		* Returns Control block corresponding to the address and NULL if
		* none exists
		*
		******************************************************************************/
		tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_bda(const BD_ADDR peer_addr) {
		tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_bda(const bt_bdaddr_t& peer_addr) {
		for (int i = 0; i < HF_CLIENT_MAX_DEVICES; i++) {
		// Check if the associated index is allocated and that BD ADDR matches
		tBTA_HF_CLIENT_CB* client_cb = &bta_hf_client_cb_arr.cb[i];
		if (client_cb->is_allocated && !bdcmp(peer_addr, client_cb->peer_addr)) {
		if (client_cb->is_allocated && peer_addr == client_cb->peer_addr) {
		return client_cb;
		} else {
		APPL_TRACE_WARNING("%s: bdaddr mismatch for handle %d alloc %d", __func__,
		@@ -580,7 +582,8 @@ tBTA_HF_CLIENT_CB* bta_hf_client_find_cb_by_sco_handle(uint16_t handle) {
		* Returns true if the creation of p_handle succeeded, false otherwise
		*
		******************************************************************************/
		bool bta_hf_client_allocate_handle(const BD_ADDR bd_addr, uint16_t* p_handle) {
		bool bta_hf_client_allocate_handle(const bt_bdaddr_t& bd_addr,
		uint16_t* p_handle) {
		tBTA_HF_CLIENT_CB* existing_cb = bta_hf_client_find_cb_by_bda(bd_addr);
		if (existing_cb != NULL) {
		BTIF_TRACE_ERROR("%s: cannot allocate handle since BDADDR already exists",
		@@ -605,7 +608,7 @@ bool bta_hf_client_allocate_handle(const BD_ADDR bd_addr, uint16_t* p_handle) {
		client_cb->handle);

		client_cb->is_allocated = true;
		bdcpy(client_cb->peer_addr, bd_addr);
		client_cb->peer_addr = bd_addr;
		bta_hf_client_at_init(client_cb);
		return true;
		}
		@@ -744,16 +747,11 @@ void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) {

		/* If the state has changed then notify the app of the corresponding change */
		if (in_state != client_cb->state) {
		APPL_TRACE_DEBUG(
		"%s: notifying state change to %d -> %d "
		"device %02x:%02x:%02x:%02x:%02x:%02x",
		__func__, in_state, client_cb->state, client_cb->peer_addr[0],
		client_cb->peer_addr[1], client_cb->peer_addr[2],
		client_cb->peer_addr[3], client_cb->peer_addr[4],
		client_cb->peer_addr[5]);
		VLOG(1) << __func__ << ": notifying state change to " << in_state << " -> "
		<< client_cb->state << " device " << client_cb->peer_addr;
		tBTA_HF_CLIENT evt;
		memset(&evt, 0, sizeof(evt));
		bdcpy(evt.bd_addr, client_cb->peer_addr);
		evt.bd_addr = client_cb->peer_addr;
		if (client_cb->state == BTA_HF_CLIENT_INIT_ST) {
		bta_hf_client_app_callback(BTA_HF_CLIENT_CLOSE_EVT, &evt);
		} else if (client_cb->state == BTA_HF_CLIENT_OPEN_ST) {
		@@ -769,14 +767,10 @@ void bta_hf_client_sm_execute(uint16_t event, tBTA_HF_CLIENT_DATA* p_data) {
		client_cb->is_allocated = false;
		}

		APPL_TRACE_EVENT(
		"%s: device %02x:%02x:%02x:%02x:%02x:%02x "
		"state change: [%s] -> [%s] after Event [%s]",
		__func__, client_cb->peer_addr[0], client_cb->peer_addr[1],
		client_cb->peer_addr[2], client_cb->peer_addr[3], client_cb->peer_addr[4],
		client_cb->peer_addr[5], bta_hf_client_state_str(in_state),
		bta_hf_client_state_str(client_cb->state),
		bta_hf_client_evt_str(in_event));
		VLOG(2) << __func__ << ": device " << client_cb->peer_addr
		<< "state change: [" << bta_hf_client_state_str(in_state) << "] -> ["
		<< bta_hf_client_state_str(client_cb->state) << "] after Event ["
		<< bta_hf_client_evt_str(in_event) << "]";
		}

		static void send_post_slc_cmd(tBTA_HF_CLIENT_CB* client_cb) {
		@@ -938,11 +932,10 @@ void bta_hf_client_dump_statistics(int fd) {

		dprintf(fd, " Control block #%d\n", i + 1);

		uint8_t* a = client_cb->peer_addr.address;
		// Device name
		dprintf(fd, " Peer Device: %02x:%02x:%02x:%02x:%02x:%02x\n",
		client_cb->peer_addr[0], client_cb->peer_addr[1],
		client_cb->peer_addr[2], client_cb->peer_addr[3],
		client_cb->peer_addr[4], client_cb->peer_addr[5]);
		dprintf(fd, " Peer Device: %02x:%02x:%02x:%02x:%02x:%02x\n", a[0], a[1],
		a[2], a[3], a[4], a[5]);

		// State machine state
		dprintf(fd, " State Machine State: %s\n",