Max Gramser
306636434b
Live picture (issue #4): a camera or image tile on a Guition takes Display -> Live picture with a pace of 15 or 30 s. The camera tiles of a page share one download: the screen asks ESP Screens for them together (esphome.screen_camera with tiles, size and bg) and the app serves one BMP, a strip of squares with the corners rounded over each tile's own colour; every tile draws its square out of it with LVGL's image offset (LV_IMAGE_ALIGN_TOP_LEFT: the default centres a taller source). A third online_image on the Guition holds the strip; it loads after the alert's picture, a cover and the camera full screen, never under a card, in standby or under a finger. The strip is served whole every time: ESPHome's http_request logs a 304 as a failed request. Firmware 0.2.77. Alert button: esp_screens_show_alert takes action and data; the app performs the action once when the button's report (esphome.screen_alert, ok) comes from any screen. show_alert keeps its seven fields, so every firmware from 0.2.31 has it. Media card and full-page media tile: a title or artist line that is too wide rolls by (LV_LABEL_LONG_SCROLL_CIRCULAR) instead of ending in dots. Full-page tiles are white or their own pastel like every other tile; the tint in the state colour of firmware 0.2.62 to 0.2.76 is gone. Host harness (27 checks) and bench Guition + local add-on on the Yellow: docs/TEST_RESULTS_0291.md. CYD firmware 1,633,728 B, 89.0 %. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
65 lines
3.7 KiB
C++
65 lines
3.7 KiB
C++
#pragma once
|
|
// A camera image full screen (firmware 0.2.57+, Guition): when to ask ESP Screen Manager for a link and when to load it
|
|
// again. Pure bookkeeping, free of LVGL and ESPHome, so tests/test_camera_view.cpp can check it on a PC; runtime_tiles.h
|
|
// draws the view and the board's online_image loads the link.
|
|
//
|
|
// The app answers `esphome.screen_camera` with a link to a BMP it keeps fresh (screen_manager/app/camera_feed.py).
|
|
// Loading shares the main loop with touch and drawing, so the view loads one image at a time and leaves time free after
|
|
// each. The rhythm is fixed rather than as fast as the Wi-Fi allows: a picture every four seconds, every time, reads as
|
|
// smoother than one after three seconds and the next after five. Never a queue: a slow load makes the next one later.
|
|
#include <cstdint>
|
|
#include <string>
|
|
|
|
namespace camera_view {
|
|
constexpr uint32_t REFRESH_MS = 4000; // from the start of one load to the start of the next: a steady rhythm
|
|
constexpr uint32_t GAP_MS = 800; // at least this long between the end of one load and the next
|
|
constexpr uint32_t ASK_AGAIN_MS = 10000; // a link that does not come (or an app without an image) is asked for again
|
|
constexpr uint8_t MAX_FAILURES = 3; // a link that fails this often in a row is old: ask for a new one
|
|
constexpr uint32_t PENDING_MS = 20000; // an alert's camera announced this long before the alert still belongs to it
|
|
|
|
struct Feed {
|
|
std::string entity, url;
|
|
uint32_t asked_at = 0, started_at = 0, finished_at = 0;
|
|
bool asked = false, loading = false, shown = false, empty = false; // empty: the app said it has no image
|
|
// once (firmware 0.2.64+): an album cover on the media card. It loads one time per link and stays; a new cover comes
|
|
// with a new link (the card asks again when Home Assistant's picture changes), never on a clock.
|
|
bool once = false, loaded = false; // loaded: this link's image is on screen
|
|
// every (firmware 0.2.77+): the live pictures on a page's camera tiles load at their own pace, 15 or 30 s, where the
|
|
// camera full screen keeps REFRESH_MS.
|
|
uint32_t every = REFRESH_MS;
|
|
uint8_t failures = 0;
|
|
|
|
void open(const std::string &camera, bool one_load = false, uint32_t every_ms = REFRESH_MS) { *this = Feed{}; entity = camera; once = one_load; every = every_ms; }
|
|
bool open() const { return !entity.empty(); }
|
|
// A cover the app has none of (or an app that knows no covers) is asked for once: the card keeps its placeholder.
|
|
// A feed whose app has no picture asks again at its own pace, never sooner than ASK_AGAIN_MS.
|
|
bool should_ask(uint32_t now) const {
|
|
if (once && empty) return false;
|
|
const uint32_t again = empty && every > ASK_AGAIN_MS ? every : ASK_AGAIN_MS;
|
|
return open() && !loading && url.empty() && (!asked || now - asked_at >= again);
|
|
}
|
|
void ask(uint32_t now) { asked = true; asked_at = now; }
|
|
// The app's answer: a link, or none (no image from Home Assistant, or a camera this screen may not show).
|
|
void link(const std::string &address) {
|
|
url = address;
|
|
empty = address.empty();
|
|
failures = 0;
|
|
started_at = finished_at = 0;
|
|
loaded = false;
|
|
}
|
|
bool should_load(uint32_t now) const {
|
|
if (!open() || loading || url.empty()) return false;
|
|
if (!started_at) return true;
|
|
if (once) return !loaded && now - finished_at >= GAP_MS; // a failed load is tried again, a loaded one stays
|
|
return now - started_at >= every && now - finished_at >= GAP_MS;
|
|
}
|
|
void start(uint32_t now) { loading = true; started_at = now ? now : 1; }
|
|
void finish(uint32_t now, bool ok) {
|
|
loading = false;
|
|
finished_at = now;
|
|
if (ok) { shown = true; loaded = true; failures = 0; return; }
|
|
if (++failures >= MAX_FAILURES) { url.clear(); asked = false; failures = 0; }
|
|
}
|
|
};
|
|
} // namespace camera_view
|