diff --git a/main/apps/app_setup/app_setup.cpp b/main/apps/app_setup/app_setup.cpp
index 28c98af5..133f28ae 100644
--- a/main/apps/app_setup/app_setup.cpp
+++ b/main/apps/app_setup/app_setup.cpp
@@ -55,6 +55,11 @@ void AppSetup::onOpen()
                      _destroy_menu = true;
                      _worker       = std::make_unique<ButtonWorker>();
                  }},
+                {"Wi-Fi",
+                 [&]() {
+                     _destroy_menu = true;
+                     _worker       = std::make_unique<WifiWorker>();
+                 }},
             },
         },
         {
diff --git a/main/apps/app_setup/workers/device.cpp b/main/apps/app_setup/workers/device.cpp
index 0a7a9119..0ada1a5b 100644
--- a/main/apps/app_setup/workers/device.cpp
+++ b/main/apps/app_setup/workers/device.cpp
@@ -9,6 +9,7 @@
 #include <hal/hal.h>
 #include <cstdint>
 #include <cstdio>
+#include <string>
 #include <vector>
 
 using namespace smooth_ui_toolkit::lvgl_cpp;
@@ -228,6 +229,160 @@ class ButtonWorker::ButtonConfigView {
     bool _save_requested = false;
 };
 
+class WifiWorker::WifiConfigView {
+public:
+    explicit WifiConfigView(const Hal::WifiStatus& initialStatus)
+    {
+        _panel = std::make_unique<Container>(lv_screen_active());
+        _panel->align(LV_ALIGN_CENTER, 0, 0);
+        _panel->setSize(466, 466);
+        _panel->setRadius(0);
+        _panel->setBorderWidth(0);
+        _panel->setPaddingAll(0);
+        _panel->setBgColor(lv_color_hex(0x000000));
+        _panel->setBgOpa(LV_OPA_COVER);
+        _panel->removeFlag(LV_OBJ_FLAG_SCROLLABLE);
+
+        _title_label = std::make_unique<Label>(_panel->get());
+        _title_label->setText("Wi-Fi");
+        _title_label->setTextFont(&MontserratSemiBold26);
+        _title_label->setTextColor(lv_color_hex(0xFFFFFF));
+        _title_label->align(LV_ALIGN_TOP_MID, 0, 52);
+
+        _row = std::make_unique<Container>(_panel->get());
+        _row->setSize(374, 119);
+        _row->align(LV_ALIGN_TOP_MID, 0, 100);
+        _row->setBgColor(lv_color_hex(0x4C4C4C));
+        _row->setBorderWidth(0);
+        _row->setShadowWidth(0);
+        _row->setRadius(60);
+        _row->setPaddingAll(0);
+        _row->setBgOpa(LV_OPA_TRANSP);
+
+        _switch_label = std::make_unique<Label>(_row->get());
+        _switch_label->setText("Wi-Fi");
+        _switch_label->setTextFont(&lv_font_montserrat_24);
+        _switch_label->setTextColor(lv_color_hex(0xFFFFFF));
+        _switch_label->align(LV_ALIGN_LEFT_MID, 36, 0);
+
+        _switch_widget = std::make_unique<Switch>(_row->get());
+        _switch_widget->setSize(80, 44);
+        _switch_widget->align(LV_ALIGN_RIGHT_MID, -36, 0);
+        _switch_widget->setValue(initialStatus.enabled);
+        _switch_widget->setBgColor(lv_color_hex(0x3A3A3A), LV_PART_MAIN);
+        _switch_widget->setBgOpa(LV_OPA_COVER, LV_PART_MAIN);
+        _switch_widget->setBorderWidth(0, LV_PART_MAIN);
+        _switch_widget->setRadius(LV_RADIUS_CIRCLE, LV_PART_MAIN);
+        lv_obj_set_style_bg_color(_switch_widget->get(), lv_color_hex(0xFFFFFF), LV_PART_KNOB);
+        lv_obj_set_style_bg_opa(_switch_widget->get(), LV_OPA_COVER, LV_PART_KNOB);
+        lv_obj_set_style_border_width(_switch_widget->get(), 0, LV_PART_KNOB);
+        lv_obj_set_style_radius(_switch_widget->get(), LV_RADIUS_CIRCLE, LV_PART_KNOB);
+        _switch_widget->setBgColor(lv_color_hex(0x53BD65), LV_PART_INDICATOR | LV_STATE_CHECKED);
+        _switch_widget->setBgOpa(LV_OPA_COVER, LV_PART_INDICATOR | LV_STATE_CHECKED);
+        _switch_widget->setBorderWidth(0, LV_PART_INDICATOR | LV_STATE_CHECKED);
+        _switch_widget->onValueChanged().connect([this](bool enabled) {
+            if (_syncing_switch) {
+                return;
+            }
+            _pending_enabled = enabled;
+            _has_pending     = true;
+        });
+
+        _status_label = std::make_unique<Label>(_panel->get());
+        _status_label->setTextFont(&lv_font_montserrat_22);
+        _status_label->setTextColor(lv_color_hex(0xD0D0D0));
+        _status_label->setWidth(360);
+        _status_label->setTextAlign(LV_TEXT_ALIGN_CENTER);
+        _status_label->setLongMode(LV_LABEL_LONG_MODE_WRAP);
+        _status_label->align(LV_ALIGN_CENTER, 0, 30);
+
+        _ok_button = std::make_unique<Button>(_panel->get());
+        _ok_button->align(LV_ALIGN_CENTER, 0, 175);
+        _ok_button->setSize(374, 130);
+        _ok_button->setRadius(77);
+        _ok_button->setBorderWidth(0);
+        _ok_button->setShadowWidth(0);
+        _ok_button->setBgColor(lv_color_hex(0x4AD78C));
+        _ok_button->label().setText("OK");
+        _ok_button->label().setTextFont(&lv_font_montserrat_28);
+        _ok_button->label().setTextColor(lv_color_hex(0x0F5831));
+        _ok_button->label().align(LV_ALIGN_CENTER, 0, 0);
+        _ok_button->onClick().connect([this]() { _done_requested = true; });
+
+        updateStatus(initialStatus);
+    }
+
+    bool consumeEnabledChange(bool& enabled)
+    {
+        if (!_has_pending) {
+            return false;
+        }
+        enabled      = _pending_enabled;
+        _has_pending = false;
+        return true;
+    }
+
+    bool consumeDoneRequested()
+    {
+        bool requested  = _done_requested;
+        _done_requested = false;
+        return requested;
+    }
+
+    void updateStatus(const Hal::WifiStatus& status)
+    {
+        if (_switch_widget) {
+            _syncing_switch = true;
+            _switch_widget->setValue(status.enabled);
+            _syncing_switch = false;
+        }
+
+        if (!_status_label) {
+            return;
+        }
+
+        _status_label->setText(buildStatusText(status));
+    }
+
+private:
+    std::string buildStatusText(const Hal::WifiStatus& status) const
+    {
+        switch (status.mode) {
+        case Hal::WifiMode::Off:
+            return "Off";
+        case Hal::WifiMode::Connecting:
+            if (!status.ssid.empty()) {
+                return "Connecting\n" + status.ssid;
+            }
+            return status.message.empty() ? "Connecting" : status.message;
+        case Hal::WifiMode::Connected:
+            if (!status.ipAddress.empty()) {
+                return "Connected\n" + status.ssid + "\n" + status.ipAddress;
+            }
+            return "Connected\n" + status.ssid;
+        case Hal::WifiMode::ConfigAp:
+            return "Setup AP\n" + status.apSsid + "\n192.168.4.1";
+        case Hal::WifiMode::BadgeAp:
+            return "Badge AP active";
+        case Hal::WifiMode::Error:
+            return status.message.empty() ? "Wi-Fi error" : status.message;
+        }
+        return status.message;
+    }
+
+    std::unique_ptr<Container> _panel;
+    std::unique_ptr<Label> _title_label;
+    std::unique_ptr<Container> _row;
+    std::unique_ptr<Label> _switch_label;
+    std::unique_ptr<Switch> _switch_widget;
+    std::unique_ptr<Label> _status_label;
+    std::unique_ptr<Button> _ok_button;
+    bool _syncing_switch = false;
+    bool _pending_enabled = false;
+    bool _has_pending = false;
+    bool _done_requested = false;
+};
+
 }  // namespace setup_workers
 
 BrightnessWorker::BrightnessWorker()
