wifi_api.cpp

#include <WiFi.h>
#include "wifi_api.h"

// Global variables for connection monitoring
static unsigned long lastConnectionCheck = 0;
static bool wifiEventHandlersSetup = false;

// WiFi event handlers
void onWiFiConnected(WiFiEvent_t event, WiFiEventInfo_t info) {
  Serial.println("WiFi Connected Event");
}

void onWiFiGotIP(WiFiEvent_t event, WiFiEventInfo_t info) {
  Serial.print("The IP Address is: ");
  Serial.println(WiFi.localIP());
}

void onWiFiDisconnected(WiFiEvent_t event, WiFiEventInfo_t info) {
  Serial.println("WiFi Disconnected Event - Reason: " + String(info.wifi_sta_disconnected.reason));
}

void setupWiFiEventHandlers() {
  if (!wifiEventHandlersSetup) {
    WiFi.onEvent(onWiFiConnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_CONNECTED);
    WiFi.onEvent(onWiFiGotIP, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_GOT_IP);
    WiFi.onEvent(onWiFiDisconnected, WiFiEvent_t::ARDUINO_EVENT_WIFI_STA_DISCONNECTED);
    wifiEventHandlersSetup = true;
    Serial.println("WiFi event handlers configured");
  }
}

bool connectToWiFi(const char* ssid, const char* password) {
  return connectToWiFiWithTimeout(ssid, password, WIFI_TIMEOUT_MS);
}

bool connectToWiFiWithTimeout(const char* ssid, const char* password, int timeoutMs) {
  Serial.println("Connecting to WiFi...");
  Serial.println("SSID: " + String(ssid));
  
  // Setup event handlers
  setupWiFiEventHandlers();
  
  // Disconnect if already connected
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("Disconnecting from current network...");
    WiFi.disconnect();
    delay(1000);
  }
  
  // Configure WiFi mode
  WiFi.mode(WIFI_STA);
  WiFi.setAutoReconnect(true);
  WiFi.persistent(true);
  
  // Start connection
  WiFi.begin(ssid, password);
  
  unsigned long startTime = millis();
  int attempts = 0;
  
  Serial.print("Connecting");
  
  while (WiFi.status() != WL_CONNECTED && (millis() - startTime) < timeoutMs) {
    delay(WIFI_RETRY_DELAY_MS);
    Serial.print(".");
    attempts++;
    
    // Show progress every 10 attempts
    if (attempts % 10 == 0) {
      Serial.printf(" [%d/%d]", attempts, timeoutMs / WIFI_RETRY_DELAY_MS);
    }
    
    // Check if we've exceeded max retries
    if (attempts >= MAX_WIFI_RETRIES) {
      Serial.println("\nMax retry attempts reached");
      break;
    }
  }
  
  Serial.println(); // New line after dots
  
  if (WiFi.status() == WL_CONNECTED) {
    printWiFiInfo();
    return true;
  } else {
    Serial.println("WiFi Connection Failed");
    Serial.println("Status Code: " + String(WiFi.status()));
    printWiFiStatusCode(WiFi.status());
    return false;
  }
}

void disconnectWiFi() {
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("Disconnecting from WiFi...");
    WiFi.disconnect();
    
    // Wait for disconnection
    int timeout = 5000; // 5 seconds
    while (WiFi.status() == WL_CONNECTED && timeout > 0) {
      delay(100);
      timeout -= 100;
    }
    
    if (WiFi.status() != WL_CONNECTED) {
      Serial.println("WiFi Disconnected");
    } else {
      Serial.println("WiFi Disconnection Timeout");
    }
  } else {
    Serial.println("WiFi already disconnected");
  }
}

WiFiStatus getWiFiStatus() {
  WiFiStatus status;
  
  status.connected = (WiFi.status() == WL_CONNECTED);
  
  if (status.connected) {
    status.ipAddress = WiFi.localIP().toString();
    status.signalStrength = WiFi.RSSI();
    status.macAddress = WiFi.macAddress();
    status.connectionTime = millis();
  }
  
  return status;
}

void printWiFiInfo() {
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("WiFi Connected Successfully!");
    Serial.println("Network Information:");
    Serial.println("  SSID: " + WiFi.SSID());
    Serial.println("  IP Address: " + WiFi.localIP().toString());
    Serial.println("  Gateway: " + WiFi.gatewayIP().toString());
    Serial.println("  DNS: " + WiFi.dnsIP().toString());
    Serial.println("  Subnet Mask: " + WiFi.subnetMask().toString());
    Serial.println("  MAC Address: " + WiFi.macAddress());
    Serial.println("  Signal Strength: " + String(WiFi.RSSI()) + " dBm");
    Serial.println("  Channel: " + String(WiFi.channel()));
    
    // Signal quality assessment
    int rssi = WiFi.RSSI();
    String quality;
    if (rssi >= -50) quality = "Excellent";
    else if (rssi >= -60) quality = "Good";
    else if (rssi >= -70) quality = "Fair";
    else quality = "Poor";
    
    Serial.println("  Signal Quality: " + quality);
  } else {
    Serial.println("WiFi Not Connected");
    printWiFiStatusCode(WiFi.status());
  }
}

void printWiFiStatusCode(wl_status_t status) {
  String statusText;
  switch (status) {
    case WL_IDLE_STATUS:
      statusText = "Idle";
      break;
    case WL_NO_SSID_AVAIL:
      statusText = "No SSID Available";
      break;
    case WL_SCAN_COMPLETED:
      statusText = "Scan Completed";
      break;
    case WL_CONNECTED:
      statusText = "Connected";
      break;
    case WL_CONNECT_FAILED:
      statusText = "Connection Failed";
      break;
    case WL_CONNECTION_LOST:
      statusText = "Connection Lost";
      break;
    case WL_DISCONNECTED:
      statusText = "Disconnected";
      break;
    default:
      statusText = "Unknown (" + String(status) + ")";
  }
  
  Serial.println("WiFi Status: " + statusText);
}

bool isWiFiConnected() {
  return (WiFi.status() == WL_CONNECTED);
}

void monitorWiFiConnection() {
  unsigned long currentTime = millis();
  
  // Check connection every 30 seconds
  if (currentTime - lastConnectionCheck > 30000) {
    lastConnectionCheck = currentTime;
    
    if (!isWiFiConnected()) {
      Serial.println("WiFi Connection Lost - Attempting Reconnection...");
      // WiFi.reconnect(); // This will use stored credentials
    } else {
      // Optional: Print periodic status
      int rssi = WiFi.RSSI();
      if (rssi < -80) {
        Serial.println("WiFi Signal Weak: " + String(rssi) + " dBm");
      }
    }
  }
}

bool waitForWiFiConnection(int timeoutMs) {
  unsigned long startTime = millis();
  
  while (!isWiFiConnected() && (millis() - startTime) < timeoutMs) {
    delay(100);
    
    // Print progress every 5 seconds
    if ((millis() - startTime) % 5000 == 0) {
      Serial.println("Waiting for WiFi connection... (" + String((millis() - startTime) / 1000) + "s)");
    }
  }
  
  return isWiFiConnected();
}