Merge "RAS: implement Real-time Ranging Data" into main (11fa99ce) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_ras_api.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -37,7 +37,8 @@ RasServer* GetRasServer();
		class RasClientCallbacks {
		public:
		virtual ~RasClientCallbacks() = default;
		virtual void OnRemoteData(RawAddress address, std::vector<uint8_t> data) = 0;
		virtual void OnRemoteData(const RawAddress& address,
		const std::vector<uint8_t>& data) = 0;
		};

		class RasClient {

system/bta/ras/ras_client.cc

+15 −6

Original line number	Diff line number	Diff line
		@@ -187,11 +187,7 @@ class RasClientImpl : public bluetooth::ras::RasClient {
		},
		nullptr);

		// Subscribe Characteristics
		SubscribeCharacteristic(tracker, kRasOnDemandDataCharacteristic);
		SubscribeCharacteristic(tracker, kRasControlPointCharacteristic);
		SubscribeCharacteristic(tracker, kRasRangingDataReadyCharacteristic);
		SubscribeCharacteristic(tracker, kRasRangingDataOverWrittenCharacteristic);
		}

		void OnGattNotification(const tBTA_GATTC_NOTIFY& evt) {
		@@ -211,8 +207,9 @@ class RasClientImpl : public bluetooth::ras::RasClient {
		getUuidName(characteristic->uuid), evt.len);

		switch (uuid_16bit) {
		case kRasRealTimeRangingDataCharacteristic16bit:
		case kRasOnDemandDataCharacteristic16bit: {
		OnDemandData(evt, tracker);
		OnRemoteData(evt, tracker);
		break;
		}
		case kRasControlPointCharacteristic16bit: {
		@@ -226,7 +223,7 @@ class RasClientImpl : public bluetooth::ras::RasClient {
		}
		}

		void OnDemandData(const tBTA_GATTC_NOTIFY& evt,
		void OnRemoteData(const tBTA_GATTC_NOTIFY& evt,
		std::shared_ptr<RasTracker> tracker) {
		std::vector<uint8_t> data;
		data.resize(evt.len);
		@@ -446,6 +443,18 @@ class RasClientImpl : public bluetooth::ras::RasClient {
		STREAM_TO_UINT32(tracker->remote_supported_features_, value);
		log::info("Remote supported features : {}",
		getFeaturesString(tracker->remote_supported_features_));
		if (tracker->remote_supported_features_ &
		feature::kRealTimeRangingData) {
		log::info("Subscribe Real-time Ranging Data");
		SubscribeCharacteristic(tracker,
		kRasRealTimeRangingDataCharacteristic);
		} else {
		log::info("Subscribe On-demand Ranging Data");
		SubscribeCharacteristic(tracker, kRasOnDemandDataCharacteristic);
		SubscribeCharacteristic(tracker, kRasRangingDataReadyCharacteristic);
		SubscribeCharacteristic(tracker,
		kRasRangingDataOverWrittenCharacteristic);
		}
		} break;
		default:
		log::warn("Unexpected UUID");

system/bta/ras/ras_server.cc

+41 −25

Original line number	Diff line number	Diff line
		@@ -35,7 +35,7 @@ namespace {
		class RasServerImpl;
		RasServerImpl* instance;

		static constexpr uint32_t kSupportedFeatures = 0;
		static constexpr uint32_t kSupportedFeatures = feature::kRealTimeRangingData;
		static constexpr uint16_t kBufferSize = 3;

		class RasServerImpl : public bluetooth::ras::RasServer {
		@@ -75,7 +75,7 @@ class RasServerImpl : public bluetooth::ras::RasServer {

		void PushProcedureData(RawAddress address, uint16_t procedure_counter,
		bool is_last, std::vector<uint8_t> data) {
		log::info("{}, counter:{}, is_last:{}, with size {}", address,
		log::debug("{}, counter:{}, is_last:{}, with size {}", address,
		procedure_counter, is_last, data.size());
		tBLE_BD_ADDR ble_bd_addr;
		ResolveAddress(ble_bd_addr, address);
		@@ -84,21 +84,40 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		log::warn("Can't find tracker for {}", ble_bd_addr.bda);
		return;
		}
		std::lock_guard<std::mutex> lock(data_mutex_);
		ClientTracker& tracker = trackers_[ble_bd_addr.bda];
		uint16_t ccc_real_time =
		tracker.ccc_values_[kRasRealTimeRangingDataCharacteristic];
		uint16_t ccc_data_ready =
		tracker.ccc_values_[kRasRangingDataReadyCharacteristic];
		uint16_t ccc_data_over_written =
		tracker.ccc_values_[kRasRangingDataOverWrittenCharacteristic];

		if (ccc_real_time != GATT_CLT_CONFIG_NONE) {
		bool need_confirm = ccc_real_time == GATT_CHAR_CLIENT_CONFIG_INDICTION;
		uint16_t attr_id =
		GetCharacteristic(kRasRealTimeRangingDataCharacteristic)
		->attribute_handle_;
		log::debug("Send Real-time Ranging Data");
		BTA_GATTS_HandleValueIndication(tracker.conn_id_, attr_id, data,
		need_confirm);
		}

		if (ccc_data_ready == GATT_CLT_CONFIG_NONE &&
		ccc_data_over_written == GATT_CLT_CONFIG_NONE) {
		return;
		}
		std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);
		DataBuffer& data_buffer =
		InitDataBuffer(ble_bd_addr.bda, procedure_counter);
		data_buffer.segments_.push_back(data);

		// Send data ready
		if (is_last) {
		uint16_t ccc_value =
		tracker.ccc_values_[kRasRangingDataReadyCharacteristic];
		if (ccc_value == GATT_CLT_CONFIG_NONE) {
		log::info("Skip Ranging Data Ready");
		if (ccc_data_ready == GATT_CLT_CONFIG_NONE) {
		log::debug("Skip Ranging Data Ready");
		} else {
		bool need_confirm = ccc_value & GATT_CLT_CONFIG_INDICATION;
		log::info("Send data ready, ranging_counter {}", procedure_counter);
		bool need_confirm = ccc_data_ready & GATT_CLT_CONFIG_INDICATION;
		log::debug("Send data ready, ranging_counter {}", procedure_counter);
		uint16_t attr_id = GetCharacteristic(kRasRangingDataReadyCharacteristic)
		->attribute_handle_;
		std::vector<uint8_t> value(kRingingCounterSize);
		@@ -112,15 +131,13 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		// Send data overwritten
		if (tracker.buffers_.size() > kBufferSize) {
		auto begin = tracker.buffers_.begin();
		uint16_t ccc_value =
		tracker.ccc_values_[kRasRangingDataOverWrittenCharacteristic];
		if (ccc_value == GATT_CLT_CONFIG_NONE) {
		log::info("Skip Ranging Data Over Written");
		if (ccc_data_over_written == GATT_CLT_CONFIG_NONE) {
		log::debug("Skip Ranging Data Over Written");
		tracker.buffers_.erase(begin);
		return;
		}
		bool need_confirm = ccc_value & GATT_CLT_CONFIG_INDICATION;
		log::info("Send data over written, ranging_counter {}",
		bool need_confirm = ccc_data_over_written & GATT_CLT_CONFIG_INDICATION;
		log::debug("Send data over written, ranging_counter {}",
		begin->ranging_counter_);
		uint16_t attr_id =
		GetCharacteristic(kRasRangingDataOverWrittenCharacteristic)
		@@ -451,7 +468,7 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		GetCharacteristic(kRasOnDemandDataCharacteristic)->attribute_handle_;
		bool need_confirm = ccc_value & GATT_CLT_CONFIG_INDICATION;

		std::lock_guard<std::mutex> lock(data_mutex_);
		std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);
		auto it = std::find_if(tracker->buffers_.begin(), tracker->buffers_.end(),
		[&ranging_counter](const DataBuffer& buffer) {
		return buffer.ranging_counter_ == ranging_counter;
		@@ -470,9 +487,8 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		ranging_counter);
		std::vector<uint8_t> response(8, 0);
		response[0] = (uint8_t)EventCode::COMPLETE_RANGING_DATA_RESPONSE;
		response[1] = 0; // Null
		response[2] = (ranging_counter & 0xFF);
		response[3] = (ranging_counter >> 8) & 0xFF;
		response[1] = (ranging_counter & 0xFF);
		response[2] = (ranging_counter >> 8) & 0xFF;
		BTA_GATTS_HandleValueIndication(
		tracker->conn_id_,
		GetCharacteristic(kRasControlPointCharacteristic)->attribute_handle_,
		@@ -491,7 +507,7 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		STREAM_TO_UINT16(ranging_counter, value);
		log::info("ranging_counter:{}", ranging_counter);

		std::lock_guard<std::mutex> lock(data_mutex_);
		std::lock_guard<std::mutex> lock(on_demand_ranging_mutex_);
		auto it = std::find_if(tracker->buffers_.begin(), tracker->buffers_.end(),
		[&ranging_counter](const DataBuffer& buffer) {
		return buffer.ranging_counter_ == ranging_counter;
		@@ -500,6 +516,7 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		if (it != tracker->buffers_.end()) {
		tracker->buffers_.erase(it);
		tracker->handling_control_point_command_ = false;
		SendResponseCode(ResponseCodeValue::SUCCESS, tracker);
		} else {
		log::warn("No Records Found");
		SendResponseCode(ResponseCodeValue::NO_RECORDS_FOUND, tracker);
		@@ -512,8 +529,7 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		GetResponseOpcodeValueText(response_code_value));
		std::vector<uint8_t> response(8, 0);
		response[0] = (uint8_t)EventCode::RESPONSE_CODE;
		response[1] = 0; // Null
		response[2] = (uint8_t)response_code_value;
		response[1] = (uint8_t)response_code_value;
		BTA_GATTS_HandleValueIndication(
		tracker->conn_id_,
		GetCharacteristic(kRasControlPointCharacteristic)->attribute_handle_,
		@@ -589,7 +605,7 @@ class RasServerImpl : public bluetooth::ras::RasServer {
		std::unordered_map<uint16_t, RasCharacteristic> characteristics_;
		// A map to client trackers with address
		std::unordered_map<RawAddress, ClientTracker> trackers_;
		std::mutex data_mutex_;
		std::mutex on_demand_ranging_mutex_;
		};

		} // namespace

system/gd/hci/distance_measurement_manager.cc

+5 −5

Original line number	Diff line number	Diff line
		@@ -56,13 +56,13 @@ static constexpr uint8_t kMode0Steps =
		0x03; // Maximum number of mode-0 steps to increase success subevent rate
		static constexpr uint8_t kChannelMapRepetition = 0x01; // No repetition
		static constexpr uint8_t kCh3cJump = 0x03; // Skip 3 Channels
		static constexpr uint16_t kMaxProcedureLen = 0xFFFF; // 40.959375s
		static constexpr uint16_t kMaxProcedureLen = 0x4E20; // 12.5s
		static constexpr uint16_t kMinProcedureInterval = 0x01;
		static constexpr uint16_t kMaxProcedureInterval = 0xFF;
		static constexpr uint16_t kMaxProcedureCount = 0x01;
		static constexpr uint32_t kMinSubeventLen = 0x0004E2; // 1250us
		static constexpr uint32_t kMaxSubeventLen = 0x3d0900; // 4s
		static constexpr uint8_t kToneAntennaConfigSelection = 0x07; // 2x2
		static constexpr uint8_t kToneAntennaConfigSelection = 0x00; // 1x1
		static constexpr uint8_t kTxPwrDelta = 0x00;
		static constexpr uint8_t kProcedureDataBufferSize = 0x10; // Buffer size of Procedure data
		static constexpr uint16_t kMtuForRasData = 507; // 512 - 5
		@@ -774,7 +774,7 @@ struct DistanceMeasurementManager::impl {
		}
		}

		void handle_remote_data(const Address& address, const std::vector<uint8_t> raw_data) {
		void handle_remote_data(const Address address, const std::vector<uint8_t> raw_data) {
		uint16_t connection_handle = acl_manager_->HACK_GetLeHandle(address);
		log::debug(
		"address:{}, connection_handle 0x{:04x}, size:{}",
		@@ -938,7 +938,7 @@ struct DistanceMeasurementManager::impl {
		double i_value = get_iq_value(tone_data.tone_data_[k].i_sample_);
		double q_value = get_iq_value(tone_data.tone_data_[k].q_sample_);
		uint8_t tone_quality_indicator = tone_data.tone_data_[k].tone_quality_indicator_;
		log::debug(
		log::verbose(
		"antenna_path {}, {:f}, {:f}", (uint16_t)(antenna_path + 1), i_value, q_value);
		if (role == CsRole::INITIATOR) {
		procedure_data->tone_pct_initiator[antenna_path].emplace_back(i_value, q_value);
		@@ -1427,7 +1427,7 @@ void DistanceMeasurementManager::StopDistanceMeasurement(
		}

		void DistanceMeasurementManager::HandleRemoteData(
		const Address& address, const std::vector<uint8_t> raw_data) {
		const Address& address, const std::vector<uint8_t>& raw_data) {
		CallOn(pimpl_.get(), &impl::handle_remote_data, address, raw_data);
		}

system/gd/hci/distance_measurement_manager.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -79,7 +79,7 @@ class DistanceMeasurementManager : public bluetooth::Module {
		void StartDistanceMeasurement(
		const Address&, uint16_t interval, DistanceMeasurementMethod method);
		void StopDistanceMeasurement(const Address& address, DistanceMeasurementMethod method);
		void HandleRemoteData(const Address& address, const std::vector<uint8_t> raw_data);
		void HandleRemoteData(const Address& address, const std::vector<uint8_t>& raw_data);

		static const ModuleFactory Factory;