@@ -305,3 +460,33 @@ void ButtonWorker::update()
 ButtonWorker::~ButtonWorker()
 {
 }
+
+WifiWorker::WifiWorker()
+{
+    mclog::tagInfo(_tag, "start wifi worker");
+
+    _last_status = GetHAL().getWifiStatus();
+    _view        = std::make_unique<WifiConfigView>(_last_status);
+}
+
+void WifiWorker::update()
+{
+    if (_view) {
+        bool enabled = false;
+        if (_view->consumeEnabledChange(enabled)) {
+            GetHAL().setWifiEnabled(enabled, true);
+        }
+
+        const auto status = GetHAL().getWifiStatus();
+        _view->updateStatus(status);
+        _last_status = status;
+
+        if (_view->consumeDoneRequested()) {
+            _is_done = true;
+        }
+    }
+}
+
+WifiWorker::~WifiWorker()
+{
+}
diff --git a/main/apps/app_setup/workers/workers.h b/main/apps/app_setup/workers/workers.h
index 0de6fe1b..7fa0b06a 100644
--- a/main/apps/app_setup/workers/workers.h
+++ b/main/apps/app_setup/workers/workers.h
@@ -85,6 +85,23 @@ class ButtonWorker : public WorkerBase {
     Hal::ButtonConfig _applied_config;
 };
 
