Merge "Revert "HCI: Use enum for LeExtendedAdvertisingResponse.event_type"" into main (4e801776) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/enum_helper.h

+1 −18

Original line number	Diff line number	Diff line
		@@ -30,23 +30,6 @@ enum DeviceType { UNKNOWN = 0, BR_EDR = 1, LE = 2, DUAL = 3 };
		// Scan mode from legacy stack, which is different from hci::ScanEnable
		enum LegacyScanMode { BT_SCAN_MODE_NONE = 0, BT_SCAN_MODE_CONNECTABLE = 1, BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE = 2 };

		inline DataStatus DataStatusFromAdvertisingEventType(ExtendedAdvertisingEventType event_type) {
		constexpr uint8_t kDataStatusBits = 5;
		return DataStatus(((uint16_t)event_type >> kDataStatusBits) & 0x3);
		}

		inline ExtendedAdvertisingEventType operator\|(
		const ExtendedAdvertisingEventType& a, const ExtendedAdvertisingEventType& b) {
		return static_cast<ExtendedAdvertisingEventType>(
		static_cast<uint16_t>(a) \| static_cast<uint16_t>(b));
		}

		inline ExtendedAdvertisingEventType operator&(
		const ExtendedAdvertisingEventType& a, const ExtendedAdvertisingEventType& b) {
		return static_cast<ExtendedAdvertisingEventType>(
		static_cast<uint16_t>(a) & static_cast<uint16_t>(b));
		}

		} // namespace hci

		// Must be defined in bluetooth namespace

system/gd/hci/le_scanning_manager.cc

+43 −25

