Kaj SchittecatandClaude Opus 4.8
86c07560e5
NVS is a tiny ~20KB partition shared with the Launcher/other apps/Wi-Fi; it was filling up (Launcher 'Failed to store settings in NVS: 4357', boot loops). The touch namespace spread 17 scalar settings (brightness, kb backlight, accent, language, rotation, lock colour, ...) across 17 separate keys. Pack them into one versioned 'cfg' blob -> ~16 NVS entries reclaimed per device. One-time migration is crash-safe (write blob, then remove legacy keys only after a durable write; idempotent via magic+ver), preserves every user's existing settings, and falls back cleanly if the write fails on an already-full NVS. use_sd/setup_ok stay standalone (main.cpp reads them at boot); strings, byte-blobs and Wi-Fi slots are untouched. Public API unchanged; both touch envs build. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
996 lines
35 KiB
C++
996 lines
35 KiB
C++
#include "TouchPrefsStore.h"
|
||
|
||
#if defined(ESP32)
|
||
|
||
#include "WifiRuntimeStore.h"
|
||
|
||
#include "SdNvsPrefs.h" // NVS, or SD /meshcomod fallback when NVS is unusable (Launcher)
|
||
|
||
#include <stddef.h> // offsetof
|
||
#include <string.h> // memcpy
|
||
|
||
static const char* TOUCH_NS = "touch";
|
||
|
||
static SdNvsPrefs s_prefs;
|
||
static bool s_begun = false;
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Packed scalar config blob ("cfg")
|
||
// ---------------------------------------------------------------------------
|
||
//
|
||
// NVS is a tiny (~20 KB) partition shared across firmwares; every distinct key
|
||
// costs an entry and the namespace was filling up. The many per-key SCALAR
|
||
// settings (brightness, kb backlight, accent colour, language, …) are therefore
|
||
// packed into ONE versioned blob keyed "cfg". Strings (tile_srv, rgn_scope,
|
||
// lk_wall, channel-scopes, quick-replies), the byte blobs (fav / ign / rpw) and
|
||
// the Wi-Fi slots keep their own keys — and "use_sd" / "setup_ok" stay standalone
|
||
// keys too, because main.cpp reads (and for use_sd, writes) them directly via a
|
||
// raw Preferences open at boot, BEFORE the touch prefs load.
|
||
//
|
||
// On first run with the blob absent we read every legacy per-key into s_cfg, write
|
||
// "cfg" ONCE, and only after that durable write do we remove() the legacy keys to
|
||
// reclaim their entries. The write-before-remove ordering makes the migration
|
||
// crash-safe and idempotent (a power-cut before the write just re-migrates next
|
||
// boot; one after it finds "cfg" present and skips). `magic` rejects a garbage /
|
||
// short read (→ treat as absent → defaults); `ver` lets later builds add fields.
|
||
static const char* KEY_CFG = "cfg";
|
||
static const uint16_t TOUCH_CFG_MAGIC = 0x5743; // 'WC' (WadaCfg)
|
||
static const uint8_t TOUCH_CFG_VER = 1;
|
||
|
||
// Defaults (kept identical to the historical per-key defaults).
|
||
static const uint16_t DEFAULT_SCREEN_TIMEOUT_S = 20;
|
||
static const uint8_t DEFAULT_BRIGHTNESS = 100;
|
||
static const uint8_t DEFAULT_KB_BL = 2; // auto
|
||
static const uint8_t DEFAULT_KB_LAYOUT = 0; // English
|
||
static const uint8_t DEFAULT_KB_SECONDARY = 0; // None
|
||
static const uint32_t DEFAULT_LOCK_COLOR = 0xE6F2FFu; // soft white
|
||
static const uint32_t DEFAULT_ACCENT = 0x15B6A6u; // brand teal
|
||
static const bool DEFAULT_DC_SHOW = true;
|
||
|
||
struct __attribute__((packed)) TouchCfg {
|
||
uint16_t magic; // TOUCH_CFG_MAGIC — rejects a garbage/short read
|
||
uint8_t ver; // TOUCH_CFG_VER — schema version
|
||
uint8_t bright; // "bright" 1..100 (clamped 5..100 on get/set)
|
||
uint8_t kb_bl; // "kb_bl" 0..2
|
||
uint8_t kb_layout; // "kblang"
|
||
uint8_t kb_secondary; // "kbsec"
|
||
uint8_t ui_lang; // "ui_lang"
|
||
uint8_t ui_rotation; // "uirot" 0..3
|
||
uint8_t dc_show; // "dc_show" bool
|
||
uint8_t use_miles; // "use_miles" bool
|
||
uint8_t tiles_from_sd; // "tiles_sd" bool
|
||
uint8_t clr_bubbles; // "clr_bub" bool
|
||
uint8_t kb_accent; // "kb_accent" bool
|
||
int8_t time_offs; // "time_offs" -23..23
|
||
uint16_t scr_to_s; // "scr_to_s"
|
||
uint16_t kb_enabled; // "kbenab" bitmask
|
||
uint16_t batt_full_mv; // "battfull"
|
||
uint32_t lock_color; // "lk_col" 0xRRGGBB
|
||
uint32_t accent; // "accent" 0xRRGGBB
|
||
uint32_t gps_baud; // "gps_baud" 0 = unset -> caller fallback
|
||
};
|
||
|
||
static TouchCfg s_cfg;
|
||
static bool s_cfg_loaded = false;
|
||
|
||
// Legacy per-key names — only referenced by the one-time migration below.
|
||
static const char* LK_SCR_TO = "scr_to_s";
|
||
static const char* LK_DC_SHOW = "dc_show";
|
||
static const char* LK_BRIGHTNESS = "bright";
|
||
static const char* LK_KB_BL = "kb_bl";
|
||
static const char* LK_KB_LAYOUT = "kblang";
|
||
static const char* LK_KB_SECONDARY = "kbsec";
|
||
static const char* LK_KB_ENABLED = "kbenab";
|
||
static const char* LK_LOCK_COLOR = "lk_col";
|
||
static const char* LK_CLR_BUBBLES = "clr_bub";
|
||
static const char* LK_KB_ACCENT = "kb_accent";
|
||
static const char* LK_ACCENT = "accent";
|
||
static const char* LK_TIME_OFFS = "time_offs";
|
||
static const char* LK_USE_MILES = "use_miles";
|
||
static const char* LK_TILES_FROM_SD= "tiles_sd";
|
||
static const char* LK_UI_LANG = "ui_lang";
|
||
static const char* LK_UI_ROTATION = "uirot";
|
||
static const char* LK_BATT_FULL = "battfull";
|
||
static const char* LK_GPS_BAUD = "gps_baud";
|
||
|
||
static void cfgSetDefaults(TouchCfg& c) {
|
||
c.magic = TOUCH_CFG_MAGIC;
|
||
c.ver = TOUCH_CFG_VER;
|
||
c.bright = DEFAULT_BRIGHTNESS;
|
||
c.kb_bl = DEFAULT_KB_BL;
|
||
c.kb_layout = DEFAULT_KB_LAYOUT;
|
||
c.kb_secondary = DEFAULT_KB_SECONDARY;
|
||
c.ui_lang = 0;
|
||
c.ui_rotation = 0;
|
||
c.dc_show = DEFAULT_DC_SHOW ? 1 : 0;
|
||
c.use_miles = 0;
|
||
c.tiles_from_sd = 0;
|
||
c.clr_bubbles = 1; // default ON
|
||
c.kb_accent = 1; // default ON
|
||
c.time_offs = 0;
|
||
c.scr_to_s = DEFAULT_SCREEN_TIMEOUT_S;
|
||
c.kb_enabled = 0;
|
||
c.batt_full_mv = 0;
|
||
c.lock_color = DEFAULT_LOCK_COLOR;
|
||
c.accent = DEFAULT_ACCENT;
|
||
c.gps_baud = 0; // 0 sentinel -> getter returns caller fallback
|
||
}
|
||
|
||
// Persist the whole blob using the same end()/begin(RW)/put/end()/begin(RO)
|
||
// discipline every setter in this file uses. Returns true on a durable write.
|
||
static bool cfgFlush() {
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) { s_begun = false; return false; }
|
||
bool ok = s_prefs.putBytes(KEY_CFG, &s_cfg, sizeof(s_cfg)) == sizeof(s_cfg);
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
// Load "cfg" once; on absence run the one-time legacy migration. Must be called
|
||
// with the namespace already open (RO is fine for the load + legacy reads; the
|
||
// migration write reopens RW via cfgFlush). Idempotent: a no-op after the first
|
||
// successful run because "cfg" then exists.
|
||
static void cfgLoadOrMigrate() {
|
||
if (s_cfg_loaded) return;
|
||
cfgSetDefaults(s_cfg);
|
||
|
||
// isKey() does NOT emit the [E] NOT_FOUND log that getBytes() would on a miss,
|
||
// so probe first to keep the (USB-CDC) console clean on a fresh device.
|
||
if (s_prefs.isKey(KEY_CFG)) {
|
||
TouchCfg tmp;
|
||
memset(&tmp, 0, sizeof(tmp));
|
||
size_t n = s_prefs.getBytes(KEY_CFG, &tmp, sizeof(tmp));
|
||
// Need at least magic(2)+ver(1) to trust the header; reject anything shorter
|
||
// (a half-written / garbage blob) and re-derive from legacy keys / defaults.
|
||
if (n >= offsetof(TouchCfg, bright) && tmp.magic == TOUCH_CFG_MAGIC) {
|
||
// Copy whatever was stored over the defaults (a shorter, older blob leaves
|
||
// newer trailing fields at their default), then version-upgrade if needed.
|
||
memcpy(&s_cfg, &tmp, n < sizeof(s_cfg) ? n : sizeof(s_cfg));
|
||
if (s_cfg.ver < TOUCH_CFG_VER) {
|
||
s_cfg.ver = TOUCH_CFG_VER;
|
||
s_cfg.magic = TOUCH_CFG_MAGIC;
|
||
cfgFlush(); // rewrite with new fields defaulted-in
|
||
}
|
||
s_cfg_loaded = true;
|
||
return;
|
||
}
|
||
// Garbage / short / wrong-magic read -> fall through and re-derive from
|
||
// legacy keys (or defaults), overwriting the bad blob.
|
||
}
|
||
|
||
// No (valid) "cfg" yet: build it from the legacy per-key values, applying the
|
||
// exact same defaults the old getters used. On a fresh device every isKey()
|
||
// is false, so this just keeps the defaults set above.
|
||
if (s_prefs.isKey(LK_SCR_TO)) s_cfg.scr_to_s = s_prefs.getUShort(LK_SCR_TO, DEFAULT_SCREEN_TIMEOUT_S);
|
||
if (s_prefs.isKey(LK_BRIGHTNESS)) s_cfg.bright = s_prefs.getUChar(LK_BRIGHTNESS, DEFAULT_BRIGHTNESS);
|
||
if (s_prefs.isKey(LK_KB_BL)) s_cfg.kb_bl = s_prefs.getUChar(LK_KB_BL, DEFAULT_KB_BL);
|
||
if (s_prefs.isKey(LK_KB_LAYOUT)) s_cfg.kb_layout = s_prefs.getUChar(LK_KB_LAYOUT, DEFAULT_KB_LAYOUT);
|
||
if (s_prefs.isKey(LK_KB_SECONDARY)) s_cfg.kb_secondary = s_prefs.getUChar(LK_KB_SECONDARY, DEFAULT_KB_SECONDARY);
|
||
if (s_prefs.isKey(LK_TIME_OFFS)) s_cfg.time_offs = s_prefs.getChar(LK_TIME_OFFS, 0);
|
||
if (s_prefs.isKey(LK_LOCK_COLOR)) s_cfg.lock_color = s_prefs.getUInt(LK_LOCK_COLOR, DEFAULT_LOCK_COLOR) & 0xFFFFFFu;
|
||
if (s_prefs.isKey(LK_ACCENT)) s_cfg.accent = s_prefs.getUInt(LK_ACCENT, DEFAULT_ACCENT) & 0xFFFFFFu;
|
||
if (s_prefs.isKey(LK_CLR_BUBBLES)) s_cfg.clr_bubbles = s_prefs.getBool(LK_CLR_BUBBLES, true) ? 1 : 0;
|
||
if (s_prefs.isKey(LK_KB_ACCENT)) s_cfg.kb_accent = s_prefs.getBool(LK_KB_ACCENT, true) ? 1 : 0;
|
||
if (s_prefs.isKey(LK_DC_SHOW)) s_cfg.dc_show = s_prefs.getBool(LK_DC_SHOW, DEFAULT_DC_SHOW) ? 1 : 0;
|
||
if (s_prefs.isKey(LK_USE_MILES)) s_cfg.use_miles = s_prefs.getBool(LK_USE_MILES, false) ? 1 : 0;
|
||
if (s_prefs.isKey(LK_TILES_FROM_SD))s_cfg.tiles_from_sd= s_prefs.getBool(LK_TILES_FROM_SD, false) ? 1 : 0;
|
||
if (s_prefs.isKey(LK_UI_LANG)) s_cfg.ui_lang = s_prefs.getUChar(LK_UI_LANG, 0);
|
||
if (s_prefs.isKey(LK_UI_ROTATION)) s_cfg.ui_rotation = s_prefs.getUChar(LK_UI_ROTATION, 0);
|
||
if (s_prefs.isKey(LK_BATT_FULL)) s_cfg.batt_full_mv = s_prefs.getUShort(LK_BATT_FULL, 0);
|
||
if (s_prefs.isKey(LK_GPS_BAUD)) s_cfg.gps_baud = s_prefs.getUInt(LK_GPS_BAUD, 0);
|
||
// Enabled-layout mask: legacy used 0xFFFF as the "never written" sentinel and
|
||
// derived a one-bit mask from the secondary layout. Reproduce that here.
|
||
{
|
||
uint16_t v = s_prefs.isKey(LK_KB_ENABLED) ? s_prefs.getUShort(LK_KB_ENABLED, 0xFFFF) : 0xFFFF;
|
||
if (v == 0xFFFF) {
|
||
uint8_t sec = s_cfg.kb_secondary;
|
||
s_cfg.kb_enabled = (sec != 0 && sec < 16) ? (uint16_t)(1u << sec) : 0;
|
||
} else {
|
||
s_cfg.kb_enabled = v;
|
||
}
|
||
}
|
||
|
||
// Write "cfg" ONCE. Only after a durable write do we reclaim the legacy keys.
|
||
// If the write fails (e.g. NVS full / SD missing) we keep the legacy keys
|
||
// intact and retry the whole migration on the next boot.
|
||
if (cfgFlush()) {
|
||
s_prefs.end();
|
||
if (s_prefs.begin(TOUCH_NS, false)) {
|
||
const char* legacy[] = {
|
||
LK_SCR_TO, LK_DC_SHOW, LK_BRIGHTNESS, LK_KB_BL, LK_KB_LAYOUT,
|
||
LK_KB_SECONDARY, LK_KB_ENABLED, LK_LOCK_COLOR, LK_CLR_BUBBLES,
|
||
LK_KB_ACCENT, LK_ACCENT, LK_TIME_OFFS, LK_USE_MILES, LK_TILES_FROM_SD,
|
||
LK_UI_LANG, LK_UI_ROTATION, LK_BATT_FULL, LK_GPS_BAUD,
|
||
};
|
||
for (const char* k : legacy) {
|
||
if (s_prefs.isKey(k)) s_prefs.remove(k);
|
||
}
|
||
s_prefs.end();
|
||
}
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
}
|
||
s_cfg_loaded = true;
|
||
}
|
||
|
||
void touchPrefsBegin() {
|
||
if (s_begun) {
|
||
if (!s_cfg_loaded) cfgLoadOrMigrate();
|
||
return;
|
||
}
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
if (!s_begun) {
|
||
/* Namespace may not exist yet — open RW once to create it, then reopen RO. */
|
||
if (s_prefs.begin(TOUCH_NS, false)) {
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
}
|
||
}
|
||
if (s_begun) cfgLoadOrMigrate();
|
||
}
|
||
|
||
// Arduino's Preferences::getString()/getBytes() emit an [E] nvs_get_* "NOT_FOUND"
|
||
// log every time a key is absent — which floods the (USB-CDC) console on a fresh
|
||
// device and on every empty Wi-Fi-slot read. isKey() (getType → raw nvs probes)
|
||
// does NOT log, so probe with it before reading an optional string key.
|
||
static String prefsGetStr(const char* key, const String& def) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_prefs.isKey(key) ? s_prefs.getString(key, def) : def;
|
||
}
|
||
|
||
uint16_t touchPrefsGetScreenTimeoutSecs() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.scr_to_s;
|
||
}
|
||
|
||
bool touchPrefsSetScreenTimeoutSecs(uint16_t seconds) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.scr_to_s = seconds;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint8_t touchPrefsGetBrightness() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
uint8_t v = s_cfg.bright;
|
||
if (v < 5) v = 5;
|
||
if (v > 100) v = 100;
|
||
return v;
|
||
}
|
||
|
||
bool touchPrefsSetBrightness(uint8_t pct) {
|
||
if (pct < 5) pct = 5;
|
||
if (pct > 100) pct = 100;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.bright = pct;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint8_t touchPrefsGetKbBacklight() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
uint8_t v = s_cfg.kb_bl;
|
||
return v > 2 ? DEFAULT_KB_BL : v;
|
||
}
|
||
|
||
bool touchPrefsSetKbBacklight(uint8_t mode) {
|
||
if (mode > 2) mode = DEFAULT_KB_BL;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.kb_bl = mode;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint8_t touchPrefsGetKeyboardLayout() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.kb_layout;
|
||
}
|
||
|
||
bool touchPrefsSetKeyboardLayout(uint8_t layout) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.kb_layout = layout;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint8_t touchPrefsGetSecondaryKeyboard() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.kb_secondary;
|
||
}
|
||
|
||
bool touchPrefsSetSecondaryKeyboard(uint8_t secondary) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.kb_secondary = secondary;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint16_t touchPrefsGetEnabledLayouts() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
// The legacy "never written -> derive a one-bit mask from the secondary
|
||
// layout" migration ran once at cfg-migration time (see cfgLoadOrMigrate);
|
||
// the resolved mask now lives in s_cfg.kb_enabled.
|
||
return s_cfg.kb_enabled;
|
||
}
|
||
|
||
bool touchPrefsSetEnabledLayouts(uint16_t mask) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.kb_enabled = mask;
|
||
return cfgFlush();
|
||
}
|
||
|
||
static const char* KEY_TILE_SRV = "tile_srv";
|
||
static const char* DEFAULT_TILE_SERVER = "http://tiles.wadamesh.com";
|
||
|
||
int touchPrefsGetTileServer(char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return 0;
|
||
out[0] = '\0';
|
||
if (!s_begun) touchPrefsBegin();
|
||
String v = prefsGetStr(KEY_TILE_SRV, String(DEFAULT_TILE_SERVER));
|
||
int n = (int)v.length();
|
||
if (n > out_cap - 1) n = out_cap - 1;
|
||
if (n > TOUCH_TILE_SERVER_MAXLEN - 1) n = TOUCH_TILE_SERVER_MAXLEN - 1;
|
||
memcpy(out, v.c_str(), (size_t)n);
|
||
out[n] = '\0';
|
||
return n;
|
||
}
|
||
|
||
bool touchPrefsSetTileServer(const char* url) {
|
||
if (!url) return false;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok = s_prefs.putString(KEY_TILE_SRV, url) > 0;
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
static const char* KEY_RGN_SCOPE = "rgn_scope";
|
||
|
||
int touchPrefsGetRegionScope(char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return 0;
|
||
out[0] = '\0';
|
||
if (!s_begun) touchPrefsBegin();
|
||
String v = prefsGetStr(KEY_RGN_SCOPE, String(""));
|
||
int n = (int)v.length();
|
||
if (n > out_cap - 1) n = out_cap - 1;
|
||
if (n > TOUCH_REGION_SCOPE_MAXLEN - 1) n = TOUCH_REGION_SCOPE_MAXLEN - 1;
|
||
memcpy(out, v.c_str(), (size_t)n);
|
||
out[n] = '\0';
|
||
return n;
|
||
}
|
||
|
||
bool touchPrefsSetRegionScope(const char* name) {
|
||
if (!name) return false;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok = s_prefs.putString(KEY_RGN_SCOPE, name) > 0;
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
// Per-channel region-scope override, keyed by channel slot (0..63). Overrides the
|
||
// default flood scope for that channel's outgoing messages. Blank = inherit the
|
||
// default. Stored as "csc<slot>" -> region name.
|
||
static void chanScopeKey(int slot, char out[8]) {
|
||
snprintf(out, 8, "csc%d", slot & 0x3F);
|
||
}
|
||
int touchPrefsGetChannelScope(int slot, char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return 0;
|
||
out[0] = '\0';
|
||
if (slot < 0) return 0;
|
||
if (!s_begun) touchPrefsBegin();
|
||
char k[8]; chanScopeKey(slot, k);
|
||
String v = prefsGetStr(k, String(""));
|
||
int n = (int)v.length();
|
||
if (n > out_cap - 1) n = out_cap - 1;
|
||
if (n > TOUCH_REGION_SCOPE_MAXLEN - 1) n = TOUCH_REGION_SCOPE_MAXLEN - 1;
|
||
if (n > 0) memcpy(out, v.c_str(), (size_t)n);
|
||
out[n] = '\0';
|
||
return n;
|
||
}
|
||
bool touchPrefsSetChannelScope(int slot, const char* name) {
|
||
if (slot < 0) return false;
|
||
if (!s_begun) touchPrefsBegin();
|
||
char k[8]; chanScopeKey(slot, k);
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok = s_prefs.putString(k, name ? name : "") > 0;
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
static const char* KEY_LOCK_WALL = "lk_wall";
|
||
static const char* DEFAULT_LOCK_WALL = "/lock/placeholder.jpg";
|
||
|
||
int touchPrefsGetLockWallpaper(char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return 0;
|
||
out[0] = '\0';
|
||
if (!s_begun) touchPrefsBegin();
|
||
String v = prefsGetStr(KEY_LOCK_WALL, String(DEFAULT_LOCK_WALL));
|
||
int n = (int)v.length();
|
||
if (n > out_cap - 1) n = out_cap - 1;
|
||
if (n > TOUCH_LOCK_WALLPAPER_MAXLEN - 1) n = TOUCH_LOCK_WALLPAPER_MAXLEN - 1;
|
||
memcpy(out, v.c_str(), (size_t)n);
|
||
out[n] = '\0';
|
||
return n;
|
||
}
|
||
|
||
bool touchPrefsSetLockWallpaper(const char* path) {
|
||
if (!path) return false;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok = s_prefs.putString(KEY_LOCK_WALL, path) > 0;
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
int touchPrefsGetTimeOffsetHours() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
int v = (int)s_cfg.time_offs;
|
||
if (v < -23) v = -23;
|
||
if (v > 23) v = 23;
|
||
return v;
|
||
}
|
||
bool touchPrefsSetTimeOffsetHours(int hours) {
|
||
if (hours < -23) hours = -23;
|
||
if (hours > 23) hours = 23;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.time_offs = (int8_t)hours;
|
||
return cfgFlush();
|
||
}
|
||
void touchPrefsBuildLocalTz(char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return;
|
||
// CET base is UTC+1 (POSIX std offset -1). The displayed local time is
|
||
// UTC + (1 + userOffset), so the POSIX std-offset field is -(1 + userOffset).
|
||
// CEST (summer) auto-adds 1h via the DST rule. offset 0 == "CET-1CEST,...".
|
||
int off = touchPrefsGetTimeOffsetHours();
|
||
snprintf(out, out_cap, "CET%dCEST,M3.5.0,M10.5.0/3", -(1 + off));
|
||
}
|
||
|
||
uint32_t touchPrefsGetLockTextColor() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.lock_color & 0xFFFFFFu;
|
||
}
|
||
|
||
bool touchPrefsSetLockTextColor(uint32_t rgb) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.lock_color = rgb & 0xFFFFFFu;
|
||
return cfgFlush();
|
||
}
|
||
|
||
// Colourful chat bubbles: colour each bubble + sender name by a hash of the
|
||
// sender's display name (same name -> same colour). Default ON.
|
||
bool touchPrefsGetColorfulBubbles() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.clr_bubbles != 0;
|
||
}
|
||
bool touchPrefsSetColorfulBubbles(bool on) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.clr_bubbles = on ? 1 : 0;
|
||
return cfgFlush();
|
||
}
|
||
|
||
// Keyboard accent-popup picker: when a typed Latin letter has accented variants,
|
||
// a tap-to-pick box appears. Default ON. (Distinct from the accent THEME colour.)
|
||
bool touchPrefsGetAccentPopups() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.kb_accent != 0;
|
||
}
|
||
bool touchPrefsSetAccentPopups(bool on) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.kb_accent = on ? 1 : 0;
|
||
return cfgFlush();
|
||
}
|
||
|
||
// UI accent colour (buttons, active tab, keyboard, highlights) as 0xRRGGBB.
|
||
// Default = the WADAMESH brand teal (the logo dots). The picker clamps it dark
|
||
// enough that the off-white button text stays readable on any hue.
|
||
uint32_t touchPrefsGetAccentColor() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.accent & 0xFFFFFFu;
|
||
}
|
||
bool touchPrefsSetAccentColor(uint32_t rgb) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.accent = rgb & 0xFFFFFFu;
|
||
return cfgFlush();
|
||
}
|
||
|
||
// Quick-reply macros. Stored as NVS strings keyed "qr0".."qr5".
|
||
// Default factory set on first read so the picker isn't useless out of the
|
||
// box and the user has examples to edit.
|
||
// Factory defaults skew tactical / radio-comms style — mesh radios get used
|
||
// for field ops a lot more than for "calling now" social texting, so seed
|
||
// the picker with phrases that actually pull weight on the air. ASCII-only
|
||
// so they render identically with or without the extras font fallback.
|
||
static const char* k_qr_defaults[TOUCH_QUICK_REPLY_COUNT] = {
|
||
"copy", // generic acknowledgment
|
||
"wilco", // will comply
|
||
"stand by", // wait one
|
||
"moving to RP", // en route to rally point
|
||
"ETA 5 min", // arrival estimate
|
||
"RTB", // returning to base
|
||
};
|
||
|
||
static void qrKeyFor(int idx, char out[8]) {
|
||
out[0] = 'q'; out[1] = 'r';
|
||
out[2] = (char)('0' + (idx & 0x07));
|
||
out[3] = '\0';
|
||
}
|
||
|
||
int touchPrefsGetQuickReply(int idx, char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return 0;
|
||
out[0] = '\0';
|
||
if (idx < 0 || idx >= TOUCH_QUICK_REPLY_COUNT) return 0;
|
||
if (!s_begun) touchPrefsBegin();
|
||
char key[8];
|
||
qrKeyFor(idx, key);
|
||
String v = prefsGetStr(key, String(k_qr_defaults[idx]));
|
||
int n = (int)v.length();
|
||
if (n > out_cap - 1) n = out_cap - 1;
|
||
if (n > TOUCH_QUICK_REPLY_MAXLEN - 1) n = TOUCH_QUICK_REPLY_MAXLEN - 1;
|
||
memcpy(out, v.c_str(), (size_t)n);
|
||
out[n] = '\0';
|
||
return n;
|
||
}
|
||
|
||
bool touchPrefsGetDutyMeterShown() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.dc_show != 0;
|
||
}
|
||
|
||
bool touchPrefsSetDutyMeterShown(bool show) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.dc_show = show ? 1 : 0;
|
||
return cfgFlush();
|
||
}
|
||
|
||
bool touchPrefsGetUseMiles() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.use_miles != 0; // default = km
|
||
}
|
||
|
||
bool touchPrefsSetUseMiles(bool use_miles) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.use_miles = use_miles ? 1 : 0;
|
||
return cfgFlush();
|
||
}
|
||
|
||
bool touchPrefsGetTilesFromSd() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.tiles_from_sd != 0; // default = tile server
|
||
}
|
||
|
||
bool touchPrefsSetTilesFromSd(bool from_sd) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.tiles_from_sd = from_sd ? 1 : 0;
|
||
return cfgFlush();
|
||
}
|
||
|
||
// Store ALL device data (identity, prefs, contacts, channels) on the SD card
|
||
// under /meshcomod instead of internal SPIFFS. Read at boot (main.cpp) BEFORE
|
||
// the data loads, so changing it needs a reboot. Key "use_sd" in the "touch"
|
||
// namespace — main.cpp reads the same key directly.
|
||
static const char* KEY_USE_SD_STORAGE = "use_sd";
|
||
|
||
bool touchPrefsGetUseSdStorage() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_prefs.getBool(KEY_USE_SD_STORAGE, false); // default = SPIFFS
|
||
}
|
||
|
||
bool touchPrefsSetUseSdStorage(bool use_sd) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok = s_prefs.putBool(KEY_USE_SD_STORAGE, use_sd);
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
// UI language index (UiLang enum in i18n.h; 0 = English). Read at boot to pick
|
||
// the active translation language. Packed into the "cfg" blob.
|
||
uint8_t touchPrefsGetUiLang() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.ui_lang; // default = English
|
||
}
|
||
bool touchPrefsSetUiLang(uint8_t lang) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.ui_lang = lang;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint8_t touchPrefsGetUiRotation() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
uint8_t r = s_cfg.ui_rotation; // default = portrait
|
||
return (r <= 3) ? r : 0;
|
||
}
|
||
|
||
bool touchPrefsSetUiRotation(uint8_t rot) {
|
||
if (rot > 3) rot = 0;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.ui_rotation = rot;
|
||
return cfgFlush();
|
||
}
|
||
|
||
uint16_t touchPrefsGetBattFullMv() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_cfg.batt_full_mv; // 0 = not calibrated -> default 4200
|
||
}
|
||
|
||
bool touchPrefsSetBattFullMv(uint16_t mv) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.batt_full_mv = mv;
|
||
return cfgFlush();
|
||
}
|
||
|
||
// Wi-Fi profile slots ----------------------------------------------------
|
||
//
|
||
// NVS keys: "wsl_<idx>_l" (label), "wsl_<idx>_s" (ssid), "wsl_<idx>_p" (pwd).
|
||
// 3 slots × 3 strings = 9 small entries; well under the 12 KB NVS default.
|
||
|
||
static void wifiSlotKey(int idx, char kind, char out[12]) {
|
||
// wsl<idx><kind> → "wsl0l", "wsl1s", "wsl2p", ...
|
||
int p = 0;
|
||
out[p++] = 'w'; out[p++] = 's'; out[p++] = 'l';
|
||
out[p++] = (char)('0' + (idx & 0x07));
|
||
out[p++] = kind;
|
||
out[p] = '\0';
|
||
}
|
||
|
||
bool touchPrefsGetWifiSlot(int idx, char* label, int label_cap,
|
||
char* ssid, int ssid_cap,
|
||
char* pwd, int pwd_cap) {
|
||
if (idx < 0 || idx >= TOUCH_WIFI_SLOT_COUNT) return false;
|
||
if (label && label_cap > 0) label[0] = '\0';
|
||
if (ssid && ssid_cap > 0) ssid[0] = '\0';
|
||
if (pwd && pwd_cap > 0) pwd[0] = '\0';
|
||
if (!s_begun) touchPrefsBegin();
|
||
char k[12];
|
||
if (label && label_cap > 0) {
|
||
wifiSlotKey(idx, 'l', k);
|
||
String v = prefsGetStr(k, "");
|
||
int n = (int)v.length();
|
||
if (n > label_cap - 1) n = label_cap - 1;
|
||
if (n > 0) memcpy(label, v.c_str(), (size_t)n);
|
||
label[n] = '\0';
|
||
}
|
||
if (ssid && ssid_cap > 0) {
|
||
wifiSlotKey(idx, 's', k);
|
||
String v = prefsGetStr(k, "");
|
||
int n = (int)v.length();
|
||
if (n > ssid_cap - 1) n = ssid_cap - 1;
|
||
if (n > 0) memcpy(ssid, v.c_str(), (size_t)n);
|
||
ssid[n] = '\0';
|
||
}
|
||
if (pwd && pwd_cap > 0) {
|
||
wifiSlotKey(idx, 'p', k);
|
||
String v = prefsGetStr(k, "");
|
||
int n = (int)v.length();
|
||
if (n > pwd_cap - 1) n = pwd_cap - 1;
|
||
if (n > 0) memcpy(pwd, v.c_str(), (size_t)n);
|
||
pwd[n] = '\0';
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool touchPrefsSetWifiSlot(int idx, const char* label,
|
||
const char* ssid, const char* pwd) {
|
||
if (idx < 0 || idx >= TOUCH_WIFI_SLOT_COUNT) return false;
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
char k[12];
|
||
wifiSlotKey(idx, 'l', k); s_prefs.putString(k, label ? label : "");
|
||
wifiSlotKey(idx, 's', k); s_prefs.putString(k, ssid ? ssid : "");
|
||
wifiSlotKey(idx, 'p', k); s_prefs.putString(k, pwd ? pwd : "");
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return true;
|
||
}
|
||
|
||
// Favorites blob (raw bytes: N * 6-byte pub_key prefixes, packed) ----------
|
||
static const char* KEY_FAV = "fav";
|
||
|
||
static int favReadAll(uint8_t out[TOUCH_FAVORITES_MAX * TOUCH_FAVORITE_KEY_BYTES]) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
if (!s_prefs.isKey(KEY_FAV)) return 0; // absent on a fresh device — skip the [E] NOT_FOUND log
|
||
size_t n = s_prefs.getBytes(KEY_FAV, out, TOUCH_FAVORITES_MAX * TOUCH_FAVORITE_KEY_BYTES);
|
||
if (n == 0 || n > (size_t)(TOUCH_FAVORITES_MAX * TOUCH_FAVORITE_KEY_BYTES)) return 0;
|
||
// Round down to a whole number of entries — guards against NVS returning
|
||
// a half-written blob from a power-cut mid-write.
|
||
return (int)(n / TOUCH_FAVORITE_KEY_BYTES);
|
||
}
|
||
|
||
static bool favWriteAll(const uint8_t* buf, int count) {
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok;
|
||
if (count <= 0) {
|
||
s_prefs.remove(KEY_FAV);
|
||
ok = true;
|
||
} else {
|
||
ok = s_prefs.putBytes(KEY_FAV, buf, (size_t)(count * TOUCH_FAVORITE_KEY_BYTES)) > 0;
|
||
}
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
bool touchPrefsIsFavorite(const uint8_t* pub_key6) {
|
||
if (!pub_key6) return false;
|
||
uint8_t buf[TOUCH_FAVORITES_MAX * TOUCH_FAVORITE_KEY_BYTES];
|
||
int n = favReadAll(buf);
|
||
for (int i = 0; i < n; ++i) {
|
||
if (memcmp(&buf[i * TOUCH_FAVORITE_KEY_BYTES], pub_key6, TOUCH_FAVORITE_KEY_BYTES) == 0) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
int touchPrefsCopyFavorites(uint8_t* out_buf) {
|
||
if (!out_buf) return 0;
|
||
return favReadAll(out_buf);
|
||
}
|
||
|
||
bool touchPrefsFavoritesSnapshotContains(const uint8_t* snapshot, int count,
|
||
const uint8_t* pub_key6) {
|
||
if (!snapshot || !pub_key6 || count <= 0) return false;
|
||
for (int i = 0; i < count; ++i) {
|
||
if (memcmp(&snapshot[i * TOUCH_FAVORITE_KEY_BYTES], pub_key6,
|
||
TOUCH_FAVORITE_KEY_BYTES) == 0) return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool touchPrefsSetFavorite(const uint8_t* pub_key6, bool fav) {
|
||
if (!pub_key6) return false;
|
||
uint8_t buf[TOUCH_FAVORITES_MAX * TOUCH_FAVORITE_KEY_BYTES];
|
||
int n = favReadAll(buf);
|
||
int found = -1;
|
||
for (int i = 0; i < n; ++i) {
|
||
if (memcmp(&buf[i * TOUCH_FAVORITE_KEY_BYTES], pub_key6, TOUCH_FAVORITE_KEY_BYTES) == 0) {
|
||
found = i; break;
|
||
}
|
||
}
|
||
if (fav) {
|
||
if (found >= 0) return true;
|
||
if (n >= TOUCH_FAVORITES_MAX) return false; // cap reached, silently refuse
|
||
memcpy(&buf[n * TOUCH_FAVORITE_KEY_BYTES], pub_key6, TOUCH_FAVORITE_KEY_BYTES);
|
||
++n;
|
||
favWriteAll(buf, n);
|
||
return true;
|
||
} else {
|
||
if (found < 0) return false;
|
||
// Shift remaining entries down to keep the blob packed.
|
||
for (int i = found; i < n - 1; ++i) {
|
||
memcpy(&buf[i * TOUCH_FAVORITE_KEY_BYTES],
|
||
&buf[(i + 1) * TOUCH_FAVORITE_KEY_BYTES],
|
||
TOUCH_FAVORITE_KEY_BYTES);
|
||
}
|
||
--n;
|
||
favWriteAll(buf, n);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// Ignored / blocked senders -------------------------------------------------
|
||
//
|
||
// Same scheme as favorites: a single NVS blob "ign" of up to TOUCH_IGNORED_MAX
|
||
// 6-byte pubkey prefixes. Incoming messages from a stored prefix are dropped
|
||
// (no chat entry, no notification). Managed from the chat "Blocked users" sheet.
|
||
static const char* KEY_IGN = "ign";
|
||
|
||
static int ignReadAll(uint8_t out[TOUCH_IGNORED_MAX * TOUCH_IGNORE_KEY_BYTES]) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
if (!s_prefs.isKey(KEY_IGN)) return 0; // absent on a fresh device — skip the [E] NOT_FOUND log
|
||
size_t n = s_prefs.getBytes(KEY_IGN, out, TOUCH_IGNORED_MAX * TOUCH_IGNORE_KEY_BYTES);
|
||
if (n == 0 || n > (size_t)(TOUCH_IGNORED_MAX * TOUCH_IGNORE_KEY_BYTES)) return 0;
|
||
return (int)(n / TOUCH_IGNORE_KEY_BYTES);
|
||
}
|
||
|
||
static bool ignWriteAll(const uint8_t* buf, int count) {
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok;
|
||
if (count <= 0) { s_prefs.remove(KEY_IGN); ok = true; }
|
||
else ok = s_prefs.putBytes(KEY_IGN, buf, (size_t)(count * TOUCH_IGNORE_KEY_BYTES)) > 0;
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
bool touchPrefsIsIgnored(const uint8_t* pub_key6) {
|
||
if (!pub_key6) return false;
|
||
uint8_t buf[TOUCH_IGNORED_MAX * TOUCH_IGNORE_KEY_BYTES];
|
||
int n = ignReadAll(buf);
|
||
for (int i = 0; i < n; ++i)
|
||
if (memcmp(&buf[i * TOUCH_IGNORE_KEY_BYTES], pub_key6, TOUCH_IGNORE_KEY_BYTES) == 0) return true;
|
||
return false;
|
||
}
|
||
|
||
int touchPrefsCopyIgnored(uint8_t* out_buf) {
|
||
if (!out_buf) return 0;
|
||
return ignReadAll(out_buf);
|
||
}
|
||
|
||
bool touchPrefsSetIgnored(const uint8_t* pub_key6, bool ignored) {
|
||
if (!pub_key6) return false;
|
||
uint8_t buf[TOUCH_IGNORED_MAX * TOUCH_IGNORE_KEY_BYTES];
|
||
int n = ignReadAll(buf);
|
||
int found = -1;
|
||
for (int i = 0; i < n; ++i)
|
||
if (memcmp(&buf[i * TOUCH_IGNORE_KEY_BYTES], pub_key6, TOUCH_IGNORE_KEY_BYTES) == 0) { found = i; break; }
|
||
if (ignored) {
|
||
if (found >= 0) return true;
|
||
if (n >= TOUCH_IGNORED_MAX) return false; // cap reached, silently refuse
|
||
memcpy(&buf[n * TOUCH_IGNORE_KEY_BYTES], pub_key6, TOUCH_IGNORE_KEY_BYTES);
|
||
++n; ignWriteAll(buf, n); return true;
|
||
} else {
|
||
if (found < 0) return false;
|
||
for (int i = found; i < n - 1; ++i)
|
||
memcpy(&buf[i * TOUCH_IGNORE_KEY_BYTES], &buf[(i + 1) * TOUCH_IGNORE_KEY_BYTES], TOUCH_IGNORE_KEY_BYTES);
|
||
--n; ignWriteAll(buf, n); return false;
|
||
}
|
||
}
|
||
|
||
// Remembered repeater admin passwords --------------------------------------
|
||
//
|
||
// Layout: single NVS blob "rpw" of up to TOUCH_REPEATER_PW_MAX records,
|
||
// each record = [6-byte pubkey prefix][16-byte null-terminated password].
|
||
// Empty/cleared records are removed (the blob is repacked) so reading the
|
||
// blob length tells you exactly how many entries exist.
|
||
static const char* KEY_RPW = "rpw";
|
||
constexpr int RPW_REC_BYTES = TOUCH_REPEATER_PW_KEY_LEN + TOUCH_REPEATER_PW_LEN; // 6 + 16 = 22
|
||
|
||
static int rpwReadAll(uint8_t out[TOUCH_REPEATER_PW_MAX * RPW_REC_BYTES]) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
if (!s_prefs.isKey(KEY_RPW)) return 0; // absent on a fresh device — skip the [E] NOT_FOUND log
|
||
size_t n = s_prefs.getBytes(KEY_RPW, out, TOUCH_REPEATER_PW_MAX * RPW_REC_BYTES);
|
||
if (n == 0 || n > (size_t)(TOUCH_REPEATER_PW_MAX * RPW_REC_BYTES)) return 0;
|
||
return (int)(n / RPW_REC_BYTES);
|
||
}
|
||
|
||
static bool rpwWriteAll(const uint8_t* buf, int count) {
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok;
|
||
if (count <= 0) {
|
||
s_prefs.remove(KEY_RPW);
|
||
ok = true;
|
||
} else {
|
||
ok = s_prefs.putBytes(KEY_RPW, buf, (size_t)(count * RPW_REC_BYTES)) > 0;
|
||
}
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
int touchPrefsGetRepeaterPassword(const uint8_t* pub_key6, char* out, int out_cap) {
|
||
if (!out || out_cap <= 0) return 0;
|
||
out[0] = '\0';
|
||
if (!pub_key6) return 0;
|
||
uint8_t buf[TOUCH_REPEATER_PW_MAX * RPW_REC_BYTES];
|
||
int n = rpwReadAll(buf);
|
||
for (int i = 0; i < n; ++i) {
|
||
const uint8_t* rec = &buf[i * RPW_REC_BYTES];
|
||
if (memcmp(rec, pub_key6, TOUCH_REPEATER_PW_KEY_LEN) == 0) {
|
||
const char* pw = (const char*)(rec + TOUCH_REPEATER_PW_KEY_LEN);
|
||
int plen = 0;
|
||
while (plen < TOUCH_REPEATER_PW_LEN - 1 && pw[plen] != '\0') ++plen;
|
||
if (plen > out_cap - 1) plen = out_cap - 1;
|
||
memcpy(out, pw, (size_t)plen);
|
||
out[plen] = '\0';
|
||
return plen;
|
||
}
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
bool touchPrefsSetRepeaterPassword(const uint8_t* pub_key6, const char* password) {
|
||
if (!pub_key6) return false;
|
||
uint8_t buf[TOUCH_REPEATER_PW_MAX * RPW_REC_BYTES];
|
||
int n = rpwReadAll(buf);
|
||
int found = -1;
|
||
for (int i = 0; i < n; ++i) {
|
||
if (memcmp(&buf[i * RPW_REC_BYTES], pub_key6, TOUCH_REPEATER_PW_KEY_LEN) == 0) {
|
||
found = i; break;
|
||
}
|
||
}
|
||
// Treat null/empty password as a remove request — saves NVS bytes and
|
||
// avoids confusing "remembered but empty" cases.
|
||
bool remove = !password || password[0] == '\0';
|
||
if (remove) {
|
||
if (found < 0) return true;
|
||
for (int i = found; i < n - 1; ++i) {
|
||
memcpy(&buf[i * RPW_REC_BYTES], &buf[(i + 1) * RPW_REC_BYTES], RPW_REC_BYTES);
|
||
}
|
||
--n;
|
||
return rpwWriteAll(buf, n);
|
||
}
|
||
// Add or overwrite. Cap reached → silently refuse.
|
||
int slot = found;
|
||
if (slot < 0) {
|
||
if (n >= TOUCH_REPEATER_PW_MAX) return false;
|
||
slot = n++;
|
||
}
|
||
uint8_t* rec = &buf[slot * RPW_REC_BYTES];
|
||
memcpy(rec, pub_key6, TOUCH_REPEATER_PW_KEY_LEN);
|
||
// Pad password slot with zeros, then copy up to PW_LEN-1 chars.
|
||
memset(rec + TOUCH_REPEATER_PW_KEY_LEN, 0, TOUCH_REPEATER_PW_LEN);
|
||
int plen = (int)strlen(password);
|
||
if (plen > TOUCH_REPEATER_PW_LEN - 1) plen = TOUCH_REPEATER_PW_LEN - 1;
|
||
memcpy(rec + TOUCH_REPEATER_PW_KEY_LEN, password, (size_t)plen);
|
||
return rpwWriteAll(buf, n);
|
||
}
|
||
|
||
bool touchPrefsActivateWifiSlot(int idx) {
|
||
char label[TOUCH_WIFI_LABEL_MAX];
|
||
char ssid[WIFI_CONFIG_SSID_MAX];
|
||
char pwd[WIFI_CONFIG_PWD_MAX];
|
||
if (!touchPrefsGetWifiSlot(idx, label, sizeof(label),
|
||
ssid, sizeof(ssid), pwd, sizeof(pwd))) {
|
||
return false;
|
||
}
|
||
if (ssid[0] == '\0') return false; // refuse to activate an empty slot
|
||
if (!wifiConfigSetSsid(ssid)) return false;
|
||
if (!wifiConfigSetPwd(pwd)) return false;
|
||
wifiConfigSetRadioEnabled(true);
|
||
wifiConfigRequestApply();
|
||
return true;
|
||
}
|
||
|
||
bool touchPrefsSetQuickReply(int idx, const char* text) {
|
||
if (idx < 0 || idx >= TOUCH_QUICK_REPLY_COUNT) return false;
|
||
if (!s_begun) touchPrefsBegin();
|
||
// Open RW. Truncate to TOUCH_QUICK_REPLY_MAXLEN-1 to bound NVS usage.
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
char key[8];
|
||
qrKeyFor(idx, key);
|
||
char buf[TOUCH_QUICK_REPLY_MAXLEN];
|
||
buf[0] = '\0';
|
||
if (text) {
|
||
int n = (int)strlen(text);
|
||
if (n > TOUCH_QUICK_REPLY_MAXLEN - 1) n = TOUCH_QUICK_REPLY_MAXLEN - 1;
|
||
memcpy(buf, text, (size_t)n);
|
||
buf[n] = '\0';
|
||
}
|
||
bool ok = s_prefs.putString(key, buf) > 0 || (buf[0] == '\0');
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
static const char* KEY_SETUP_DONE = "setup_ok";
|
||
|
||
bool touchPrefsGetSetupDone() {
|
||
if (!s_begun) touchPrefsBegin();
|
||
return s_prefs.getBool(KEY_SETUP_DONE, false);
|
||
}
|
||
|
||
bool touchPrefsSetSetupDone(bool done) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_prefs.end();
|
||
if (!s_prefs.begin(TOUCH_NS, false)) return false;
|
||
bool ok = s_prefs.putBool(KEY_SETUP_DONE, done);
|
||
s_prefs.end();
|
||
s_begun = s_prefs.begin(TOUCH_NS, true);
|
||
return ok;
|
||
}
|
||
|
||
uint32_t touchPrefsGetGpsBaud(uint32_t fallback) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
// 0 = never set -> caller's compile-time default. A real configured baud is
|
||
// always non-zero, so this preserves the old "absent key -> fallback" result.
|
||
return s_cfg.gps_baud != 0 ? s_cfg.gps_baud : fallback;
|
||
}
|
||
|
||
bool touchPrefsSetGpsBaud(uint32_t baud) {
|
||
if (!s_begun) touchPrefsBegin();
|
||
s_cfg.gps_baud = baud;
|
||
return cfgFlush();
|
||
}
|
||
|
||
#endif
|