Power button short press when sleeping refreshes TRMNL

CHANGELOG.md

@@ -93,6 +93,7 @@
 - File Browser long-press folder action for choosing a custom sleep-image folder instead of only `/.sleep` or `/sleep`.
 - Expanded X3 Reading Stats, including streaks, time charts, editable dates, all-time backups, reset controls, an idle-time threshold, and the `Minimal Stats` sleep screen.
 - `Reset Reading Pace` in the EPUB reader menu when Time Left is enabled, for clearing only the time-left pace estimate while keeping book reading stats.
+- Added TRMNL as a sleep-screen wallpaper source with configurable server, API key, device ID, and orientation.
 
 ### Changed
 - Display, Reader, and Controls settings now open list menus instead of cycling through options one by one.

lib/I18n/translations/english.yaml

@@ -6,6 +6,7 @@ STR_CROSSINK: "CrossInk"
 STR_BOOTING: "BOOTING"
 STR_SLEEPING: "SLEEPING"
 STR_ENTERING_SLEEP: "Going to sleep"
+STR_REFRESHING: "Refreshing"
 STR_BROWSE_FILES: "Browse Files"
 STR_BROWSE: "Browse"
 STR_FILE_TRANSFER: "File Transfer"
@@ -342,6 +343,18 @@ STR_THEME_MINIMAL: "Minimal"
 STR_THEME_DASHBOARD: "Dashboard"
 STR_THEME_MINIMAL_STATS: "Minimal Stats"
 STR_QUICK_RESUME: "Quick Resume"
+STR_TRMNL: "TRMNL"
+STR_TRMNL_SETTINGS: "TRMNL Settings"
+STR_TRMNL_SERVER_URL: "TRMNL Server URL"
+STR_TRMNL_API_KEY: "TRMNL API Key"
+STR_TRMNL_DEVICE_ID: "TRMNL Device ID"
+STR_TRMNL_ORIENTATION: "TRMNL Orientation"
+STR_TRMNL_HORIZONTAL: "Horizontal"
+STR_TRMNL_VERTICAL: "Vertical"
+STR_TRMNL_FETCH_FAILED: "TRMNL fetch failed"
+STR_TRMNL_REFRESH_ON_POWER_BUTTON: "Refresh on Power Button"
+STR_TRMNL_REFRESH_HINT_1: "Short press power to refresh"
+STR_TRMNL_REFRESH_HINT_2: "Long press power to wake up"
 STR_RECENT_BOOKS_VIEW: "Recent Books View"
 STR_LIST_VIEW: "List"
 STR_GRID_VIEW: "Grid"

lib/JsonParser/TrmnlDisplayJsonParser.cpp