Original line number	Diff line number	Diff line
		@@ -21,7 +21,6 @@
		#include "android_bluetooth_flags.h"
		#include "hci/acl_manager.h"
		#include "hci/controller.h"
		#include "hci/enum_helper.h"
		#include "hci/event_checkers.h"
		#include "hci/hci_layer.h"
		#include "hci/hci_packets.h"
		@@ -52,6 +51,12 @@ constexpr uint16_t kLeScanIntervalMax = 0x4000;
		constexpr uint16_t kDefaultLeExtendedScanInterval = 4800;
		constexpr uint16_t kLeExtendedScanIntervalMax = 0xFFFF;

		constexpr uint8_t kScannableBit = 1;
		constexpr uint8_t kDirectedBit = 2;
		constexpr uint8_t kScanResponseBit = 3;
		constexpr uint8_t kLegacyBit = 4;
		constexpr uint8_t kDataStatusBits = 5;

		// system properties
		const std::string kLeRxPathLossCompProperty = "bluetooth.hardware.radio.le_rx_path_loss_comp_db";

		@@ -290,6 +295,16 @@ struct LeScanningManager::impl : public LeAddressManagerCallback {
		}
		}

		struct ExtendedEventTypeOptions {
		bool connectable{false};
		bool scannable{false};
		bool directed{false};
		bool scan_response{false};
		bool legacy{false};
		bool continuing{false};
		bool truncated{false};
		};

		int8_t get_rx_path_loss_compensation() {
		int8_t compensation = 0;
		auto compensation_prop = os::GetSystemProperty(kLeRxPathLossCompProperty);
		@@ -322,6 +337,13 @@ struct LeScanningManager::impl : public LeAddressManagerCallback {
		return calibrated_rssi;
		}

		uint16_t transform_to_extended_event_type(ExtendedEventTypeOptions o) {
		return (o.connectable ? 0x0001 << 0 : 0) \| (o.scannable ? 0x0001 << 1 : 0) \|
		(o.directed ? 0x0001 << 2 : 0) \| (o.scan_response ? 0x0001 << 3 : 0) \|
		(o.legacy ? 0x0001 << 4 : 0) \| (o.continuing ? 0x0001 << 5 : 0) \|
		(o.truncated ? 0x0001 << 6 : 0);
		}

		void handle_advertising_report(LeAdvertisingReportRawView event_view) {
		if (!event_view.IsValid()) {
		LOG_INFO("Dropping invalid advertising event");
		@@ -334,38 +356,32 @@ struct LeScanningManager::impl : public LeAddressManagerCallback {
		}

		for (LeAdvertisingResponseRaw report : reports) {
		ExtendedAdvertisingEventType extended_event_type =
		static_cast<ExtendedAdvertisingEventType>(0);
		uint16_t extended_event_type = 0;
		switch (report.event_type_) {
		case AdvertisingEventType::ADV_IND:
		extended_event_type = ExtendedAdvertisingEventType::LEGACY \|
		ExtendedAdvertisingEventType::CONNECTABLE \|
		ExtendedAdvertisingEventType::SCANNABLE;
		extended_event_type = transform_to_extended_event_type(
		{.connectable = true, .scannable = true, .legacy = true});
		break;
		case AdvertisingEventType::ADV_DIRECT_IND:
		extended_event_type = ExtendedAdvertisingEventType::LEGACY \|
		ExtendedAdvertisingEventType::CONNECTABLE \|
		ExtendedAdvertisingEventType::DIRECTED;
		extended_event_type = transform_to_extended_event_type(
		{.connectable = true, .directed = true, .legacy = true});
		break;
		case AdvertisingEventType::ADV_SCAN_IND:
		extended_event_type =
		ExtendedAdvertisingEventType::LEGACY \| ExtendedAdvertisingEventType::SCANNABLE;
		transform_to_extended_event_type({.scannable = true, .legacy = true});
		break;
		case AdvertisingEventType::ADV_NONCONN_IND:
		extended_event_type = ExtendedAdvertisingEventType::LEGACY;
		extended_event_type = transform_to_extended_event_type({.legacy = true});
		break;
		case AdvertisingEventType::SCAN_RESPONSE:
		if (IS_FLAG_ENABLED(fix_nonconnectable_scannable_advertisement)) {
		// We don't know if the initial advertising report was connectable or not.
		// LeScanningReassembler fixes the connectable field.
		extended_event_type = ExtendedAdvertisingEventType::LEGACY \|
		ExtendedAdvertisingEventType::SCAN_RESPONSE \|
		ExtendedAdvertisingEventType::SCANNABLE;
		extended_event_type = transform_to_extended_event_type(
		{.scannable = true, .scan_response = true, .legacy = true});
		} else {
		extended_event_type = ExtendedAdvertisingEventType::CONNECTABLE \|
		ExtendedAdvertisingEventType::LEGACY \|
		ExtendedAdvertisingEventType::SCAN_RESPONSE \|
		ExtendedAdvertisingEventType::SCANNABLE;
		extended_event_type = transform_to_extended_event_type(
		{.connectable = true, .scannable = true, .scan_response = true, .legacy = true});
		}
		break;
		default:
		@@ -404,8 +420,11 @@ struct LeScanningManager::impl : public LeAddressManagerCallback {
		}

		for (LeExtendedAdvertisingResponseRaw& report : reports) {
		uint16_t event_type = report.connectable_ \| (report.scannable_ << kScannableBit) \|
		(report.directed_ << kDirectedBit) \| (report.scan_response_ << kScanResponseBit) \|
		(report.legacy_ << kLegacyBit) \| ((uint16_t)report.data_status_ << kDataStatusBits);
		process_advertising_package_content(
		report.event_type_,
		event_type,
		(uint8_t)report.address_type_,
		report.address_,
		(uint8_t)report.primary_phy_,
		@@ -419,7 +438,7 @@ struct LeScanningManager::impl : public LeAddressManagerCallback {
		}

		void process_advertising_package_content(
		ExtendedAdvertisingEventType event_type,
		uint16_t event_type,
		uint8_t address_type,
		Address address,
		uint8_t primary_phy,
		@@ -455,13 +474,12 @@ struct LeScanningManager::impl : public LeAddressManagerCallback {
		break;
		}

		const ExtendedAdvertisingEventType result_event_type =
		IS_FLAG_ENABLED(fix_nonconnectable_scannable_advertisement)
		const uint16_t result_event_type = IS_FLAG_ENABLED(fix_nonconnectable_scannable_advertisement)
		? processed_report->extended_event_type
		: event_type;

		scanning_callbacks_->OnScanResult(
		static_cast<uint16_t>(result_event_type),
		result_event_type,
		address_type,
		address,
		primary_phy,

system/gd/hci/le_scanning_manager_test.cc

+5 −5

Original line number	Diff line number	Diff line
		@@ -34,7 +34,6 @@
		#include "hci/acl_manager.h"
		#include "hci/address.h"
		#include "hci/controller.h"
		#include "hci/enum_helper.h"
		#include "hci/hci_layer.h"
		#include "hci/hci_layer_fake.h"
		#include "hci/uuid.h"
		@@ -732,7 +731,8 @@ TEST_F(LeScanningManagerExtendedTest, start_scan_test) {
		ASSERT_EQ(OpCode::LE_SET_EXTENDED_SCAN_ENABLE, test_hci_layer_->GetCommand().GetOpCode());
		test_hci_layer_->IncomingEvent(LeSetExtendedScanEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
		LeExtendedAdvertisingResponse report{};
		report.event_type_ = ExtendedAdvertisingEventType::CONNECTABLE;
		report.connectable_ = 1;
		report.scannable_ = 0;
		report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;
		Address::FromString("12:34:56:78:9a:bc", report.address_);
		std::vector<LengthAndData> adv_data{};
		@@ -856,8 +856,8 @@ TEST_F(LeScanningManagerExtendedTest, drop_insignificant_bytes_test) {

		// Prepare advertisement report
		LeExtendedAdvertisingResponse advertisement_report{};
		advertisement_report.event_type_ =
		ExtendedAdvertisingEventType::CONNECTABLE \| ExtendedAdvertisingEventType::SCANNABLE;
		advertisement_report.connectable_ = 1;
		advertisement_report.scannable_ = 1;
		advertisement_report.address_type_ = DirectAdvertisingAddressType::PUBLIC_DEVICE_ADDRESS;
		Address::FromString("12:34:56:78:9a:bc", advertisement_report.address_);
		std::vector<LengthAndData> adv_data{};
		@@ -878,7 +878,7 @@ TEST_F(LeScanningManagerExtendedTest, drop_insignificant_bytes_test) {

		// Prepare scan response report
		auto scan_response_report = advertisement_report;
		scan_response_report.event_type_ = ExtendedAdvertisingEventType::SCAN_RESPONSE;
		scan_response_report.scan_response_ = true;
		LengthAndData extra_data{};
		extra_data.data_.push_back(static_cast<uint8_t>(GapDataType::MANUFACTURER_SPECIFIC_DATA));
		for (auto octet : "manufacturer specific") {

system/gd/hci/le_scanning_reassembler.cc

+10 −13

Original line number	Diff line number	Diff line
		@@ -34,16 +34,15 @@ namespace bluetooth::hci {

		std::optional<LeScanningReassembler::CompleteAdvertisingData>
		LeScanningReassembler::ProcessAdvertisingReport(
		ExtendedAdvertisingEventType event_type,
		uint16_t event_type,
		uint8_t address_type,
		Address address,
		uint8_t advertising_sid,
		const std::vector<uint8_t>& advertising_data) {
		bool is_scannable = static_cast<uint16_t>(event_type & ExtendedAdvertisingEventType::SCANNABLE);
		bool is_scan_response =
		static_cast<uint16_t>(event_type & ExtendedAdvertisingEventType::SCAN_RESPONSE);
		bool is_legacy = static_cast<uint16_t>(event_type & ExtendedAdvertisingEventType::LEGACY);
		DataStatus data_status = DataStatusFromAdvertisingEventType(event_type);
		bool is_scannable = event_type & (1 << kScannableBit);
		bool is_scan_response = event_type & (1 << kScanResponseBit);
		bool is_legacy = event_type & (1 << kLegacyBit);
		DataStatus data_status = DataStatus((event_type >> kDataStatusBits) & 0x3);

		if (address_type != (uint8_t)DirectAdvertisingAddressType::NO_ADDRESS_PROVIDED &&
		address == Address::kEmpty) {
		@@ -145,17 +144,15 @@ bool LeScanningReassembler::AdvertisingKey::operator==(const AdvertisingKey& oth
		/// dropping the oldest advertiser.
		std::list<LeScanningReassembler::AdvertisingFragment>::iterator
		LeScanningReassembler::AppendFragment(
		const AdvertisingKey& key,
		ExtendedAdvertisingEventType extended_event_type,
		const std::vector<uint8_t>& data) {
		const AdvertisingKey& key, uint16_t extended_event_type, const std::vector<uint8_t>& data) {
		auto it = FindFragment(key);
		if (it != cache_.end()) {
		// Legacy scan responses don't contain a 'connectable' bit, so this adds the
		// 'connectable' bit from the initial report.
		if (static_cast<uint16_t>(extended_event_type & ExtendedAdvertisingEventType::LEGACY) &&
		static_cast<uint16_t>(extended_event_type & ExtendedAdvertisingEventType::SCAN_RESPONSE)) {
		it->extended_event_type = extended_event_type \| (it->extended_event_type &
		ExtendedAdvertisingEventType::CONNECTABLE);
		if ((extended_event_type & (1 << kLegacyBit)) &&
		(extended_event_type & (1 << kScanResponseBit))) {
		it->extended_event_type =
		extended_event_type \| (it->extended_event_type & (1 << kConnectableBit));
		} else {
		it->extended_event_type = extended_event_type;
		}

system/gd/hci/le_scanning_reassembler.h

+13 −9

Original line number	Diff line number	Diff line
		@@ -36,7 +36,7 @@ namespace bluetooth::hci {
		class LeScanningReassembler {
		public:
		struct CompleteAdvertisingData {
		ExtendedAdvertisingEventType extended_event_type;
		uint16_t extended_event_type;
		std::vector<uint8_t> data;
		};

		@@ -52,7 +52,7 @@ class LeScanningReassembler {
		/// Returns the completed advertising data if the event was complete, or the
		/// completion of a fragmented advertising event.
		std::optional<CompleteAdvertisingData> ProcessAdvertisingReport(
		ExtendedAdvertisingEventType event_type,
		uint16_t event_type,
		uint8_t address_type,
		Address address,
		uint8_t advertising_sid,
		@@ -68,6 +68,14 @@ class LeScanningReassembler {
		/// Determine if scan responses should be processed or ignored.
		bool ignore_scan_responses_{false};

		/// Constants for parsing event_type.
		static constexpr uint8_t kConnectableBit = 0;
		static constexpr uint8_t kScannableBit = 1;
		static constexpr uint8_t kDirectedBit = 2;
		static constexpr uint8_t kScanResponseBit = 3;
		static constexpr uint8_t kLegacyBit = 4;
		static constexpr uint8_t kDataStatusBits = 5;

		/// Packs the information necessary to disambiguate advertising events:
		/// - For legacy advertising events, the advertising address and
		/// advertising address type are used to disambiguate advertisers.
		@@ -89,13 +97,11 @@ class LeScanningReassembler {
		/// Packs incomplete advertising data.
		struct AdvertisingFragment {
		AdvertisingKey key;
		ExtendedAdvertisingEventType extended_event_type;
		uint16_t extended_event_type;
		std::vector<uint8_t> data;

		AdvertisingFragment(
		const AdvertisingKey& key,
		ExtendedAdvertisingEventType extended_event_type,
		const std::vector<uint8_t>& data)
		const AdvertisingKey& key, uint16_t extended_event_type, const std::vector<uint8_t>& data)
		: key(key), extended_event_type(extended_event_type), data(data.begin(), data.end()) {}
		};

		@@ -109,9 +115,7 @@ class LeScanningReassembler {

		/// Advertising cache management methods.
		std::list<AdvertisingFragment>::iterator AppendFragment(
		const AdvertisingKey& key,
		ExtendedAdvertisingEventType extended_event_type,
		const std::vector<uint8_t>& data);
		const AdvertisingKey& key, uint16_t extended_event_type, const std::vector<uint8_t>& data);

		void RemoveFragment(const AdvertisingKey& key);