Static address is seen on scanner after unpairing (c3890bf8) · Commits · e / os / android_packages_modules_Bluetooth

system/btif/src/btif_dm.c

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -1681,6 +1681,7 @@ static void btif_dm_upstreams_evt(UINT16 event, char* p_param)
	}		}
	/* clear control blocks */		/* clear control blocks */
	memset(&pairing_cb, 0, sizeof(btif_dm_pairing_cb_t));		memset(&pairing_cb, 0, sizeof(btif_dm_pairing_cb_t));
			pairing_cb.bond_type = BOND_TYPE_PERSISTENT;

	/* This function will also trigger the adapter_properties_cb		/* This function will also trigger the adapter_properties_cb
	** and bonded_devices_info_cb		** and bonded_devices_info_cb

system/stack/btm/btm_ble.c

+7 −1

Original line number	Original line	Diff line number	Diff line
	@@ -1798,9 +1798,15 @@ void btm_ble_conn_complete(UINT8 *p, UINT16 evt_len, BOOLEAN enhanced)
	else		else
	{		{
	role = HCI_ROLE_UNKNOWN;		role = HCI_ROLE_UNKNOWN;

	if (status != HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT)		if (status != HCI_ERR_DIRECTED_ADVERTISING_TIMEOUT)
			{
	btm_ble_set_conn_st(BLE_CONN_IDLE);		btm_ble_set_conn_st(BLE_CONN_IDLE);
			btm_ble_disable_resolving_list(BTM_BLE_RL_INIT, TRUE);
			}
			else
			{
			btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
			}
	}		}

	btm_ble_update_mode_operation(role, bda, status);		btm_ble_update_mode_operation(role, bda, status);

system/stack/btm/btm_ble_addr.c

+0 −27

Original line number	Original line	Diff line number	Diff line
	@@ -427,30 +427,6 @@ void btm_ble_resolve_random_addr(BD_ADDR random_bda, tBTM_BLE_RESOLVE_CBACK * p_
	/*******************************************************************************		/*******************************************************************************
	** address mapping between pseudo address and real connection address		** address mapping between pseudo address and real connection address
	*******************************************************************************/		*******************************************************************************/
	/*******************************************************************************
	**
	** Function btm_ble_map_bda_to_conn_bda
	**
	** Description This function map a BD address to the real connection address
	** and return the connection address type.
	*******************************************************************************/
	tBLE_ADDR_TYPE btm_ble_map_bda_to_conn_bda(BD_ADDR bd_addr)
	{
	tBTM_SEC_DEV_REC *p_dev_rec = NULL;
	BTM_TRACE_EVENT ("btm_ble_map_bda_to_conn_bda");
	if ((p_dev_rec = btm_find_dev (bd_addr)) != NULL &&
	(p_dev_rec->device_type & BT_DEVICE_TYPE_BLE) == BT_DEVICE_TYPE_BLE)
	{
	if (p_dev_rec->ble.ble_addr_type != BLE_ADDR_PUBLIC)
	{
	memcpy(bd_addr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
	}
	return p_dev_rec->ble.ble_addr_type;
	}
	else
	return BLE_ADDR_PUBLIC;
	}

	/*******************************************************************************		/*******************************************************************************
	**		**
	** Function btm_find_dev_by_identity_addr		** Function btm_find_dev_by_identity_addr
	@@ -506,9 +482,6 @@ BOOLEAN btm_identity_addr_to_random_pseudo(BD_ADDR bd_addr, UINT8 *p_addr_type,
	if (refresh && controller_get_interface()->get_ble_resolving_list_max_size() != 0)		if (refresh && controller_get_interface()->get_ble_resolving_list_max_size() != 0)
	btm_ble_read_resolving_list_entry(p_dev_rec);		btm_ble_read_resolving_list_entry(p_dev_rec);

	/* assign the original address to be the current report address */
	memcpy(bd_addr, p_dev_rec->bd_addr, BD_ADDR_LEN);

	/* assign the original address to be the current report address */		/* assign the original address to be the current report address */
	if (!btm_ble_init_pseudo_addr (p_dev_rec, bd_addr))		if (!btm_ble_init_pseudo_addr (p_dev_rec, bd_addr))
	memcpy(bd_addr, p_dev_rec->ble.pseudo_addr, BD_ADDR_LEN);		memcpy(bd_addr, p_dev_rec->ble.pseudo_addr, BD_ADDR_LEN);

system/stack/btm/btm_ble_bgconn.c

+23 −24

Original line number	Original line	Diff line number	Diff line
	@@ -392,13 +392,14 @@ BOOLEAN btm_ble_start_auto_conn(BOOLEAN start)
	btm_execute_wl_dev_operation();		btm_execute_wl_dev_operation();

	#if BLE_PRIVACY_SPT == TRUE		#if BLE_PRIVACY_SPT == TRUE
	btm_ble_enable_resolving_list_for_platform();		btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_INIT);
	#endif		#endif
	scan_int = (p_cb->scan_int == BTM_BLE_CONN_PARAM_UNDEF) ?		scan_int = (p_cb->scan_int == BTM_BLE_SCAN_PARAM_UNDEF) ?
	BTM_BLE_SCAN_SLOW_INT_1 : p_cb->scan_int;		BTM_BLE_SCAN_SLOW_INT_1 : p_cb->scan_int;
	scan_win = (p_cb->scan_win == BTM_BLE_CONN_PARAM_UNDEF) ?		scan_win = (p_cb->scan_win == BTM_BLE_SCAN_PARAM_UNDEF) ?
	BTM_BLE_SCAN_SLOW_WIN_1 : p_cb->scan_win;		BTM_BLE_SCAN_SLOW_WIN_1 : p_cb->scan_win;
	if (btm_cb.ble_ctr_cb.enabled)
			if (btm_cb.ble_ctr_cb.rl_state != BTM_BLE_RL_IDLE)
	{		{
	own_addr_type \|= BLE_ADDR_TYPE_ID_BIT;		own_addr_type \|= BLE_ADDR_TYPE_ID_BIT;
	peer_addr_type \|= BLE_ADDR_TYPE_ID_BIT;		peer_addr_type \|= BLE_ADDR_TYPE_ID_BIT;
	@@ -441,10 +442,8 @@ BOOLEAN btm_ble_start_auto_conn(BOOLEAN start)
	}		}
	else		else
	{		{
	#if 0		BTM_TRACE_DEBUG("conn_st = %d, not in auto conn state, cannot stop", p_cb->conn_state);
	BTM_TRACE_ERROR("conn_st = %d, not in auto conn state, can not stop.", p_cb->conn_state);
	exec = FALSE;		exec = FALSE;
	#endif
	}		}
	}		}
	return exec;		return exec;
	@@ -466,8 +465,8 @@ BOOLEAN btm_ble_start_auto_conn(BOOLEAN start)
	BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cback)		BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cback)
	{		{
	tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;		tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;
	UINT32 scan_int = p_cb->scan_int == BTM_BLE_CONN_PARAM_UNDEF ? BTM_BLE_SCAN_FAST_INT : p_cb->scan_int;		UINT32 scan_int = p_cb->scan_int == BTM_BLE_SCAN_PARAM_UNDEF ? BTM_BLE_SCAN_FAST_INT : p_cb->scan_int;
	UINT32 scan_win = p_cb->scan_win == BTM_BLE_CONN_PARAM_UNDEF ? BTM_BLE_SCAN_FAST_WIN : p_cb->scan_win;		UINT32 scan_win = p_cb->scan_win == BTM_BLE_SCAN_PARAM_UNDEF ? BTM_BLE_SCAN_FAST_WIN : p_cb->scan_win;

	BTM_TRACE_EVENT ("%s", __func__);		BTM_TRACE_EVENT ("%s", __func__);

	@@ -515,6 +514,9 @@ BOOLEAN btm_ble_start_select_conn(BOOLEAN start, tBTM_BLE_SEL_CBACK *p_select_cb
	}		}
	else if (background_connections_pending())		else if (background_connections_pending())
	{		{
			#if BLE_PRIVACY_SPT == TRUE
			btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
			#endif
	if (!btsnd_hcic_ble_set_scan_enable(TRUE, TRUE)) /* duplicate filtering enabled */		if (!btsnd_hcic_ble_set_scan_enable(TRUE, TRUE)) /* duplicate filtering enabled */
	return FALSE;		return FALSE;
	/* mark up inquiry status flag */		/* mark up inquiry status flag */
	@@ -575,19 +577,16 @@ void btm_ble_initiate_select_conn(BD_ADDR bda)
	** Returns none.		** Returns none.
	**		**
	*******************************************************************************/		*******************************************************************************/
	void btm_ble_suspend_bg_conn(void)		BOOLEAN btm_ble_suspend_bg_conn(void)
	{		{
	tBTM_BLE_CB *p_cb = &btm_cb.ble_ctr_cb;		BTM_TRACE_EVENT ("%s", __func__);
	BTM_TRACE_EVENT ("btm_ble_suspend_bg_conn");

	if (p_cb->bg_conn_type == BTM_BLE_CONN_AUTO)		if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_AUTO)
	{		return btm_ble_start_auto_conn(FALSE);
	btm_ble_start_auto_conn(FALSE);		else if (btm_cb.ble_ctr_cb.bg_conn_type == BTM_BLE_CONN_SELECTIVE)
	}		return btm_ble_start_select_conn(FALSE, NULL);
	else if (p_cb->bg_conn_type == BTM_BLE_CONN_SELECTIVE)
	{		return FALSE;
	btm_ble_start_select_conn(FALSE, NULL);
	}
	}		}
	/*******************************************************************************		/*******************************************************************************
	**		**

system/stack/btm/btm_ble_gap.c

+39 −27

Original line number	Original line	Diff line number	Diff line
	@@ -351,7 +351,7 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
	UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;		UINT32 scan_interval = !p_inq->scan_interval ? BTM_BLE_GAP_DISC_SCAN_INT : p_inq->scan_interval;
	UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;		UINT32 scan_window = !p_inq->scan_window ? BTM_BLE_GAP_DISC_SCAN_WIN : p_inq->scan_window;

	BTM_TRACE_EVENT ("BTM_BleObserve : scan_type:%d, %d, %d",btm_cb.btm_inq_vars.scan_type,		BTM_TRACE_EVENT ("%s : scan_type:%d, %d, %d", __func__, btm_cb.btm_inq_vars.scan_type,
	p_inq->scan_interval, p_inq->scan_window);		p_inq->scan_interval, p_inq->scan_window);

	if (!controller_get_interface()->supports_ble())		if (!controller_get_interface()->supports_ble())
	@@ -362,7 +362,7 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
	/* shared inquiry database, do not allow observe if any inquiry is active */		/* shared inquiry database, do not allow observe if any inquiry is active */
	if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))		if (BTM_BLE_IS_OBS_ACTIVE(btm_cb.ble_ctr_cb.scan_activity))
	{		{
	BTM_TRACE_ERROR("Observe Already Active");		BTM_TRACE_ERROR("%s Observe Already Active", __func__);
	return status;		return status;
	}		}

	@@ -377,6 +377,11 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
	p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE) ?		p_inq->scan_type = (p_inq->scan_type == BTM_BLE_SCAN_MODE_NONE) ?
	BTM_BLE_SCAN_MODE_ACTI: p_inq->scan_type;		BTM_BLE_SCAN_MODE_ACTI: p_inq->scan_type;
	/* assume observe always not using white list */		/* assume observe always not using white list */
			#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
			/* enable resolving list */
			btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
			#endif

	if (cmn_ble_vsc_cb.extended_scan_support == 0)		if (cmn_ble_vsc_cb.extended_scan_support == 0)
	{		{
	btsnd_hcic_ble_set_scan_params(p_inq->scan_type, (UINT16)scan_interval,		btsnd_hcic_ble_set_scan_params(p_inq->scan_type, (UINT16)scan_interval,
	@@ -391,16 +396,13 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
	BTM_BLE_DEFAULT_SFP);		BTM_BLE_DEFAULT_SFP);
	}		}

	#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)		p_inq->scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
	/* enable resolving list */		status = btm_ble_start_scan();
	btm_ble_enable_resolving_list_for_platform();
	#endif
	status = btm_ble_start_scan(BTM_BLE_DUPLICATE_DISABLE);
	}		}

	if (status == BTM_CMD_STARTED)		if (status == BTM_CMD_STARTED)
	{		{
	btm_cb.ble_ctr_cb.scan_activity \|= BTM_LE_OBSERVE_ACTIVE;		btm_cb.ble_ctr_cb.scan_activity \|= BTM_LE_OBSERVE_ACTIVE;

	if (duration != 0)		if (duration != 0)
	/* start observer timer */		/* start observer timer */
	btu_start_timer (&btm_cb.ble_ctr_cb.obs_timer_ent, BTU_TTYPE_BLE_OBSERVE, duration);		btu_start_timer (&btm_cb.ble_ctr_cb.obs_timer_ent, BTU_TTYPE_BLE_OBSERVE, duration);
	@@ -413,7 +415,7 @@ tBTM_STATUS BTM_BleObserve(BOOLEAN start, UINT8 duration,
	}		}
	else		else
	{		{
	BTM_TRACE_ERROR("Observe not active");		BTM_TRACE_ERROR("%s Observe not active", __func__);
	}		}

	return status;		return status;
	@@ -471,6 +473,7 @@ tBTM_STATUS BTM_BleBroadcast(BOOLEAN start)
	else if (!start)		else if (!start)
	{		{
	status = btm_ble_stop_adv();		status = btm_ble_stop_adv();
			btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
	}		}
	else		else
	{		{
	@@ -935,13 +938,17 @@ static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb,
	if ((p_dev_rec = btm_find_or_alloc_dev (p_cb->direct_bda.bda)) != NULL &&		if ((p_dev_rec = btm_find_or_alloc_dev (p_cb->direct_bda.bda)) != NULL &&
	p_dev_rec->ble.in_controller_list & BTM_RESOLVING_LIST_BIT)		p_dev_rec->ble.in_controller_list & BTM_RESOLVING_LIST_BIT)
	{		{
	btm_ble_enable_resolving_list();		btm_ble_enable_resolving_list(BTM_BLE_RL_ADV);
	memcpy(p_peer_addr_ptr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);		memcpy(p_peer_addr_ptr, p_dev_rec->ble.static_addr, BD_ADDR_LEN);
	*p_peer_addr_type = p_dev_rec->ble.static_addr_type;		*p_peer_addr_type = p_dev_rec->ble.static_addr_type;
	*p_own_addr_type = BLE_ADDR_RANDOM_ID;		*p_own_addr_type = BLE_ADDR_RANDOM_ID;
	return evt_type;		return evt_type;
	}		}
	/* otherwise fall though as normal directed adv */		/* otherwise fall though as normal directed adv */
			else
			{
			btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
			}
	}		}
	#endif		#endif
	/* direct adv mode does not have privacy, if privacy is not enabled */		/* direct adv mode does not have privacy, if privacy is not enabled */
	@@ -975,13 +982,11 @@ static UINT8 btm_set_conn_mode_adv_init_addr(tBTM_BLE_INQ_CB *p_cb,
	/* resolving list is empty, not enabled */		/* resolving list is empty, not enabled */
	*p_own_addr_type = BLE_ADDR_RANDOM;		*p_own_addr_type = BLE_ADDR_RANDOM;
	}		}

	/* privacy 1.1, or privacy 1.2, general discoverable/connectable mode, disable privacy in */		/* privacy 1.1, or privacy 1.2, general discoverable/connectable mode, disable privacy in */
	/* controller fall back to host based privacy */		/* controller fall back to host based privacy */
	else if (btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE)		else if (btm_cb.ble_ctr_cb.privacy_mode != BTM_PRIVACY_NONE)
	{		{
	*p_own_addr_type = BLE_ADDR_RANDOM;		*p_own_addr_type = BLE_ADDR_RANDOM;
	btm_ble_disable_resolving_list ();
	}		}
	#endif		#endif

	@@ -1757,6 +1762,7 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode)
	else		else
	status = btm_ble_stop_adv();		status = btm_ble_stop_adv();
	}		}

	if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE)		if (p_cb->adv_mode == BTM_BLE_ADV_ENABLE)
	{		{
	p_cb->fast_adv_on = TRUE;		p_cb->fast_adv_on = TRUE;
	@@ -1764,6 +1770,10 @@ tBTM_STATUS btm_ble_set_discoverability(UINT16 combined_mode)
	btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,		btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,
	BTM_BLE_GAP_FAST_ADV_TOUT);		BTM_BLE_GAP_FAST_ADV_TOUT);
	}		}
			else
			{
			btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
			}

	/* set up stop advertising timer */		/* set up stop advertising timer */
	if (status == BTM_SUCCESS && mode == BTM_BLE_LIMITED_DISCOVERABLE)		if (status == BTM_SUCCESS && mode == BTM_BLE_LIMITED_DISCOVERABLE)
	@@ -1860,6 +1870,10 @@ tBTM_STATUS btm_ble_set_connectability(UINT16 combined_mode)
	btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,		btu_start_timer (&p_cb->fast_adv_timer, BTU_TTYPE_BLE_GAP_FAST_ADV,
	BTM_BLE_GAP_FAST_ADV_TOUT);		BTM_BLE_GAP_FAST_ADV_TOUT);
	}		}
			else
			{
			btm_ble_disable_resolving_list(BTM_BLE_RL_ADV, TRUE);
			}
	return status;		return status;
	}		}

	@@ -1905,9 +1919,10 @@ tBTM_STATUS btm_ble_start_inquiry (UINT8 mode, UINT8 duration)

	#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)		#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
	/* enable IRK list */		/* enable IRK list */
	btm_ble_enable_resolving_list_for_platform();		btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_SCAN);
	#endif		#endif
	status = btm_ble_start_scan(BTM_BLE_DUPLICATE_DISABLE);		p_ble_cb->inq_var.scan_duplicate_filter = BTM_BLE_DUPLICATE_DISABLE;
			status = btm_ble_start_scan();
	}		}

	if (status == BTM_CMD_STARTED)		if (status == BTM_CMD_STARTED)
	@@ -2788,13 +2803,13 @@ static void btm_ble_process_adv_pkt_cont(BD_ADDR bda, UINT8 addr_type, UINT8 evt
	** Returns void		** Returns void
	**		**
	*******************************************************************************/		*******************************************************************************/
	tBTM_STATUS btm_ble_start_scan (UINT8 filter_enable)		tBTM_STATUS btm_ble_start_scan(void)
	{		{
	tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;		tBTM_BLE_INQ_CB *p_inq = &btm_cb.ble_ctr_cb.inq_var;
	tBTM_STATUS status = BTM_CMD_STARTED;		tBTM_STATUS status = BTM_CMD_STARTED;

	/* start scan, disable duplicate filtering */		/* start scan, disable duplicate filtering */
	if (!btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, filter_enable))		if (!btsnd_hcic_ble_set_scan_enable (BTM_BLE_SCAN_ENABLE, p_inq->scan_duplicate_filter))
	{		{
	status = BTM_NO_RESOURCES;		status = BTM_NO_RESOURCES;
	}		}
	@@ -2949,15 +2964,12 @@ tBTM_STATUS btm_ble_start_adv(void)
	return BTM_WRONG_MODE;		return BTM_WRONG_MODE;

	#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)		#if (defined BLE_PRIVACY_SPT && BLE_PRIVACY_SPT == TRUE)
	/* When privacy 1.2 goes into general connection/discoverable mode, */		/* To relax resolving list, always have resolving list enabled, unless directed adv */
	/* disable controller privacy */		if (p_cb->evt_type != BTM_BLE_CONNECT_LO_DUTY_DIR_EVT &&
	if (p_cb->afp == AP_SCAN_CONN_ALL && btm_cb.ble_ctr_cb.privacy_mode == BTM_PRIVACY_1_2)		p_cb->evt_type != BTM_BLE_CONNECT_DIR_EVT)
	btm_ble_disable_resolving_list();
	else
	/* enable resolving list is desired */		/* enable resolving list is desired */
	btm_ble_enable_resolving_list_for_platform();		btm_ble_enable_resolving_list_for_platform(BTM_BLE_RL_ADV);
	#endif		#endif

	if (p_cb->afp != AP_SCAN_CONN_ALL)		if (p_cb->afp != AP_SCAN_CONN_ALL)
	{		{
	btm_execute_wl_dev_operation();		btm_execute_wl_dev_operation();
	@@ -3314,7 +3326,7 @@ void btm_ble_init (void)
	p_cb->inq_var.discoverable_mode = BTM_BLE_NON_DISCOVERABLE;		p_cb->inq_var.discoverable_mode = BTM_BLE_NON_DISCOVERABLE;

	/* for background connection, reset connection params to be undefined */		/* for background connection, reset connection params to be undefined */
	p_cb->scan_int = p_cb->scan_win = BTM_BLE_CONN_PARAM_UNDEF;		p_cb->scan_int = p_cb->scan_win = BTM_BLE_SCAN_PARAM_UNDEF;

	p_cb->inq_var.evt_type = BTM_BLE_NON_CONNECT_EVT;		p_cb->inq_var.evt_type = BTM_BLE_NON_CONNECT_EVT;