BaseWifi.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
 
#define HF_WIFI_ERR_LIST(X)                                                                        \
  /* Success codes */                                                                              \
  X(WIFI_SUCCESS, 0, "Success")                                                                    \
                                                                                                   \
  /* General errors */                                                                             \
  X(WIFI_ERR_FAILURE, 1, "General failure")                                                        \
  X(WIFI_ERR_INVALID_PARAM, 2, "Invalid parameter")                                                \
  X(WIFI_ERR_NOT_INITIALIZED, 3, "WiFi not initialized")                                           \
  X(WIFI_ERR_ALREADY_INITIALIZED, 4, "WiFi already initialized")                                   \
  X(WIFI_ERR_NOT_CONNECTED, 5, "WiFi not connected")                                               \
  X(WIFI_ERR_ALREADY_CONNECTED, 6, "WiFi already connected")                                       \
  X(WIFI_ERR_CONNECTION_FAILED, 7, "Connection failed")                                            \
  X(WIFI_ERR_DISCONNECTION_FAILED, 8, "Disconnection failed")                                      \
  X(WIFI_ERR_SCAN_FAILED, 9, "Network scan failed")                                                \
  X(WIFI_ERR_AP_START_FAILED, 10, "Access Point start failed")                                     \
  X(WIFI_ERR_AP_STOP_FAILED, 11, "Access Point stop failed")                                       \
  X(WIFI_ERR_TIMEOUT, 12, "Operation timeout")                                                     \
  X(WIFI_ERR_NO_MEMORY, 13, "Insufficient memory")                                                 \
  X(WIFI_ERR_INVALID_SSID, 14, "Invalid SSID")                                                     \
  X(WIFI_ERR_INVALID_PASSWORD, 15, "Invalid password")                                             \
  X(WIFI_ERR_WEAK_SIGNAL, 16, "Weak signal strength")                                              \
  X(WIFI_ERR_AUTHENTICATION_FAILED, 17, "Authentication failed")                                   \
  X(WIFI_ERR_ASSOCIATION_FAILED, 18, "Association failed")                                         \
  X(WIFI_ERR_HANDSHAKE_FAILED, 19, "4-way handshake failed")                                       \
  X(WIFI_ERR_INIT_FAILED, 20, "WiFi initialization failed")                                        \
  X(WIFI_ERR_CONFIG_INVALID, 21, "Invalid configuration")                                          \
  X(WIFI_ERR_ENTERPRISE_FAILED, 22, "Enterprise authentication failed")                            \
  X(WIFI_ERR_WPA3_NOT_SUPPORTED, 23, "WPA3 not supported")                                         \
  X(WIFI_ERR_MESH_FAILED, 24, "Mesh operation failed")                                             \
  X(WIFI_ERR_UNKNOWN, 25, "Unknown error")
 
#define X(name, value, desc) name = value,
enum class hf_wifi_err_t : hf_u8_t { HF_WIFI_ERR_LIST(X) };
#undef X
 
constexpr std::string_view HfWifiErrToString(hf_wifi_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case hf_wifi_err_t::NAME:                                                                        \
    return DESC;
    HF_WIFI_ERR_LIST(X)
#undef X
  default:
    return HfWifiErrToString(hf_wifi_err_t::WIFI_ERR_UNKNOWN);
  }
}
 
enum class hf_wifi_mode_t : hf_u8_t {
  HF_WIFI_MODE_STATION = 0,      
  HF_WIFI_MODE_ACCESS_POINT = 1, 
  HF_WIFI_MODE_STATION_AP = 2,   
  HF_WIFI_MODE_DISABLED = 3      
};
 
