.. _program_listing_file_components_Network_src_WiFi.cpp:

Program Listing for File WiFi.cpp
=================================

|exhale_lsh| :ref:`Return to documentation for file <file_components_Network_src_WiFi.cpp>` (``components/Network/src/WiFi.cpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   #include "WiFi.h"
   
   #include <cstdint>
   #include <cstring>
   
   #include <esp_log.h>
   #include <esp_wifi.h>
   
   namespace network {
   
   static const char* TAG = "WiFi";
   
   WiFiDefaultEventHandler::WiFiDefaultEventHandler()
   {
   }
   
   esp_err_t WiFiDefaultEventHandler::staStart()
   {
       ESP_LOGI(TAG, "STA Start");
   
       WiFi& wifi = WiFi::getInstance();
   
       esp_err_t err = wifi.connect();
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "Couldn't connect to AP (%s)", esp_err_to_name(err));
           return err;
       }
   
       return ESP_OK;
   }
   
   esp_err_t WiFiDefaultEventHandler::staStop()
   {
       ESP_LOGI(TAG, "STA Stop");
   
       return ESP_OK;
   }
   
   WiFi::WiFi()
       : m_event_handler()
   {
   }
   esp_err_t WiFi::init()
   {
   
       ESP_LOGD(TAG, "Init TCP/IP adapter");
       
       esp_err_t err;
       err = esp_netif_init();
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_netif_init failed, err = %s", esp_err_to_name(err));
           return err;
       }
   
       err = esp_event_loop_create_default();
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "Couldn't create event loop, err = %s", esp_err_to_name(err));
           return err;
       }
       esp_netif_create_default_wifi_ap();
   
       ESP_LOGD(TAG, "Initializing Wi-Fi");
   
       wifi_init_config_t init_config = WIFI_INIT_CONFIG_DEFAULT();
       err = esp_wifi_init(&init_config);
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_wifi_init failed, err = %s", esp_err_to_name(err));
           return err;
       }
   
       err = esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,
           &WiFi::eventHandler, this);
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "Couldn't register Wi-Fi event handler, err = %s", esp_err_to_name(err));
           return err;
       }
   
       return ESP_OK;
   }
   
   esp_err_t WiFi::setMode(wifi_mode_t mode)
   {
       return esp_wifi_set_mode(mode);
   }
   
   esp_err_t WiFi::getMode(wifi_mode_t& mode)
   {
       return esp_wifi_get_mode(&mode);
   }
   
   esp_err_t WiFi::setApConfig(wifi_config_t& ap_config)
   {
       return esp_wifi_set_config(WIFI_IF_AP, &ap_config);
   }
   
   esp_err_t WiFi::getApConfig(wifi_config_t& ap_config)
   {
       return esp_wifi_get_config(WIFI_IF_AP, &ap_config);
   }
   
   esp_err_t WiFi::setStaConfig(wifi_config_t& sta_config)
   {
       return esp_wifi_set_config(WIFI_IF_STA, &sta_config);
   }
   
   esp_err_t WiFi::getStaConfig(wifi_config_t& sta_config)
   {
       return esp_wifi_get_config(WIFI_IF_STA, &sta_config);
   }
   
   bool WiFi::isAp()
   {
       wifi_mode_t mode;
       esp_err_t err = esp_wifi_get_mode(&mode);
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_wifi_get_mode failed (%s)", esp_err_to_name(err));
           return false;
       }
   
       return (mode == WIFI_MODE_APSTA || mode == WIFI_MODE_AP);
   }
   
   bool WiFi::isSta()
   {
       wifi_mode_t mode;
       esp_err_t err = esp_wifi_get_mode(&mode);
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_wifi_get_mode failed (%s)", esp_err_to_name(err));
           return false;
       }
   
       return (mode == WIFI_MODE_APSTA || mode == WIFI_MODE_STA);
   }
   
   esp_err_t WiFi::start()
   {
       ESP_LOGD(TAG, "Starting Wi-Fi");
   
       esp_err_t err = esp_wifi_start();
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_wifi_start failed");
           return err;
       }
   
       return ESP_OK;
   }
   
   esp_err_t WiFi::connect()
   {
       esp_err_t err;
   
       wifi_mode_t wifimode;
       err = esp_wifi_get_mode(&wifimode);
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_wifi_get_mode failed");
           return err;
       }
   
       if (!isSta()) {
           ESP_LOGE(TAG, "Wi-Fi mode is not STA");
           return ESP_FAIL;
       }
   
       return esp_wifi_connect();
   }
   
   void WiFi::setEventHandler(std::unique_ptr<WiFiEventHandler>&& event_handler)
   {
       ESP_LOGD(TAG, "Setting Wi-Fi event handler");
   
       m_event_handler.setNextHandler(std::move(event_handler));
   }
   
   esp_err_t WiFi::stop()
   {
       esp_err_t err = esp_wifi_stop();
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "esp_wifi_stop failed, err = %s", esp_err_to_name(err));
           return err;
       }
   
       return ESP_OK;
   }
   
   void WiFi::eventHandler(void* event_handler_arg,
       esp_event_base_t event_base,
       std::int32_t event_id,
       void* event_data)
   {
       ESP_LOGD(TAG, "Wi-Fi Event Handler Called");
       WiFi* wifi = reinterpret_cast<WiFi*>(event_handler_arg);
   
       esp_err_t err = wifi->m_event_handler.eventDispatcher(event_id, event_data);
       if (err != ESP_OK) {
           ESP_LOGE(TAG, "Event handler error, err = %s", esp_err_to_name(err));
       }
   }
   
   } // namespace network