+/**
+ * @brief
+ *
+ */
+class WifiWorker : public WorkerBase {
+public:
+    WifiWorker();
+    ~WifiWorker();
+    void update() override;
+
+private:
+    class WifiConfigView;
+
+    std::unique_ptr<WifiConfigView> _view;
+    Hal::WifiStatus _last_status;
+};
+
 /**
  * @brief
  *
diff --git a/main/apps/common/status_bar/status_bar.cpp b/main/apps/common/status_bar/status_bar.cpp
index 2aa2de69..fb9f9c92 100644
--- a/main/apps/common/status_bar/status_bar.cpp
+++ b/main/apps/common/status_bar/status_bar.cpp
@@ -92,12 +92,57 @@ class StatuBarGesture {
 
 namespace status_bar_view {
 
+constexpr int _module_y_ofs            = 8;
+constexpr int _wifi_icon_x_ofs         = -51;
+constexpr int _battery_icon_x_ofs      = -12;
+constexpr int _battery_level_x_ofs     = 39;
+constexpr int _battery_level_width     = 44;
+
 class Widget {
 public:
     virtual ~Widget()     = default;
     virtual void update() = 0;
 };
 
+class WifiIndicator : public Widget {
+public:
+    WifiIndicator(lv_obj_t* parent, uint32_t colorPrimary)
+    {
+        _icon = std::make_unique<Label>(parent);
+        _icon->setText(LV_SYMBOL_WIFI);
+        _icon->setTextFont(&lv_font_montserrat_16);
+        _icon->setTextColor(lv_color_hex(colorPrimary));
+        _icon->align(LV_ALIGN_CENTER, _wifi_icon_x_ofs, _module_y_ofs);
+
+        update();
+    }
+
+    void update() override
+    {
+        const auto status = GetHAL().getWifiStatus();
+
+        switch (status.mode) {
+        case Hal::WifiMode::Connected:
+            _icon->setHidden(false);
+            _icon->setOpa(LV_OPA_COVER);
+            break;
+        case Hal::WifiMode::Connecting:
+        case Hal::WifiMode::ConfigAp:
+        case Hal::WifiMode::BadgeAp:
+            _icon->setHidden(false);
+            _icon->setOpa(LV_OPA_50);
+            break;
+        case Hal::WifiMode::Off:
+        case Hal::WifiMode::Error:
+            _icon->setHidden(true);
+            break;
+        }
+    }
+
+private:
+    std::unique_ptr<Label> _icon;
+};
+
 class BatteryIcon {
 public:
     BatteryIcon(lv_obj_t* parent, uint32_t colorSecondary, uint32_t colorPrimary)
@@ -169,14 +214,16 @@ class Battery : public Widget {
 public:
     Battery(lv_obj_t* parent, uint32_t colorSecondary, uint32_t colorPrimary)
     {
+        _battery_icon = std::make_unique<BatteryIcon>(parent, colorSecondary, colorPrimary);
+        _battery_icon->align(LV_ALIGN_CENTER, _battery_icon_x_ofs, _module_y_ofs);
+
         _label_level = std::make_unique<Label>(parent);
         _label_level->setText("");
         _label_level->setTextColor(lv_color_hex(colorPrimary));
         _label_level->setTextFont(&lv_font_montserrat_16);
-        _label_level->align(LV_ALIGN_RIGHT_MID, -78, 8);
-
-        _battery_icon = std::make_unique<BatteryIcon>(parent, colorSecondary, colorPrimary);
-        _battery_icon->align(LV_ALIGN_RIGHT_MID, -43, 8);
+        _label_level->setWidth(_battery_level_width);
+        _label_level->setTextAlign(LV_TEXT_ALIGN_LEFT);
+        _label_level->align(LV_ALIGN_CENTER, _battery_level_x_ofs, _module_y_ofs);
 
         update();
     }
@@ -209,6 +256,7 @@ class StatusBarView {
         _panel->removeFlag(LV_OBJ_FLAG_SCROLLABLE);
         _panel->onClick().connect([this]() { hide(); });
 
+        _widgets.push_back(std::make_unique<WifiIndicator>(_panel->get(), colorPrimary));
         _widgets.push_back(std::make_unique<Battery>(_panel->get(), colorSecondary, colorPrimary));
 
         _panel->setPos(0, _pos_y_hide);
diff --git a/main/hal/hal.cpp b/main/hal/hal.cpp
index 4d205852..98b98231 100644
--- a/main/hal/hal.cpp
+++ b/main/hal/hal.cpp
@@ -44,6 +44,7 @@ void Hal::init()
     rtc_init();
     button_init();
     fs_init();
+    wifi_init();
 }
 
 /* -------------------------------------------------------------------------- */