enum class hf_wifi_security_t : hf_u8_t {
  HF_WIFI_SECURITY_OPEN = 0,            
  HF_WIFI_SECURITY_WEP = 1,             
  HF_WIFI_SECURITY_WPA_PSK = 2,         
  HF_WIFI_SECURITY_WPA2_PSK = 3,        
  HF_WIFI_SECURITY_WPA_WPA2_PSK = 4,    
  HF_WIFI_SECURITY_WPA2_ENTERPRISE = 5, 
  HF_WIFI_SECURITY_WPA3_PSK = 6,        
  HF_WIFI_SECURITY_WPA2_WPA3_PSK = 7,   
  HF_WIFI_SECURITY_WPA3_ENTERPRISE = 8, 
  HF_WIFI_SECURITY_WAPI_PSK = 9         
};
 
enum class hf_wifi_state_t : hf_u8_t {
  HF_WIFI_STATE_DISCONNECTED = 0,  
  HF_WIFI_STATE_CONNECTING = 1,    
  HF_WIFI_STATE_CONNECTED = 2,     
  HF_WIFI_STATE_DISCONNECTING = 3, 
  HF_WIFI_STATE_RECONNECTING = 4,  
  HF_WIFI_STATE_AP_STARTED = 5,    
  HF_WIFI_STATE_AP_STOPPED = 6,    
  HF_WIFI_STATE_SCANNING = 7       
};
 
enum class hf_wifi_power_save_t : hf_u8_t {
  HF_WIFI_POWER_SAVE_NONE = 0,      
  HF_WIFI_POWER_SAVE_MIN_MODEM = 1, 
  HF_WIFI_POWER_SAVE_MAX_MODEM = 2  
};
 
enum class hf_wifi_event_t : hf_u8_t {
  HF_WIFI_EVENT_STA_START = 0,           
  HF_WIFI_EVENT_STA_STOP = 1,            
  HF_WIFI_EVENT_STA_CONNECTED = 2,       
  HF_WIFI_EVENT_STA_DISCONNECTED = 3,    
  HF_WIFI_EVENT_STA_AUTHMODE_CHANGE = 4, 
  HF_WIFI_EVENT_STA_GOT_IP = 5,          
  HF_WIFI_EVENT_STA_LOST_IP = 6,         
  HF_WIFI_EVENT_AP_START = 7,            
  HF_WIFI_EVENT_AP_STOP = 8,             
  HF_WIFI_EVENT_AP_STACONNECTED = 9,     
  HF_WIFI_EVENT_AP_STADISCONNECTED = 10, 
  HF_WIFI_EVENT_SCAN_DONE = 11           
};
 
struct hf_wifi_network_info_t {
  std::string ssid;            
  uint8_t bssid[6];            
  hf_wifi_security_t security; 
  int8_t rssi;                 
  uint8_t channel;             
  bool hidden;                 
};
 
struct hf_wifi_station_config_t {
  std::string ssid;                      
  std::string password;                  
  uint8_t bssid[6];                      
  uint8_t channel;                       
  bool bssid_set;                        
  uint32_t scan_method;                  
  bool sort_method;                      
  uint16_t threshold_rssi;               
  hf_wifi_security_t threshold_authmode; 
};
 
struct hf_wifi_ap_config_t {
  std::string ssid;            
  std::string password;        
  uint8_t ssid_len;            
  uint8_t channel;             
  hf_wifi_security_t authmode; 
  uint8_t ssid_hidden;         
  uint8_t max_connection;      
  uint16_t beacon_interval;    
};
 
struct hf_wifi_ip_info_t {
  uint32_t ip;      
  uint32_t netmask; 
  uint32_t gateway; 
};
 
using hf_wifi_event_callback_t = std::function<void(hf_wifi_event_t event, void* event_data)>;
 
using hf_wifi_scan_callback_t =
    std::function<void(const std::vector<hf_wifi_network_info_t>& networks)>;
 
class BaseWifi {
public:
  virtual ~BaseWifi() noexcept = default;
 
  // ========== Initialization and Configuration ==========
 
  virtual hf_wifi_err_t Initialize(hf_wifi_mode_t mode) noexcept = 0;
 
