wifi: Stub implementation of WifiRttController methods

am: 7913f5e49d Change-Id: I45a075986e47dd3ed6feb5735c1fc8e396bf3ad0
2026-02-01 21:37:44 +00:00 · 2016-11-17 00:57:03 +00:00
parent e65ad43046 7913f5e49d
commit ee5137a3d1
2 changed files with 272 additions and 0 deletions
--- a/wifi/1.0/default/wifi_rtt_controller.cpp
+++ b/wifi/1.0/default/wifi_rtt_controller.cpp
@@ -34,6 +34,7 @@ WifiRttController::WifiRttController(

 void WifiRttController::invalidate() {
  legacy_hal_.reset();
+  event_callbacks_.clear();
  is_valid_ = false;
 }

@@ -48,11 +49,226 @@ Return<void> WifiRttController::getBoundIface(getBoundIface_cb hidl_status_cb) {
                         hidl_status_cb);
 }

+Return<void> WifiRttController::registerEventCallback(
+    const sp<IWifiRttControllerEventCallback>& callback,
+    registerEventCallback_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::registerEventCallbackInternal,
+                         hidl_status_cb,
+                         callback);
+}
+
+Return<void> WifiRttController::rangeRequest(
+    uint32_t cmd_id,
+    const hidl_vec<RttConfig>& rtt_configs,
+    rangeRequest_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::rangeRequestInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         rtt_configs);
+}
+
+Return<void> WifiRttController::rangeCancel(
+    uint32_t cmd_id,
+    const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
+    rangeCancel_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::rangeCancelInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         addrs);
+}
+
+Return<void> WifiRttController::setChannelMap(uint32_t cmd_id,
+                                              const RttChannelMap& params,
+                                              uint32_t num_dw,
+                                              setChannelMap_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setChannelMapInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         params,
+                         num_dw);
+}
+
+Return<void> WifiRttController::clearChannelMap(
+    uint32_t cmd_id, clearChannelMap_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::clearChannelMapInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
+Return<void> WifiRttController::getCapabilities(
+    getCapabilities_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getCapabilitiesInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::setDebugCfg(RttDebugType type,
+                                            setDebugCfg_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setDebugCfgInternal,
+                         hidl_status_cb,
+                         type);
+}
+
+Return<void> WifiRttController::getDebugInfo(getDebugInfo_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getDebugInfoInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::setLci(uint32_t cmd_id,
+                                       const RttLciInformation& lci,
+                                       setLci_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setLciInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         lci);
+}
+
+Return<void> WifiRttController::setLcr(uint32_t cmd_id,
+                                       const RttLcrInformation& lcr,
+                                       setLcr_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::setLcrInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         lcr);
+}
+
+Return<void> WifiRttController::getResponderInfo(
+    getResponderInfo_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::getResponderInfoInternal,
+                         hidl_status_cb);
+}
+
+Return<void> WifiRttController::enableResponder(
+    uint32_t cmd_id,
+    const WifiChannelInfo& channel_hint,
+    uint32_t maxDurationSeconds,
+    const RttResponder& info,
+    enableResponder_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::enableResponderInternal,
+                         hidl_status_cb,
+                         cmd_id,
+                         channel_hint,
+                         maxDurationSeconds,
+                         info);
+}
+
+Return<void> WifiRttController::disableResponder(
+    uint32_t cmd_id, disableResponder_cb hidl_status_cb) {
+  return validateAndCall(this,
+                         WifiStatusCode::ERROR_WIFI_RTT_CONTROLLER_INVALID,
+                         &WifiRttController::disableResponderInternal,
+                         hidl_status_cb,
+                         cmd_id);
+}
+
 std::pair<WifiStatus, sp<IWifiIface>>
 WifiRttController::getBoundIfaceInternal() {
  return {createWifiStatus(WifiStatusCode::SUCCESS), bound_iface_};
 }

