479 make wifi connect asynchronous

aether/access_points/wifi_access_point.cpp

@@ -27,19 +27,24 @@
 #  include "aether/channels/wifi_channel.h"
 #  include "aether/access_points/filter_endpoints.h"
 
+#  include "aether/tele/tele.h"
+
 namespace ae {
 
-WifiConnectAction::WifiConnectAction(AeContext const& ae_context,
-                                     WifiDriver& driver, WiFiAp wifi_ap,
-                                     WiFiPowerSaveParam psp,
-                                     WiFiBaseStation& base_station)
+WifiConnectAction::WifiConnectAction(
+    AeContext const& ae_context, WifiAccessPoint& access_point,
+    WifiDriver& driver, WiFiAp wifi_ap, std::optional<WiFiPowerSaveParam> psp,
+    std::optional<WiFiBaseStation> base_station)
     : ae_context_{ae_context},
+      access_point_{&access_point},
       driver_{&driver},
       wifi_ap_{std::move(wifi_ap)},
       psp_{std::move(psp)},
-      base_station_{base_station},
+      base_station_{std::move(base_station)},
       scheduler_sub_{
-          ae_context_.scheduler().Task([this]() { EnsureConnected(); })} {}
+          ae_context_.scheduler().Task([this]() { EnsureConnected(); })} {
+  AE_TELED_DEBUG("WifiConnectAction created");
+}
 
 WifiConnectAction::ConnectionEvent::Subscriber
 WifiConnectAction::connection_event() {
@@ -48,10 +53,37 @@ WifiConnectAction::connection_event() {
 
 void WifiConnectAction::EnsureConnected() {
   auto connected_to = driver_->connected_to();
-  if (connected_to.ssid != wifi_ap_.creds.ssid) {
-    driver_->Connect(wifi_ap_, psp_, base_station_);
+  AE_TELED_DEBUG("Driver connected to {}", connected_to.value_or("NOT CONNECTED"));
+  // if already connected
+  if (connected_to && (*connected_to == wifi_ap_.creds.ssid)) {
+    SetConnected(true);
+    return;
   }
-  SetConnected(true);
+  Connect();
+}
+
+void WifiConnectAction::Connect() {
+  connect_sub_ = driver_->connect_res_event().Subscribe(
+      [&](Result<WiFiBaseStation, int>&& res) {
+        connect_sub_.Reset();
+        if (res) {
+          AE_TELED_INFO("Wifi connected");
+          // save base station to access point
+          access_point_->SetWifiBaseStation(std::move(res).value());
+          SetConnected(true);
+        } else {
+          // retry without base station
+          if (base_station_) {
+            base_station_.reset();
+            scheduler_sub_ = ae_context_.scheduler().Task([&]() { Connect(); });
+            return;
+          }
+          AE_TELED_ERROR("Wifi did not connected with error {}", res.error());
+          SetConnected(false);
+        }
+      });
+
+  driver_->Connect(wifi_ap_, psp_, base_station_);
 }
 
 void WifiConnectAction::SetConnected(bool is_connected) {
@@ -65,7 +97,7 @@ WifiAccessPoint::WifiAccessPoint(ObjProp prop, ObjPtr<Aether> aether,
                                  ObjPtr<WifiAdapter> adapter,
                                  ObjPtr<IPoller> poller,
                                  ObjPtr<DnsResolver> resolver, WiFiAp wifi_ap,
-                                 WiFiPowerSaveParam psp)
+                                 std::optional<WiFiPowerSaveParam> psp)
     : AccessPoint{prop},
       aether_{std::move(aether)},
       adapter_{std::move(adapter)},
@@ -105,8 +137,8 @@ WifiConnectAction& WifiAccessPoint::Connect() {
         [](auto const& a) { return &a->driver(); });
     assert(driver.has_value());
 
-    connect_action_.emplace(*aether_.Load().as<Aether>(), **driver, wifi_ap_,
-                            psp_, base_station_);
+    connect_action_.emplace(*aether_.Load().as<Aether>(), *this, **driver,
+                            wifi_ap_, psp_, base_station_);
   }
   return *connect_action_;
 }
@@ -116,9 +148,13 @@ bool WifiAccessPoint::IsConnected() {
       .WithLoaded([this](auto const& a) {
         auto& driver = a->driver();
         auto connected_to = driver.connected_to();
-        return connected_to.ssid == wifi_ap_.creds.ssid;
+        return connected_to && (*connected_to == wifi_ap_.creds.ssid);
       })
       .value_or(false);
 }
+
+void WifiAccessPoint::SetWifiBaseStation(WiFiBaseStation&& wifi_base_station) {
+  base_station_.emplace(std::move(wifi_base_station));
+}
 }  // namespace ae
 #endif