  virtual hf_wifi_err_t Deinitialize() noexcept = 0;
 
  virtual bool IsInitialized() const noexcept = 0;
 
  virtual hf_wifi_err_t SetMode(hf_wifi_mode_t mode) noexcept = 0;
 
  virtual hf_wifi_mode_t GetMode() const noexcept = 0;
 
  // ========== Station Mode Operations ==========
 
  virtual hf_wifi_err_t ConfigureStation(const hf_wifi_station_config_t& config) noexcept = 0;
 
  virtual hf_wifi_err_t Connect(uint32_t timeout_ms = 0) noexcept = 0;
 
  virtual hf_wifi_err_t Disconnect() noexcept = 0;
 
  virtual bool IsConnected() const noexcept = 0;
 
  virtual int8_t GetRssi() const noexcept = 0;
 
  virtual hf_wifi_err_t GetIpInfo(hf_wifi_ip_info_t& ip_info) const noexcept = 0;
 
  // ========== Access Point Mode Operations ==========
 
  virtual hf_wifi_err_t ConfigureAccessPoint(const hf_wifi_ap_config_t& config) noexcept = 0;
 
  virtual hf_wifi_err_t StartAccessPoint() noexcept = 0;
 
  virtual hf_wifi_err_t StopAccessPoint() noexcept = 0;
 
  virtual bool IsAccessPointActive() const noexcept = 0;
 
  virtual int GetConnectedStationCount() const noexcept = 0;
 
  // ========== Network Scanning ==========
 
  virtual hf_wifi_err_t StartScan(bool show_hidden = false, bool passive = false,
                                  uint32_t max_scan_time_ms = 0) noexcept = 0;
 
  virtual hf_wifi_err_t GetScanResults(std::vector<hf_wifi_network_info_t>& networks,
                                       uint16_t max_networks = 0) noexcept = 0;
 
  virtual bool IsScanning() const noexcept = 0;
 
  // ========== State and Status ==========
 
  virtual hf_wifi_state_t GetState() const noexcept = 0;
 
  virtual std::string GetConnectedSsid() const noexcept = 0;
 
  virtual hf_wifi_err_t GetConnectedBssid(uint8_t bssid[6]) const noexcept = 0;
 
  // ========== Power Management ==========
 
  virtual hf_wifi_err_t SetPowerSave(hf_wifi_power_save_t mode) noexcept = 0;
 
  virtual hf_wifi_power_save_t GetPowerSave() const noexcept = 0;
 
  // ========== Event Handling ==========
 
  virtual hf_wifi_err_t RegisterEventCallback(hf_wifi_event_callback_t callback) noexcept = 0;
 
  virtual hf_wifi_err_t UnregisterEventCallback() noexcept = 0;
 
  // ========== Utility Functions ==========
 
  virtual hf_wifi_err_t GetMacAddress(uint8_t mac[6], uint8_t interface = 0) const noexcept = 0;
 
  virtual hf_wifi_err_t SetMacAddress(const uint8_t mac[6], uint8_t interface = 0) noexcept = 0;
 
  virtual uint8_t GetChannel() const noexcept = 0;
 
  virtual hf_wifi_err_t SetChannel(uint8_t channel) noexcept = 0;
 
  static std::string_view GetErrorString(hf_wifi_err_t error);
 
protected:
  BaseWifi() = default;
 
  BaseWifi(const BaseWifi&) = delete;
 
  BaseWifi& operator=(const BaseWifi&) = delete;
};
 
inline std::string_view BaseWifi::GetErrorString(hf_wifi_err_t error) {
#define X(name, value, desc)                                                                       \
  case hf_wifi_err_t::name:                                                                        \
    return desc;
  switch (error) {
    HF_WIFI_ERR_LIST(X)
  default:
    return HfWifiErrToString(hf_wifi_err_t::WIFI_ERR_UNKNOWN);
  }
#undef X
}