wifi_client.hpp

#pragma once
 
#include <string>
#include <vector>
 
#include "libxr_def.hpp"
#include "libxr_rw.hpp"
 
namespace LibXR
{
 
class WifiClient
{
 public:
  enum class WifiError
  {
    NONE,                   
    ALREADY_ENABLED,        
    NOT_ENABLED,            
    CONNECTION_TIMEOUT,     
    AUTHENTICATION_FAILED,  
    DHCP_FAILED,            
    SSID_NOT_FOUND,         
    INVALID_CONFIG,         
    HARDWARE_FAILURE,       
    SCAN_FAILED,            
    UNKNOWN,                
  };
 
  enum class Security
  {
    OPEN,             
    WPA2_PSK,         
    WPA2_ENTERPRISE,  
    UNKNOWN,          
  };
 
  struct EnterpriseConfig
  {
    std::string identity;     
    std::string username;     
    std::string password;     
    std::string ca_cert;      
    std::string client_cert;  
    std::string client_key;   
  };
 
  struct StaticIPConfig
  {
    std::string ip;       
    std::string gateway;  
    std::string netmask;  
    std::string dns;      
  };
 
  struct Config
  {
    std::string ssid;                        
    std::string password;                    
    Security security = Security::WPA2_PSK;  
 
    EnterpriseConfig* enterprise_config =
        nullptr;  
 
    StaticIPConfig* static_ip_config =
        nullptr;  
 
    bool use_dhcp = true;  
  };
 
  struct ScanResult
  {
    std::string ssid;   
    int rssi;           
    Security security;  
  };
 
  using WifiCallback = LibXR::Callback<WifiError>;
 
  virtual ~WifiClient() = default;
 
  virtual WifiError Enable() = 0;
 
  virtual WifiError Disable() = 0;
 
  virtual WifiError Connect(const Config& config) = 0;
 
  virtual WifiError Disconnect() = 0;
 
  virtual bool IsConnected() const = 0;
 
  virtual const char* GetIPAddress() const = 0;
 
  virtual WifiError Scan(std::vector<ScanResult>& results) = 0;
 
  virtual int GetRSSI() const = 0;
};
 
}  // namespace LibXR