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

Commit 5c05546f authored by Roshan Pius's avatar Roshan Pius
Browse files

wifi: Make methods deliver status synchronously (2/3) 

Make all the |IWifiChip| HIDL interface methods return a synchronous
status code. Change from using the event callbacks to the synchronous
callbacks for delivering status.

While there,
1. Use std::tie to retrive values out of the legacy HAL functions returning
a pair.
2. Use the std::vector to hidl_vec constructor for returning vector of
ifnames.

Bug: 32056230
Bug: 32061909
Test: Compiles
Change-Id: Iac27521be17cd9852df04ad7d412e09160a08d33
parent 503582ed

wifi/1.0/default/wifi_chip.cpp

+161 −120
Original line number Diff line number Diff line
@@ -18,23 +18,19 @@ 


#include <android-base/logging.h>



#include "failure_reason_util.h"

#include "wifi_status_util.h"



namespace {

using android::sp;

using android::hardware::hidl_vec;

using android::hardware::hidl_string;



hidl_vec<hidl_string> createHidlVecOfIfaceNames(const std::string& ifname) {

std::vector<hidl_string> createHidlVecOfIfaceNames(const std::string& ifname) {

  std::vector<hidl_string> ifnames;

  if (!ifname.empty()) {

    hidl_string hidl_ifname;

    hidl_ifname = ifname.c_str();

    ifnames.emplace_back(hidl_ifname);

    ifnames.emplace_back(ifname);

  }

  hidl_vec<hidl_string> hidl_ifnames;

  hidl_ifnames.setToExternal(ifnames.data(), ifnames.size());

  return hidl_ifnames;

  return ifnames;

}



template <typename Iface>
@@ -59,156 +55,181 @@ WifiChip::WifiChip(ChipId chip_id, 
void WifiChip::invalidate() {

  invalidateAndRemoveAllIfaces();

  legacy_hal_.reset();

  callbacks_.clear();

  event_callbacks_.clear();

  is_valid_ = false;

}



Return<ChipId> WifiChip::getId() {

  return chip_id_;

Return<void> WifiChip::getId(getId_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   UINT32_MAX);

    return Void();

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), chip_id_);

  return Void();

}



Return<void> WifiChip::registerEventCallback(

    const sp<IWifiChipEventCallback>& callback) {

  if (!is_valid_)

    const sp<IWifiChipEventCallback>& event_callback,

    registerEventCallback_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID));

    return Void();

  }

  // TODO(b/31632518): remove the callback when the client is destroyed

  callbacks_.emplace_back(callback);

  event_callbacks_.emplace_back(event_callback);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS));

  return Void();

}



Return<void> WifiChip::getAvailableModes(getAvailableModes_cb cb) {

Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(hidl_vec<ChipMode>());

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<ChipMode>());

    return Void();

  } else {

  }

  // TODO add implementation

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 hidl_vec<ChipMode>());

  return Void();

}

}



Return<void> WifiChip::configureChip(uint32_t /*mode_id*/) {

  if (!is_valid_)

Return<void> WifiChip::configureChip(uint32_t /*mode_id*/,

                                     configureChip_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID));

    return Void();

  }



  invalidateAndRemoveAllIfaces();

  // TODO add implementation

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS));

  return Void();

}



Return<uint32_t> WifiChip::getMode() {

  if (!is_valid_)

    return 0;

Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   UINT32_MAX);

    return Void();

  }

  // TODO add implementation

  return 0;

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), 0);

  return Void();

}