aether/access_points/wifi_access_point.h

@@ -35,28 +35,33 @@ class Aether;
 class WifiAdapter;
 class IPoller;
 class DnsResolver;
+class WifiAccessPoint;
 
 class WifiConnectAction final : public Action {
  public:
   using ConnectionEvent = Event<void(bool)>;
 
-  WifiConnectAction(AeContext const& ae_context, WifiDriver& driver,
-                    WiFiAp wifi_ap, WiFiPowerSaveParam psp,
-                    WiFiBaseStation& base_station);
+  WifiConnectAction(AeContext const& ae_context, WifiAccessPoint& access_point,
+                    WifiDriver& driver, WiFiAp wifi_ap,
+                    std::optional<WiFiPowerSaveParam> psp,
+                    std::optional<WiFiBaseStation> base_station);
 
   ConnectionEvent::Subscriber connection_event();
 
  private:
   void EnsureConnected();
+  void Connect();
   void SetConnected(bool is_connected);
 
   AeContext ae_context_;
+  WifiAccessPoint* access_point_;
   WifiDriver* driver_;
   WiFiAp wifi_ap_;
-  WiFiPowerSaveParam psp_;
-  WiFiBaseStation& base_station_;
+  std::optional<WiFiPowerSaveParam> psp_;
+  std::optional<WiFiBaseStation> base_station_;
   ConnectionEvent connection_event_;
   TaskSubscription scheduler_sub_;
+  Subscription connect_sub_;
 };
 
 class WifiAccessPoint final : public AccessPoint {
@@ -67,7 +72,7 @@ class WifiAccessPoint final : public AccessPoint {
   WifiAccessPoint(ObjProp prop, ObjPtr<Aether> aether,
                   ObjPtr<WifiAdapter> adapter, ObjPtr<IPoller> poller,
                   ObjPtr<DnsResolver> resolver, WiFiAp wifi_ap,
-                  WiFiPowerSaveParam psp);
+                  std::optional<WiFiPowerSaveParam> psp);
 
   AE_OBJECT_REFLECT(AE_MMBRS(aether_, adapter_, poller_, resolver_, wifi_ap_,
                              base_station_))
@@ -82,14 +87,16 @@ class WifiAccessPoint final : public AccessPoint {
 
   bool IsConnected();
 
+  void SetWifiBaseStation(WiFiBaseStation&& wifi_base_station);
+
  private:
   ObjPtr<Aether> aether_;
   Obj::ptr adapter_;
   ObjPtr<IPoller> poller_;
   ObjPtr<DnsResolver> resolver_;
   WiFiAp wifi_ap_{};
-  WiFiPowerSaveParam psp_{};
-  WiFiBaseStation base_station_{};
+  std::optional<WiFiPowerSaveParam> psp_;
+  std::optional<WiFiBaseStation> base_station_;
   std::optional<WifiConnectAction> connect_action_;
 };
 }  // namespace ae

aether/adapters/wifi_adapter.cpp

@@ -56,7 +56,7 @@ std::vector<AccessPoint::ptr> WifiAdapter::access_points() {
 
 WifiDriver& WifiAdapter::driver() {
   if (!wifi_driver_) {
-    wifi_driver_ = WifiDriverFactory::CreateWifiDriver();
+    wifi_driver_ = WifiDriverFactory::CreateWifiDriver(*aether_);
   }
   return *wifi_driver_;
 }

aether/channels/wifi_channel.cpp

@@ -38,10 +38,10 @@ namespace wifi_channel_internal {
 ex::sender auto WifiConnect(Ptr<WifiAccessPoint> const& access_point) {
   return ex::create<ex::set_value_t(), ex::set_error_t(int)>(
       [ap{PtrView<WifiAccessPoint>{access_point}},
-       connect_sub{Subscription{}}](auto& ctx) mutable noexcept {
+       connect_sub_ = Subscription{}](auto& ctx) mutable noexcept {
         auto access_point = ap.Lock();
         assert(access_point && "Wifi access point is not loaded");
-        connect_sub = access_point->Connect().connection_event().Subscribe(
+        connect_sub_ = access_point->Connect().connection_event().Subscribe(
             [&](bool is_connected) mutable noexcept {
               if (is_connected) {
                 ex::set_value(std::move(ctx.receiver));