src/settings.cpp - master - ellersseer/MyCheat

src/settings.cpp
316 строк10 KB
Dmitry Zhiltsov
feat(logs): Добавить логи в WEB
20 фев 2026, 20:39
20 фев 2026, 20:39dae6bcf
#include "settings.h"
#include "config.h"
#include "log_buffer.h"
#include <Preferences.h>

// Namespace names for NVS storage
const char* SettingsManager::NAMESPACE_WIFI = "wifi";
const char* SettingsManager::NAMESPACE_MQTT = "mqtt";
const char* SettingsManager::NAMESPACE_DEVICE = "device";
const char* SettingsManager::NAMESPACE_SENSORS = "sensors";

// Global instance
SettingsManager settingsManager;

bool SettingsManager::begin() {
    if (initialized) {
        return true;
    }

    logCapture.println("[Settings] Initializing settings manager...");
    initialized = true;

    if (isFirstRun()) {
        logCapture.println("[Settings] First run detected - settings not configured");
    } else {
        logCapture.println("[Settings] Existing settings found");
    }

    return true;
}

bool SettingsManager::isFirstRun() {
    return !checkMagic();
}

bool SettingsManager::checkMagic() {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_DEVICE, true)) { // read-only
        return false;
    }
    uint32_t magic = prefs.getUInt("magic", 0);
    prefs.end();
    return magic == MAGIC_VALUE;
}

bool SettingsManager::setMagic() {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_DEVICE, false)) { // read-write
        return false;
    }
    prefs.putUInt("magic", MAGIC_VALUE);
    prefs.end();
    return true;
}

bool SettingsManager::loadWifiSettings(WifiSettings& settings) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_WIFI, true)) { // read-only
        logCapture.println("[Settings] Failed to open WiFi namespace");
        return false;
    }

    // Load SSID
    String ssid = prefs.getString("ssid", DEFAULT_WIFI_SSID);
    strncpy(settings.ssid, ssid.c_str(), WIFI_SSID_MAX_LEN - 1);
    settings.ssid[WIFI_SSID_MAX_LEN - 1] = '\0';

    // Load password
    String password = prefs.getString("password", DEFAULT_WIFI_PASSWORD);
    strncpy(settings.password, password.c_str(), WIFI_PASSWORD_MAX_LEN - 1);
    settings.password[WIFI_PASSWORD_MAX_LEN - 1] = '\0';

    // Load configured flag
    settings.configured = prefs.getBool("configured", false);

    prefs.end();

    return true;
}

bool SettingsManager::saveWifiSettings(const WifiSettings& settings) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_WIFI, false)) { // read-write
        logCapture.println("[Settings] Failed to open WiFi namespace for writing");
        return false;
    }

    prefs.putString("ssid", settings.ssid);
    prefs.putString("password", settings.password);
    prefs.putBool("configured", settings.configured);

    prefs.end();

    // Set magic to indicate settings have been saved
    setMagic();

    logCapture.printf("[Settings] WiFi saved: SSID='%s', configured=%s\n",
                  settings.ssid, settings.configured ? "true" : "false");
    return true;
}

bool SettingsManager::loadMqttSettings(MqttSettings& settings) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_MQTT, true)) { // read-only
        logCapture.println("[Settings] Failed to open MQTT namespace");
        return false;
    }

    // Load server
    String server = prefs.getString("server", DEFAULT_MQTT_SERVER);
    strncpy(settings.server, server.c_str(), MQTT_SERVER_MAX_LEN - 1);
    settings.server[MQTT_SERVER_MAX_LEN - 1] = '\0';

    // Load port
    settings.port = prefs.getUShort("port", DEFAULT_MQTT_PORT);

    // Load user
    String user = prefs.getString("user", DEFAULT_MQTT_USER);
    strncpy(settings.user, user.c_str(), MQTT_USER_MAX_LEN - 1);
    settings.user[MQTT_USER_MAX_LEN - 1] = '\0';

    // Load password
    String password = prefs.getString("password", DEFAULT_MQTT_PASSWORD);
    strncpy(settings.password, password.c_str(), MQTT_PASSWORD_MAX_LEN - 1);
    settings.password[MQTT_PASSWORD_MAX_LEN - 1] = '\0';

    // Load client_id (default: mycheat_XXXXXX based on chip ID)
    char defaultClientId[32];
    uint32_t chipId = (uint32_t)(ESP.getEfuseMac() >> 24);
    snprintf(defaultClientId, sizeof(defaultClientId), "%s%06X", DEFAULT_MQTT_CLIENT_ID_PREFIX, chipId);
    String client_id = prefs.getString("client_id", defaultClientId);
    strncpy(settings.client_id, client_id.c_str(), MQTT_CLIENT_ID_MAX_LEN - 1);
    settings.client_id[MQTT_CLIENT_ID_MAX_LEN - 1] = '\0';

    // Load topic_prefix
    String topic_prefix = prefs.getString("topic_prefix", DEFAULT_MQTT_TOPIC_PREFIX);
    strncpy(settings.topic_prefix, topic_prefix.c_str(), MQTT_TOPIC_PREFIX_MAX_LEN - 1);
    settings.topic_prefix[MQTT_TOPIC_PREFIX_MAX_LEN - 1] = '\0';

    // Load enabled flag
    settings.enabled = prefs.getBool("enabled", DEFAULT_MQTT_ENABLED);

    prefs.end();

    return true;
}

