wifi: Add Iface related method implementations in WifiChip

am: 35d958c43f

Change-Id: Id9009dd7b246940de52fbefeb251944d9106b8e5

wifi/1.0/default/wifi_chip.cpp

@@ -20,6 +20,32 @@
 
 #include "failure_reason_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> ifnames;
+  if (!ifname.empty()) {
+    hidl_string hidl_ifname;
+    hidl_ifname = ifname.c_str();
+    ifnames.emplace_back(hidl_ifname);
+  }
+  hidl_vec<hidl_string> hidl_ifnames;
+  hidl_ifnames.setToExternal(ifnames.data(), ifnames.size());
+  return hidl_ifnames;
+}
+
+template <typename Iface>
+void invalidateAndClear(sp<Iface>& iface) {
+  if (iface.get()) {
+    iface->invalidate();
+    iface.clear();
+  }
+}
+}  // namepsace
+
 namespace android {
 namespace hardware {
 namespace wifi {
@@ -28,11 +54,13 @@ namespace implementation {
 
 WifiChip::WifiChip(ChipId chip_id,
                    const std::weak_ptr<WifiLegacyHal> legacy_hal)
-    : chip_id_(chip_id), legacy_hal_(legacy_hal) {}
+    : chip_id_(chip_id), legacy_hal_(legacy_hal), is_valid_(true) {}
 
 void WifiChip::invalidate() {
+  invalidateAndRemoveAllIfaces();
   legacy_hal_.reset();
   callbacks_.clear();
+  is_valid_ = false;
 }
 
 Return<ChipId> WifiChip::getId() {
@@ -41,15 +69,15 @@ Return<ChipId> WifiChip::getId() {
 
 Return<void> WifiChip::registerEventCallback(
     const sp<IWifiChipEventCallback>& callback) {
-  if (!legacy_hal_.lock())
+  if (!is_valid_)
     return Void();
   // TODO(b/31632518): remove the callback when the client is destroyed
-  callbacks_.insert(callback);
+  callbacks_.emplace_back(callback);
   return Void();
 }
 
 Return<void> WifiChip::getAvailableModes(getAvailableModes_cb cb) {
-  if (!legacy_hal_.lock()) {
+  if (!is_valid_) {
     cb(hidl_vec<ChipMode>());
     return Void();
   } else {
@@ -59,21 +87,23 @@ Return<void> WifiChip::getAvailableModes(getAvailableModes_cb cb) {
 }
 
 Return<void> WifiChip::configureChip(uint32_t /*mode_id*/) {
-  if (!legacy_hal_.lock())
+  if (!is_valid_)
     return Void();
+
+  invalidateAndRemoveAllIfaces();
   // TODO add implementation
   return Void();
 }
 
 Return<uint32_t> WifiChip::getMode() {
-  if (!legacy_hal_.lock())
+  if (!is_valid_)
     return 0;
   // TODO add implementation
   return 0;
 }
 
 Return<void> WifiChip::requestChipDebugInfo() {
-  if (!legacy_hal_.lock())
+  if (!is_valid_)
     return Void();
 
   IWifiChipEventCallback::ChipDebugInfo result;
@@ -102,7 +132,7 @@ Return<void> WifiChip::requestChipDebugInfo() {
 }
 
 Return<void> WifiChip::requestDriverDebugDump() {
-  if (!legacy_hal_.lock())
+  if (!is_valid_)
     return Void();
 
   std::pair<wifi_error, std::vector<char>> ret =
@@ -124,7 +154,7 @@ Return<void> WifiChip::requestDriverDebugDump() {
 }
 
 Return<void> WifiChip::requestFirmwareDebugDump() {
-  if (!legacy_hal_.lock())
+  if (!is_valid_)
     return Void();
 
   std::pair<wifi_error, std::vector<char>> ret =
@@ -145,6 +175,184 @@ Return<void> WifiChip::requestFirmwareDebugDump() {
   return Void();
 }
 
+Return<void> WifiChip::createApIface(createApIface_cb cb) {
+  if (!is_valid_) {
+    cb(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_);
+  return Void();
+}
+
+Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb cb) {
+  if (!is_valid_) {
+    cb(hidl_vec<hidl_string>());
+    return Void();
+  }
+
+  std::string ifname;
+  if (ap_iface_.get()) {
+    ifname = legacy_hal_.lock()->getApIfaceName().c_str();
+  }
+  cb(createHidlVecOfIfaceNames(ifname));
+  return Void();
+}
+
+Return<void> WifiChip::getApIface(const hidl_string& ifname, getApIface_cb cb) {
+  if (!is_valid_) {
+    cb(nullptr);
+    return Void();
+  }
+
+  if (ap_iface_.get() &&
+      (ifname.c_str() == legacy_hal_.lock()->getApIfaceName())) {
+    cb(ap_iface_);
+  } else {
+    cb(nullptr);
+  }
+  return Void();
+}
+
+Return<void> WifiChip::createNanIface(createNanIface_cb cb) {
+  if (!is_valid_) {
+    cb(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_);
+  return Void();
+}
+
+Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb cb) {
+  if (!is_valid_) {
+    cb(hidl_vec<hidl_string>());
+    return Void();
+  }
+
+  std::string ifname;
+  if (nan_iface_.get()) {
+    ifname = legacy_hal_.lock()->getNanIfaceName().c_str();
+  }
+  cb(createHidlVecOfIfaceNames(ifname));
+  return Void();
+}
+
+Return<void> WifiChip::getNanIface(const hidl_string& ifname,
+                                   getNanIface_cb cb) {
+  if (!is_valid_) {
+    cb(nullptr);
+    return Void();
+  }
+
+  if (nan_iface_.get() &&
+      (ifname.c_str() == legacy_hal_.lock()->getNanIfaceName())) {
+    cb(nan_iface_);
+  } else {
+    cb(nullptr);
+  }
+  return Void();
+}
+
+Return<void> WifiChip::createP2pIface(createP2pIface_cb cb) {
+  if (!is_valid_) {
+    cb(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_);
+  return Void();
+}
+
+Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb cb) {
+  if (!is_valid_) {
+    cb(hidl_vec<hidl_string>());
+    return Void();
+  }
+
+  std::string ifname;
+  if (p2p_iface_.get()) {
+    ifname = legacy_hal_.lock()->getP2pIfaceName().c_str();
+  }
+  cb(createHidlVecOfIfaceNames(ifname));
+  return Void();
+}
+
+Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
+                                   getP2pIface_cb cb) {
+  if (!is_valid_) {
+    cb(nullptr);
+    return Void();
+  }
+
+  if (p2p_iface_.get() &&
+      (ifname.c_str() == legacy_hal_.lock()->getP2pIfaceName())) {
+    cb(p2p_iface_);
+  } else {
+    cb(nullptr);
+  }
+  return Void();
+}
+
+Return<void> WifiChip::createStaIface(createStaIface_cb cb) {
+  if (!is_valid_) {
+    cb(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_);
+  return Void();
+}
+
+Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb cb) {
+  if (!is_valid_) {
+    cb(hidl_vec<hidl_string>());
+    return Void();
+  }
+
+  std::string ifname;
+  if (sta_iface_.get()) {
+    ifname = legacy_hal_.lock()->getStaIfaceName().c_str();
+  }
+  cb(createHidlVecOfIfaceNames(ifname));
+  return Void();
+}
+
+Return<void> WifiChip::getStaIface(const hidl_string& ifname,
+                                   getStaIface_cb cb) {
+  if (!is_valid_) {
+    cb(nullptr);
+    return Void();
+  }
+
+  if (sta_iface_.get() &&
+      (ifname.c_str() == legacy_hal_.lock()->getStaIfaceName())) {
+    cb(sta_iface_);
+  } else {
+    cb(nullptr);
+  }
+  return Void();
+}
+
+void WifiChip::invalidateAndRemoveAllIfaces() {
+  invalidateAndClear(ap_iface_);
+  invalidateAndClear(nan_iface_);
+  invalidateAndClear(p2p_iface_);
+  invalidateAndClear(sta_iface_);
+}
+
 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace wifi

wifi/1.0/default/wifi_chip.h

@@ -17,12 +17,16 @@
 #ifndef WIFI_CHIP_H_
 #define WIFI_CHIP_H_
 
-#include <set>
+#include <map>
 
 #include <android-base/macros.h>
 #include <android/hardware/wifi/1.0/IWifiChip.h>
 
+#include "wifi_ap_iface.h"
 #include "wifi_legacy_hal.h"
+#include "wifi_nan_iface.h"
+#include "wifi_p2p_iface.h"
+#include "wifi_sta_iface.h"
 
 namespace android {
 namespace hardware {
@@ -63,11 +67,33 @@ class WifiChip : public IWifiChip {
   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;
+  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;
+  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;
+  Return<void> getStaIface(const hidl_string& ifname,
+                           getStaIface_cb cb) override;
 
  private:
+  void invalidateAndRemoveAllIfaces();
+
   ChipId chip_id_;
   std::weak_ptr<WifiLegacyHal> legacy_hal_;
-  std::set<sp<IWifiChipEventCallback>> callbacks_;
+  std::vector<sp<IWifiChipEventCallback>> callbacks_;
+  sp<WifiApIface> ap_iface_;
+  sp<WifiNanIface> nan_iface_;
+  sp<WifiP2pIface> p2p_iface_;
+  sp<WifiStaIface> sta_iface_;
+  bool is_valid_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiChip);
 };