@@ -67,6 +68,7 @@ std::uint32_t Hal::millis()
 
 void Hal::feedTheDog()
 {
+    wifi_tick();
     vTaskDelay(1);
 }
 
diff --git a/main/hal/hal.h b/main/hal/hal.h
index 4096365c..0f430351 100644
--- a/main/hal/hal.h
+++ b/main/hal/hal.h
@@ -251,6 +251,33 @@ class Hal {
     void setButtonConfig(ButtonConfig config, bool saveToSettings = false);
     const ButtonConfig& getButtonConfig(bool loadFromSettings = false);
 
+    /* ---------------------------------- Wi-Fi --------------------------------- */
+    enum class WifiMode {
+        Off,
+        Connecting,
+        Connected,
+        ConfigAp,
+        BadgeAp,
+        Error,
+    };
+
+    struct WifiStatus {
+        bool enabled    = false;
+        WifiMode mode   = WifiMode::Off;
+        bool connected  = false;
+        bool configMode = false;
+        bool badgeMode  = false;
+        std::string ssid;
+        std::string ipAddress;
+        std::string apSsid;
+        std::string apUrl;
+        std::string message;
+    };
+
+    void setWifiEnabled(bool enabled, bool saveToSettings = true);
+    bool isWifiEnabled(bool loadFromSettings = false);
+    WifiStatus getWifiStatus();
+
     /* ---------------------------------- Badge --------------------------------- */
     bool loadBadgeImage(lv_obj_t* image);
     bool loadNextBadgeImage(lv_obj_t* image);
@@ -285,6 +312,10 @@ class Hal {
     void rtc_init();
     void button_init();
     void fs_init();
+    void wifi_init();
+    void wifi_tick();
+    void wifi_enter_badge_ap();
+    void wifi_exit_badge_ap();
 };
 
 Hal& GetHAL();
diff --git a/main/hal/hal_badge.cpp b/main/hal/hal_badge.cpp
index 106d595f..84e152fc 100644
--- a/main/hal/hal_badge.cpp
+++ b/main/hal/hal_badge.cpp
@@ -498,6 +498,7 @@ void Hal::startBadgeEditModeViaAp(std::function<void(std::string_view)> onLog)
         return;
     }
 