@@ -0,0 +1,88 @@
+#include "TrmnlDisplayJsonParser.h"
+
+#include <cstdlib>
+#include <cstring>
+
+namespace {
+void safeCopy(char* dst, const size_t dstSize, const char* src, const size_t srcLen) {
+  const size_t n = srcLen < dstSize - 1 ? srcLen : dstSize - 1;
+  memcpy(dst, src, n);
+  dst[n] = '\0';
+}
+}  // namespace
+
+TrmnlDisplayJsonParser::TrmnlDisplayJsonParser()
+    : parser(JsonCallbacks{this, sOnKey, sOnString, sOnNumber, sOnBool, sOnNull, sOnObjectStart, sOnObjectEnd,
+                           sOnArrayStart, sOnArrayEnd}) {
+  reset();
+}
+
+void TrmnlDisplayJsonParser::reset() {
+  parser.reset();
+  lastKey = LastKey::NONE;
+  depth = 0;
+  imageUrl[0] = '\0';
+  filename[0] = '\0';
+  refreshRateSeconds = 0;
+  imageUrlFound = false;
+}
+
+void TrmnlDisplayJsonParser::feed(const char* data, const size_t len) { parser.feed(data, len); }
+bool TrmnlDisplayJsonParser::foundImageUrl() const { return imageUrlFound; }
+bool TrmnlDisplayJsonParser::hasError() const { return parser.hasError(); }
+const char* TrmnlDisplayJsonParser::getImageUrl() const { return imageUrl; }
+const char* TrmnlDisplayJsonParser::getFilename() const { return filename; }
+uint32_t TrmnlDisplayJsonParser::getRefreshRateSeconds() const { return refreshRateSeconds; }
+
+void TrmnlDisplayJsonParser::sOnKey(void* ctx, const char* key, const size_t len) {
+  auto* self = static_cast<TrmnlDisplayJsonParser*>(ctx);
+  if (self->depth != 1) {
+    self->lastKey = LastKey::NONE;
+    return;
+  }
+  if (len == 9 && memcmp(key, "image_url", 9) == 0) {
+    self->lastKey = LastKey::IMAGE_URL;
+  } else if ((len == 8 && memcmp(key, "filename", 8) == 0) || (len == 10 && memcmp(key, "image_name", 10) == 0)) {
+    self->lastKey = LastKey::FILENAME;
+  } else if (len == 12 && memcmp(key, "refresh_rate", 12) == 0) {
+    self->lastKey = LastKey::REFRESH_RATE;
+  } else {
+    self->lastKey = LastKey::NONE;
+  }
+}
+
+void TrmnlDisplayJsonParser::sOnString(void* ctx, const char* value, const size_t len) {
+  auto* self = static_cast<TrmnlDisplayJsonParser*>(ctx);
+  if (self->depth == 1 && self->lastKey == LastKey::IMAGE_URL) {
+    safeCopy(self->imageUrl, sizeof(self->imageUrl), value, len);
+    self->imageUrlFound = self->imageUrl[0] != '\0';
+  } else if (self->depth == 1 && self->lastKey == LastKey::FILENAME) {
+    safeCopy(self->filename, sizeof(self->filename), value, len);
+  }
+  self->lastKey = LastKey::NONE;
+}
+
+void TrmnlDisplayJsonParser::sOnNumber(void* ctx, const char* value, const size_t /*len*/) {
+  auto* self = static_cast<TrmnlDisplayJsonParser*>(ctx);
+  if (self->depth == 1 && self->lastKey == LastKey::REFRESH_RATE) {
+    self->refreshRateSeconds = static_cast<uint32_t>(strtoul(value, nullptr, 10));
+  }
+  self->lastKey = LastKey::NONE;
+}
+
+void TrmnlDisplayJsonParser::sOnBool(void* ctx, bool /*value*/) {
+  static_cast<TrmnlDisplayJsonParser*>(ctx)->lastKey = LastKey::NONE;
+}
+void TrmnlDisplayJsonParser::sOnNull(void* ctx) { static_cast<TrmnlDisplayJsonParser*>(ctx)->lastKey = LastKey::NONE; }
+void TrmnlDisplayJsonParser::sOnObjectStart(void* ctx) {
+  auto* self = static_cast<TrmnlDisplayJsonParser*>(ctx);
+  self->depth++;
+  self->lastKey = LastKey::NONE;
+}
+void TrmnlDisplayJsonParser::sOnObjectEnd(void* ctx) {
+  auto* self = static_cast<TrmnlDisplayJsonParser*>(ctx);
+  if (self->depth > 0) self->depth--;
+  self->lastKey = LastKey::NONE;
+}
+void TrmnlDisplayJsonParser::sOnArrayStart(void* ctx) { sOnObjectStart(ctx); }
+void TrmnlDisplayJsonParser::sOnArrayEnd(void* ctx) { sOnObjectEnd(ctx); }

lib/JsonParser/TrmnlDisplayJsonParser.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "StreamingJsonParser.h"
+
+class TrmnlDisplayJsonParser {
+ public:
+  TrmnlDisplayJsonParser();
+  void reset();
+  void feed(const char* data, size_t len);
+
+  bool foundImageUrl() const;
+  bool hasError() const;
+  const char* getImageUrl() const;
+  const char* getFilename() const;
+  uint32_t getRefreshRateSeconds() const;
+
+ private:
+  enum class LastKey : uint8_t { NONE, IMAGE_URL, FILENAME, REFRESH_RATE };
+
+  static void sOnKey(void* ctx, const char* key, size_t len);
+  static void sOnString(void* ctx, const char* value, size_t len);
+  static void sOnNumber(void* ctx, const char* value, size_t len);
+  static void sOnBool(void* ctx, bool value);
+  static void sOnNull(void* ctx);
+  static void sOnObjectStart(void* ctx);
+  static void sOnObjectEnd(void* ctx);
+  static void sOnArrayStart(void* ctx);
+  static void sOnArrayEnd(void* ctx);
+
+  StreamingJsonParser parser;
+  LastKey lastKey = LastKey::NONE;
+  uint16_t depth = 0;
+  char imageUrl[512] = "";
+  char filename[128] = "";
+  uint32_t refreshRateSeconds = 0;
+  bool imageUrlFound = false;
+};

