HCI: Use common status checks for events (6f4d3183) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/acl_manager/classic_acl_connection.cc

+36 −22

Original line number	Diff line number	Diff line
		@@ -15,8 +15,9 @@
		*/

		#include "hci/acl_manager/classic_acl_connection.h"
		#include "hci/acl_manager/event_checkers.h"

		#include "hci/address.h"
		#include "hci/event_checkers.h"
		#include "os/metrics.h"

		using bluetooth::hci::Address;
		@@ -369,71 +370,73 @@ void ClassicAclConnection::RegisterCallbacks(ConnectionManagementCallbacks* call
		bool ClassicAclConnection::Disconnect(DisconnectReason reason) {
		acl_connection_interface_->EnqueueCommand(
		DisconnectBuilder::Create(handle_, reason),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<DisconnectStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<DisconnectStatusView>));
		return true;
		}

		bool ClassicAclConnection::ChangeConnectionPacketType(uint16_t packet_type) {
		acl_connection_interface_->EnqueueCommand(
		ChangeConnectionPacketTypeBuilder::Create(handle_, packet_type),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<ChangeConnectionPacketTypeStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(
		check_status<ChangeConnectionPacketTypeStatusView>));
		return true;
		}

		bool ClassicAclConnection::AuthenticationRequested() {
		acl_connection_interface_->EnqueueCommand(
		AuthenticationRequestedBuilder::Create(handle_),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<AuthenticationRequestedStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<AuthenticationRequestedStatusView>));
		return true;
		}

		bool ClassicAclConnection::SetConnectionEncryption(Enable enable) {
		acl_connection_interface_->EnqueueCommand(
		SetConnectionEncryptionBuilder::Create(handle_, enable),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<SetConnectionEncryptionStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<SetConnectionEncryptionStatusView>));
		return true;
		}

		bool ClassicAclConnection::ChangeConnectionLinkKey() {
		acl_connection_interface_->EnqueueCommand(
		ChangeConnectionLinkKeyBuilder::Create(handle_),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<ChangeConnectionLinkKeyStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<ChangeConnectionLinkKeyStatusView>));
		return true;
		}

		bool ClassicAclConnection::ReadClockOffset() {
		acl_connection_interface_->EnqueueCommand(
		ReadClockOffsetBuilder::Create(handle_),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<ReadClockOffsetStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<ReadClockOffsetStatusView>));
		return true;
		}

		bool ClassicAclConnection::HoldMode(uint16_t max_interval, uint16_t min_interval) {
		acl_connection_interface_->EnqueueCommand(
		HoldModeBuilder::Create(handle_, max_interval, min_interval),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<HoldModeStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<HoldModeStatusView>));
		return true;
		}

		bool ClassicAclConnection::SniffMode(uint16_t max_interval, uint16_t min_interval, uint16_t attempt, uint16_t timeout) {
		acl_connection_interface_->EnqueueCommand(
		SniffModeBuilder::Create(handle_, max_interval, min_interval, attempt, timeout),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<SniffModeStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<SniffModeStatusView>));
		return true;
		}

		bool ClassicAclConnection::ExitSniffMode() {
		acl_connection_interface_->EnqueueCommand(
		ExitSniffModeBuilder::Create(handle_),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<ExitSniffModeStatusView>));
		pimpl_->tracker.client_handler_->BindOnce(check_status<ExitSniffModeStatusView>));
		return true;
		}

		bool ClassicAclConnection::QosSetup(ServiceType service_type, uint32_t token_rate, uint32_t peak_bandwidth,
		uint32_t latency, uint32_t delay_variation) {
		acl_connection_interface_->EnqueueCommand(
		QosSetupBuilder::Create(handle_, service_type, token_rate, peak_bandwidth, latency, delay_variation),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<QosSetupStatusView>));
		QosSetupBuilder::Create(
		handle_, service_type, token_rate, peak_bandwidth, latency, delay_variation),
		pimpl_->tracker.client_handler_->BindOnce(check_status<QosSetupStatusView>));
		return true;
		}

		@@ -455,7 +458,8 @@ bool ClassicAclConnection::ReadLinkPolicySettings() {
		bool ClassicAclConnection::WriteLinkPolicySettings(uint16_t link_policy_settings) {
		acl_connection_interface_->EnqueueCommand(
		WriteLinkPolicySettingsBuilder::Create(handle_, link_policy_settings),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_complete<WriteLinkPolicySettingsCompleteView>));
		pimpl_->tracker.client_handler_->BindOnce(
		check_complete<WriteLinkPolicySettingsCompleteView>));
		return true;
		}

		@@ -463,24 +467,31 @@ bool ClassicAclConnection::FlowSpecification(FlowDirection flow_direction, Servi
		uint32_t token_rate, uint32_t token_bucket_size, uint32_t peak_bandwidth,
		uint32_t access_latency) {
		acl_connection_interface_->EnqueueCommand(
		FlowSpecificationBuilder::Create(handle_, flow_direction, service_type, token_rate, token_bucket_size,
		peak_bandwidth, access_latency),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_status<FlowSpecificationStatusView>));
		FlowSpecificationBuilder::Create(
		handle_,
		flow_direction,
		service_type,
		token_rate,
		token_bucket_size,
		peak_bandwidth,
		access_latency),
		pimpl_->tracker.client_handler_->BindOnce(check_status<FlowSpecificationStatusView>));
		return true;
		}

		bool ClassicAclConnection::SniffSubrating(uint16_t maximum_latency, uint16_t minimum_remote_timeout,
		uint16_t minimum_local_timeout) {
		acl_connection_interface_->EnqueueCommand(
		SniffSubratingBuilder::Create(handle_, maximum_latency, minimum_remote_timeout, minimum_local_timeout),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_complete<SniffSubratingCompleteView>));
		SniffSubratingBuilder::Create(
		handle_, maximum_latency, minimum_remote_timeout, minimum_local_timeout),
		pimpl_->tracker.client_handler_->BindOnce(check_complete<SniffSubratingCompleteView>));
		return true;
		}

		bool ClassicAclConnection::Flush() {
		acl_connection_interface_->EnqueueCommand(
		FlushBuilder::Create(handle_),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_complete<FlushCompleteView>));
		pimpl_->tracker.client_handler_->BindOnce(check_complete<FlushCompleteView>));
		return true;
		}

		@@ -495,7 +506,8 @@ bool ClassicAclConnection::ReadAutomaticFlushTimeout() {
		bool ClassicAclConnection::WriteAutomaticFlushTimeout(uint16_t flush_timeout) {
		acl_connection_interface_->EnqueueCommand(
		WriteAutomaticFlushTimeoutBuilder::Create(handle_, flush_timeout),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_complete<WriteAutomaticFlushTimeoutCompleteView>));
		pimpl_->tracker.client_handler_->BindOnce(
		check_complete<WriteAutomaticFlushTimeoutCompleteView>));
		return true;
		}

		@@ -518,7 +530,8 @@ bool ClassicAclConnection::ReadLinkSupervisionTimeout() {
		bool ClassicAclConnection::WriteLinkSupervisionTimeout(uint16_t link_supervision_timeout) {
		acl_connection_interface_->EnqueueCommand(
		WriteLinkSupervisionTimeoutBuilder::Create(handle_, link_supervision_timeout),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_complete<WriteLinkSupervisionTimeoutCompleteView>));
		pimpl_->tracker.client_handler_->BindOnce(
		check_complete<WriteLinkSupervisionTimeoutCompleteView>));
		return true;
		}

		@@ -533,7 +546,8 @@ bool ClassicAclConnection::ReadFailedContactCounter() {
		bool ClassicAclConnection::ResetFailedContactCounter() {
		acl_connection_interface_->EnqueueCommand(
		ResetFailedContactCounterBuilder::Create(handle_),
		pimpl_->tracker.client_handler_->BindOnce(&check_command_complete<ResetFailedContactCounterCompleteView>));
		pimpl_->tracker.client_handler_->BindOnce(
		check_complete<ResetFailedContactCounterCompleteView>));
		return true;
		}

