src/wifi_manager.cpp - master - ellersseer/MyCheat

src/wifi_manager.cpp
266 строк8 KB
Dmitry Zhiltsov
feat(logs): Добавить логи в WEB
20 фев 2026, 20:39
20 фев 2026, 20:39dae6bcf
#include "wifi_manager.h"
#include "config.h"
#include "log_buffer.h"
#include <WiFi.h>

// Global instance
WifiManager wifiManager;

// Static pointer for event callback
static WifiManager* wifiManagerInstance = nullptr;

bool WifiManager::begin() {
    logCapture.println("[WiFiManager] Initializing...");
    wifiManagerInstance = this;

    // Generate unique AP SSID based on chip ID
    generateAPSSID();

    // Register event handler
    WiFi.onEvent(onWiFiEvent);

    // Start in disconnected state
    WiFi.mode(WIFI_OFF);
    delay(100);

    currentMode = WifiMode::DISCONNECTED;
    logCapture.println("[WiFiManager] Initialized");
    return true;
}

void WifiManager::generateAPSSID() {
    uint32_t chipId = (uint32_t)(ESP.getEfuseMac() >> 24);  // Last 3 bytes of MAC
    snprintf(apSSID, sizeof(apSSID), "%s%06X", AP_SSID_PREFIX, chipId);
    logCapture.printf("[WiFiManager] Device ID: %06X\n", chipId);
}

bool WifiManager::connectToSaved() {
    WifiSettings settings;
    if (!settingsManager.loadWifiSettings(settings)) {
        logCapture.println("[WiFiManager] Failed to load WiFi settings");
        return false;
    }

    if (!settings.configured || strlen(settings.ssid) == 0) {
        logCapture.println("[WiFiManager] No saved WiFi configuration");
        return false;
    }

    logCapture.printf("[WiFiManager] Connecting to saved network: %s\n", settings.ssid);
    return connectTo(settings.ssid, settings.password, WIFI_CONNECT_TIMEOUT_MS);
}

bool WifiManager::connectTo(const char* ssid, const char* password, uint32_t timeoutMs) {
    if (ssid == nullptr || strlen(ssid) == 0) {
        logCapture.println("[WiFiManager] Invalid SSID");
        return false;
    }

    logCapture.printf("[WiFiManager] Connecting to '%s'...\n", ssid);
    setMode(WifiMode::CONNECTING);

    // Stop AP if running
    if (apStarted) {
        WiFi.softAPdisconnect(true);
        apStarted = false;
    }

    // Set station mode
    WiFi.mode(WIFI_STA);
    WiFi.setAutoReconnect(true);

    // Begin connection
    if (strlen(password) > 0) {
        WiFi.begin(ssid, password);
    } else {
        WiFi.begin(ssid);
    }

    // Wait for connection with timeout
    unsigned long startTime = millis();
    while (WiFi.status() != WL_CONNECTED && (millis() - startTime) < timeoutMs) {
        delay(500);
        logCapture.print(".");
    }
    logCapture.println();

    if (WiFi.status() == WL_CONNECTED) {
        setMode(WifiMode::CONNECTED_STA);
        logCapture.printf("[WiFiManager] Connected! IP: %s\n", WiFi.localIP().toString().c_str());
        return true;
    } else {
        logCapture.printf("[WiFiManager] Connection failed (status=%d)\n", WiFi.status());
        setMode(WifiMode::DISCONNECTED);
        return false;
    }
}

bool WifiManager::startAP() {
    logCapture.println("[WiFiManager] Starting Access Point...");

    // Configure AP with STA for WiFi scanning capability
    WiFi.mode(WIFI_AP_STA);
    delay(100);

    bool success;
    if (strlen(AP_PASSWORD) > 0) {
        success = WiFi.softAP(apSSID, AP_PASSWORD);
    } else {
        success = WiFi.softAP(apSSID);
    }

    if (success) {
        // Set static IP for AP
        IPAddress apIP(192, 168, 4, 1);
        IPAddress gateway(192, 168, 4, 1);
        IPAddress subnet(255, 255, 255, 0);
        WiFi.softAPConfig(apIP, gateway, subnet);

        apStarted = true;
        setMode(WifiMode::AP_MODE);
        logCapture.printf("[WiFiManager] AP started: SSID='%s', IP=%s\n",
                      apSSID, WiFi.softAPIP().toString().c_str());
        return true;
    } else {
        logCapture.println("[WiFiManager] Failed to start AP");
        return false;
    }
}