Return<void> WifiChip::requestChipDebugInfo() {

  if (!is_valid_)

Return<void> WifiChip::requestChipDebugInfo(

    requestChipDebugInfo_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   IWifiChip::ChipDebugInfo());

    return Void();

  }



  IWifiChipEventCallback::ChipDebugInfo result;

  IWifiChip::ChipDebugInfo result;



  std::pair<wifi_error, std::string> ret =

      legacy_hal_.lock()->getDriverVersion();

  if (ret.first != WIFI_SUCCESS) {

  wifi_error legacy_status;

  std::string driver_desc;

  std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();

  if (legacy_status != WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get driver version: "

               << LegacyErrorToString(ret.first);

    FailureReason reason = CreateFailureReasonLegacyError(

        ret.first, " failed to get driver version");

    for (const auto& callback : callbacks_) {

      callback->onChipDebugInfoFailure(reason);

    }

               << legacyErrorToString(legacy_status);

    WifiStatus status = createWifiStatusFromLegacyError(

        legacy_status, "failed to get driver version");

    hidl_status_cb(status, result);

    return Void();

  }

  result.driverDescription = ret.second.c_str();

  result.driverDescription = driver_desc.c_str();



  ret = legacy_hal_.lock()->getFirmwareVersion();

  if (ret.first != WIFI_SUCCESS) {

  std::string firmware_desc;

  std::tie(legacy_status, firmware_desc) =

      legacy_hal_.lock()->getFirmwareVersion();

  if (legacy_status != WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get firmware version: "

               << LegacyErrorToString(ret.first);

    FailureReason reason = CreateFailureReasonLegacyError(

        ret.first, " failed to get firmware version");

    for (const auto& callback : callbacks_) {

      callback->onChipDebugInfoFailure(reason);

    }

               << legacyErrorToString(legacy_status);

    WifiStatus status = createWifiStatusFromLegacyError(

        legacy_status, "failed to get firmware version");

    hidl_status_cb(status, result);

    return Void();

  }

  result.firmwareDescription = ret.second.c_str();

  result.firmwareDescription = firmware_desc.c_str();



  for (const auto& callback : callbacks_) {

    callback->onChipDebugInfoAvailable(result);

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), result);

  return Void();

}



Return<void> WifiChip::requestDriverDebugDump() {

  if (!is_valid_)

Return<void> WifiChip::requestDriverDebugDump(

    requestDriverDebugDump_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<uint8_t>());

    return Void();

  }



  std::pair<wifi_error, std::vector<char>> ret =

  wifi_error legacy_status;

  std::vector<char> driver_dump;

  std::tie(legacy_status, driver_dump) =

      legacy_hal_.lock()->requestDriverMemoryDump();

  if (ret.first != WIFI_SUCCESS) {

  if (legacy_status != WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get driver debug dump: "

               << LegacyErrorToString(ret.first);

    FailureReason reason = CreateFailureReasonLegacyError(ret.first, "");

    for (const auto& callback : callbacks_) {

      callback->onDriverDebugDumpFailure(reason);

    }

               << legacyErrorToString(legacy_status);

    hidl_status_cb(createWifiStatusFromLegacyError(legacy_status),

                   hidl_vec<uint8_t>());

    return Void();

  }



  auto& driver_dump = ret.second;

  hidl_vec<uint8_t> hidl_data;

  hidl_data.setToExternal(reinterpret_cast<uint8_t*>(driver_dump.data()),

                          driver_dump.size());

  for (const auto& callback : callbacks_) {

    callback->onDriverDebugDumpAvailable(hidl_data);

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), hidl_data);

  return Void();

}



Return<void> WifiChip::requestFirmwareDebugDump() {

  if (!is_valid_)

Return<void> WifiChip::requestFirmwareDebugDump(

    requestFirmwareDebugDump_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<uint8_t>());

    return Void();

  }



  std::pair<wifi_error, std::vector<char>> ret =

  wifi_error legacy_status;

  std::vector<char> firmware_dump;

  std::tie(legacy_status, firmware_dump) =

      legacy_hal_.lock()->requestFirmwareMemoryDump();

  if (ret.first != WIFI_SUCCESS) {

  if (legacy_status != WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get firmware debug dump: "

               << LegacyErrorToString(ret.first);

    FailureReason reason = CreateFailureReasonLegacyError(ret.first, "");

    for (const auto& callback : callbacks_) {

      callback->onFirmwareDebugDumpFailure(reason);

    }

               << legacyErrorToString(legacy_status);

    hidl_status_cb(createWifiStatusFromLegacyError(legacy_status),

                   hidl_vec<uint8_t>());

    return Void();

  }



  auto& firmware_dump = ret.second;

  hidl_vec<uint8_t> hidl_data;

  hidl_data.setToExternal(reinterpret_cast<uint8_t*>(firmware_dump.data()),

                          firmware_dump.size());

  for (const auto& callback : callbacks_) {

    callback->onFirmwareDebugDumpAvailable(hidl_data);

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), hidl_data);

  return Void();

}



