Max Gramser
b58f0cde25
A code check found that a setting changed on a screen could jump back. ESP Screen Manager kept its own copy and sent it with every full update: after a restart of the app or Home Assistant, every hour and after every save. A change it missed while it or Home Assistant restarted came back to the old value, a reported setting was lost when save() refused a layout with a removed entity, and every step of a held - or + on the screen resent the whole screen. Firmware 0.2.49 offers every setting as an entity over the existing preference records (no migration): Night mode, Night starts/ends, 24-hour clock, Back to page 1 and after how long, Back to page 1 on standby, Swipe between pages and, on the Guition, Rotation, next to the four numbers and Auto standby. The settings page and every entity write through settings_screen::set(), which clamps like the page and stores, applies and reports only a real change. screen_message answers a caller that asks with its status and layout revision (api.respond). The settings tile opens without Home Assistant. The app reads and changes the settings of such a screen through its entities and leaves them out of the layout message. Older firmware keeps them with the layout; a setting it reports is stored without the tile check and not sent back. Pings to screens that can answer learn at once whether a tile is missing and resend after 30 s instead of 120 s. Layout sensors come back after a Home Assistant restart, and weather tiles only ask for the forecasts the entity supports. The editor's settings form is now three cards with the rows of the screen's own page; a change applies at once, and an offline screen shows its values as unknown. Checked with 245 Python and 14 C++ tests, generate_packages --check, ESP32 builds of both profiles, host-build API tests on both boards, and a live run against Home Assistant 2026.9.1 with a temporary host device. Firmware 0.2.49. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
169 lines
8.9 KiB
C++
169 lines
8.9 KiB
C++
#define SETTINGS_SCREEN_TEST
|
|
#include "../components/smart_display/settings_screen.h"
|
|
#include <cassert>
|
|
#include <string>
|
|
|
|
using namespace settings_screen;
|
|
|
|
// The row of a page by its label, so a test says what it means.
|
|
static const Row &row_named(const Page &page, const std::string &label) {
|
|
for (uint8_t i = 0; i < page.count; ++i)
|
|
if (label == page.rows[i].label) return page.rows[i];
|
|
assert(false);
|
|
return page.rows[0];
|
|
}
|
|
|
|
int main() {
|
|
// ---- the duration ladder: seconds low down, quarters of an hour up top, and symmetric ----
|
|
assert(ladder_step(60) == 30 && ladder_step(600) == 60 && ladder_step(1800) == 300);
|
|
assert(ladder_step(3600) == 900 && ladder_step(36000) == 1800);
|
|
Row timeout = duration("After", nullptr, nullptr, 30, 3600);
|
|
assert(stepped(timeout, 120, 1) == 150 && stepped(timeout, 120, -1) == 90);
|
|
assert(stepped(timeout, 300, 1) == 360 && stepped(timeout, 360, -1) == 300);
|
|
assert(stepped(timeout, 300, -1) == 270 && stepped(timeout, 270, 1) == 300);
|
|
assert(stepped(timeout, 30, -1) == 30 && stepped(timeout, 3600, 1) == 3600);
|
|
assert(at_end(timeout, 30, -1) && at_end(timeout, 3600, 1) && !at_end(timeout, 120, -1));
|
|
|
|
// ---- a number stops at its ends, a moment walks around midnight ----
|
|
Row percent = number("Brightness", nullptr, nullptr, 5, 100, 5, "%");
|
|
assert(stepped(percent, 100, 1) == 100 && stepped(percent, 5, -1) == 5 && stepped(percent, 95, 1) == 100);
|
|
Row start = moment("Starts", nullptr, nullptr);
|
|
assert(stepped(start, 1320, 1) == 1335 && stepped(start, 1425, 1) == 0 && stepped(start, 0, -1) == 1425);
|
|
assert(!at_end(start, 0, -1));
|
|
// Holding the key walks whole hours, and first lands on the hour it is in.
|
|
assert(stepped(start, 1320, 1, true) == 1380 && stepped(start, 1320, -1, true) == 1260);
|
|
assert(stepped(start, 1327, 1, true) == 1380 && stepped(start, 1327, -1, true) == 1320);
|
|
assert(stepped(start, 1380, 1, true) == 1440 % 1440); // 23:00 + 1 h wraps to 00:00
|
|
assert(stepped(start, 0, -1, true) == 1380); // 00:00 - 1 h is 23:00
|
|
|
|
// ---- texts ----
|
|
assert(duration_text(45) == "45 sec" && duration_text(60) == "1 min" && duration_text(120) == "2 min");
|
|
assert(duration_text(3600) == "1 h" && duration_text(5400) == "1 h 30" && duration_text(86400) == "24 h");
|
|
assert(moment_text(1320, true) == "22:00" && moment_text(0, true) == "00:00");
|
|
assert(moment_text(1320, false) == "10:00 PM" && moment_text(0, false) == "12:00 AM");
|
|
assert(moment_text(750, false) == "12:30 PM" && moment_text(60, false) == "1:00 AM");
|
|
|
|
// ---- rows read and write the real settings ----
|
|
screen_settings::current = screen_settings::Settings{};
|
|
const Page &light = pages[1];
|
|
const Row &brightness = row_named(light, "Brightness");
|
|
assert(value_text(brightness) == "100%");
|
|
brightness.write(40);
|
|
assert(screen_settings::current.brightness == 40 && value_text(brightness) == "40%");
|
|
// Lowering the normal brightness pulls the two dim levels down with it, exactly like the add-on.
|
|
screen_settings::current.standby_brightness = 60;
|
|
brightness.write(30);
|
|
assert(screen_settings::current.standby_brightness == 30);
|
|
const Row &standby = row_named(light, "Standby brightness");
|
|
standby.write(90);
|
|
assert(screen_settings::current.standby_brightness == 30); // never above the normal brightness
|
|
assert(screen_settings::current.valid());
|
|
|
|
const Page &screen = pages[3];
|
|
const Row &clock = row_named(screen, "Clock");
|
|
assert(clock.option_count == 2 && value_text(clock) == "24 hour");
|
|
clock.write(0);
|
|
assert(screen_settings::current.clock_24h == 0 && value_text(clock) == "12 hour");
|
|
const Row &home = row_named(screen, "Back to page 1");
|
|
home.write(0);
|
|
assert(auto_home == 0 && value_text(home) == "Off");
|
|
const Row &rotate = row_named(screen, "Rotation");
|
|
rotation_supported = false;
|
|
assert(!visible_row(rotate)); // a board that cannot turn never shows the row
|
|
rotation_supported = true;
|
|
assert(visible_row(rotate));
|
|
rotate.write(2);
|
|
assert(rotation == 180 && value_text(rotate) == "180°");
|
|
rotate.write(3);
|
|
assert(rotation == 270);
|
|
rotate.write(0);
|
|
assert(rotation == 0);
|
|
|
|
// ---- every page hangs together: menu rows open a real page, controls can be worked ----
|
|
assert(PAGE_COUNT == 5);
|
|
for (uint8_t p = 0; p < PAGE_COUNT; ++p) {
|
|
const Page &page = pages[p];
|
|
assert(page.title && page.count && page.count <= 8);
|
|
for (uint8_t i = 0; i < page.count; ++i) {
|
|
const Row &row = page.rows[i];
|
|
assert(row.label && *row.label);
|
|
if (row.kind == Kind::page) assert(row.opens > 0 && row.opens < PAGE_COUNT && *row.icon);
|
|
if (row.kind == Kind::toggle || row.kind == Kind::choice || row.kind == Kind::number ||
|
|
row.kind == Kind::duration || row.kind == Kind::moment)
|
|
assert(row.read && row.write);
|
|
if (row.kind == Kind::number) assert(row.step > 0 && row.high > row.low);
|
|
if (row.kind == Kind::duration) assert(row.high > row.low);
|
|
if (row.kind == Kind::choice) assert(row.options && row.option_count);
|
|
if (row.kind == Kind::info) assert(row.text);
|
|
if (row.kind == Kind::action) assert(row.run && *row.icon);
|
|
}
|
|
}
|
|
// Every page is reachable from the menu.
|
|
bool reached[PAGE_COUNT] = {true};
|
|
for (uint8_t i = 0; i < pages[0].count; ++i) reached[pages[0].rows[i].opens] = true;
|
|
for (bool page : reached) assert(page);
|
|
|
|
// ---- how many rows fit, and when the pager appears ----
|
|
bool paged = false;
|
|
assert(fitting_rows(180, 34, 4, 26, 4, paged) == 4 && !paged); // CYD: four rows, no pager
|
|
assert(fitting_rows(180, 34, 4, 26, 6, paged) == 4 && paged); // six rows: 4 + 2
|
|
assert(fitting_rows(372, 52, 8, 40, 6, paged) == 6 && !paged); // Guition: the whole group at once
|
|
assert(fitting_rows(372, 52, 8, 40, 9, paged) == 5 && paged);
|
|
assert(fitting_rows(40, 34, 4, 26, 5, paged) >= 1); // never zero rows
|
|
|
|
// ---- a change is stored, applied and reported once ----
|
|
static int stored = 0, applied = 0;
|
|
static std::string last_key;
|
|
static int32_t last_value = 0;
|
|
store = [] { ++stored; };
|
|
apply = [] { ++applied; };
|
|
report = [](const char *key, int32_t value) { last_key = key; last_value = value; };
|
|
row_named(light, "Auto standby").write(0);
|
|
assert(stored == 1 && applied == 1 && last_key == "standby_enabled" && last_value == 0);
|
|
row_named(screen, "After").write(600);
|
|
assert(stored == 2 && last_key == "auto_home_seconds" && last_value == 600 && auto_home_seconds == 600);
|
|
|
|
// ---- set(): the one path for the rows and for Home Assistant's entities (firmware 0.2.49+) ----
|
|
// A value the screen already has is not stored, applied or reported: an automation may set it on every change.
|
|
SetResult result = set("standby_enabled", 0);
|
|
assert(result == SetResult::same && stored == 2 && applied == 2);
|
|
result = set("auto_home_seconds", 600);
|
|
assert(result == SetResult::same && stored == 2);
|
|
// Every key ESP Screens knows lands on the screen, clamped the way the page steps it.
|
|
screen_settings::current = screen_settings::Settings{};
|
|
rotation_supported = true;
|
|
const struct { const char *key; int32_t value, expected; } cases[] = {
|
|
{"standby_enabled", 5, 1}, {"standby_seconds", 10, 60}, {"standby_seconds", 999999, 86400},
|
|
{"brightness", 1, 5}, {"brightness", 250, 100}, {"standby_brightness", 101, 100}, {"night_enabled", 0, 0},
|
|
{"night_start", -5, 0}, {"night_end", 2000, 1439}, {"night_brightness", 7, 7}, {"clock_24h", 0, 0},
|
|
{"home_on_standby", 1, 1}, {"swipe_pages", 2, 1}, {"rotation", 100, 90}, {"rotation", 400, 270},
|
|
{"auto_home", 0, 0}, {"auto_home_seconds", 5, 30}, {"auto_home_seconds", 99999, 3600},
|
|
};
|
|
for (const auto &c : cases) {
|
|
result = set(c.key, c.value);
|
|
assert(result != SetResult::unknown);
|
|
if (result == SetResult::changed) assert(last_key == c.key && last_value == c.expected);
|
|
}
|
|
assert(screen_settings::current.standby_seconds == 86400 && screen_settings::current.brightness == 100);
|
|
assert(screen_settings::current.night_start == 0 && screen_settings::current.night_end == 1439);
|
|
assert(swipe_pages == 1 && rotation == 270 && auto_home == 0 && auto_home_seconds == 3600);
|
|
assert(screen_settings::current.valid());
|
|
// A lower brightness pulls both dim levels down, and reports the brightness itself.
|
|
set("standby_brightness", 60);
|
|
set("night_brightness", 50);
|
|
result = set("brightness", 30);
|
|
assert(result == SetResult::changed && last_key == "brightness" && last_value == 30);
|
|
assert(screen_settings::current.standby_brightness == 30 && screen_settings::current.night_brightness == 30);
|
|
result = set("standby_brightness", 90);
|
|
assert(result == SetResult::same && screen_settings::current.standby_brightness == 30);
|
|
// What the screen cannot do, or does not know, is refused without a store.
|
|
const int before = stored;
|
|
rotation_supported = false;
|
|
result = set("rotation", 90);
|
|
assert(result == SetResult::unknown && rotation == 270);
|
|
result = set("show_clock", 0);
|
|
assert(result == SetResult::unknown);
|
|
result = set("beep", 1);
|
|
assert(result == SetResult::unknown && stored == before);
|
|
}
|