Merge "Configs MTU for RAS if it is required." into main (01172369) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/include/bta_ras_api.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@ public:
		const RawAddress& address,
		const std::vector<VendorSpecificCharacteristic>& vendor_specific_reply) = 0;
		virtual void OnRasServerConnected(const RawAddress& identity_address) = 0;
		virtual void OnMtuChangedFromServer(const RawAddress& address, uint16_t mtu) = 0;
		virtual void OnRasServerDisconnected(const RawAddress& identity_address) = 0;
		};

		@@ -67,6 +68,7 @@ public:
		virtual void OnWriteVendorSpecificReplyComplete(const RawAddress& address, bool success) = 0;
		virtual void OnRemoteData(const RawAddress& address, const std::vector<uint8_t>& data) = 0;
		virtual void OnRemoteDataTimeout(const RawAddress& address) = 0;
		virtual void OnMtuChangedFromClient(const RawAddress& address, uint16_t mtu) = 0;
		};

		class RasClient {

system/bta/ras/ras_client.cc

+22 −0

Original line number	Diff line number	Diff line
		@@ -68,6 +68,7 @@ class RasClientImpl : public bluetooth::ras::RasClient {
		static constexpr uint16_t kFollowingSegmentTimeoutMs = 1000;
		static constexpr uint16_t kRangingDataReadyTimeoutMs = 5000;
		static constexpr uint16_t kInvalidConnInterval = 0; // valid value is from 0x0006 to 0x0C0
		static constexpr uint16_t kMinimumRasMtu = 247; // 4.1 Maximum transmission unit of RAP 1.0

		public:
		struct GattReadCallbackData {
		@@ -108,6 +109,7 @@ public:
		RangingType ranging_type_ = RANGING_TYPE_NONE;
		TimeoutType timeout_type_ = TIMEOUT_NONE;
		uint16_t conn_interval_ = kInvalidConnInterval;
		uint16_t mtu = kDefaultGattMtu;

		const gatt::Characteristic* FindCharacteristicByUuid(Uuid uuid) {
		if (service_ == nullptr) {
		@@ -235,6 +237,9 @@ public:
		case BTA_GATTC_SEARCH_CMPL_EVT: {
		OnGattServiceSearchComplete(p_data->search_cmpl);
		} break;
		case BTA_GATTC_CFG_MTU_EVT: {
		OnGattConfigMtu(p_data->cfg_mtu);
		} break;
		case BTA_GATTC_NOTIF_EVT: {
		OnGattNotification(p_data->notify);
		} break;
		@@ -315,6 +320,9 @@ public:
		break;
		}
		}
		// config mtu anyway, if it had been configured by others, it can get the current mtu.
		log::info("config the MTU size as RAP minimum value {}", kMinimumRasMtu);
		BTA_GATTC_ConfigureMTU(evt.conn_id, kMinimumRasMtu);

		if (tracker->service_search_complete_) {
		log::info("Service search already completed, ignore");
		@@ -367,6 +375,20 @@ public:
		}
		}

		void OnGattConfigMtu(const tBTA_GATTC_CFG_MTU& evt) {
		if (evt.status != GATT_SUCCESS) {
		log::warn("Failed to config the MTU size:{}", evt.mtu);
		return;
		}
		// the MTU is always 517 since android 14
		log::info("conn_id=0x{:04x}, status:{}, mtu:{}", evt.conn_id, evt.status, evt.mtu);
		auto tracker = FindTrackerByHandle(evt.conn_id);
		if (tracker != nullptr) {
		tracker->mtu = evt.mtu;
		callbacks_->OnMtuChangedFromClient(tracker->address_for_cs_, evt.mtu);
		}
		}

		bool UseCachedData(std::shared_ptr<RasTracker> tracker) {
		auto cached_data = cached_data_.find(tracker->address_);
		if (cached_data == cached_data_.end()) {

system/bta/ras/ras_server.cc

+17 −0

Original line number	Diff line number	Diff line
		@@ -85,6 +85,7 @@ public:
		PendingWriteResponse pending_write_response_;
		uint16_t last_ready_procedure_ = 0;
		uint16_t last_overwritten_procedure_ = 0;
		uint16_t mtu = kDefaultGattMtu;
		};

		void Initialize() override {
		@@ -210,6 +211,9 @@ public:
		case BTA_GATTS_DISCONNECT_EVT: {
		OnGattDisconnect(p_data);
		} break;
		case BTA_GATTS_MTU_EVT: {
		OnGattMtuChanged(p_data->req_data);
		} break;
		case BTA_GATTS_REG_EVT: {
		OnGattServerRegister(p_data);
		} break;
		@@ -250,6 +254,19 @@ public:
		callbacks_->OnRasServerConnected(identity_address);
		}

		void OnGattMtuChanged(const tBTA_GATTS_REQ& req_data) {
		auto remote_bda = req_data.remote_bda;
		log::info("mtu is changed as {}", req_data.p_data->mtu);
		auto it = trackers_.find(remote_bda);
		if (it != trackers_.end()) {
		it->second.mtu = req_data.p_data->mtu;

		tBLE_ADDR_TYPE address_type = BLE_ADDR_PUBLIC_ID;
		btm_random_pseudo_to_identity_addr(&remote_bda, &address_type);
		callbacks_->OnMtuChangedFromServer(remote_bda, it->second.mtu);
		}
		}

		void OnGattDisconnect(tBTA_GATTS* p_data) {
		auto remote_bda = p_data->conn.remote_bda;
		log::info("Address: {}, conn_id:{}", remote_bda, p_data->conn.conn_id);

system/bta/ras/ras_types.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@ static const uint16_t kRasControlPointCharacteristic16bit = 0x2C17;
		static const uint16_t kRasRangingDataReadyCharacteristic16bit = 0x2C18;
		static const uint16_t kRasRangingDataOverWrittenCharacteristic16bit = 0x2C19;
		static const uint16_t kClientCharacteristicConfiguration16bit = 0x2902;
		static const uint16_t kDefaultGattMtu = 23;

		static const bluetooth::Uuid kRangingService = bluetooth::Uuid::From16Bit(kRangingService16Bit);
		static const bluetooth::Uuid kRasFeaturesCharacteristic =

system/gd/hci/distance_measurement_manager.cc

+33 −8

Original line number	Diff line number	Diff line
		@@ -66,7 +66,6 @@ static constexpr uint32_t kMinSubeventLen = 0x0004E2; // 1250us
		static constexpr uint32_t kMaxSubeventLen = 0x3d0900; // 4s
		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
		static constexpr uint16_t kRangingCounterMask = 0x0FFF;
		static constexpr uint8_t kInvalidConfigId = 0xFF;
		static constexpr uint8_t kMinConfigId = 0;
		@@ -75,6 +74,9 @@ static constexpr uint16_t kDefaultIntervalMs = 1000; // 1s
		static constexpr uint8_t kMaxRetryCounterForCreateConfig = 0x03;
		static constexpr uint8_t kMaxRetryCounterForCsEnable = 0x03;
		static constexpr uint16_t kInvalidConnInterval = 0; // valid value is from 0x0006 to 0x0C80
		static constexpr uint16_t kDefaultRasMtu = 247; // Section 3.1.2 of RAP 1.0
		static constexpr uint8_t kAttHeaderSize = 5; // Section 3.2.2.1 of RAS 1.0
		static constexpr uint8_t kRasSegmentHeaderSize = 1;

		struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		struct CsProcedureData {
		@@ -534,6 +536,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		}
		distance_measurement_callbacks_->OnDistanceMeasurementStopped(
		address, REASON_NO_LE_CONNECTION, METHOD_CS);
		gatt_mtus_.erase(it->first);
		it = cs_requester_trackers_.erase(it); // erase and get the next iterator
		} else {
		++it;
		@@ -580,6 +583,20 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		it->second.local_hci_role = local_hci_role;
		}

		void handle_mtu_changed(uint16_t connection_handle, uint16_t mtu) {
		log::info("gatt mtu is changed as {}", mtu);
		gatt_mtus_[connection_handle] = mtu;
		}

		uint16_t get_ras_raw_payload_size(uint16_t connection_handle) {
		auto it = gatt_mtus_.find(connection_handle);
		uint16_t mtu = kDefaultRasMtu;
		if (it != gatt_mtus_.end()) {
		mtu = gatt_mtus_[connection_handle];
		}
		return mtu - kAttHeaderSize - kRasSegmentHeaderSize;
		}

		void handle_ras_server_disconnected(const Address& identity_address, uint16_t connection_handle) {
		auto it = cs_responder_trackers_.find(connection_handle);
		if (it == cs_responder_trackers_.end()) {
		@@ -592,6 +609,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		return;
		}
		cs_responder_trackers_.erase(connection_handle);
		gatt_mtus_.erase(connection_handle);
		}

		void handle_vendor_specific_reply_complete(const Address address, uint16_t connection_handle,
		@@ -1356,7 +1374,8 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		append_vector(procedure_data->ras_raw_data_, subevent_raw);
		// erase buffer
		procedure_data->ras_subevent_data_.clear();
		send_on_demand_data(live_tracker->address, procedure_data);
		send_on_demand_data(live_tracker->address, procedure_data,
		get_ras_raw_payload_size(connection_handle));
		// remove procedure data sent previously
		if (procedure_done_status == CsProcedureDoneStatus::ALL_RESULTS_COMPLETE) {
		delete_consumed_procedure_data(live_tracker, live_tracker->procedure_counter);
		@@ -1364,20 +1383,21 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		}
		}

		void send_on_demand_data(Address address, CsProcedureData* procedure_data) {
		void send_on_demand_data(Address address, CsProcedureData* procedure_data,
		uint16_t raw_payload_size) {
		// Check is last segment or not.
		uint16_t unsent_data_size =
		procedure_data->ras_raw_data_.size() - procedure_data->ras_raw_data_index_;
		if (procedure_data->local_status != CsProcedureDoneStatus::PARTIAL_RESULTS &&
		unsent_data_size <= kMtuForRasData) {
		unsent_data_size <= raw_payload_size) {
		procedure_data->segmentation_header_.last_segment_ = 1;
		} else if (unsent_data_size < kMtuForRasData) {
		} else if (unsent_data_size < raw_payload_size) {
		log::verbose("waiting for more data, current unsent data size {}", unsent_data_size);
		return;
		}

		// Create raw data for segment_data;
		uint16_t copy_size = unsent_data_size < kMtuForRasData ? unsent_data_size : kMtuForRasData;
		uint16_t copy_size = unsent_data_size < raw_payload_size ? unsent_data_size : raw_payload_size;
		auto copy_start = procedure_data->ras_raw_data_.begin() + procedure_data->ras_raw_data_index_;
		auto copy_end = copy_start + copy_size;
		std::vector<uint8_t> subevent_data(copy_start, copy_end);
		@@ -1398,8 +1418,8 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		if (procedure_data->segmentation_header_.last_segment_) {
		// last segment sent, clear buffer
		procedure_data->ras_raw_data_.clear();
		} else if (unsent_data_size > kMtuForRasData) {
		send_on_demand_data(address, procedure_data);
		} else if (unsent_data_size > raw_payload_size) {
		send_on_demand_data(address, procedure_data, raw_payload_size);
		}
		}

		@@ -2458,6 +2478,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback {
		std::unordered_map<Address, RSSITracker> rssi_trackers;
		std::unordered_map<uint16_t, CsTracker> cs_requester_trackers_;
		std::unordered_map<uint16_t, CsTracker> cs_responder_trackers_;
		std::unordered_map<uint16_t, uint16_t> gatt_mtus_;
		DistanceMeasurementCallbacks* distance_measurement_callbacks_;
		CsOptionalSubfeaturesSupported cs_subfeature_supported_;
		uint8_t num_antennas_supported_ = 0x01;
		@@ -2551,6 +2572,10 @@ void DistanceMeasurementManager::HandleRasServerConnected(const Address& identit
		local_hci_role);
		}

		void DistanceMeasurementManager::HandleMtuChanged(uint16_t connection_handle, uint16_t mtu) {
		CallOn(pimpl_.get(), &impl::handle_mtu_changed, connection_handle, mtu);
		}

		void DistanceMeasurementManager::HandleRasServerDisconnected(
		const bluetooth::hci::Address& identity_address, uint16_t connection_handle) {
		CallOn(pimpl_.get(), &impl::handle_ras_server_disconnected, identity_address, connection_handle);