+WifiStatus WifiRttController::registerEventCallbackInternal(
+    const sp<IWifiRttControllerEventCallback>& callback) {
+  // TODO(b/31632518): remove the callback when the client is destroyed
+  event_callbacks_.emplace_back(callback);
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::rangeRequestInternal(
+    uint32_t /* cmd_id */, const std::vector<RttConfig>& /* rtt_configs */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::rangeCancelInternal(
+    uint32_t /* cmd_id */,
+    const std::vector<hidl_array<uint8_t, 6>>& /* addrs */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::setChannelMapInternal(
+    uint32_t /* cmd_id */,
+    const RttChannelMap& /* params */,
+    uint32_t /* num_dw */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::clearChannelMapInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, RttCapabilities>
+WifiRttController::getCapabilitiesInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiRttController::setDebugCfgInternal(RttDebugType /* type */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, RttDebugInfo> WifiRttController::getDebugInfoInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiRttController::setLciInternal(
+    uint32_t /* cmd_id */, const RttLciInformation& /* lci */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::setLcrInternal(
+    uint32_t /* cmd_id */, const RttLcrInformation& /* lcr */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+std::pair<WifiStatus, RttResponder>
+WifiRttController::getResponderInfoInternal() {
+  // TODO implement
+  return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
+}
+
+WifiStatus WifiRttController::enableResponderInternal(
+    uint32_t /* cmd_id */,
+    const WifiChannelInfo& /* channel_hint */,
+    uint32_t /* maxDurationSeconds */,
+    const RttResponder& /* info */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
+
+WifiStatus WifiRttController::disableResponderInternal(uint32_t /* cmd_id */) {
+  // TODO implement
+  return createWifiStatus(WifiStatusCode::SUCCESS);
+}
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi
--- a/wifi/1.0/default/wifi_rtt_controller.h
+++ b/wifi/1.0/default/wifi_rtt_controller.h
@@ -20,6 +20,7 @@
 #include <android-base/macros.h>
 #include <android/hardware/wifi/1.0/IWifiIface.h>
 #include <android/hardware/wifi/1.0/IWifiRttController.h>
+#include <android/hardware/wifi/1.0/IWifiRttControllerEventCallback.h>

 #include "wifi_legacy_hal.h"

@@ -42,13 +43,68 @@ class WifiRttController : public IWifiRttController {

  // HIDL methods exposed.
  Return<void> getBoundIface(getBoundIface_cb hidl_status_cb) override;
+  Return<void> registerEventCallback(
+      const sp<IWifiRttControllerEventCallback>& callback,
+      registerEventCallback_cb hidl_status_cb) override;
+  Return<void> rangeRequest(uint32_t cmd_id,
+                            const hidl_vec<RttConfig>& rtt_configs,
+                            rangeRequest_cb hidl_status_cb) override;
+  Return<void> rangeCancel(uint32_t cmd_id,
+                           const hidl_vec<hidl_array<uint8_t, 6>>& addrs,
+                           rangeCancel_cb hidl_status_cb) override;
+  Return<void> setChannelMap(uint32_t cmd_id,
+                             const RttChannelMap& params,
+                             uint32_t num_dw,
+                             setChannelMap_cb hidl_status_cb) override;
+  Return<void> clearChannelMap(uint32_t cmd_id,
+                               clearChannelMap_cb hidl_status_cb) override;
+  Return<void> getCapabilities(getCapabilities_cb hidl_status_cb) override;
+  Return<void> setDebugCfg(RttDebugType type,
+                           setDebugCfg_cb hidl_status_cb) override;
+  Return<void> getDebugInfo(getDebugInfo_cb hidl_status_cb) override;
+  Return<void> setLci(uint32_t cmd_id,
+                      const RttLciInformation& lci,
+                      setLci_cb hidl_status_cb) override;
+  Return<void> setLcr(uint32_t cmd_id,
+                      const RttLcrInformation& lcr,
+                      setLcr_cb hidl_status_cb) override;
+  Return<void> getResponderInfo(getResponderInfo_cb hidl_status_cb) override;
+  Return<void> enableResponder(uint32_t cmd_id,
+                               const WifiChannelInfo& channel_hint,
+                               uint32_t maxDurationSeconds,
+                               const RttResponder& info,
+                               enableResponder_cb hidl_status_cb) override;
+  Return<void> disableResponder(uint32_t cmd_id,
+                                disableResponder_cb hidl_status_cb) override;

 private:
  // Corresponding worker functions for the HIDL methods.
  std::pair<WifiStatus, sp<IWifiIface>> getBoundIfaceInternal();
+  WifiStatus registerEventCallbackInternal(
+      const sp<IWifiRttControllerEventCallback>& callback);
+  WifiStatus rangeRequestInternal(uint32_t cmd_id,
+                                  const std::vector<RttConfig>& rtt_configs);
+  WifiStatus rangeCancelInternal(
+      uint32_t cmd_id, const std::vector<hidl_array<uint8_t, 6>>& addrs);
+  WifiStatus setChannelMapInternal(uint32_t cmd_id,
+                                   const RttChannelMap& params,
+                                   uint32_t num_dw);
+  WifiStatus clearChannelMapInternal(uint32_t cmd_id);
+  std::pair<WifiStatus, RttCapabilities> getCapabilitiesInternal();
+  WifiStatus setDebugCfgInternal(RttDebugType type);
+  std::pair<WifiStatus, RttDebugInfo> getDebugInfoInternal();
+  WifiStatus setLciInternal(uint32_t cmd_id, const RttLciInformation& lci);
+  WifiStatus setLcrInternal(uint32_t cmd_id, const RttLcrInformation& lcr);
+  std::pair<WifiStatus, RttResponder> getResponderInfoInternal();
+  WifiStatus enableResponderInternal(uint32_t cmd_id,
+                                     const WifiChannelInfo& channel_hint,
+                                     uint32_t maxDurationSeconds,
+                                     const RttResponder& info);
+  WifiStatus disableResponderInternal(uint32_t cmd_id);

  sp<IWifiIface> bound_iface_;
  std::weak_ptr<WifiLegacyHal> legacy_hal_;
+  std::vector<sp<IWifiRttControllerEventCallback>> event_callbacks_;
  bool is_valid_;

  DISALLOW_COPY_AND_ASSIGN(WifiRttController);