Merge changes I8ba33334,Icf238a7c,I843c499b into main (d1476dd4) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,7 @@ filegroup {
		"dm/bta_dm_cfg.cc",
		"dm/bta_dm_ci.cc",
		"dm/bta_dm_disc.cc",
		"dm/bta_dm_disc_legacy.cc",
		"dm/bta_dm_gatt_client.cc",
		"dm/bta_dm_main.cc",
		"dm/bta_dm_pm.cc",

system/bta/BUILD.gn

+1 −0

Original line number	Diff line number	Diff line
		@@ -44,6 +44,7 @@ static_library("bta") {
		"dm/bta_dm_cfg.cc",
		"dm/bta_dm_ci.cc",
		"dm/bta_dm_disc.cc",
		"dm/bta_dm_disc_legacy.cc",
		"dm/bta_dm_gatt_client.cc",
		"dm/bta_dm_main.cc",
		"dm/bta_dm_pm.cc",

system/bta/dm/bta_dm_disc.cc

+97 −20

Original line number	Diff line number	Diff line
		@@ -22,8 +22,8 @@
		#include <base/functional/bind.h>
		#include <base/strings/stringprintf.h>
		#include <bluetooth/log.h>
		#include <stddef.h>

		#include <cstddef>
		#include <cstdint>
		#include <string>
		#include <variant>
		@@ -31,6 +31,7 @@

		#include "android_bluetooth_flags.h"
		#include "bta/dm/bta_dm_disc_int.h"
		#include "bta/dm/bta_dm_disc_legacy.h"
		#include "bta/include/bta_gatt_api.h"
		#include "bta/include/bta_sdp_api.h"
		#include "btif/include/btif_config.h"
		@@ -193,17 +194,35 @@ gatt_interface_t& get_gatt_interface() { return *gatt_interface; }

		} // namespace

		void bta_dm_disc_disable_search_and_disc() { bta_dm_disable_search_and_disc(); }
		void bta_dm_disc_disable_search_and_disc() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_disable_search_and_disc();
		return;
		}
		bta_dm_disable_search_and_disc();
		}

		void bta_dm_disc_gatt_cancel_open(const RawAddress& bd_addr) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_gatt_cancel_open(bd_addr);
		return;
		}
		get_gatt_interface().BTA_GATTC_CancelOpen(0, bd_addr, false);
		}

		void bta_dm_disc_gatt_refresh(const RawAddress& bd_addr) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_gatt_refresh(bd_addr);
		return;
		}
		get_gatt_interface().BTA_GATTC_Refresh(bd_addr);
		}

		void bta_dm_disc_remove_device(const RawAddress& bd_addr) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_remove_device(bd_addr);
		return;
		}
		if (bta_dm_search_cb.state == BTA_DM_DISCOVER_ACTIVE &&
		bta_dm_search_cb.peer_bdaddr == bd_addr) {
		log::info(
		@@ -214,9 +233,21 @@ void bta_dm_disc_remove_device(const RawAddress& bd_addr) {
		}
		}

		void bta_dm_disc_discover_next_device() { bta_dm_discover_next_device(); }
		void bta_dm_disc_discover_next_device() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_discover_next_device();
		return;
		}
		bta_dm_discover_next_device();
		}

		void bta_dm_disc_gattc_register() { bta_dm_gattc_register(); }
		void bta_dm_disc_gattc_register() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_gattc_register();
		return;
		}
		bta_dm_gattc_register();
		}

		static void bta_dm_observe_results_cb(tBTM_INQ_RESULTS* p_inq,
		const uint8_t* p_eir, uint16_t eir_len);
		@@ -811,16 +842,10 @@ static void bta_dm_read_dis_cmpl(const RawAddress& addr,
		}
		#endif

		/*******************************************************************************
		*
		* Function bta_dm_search_cmpl
		*
		* Description Sends event to application
		*
		* Returns void
		*
		******************************************************************************/
		static void bta_dm_search_cmpl() {
		static void bta_dm_service_discovery_cmpl() {
		// TODO: we shouldn't change search state, just service discovery state, but
		// both state machines are now joined. This bug will be fixed in upcoming
		// patches.
		bta_dm_search_set_state(BTA_DM_SEARCH_IDLE);

		uint16_t conn_id = bta_dm_search_cb.conn_id;
		@@ -879,9 +904,6 @@ static void bta_dm_search_cmpl() {
		}
		}

		if (bta_dm_search_cb.p_device_search_cback) {
		bta_dm_search_cb.p_device_search_cback(BTA_DM_DISC_CMPL_EVT, nullptr);
		}
		bta_dm_search_cb.gatt_disc_active = false;

		#if TARGET_FLOSS
		@@ -895,6 +917,16 @@ static void bta_dm_search_cmpl() {
		bta_dm_execute_queued_request();
		}

		static void bta_dm_search_cmpl() {
		bta_dm_search_set_state(BTA_DM_SEARCH_IDLE);

		if (bta_dm_search_cb.p_device_search_cback) {
		bta_dm_search_cb.p_device_search_cback(BTA_DM_DISC_CMPL_EVT, nullptr);
		}

		bta_dm_execute_queued_request();
		}

		/*******************************************************************************
		*
		* Function bta_dm_disc_result
		@@ -926,7 +958,7 @@ static void bta_dm_disc_result(tBTA_DM_SVC_RES& disc_result) {
		get_gatt_interface().BTA_GATTC_CancelOpen(0, bta_dm_search_cb.peer_bdaddr,
		true);

		bta_dm_search_cmpl();
		bta_dm_service_discovery_cmpl();
		}
		}

		@@ -1011,6 +1043,9 @@ static void bta_dm_execute_queued_request() {
		*
		******************************************************************************/
		bool bta_dm_is_search_request_queued() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		return bta_dm_disc_legacy::bta_dm_is_search_request_queued();
		}
		return bta_dm_search_cb.p_pending_search != NULL;
		}

		@@ -1553,7 +1588,10 @@ static void bta_dm_remname_cback(const tBTM_REMOTE_DEV_NAME* p_remote_name) {
		*
		* Returns char * - Pointer to the remote device name
		******************************************************************************/
		const char* bta_dm_get_remname(void) {
		const char* bta_dm_get_remname() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		return bta_dm_disc_legacy::bta_dm_get_remname();
		}
		const char* p_name = (const char*)bta_dm_search_cb.peer_name;

		/* If the name isn't already stored, try retrieving from BTM */
		@@ -1705,6 +1743,10 @@ static void bta_dm_start_scan(uint8_t duration_sec,

		void bta_dm_ble_scan(bool start, uint8_t duration_sec,
		bool low_latency_scan = false) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_ble_scan(start, duration_sec, low_latency_scan);
		return;
		}
		if (!start) {
		get_btm_client_interface().ble.BTM_BleObserve(false, 0, NULL, NULL, false);
		return;
		@@ -1714,6 +1756,10 @@ void bta_dm_ble_scan(bool start, uint8_t duration_sec,
		}

		void bta_dm_ble_csis_observe(bool observe, tBTA_DM_SEARCH_CBACK* p_cback) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_ble_csis_observe(observe, p_cback);
		return;
		}
		if (!observe) {
		bta_dm_search_cb.p_csis_scan_cback = NULL;
		BTM_BleOpportunisticObserve(false, NULL);
		@@ -2242,6 +2288,10 @@ static void bta_dm_disc_reset() {
		}

		void bta_dm_disc_start(bool delay_close_gatt) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_start(delay_close_gatt);
		return;
		}
		bta_dm_disc_reset();
		bta_dm_search_cb.search_timer = alarm_new("bta_dm_search.search_timer");
		bta_dm_search_cb.gatt_close_timer =
		@@ -2250,6 +2300,10 @@ void bta_dm_disc_start(bool delay_close_gatt) {
		}

		void bta_dm_disc_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_acl_down(bd_addr, transport);
		return;
		}
		switch (transport) {
		case BT_TRANSPORT_BR_EDR:
		if (bta_dm_search_cb.wait_disc &&
		@@ -2270,21 +2324,40 @@ void bta_dm_disc_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport) {
		}
		}

		void bta_dm_disc_stop() { bta_dm_disc_reset(); }
		void bta_dm_disc_stop() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_stop();
		return;
		}
		bta_dm_disc_reset();
		}

		void bta_dm_disc_start_device_discovery(tBTA_DM_SEARCH_CBACK* p_cback) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_start_device_discovery(p_cback);
		return;
		}
		bta_dm_search_sm_execute(
		BTA_DM_API_SEARCH_EVT,
		std::make_unique<tBTA_DM_MSG>(tBTA_DM_API_SEARCH{.p_cback = p_cback}));
		}

		void bta_dm_disc_stop_device_discovery() {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_stop_device_discovery();
		return;
		}
		bta_dm_search_sm_execute(BTA_DM_API_SEARCH_CANCEL_EVT, nullptr);
		}

		void bta_dm_disc_start_service_discovery(service_discovery_callbacks cbacks,
		const RawAddress& bd_addr,
		tBT_TRANSPORT transport) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::bta_dm_disc_start_service_discovery(cbacks, bd_addr,
		transport);
		return;
		}
		bta_dm_search_sm_execute(
		BTA_DM_API_DISCOVER_EVT,
		std::make_unique<tBTA_DM_MSG>(tBTA_DM_API_DISCOVER{
		@@ -2293,6 +2366,10 @@ void bta_dm_disc_start_service_discovery(service_discovery_callbacks cbacks,

		#define DUMPSYS_TAG "shim::legacy::bta::dm"
		void DumpsysBtaDmDisc(int fd) {
		if (!IS_FLAG_ENABLED(separate_service_and_device_discovery)) {
		bta_dm_disc_legacy::DumpsysBtaDmDisc(fd);
		return;
		}
		auto copy = search_state_history_.Pull();
		LOG_DUMPSYS(fd, " last %zu search state transitions", copy.size());
		for (const auto& it : copy) {

system/bta/dm/bta_dm_disc.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -41,7 +41,7 @@ void bta_dm_disc_disable_search_and_disc();
		void bta_dm_disc_acl_down(const RawAddress& bd_addr, tBT_TRANSPORT transport);

		// Return most recent remote name
		const char* bta_dm_get_remname(void);
		const char* bta_dm_get_remname();

		// LE observe and scan interface
		void bta_dm_ble_scan(bool start, uint8_t duration_sec, bool low_latency_scan);

system/bta/dm/bta_dm_disc_int_legacy.h

0 → 100644

+188 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2023 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

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

		#include <queue>
		#include <string>

		#include "bta/include/bta_api.h"
		#include "bta/sys/bta_sys.h"
		#include "macros.h"
		#include "stack/btm/neighbor_inquiry.h"
		#include "stack/include/sdp_status.h"
		#include "stack/sdp/sdp_discovery_db.h"
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		#define BTA_SERVICE_ID_TO_SERVICE_MASK(id) (1 << (id))

		// TODO: Remove this file after flag separate_service_and_device_discovery rolls
		// out
		namespace bta_dm_disc_legacy {

		/* DM search events */
		typedef enum : uint16_t {
		/* DM search API events */
		BTA_DM_API_SEARCH_EVT,
		BTA_DM_API_SEARCH_CANCEL_EVT,
		BTA_DM_API_DISCOVER_EVT,
		BTA_DM_INQUIRY_CMPL_EVT,
		BTA_DM_REMT_NAME_EVT,
		BTA_DM_SDP_RESULT_EVT,
		BTA_DM_SEARCH_CMPL_EVT,
		BTA_DM_DISCOVERY_RESULT_EVT,
		BTA_DM_DISC_CLOSE_TOUT_EVT,
		} tBTA_DM_EVT;

		inline std::string bta_dm_event_text(const tBTA_DM_EVT& event) {
		switch (event) {
		CASE_RETURN_TEXT(BTA_DM_API_SEARCH_EVT);
		CASE_RETURN_TEXT(BTA_DM_API_SEARCH_CANCEL_EVT);
		CASE_RETURN_TEXT(BTA_DM_API_DISCOVER_EVT);
		CASE_RETURN_TEXT(BTA_DM_INQUIRY_CMPL_EVT);
		CASE_RETURN_TEXT(BTA_DM_REMT_NAME_EVT);
		CASE_RETURN_TEXT(BTA_DM_SDP_RESULT_EVT);
		CASE_RETURN_TEXT(BTA_DM_SEARCH_CMPL_EVT);
		CASE_RETURN_TEXT(BTA_DM_DISCOVERY_RESULT_EVT);
		CASE_RETURN_TEXT(BTA_DM_DISC_CLOSE_TOUT_EVT);
		default:
		return base::StringPrintf("UNKNOWN[0x%04x]", event);
		}
		}

		/* data type for BTA_DM_API_SEARCH_EVT */
		typedef struct {
		tBTA_DM_SEARCH_CBACK* p_cback;
		} tBTA_DM_API_SEARCH;

		/* data type for BTA_DM_API_DISCOVER_EVT */
		typedef struct {
		RawAddress bd_addr;
		service_discovery_callbacks cbacks;
		tBT_TRANSPORT transport;
		} tBTA_DM_API_DISCOVER;

		typedef struct {
		} tBTA_DM_API_DISCOVERY_CANCEL;

		typedef struct {
		RawAddress bd_addr;
		BD_NAME bd_name; /* Name of peer device. */
		tHCI_STATUS hci_status;
		} tBTA_DM_REMOTE_NAME;

		/* data type for tBTA_DM_DISC_RESULT */
		typedef struct {
		tBTA_DM_SEARCH result;
		} tBTA_DM_DISC_RESULT;

		/* data type for BTA_DM_INQUIRY_CMPL_EVT */
		typedef struct {
		uint8_t num;
		} tBTA_DM_INQUIRY_CMPL;

		/* data type for BTA_DM_SDP_RESULT_EVT */
		typedef struct {
		tSDP_RESULT sdp_result;
		} tBTA_DM_SDP_RESULT;

		typedef struct {
		bool enable;
		} tBTA_DM_API_BLE_FEATURE;

		typedef struct {
		RawAddress bd_addr; /* BD address peer device. */
		tBTA_SERVICE_MASK services; /* Services found on peer device. */
		tBT_DEVICE_TYPE device_type; /* device type in case it is BLE device */
		std::vector<bluetooth::Uuid> uuids;
		tBTA_STATUS result;
		tHCI_STATUS hci_status;
		} tBTA_DM_SVC_RES;

		using tBTA_DM_MSG =
		std::variant<tBTA_DM_API_SEARCH, tBTA_DM_API_DISCOVER, tBTA_DM_REMOTE_NAME,
		tBTA_DM_DISC_RESULT, tBTA_DM_INQUIRY_CMPL, tBTA_DM_SDP_RESULT,
		tBTA_DM_SVC_RES>;

		/* DM search state */
		typedef enum {

		BTA_DM_SEARCH_IDLE,
		BTA_DM_SEARCH_ACTIVE,
		BTA_DM_SEARCH_CANCELLING,
		BTA_DM_DISCOVER_ACTIVE

		} tBTA_DM_STATE;

		inline std::string bta_dm_state_text(const tBTA_DM_STATE& state) {
		switch (state) {
		CASE_RETURN_TEXT(BTA_DM_SEARCH_IDLE);
		CASE_RETURN_TEXT(BTA_DM_SEARCH_ACTIVE);
		CASE_RETURN_TEXT(BTA_DM_SEARCH_CANCELLING);
		CASE_RETURN_TEXT(BTA_DM_DISCOVER_ACTIVE);
		default:
		return base::StringPrintf("UNKNOWN[%d]", state);
		}
		}

		/* DM search control block */
		typedef struct {
		tBTA_DM_SEARCH_CBACK* p_device_search_cback;
		service_discovery_callbacks service_search_cbacks;
		tBTM_INQ_INFO* p_btm_inq_info;
		tBTA_SERVICE_MASK services_to_search;
		tBTA_SERVICE_MASK services_found;
		tSDP_DISCOVERY_DB* p_sdp_db;
		tBTA_DM_STATE state;
		RawAddress peer_bdaddr;
		bool name_discover_done;
		BD_NAME peer_name;
		alarm_t* search_timer;
		uint8_t service_index;
		std::unique_ptr<tBTA_DM_MSG> p_pending_search;
		std::queue<tBTA_DM_API_DISCOVER> pending_discovery_queue;
		bool wait_disc;
		bool sdp_results;
		bluetooth::Uuid uuid;
		uint8_t peer_scn;
		tBT_TRANSPORT transport;
		tBTA_DM_SEARCH_CBACK* p_csis_scan_cback;
		tGATT_IF client_if;
		uint8_t uuid_to_search;
		bool gatt_disc_active;
		uint16_t conn_id;
		alarm_t* gatt_close_timer; /* GATT channel close delay timer */
		RawAddress pending_close_bda; /* pending GATT channel remote device address */

		} tBTA_DM_SEARCH_CB;

		extern const uint32_t bta_service_id_to_btm_srv_id_lkup_tbl[];
		extern const uint16_t bta_service_id_to_uuid_lkup_tbl[];

		} // namespace bta_dm_disc_legacy

		namespace fmt {
		template <>
		struct formatter<bta_dm_disc_legacy::tBTA_DM_EVT>
		: enum_formatter<bta_dm_disc_legacy::tBTA_DM_EVT> {};
		template <>
		struct formatter<bta_dm_disc_legacy::tBTA_DM_STATE>
		: enum_formatter<bta_dm_disc_legacy::tBTA_DM_STATE> {};
		} // namespace fmt