+    wifi_enter_badge_ap();
     badge::config_ap::run(onLog, {
                                      .onUpload    = save_badge_upload,
                                      .onGetState  = make_badge_state,
@@ -505,4 +506,5 @@ void Hal::startBadgeEditModeViaAp(std::function<void(std::string_view)> onLog)
                                      .onSetActive = set_active_badge_slot,
                                      .onDelete    = delete_badge_slot,
                                  });
+    wifi_exit_badge_ap();
 }
diff --git a/main/hal/hal_network.cpp b/main/hal/hal_network.cpp
new file mode 100644
index 00000000..e5ce2cb7
--- /dev/null
+++ b/main/hal/hal_network.cpp
@@ -0,0 +1,437 @@
+/*
+ * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
+ *
+ * SPDX-License-Identifier: MIT
+ */
+#include "hal.h"
+#include "utils/settings/settings.h"
+
+#include <esp_log.h>
+#include <esp_timer.h>
+#include <mooncake_log.h>
+#include <ssid_manager.h>
+#include <wifi_manager.h>
+
+#include <mutex>
+#include <string>
+
+namespace {
+
+constexpr const char* _tag                     = "HAL-WiFi";
+constexpr const char* _settings_namespace      = "system";
+constexpr const char* _wifi_enabled_key        = "wifi_enabled";
+constexpr const char* _wifi_ap_ssid_prefix     = "M5StopWatch";
+constexpr const char* _wifi_config_language    = "en-US";
+constexpr uint32_t _station_connect_timeout_ms = 30000;
+
+uint32_t millis()
+{
+    return static_cast<uint32_t>(esp_timer_get_time() / 1000);
+}
+
+bool deadline_expired(uint32_t now, uint32_t deadline)
+{
+    return deadline != 0 && static_cast<int32_t>(now - deadline) >= 0;
+}
+
+class NetworkController {
+public:
+    void init()
+    {
+        const bool enabled = load_enabled_from_settings();
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            _status.enabled = enabled;
+            _wifi_enabled   = enabled;
+        }
+
+        if (enabled) {
+            start_station_or_config_ap("Wi-Fi enabled");
+        } else {
+            set_off_status("Wi-Fi off");
+        }
+    }
+
+    void tick()
+    {
+        bool should_fallback_to_ap = false;
+        bool should_restart_sta    = false;
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            const uint32_t now = millis();
+            should_fallback_to_ap =
+                _wifi_enabled && !_badge_active && _status.mode == Hal::WifiMode::Connecting &&
+                !_status.connected && deadline_expired(now, _station_deadline_ms);
+            should_restart_sta = _restart_station_requested && _wifi_enabled && !_badge_active;
+            if (should_restart_sta) {
+                _restart_station_requested = false;
+            }
+        }
+
+        if (should_fallback_to_ap) {
+            mclog::tagWarn(_tag, "station connect timeout, entering config AP");
+            start_config_ap("Connection timed out");
+            return;
+        }
+
+        if (should_restart_sta) {
+            start_station_or_config_ap("Configuration saved");
+        }
+    }
+
+    void set_enabled(bool enabled, bool save_to_settings)
+    {
+        if (save_to_settings) {
+            Settings settings(_settings_namespace, true);
+            settings.SetBool(_wifi_enabled_key, enabled);
+        }
+
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            _wifi_enabled              = enabled;
+            _status.enabled            = enabled;
+            _restart_station_requested = false;
+        }
+
+        if (enabled) {
+            start_station_or_config_ap("Wi-Fi enabled");
+        } else {
+            stop_wifi_owner();
+            set_off_status("Wi-Fi off");
+        }
+    }
+
+    bool is_enabled(bool load_from_settings)
+    {
+        if (load_from_settings) {
+            return load_enabled_from_settings();
+        }
+
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        return _wifi_enabled;
+    }
+
+    Hal::WifiStatus status()
+    {
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        if (_initialized && !_badge_active) {
+            auto& wifi = WifiManager::GetInstance();
+            if (_status.mode == Hal::WifiMode::Connected || _status.mode == Hal::WifiMode::Connecting) {
+                _status.connected = wifi.IsConnected();
+                _status.ssid      = wifi.GetSsid();
+                _status.ipAddress = wifi.GetIpAddress();
+                if (_status.connected) {
+                    _status.mode    = Hal::WifiMode::Connected;
+                    _status.message = "Connected";
+                }
+            } else if (_status.mode == Hal::WifiMode::ConfigAp) {
+                _status.configMode = wifi.IsConfigMode();
+                _status.apSsid     = wifi.GetApSsid();
+                _status.apUrl      = wifi.GetApWebUrl();
+            }
+        }
+        return _status;
+    }
+
+    void enter_badge_ap()
+    {
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            _badge_active              = true;
+            _restart_station_requested = false;
+        }
+
+        ensure_initialized();
+        stop_wifi_owner();
+
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        _station_deadline_ms = 0;
+        _status.mode         = Hal::WifiMode::BadgeAp;
+        _status.badgeMode    = true;
+        _status.connected    = false;
+        _status.configMode   = false;
+        _status.ssid.clear();
+        _status.ipAddress.clear();
+        _status.apSsid.clear();
+        _status.apUrl        = "http://192.168.4.1";
+        _status.message      = "Badge edit AP";
+    }
+
+    void exit_badge_ap()
+    {
+        bool should_resume_wifi = false;
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            _badge_active       = false;
+            _status.badgeMode   = false;
+            should_resume_wifi  = _wifi_enabled;
+        }
+
+        if (should_resume_wifi) {
+            start_station_or_config_ap("Resuming Wi-Fi");
+        } else {
+            set_off_status("Wi-Fi off");
+        }
+    }
+
+private:
+    bool load_enabled_from_settings()
+    {
+        Settings settings(_settings_namespace, false);
+        return settings.GetBool(_wifi_enabled_key, false);
+    }
+
+    bool has_saved_credentials()
+    {
+        return !SsidManager::GetInstance().GetSsidList().empty();
+    }
+
+    bool ensure_initialized()
+    {
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            if (_initialized) {
+                return true;
+            }
+        }
+
+        WifiManagerConfig config;
+        config.ssid_prefix                       = _wifi_ap_ssid_prefix;
+        config.language                          = _wifi_config_language;
+        config.station_scan_min_interval_seconds = 5;
+        config.station_scan_max_interval_seconds = 30;
+
+        auto& wifi = WifiManager::GetInstance();
+        wifi.SetEventCallback([](WifiEvent event, const std::string& data) {
+            controller().handle_event(event, data);
+        });
+
+        if (!wifi.Initialize(config)) {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            _status.mode    = Hal::WifiMode::Error;
+            _status.message = "Wi-Fi initialization failed";
+            return false;
+        }
+
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        _initialized = true;
+        return true;
+    }
+
+    void start_station_or_config_ap(const std::string& message)
+    {
+        if (!ensure_initialized()) {
+            return;
+        }
+
+        if (!has_saved_credentials()) {
+            start_config_ap("No saved Wi-Fi");
+            return;
+        }
+
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            if (_badge_active || !_wifi_enabled) {
+                return;
+            }
+        }
+
+        auto& wifi = WifiManager::GetInstance();
+        if (wifi.IsConfigMode()) {
+            wifi.StopConfigAp();
+        }
+        wifi.StartStation();
+
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        _station_deadline_ms = millis() + _station_connect_timeout_ms;
+        _status.enabled      = true;
+        _status.mode         = Hal::WifiMode::Connecting;
+        _status.connected    = false;
+        _status.configMode   = false;
+        _status.badgeMode    = false;
+        _status.ssid.clear();
+        _status.ipAddress.clear();
+        _status.apSsid.clear();
+        _status.apUrl.clear();
+        _status.message = message.empty() ? "Connecting" : message;
+    }
+
+    void start_config_ap(const std::string& reason)
+    {
+        if (!ensure_initialized()) {
+            return;
+        }
+
+        {
+            std::lock_guard<std::recursive_mutex> lock(_mutex);
+            if (_badge_active || !_wifi_enabled) {
+                return;
+            }
+        }
+
+        auto& wifi = WifiManager::GetInstance();
+        wifi.StopStation();
+        wifi.StartConfigAp();
+
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        _station_deadline_ms = 0;
+        _status.enabled      = true;
+        _status.mode         = Hal::WifiMode::ConfigAp;
+        _status.connected    = false;
+        _status.configMode   = true;
+        _status.badgeMode    = false;
+        _status.ssid.clear();
+        _status.ipAddress.clear();
+        _status.apSsid  = wifi.GetApSsid();
+        _status.apUrl   = wifi.GetApWebUrl();
+        _status.message = reason.empty() ? "Setup AP" : reason;
+    }
+
+    void stop_wifi_owner()
+    {
+        if (!_initialized) {
+            return;
+        }
+
+        auto& wifi = WifiManager::GetInstance();
+        wifi.StopStation();
+        wifi.StopConfigAp();
+    }
+
+    void set_off_status(const std::string& message)
+    {
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        _station_deadline_ms = 0;
+        _status.enabled      = _wifi_enabled;
+        _status.mode         = Hal::WifiMode::Off;
+        _status.connected    = false;
+        _status.configMode   = false;
+        _status.badgeMode    = false;
+        _status.ssid.clear();
+        _status.ipAddress.clear();
+        _status.apSsid.clear();
+        _status.apUrl.clear();
+        _status.message = message;
+    }
+
+    void handle_event(WifiEvent event, const std::string& data)
+    {
+        std::lock_guard<std::recursive_mutex> lock(_mutex);
+        if (_badge_active) {
+            return;
+        }
+
+        switch (event) {
+        case WifiEvent::Scanning:
+            if (_wifi_enabled && _status.mode == Hal::WifiMode::Connecting) {
+                _status.message = "Scanning";
+            }
+            break;
+        case WifiEvent::Connecting:
+            if (_wifi_enabled) {
+                _status.mode      = Hal::WifiMode::Connecting;
+                _status.connected = false;
+                _status.ssid      = data;
+                _status.message   = "Connecting";
+            }
+            break;
+        case WifiEvent::Connected:
+            if (_wifi_enabled) {
+                auto& wifi              = WifiManager::GetInstance();
+                _station_deadline_ms    = 0;
+                _status.mode            = Hal::WifiMode::Connected;
+                _status.connected       = true;
+                _status.configMode      = false;
+                _status.ssid            = data.empty() ? wifi.GetSsid() : data;
+                _status.ipAddress       = wifi.GetIpAddress();
+                _status.message         = "Connected";
+            }
+            break;
+        case WifiEvent::Disconnected:
+            if (_wifi_enabled && _status.mode == Hal::WifiMode::Connected) {
+                _status.mode      = Hal::WifiMode::Connecting;
+                _status.connected = false;
+                _status.message   = "Disconnected";
+                _station_deadline_ms = millis() + _station_connect_timeout_ms;
+            }
+            break;
+        case WifiEvent::ConfigModeEnter:
+            if (_wifi_enabled) {
+                auto& wifi        = WifiManager::GetInstance();
+                _status.mode      = Hal::WifiMode::ConfigAp;
+                _status.connected = false;
+                _status.configMode = true;
+                _status.apSsid    = wifi.GetApSsid();
+                _status.apUrl     = wifi.GetApWebUrl();
+                _status.message   = "Setup AP";
+            }
+            break;
+        case WifiEvent::ConfigModeExit:
+            _status.configMode = false;
+            if (_wifi_enabled) {
+                _restart_station_requested = true;
+                _status.mode               = Hal::WifiMode::Connecting;
+                _status.message            = "Connecting";
+            }
+            break;
+        }
+    }
+
+    static NetworkController& controller()
+    {
+        static NetworkController instance;
+        return instance;
+    }
+
+    std::recursive_mutex _mutex;
+    bool _initialized                = false;
+    bool _wifi_enabled               = false;
+    bool _badge_active               = false;
+    bool _restart_station_requested  = false;
+    uint32_t _station_deadline_ms    = 0;
+    Hal::WifiStatus _status;
+
+    friend NetworkController& get_network_controller();
+};
+
+NetworkController& get_network_controller()
+{
+    return NetworkController::controller();
+}
+
+}  // namespace
+
+void Hal::wifi_init()
+{
+    get_network_controller().init();
+}
+
+void Hal::wifi_tick()
+{
+    get_network_controller().tick();
+}
+
+void Hal::setWifiEnabled(bool enabled, bool saveToSettings)
+{
+    get_network_controller().set_enabled(enabled, saveToSettings);
+}
+
+bool Hal::isWifiEnabled(bool loadFromSettings)
+{
+    return get_network_controller().is_enabled(loadFromSettings);
+}
+
+Hal::WifiStatus Hal::getWifiStatus()
+{
+    return get_network_controller().status();
+}
+
+void Hal::wifi_enter_badge_ap()
+{
+    get_network_controller().enter_badge_ap();
+}
+
+void Hal::wifi_exit_badge_ap()
+{
+    get_network_controller().exit_badge_ap();
+}
diff --git a/main/hal/utils/config_ap/config_ap.cpp b/main/hal/utils/config_ap/config_ap.cpp
index 327dadfc..6ac598c0 100644
--- a/main/hal/utils/config_ap/config_ap.cpp
+++ b/main/hal/utils/config_ap/config_ap.cpp
@@ -151,12 +151,10 @@ class Session {
 
     bool start_access_point()
     {
-        static esp_netif_t* ap_netif = nullptr;
-
-        if (ap_netif == nullptr) {
-            ap_netif = esp_netif_create_default_wifi_ap();
+        if (_ap_netif == nullptr) {
+            _ap_netif = esp_netif_create_default_wifi_ap();
         }
-        if (ap_netif == nullptr) {
+        if (_ap_netif == nullptr) {
             log("Failed to create AP network interface");
             return false;
         }
@@ -165,9 +163,9 @@ class Session {
         IP4_ADDR(&ip_info.ip, 192, 168, 4, 1);
         IP4_ADDR(&ip_info.gw, 192, 168, 4, 1);
         IP4_ADDR(&ip_info.netmask, 255, 255, 255, 0);
-        esp_netif_dhcps_stop(ap_netif);
-        esp_netif_set_ip_info(ap_netif, &ip_info);
-        esp_netif_dhcps_start(ap_netif);
+        esp_netif_dhcps_stop(_ap_netif);
+        esp_netif_set_ip_info(_ap_netif, &ip_info);
+        esp_netif_dhcps_start(_ap_netif);
 
         _dns_server = std::make_unique<DnsServer>();
         _dns_server->Start(ip_info.gw);
@@ -329,6 +327,11 @@ class Session {
             ESP_LOGW(_tag, "wifi stop failed: %s", esp_err_to_name(ret));
         }
 
+        if (_ap_netif != nullptr) {
+            esp_netif_destroy_default_wifi(_ap_netif);
+            _ap_netif = nullptr;
+        }
+
         if (_event_group != nullptr) {
             vEventGroupDelete(_event_group);
             _event_group = nullptr;
@@ -573,6 +576,7 @@ class Session {
     Callbacks _callbacks;
     std::string _ssid;
     std::unique_ptr<DnsServer> _dns_server;
+    esp_netif_t* _ap_netif = nullptr;
 };
 
 }  // namespace
@@ -582,4 +586,4 @@ bool run(const std::function<void(std::string_view)>& onLog, const Callbacks& ca
     return Session(onLog, callbacks).run();
 }
 
-}  // namespace badge::config_ap
\ No newline at end of file
+}  // namespace badge::config_ap