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

Commit dfc3fc84 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Send aborted procedure data to HAL as required." into main am: 5a131460 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/3418940



Change-Id: I81f2f3a4c50434a3624e0e4546c147fd88bff43e
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 70437bdd 5a131460

system/gd/hal/ranging_hal.h

+1 −0
Original line number Diff line number Diff line
@@ -323,6 +323,7 @@ public: 
  virtual void WriteProcedureData(uint16_t connection_handle, hci::CsRole local_cs_role,

                                  const ProcedureDataV2& procedure_data,

                                  uint16_t procedure_counter) = 0;

  virtual bool IsAbortedProcedureRequired(uint16_t connection_handle) = 0;

};



}  // namespace hal

system/gd/hal/ranging_hal_android.cc

+19 −0
Original line number Diff line number Diff line
@@ -521,6 +521,25 @@ public: 
    }

  }



  bool IsAbortedProcedureRequired(uint16_t connection_handle) override {

    auto it = session_trackers_.find(connection_handle);

    if (it == session_trackers_.end()) {

      log::error("Can't find session for connection_handle:0x{:04x}", connection_handle);

      return false;

    }

    if (it->second->GetSession() == nullptr) {

      log::error("Session not opened");

      return false;

    }

    bool isRequired = false;

    auto aidl_ret = it->second->GetSession()->isAbortedProcedureRequired(&isRequired);

    if (aidl_ret.isOk()) {

      return isRequired;

    }

    log::error("can not get result for isAbortedProcedureRequired.");

    return false;

  }



protected:

  void ListDependencies(ModuleList* /*list*/) const {}

system/gd/hal/ranging_hal_host.cc

+2 −0
Original line number Diff line number Diff line
@@ -63,6 +63,8 @@ public: 
  void UpdateConnInterval(uint16_t /* connection_handle */, uint16_t /* conn_interval */) override {

  }



  bool IsAbortedProcedureRequired(uint16_t /*connection_handle*/) { return false; }



protected:

  void ListDependencies(ModuleList* /*list*/) const {}

system/gd/hci/distance_measurement_manager.cc

+54 −32
Original line number Diff line number Diff line
@@ -208,6 +208,7 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback { 
    RangingHeader ranging_header_;

    PacketViewForRecombination segment_data_;

    uint16_t conn_interval_ = kInvalidConnInterval;

    uint8_t procedure_sequence_after_enable = -1;

  };



  bool get_free_config_id(uint16_t connection_handle, uint8_t& config_id) {
@@ -1193,6 +1194,8 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback { 
                                                                      METHOD_CS);

      }

      if (live_tracker->local_start && is_hal_v2()) {

        // reset the procedure sequence

        live_tracker->procedure_sequence_after_enable = -1;

        ranging_hal_->UpdateProcedureEnableConfig(connection_handle, event_view);

      }

    } else if (event_view.GetState() == Enable::DISABLED) {
@@ -1357,9 +1360,9 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback { 
              static_cast<bluetooth::ras::SubeventAbortReason>(subevent_abort_reason);

    }

    parse_cs_result_data(result_data_structures, *procedure_data, live_tracker->role);

    check_cs_procedure_complete(live_tracker, procedure_data, connection_handle);



    if (live_tracker->local_start) {

      check_cs_procedure_complete(live_tracker, procedure_data, connection_handle);

      // Skip to send remote

      return;

    }
@@ -1963,17 +1966,24 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback { 
    return procedure_data;

  }



  void check_cs_procedure_complete(CsTracker* live_tracker, CsProcedureData* procedure_data,

                                   uint16_t connection_handle) const {

    if (live_tracker->local_start &&

  void try_send_data_to_hal(uint16_t connection_handle, const CsTracker* live_tracker,

                            const CsProcedureData* procedure_data) const {

    if (!ranging_hal_->IsBound()) {

      return;

    }

    bool should_send_to_hal = false;

    if (ranging_hal_->IsAbortedProcedureRequired(connection_handle)) {

      should_send_to_hal = procedure_data->local_status != CsProcedureDoneStatus::PARTIAL_RESULTS &&

                           procedure_data->remote_status != CsProcedureDoneStatus::PARTIAL_RESULTS;

    } else {

      should_send_to_hal =

              procedure_data->local_status == CsProcedureDoneStatus::ALL_RESULTS_COMPLETE &&

              procedure_data->remote_status == CsProcedureDoneStatus::ALL_RESULTS_COMPLETE &&

        procedure_data->contains_complete_subevent_) {

      log::debug("Procedure complete counter:{} data size:{}, main_mode_type:{}, sub_mode_type:{}",

                 (uint16_t)procedure_data->counter, (uint16_t)procedure_data->step_channel.size(),

                 (uint16_t)live_tracker->main_mode_type, (uint16_t)live_tracker->sub_mode_type);



      if (ranging_hal_->IsBound()) {

              procedure_data->contains_complete_subevent_;

    }

    if (should_send_to_hal) {

      log::debug("Procedure complete counter:{} data size:{}", (uint16_t)procedure_data->counter,

                 procedure_data->step_channel.size());

      if (is_hal_v2()) {

        ranging_hal_->WriteProcedureData(connection_handle, live_tracker->role,

                                         procedure_data->procedure_data_v2_,
@@ -1998,6 +2008,18 @@ struct DistanceMeasurementManager::impl : bluetooth::hal::RangingHalCallback { 
    }

  }



  void check_cs_procedure_complete(CsTracker* live_tracker, CsProcedureData* procedure_data,

                                   uint16_t connection_handle) const {

    if (is_hal_v2() && procedure_data->local_status != CsProcedureDoneStatus::PARTIAL_RESULTS &&

        procedure_data->remote_status != CsProcedureDoneStatus::PARTIAL_RESULTS) {

      live_tracker->procedure_sequence_after_enable++;

      log::debug("procedure sequence after enabled is {}",

                 live_tracker->procedure_sequence_after_enable);

      procedure_data->procedure_data_v2_.procedure_sequence_ =

              live_tracker->procedure_sequence_after_enable;

    }

    try_send_data_to_hal(connection_handle, live_tracker, procedure_data);



    // If the procedure is completed or aborted, delete all previous data

    if (procedure_data->local_status != CsProcedureDoneStatus::PARTIAL_RESULTS &&

        procedure_data->remote_status != CsProcedureDoneStatus::PARTIAL_RESULTS) {