lib/hal/HalGPIO.cpp

@@ -249,10 +249,16 @@ void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPre
   }
   // TODO: Intermittent edge case remains: a single tap followed by another single tap
   // can still power on the device. Tighten wake debounce/state handling here.
+  if (measurePowerButtonPressWasShort(requiredDurationMs)) {
+    startDeepSleep();
+  }
+}
 
+bool HalGPIO::measurePowerButtonPressWasShort(uint16_t longPressDurationMs) {
   // Calibrate: subtract boot time already elapsed, assuming button held since boot
   const uint16_t calibration = millis();
-  const uint16_t calibratedDuration = (calibration < requiredDurationMs) ? (requiredDurationMs - calibration) : 1;
+  const uint16_t calibratedDuration =
+      (calibration < longPressDurationMs) ? (longPressDurationMs - calibration) : 1;
 
   const auto start = millis();
   inputMgr.update();
@@ -261,17 +267,15 @@ void HalGPIO::verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPre
     delay(10);
     inputMgr.update();
   }
-  if (inputMgr.isPressed(BTN_POWER)) {
-    do {
-      delay(10);
-      inputMgr.update();
-    } while (inputMgr.isPressed(BTN_POWER) && inputMgr.getPowerButtonHeldTime() < calibratedDuration);
-    if (inputMgr.getPowerButtonHeldTime() < calibratedDuration) {
-      startDeepSleep();
-    }
-  } else {
-    startDeepSleep();
+  if (!inputMgr.isPressed(BTN_POWER)) {
+    // Never registered as pressed (already released) -- treat as short.
+    return true;
   }
+  do {
+    delay(10);
+    inputMgr.update();
+  } while (inputMgr.isPressed(BTN_POWER) && inputMgr.getPowerButtonHeldTime() < calibratedDuration);
+  return inputMgr.getPowerButtonHeldTime() < calibratedDuration;
 }
 
 bool HalGPIO::isUsbConnected() const {

lib/hal/HalGPIO.h

@@ -80,6 +80,13 @@ class HalGPIO {
   // Should only be called when wakeup reason is PowerButton.
   void verifyPowerButtonWakeup(uint16_t requiredDurationMs, bool shortPressAllowed);
 
+  // Measures the power-button press that caused a PowerButton wakeup and reports
+  // whether it was short (released before longPressDurationMs) or long. Unlike
+  // verifyPowerButtonWakeup, this never rejects the wakeup -- the caller decides
+  // what a short vs. long press means. Should only be called when wakeup reason
+  // is PowerButton.
+  bool measurePowerButtonPressWasShort(uint16_t longPressDurationMs);
+
   // Check if USB is connected
   bool isUsbConnected() const;
 

src/CrossPointSettings.cpp

@@ -47,6 +47,7 @@ constexpr uint8_t SLEEP_SCREEN_STORAGE_ORDER[] = {
     static_cast<uint8_t>(CrossPointSettings::QUICK_RESUME),
     static_cast<uint8_t>(CrossPointSettings::MINIMAL_STATS_SLEEP),
     static_cast<uint8_t>(CrossPointSettings::DASHBOARD_SLEEP),
+    static_cast<uint8_t>(CrossPointSettings::TRMNL),
 };
 constexpr uint8_t SLEEP_SCREEN_STORAGE_ORDER_COUNT =
     sizeof(SLEEP_SCREEN_STORAGE_ORDER) / sizeof(SLEEP_SCREEN_STORAGE_ORDER[0]);

src/CrossPointSettings.h

@@ -31,6 +31,7 @@ class CrossPointSettings {
     QUICK_RESUME = 9,
     MINIMAL_STATS_SLEEP = 10,
     DASHBOARD_SLEEP = 11,
+    TRMNL = 12,
     SLEEP_SCREEN_MODE_COUNT
   };
   enum SLEEP_SCREEN_COVER_MODE { FIT = 0, CROP = 1, SLEEP_SCREEN_COVER_MODE_COUNT };
@@ -40,6 +41,7 @@ class CrossPointSettings {
     INVERTED_BLACK_AND_WHITE = 2,
     SLEEP_SCREEN_COVER_FILTER_COUNT
   };
+  enum TRMNL_ORIENTATION { TRMNL_LANDSCAPE = 0, TRMNL_PORTRAIT = 1, TRMNL_ORIENTATION_COUNT };
 
   // Status bar enum - legacy
   enum STATUS_BAR_MODE {
@@ -387,6 +389,14 @@ class CrossPointSettings {
   char opdsServerUrl[128] = "";
   char opdsUsername[64] = "";
   char opdsPassword[64] = "";
+  char trmnlServerUrl[160] = "";
+  char trmnlApiKey[128] = "";
+  char trmnlDeviceId[32] = "";
+  uint8_t trmnlOrientation = TRMNL_LANDSCAPE;
+  // Short-pressing the power button while asleep with the TRMNL sleep screen
+  // active refreshes it in place instead of the default wake behavior. Off by
+  // default -- opt in per-device.
+  uint8_t trmnlRefreshOnPowerButton = 0;
   // Hide battery percentage
   uint8_t hideBatteryPercentage = HIDE_NEVER;
   // Long-press page turn button behavior

src/GlobalActions.h

@@ -33,4 +33,4 @@ inline bool isPowerButtonActionAvailableOutsideReader(const CrossPointSettings::
   }
 }
 
-void enterDeepSleep(bool fromTimeout = false);
+void enterDeepSleep(bool fromTimeout = false, bool isPowerButtonRefresh = false);

src/SettingsList.h

@@ -240,7 +240,7 @@ inline SettingInfo buildSleepScreenSetting() {
       StrId::STR_SLEEP_SCREEN, &CrossPointSettings::sleepScreen,
       {StrId::STR_NONE_OPT, StrId::STR_DARK, StrId::STR_LIGHT, StrId::STR_CUSTOM, StrId::STR_COVER,
        StrId::STR_COVER_CUSTOM, StrId::STR_PAGE_OVERLAY, StrId::STR_READING_STATS, StrId::STR_THEME_MINIMAL,
-       StrId::STR_THEME_MINIMAL_STATS, StrId::STR_THEME_DASHBOARD, StrId::STR_QUICK_RESUME},
+       StrId::STR_THEME_MINIMAL_STATS, StrId::STR_THEME_DASHBOARD, StrId::STR_TRMNL, StrId::STR_QUICK_RESUME},
       "sleepScreen", StrId::STR_CAT_DISPLAY);
   s.withEnumRawValues({
       static_cast<uint8_t>(CrossPointSettings::BLANK),
@@ -254,7 +254,9 @@ inline SettingInfo buildSleepScreenSetting() {
       static_cast<uint8_t>(CrossPointSettings::MINIMAL_SLEEP),
       static_cast<uint8_t>(CrossPointSettings::MINIMAL_STATS_SLEEP),
       static_cast<uint8_t>(CrossPointSettings::DASHBOARD_SLEEP),
+      static_cast<uint8_t>(CrossPointSettings::TRMNL),
       static_cast<uint8_t>(CrossPointSettings::QUICK_RESUME),
+      static_cast<uint8_t>(CrossPointSettings::TRMNL),
   });
   return s;
 }
@@ -587,6 +589,18 @@ inline std::vector<SettingInfo> getSettingsList(const SdCardFontRegistry* regist
     add(SettingInfo::Toggle(StrId::STR_TRACK_READING_STATS, &CrossPointSettings::trackReadingStats, "trackReadingStats",
                             StrId::STR_CAT_SYSTEM));
 #endif
+    add(SettingInfo::String(StrId::STR_TRMNL_SERVER_URL, SETTINGS.trmnlServerUrl, sizeof(SETTINGS.trmnlServerUrl),
+                            "trmnlServerUrl", StrId::STR_TRMNL_SETTINGS));
+    add(SettingInfo::String(StrId::STR_TRMNL_API_KEY, SETTINGS.trmnlApiKey, sizeof(SETTINGS.trmnlApiKey),
+                            "trmnlApiKey", StrId::STR_TRMNL_SETTINGS)
+            .withObfuscated());
+    add(SettingInfo::String(StrId::STR_TRMNL_DEVICE_ID, SETTINGS.trmnlDeviceId, sizeof(SETTINGS.trmnlDeviceId),
+                            "trmnlDeviceId", StrId::STR_TRMNL_SETTINGS));
+    add(SettingInfo::Enum(StrId::STR_TRMNL_ORIENTATION, &CrossPointSettings::trmnlOrientation,
+                          {StrId::STR_TRMNL_HORIZONTAL, StrId::STR_TRMNL_VERTICAL}, "trmnlOrientation",
+                          StrId::STR_TRMNL_SETTINGS));
+    add(SettingInfo::Toggle(StrId::STR_TRMNL_REFRESH_ON_POWER_BUTTON, &CrossPointSettings::trmnlRefreshOnPowerButton,
+                            "trmnlRefreshOnPowerButton", StrId::STR_TRMNL_SETTINGS));
 
     // --- KOReader Sync (web-only, uses KOReaderCredentialStore) ---
     add(SettingInfo::DynamicString(
@@ -914,11 +928,12 @@ inline std::vector<SettingInfo> buildDisplaySleepSettingsList(const std::vector<
 
 inline std::vector<SettingInfo> buildSystemSettingsParentList(const std::vector<SettingInfo>& allSettings) {
   std::vector<SettingInfo> systemSettings;
-  systemSettings.reserve(8);
+  systemSettings.reserve(9);
   systemSettings.push_back(SettingInfo::Submenu(StrId::STR_SYSTEM_DEVICE, SettingAction::SystemDevice));
   systemSettings.push_back(SettingInfo::Submenu(StrId::STR_SYSTEM_FILES_CACHE, SettingAction::SystemFilesCache));
   systemSettings.push_back(SettingInfo::Submenu(StrId::STR_READING_STATS, SettingAction::SystemReadingStats));
   systemSettings.push_back(SettingInfo::Action(StrId::STR_WIFI_NETWORKS, SettingAction::Network));
+  systemSettings.push_back(SettingInfo::Action(StrId::STR_TRMNL_SETTINGS, SettingAction::TrmnlSettings));
   systemSettings.push_back(SettingInfo::Action(StrId::STR_KOREADER_SYNC, SettingAction::KOReaderSync));
   systemSettings.push_back(SettingInfo::Action(StrId::STR_OPDS_SERVERS, SettingAction::OPDSBrowser));
   systemSettings.push_back(SettingInfo::Action(StrId::STR_CHECK_UPDATES, SettingAction::CheckForUpdates));

src/activities/ActivityManager.cpp

@@ -237,10 +237,10 @@ void ActivityManager::goToReader(std::string path, const bool suppressBackReleas
   replaceActivity(std::make_unique<ReaderActivity>(renderer, mappedInput, std::move(path), suppressBackRelease));
 }
 
-void ActivityManager::goToSleep(bool fromTimeout) {
+void ActivityManager::goToSleep(bool fromTimeout, bool isPowerButtonRefresh) {
   const bool canSnapshotOverlay = currentActivity && currentActivity->canSnapshotForSleepOverlay();
-  replaceActivity(
-      std::make_unique<SleepActivity>(renderer, mappedInput, canSnapshotOverlay, getCurrentBookPath(), fromTimeout));
+  replaceActivity(std::make_unique<SleepActivity>(renderer, mappedInput, canSnapshotOverlay, getCurrentBookPath(),
+                                                  fromTimeout, isPowerButtonRefresh));
   loop();  // Important: sleep screen must be rendered immediately, the caller will go to sleep right after this returns
 }
 

src/activities/ActivityManager.h

@@ -99,7 +99,7 @@ class ActivityManager {
   void goToRecentBooks();
   void goToBrowser();
   void goToReader(std::string path, bool suppressBackRelease = false);
-  void goToSleep(bool fromTimeout = false);
+  void goToSleep(bool fromTimeout = false, bool isPowerButtonRefresh = false);
   void goToBoot();
   void goToFullScreenMessage(std::string message, EpdFontFamily::Style style = EpdFontFamily::REGULAR);
   void goToCrashReport();