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

Commit 658a2724 authored by Roshan Pius's avatar Roshan Pius Committed by android-build-merger
Browse files

wifi: Add method implementations in IWifiRttController am: e3f72ff3 am: 55e445fb 

am: 14e73a88

Change-Id: Ia3757538ff1ae80748b58aa3d7b0b1ed0054467b
parents 34ff9a08 14e73a88

wifi/1.0/default/hidl_struct_util.cpp

+34 −0
Original line number Diff line number Diff line
@@ -1431,6 +1431,23 @@ bool convertHidlRttConfigToLegacy(const RttConfig& hidl_config, 
  return true;

}



bool convertHidlVectorOfRttConfigToLegacy(

    const std::vector<RttConfig>& hidl_configs,

    std::vector<legacy_hal::wifi_rtt_config>* legacy_configs) {

  if (!legacy_configs) {

    return false;

  }

  legacy_configs->clear();

  for (const auto& hidl_config : hidl_configs) {

    legacy_hal::wifi_rtt_config legacy_config;

    if (!convertHidlRttConfigToLegacy(hidl_config, &legacy_config)) {

      return false;

    }

    legacy_configs->push_back(legacy_config);

  }

  return true;

}



bool convertHidlRttLciInformationToLegacy(

    const RttLciInformation& hidl_info,

    legacy_hal::wifi_lci_information* legacy_info) {
@@ -1596,6 +1613,23 @@ bool convertLegacyRttResultToHidl( 
  }

  return true;

}



bool convertLegacyVectorOfRttResultToHidl(

    const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,

    std::vector<RttResult>* hidl_results) {

  if (!hidl_results) {

    return false;

  }

  hidl_results->clear();

  for (const auto legacy_result : legacy_results) {

    RttResult hidl_result;

    if (!convertLegacyRttResultToHidl(*legacy_result, &hidl_result)) {

      return false;

    }

    hidl_results->push_back(hidl_result);

  }

  return true;

}

}  // namespace hidl_struct_util

}  // namespace implementation

}  // namespace V1_0

wifi/1.0/default/hidl_struct_util.h

+9 −4
Original line number Diff line number Diff line
@@ -166,8 +166,9 @@ bool convertLegacyNanTransmitFollowupIndToHidl( 
    NanTransmitFollowupInd* hidl_ind);



// RTT controller conversion methods.

bool convertHidlRttConfigToLegacy(const RttConfig& hidl_config,

                                  legacy_hal::wifi_rtt_config* legacy_config);

bool convertHidlVectorOfRttConfigToLegacy(

    const std::vector<RttConfig>& hidl_configs,

    std::vector<legacy_hal::wifi_rtt_config>* legacy_configs);

bool convertHidlRttLciInformationToLegacy(

    const RttLciInformation& hidl_info,

    legacy_hal::wifi_lci_information* legacy_info);
@@ -177,14 +178,18 @@ bool convertHidlRttLcrInformationToLegacy( 
bool convertHidlRttResponderToLegacy(

    const RttResponder& hidl_responder,

    legacy_hal::wifi_rtt_responder* legacy_responder);

bool convertHidlWifiChannelInfoToLegacy(

    const WifiChannelInfo& hidl_info,

    legacy_hal::wifi_channel_info* legacy_info);

bool convertLegacyRttResponderToHidl(

    const legacy_hal::wifi_rtt_responder& legacy_responder,

    RttResponder* hidl_responder);

bool convertLegacyRttCapabilitiesToHidl(

    const legacy_hal::wifi_rtt_capabilities& legacy_capabilities,

    RttCapabilities* hidl_capabilities);

bool convertLegacyRttResultToHidl(

    const legacy_hal::wifi_rtt_result& legacy_result, RttResult* hidl_result);

bool convertLegacyVectorOfRttResultToHidl(

    const std::vector<const legacy_hal::wifi_rtt_result*>& legacy_results,

    std::vector<RttResult>* hidl_results);

}  // namespace hidl_struct_util

}  // namespace implementation

}  // namespace V1_0

wifi/1.0/default/wifi_rtt_controller.cpp

+112 −30
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <android-base/logging.h>



#include "hidl_return_util.h"

#include "hidl_struct_util.h"

#include "wifi_rtt_controller.h"

#include "wifi_status_util.h"
@@ -42,6 +43,11 @@ bool WifiRttController::isValid() { 
  return is_valid_;

}