Return<void> WifiChip::createApIface(createApIface_cb cb) {

Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getApIfaceName();

  ap_iface_ = new WifiApIface(ifname, legacy_hal_);

  cb(ap_iface_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_);

  return Void();

}



Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb cb) {

Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(hidl_vec<hidl_string>());

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  }
@@ -216,41 +237,47 @@ Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb cb) { 
  if (ap_iface_.get()) {

    ifname = legacy_hal_.lock()->getApIfaceName().c_str();

  }

  cb(createHidlVecOfIfaceNames(ifname));

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

}



Return<void> WifiChip::getApIface(const hidl_string& ifname, getApIface_cb cb) {

Return<void> WifiChip::getApIface(const hidl_string& ifname,

                                  getApIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (ap_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getApIfaceName())) {

    cb(ap_iface_);

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_);

  } else {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

  }

  return Void();

}



Return<void> WifiChip::createNanIface(createNanIface_cb cb) {

Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getNanIfaceName();

  nan_iface_ = new WifiNanIface(ifname, legacy_hal_);

  cb(nan_iface_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_);

  return Void();

}



Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb cb) {

Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(hidl_vec<hidl_string>());

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  }
@@ -258,42 +285,47 @@ Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb cb) { 
  if (nan_iface_.get()) {

    ifname = legacy_hal_.lock()->getNanIfaceName().c_str();

  }

  cb(createHidlVecOfIfaceNames(ifname));

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

}



Return<void> WifiChip::getNanIface(const hidl_string& ifname,

                                   getNanIface_cb cb) {

                                   getNanIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (nan_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getNanIfaceName())) {

    cb(nan_iface_);

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_);

  } else {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

  }

  return Void();

}



Return<void> WifiChip::createP2pIface(createP2pIface_cb cb) {

Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getP2pIfaceName();

  p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);

  cb(p2p_iface_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_);

  return Void();

}



Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb cb) {

Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(hidl_vec<hidl_string>());

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  }
@@ -301,42 +333,47 @@ Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb cb) { 
  if (p2p_iface_.get()) {

    ifname = legacy_hal_.lock()->getP2pIfaceName().c_str();

  }

  cb(createHidlVecOfIfaceNames(ifname));

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

}



Return<void> WifiChip::getP2pIface(const hidl_string& ifname,

                                   getP2pIface_cb cb) {

                                   getP2pIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (p2p_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getP2pIfaceName())) {

    cb(p2p_iface_);

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_);

  } else {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

  }

  return Void();

}



Return<void> WifiChip::createStaIface(createStaIface_cb cb) {

Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getStaIfaceName();

  sta_iface_ = new WifiStaIface(ifname, legacy_hal_);

  cb(sta_iface_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_);

  return Void();

}



Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb cb) {

Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(hidl_vec<hidl_string>());

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  }
@@ -344,36 +381,40 @@ Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb cb) { 
  if (sta_iface_.get()) {

    ifname = legacy_hal_.lock()->getStaIfaceName().c_str();

  }

  cb(createHidlVecOfIfaceNames(ifname));

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

}



Return<void> WifiChip::getStaIface(const hidl_string& ifname,

                                   getStaIface_cb cb) {

                                   getStaIface_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (sta_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getStaIfaceName())) {

    cb(sta_iface_);

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_);

  } else {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

  }

  return Void();

}



