spore/examples/wifiscan/main.cpp

#include <Arduino.h>
#include <functional>
#include "Globals.h"
#include "NodeContext.h"
#include "NetworkManager.h"
#include "ClusterManager.h"
#include "ApiServer.h"
#include "TaskManager.h"

using namespace std;

class WiFiScannerService {
public:
    WiFiScannerService(NodeContext& ctx, TaskManager& taskMgr, NetworkManager& networkMgr)
        : ctx(ctx), taskManager(taskMgr), network(networkMgr) {
        registerTasks();
    }

    void registerApi(ApiServer& api) {
        api.addEndpoint("/api/wifi/scan", HTTP_POST, [this](AsyncWebServerRequest* request) {
            if (network.isWiFiScanning()) {
                JsonDocument resp;
                resp["success"] = false;
                resp["message"] = "WiFi scan already in progress";
                String json;
                serializeJson(resp, json);
                request->send(409, "application/json", json);
                return;
            }
            
            network.startWiFiScan();
            
            JsonDocument resp;
            resp["success"] = true;
            resp["message"] = "WiFi scan started";
            String json;
            serializeJson(resp, json);
            request->send(200, "application/json", json);
        });

        api.addEndpoint("/api/wifi/status", HTTP_GET, [this](AsyncWebServerRequest* request) {
            JsonDocument doc;
            doc["scanning"] = network.isWiFiScanning();
            doc["networks_found"] = ctx.wifiAccessPoints->size();
            
            JsonArray networks = doc["networks"].to<JsonArray>();
            for (const auto& ap : *ctx.wifiAccessPoints) {
                JsonObject network = networks.add<JsonObject>();
                network["ssid"] = ap.ssid;
                network["rssi"] = ap.rssi;
                network["channel"] = ap.channel;
                network["encryption"] = ap.encryption;
                network["hidden"] = ap.isHidden;
            }
            
            String json;
            serializeJson(doc, json);
            request->send(200, "application/json", json);
        });
    }

private:
    void registerTasks() {
        // Register task to start WiFi scan every minute (60000ms)
        taskManager.registerTask("wifi_scan_periodic", 60000, [this]() {
            if (!network.isWiFiScanning()) {
                Serial.println("[WiFiScannerService] Starting periodic WiFi scan...");
                ctx.fire("wifi/scan/start", nullptr);
                network.startWiFiScan();
            } else {
                Serial.println("[WiFiScannerService] Skipping scan - already in progress");
            }
        });
    }

    NodeContext& ctx;
    TaskManager& taskManager;
    NetworkManager& network;
};

NodeContext ctx({
	{"app", "wifiscan"},
	{"role", "demo"}
});
NetworkManager network(ctx);
TaskManager taskManager(ctx);
ClusterManager cluster(ctx, taskManager);
ApiServer apiServer(ctx, taskManager, ctx.config.api_server_port);
WiFiScannerService wifiScanner(ctx, taskManager, network);

// WiFi scan start callback
void onWiFiScanStart(void* data) {
    Serial.println("[WiFi] Scan started...");
}

// WiFi scan complete callback
void onWiFiScanComplete(void* data) {
    Serial.println("\n=== WiFi Scan Results ===");
    
    std::vector<WiFiAccessPoint>* accessPoints = static_cast<std::vector<WiFiAccessPoint>*>(data);
    
    if (accessPoints->empty()) {
        Serial.println("No networks found");
        return;
    }
    
    Serial.printf("Found %d networks:\n", accessPoints->size());
    Serial.println("SSID\t\t\tRSSI\tChannel\tEncryption");
    Serial.println("----------------------------------------");
    
    for (const auto& ap : *accessPoints) {
        String encryptionStr = "Unknown";
        switch (ap.encryption) {
            case ENC_TYPE_NONE:
                encryptionStr = "Open";
                break;
            case ENC_TYPE_WEP:
                encryptionStr = "WEP";
                break;
            case ENC_TYPE_TKIP:
                encryptionStr = "WPA";
                break;
            case ENC_TYPE_CCMP:
                encryptionStr = "WPA2";
                break;
            case ENC_TYPE_AUTO:
                encryptionStr = "Auto";
                break;
        }
        
        Serial.printf("%-20s\t%d\t%d\t%s\n", 
                     ap.ssid.c_str(), ap.rssi, ap.channel, encryptionStr.c_str());
    }
    Serial.println("========================\n");
}

// WiFi scan error callback
void onWiFiScanError(void* data) {
    Serial.println("[WiFi] Scan failed - error occurred");
}

// WiFi scan timeout callback
void onWiFiScanTimeout(void* data) {
    Serial.println("[WiFi] Scan failed - timeout");
}

void setup() {
    Serial.begin(115200);
    Serial.println("\n=== WiFi Scanner Example ===");

	// Initialize task manager first
	taskManager.initialize();
	ctx.taskManager = &taskManager;

	// Initialize network tasks
	network.initTasks();

	// Setup WiFi
	network.setupWiFi();
	
	// Start the API server
	apiServer.begin();
	wifiScanner.registerApi(apiServer);
	
	// Register WiFi scan event callbacks
	ctx.on("wifi/scan/start", onWiFiScanStart);
	ctx.on("wifi/scan/complete", onWiFiScanComplete);
	ctx.on("wifi/scan/error", onWiFiScanError);
	ctx.on("wifi/scan/timeout", onWiFiScanTimeout);
	
	// Start an initial WiFi scan
	Serial.println("Starting initial WiFi scan...");
	ctx.fire("wifi/scan/start", nullptr);
	network.startWiFiScan();
	
	// Print initial task status
	taskManager.printTaskStatus();
}

void loop() {
	taskManager.execute();
	yield();
}