Disconnect before removing device (54f48d3a) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/dm/bta_dm_act.cc

+176 −3

Original line number	Diff line number	Diff line
		@@ -205,6 +205,7 @@ static void bta_dm_deinit_cb(void) {
		alarm_free(bta_dm_cb.pm_timer[i].timer[j]);
		}
		}
		bta_dm_cb.pending_removals.clear();
		bta_dm_cb = {};
		}

		@@ -471,8 +472,8 @@ void bta_dm_process_remove_device(const RawAddress& bd_addr) {
		}
		}

		/** Removes device, disconnects ACL link if required */
		void bta_dm_remove_device(const RawAddress& bd_addr) {
		// TODO: Remove when flag wait_for_disconnect_before_unbond is shipped
		static void bta_dm_remove_device_(const RawAddress& bd_addr) {
		/* If ACL exists for the device in the remove_bond message*/
		bool is_bd_addr_connected =
		get_btm_client_interface().peer.BTM_IsAclConnectionUp(bd_addr, BT_TRANSPORT_LE) \|\|
		@@ -564,6 +565,112 @@ void bta_dm_remove_device(const RawAddress& bd_addr) {
		}
		}

		/** Removes device, disconnects ACL link if required */
		void bta_dm_remove_device(const RawAddress& target) {
		if (!com::android::bluetooth::flags::wait_for_disconnect_before_unbond()) {
		bta_dm_remove_device_(target);
		return;
		}

		// Find all aliases and connection status on all transports
		RawAddress pseudo_addr = target;
		RawAddress identity_addr = target;
		bool le_connected = get_btm_client_interface().peer.BTM_ReadConnectedTransportAddress(
		&pseudo_addr, BT_TRANSPORT_LE);
		bool bredr_connected = get_btm_client_interface().peer.BTM_ReadConnectedTransportAddress(
		&identity_addr, BT_TRANSPORT_BR_EDR);
		/* If connection not found with identity address, check with pseudo address if different */
		if (!bredr_connected && identity_addr != pseudo_addr) {
		identity_addr = pseudo_addr;
		bredr_connected = get_btm_client_interface().peer.BTM_ReadConnectedTransportAddress(
		&identity_addr, BT_TRANSPORT_BR_EDR);
		}

		// Remove from LE allowlist
		if (!GATT_CancelConnect(0, pseudo_addr, false)) {
		if (identity_addr != pseudo_addr && !GATT_CancelConnect(0, identity_addr, false)) {
		log::warn("Unable to cancel GATT connect peer:{}", pseudo_addr);
		}
		}

		// Disconnect LE transport
		if (le_connected) {
		tBTM_STATUS status = btm_remove_acl(pseudo_addr, BT_TRANSPORT_LE);
		if (status != BTM_SUCCESS && identity_addr != pseudo_addr) {
		status = btm_remove_acl(identity_addr, BT_TRANSPORT_LE);
		}

		if (status != BTM_SUCCESS) {
		le_connected = false;
		log::error("Unable to disconnect LE connection {}", pseudo_addr);
		}
		}

		// Disconnect BR/EDR transport
		if (bredr_connected) {
		tBTM_STATUS status = btm_remove_acl(identity_addr, BT_TRANSPORT_BR_EDR);
		if (status != BTM_SUCCESS && identity_addr != pseudo_addr) {
		status = btm_remove_acl(pseudo_addr, BT_TRANSPORT_BR_EDR);
		}

		if (status != BTM_SUCCESS) {
		bredr_connected = false;
		log::error("Unable to disconnect BR/EDR connection {}", identity_addr);
		}
		}

		if (le_connected \|\| bredr_connected) {
		// Wait for all transports to be disconnected
		tBTA_DM_REMOVE_PENDNIG node = {pseudo_addr, target, le_connected, bredr_connected};
		bta_dm_cb.pending_removals.push_back(node);
		log::info(
		"Waiting for disconnection over LE:{}, BR/EDR:{} for pseudo address: {}, identity "
		"address: {}",
		le_connected, bredr_connected, pseudo_addr, identity_addr);
		} else {
		// No existing connection, remove the device right away
		log::verbose("Not connected, remove the device {}", target);
		bta_dm_process_remove_device(identity_addr);
		if (identity_addr != pseudo_addr) {
		bta_dm_process_remove_device(pseudo_addr);
		}
		}
		}

		static void bta_dm_remove_on_disconnect(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
		for (auto it = bta_dm_cb.pending_removals.begin(); it != bta_dm_cb.pending_removals.end(); it++) {
		if (bd_addr == it->identity_addr \|\| bd_addr == it->pseudo_addr) {
		if (transport == BT_TRANSPORT_BR_EDR) {
		it->bredr_connected = false;
		} else {
		it->le_connected = false;
		}

		if (!it->bredr_connected && !it->le_connected) {
		log::info("All transports disconnected, remove the device {}", bd_addr);
		bta_dm_process_remove_device(it->identity_addr);
		if (it->identity_addr != it->pseudo_addr) {
		bta_dm_process_remove_device(it->pseudo_addr);
		}
		bta_dm_cb.pending_removals.erase(it);
		} else {
		log::info("Awaiting {} disconnection over {}", it->le_connected ? "LE" : "BR/EDR", bd_addr);
		}
		break;
		}
		}
		}

		bool bta_dm_removal_pending(const RawAddress& bd_addr) {
		for (auto it : bta_dm_cb.pending_removals) {
		if (bd_addr == it.pseudo_addr \|\| bd_addr == it.identity_addr) {
		return true;
		}
		}

		return false;
		}

		/*******************************************************************************
		*
		* Function bta_dm_local_name_cback
		@@ -677,6 +784,23 @@ static tBTA_DM_PEER_DEVICE* allocate_device_for(const RawAddress& bd_addr,
		}

		static void bta_dm_acl_up(const RawAddress& bd_addr, tBT_TRANSPORT transport, uint16_t acl_handle) {
		if (com::android::bluetooth::flags::wait_for_disconnect_before_unbond()) {
		// Disconnect if the device is being removed
		for (auto& it : bta_dm_cb.pending_removals) {
		if (bd_addr == it.identity_addr \|\| bd_addr == it.pseudo_addr) {
		log::warn("ACL connected while removing the device {} transport: {}", bd_addr, transport);
		if (transport == BT_TRANSPORT_BR_EDR) {
		it.bredr_connected = true;
		} else {
		it.le_connected = true;
		}

		btm_remove_acl(bd_addr, transport);
		return;
		}
		}
		}

		auto device = allocate_device_for(bd_addr, transport);
		if (device == nullptr) {
		log::warn("Unable to allocate device resources for new connection");
		@@ -730,7 +854,8 @@ void BTA_dm_acl_up_failed(const RawAddress bd_addr, tBT_TRANSPORT transport, tHC
		do_in_main_thread(base::BindOnce(bta_dm_acl_up_failed, bd_addr, transport, status));
		}

		static void bta_dm_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
		// TODO: Remove when flag wait_for_disconnect_before_unbond is shipped
		static void bta_dm_acl_down_(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
		bool issue_unpair_cb = false;
		bool remove_device = false;

		@@ -810,6 +935,54 @@ static void bta_dm_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport)
		bta_dm_adjust_roles(true);
		}

		static void bta_dm_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
		log::verbose("Device {} disconnected over transport {}", bd_addr, bt_transport_text(transport));
		if (!com::android::bluetooth::flags::wait_for_disconnect_before_unbond()) {
		bta_dm_acl_down_(bd_addr, transport);
		return;
		}

		for (uint8_t i = 0; i < bta_dm_cb.device_list.count; i++) {
		auto device = &bta_dm_cb.device_list.peer_device[i];
		if (device->peer_bdaddr == bd_addr && device->transport == transport) {
		// Move the last item into its place
		if (i + 1 < bta_dm_cb.device_list.count) {
		*device = bta_dm_cb.device_list.peer_device[bta_dm_cb.device_list.count - 1];
		}
		bta_dm_cb.device_list.peer_device[bta_dm_cb.device_list.count - 1] = {};
		break;
		}
		}

		if (bta_dm_cb.device_list.count > 0) {
		bta_dm_cb.device_list.count--;
		}
		if (transport == BT_TRANSPORT_LE && bta_dm_cb.device_list.le_count > 0) {
		bta_dm_cb.device_list.le_count--;
		}

		bta_dm_disc_acl_down(bd_addr, transport);
		if (bta_dm_cb.disabling && !BTM_GetNumAclLinks()) {
		/*
		* Start a timer to make sure that the profiles
		* get the disconnect event.
		*/
		alarm_set_on_mloop(bta_dm_cb.disable_timer, BTA_DM_DISABLE_CONN_DOWN_TIMER_MS,
		bta_dm_disable_conn_down_timer_cback, NULL);
		}

		if (bta_dm_acl_cb.p_acl_cback) {
		tBTA_DM_ACL conn{};
		conn.link_down.bd_addr = bd_addr;
		conn.link_down.transport_link_type = transport;

		bta_dm_acl_cb.p_acl_cback(BTA_DM_LINK_DOWN_EVT, &conn);
		}

		bta_dm_adjust_roles(true);
		bta_dm_remove_on_disconnect(bd_addr, transport);
		}

		void BTA_dm_acl_down(const RawAddress bd_addr, tBT_TRANSPORT transport) {
		do_in_main_thread(base::BindOnce(bta_dm_acl_down, bd_addr, transport));
		}

