esp-vfd-clock/firmware/main/wifi_provisioner.cpp

//
// Created by erki on 07/01/24.
//

#include "wifi_provisioner.hpp"

#include <cstring>
#include "esp_wifi.h"
#include "esp_mac.h"
#include "esp_log.h"

#include <etl/string.h>
#include <cJSON.h>

#include "esp_expected.hpp"

#define EXAMPLE_ESP_WIFI_SSID      "ESP_TEST"
#define EXAMPLE_ESP_WIFI_PASS      "1234567891"
#define EXAMPLE_ESP_WIFI_CHANNEL   5
#define EXAMPLE_MAX_STA_CONN       5

extern const char index_start[] asm("_binary_index_html_start");
extern const char index_end[] asm("_binary_index_html_end");

namespace
{

const char* TAG = "wifi softAP";
const char* NVS_IS_INITED = "_is_inited";

ssize_t indexHtmlLength()
{
  return std::distance(index_start, index_end);
}

void wifiEventHandler_(void* arg, esp_event_base_t event_base,
                       int32_t event_id, void* event_data)
{
  if (event_id == WIFI_EVENT_AP_STACONNECTED) {
    wifi_event_ap_staconnected_t* event = (wifi_event_ap_staconnected_t*) event_data;
    ESP_LOGI(TAG, "station join, AID=%d",
             event->aid);
  } else if (event_id == WIFI_EVENT_AP_STADISCONNECTED) {
    wifi_event_ap_stadisconnected_t* event = (wifi_event_ap_stadisconnected_t*) event_data;
    ESP_LOGI(TAG, "station leave, AID=%d",
             event->aid);
  }
}

esp_err_t rootGetHandler_(httpd_req_t* req)
{
  httpd_resp_set_type(req, "text/html");
  httpd_resp_send(req, index_start, indexHtmlLength());
  return ESP_OK;
}

esp_err_t rootPostHandler_(httpd_req_t* req)
{
  etl::string<1024> content;

  content.initialize_free_space();
  const std::size_t size = MIN(req->content_len, content.max_size() - 1);

  if (const int ret = httpd_req_recv(req, content.data_end(), size);
      ret <= 0)
  {
    if (ret == HTTPD_SOCK_ERR_TIMEOUT)
      httpd_resp_send_408(req);

    return ESP_FAIL;
  }

  content.trim_to_terminator();

  etl::string<100> header;
  if (const auto err = httpd_req_get_hdr_value_str(req, "Content-Type", header.data(), header.max_size() - 1);
      err != ESP_OK)
  {
    ESP_LOGE(TAG, "Error reading content header.");
    return ESP_FAIL;
  }

  //httpd_query_key_value
  ESP_LOGI(TAG, "Data from post: %s, %s", header.data(), content.data());

  const char resp[] = "URI POST Response";
  httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN);
  return ESP_OK;
}

esp_err_t parametersGetHandler_(httpd_req_t* req)
{
  auto* provisioner = static_cast<WifiProvisioner*>(req->user_ctx);
  CJsonPtr data = provisioner->getParameterObjects();
  cJSON* raw_data = data.get();

  auto stringified = CJsonStrPtr(cJSON_Print(raw_data));

  if (!stringified)
  {
    httpd_resp_send_500(req);
    return ESP_FAIL;
  }

  httpd_resp_set_type(req, "application/json");
  httpd_resp_send(req, stringified.get(), HTTPD_RESP_USE_STRLEN);

  return ESP_OK;
}

}

std::expected<WifiProvisioner::Parameter::Value, esp_err_t> WifiProvisioner::Parameter::getValue(nvs::NVSHandle* file_handle) const
{
  if (type == Parameter::Type::INT)
  {
    std::int32_t value = 0;
    TRY_ESP(file_handle->get_item(nvs_name.c_str(), value));

    return value;
  }
  else if (type == Parameter::Type::FLOAT)
  {
    std::int32_t value_raw = 0;
    TRY_ESP(file_handle->get_item(nvs_name.c_str(), value_raw));
    return std::bit_cast<float>(value_raw);
  }
  else if (type == Parameter::Type::STRING)
  {
    etl::string<100> value;
    value.initialize_free_space();

    TRY_ESP(file_handle->get_string(nvs_name.c_str(), value.data(), value.size() - 1));
    value.trim_to_terminator();

    return value;
  }

  return ESP_FAIL;
}

WifiProvisioner::WifiProvisioner(const char* settings_namespace)
{
  esp_err_t err = ESP_OK;
  file_handle_ = nvs::open_nvs_handle(settings_namespace, NVS_READWRITE, &err);

  ESP_ERROR_CHECK(err);

  err = file_handle_->get_item(NVS_IS_INITED, settings_initialized_);

  if (err != ESP_OK)
  {
    ESP_ERROR_CHECK(initializeNvsNamespace_());
  }
}

