Show who is at the door: camera images on the Guition (0.2.66)

An alert from esp_screens_show_alert takes a `camera` (a camera.* or image.* entity): a Guition with firmware
0.2.57 shows that moment's picture across the top of the card, and a tap opens the camera full screen. A camera
or image tile opens the same full-screen view, refreshed every four seconds at a steady pace.

ESP Screen Manager fetches the snapshot with its own access, sizes it for the screen and serves a 24-bit BMP
under a random, short-lived link on port 8098; the screen loads it with ESPHome's online_image and holds no
Home Assistant token. BMP because ESPHome decodes it per chunk, where a full-screen JPEG held the loop 0.6 s.
The CYD keeps its alerts without the picture and gets no camera tiles.

The Guition also builds with ESPHome 2026.8+ again: backlight_fade.h derived from ESPHome's LEDC output, which
2026.8 made final, so the backlight now dims through ESPHome's own light transition.

Tested on the bench boards and a local add-on on the Home Assistant Yellow; docs/TEST_RESULTS_0266.md.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

components/smart_display/camera_view.h

@@ -0,0 +1,50 @@
+#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
+  uint8_t failures = 0;
+
+  void open(const std::string &camera) { *this = Feed{}; entity = camera; }
+  bool open() const { return !entity.empty(); }
+  bool should_ask(uint32_t now) const { return open() && !loading && url.empty() && (!asked || now - asked_at >= ASK_AGAIN_MS); }
+  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;
+  }
+  bool should_load(uint32_t now) const {
+    if (!open() || loading || url.empty()) return false;
+    if (!started_at) return true;
+    return now - started_at >= REFRESH_MS && 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; failures = 0; return; }
+    if (++failures >= MAX_FAILURES) { url.clear(); asked = false; failures = 0; }
+  }
+};
+}  // namespace camera_view