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

Commit d8e915ab authored by Roshan Pius's avatar Roshan Pius
Browse files

wifi: Add RTT API wrappers in WifiLegacyHal 

These are just wrapper methods over the legacy RTT related HAL API's.
Note: Some of the RTT related API's have been intentionally left off
because they're no longer used.

Bug: 31991232
Test: Compiles
Change-Id: Ied19d9ec1d4347ead0c40ab3683a1a0bae704f90
parent 8714a3e1

wifi/1.0/default/wifi_legacy_hal.cpp

+115 −0
Original line number Diff line number Diff line
@@ -112,6 +112,18 @@ void onRingBufferData(char* ring_name, 
  }

}



// Callback to be invoked for rtt results results.

std::function<void(

    wifi_request_id, unsigned num_results, wifi_rtt_result* rtt_results[])>

    on_rtt_results_internal_callback;

void onRttResults(wifi_request_id id,

                  unsigned num_results,

                  wifi_rtt_result* rtt_results[]) {

  if (on_rtt_results_internal_callback) {

    on_rtt_results_internal_callback(id, num_results, rtt_results);

  }

}



// End of the free-standing "C" style callbacks.



WifiLegacyHal::WifiLegacyHal()
@@ -549,6 +561,108 @@ wifi_error WifiLegacyHal::getRingBufferData(const std::string& ring_name) { 
                                               ring_name_internal.data());

}



wifi_error WifiLegacyHal::startRttRangeRequest(

    wifi_request_id id,

    const std::vector<wifi_rtt_config>& rtt_configs,

    const on_rtt_results_callback& on_results_user_callback) {

  if (on_rtt_results_internal_callback) {

    return WIFI_ERROR_NOT_AVAILABLE;

  }



  on_rtt_results_internal_callback = [on_results_user_callback](

      wifi_request_id id,

      unsigned num_results,

      wifi_rtt_result* rtt_results[]) {

    if (num_results > 0 && !rtt_results) {

      LOG(ERROR) << "Unexpected nullptr in RTT results";

      return;

    }

    std::vector<const wifi_rtt_result*> rtt_results_vec;

    std::copy_if(

        rtt_results,

        rtt_results + num_results,

        back_inserter(rtt_results_vec),

        [](wifi_rtt_result* rtt_result) { return rtt_result != nullptr; });

    on_results_user_callback(id, rtt_results_vec);

  };



  std::vector<wifi_rtt_config> rtt_configs_internal(rtt_configs);

  return global_func_table_.wifi_rtt_range_request(id,

                                                   wlan_interface_handle_,

                                                   rtt_configs.size(),

                                                   rtt_configs_internal.data(),

                                                   {onRttResults});

}



wifi_error WifiLegacyHal::cancelRttRangeRequest(

    wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs) {

  if (!on_rtt_results_internal_callback) {

    return WIFI_ERROR_NOT_AVAILABLE;

  }

  static_assert(sizeof(mac_addr) == sizeof(std::array<uint8_t, 6>),

                "MAC address size mismatch");

  // TODO: How do we handle partial cancels (i.e only a subset of enabled mac

  // addressed are cancelled).

  std::vector<std::array<uint8_t, 6>> mac_addrs_internal(mac_addrs);

  wifi_error status = global_func_table_.wifi_rtt_range_cancel(

      id,

      wlan_interface_handle_,

      mac_addrs.size(),

      reinterpret_cast<mac_addr*>(mac_addrs_internal.data()));

  // If the request Id is wrong, don't stop the ongoing range request. Any

  // other error should be treated as the end of rtt ranging.

  if (status != WIFI_ERROR_INVALID_REQUEST_ID) {

    on_rtt_results_internal_callback = nullptr;

  }

  return status;

}



std::pair<wifi_error, wifi_rtt_capabilities>

WifiLegacyHal::getRttCapabilities() {

  wifi_rtt_capabilities rtt_caps;

  wifi_error status = global_func_table_.wifi_get_rtt_capabilities(

      wlan_interface_handle_, &rtt_caps);

  return {status, rtt_caps};

}