bool WifiManager::stopAP() {
    if (!apStarted) {
        return true;
    }

    logCapture.println("[WiFiManager] Stopping Access Point...");
    WiFi.softAPdisconnect(true);
    apStarted = false;

    if (currentMode == WifiMode::AP_MODE) {
        setMode(WifiMode::DISCONNECTED);
    }

    return true;
}

IPAddress WifiManager::getIP() const {
    if (currentMode == WifiMode::CONNECTED_STA) {
        return WiFi.localIP();
    } else if (currentMode == WifiMode::AP_MODE) {
        return WiFi.softAPIP();
    }
    return IPAddress(0, 0, 0, 0);
}

const char* WifiManager::getAPSSID() const {
    return apSSID;
}

String WifiManager::getConnectedSSID() const {
    if (currentMode == WifiMode::CONNECTED_STA) {
        return WiFi.SSID();
    }
    return "";
}

int32_t WifiManager::getRSSI() const {
    if (currentMode == WifiMode::CONNECTED_STA) {
        return WiFi.RSSI();
    }
    return 0;
}

int WifiManager::scanNetworks(WifiNetwork* results, int maxResults) {
    logCapture.println("[WiFiManager] Scanning for networks...");

    // Start scan (synchronous) - AP is already in AP_STA mode
    int numNetworks = WiFi.scanNetworks(false, false, false, 300);

    if (numNetworks < 0) {
        logCapture.printf("[WiFiManager] Scan failed with error: %d\n", numNetworks);
        return 0;
    }

    logCapture.printf("[WiFiManager] Found %d networks\n", numNetworks);

    int count = min(numNetworks, maxResults);
    for (int i = 0; i < count; i++) {
        strncpy(results[i].ssid, WiFi.SSID(i).c_str(), WIFI_SSID_MAX_LEN - 1);
        results[i].ssid[WIFI_SSID_MAX_LEN - 1] = '\0';
        results[i].rssi = WiFi.RSSI(i);
        results[i].encryptionType = WiFi.encryptionType(i);
        results[i].isOpen = (WiFi.encryptionType(i) == WIFI_AUTH_OPEN);
    }

    // Clean up scan results
    WiFi.scanDelete();

    return count;
}

void WifiManager::loop() {
    // Check for disconnection in STA mode
    if (currentMode == WifiMode::CONNECTED_STA && WiFi.status() != WL_CONNECTED) {
        logCapture.println("[WiFiManager] Lost WiFi connection");
        setMode(WifiMode::DISCONNECTED);
    }
}

const char* WifiManager::getModeString() const {
    switch (currentMode) {
        case WifiMode::DISCONNECTED: return "Disconnected";
        case WifiMode::CONNECTING: return "Connecting";
        case WifiMode::CONNECTED_STA: return "Connected (STA)";
        case WifiMode::AP_MODE: return "Access Point";
        default: return "Unknown";
    }
}

void WifiManager::setMode(WifiMode mode) {
    if (currentMode != mode) {
        logCapture.printf("[WiFiManager] Mode changed: %s -> %s\n",
                      getModeString(),
                      (mode == WifiMode::DISCONNECTED ? "Disconnected" :
                       mode == WifiMode::CONNECTING ? "Connecting" :
                       mode == WifiMode::CONNECTED_STA ? "Connected (STA)" :
                       mode == WifiMode::AP_MODE ? "Access Point" : "Unknown"));
        currentMode = mode;
    }
}

void WifiManager::onWiFiEvent(WiFiEvent_t event) {
    if (wifiManagerInstance == nullptr) return;

    switch (event) {
        case ARDUINO_EVENT_WIFI_STA_GOT_IP:
            logCapture.printf("[WiFiManager] Got IP: %s\n", WiFi.localIP().toString().c_str());
            wifiManagerInstance->setMode(WifiMode::CONNECTED_STA);
            break;

        case ARDUINO_EVENT_WIFI_STA_DISCONNECTED:
            if (wifiManagerInstance->currentMode == WifiMode::CONNECTED_STA) {
                logCapture.println("[WiFiManager] Disconnected from WiFi");
                wifiManagerInstance->setMode(WifiMode::DISCONNECTED);
            }
            break;

        case ARDUINO_EVENT_WIFI_AP_START:
            logCapture.println("[WiFiManager] AP Started");
            break;

        case ARDUINO_EVENT_WIFI_AP_STOP:
            logCapture.println("[WiFiManager] AP Stopped");
            break;

        case ARDUINO_EVENT_WIFI_AP_STACONNECTED:
            logCapture.println("[WiFiManager] Client connected to AP");
            break;

        case ARDUINO_EVENT_WIFI_AP_STADISCONNECTED:
            logCapture.println("[WiFiManager] Client disconnected from AP");
            break;

        default:
            break;
    }
}