rgbwifi/src/server/settings.cpp

/*
 * ESP8266 RGBW controller
 * Copyright 2020 (c) Mark van Renswoude
 *
 * https://git.x2software.net/pub/RGBWifi
*/
#include "./settings.h"
#include <ArduinoJson.h>
#include <AsyncJson.h>
#include <IPAddress.h>
#include <ESP8266WiFi.h>
#include <EspSaveCrash.h>
#include "./shared.h"
#include "../assets/version.h"
#include "../config.h"
#include "../debug.h"
#include "../global.h"
#include "../settings/connection.h"

extern "C" {
  #include <user_interface.h>
}


bool clearedResetReason = false;


void handleStatus(AsyncWebServerRequest *request)
{
  _dln("API :: status");

  DynamicJsonDocument jsonDocument(1024);

  jsonDocument["systemID"] = String(ESP.getChipId(), HEX);
  jsonDocument["version"] = String(VersionFullSemVer);

  jsonDocument["resetReason"] = clearedResetReason ? 0 : ESP.getResetInfoPtr()->reason;
  jsonDocument["stackTrace"] = SaveCrash.count() > 0;

  AsyncResponseStream *response = request->beginResponseStream("application/json");
  serializeJson(jsonDocument, *response);

  request->send(response);
}


void handleConnectionStatus(AsyncWebServerRequest *request)
{
  _dln("API :: connection status");

  WiFiMode_t mode = WiFi.getMode();


  DynamicJsonDocument jsonDocument(1024);

  JsonObject ap = jsonDocument.createNestedObject("ap");
  ap["enabled"] = (mode == WIFI_AP || mode == WIFI_AP_STA);
  ap["ip"] = WiFi.softAPIP().toString();

  JsonObject station = jsonDocument.createNestedObject("station");
  station["enabled"] = (mode == WIFI_STA || mode == WIFI_AP_STA);
  station["status"] = (uint8_t)WiFi.status();
  station["ip"] = WiFi.localIP().toString();

  AsyncResponseStream *response = request->beginResponseStream("application/json");
  serializeJson(jsonDocument, *response);

  request->send(response);
}


void handleGetConnection(AsyncWebServerRequest *request)
{
  _dln("API :: get connection");

  AsyncResponseStream *response = request->beginResponseStream("application/json");
  connectionSettings->toJson(*response);
  request->send(response);
}


void handlePostConnection(AsyncWebServerRequest *request, JsonVariant &json)
{
  _dln("API :: post connection");

  bool changed;
  if (connectionSettings->fromJson(json, &changed))
  {
    connectionSettings->write();

    if (changed)
      connectionSettingsChanged = true;

    request->send(200);
  }
  else
    request->send(400);
}


void handleGetSystem(AsyncWebServerRequest *request)
{
  _dln("API :: get system");

  AsyncResponseStream *response = request->beginResponseStream("application/json");
  systemSettings->toJson(*response);
  request->send(response);
}


void handlePostSystem(AsyncWebServerRequest *request, JsonVariant &json)
{
  _dln("API :: post system");

  bool changed;
  if (systemSettings->fromJson(json, &changed))
  {
    systemSettings->write();

    if (changed)
      systemSettingsChanged = true;

    request->send(200);
  }
  else
    request->send(400);
}


void handleGetStackTrace(AsyncWebServerRequest *request)
{
  _dln("API :: get stack trace");

  if (SaveCrash.count() == 0)
  {
    request->send(404);
    return;
  }

  AsyncResponseStream *response = request->beginResponseStream("application/octet-stream");
  response->addHeader("Content-Disposition", "attachment; filename=\"stacktrace.txt\"");
  SaveCrash.print(*response);
  request->send(response);
}


void handleDeleteStackTrace(AsyncWebServerRequest *request)
{
  _dln("API :: delete stack trace");

  clearedResetReason = true;
  SaveCrash.clear();
  request->send(200);
}


#ifdef EnableCrashAPI
#pragma "!!! Crash API is enabled on this build !!!"

void handleCrashException(AsyncWebServerRequest *request)
{
  _dln("API :: crash exception");

  int* i = nullptr;
  *i = 42;
}

void handleCrashSoftWDT(AsyncWebServerRequest *request)
{
  _dln("API :: crash soft WDT");

  while (true);
}

void handleCrashWDT(AsyncWebServerRequest *request)
{
  _dln("API :: crash WDT");

  ESP.wdtDisable();
  while (true);
}
#endif


void registerSettingsRoutes(AsyncWebServer* server)
{
  server->on("/api/status", HTTP_GET, handleStatus);

  server->on("/api/connection/status", HTTP_GET, handleConnectionStatus);
  server->on("/api/connection", HTTP_GET, handleGetConnection);

  AsyncCallbackJsonWebHandler* connectionPostHandler = new AsyncCallbackJsonWebHandler("/api/connection", handlePostConnection);
  connectionPostHandler->setMethod(HTTP_POST);
  server->addHandler(connectionPostHandler);

  server->on("/api/system", HTTP_GET, handleGetSystem);

  AsyncCallbackJsonWebHandler* systemPostHandler = new AsyncCallbackJsonWebHandler("/api/system", handlePostSystem);
  systemPostHandler->setMethod(HTTP_POST);
  server->addHandler(systemPostHandler);

  server->on("/api/stacktrace/get", HTTP_GET, handleGetStackTrace);
  server->on("/api/stacktrace/delete", HTTP_GET, handleDeleteStackTrace);

  #ifdef EnableCrashAPI
  server->on("/api/crash/exception", HTTP_GET, handleCrashException);
  server->on("/api/crash/softwdt", HTTP_GET, handleCrashSoftWDT);
  server->on("/api/crash/wdt", HTTP_GET, handleCrashWDT);
  #endif
}