wifi_manager.h

Go to the documentation of this file.

 
#pragma once
 
#include "choose.h"
#include "form.h"
#include "network_list.h"
#include "pin_guard.h"
#include "prov_types.h"
#include "sync.h"
#include "wifi_plan.h"
#include "wifi_store.h"
#include <Arduino.h>
#include <DNSServer.h>
#include <WiFi.h>
#include <atomic>
#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>
 
class WifiManager
{
public:
    struct Status {
        const char* mode = "joining"; 
        char ssid[prov::kSsidMax + 1] = {};
        char ip[16] = {};
        bool pin_set = false;
        const char* failure = ""; 
    };
 
    enum class Result { Ok, BadInput, WrongPin, LockedOut };
 
    struct Outcome {
        Result result = Result::BadInput;
        uint32_t seconds_left = 0;
    };
    using AddOutcome = Outcome;
    using ForgetOutcome = Outcome;
 
    static constexpr size_t kScanCap = 24;
 
    WifiManager() = default;
    WifiManager(const WifiManager&) = delete;
    WifiManager& operator=(const WifiManager&) = delete;
 
    void begin();
 
    void maintain();
 
    Status status();
 
    const char* mode_name();
 
    bool setup_mode() const { return this->_hotspot_flag.load(); }
 
    prov::PlanState plan_state();
 
    size_t scan(prov::ScanResult* out, size_t cap);
 
    size_t saved(char (*ssids)[prov::kSsidMax + 1], size_t cap);
 
    AddOutcome add(const char* ssid, size_t ssid_len, const char* pass, size_t pass_len, const char* pin,
                   size_t pin_len, uint32_t now_ms);
 
    ForgetOutcome forget(const char* ssid, size_t ssid_len, const char* pin, size_t pin_len, uint32_t now_ms);
 
private:
    static void on_wifi_event(arduino_event_id_t event, arduino_event_info_t info);
 
    void process_events(uint32_t now);
    void poll_scan(uint32_t now);
    void collect_scan(int count, uint32_t now);
    void apply(prov::Action a, uint32_t now);
    void do_join(const prov::NetworkEntry& e);
    void start_hotspot();
    void stop_hotspot();
    void poll_serial();
    void factory_reset();
    const char* mode_name_locked() const;
    Status build_status_locked() const;
    void publish_status_locked();
 
    static WifiManager* _instance;
 
    SemaphoreHandle_t _mutex = nullptr;
    WifiStore _store;
    prov::NetworkList _list;
    prov::PinGuard _pin;
    prov::WifiPlan _plan;
    DNSServer _dns;
 
    // Event flags written by the arduino_events task.
    std::atomic<bool> _ev_got_ip{false};
    std::atomic<bool> _ev_disc{false};
    std::atomic<bool> _ev_leave{false}; // ASSOC_LEAVE: kept apart from _ev_reason, see on_wifi_event()
    std::atomic<uint8_t> _ev_reason{0};
    std::atomic<bool> _hotspot_flag{false};
 
    vsync::SpinGuarded<Status> _status_snap;
 
    // Shared with the HTTP layer (guarded by _mutex).
    prov::ScanResult _scan[kScanCap];
    size_t _scan_n = 0;
    bool _scan_valid = false;
    uint32_t _scan_time_ms = 0;
    bool _ui_scan_wanted = false;
    bool _added_pending = false;
    char _cur_ssid[prov::kSsidMax + 1] = {};
    char _cur_ip[16] = {};
    char _joining_ssid[prov::kSsidMax + 1] = {};
 
    // Used by the loop() side only.
    bool _scan_running = false;
    bool _plan_scan_pending = false;
    uint32_t _scan_start_ms = 0;
    prov::PlanState _prev_state = prov::PlanState::Boot;
    char _cand_ssid[prov::kMaxNetworks][prov::kSsidMax + 1] = {}; // list SSIDs at the last scan, by list index
    bool _hotspot_failed = false;
    uint32_t _hotspot_retry_ms = 0;
    bool _hotspot_running = false;
    bool _stop_pending = false;
    uint32_t _stop_at_ms = 0;
    char _hotspot_ssid[20] = {};
    char _line[24] = {};
    size_t _line_len = 0;
    bool _line_overflow = false;
};