Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 36de764f authored by Myles Watson's avatar Myles Watson Committed by Gerrit Code Review
Browse files

Merge changes Id7ff7df7,I9a8e5293,I600cc8f3,I9e30d2f6,I8a0182e3 into main 

* changes:
  LeScanningManager: Use hci::check_complete
  LeAdvertisingManager: Use hci::check_complete
  DistanceManager: Use hci::check_complete
  Controller: Use hci::check_complete
  HCI: Use common status checks for events
parents fca6e070 de77f9a2

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/controller.cc

+19 −31
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <utility>



#include "common/init_flags.h"

#include "hci/event_checkers.h"

#include "hci/hci_layer.h"

#include "hci_controller_generated.h"

#include "os/metrics.h"
@@ -589,8 +590,9 @@ struct Controller::impl { 


  void set_event_mask(uint64_t event_mask) {

    std::unique_ptr<SetEventMaskBuilder> packet = SetEventMaskBuilder::Create(event_mask);

    hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(

                                                this, &Controller::impl::check_status<SetEventMaskCompleteView>));

    hci_->EnqueueCommand(

        std::move(packet),

        module_.GetHandler()->BindOnce(check_complete<SetEventMaskCompleteView>));

  }



  void write_le_host_support(Enable enable, Enable deprecated_host_bit) {
@@ -601,20 +603,20 @@ struct Controller::impl { 
    std::unique_ptr<WriteLeHostSupportBuilder> packet = WriteLeHostSupportBuilder::Create(enable, deprecated_host_bit);

    hci_->EnqueueCommand(

        std::move(packet),

        module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<WriteLeHostSupportCompleteView>));

        module_.GetHandler()->BindOnce(check_complete<WriteLeHostSupportCompleteView>));

  }



  void write_simple_pairing_mode(Enable enable) {

    std::unique_ptr<WriteSimplePairingModeBuilder> packet = WriteSimplePairingModeBuilder::Create(enable);

    hci_->EnqueueCommand(

        std::move(packet),

        module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<WriteSimplePairingModeCompleteView>));

        module_.GetHandler()->BindOnce(check_complete<WriteSimplePairingModeCompleteView>));

  }



  void reset() {

    std::unique_ptr<ResetBuilder> packet = ResetBuilder::Create();

    hci_->EnqueueCommand(std::move(packet),

                         module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<ResetCompleteView>));

    hci_->EnqueueCommand(

        std::move(packet), module_.GetHandler()->BindOnce(check_complete<ResetCompleteView>));

  }



  void le_rand(LeRandCallback cb) {
@@ -635,8 +637,9 @@ struct Controller::impl { 
  }



  void set_event_filter(std::unique_ptr<SetEventFilterBuilder> packet) {

    hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(

                                                this, &Controller::impl::check_status<SetEventFilterCompleteView>));

    hci_->EnqueueCommand(

        std::move(packet),

        module_.GetHandler()->BindOnce(check_complete<SetEventFilterCompleteView>));

  }



  void write_local_name(std::string local_name) {
@@ -647,8 +650,9 @@ struct Controller::impl { 
    std::copy(std::begin(local_name), std::end(local_name), std::begin(local_name_array));



    std::unique_ptr<WriteLocalNameBuilder> packet = WriteLocalNameBuilder::Create(local_name_array);

    hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(

                                                this, &Controller::impl::check_status<WriteLocalNameCompleteView>));

    hci_->EnqueueCommand(

        std::move(packet),

        module_.GetHandler()->BindOnce(check_complete<WriteLocalNameCompleteView>));

  }



  void host_buffer_size(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
@@ -656,32 +660,16 @@ struct Controller::impl { 
    std::unique_ptr<HostBufferSizeBuilder> packet =

        HostBufferSizeBuilder::Create(host_acl_data_packet_length, host_synchronous_data_packet_length,

                                      host_total_num_acl_data_packets, host_total_num_synchronous_data_packets);

    hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(

                                                this, &Controller::impl::check_status<HostBufferSizeCompleteView>));

    hci_->EnqueueCommand(

        std::move(packet),

        module_.GetHandler()->BindOnce(check_complete<HostBufferSizeCompleteView>));

  }



  void le_set_event_mask(uint64_t le_event_mask) {

    std::unique_ptr<LeSetEventMaskBuilder> packet = LeSetEventMaskBuilder::Create(le_event_mask);

    hci_->EnqueueCommand(

        std::move(packet), module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_le_set_event_mask_status));

  }



  void check_le_set_event_mask_status(CommandCompleteView view) {

    ASSERT(view.IsValid());

    auto status_view = LeSetEventMaskCompleteView::Create(view);

    ASSERT(status_view.IsValid());

    auto status = status_view.GetStatus();

    if (status != ErrorCode::SUCCESS) {

      LOG_WARN("Unexpected return status %s", ErrorCodeText(status).c_str());

    }

  }



  template <class T>

  void check_status(CommandCompleteView view) {

    ASSERT(view.IsValid());

    auto status_view = T::Create(view);

    ASSERT(status_view.IsValid());

    ASSERT(status_view.GetStatus() == ErrorCode::SUCCESS);

        std::move(packet),

        module_.GetHandler()->BindOnce(check_complete<LeSetEventMaskCompleteView>));

  }



#define OP_CODE_MAPPING(name)                                                  \

system/gd/hci/distance_measurement_manager.cc

+2 −15
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 


#include "hci/acl_manager.h"

#include "hci/distance_measurement_interface.h"

#include "hci/event_checkers.h"

#include "hci/hci_layer.h"

#include "module.h"

#include "os/handler.h"
@@ -104,8 +105,7 @@ struct DistanceMeasurementManager::impl { 
          hci_layer_->EnqueueCommand(

              LeSetTransmitPowerReportingEnableBuilder::Create(

                  rssi_trackers[address].handle, 0x00, 0x00),

              handler_->BindOnceOn(

                  this, &impl::check_status<LeSetTransmitPowerReportingEnableCompleteView>));

              handler_->BindOnce(check_complete<LeSetTransmitPowerReportingEnableCompleteView>));

          rssi_trackers[address].alarm->Cancel();

          rssi_trackers[address].alarm.reset();

          rssi_trackers.erase(address);
@@ -299,19 +299,6 @@ struct DistanceMeasurementManager::impl { 
        DistanceMeasurementMethod::METHOD_RSSI);

  }



  template <class View>

  void check_status(CommandCompleteView view) {

    auto status_view = View::Create(view);

    if (!status_view.IsValid()) {

      LOG_WARN("Get invalid command complete event");

    } else if (status_view.GetStatus() != ErrorCode::SUCCESS) {

      LOG_INFO(

          "Got a Command complete %s, status %s",

          OpCodeText(view.GetCommandOpCode()).c_str(),

          ErrorCodeText(status_view.GetStatus()).c_str());

    }

  }



  struct RSSITracker {

    uint16_t handle;

    uint16_t frequency;

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