system/bta/dm/bta_dm_int.h

+21 −0

Original line number	Diff line number	Diff line
		@@ -26,7 +26,9 @@

		#include <base/strings/stringprintf.h>
		#include <bluetooth/log.h>
		#include <com_android_bluetooth_flags.h>

		#include <list>
		#include <string>
		#include <vector>

		@@ -95,9 +97,21 @@ inline std::string device_info_text(tBTA_DM_DEV_INFO info) {
		#define BTA_DM_PM_EXECUTE 3
		typedef uint8_t tBTA_DM_PM_REQ;

		struct tBTA_DM_REMOVE_PENDNIG {
		RawAddress pseudo_addr;
		RawAddress identity_addr;
		bool le_connected;
		bool bredr_connected;
		};

		bool bta_dm_removal_pending(const RawAddress& bd_addr);

		struct tBTA_DM_PEER_DEVICE {
		RawAddress peer_bdaddr;

		// TODO: Remove when flag wait_for_disconnect_before_unbond is shipped
		tBTA_DM_CONN_STATE conn_state{tBTA_DM_CONN_STATE::BTA_DM_CONNECTED};

		tBTA_PREF_ROLES pref_role;
		bool in_use;

		@@ -135,6 +149,11 @@ public:
		bool is_ssr_active() const { return info & BTA_DM_DI_USE_SSR; }

		bool is_connected() const {
		// Devices getting removed should be treated as disconnected
		if (com::android::bluetooth::flags::wait_for_disconnect_before_unbond() &&
		bta_dm_removal_pending(peer_bdaddr)) {
		return false;
		}
		return (conn_state == tBTA_DM_CONN_STATE::BTA_DM_CONNECTED);
		}

		@@ -223,6 +242,8 @@ typedef struct {
		tBTA_CUSTOM_UUID bta_custom_uuid[BTA_EIR_SERVER_NUM_CUSTOM_UUID];
		#endif
		alarm_t* switch_delay_timer;

		std::list<tBTA_DM_REMOVE_PENDNIG> pending_removals;
		} tBTA_DM_CB;

		/* DI control block */