std::pair<wifi_error, wifi_rtt_responder> WifiLegacyHal::getRttResponderInfo() {

  wifi_rtt_responder rtt_responder;

  wifi_error status = global_func_table_.wifi_rtt_get_responder_info(

      wlan_interface_handle_, &rtt_responder);

  return {status, rtt_responder};

}



wifi_error WifiLegacyHal::enableRttResponder(

    wifi_request_id id,

    const wifi_channel_info& channel_hint,

    uint32_t max_duration_secs,

    const wifi_rtt_responder& info) {

  wifi_rtt_responder info_internal(info);

  return global_func_table_.wifi_enable_responder(id,

                                                  wlan_interface_handle_,

                                                  channel_hint,

                                                  max_duration_secs,

                                                  &info_internal);

}



wifi_error WifiLegacyHal::disableRttResponder(wifi_request_id id) {

  return global_func_table_.wifi_disable_responder(id, wlan_interface_handle_);

}



wifi_error WifiLegacyHal::setRttLci(wifi_request_id id,

                                    const wifi_lci_information& info) {

  wifi_lci_information info_internal(info);

  return global_func_table_.wifi_set_lci(

      id, wlan_interface_handle_, &info_internal);

}



wifi_error WifiLegacyHal::setRttLcr(wifi_request_id id,

                                    const wifi_lcr_information& info) {

  wifi_lcr_information info_internal(info);

  return global_func_table_.wifi_set_lcr(

      id, wlan_interface_handle_, &info_internal);

}



wifi_error WifiLegacyHal::retrieveWlanInterfaceHandle() {

  const std::string& ifname_to_find = getStaIfaceName();

  wifi_interface_handle* iface_handles = nullptr;
@@ -627,6 +741,7 @@ void WifiLegacyHal::invalidate() { 
  on_gscan_full_result_internal_callback = nullptr;

  on_link_layer_stats_result_internal_callback = nullptr;

  on_ring_buffer_data_internal_callback = nullptr;

  on_rtt_results_internal_callback = nullptr;

}



}  // namespace legacy_hal

wifi/1.0/default/wifi_legacy_hal.h

+23 −0
Original line number Diff line number Diff line
@@ -75,6 +75,13 @@ using on_gscan_full_result_callback = 
using on_gscan_results_callback = std::function<void(

    wifi_request_id, const std::vector<wifi_cached_scan_results>&)>;



// Callback for RTT range request results.

// Rtt results contain IE info and are hence passed by reference, to

// preserve the |LCI| and |LCR| pointers. Callee must not retain

// the pointer.

using on_rtt_results_callback = std::function<void(

    wifi_request_id, const std::vector<const wifi_rtt_result*>&)>;



// Callback for ring buffer data.

using on_ring_buffer_data_callback =

    std::function<void(const std::string&,
@@ -147,6 +154,22 @@ class WifiLegacyHal { 
                                    uint32_t max_interval_sec,

                                    uint32_t min_data_size);

  wifi_error getRingBufferData(const std::string& ring_name);

  // RTT functions.

  wifi_error startRttRangeRequest(

      wifi_request_id id,

      const std::vector<wifi_rtt_config>& rtt_configs,

      const on_rtt_results_callback& on_results_callback);

  wifi_error cancelRttRangeRequest(

      wifi_request_id id, const std::vector<std::array<uint8_t, 6>>& mac_addrs);

  std::pair<wifi_error, wifi_rtt_capabilities> getRttCapabilities();

  std::pair<wifi_error, wifi_rtt_responder> getRttResponderInfo();

  wifi_error enableRttResponder(wifi_request_id id,

                                const wifi_channel_info& channel_hint,

                                uint32_t max_duration_secs,

                                const wifi_rtt_responder& info);

  wifi_error disableRttResponder(wifi_request_id id);

  wifi_error setRttLci(wifi_request_id id, const wifi_lci_information& info);

  wifi_error setRttLcr(wifi_request_id id, const wifi_lcr_information& info);



 private:

  // Retrieve the interface handle to be used for the "wlan" interface.