Return<void> WifiChip::createRttController(const sp<IWifiIface>& bound_iface,

                                           createRttController_cb cb) {

Return<void> WifiChip::createRttController(

    const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {

  if (!is_valid_) {

    cb(nullptr);

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  sp<WifiRttController> rtt = new WifiRttController(bound_iface, legacy_hal_);

  rtt_controllers_.emplace_back(rtt);

  cb(rtt);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), rtt);

  return Void();

}

wifi/1.0/default/wifi_chip.h

+30 −23
Original line number Diff line number Diff line
@@ -59,39 +59,46 @@ class WifiChip : public IWifiChip { 
  void invalidate();



  // HIDL methods exposed.

  Return<ChipId> getId() override;

  Return<void> getId(getId_cb hidl_status_cb) override;

  Return<void> registerEventCallback(

      const sp<IWifiChipEventCallback>& callback) override;

  Return<void> getAvailableModes(getAvailableModes_cb cb) override;

  Return<void> configureChip(uint32_t mode_id) override;

  Return<uint32_t> getMode() override;

  Return<void> requestChipDebugInfo() override;

  Return<void> requestDriverDebugDump() override;

  Return<void> requestFirmwareDebugDump() override;

  Return<void> createApIface(createApIface_cb cb) override;

  Return<void> getApIfaceNames(getApIfaceNames_cb cb) override;

  Return<void> getApIface(const hidl_string& ifname, getApIface_cb cb) override;

  Return<void> createNanIface(createNanIface_cb cb) override;

  Return<void> getNanIfaceNames(getNanIfaceNames_cb cb) override;

      const sp<IWifiChipEventCallback>& event_callback,

      registerEventCallback_cb hidl_status_cb) override;

  Return<void> getAvailableModes(getAvailableModes_cb hidl_status_cb) override;

  Return<void> configureChip(uint32_t mode_id,

                             configureChip_cb hidl_status_cb) override;

  Return<void> getMode(getMode_cb hidl_status_cb) override;

  Return<void> requestChipDebugInfo(

      requestChipDebugInfo_cb hidl_status_cb) override;

  Return<void> requestDriverDebugDump(

      requestDriverDebugDump_cb hidl_status_cb) override;

  Return<void> requestFirmwareDebugDump(

      requestFirmwareDebugDump_cb hidl_status_cb) override;

  Return<void> createApIface(createApIface_cb hidl_status_cb) override;

  Return<void> getApIfaceNames(getApIfaceNames_cb hidl_status_cb) override;

  Return<void> getApIface(const hidl_string& ifname,

                          getApIface_cb hidl_status_cb) override;

  Return<void> createNanIface(createNanIface_cb hidl_status_cb) override;

  Return<void> getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) override;

  Return<void> getNanIface(const hidl_string& ifname,

                           getNanIface_cb cb) override;

  Return<void> createP2pIface(createP2pIface_cb cb) override;

  Return<void> getP2pIfaceNames(getP2pIfaceNames_cb cb) override;

                           getNanIface_cb hidl_status_cb) override;

  Return<void> createP2pIface(createP2pIface_cb hidl_status_cb) override;

  Return<void> getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) override;

  Return<void> getP2pIface(const hidl_string& ifname,

                           getP2pIface_cb cb) override;

  Return<void> createStaIface(createStaIface_cb cb) override;

  Return<void> getStaIfaceNames(getStaIfaceNames_cb cb) override;

                           getP2pIface_cb hidl_status_cb) override;

  Return<void> createStaIface(createStaIface_cb hidl_status_cb) override;

  Return<void> getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) override;

  Return<void> getStaIface(const hidl_string& ifname,

                           getStaIface_cb cb) override;

  Return<void> createRttController(const sp<IWifiIface>& bound_iface,

                                   createRttController_cb cb) override;

                           getStaIface_cb hidl_status_cb) override;

  Return<void> createRttController(

      const sp<IWifiIface>& bound_iface,

      createRttController_cb hidl_status_cb) override;



 private:

  void invalidateAndRemoveAllIfaces();



  ChipId chip_id_;

  std::weak_ptr<WifiLegacyHal> legacy_hal_;

  std::vector<sp<IWifiChipEventCallback>> callbacks_;

  std::vector<sp<IWifiChipEventCallback>> event_callbacks_;

  sp<WifiApIface> ap_iface_;

  sp<WifiNanIface> nan_iface_;

  sp<WifiP2pIface> p2p_iface_;