std::vector<sp<IWifiRttControllerEventCallback>>

WifiRttController::getEventCallbacks() {

  return event_callbacks_;

}



Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
@@ -124,7 +130,7 @@ Return<void> WifiRttController::getResponderInfo( 
Return<void> WifiRttController::enableResponder(

    uint32_t cmd_id,

    const WifiChannelInfo& channel_hint,

    uint32_t maxDurationSeconds,

    uint32_t max_duration_seconds,

    const RttResponder& info,

    enableResponder_cb hidl_status_cb) {

  return validateAndCall(this,
@@ -133,7 +139,7 @@ Return<void> WifiRttController::enableResponder( 
                         hidl_status_cb,

                         cmd_id,

                         channel_hint,

                         maxDurationSeconds,

                         max_duration_seconds,

                         info);

}
@@ -159,54 +165,130 @@ WifiStatus WifiRttController::registerEventCallbackInternal( 
}



WifiStatus WifiRttController::rangeRequestInternal(

    uint32_t /* cmd_id */, const std::vector<RttConfig>& /* rtt_configs */) {

  // TODO implement

  return createWifiStatus(WifiStatusCode::SUCCESS);

    uint32_t cmd_id, const std::vector<RttConfig>& rtt_configs) {

  std::vector<legacy_hal::wifi_rtt_config> legacy_configs;

  if (!hidl_struct_util::convertHidlVectorOfRttConfigToLegacy(

          rtt_configs, &legacy_configs)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  android::wp<WifiRttController> weak_ptr_this(this);

  const auto& on_results_callback = [weak_ptr_this](

      legacy_hal::wifi_request_id id,

      const std::vector<const legacy_hal::wifi_rtt_result*>& results) {

    const auto shared_ptr_this = weak_ptr_this.promote();

    if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {

      LOG(ERROR) << "Callback invoked on an invalid object";

      return;

    }

    std::vector<RttResult> hidl_results;

    if (!hidl_struct_util::convertLegacyVectorOfRttResultToHidl(

            results, &hidl_results)) {

      LOG(ERROR) << "Failed to convert rtt results to HIDL structs";

      return;

    }

    for (const auto& callback : shared_ptr_this->getEventCallbacks()) {

      callback->onResults(id, hidl_results);

    }

  };

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->startRttRangeRequest(

          cmd_id, legacy_configs, on_results_callback);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiRttController::rangeCancelInternal(

    uint32_t /* cmd_id */,

    const std::vector<hidl_array<uint8_t, 6>>& /* addrs */) {

  // TODO implement

  return createWifiStatus(WifiStatusCode::SUCCESS);

    uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs) {

  std::vector<std::array<uint8_t, 6>> legacy_addrs;

  for (const auto& addr : addrs) {

    legacy_addrs.push_back(addr);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->cancelRttRangeRequest(cmd_id, legacy_addrs);

  return createWifiStatusFromLegacyError(legacy_status);

}



std::pair<WifiStatus, RttCapabilities>

WifiRttController::getCapabilitiesInternal() {

  // TODO implement

  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};

  legacy_hal::wifi_error legacy_status;

  legacy_hal::wifi_rtt_capabilities legacy_caps;

  std::tie(legacy_status, legacy_caps) =

      legacy_hal_.lock()->getRttCapabilities();

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    return {createWifiStatusFromLegacyError(legacy_status), {}};

  }

  RttCapabilities hidl_caps;

  if (!hidl_struct_util::convertLegacyRttCapabilitiesToHidl(legacy_caps,

                                                            &hidl_caps)) {

    return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};

  }

  return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};

}



WifiStatus WifiRttController::setLciInternal(

    uint32_t /* cmd_id */, const RttLciInformation& /* lci */) {

  // TODO implement

  return createWifiStatus(WifiStatusCode::SUCCESS);

WifiStatus WifiRttController::setLciInternal(uint32_t cmd_id,

                                             const RttLciInformation& lci) {

  legacy_hal::wifi_lci_information legacy_lci;

  if (!hidl_struct_util::convertHidlRttLciInformationToLegacy(lci,

                                                              &legacy_lci)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->setRttLci(cmd_id, legacy_lci);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiRttController::setLcrInternal(

    uint32_t /* cmd_id */, const RttLcrInformation& /* lcr */) {

  // TODO implement

  return createWifiStatus(WifiStatusCode::SUCCESS);

WifiStatus WifiRttController::setLcrInternal(uint32_t cmd_id,

                                             const RttLcrInformation& lcr) {

  legacy_hal::wifi_lcr_information legacy_lcr;

  if (!hidl_struct_util::convertHidlRttLcrInformationToLegacy(lcr,

                                                              &legacy_lcr)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->setRttLcr(cmd_id, legacy_lcr);

  return createWifiStatusFromLegacyError(legacy_status);

}



std::pair<WifiStatus, RttResponder>

WifiRttController::getResponderInfoInternal() {

  // TODO implement

  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};

  legacy_hal::wifi_error legacy_status;

  legacy_hal::wifi_rtt_responder legacy_responder;

  std::tie(legacy_status, legacy_responder) =

      legacy_hal_.lock()->getRttResponderInfo();

  if (legacy_status != legacy_hal::WIFI_SUCCESS) {

    return {createWifiStatusFromLegacyError(legacy_status), {}};

  }

  RttResponder hidl_responder;

  if (!hidl_struct_util::convertLegacyRttResponderToHidl(legacy_responder,

                                                         &hidl_responder)) {

    return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};

  }

  return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_responder};

}



WifiStatus WifiRttController::enableResponderInternal(

    uint32_t /* cmd_id */,

    const WifiChannelInfo& /* channel_hint */,

    uint32_t /* maxDurationSeconds */,

    const RttResponder& /* info */) {

  // TODO implement

  return createWifiStatus(WifiStatusCode::SUCCESS);

    uint32_t cmd_id,

    const WifiChannelInfo& channel_hint,

    uint32_t max_duration_seconds,

    const RttResponder& info) {

  legacy_hal::wifi_channel_info legacy_channel_info;

  if (!hidl_struct_util::convertHidlWifiChannelInfoToLegacy(

          channel_hint, &legacy_channel_info)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_rtt_responder legacy_responder;

  if (!hidl_struct_util::convertHidlRttResponderToLegacy(info,

                                                         &legacy_responder)) {

    return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);

  }

  legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->enableRttResponder(

      cmd_id, legacy_channel_info, max_duration_seconds, legacy_responder);

  return createWifiStatusFromLegacyError(legacy_status);

}



WifiStatus WifiRttController::disableResponderInternal(uint32_t /* cmd_id */) {

  // TODO implement

  return createWifiStatus(WifiStatusCode::SUCCESS);

WifiStatus WifiRttController::disableResponderInternal(uint32_t cmd_id) {

  legacy_hal::wifi_error legacy_status =

      legacy_hal_.lock()->disableRttResponder(cmd_id);

  return createWifiStatusFromLegacyError(legacy_status);

}

}  // namespace implementation

}  // namespace V1_0

wifi/1.0/default/wifi_rtt_controller.h

+3 −2
Original line number Diff line number Diff line
@@ -40,6 +40,7 @@ class WifiRttController : public IWifiRttController { 
  // Refer to |WifiChip::invalidate()|.

  void invalidate();

  bool isValid();

  std::vector<sp<IWifiRttControllerEventCallback>> getEventCallbacks();



  // HIDL methods exposed.

  Return<void> getBoundIface(getBoundIface_cb hidl_status_cb) override;
@@ -62,7 +63,7 @@ class WifiRttController : public IWifiRttController { 
  Return<void> getResponderInfo(getResponderInfo_cb hidl_status_cb) override;

  Return<void> enableResponder(uint32_t cmd_id,

                               const WifiChannelInfo& channel_hint,

                               uint32_t maxDurationSeconds,

                               uint32_t max_duration_seconds,

                               const RttResponder& info,

                               enableResponder_cb hidl_status_cb) override;

  Return<void> disableResponder(uint32_t cmd_id,
@@ -83,7 +84,7 @@ class WifiRttController : public IWifiRttController { 
  std::pair<WifiStatus, RttResponder> getResponderInfoInternal();

  WifiStatus enableResponderInternal(uint32_t cmd_id,

                                     const WifiChannelInfo& channel_hint,

                                     uint32_t maxDurationSeconds,

                                     uint32_t max_duration_seconds,

                                     const RttResponder& info);

  WifiStatus disableResponderInternal(uint32_t cmd_id);