bool SettingsManager::saveMqttSettings(const MqttSettings& settings) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_MQTT, false)) { // read-write
        logCapture.println("[Settings] Failed to open MQTT namespace for writing");
        return false;
    }

    prefs.putString("server", settings.server);
    prefs.putUShort("port", settings.port);
    prefs.putString("user", settings.user);
    prefs.putString("password", settings.password);
    prefs.putString("client_id", settings.client_id);
    prefs.putString("topic_prefix", settings.topic_prefix);
    prefs.putBool("enabled", settings.enabled);

    prefs.end();

    // Set magic to indicate settings have been saved
    setMagic();

    logCapture.printf("[Settings] MQTT saved: server='%s:%d', enabled=%s\n",
                  settings.server, settings.port, settings.enabled ? "true" : "false");
    return true;
}

bool SettingsManager::loadSensorSettings(SensorSettings& settings) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_SENSORS, true)) { // read-only
        logCapture.println("[Settings] Failed to open sensors namespace, using defaults");
        return false;
    }

    // Load temperatures
    for (int i = 0; i < MAX_SENSORS; i++) {
        char key[8];
        snprintf(key, sizeof(key), "temp_%d", i);
        settings.lastTemperatures[i] = prefs.getFloat(key, 20.0f);

        snprintf(key, sizeof(key), "en_%d", i);
        settings.sensorEnabled[i] = prefs.getBool(key, true);
    }

    // Load stale timeout
    settings.staleTimeoutMinutes = prefs.getUShort("stale_tout", 60);

    prefs.end();

    logCapture.printf("[Settings] Sensors loaded: staleTimeout=%d min\n", settings.staleTimeoutMinutes);
    return true;
}

bool SettingsManager::saveSensorSettings(const SensorSettings& settings) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_SENSORS, false)) { // read-write
        logCapture.println("[Settings] Failed to open sensors namespace for writing");
        return false;
    }

    // Save temperatures
    for (int i = 0; i < MAX_SENSORS; i++) {
        char key[8];
        snprintf(key, sizeof(key), "temp_%d", i);
        prefs.putFloat(key, settings.lastTemperatures[i]);

        snprintf(key, sizeof(key), "en_%d", i);
        prefs.putBool(key, settings.sensorEnabled[i]);
    }

    // Save stale timeout
    prefs.putUShort("stale_tout", settings.staleTimeoutMinutes);

    prefs.end();

    logCapture.printf("[Settings] Sensors saved: staleTimeout=%d min\n", settings.staleTimeoutMinutes);
    return true;
}

bool SettingsManager::saveSensorTemperature(uint8_t idx, float temp) {
    if (idx >= MAX_SENSORS) return false;

    Preferences prefs;
    if (!prefs.begin(NAMESPACE_SENSORS, false)) {
        return false;
    }

    char key[8];
    snprintf(key, sizeof(key), "temp_%d", idx);
    prefs.putFloat(key, temp);

    prefs.end();
    return true;
}

bool SettingsManager::saveSensorEnabled(uint8_t idx, bool enabled) {
    if (idx >= MAX_SENSORS) return false;

    Preferences prefs;
    if (!prefs.begin(NAMESPACE_SENSORS, false)) {
        return false;
    }

    char key[8];
    snprintf(key, sizeof(key), "en_%d", idx);
    prefs.putBool(key, enabled);

    prefs.end();
    return true;
}

bool SettingsManager::saveStaleTimeout(uint16_t minutes) {
    Preferences prefs;
    if (!prefs.begin(NAMESPACE_SENSORS, false)) {
        return false;
    }

    prefs.putUShort("stale_tout", minutes);

    prefs.end();
    return true;
}

bool SettingsManager::factoryReset() {
    logCapture.println("[Settings] Performing factory reset...");

    Preferences prefs;

    // Clear WiFi namespace
    if (prefs.begin(NAMESPACE_WIFI, false)) {
        prefs.clear();
        prefs.end();
    }

    // Clear MQTT namespace
    if (prefs.begin(NAMESPACE_MQTT, false)) {
        prefs.clear();
        prefs.end();
    }

    // Clear device namespace (magic value)
    if (prefs.begin(NAMESPACE_DEVICE, false)) {
        prefs.clear();
        prefs.end();
    }

    // Clear sensors namespace
    if (prefs.begin(NAMESPACE_SENSORS, false)) {
        prefs.clear();
        prefs.end();
    }

    logCapture.println("[Settings] Factory reset complete");
    return true;
}

void SettingsManager::printSettings(const WifiSettings& wifi, const MqttSettings& mqtt) {
    logCapture.println("=== Current Settings ===");
    logCapture.println("WiFi:");
    logCapture.printf("  SSID: %s\n", wifi.ssid);
    logCapture.printf("  Password: %s\n", strlen(wifi.password) > 0 ? "********" : "(empty)");
    logCapture.printf("  Configured: %s\n", wifi.configured ? "true" : "false");
    logCapture.println("MQTT:");
    logCapture.printf("  Server: %s:%d\n", mqtt.server, mqtt.port);
    logCapture.printf("  User: %s\n", mqtt.user);
    logCapture.printf("  Password: %s\n", strlen(mqtt.password) > 0 ? "********" : "(empty)");
    logCapture.printf("  Client ID: %s\n", mqtt.client_id);
    logCapture.printf("  Topic Prefix: %s\n", mqtt.topic_prefix);
    logCapture.printf("  Enabled: %s\n", mqtt.enabled ? "true" : "false");
    logCapture.println("========================");
}