bool WifiProvisioner::parametersAreConfigured()
{
  if (params_.empty())
    return false;

  for (const auto& param : params_)
  {
    if (const auto value = param.getValue(file_handle_.get());
        !value.has_value())
    {
      return false;
    }
  }

  return true;
}

std::expected<void, esp_err_t> WifiProvisioner::startProvisioning()
{
  TRY(initializeWifiAp_());

  http_server_ = TRY(initializeCaptivePortal_());

  return {};
}

std::expected<void, std::error_code> WifiProvisioner::addParameter(const char* name, const char* nvs_name, const Parameter::Type type)
{
  if (params_.full())
    return std::unexpected(std::make_error_code(std::errc::not_enough_memory));

  auto new_param = Parameter(name, nvs_name, type);
  params_.push_back(new_param);

  return {};
}

CJsonPtr WifiProvisioner::getParameterObjects() const
{
  auto root = CJsonPtr(cJSON_CreateArray());

  for (const Parameter& param : params_)
  {
    cJSON* element = cJSON_CreateObject();
    cJSON_AddStringToObject(element, "name", param.name.c_str());
    cJSON_AddStringToObject(element, "nvs_name", param.nvs_name.c_str());
    cJSON_AddNumberToObject(element, "type", int(param.type));

    cJSON_AddItemToArray(root.get(), element);
  }

  return root;
}

esp_err_t WifiProvisioner::initializeNvsNamespace_()
{
  esp_err_t err = file_handle_->set_item(NVS_IS_INITED, false);

  if (err != ESP_OK)
    return err;

  err = file_handle_->commit();

  return err;
}

std::expected<void, esp_err_t> WifiProvisioner::initializeWifiAp_()
{
  TRY_ESP(esp_netif_init());
  TRY_ESP(esp_event_loop_create_default());
  esp_netif_create_default_wifi_ap();

  wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
  TRY_ESP(esp_wifi_init(&config));

  TRY_ESP(esp_event_handler_instance_register(
          WIFI_EVENT, ESP_EVENT_ANY_ID, &wifiEventHandler_, this, nullptr
          ));

  //https://github.com/espressif/esp-idf/blob/5524b692ee5d04d7a1000eb0c41640746fc67f3c/examples/wifi/getting_started/softAP/main/softap_example_main.c
  wifi_config_t wifi_config = {
          .ap = {
                  .ssid = EXAMPLE_ESP_WIFI_SSID,
                  .password = EXAMPLE_ESP_WIFI_PASS,
                  .ssid_len = std::uint8_t(strlen(EXAMPLE_ESP_WIFI_SSID)),
                  .channel = EXAMPLE_ESP_WIFI_CHANNEL,
#ifdef CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT
                  .authmode = WIFI_AUTH_WPA3_PSK,
#else /* CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT */
                  .authmode = WIFI_AUTH_WPA2_PSK,
#endif
                  .ssid_hidden = 0,
                  .max_connection = EXAMPLE_MAX_STA_CONN,
                  .pmf_cfg = {
                          .required = true,
                  },
#ifdef CONFIG_ESP_WIFI_SOFTAP_SAE_SUPPORT
                  .sae_pwe_h2e = WPA3_SAE_PWE_BOTH,
#endif
          }
  };

  if (strlen(EXAMPLE_ESP_WIFI_PASS) == 0)
    wifi_config.ap.authmode = WIFI_AUTH_OPEN;

  TRY_ESP(esp_wifi_set_mode(WIFI_MODE_AP));
  TRY_ESP(esp_wifi_set_config(WIFI_IF_AP, &wifi_config));
  TRY_ESP(esp_wifi_start());

  return {};
}

std::expected<httpd_handle_t, esp_err_t> WifiProvisioner::initializeCaptivePortal_()
{
  httpd_config_t config = HTTPD_DEFAULT_CONFIG();
  httpd_handle_t server = nullptr;

  TRY_ESP(httpd_start(&server, &config));

  static httpd_uri_t uri_main = {
    .uri = "/",
    .method = HTTP_GET,
    .handler = rootGetHandler_,
    .user_ctx = this
  };

  static httpd_uri_t uri_post = {
    .uri = "/configure",
    .method = HTTP_POST,
    .handler = rootPostHandler_,
    .user_ctx = this
  };

  static httpd_uri_t uri_get_params = {
    .uri = "/parameters",
    .method = HTTP_GET,
    .handler = parametersGetHandler_,
    .user_ctx = this
  };

  if (const auto err = httpd_register_uri_handler(server, &uri_main);
      err != ESP_OK)
  {
    httpd_stop(server);
    return std::unexpected(err);
  }

  if (const auto err = httpd_register_uri_handler(server, &uri_post);
      err != ESP_OK)
  {
    httpd_stop(server);
    return std::unexpected(err);
  }

  if (const auto err = httpd_register_uri_handler(server, &uri_get_params);
      err != ESP_OK)
  {
    httpd_stop(server);
    return std::unexpected(err);
  }

  return server;
}