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

Commit b169ee55 authored by Steven Liu's avatar Steven Liu
Browse files

Send aborted procedure data to HAL as required. 

1. send aborted procedure as required;
2. update the procedure sequence after procedure enabled;

Flag: com.android.bluetooth.flags.channel_sounding_25q2_apis
Bug: 367409858
Bug: 378942784
Test: m com.android.btservices

Change-Id: I485436c17accbbd0b702c69701cd94f190160511
parent 90cef83f

system/gd/hal/ranging_hal.h

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

  virtual void WriteProcedureData(uint16_t connection_handle, hci::CsRole local_cs_role,

                                  const ProcedureDataV2& procedure_data,

                                  const ProcedureDataV2& procedure_data,

                                  uint16_t procedure_counter) = 0;

                                  uint16_t procedure_counter) = 0;

  virtual bool IsAbortedProcedureRequired(uint16_t connection_handle) = 0;

};

};





}  // namespace hal

}  // namespace hal

system/gd/hal/ranging_hal_android.cc

+19 −0
Original line number Original line 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:

protected:

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

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

system/gd/hal/ranging_hal_host.cc

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

  void UpdateConnInterval(uint16_t /* connection_handle */, uint16_t /* conn_interval */) override {

  }

  }





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



protected:

protected:

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

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

system/gd/hci/distance_measurement_manager.cc

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

    RangingHeader ranging_header_;

    PacketViewForRecombination segment_data_;

    PacketViewForRecombination segment_data_;

    uint16_t conn_interval_ = kInvalidConnInterval;

    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) {

  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);

                                                                      METHOD_CS);

      }

      }

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

      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);

        ranging_hal_->UpdateProcedureEnableConfig(connection_handle, event_view);

      }

      }

    } else if (event_view.GetState() == Enable::DISABLED) {

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

              static_cast<bluetooth::ras::SubeventAbortReason>(subevent_abort_reason);

    }

    }

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

    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) {

    if (live_tracker->local_start) {

      check_cs_procedure_complete(live_tracker, procedure_data, connection_handle);

      // Skip to send remote

      // Skip to send remote

      return;

      return;

    }

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

    return procedure_data;

  }

  }





  void check_cs_procedure_complete(CsTracker* live_tracker, CsProcedureData* procedure_data,

  void try_send_data_to_hal(uint16_t connection_handle, const CsTracker* live_tracker,

                                   uint16_t connection_handle) const {

                            const CsProcedureData* procedure_data) const {

    if (live_tracker->local_start &&

    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->local_status == CsProcedureDoneStatus::ALL_RESULTS_COMPLETE &&

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

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

        procedure_data->contains_complete_subevent_) {

              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(),

    if (should_send_to_hal) {

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

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



                 procedure_data->step_channel.size());

      if (ranging_hal_->IsBound()) {

      if (is_hal_v2()) {

      if (is_hal_v2()) {

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

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

                                         procedure_data->procedure_data_v2_,

                                         procedure_data->procedure_data_v2_,
@@ -1996,6 +2006,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 the procedure is completed or aborted, delete all previous data

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

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

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

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