system/gd/hci/acl_manager/classic_impl.h

+7 −6

Original line number	Diff line number	Diff line
		@@ -24,9 +24,9 @@
		#include "common/init_flags.h"
		#include "hci/acl_manager/acl_scheduler.h"
		#include "hci/acl_manager/assembler.h"
		#include "hci/acl_manager/event_checkers.h"
		#include "hci/acl_manager/round_robin_scheduler.h"
		#include "hci/controller.h"
		#include "hci/event_checkers.h"
		#include "hci/remote_name_request.h"
		#include "os/metrics.h"
		#include "security/security_manager_listener.h"
		@@ -470,7 +470,7 @@ struct classic_impl : public security::ISecurityManagerListener {
		void actually_cancel_connect(Address address) {
		std::unique_ptr<CreateConnectionCancelBuilder> packet = CreateConnectionCancelBuilder::Create(address);
		acl_connection_interface_->EnqueueCommand(
		std::move(packet), handler_->BindOnce(&check_command_complete<CreateConnectionCancelCompleteView>));
		std::move(packet), handler_->BindOnce(check_complete<CreateConnectionCancelCompleteView>));
		}

		static constexpr bool kRemoveConnectionAfterwards = true;
		@@ -754,20 +754,21 @@ struct classic_impl : public security::ISecurityManagerListener {
		void central_link_key(KeyFlag key_flag) {
		std::unique_ptr<CentralLinkKeyBuilder> packet = CentralLinkKeyBuilder::Create(key_flag);
		acl_connection_interface_->EnqueueCommand(
		std::move(packet), handler_->BindOnce(&check_command_status<CentralLinkKeyStatusView>));
		std::move(packet), handler_->BindOnce(check_status<CentralLinkKeyStatusView>));
		}

		void switch_role(Address address, Role role) {
		std::unique_ptr<SwitchRoleBuilder> packet = SwitchRoleBuilder::Create(address, role);
		acl_connection_interface_->EnqueueCommand(
		std::move(packet), handler_->BindOnce(&check_command_status<SwitchRoleStatusView>));
		std::move(packet), handler_->BindOnce(check_status<SwitchRoleStatusView>));
		}

		void write_default_link_policy_settings(uint16_t default_link_policy_settings) {
		std::unique_ptr<WriteDefaultLinkPolicySettingsBuilder> packet =
		WriteDefaultLinkPolicySettingsBuilder::Create(default_link_policy_settings);
		acl_connection_interface_->EnqueueCommand(
		std::move(packet), handler_->BindOnce(&check_command_complete<WriteDefaultLinkPolicySettingsCompleteView>));
		std::move(packet),
		handler_->BindOnce(check_complete<WriteDefaultLinkPolicySettingsCompleteView>));
		}

		void accept_connection(Address address) {
		@@ -779,7 +780,7 @@ struct classic_impl : public security::ISecurityManagerListener {

		void reject_connection(std::unique_ptr<RejectConnectionRequestBuilder> builder) {
		acl_connection_interface_->EnqueueCommand(
		std::move(builder), handler_->BindOnce(&check_command_status<RejectConnectionRequestStatusView>));
		std::move(builder), handler_->BindOnce(check_status<RejectConnectionRequestStatusView>));
		}

		void OnDeviceBonded(bluetooth::hci::AddressWithType /* device */) override {}

system/gd/hci/acl_manager/event_checkers.h→system/gd/hci/event_checkers.h

+6 −8

Original line number	Diff line number	Diff line
		@@ -18,42 +18,40 @@

		namespace bluetooth {
		namespace hci {
		namespace acl_manager {

		template <class T>
		void check_command_complete(CommandCompleteView view) {
		void check_complete(CommandCompleteView view) {
		ASSERT(view.IsValid());
		auto status_view = T::Create(view);
		if (!status_view.IsValid()) {
		LOG_ERROR("Received command complete with invalid packet, opcode 0x%02hx", view.GetCommandOpCode());
		LOG_ERROR("Invalid packet, opcode 0x%02hx", view.GetCommandOpCode());
		return;
		}
		ErrorCode status = status_view.GetStatus();
		OpCode op_code = status_view.GetCommandOpCode();
		if (status != ErrorCode::SUCCESS) {
		std::string error_code = ErrorCodeText(status);
		LOG_ERROR("Received command complete with error code %s, opcode 0x%02hx", error_code.c_str(), op_code);
		LOG_ERROR("Error code %s, opcode 0x%02hx", error_code.c_str(), op_code);
		return;
		}
		}

		template <class T>
		void check_command_status(CommandStatusView view) {
		void check_status(CommandStatusView view) {
		ASSERT(view.IsValid());
		auto status_view = T::Create(view);
		if (!status_view.IsValid()) {
		LOG_ERROR("Received command status with invalid packet, opcode 0x%02hx", view.GetCommandOpCode());
		LOG_ERROR("Invalid packet, opcode 0x%02hx", view.GetCommandOpCode());
		return;
		}
		ErrorCode status = status_view.GetStatus();
		OpCode op_code = status_view.GetCommandOpCode();
		if (status != ErrorCode::SUCCESS) {
		std::string error_code = ErrorCodeText(status);
		LOG_ERROR("Received command status with error code %s, opcode 0x%02hx", error_code.c_str(), op_code);
		LOG_ERROR("Error code %s, opcode 0x%02hx", error_code.c_str(), op_code);
		return;
		}
		}

		} // namespace acl_manager
		} // namespace hci
		} // namespace bluetooth

system/gd/hci/le_periodic_sync_manager.h

+6 −26

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include "common/callback.h"
		#include "common/init_flags.h"
		#include "hci/address_with_type.h"
		#include "hci/event_checkers.h"
		#include "hci/hci_packets.h"
		#include "hci/le_scanning_callback.h"
		#include "hci/le_scanning_interface.h"
		@@ -118,14 +119,13 @@ class PeriodicSyncManager {
		LOG_ERROR("[PSync]: invalid index for handle %u", handle);
		le_scanning_interface_->EnqueueCommand(
		hci::LePeriodicAdvertisingTerminateSyncBuilder::Create(handle),
		handler_->BindOnceOn(
		this, &PeriodicSyncManager::check_status<LePeriodicAdvertisingTerminateSyncCompleteView>));
		handler_->BindOnce(check_complete<LePeriodicAdvertisingTerminateSyncCompleteView>));
		return;
		};
		periodic_syncs_.erase(periodic_sync);
		le_scanning_interface_->EnqueueCommand(
		hci::LePeriodicAdvertisingTerminateSyncBuilder::Create(handle),
		handler_->BindOnceOn(this, &PeriodicSyncManager::check_status<LePeriodicAdvertisingTerminateSyncCompleteView>));
		handler_->BindOnce(check_complete<LePeriodicAdvertisingTerminateSyncCompleteView>));
		}

		void CancelCreateSync(uint8_t adv_sid, Address address) {
		@@ -198,9 +198,8 @@ class PeriodicSyncManager {
		le_scanning_interface_->EnqueueCommand(
		hci::LeSetDefaultPeriodicAdvertisingSyncTransferParametersBuilder::Create(
		static_cast<SyncTransferMode>(mode), skip, timeout, sync_cte_type),
		handler_->BindOnceOn(
		this,
		&PeriodicSyncManager::check_status<LeSetDefaultPeriodicAdvertisingSyncTransferParametersCompleteView>));
		handler_->BindOnce(
		check_complete<LeSetDefaultPeriodicAdvertisingSyncTransferParametersCompleteView>));
		}

		void HandlePeriodicAdvertisingCreateSyncStatus(CommandStatusView) {}
		@@ -237,24 +236,6 @@ class PeriodicSyncManager {
		periodic_sync_transfers_.erase(periodic_sync_transfer);
		}

		template <class View>
		void check_status(CommandCompleteView view) {
		ASSERT(view.IsValid());
		auto status_view = View::Create(view);
		ASSERT(status_view.IsValid());
		if (status_view.GetStatus() != ErrorCode::SUCCESS) {
		LOG_WARN(
		"Got a Command complete %s, status %s",
		OpCodeText(view.GetCommandOpCode()).c_str(),
		ErrorCodeText(status_view.GetStatus()).c_str());
		} else {
		LOG_DEBUG(
		"Got a Command complete %s, status %s",
		OpCodeText(view.GetCommandOpCode()).c_str(),
		ErrorCodeText(status_view.GetStatus()).c_str());
		}
		}

		void HandleLePeriodicAdvertisingSyncEstablished(LePeriodicAdvertisingSyncEstablishedView event_view) {
		ASSERT(event_view.IsValid());
		LOG_DEBUG(
		@@ -296,8 +277,7 @@ class PeriodicSyncManager {
		LOG_WARN("Terminate sync");
		le_scanning_interface_->EnqueueCommand(
		hci::LePeriodicAdvertisingTerminateSyncBuilder::Create(event_view.GetSyncHandle()),
		handler_->BindOnceOn(
		this, &PeriodicSyncManager::check_status<LePeriodicAdvertisingTerminateSyncCompleteView>));
		handler_->BindOnce(check_complete<LePeriodicAdvertisingTerminateSyncCompleteView>));
		}
		AdvanceRequest();
		return;

system/gd/hci/remote_name_request.cc

+2 −3

Original line number	Diff line number	Diff line
		@@ -22,7 +22,7 @@
		#include <variant>

		#include "hci/acl_manager/acl_scheduler.h"
		#include "hci/acl_manager/event_checkers.h"
		#include "hci/event_checkers.h"
		#include "hci/hci_layer.h"

		namespace bluetooth {
		@@ -150,8 +150,7 @@ struct RemoteNameRequestModule::impl {
		LOG_INFO("Cancelling remote name request to %s", address.ToRedactedStringForLogging().c_str());
		hci_layer_->EnqueueCommand(
		RemoteNameRequestCancelBuilder::Create(address),
		handler_->BindOnce(
		&acl_manager::check_command_complete<RemoteNameRequestCancelCompleteView>));
		handler_->BindOnce(check_complete<RemoteNameRequestCancelCompleteView>));
		}

		void on_remote_host_supported_features_notification(EventView view) {