Merge branch 'master' of github.com:daveallie/crosspoint-reader into feat/recent-books

src/CrossPointSettings.cpp

@@ -4,6 +4,8 @@
 #include <SDCardManager.h>
 #include <Serialization.h>
 
+#include <cstring>
+
 #include "fontIds.h"
 
 // Initialize the static instance
@@ -12,7 +14,7 @@ CrossPointSettings CrossPointSettings::instance;
 namespace {
 constexpr uint8_t SETTINGS_FILE_VERSION = 1;
 // Increment this when adding new persisted settings fields
-constexpr uint8_t SETTINGS_COUNT = 13;
+constexpr uint8_t SETTINGS_COUNT = 17;
 constexpr char SETTINGS_FILE[] = "/.crosspoint/settings.bin";
 }  // namespace
 
@@ -40,6 +42,11 @@ bool CrossPointSettings::saveToFile() const {
   serialization::writePod(outputFile, paragraphAlignment);
   serialization::writePod(outputFile, sleepTimeout);
   serialization::writePod(outputFile, refreshFrequency);
+  serialization::writePod(outputFile, screenMargin);
+  serialization::writePod(outputFile, sleepScreenCoverMode);
+  serialization::writeString(outputFile, std::string(opdsServerUrl));
+  serialization::writePod(outputFile, textAntiAliasing);
+  serialization::writePod(outputFile, hideBatteryPercentage);
   outputFile.close();
 
   Serial.printf("[%lu] [CPS] Settings saved to file\n", millis());
@@ -92,6 +99,20 @@ bool CrossPointSettings::loadFromFile() {
     if (++settingsRead >= fileSettingsCount) break;
     serialization::readPod(inputFile, refreshFrequency);
     if (++settingsRead >= fileSettingsCount) break;
+    serialization::readPod(inputFile, screenMargin);
+    if (++settingsRead >= fileSettingsCount) break;
+    serialization::readPod(inputFile, sleepScreenCoverMode);
+    if (++settingsRead >= fileSettingsCount) break;
+    {
+      std::string urlStr;
+      serialization::readString(inputFile, urlStr);
+      strncpy(opdsServerUrl, urlStr.c_str(), sizeof(opdsServerUrl) - 1);
+      opdsServerUrl[sizeof(opdsServerUrl) - 1] = '\0';
+    }
+    serialization::readPod(inputFile, textAntiAliasing);
+    if (++settingsRead >= fileSettingsCount) break;
+    serialization::readPod(inputFile, hideBatteryPercentage);
+    if (++settingsRead >= fileSettingsCount) break;
   } while (false);
 
   inputFile.close();

src/CrossPointSettings.h

@@ -16,7 +16,8 @@ class CrossPointSettings {
   CrossPointSettings& operator=(const CrossPointSettings&) = delete;
 
   // Should match with SettingsActivity text
-  enum SLEEP_SCREEN_MODE { DARK = 0, LIGHT = 1, CUSTOM = 2, COVER = 3 };
+  enum SLEEP_SCREEN_MODE { DARK = 0, LIGHT = 1, CUSTOM = 2, COVER = 3, BLANK = 4 };
+  enum SLEEP_SCREEN_COVER_MODE { FIT = 0, CROP = 1 };
 
   // Status bar display type enum
   enum STATUS_BAR_MODE { NONE = 0, NO_PROGRESS = 1, FULL = 2 };
@@ -51,14 +52,23 @@ class CrossPointSettings {
   // E-ink refresh frequency (pages between full refreshes)
   enum REFRESH_FREQUENCY { REFRESH_1 = 0, REFRESH_5 = 1, REFRESH_10 = 2, REFRESH_15 = 3, REFRESH_30 = 4 };
 
+  // Short power button press actions
+  enum SHORT_PWRBTN { IGNORE = 0, SLEEP = 1, PAGE_TURN = 2 };
+
+  // Hide battery percentage
+  enum HIDE_BATTERY_PERCENTAGE { HIDE_NEVER = 0, HIDE_READER = 1, HIDE_ALWAYS = 2 };
+
   // Sleep screen settings
   uint8_t sleepScreen = DARK;
+  // Sleep screen cover mode settings
+  uint8_t sleepScreenCoverMode = FIT;
   // Status bar settings
   uint8_t statusBar = FULL;
   // Text rendering settings
   uint8_t extraParagraphSpacing = 1;
-  // Duration of the power button press
-  uint8_t shortPwrBtn = 0;
+  uint8_t textAntiAliasing = 1;
+  // Short power button click behaviour
+  uint8_t shortPwrBtn = IGNORE;
   // EPUB reading orientation settings
   // 0 = portrait (default), 1 = landscape clockwise, 2 = inverted, 3 = landscape counter-clockwise
   uint8_t orientation = PORTRAIT;
@@ -74,13 +84,21 @@ class CrossPointSettings {
   uint8_t sleepTimeout = SLEEP_10_MIN;
   // E-ink refresh frequency (default 15 pages)
   uint8_t refreshFrequency = REFRESH_15;
+  // Reader screen margin settings
+  uint8_t screenMargin = 5;
+  // OPDS browser settings
+  char opdsServerUrl[128] = "";
+  // Hide battery percentage
+  uint8_t hideBatteryPercentage = HIDE_NEVER;
 
   ~CrossPointSettings() = default;
 
   // Get singleton instance
   static CrossPointSettings& getInstance() { return instance; }
 
-  uint16_t getPowerButtonDuration() const { return shortPwrBtn ? 10 : 400; }
+  uint16_t getPowerButtonDuration() const {
+    return (shortPwrBtn == CrossPointSettings::SHORT_PWRBTN::SLEEP) ? 10 : 400;
+  }
   int getReaderFontId() const;
 
   bool saveToFile() const;

src/ScreenComponents.cpp

@@ -2,15 +2,18 @@
 
 #include <GfxRenderer.h>
 
+#include <cstdint>
 #include <string>
 
 #include "Battery.h"
 #include "fontIds.h"
 
-void ScreenComponents::drawBattery(const GfxRenderer& renderer, const int left, const int top) {
+void ScreenComponents::drawBattery(const GfxRenderer &renderer, const int left,
+                                   const int top, const bool showPercentage) {
   // Left aligned battery icon and percentage
   const uint16_t percentage = battery.readPercentage();
-  const auto percentageText = std::to_string(percentage) + "%";
+  const auto percentageText =
+      showPercentage ? std::to_string(percentage) + "%" : "";
   renderer.drawText(SMALL_FONT_ID, left + 20, top, percentageText.c_str());
 
   // 1 column on left, 2 columns on right, 5 columns of battery body
@@ -22,46 +25,53 @@ void ScreenComponents::drawBattery(const GfxRenderer& renderer, const int left,
   // Top line
   renderer.drawLine(x + 1, y, x + batteryWidth - 3, y);
   // Bottom line
-  renderer.drawLine(x + 1, y + batteryHeight - 1, x + batteryWidth - 3, y + batteryHeight - 1);
+  renderer.drawLine(x + 1, y + batteryHeight - 1, x + batteryWidth - 3,
+                    y + batteryHeight - 1);
   // Left line
   renderer.drawLine(x, y + 1, x, y + batteryHeight - 2);
   // Battery end
-  renderer.drawLine(x + batteryWidth - 2, y + 1, x + batteryWidth - 2, y + batteryHeight - 2);
+  renderer.drawLine(x + batteryWidth - 2, y + 1, x + batteryWidth - 2,
+                    y + batteryHeight - 2);
   renderer.drawPixel(x + batteryWidth - 1, y + 3);
   renderer.drawPixel(x + batteryWidth - 1, y + batteryHeight - 4);
-  renderer.drawLine(x + batteryWidth - 0, y + 4, x + batteryWidth - 0, y + batteryHeight - 5);
+  renderer.drawLine(x + batteryWidth - 0, y + 4, x + batteryWidth - 0,
+                    y + batteryHeight - 5);
 
   // The +1 is to round up, so that we always fill at least one pixel
   int filledWidth = percentage * (batteryWidth - 5) / 100 + 1;
   if (filledWidth > batteryWidth - 5) {
-    filledWidth = batteryWidth - 5;  // Ensure we don't overflow
+    filledWidth = batteryWidth - 5; // Ensure we don't overflow
   }
 
   renderer.fillRect(x + 2, y + 2, filledWidth, batteryHeight - 4);
 }
 
-int ScreenComponents::drawTabBar(const GfxRenderer& renderer, const int y, const std::vector<TabInfo>& tabs) {
-  constexpr int tabPadding = 20;      // Horizontal padding between tabs
-  constexpr int leftMargin = 20;      // Left margin for first tab
-  constexpr int underlineHeight = 2;  // Height of selection underline
-  constexpr int underlineGap = 4;     // Gap between text and underline
+int ScreenComponents::drawTabBar(const GfxRenderer &renderer, const int y,
+                                 const std::vector<TabInfo> &tabs) {
+  constexpr int tabPadding = 20;     // Horizontal padding between tabs
+  constexpr int leftMargin = 20;     // Left margin for first tab
+  constexpr int underlineHeight = 2; // Height of selection underline
+  constexpr int underlineGap = 4;    // Gap between text and underline
 
   const int lineHeight = renderer.getLineHeight(UI_12_FONT_ID);
   const int tabBarHeight = lineHeight + underlineGap + underlineHeight;
 
   int currentX = leftMargin;
 
-  for (const auto& tab : tabs) {
-    const int textWidth = renderer.getTextWidth(UI_12_FONT_ID, tab.label,
-                                                tab.selected ? EpdFontFamily::BOLD : EpdFontFamily::REGULAR);
+  for (const auto &tab : tabs) {
+    const int textWidth = renderer.getTextWidth(
+        UI_12_FONT_ID, tab.label,
+        tab.selected ? EpdFontFamily::BOLD : EpdFontFamily::REGULAR);
 
     // Draw tab label
     renderer.drawText(UI_12_FONT_ID, currentX, y, tab.label, true,
-                      tab.selected ? EpdFontFamily::BOLD : EpdFontFamily::REGULAR);
+                      tab.selected ? EpdFontFamily::BOLD
+                                   : EpdFontFamily::REGULAR);
 
     // Draw underline for selected tab
     if (tab.selected) {
-      renderer.fillRect(currentX, y + lineHeight + underlineGap, textWidth, underlineHeight);
+      renderer.fillRect(currentX, y + lineHeight + underlineGap, textWidth,
+                        underlineHeight);
     }
 
     currentX += textWidth + tabPadding;
@@ -70,10 +80,13 @@ int ScreenComponents::drawTabBar(const GfxRenderer& renderer, const int y, const
   return tabBarHeight;
 }
 
-void ScreenComponents::drawScrollIndicator(const GfxRenderer& renderer, const int currentPage, const int totalPages,
-                                           const int contentTop, const int contentHeight) {
+void ScreenComponents::drawScrollIndicator(const GfxRenderer &renderer,
+                                           const int currentPage,
+                                           const int totalPages,
+                                           const int contentTop,
+                                           const int contentHeight) {
   if (totalPages <= 1) {
-    return;  // No need for indicator if only one page
+    return; // No need for indicator if only one page
   }
 
   const int screenWidth = renderer.getScreenWidth();
@@ -89,22 +102,53 @@ void ScreenComponents::drawScrollIndicator(const GfxRenderer& renderer, const in
   for (int i = 0; i < arrowSize; ++i) {
     const int lineWidth = 1 + i * 2;
     const int startX = centerX - i;
-    renderer.drawLine(startX, indicatorTop + arrowSize - 1 - i, startX + lineWidth - 1, indicatorTop + arrowSize - 1 - i);
+    renderer.drawLine(startX, indicatorTop + arrowSize - 1 - i,
+                      startX + lineWidth - 1, indicatorTop + arrowSize - 1 - i);
   }
 
   // Draw down arrow (triangle pointing down)
   for (int i = 0; i < arrowSize; ++i) {
     const int lineWidth = 1 + i * 2;
     const int startX = centerX - i;
-    renderer.drawLine(startX, indicatorBottom - arrowSize + 1 + i, startX + lineWidth - 1,
+    renderer.drawLine(startX, indicatorBottom - arrowSize + 1 + i,
+                      startX + lineWidth - 1,
                       indicatorBottom - arrowSize + 1 + i);
   }
 
   // Draw page fraction in the middle (e.g., "1/3")
-  const std::string pageText = std::to_string(currentPage) + "/" + std::to_string(totalPages);
+  const std::string pageText =
+      std::to_string(currentPage) + "/" + std::to_string(totalPages);
   const int textWidth = renderer.getTextWidth(SMALL_FONT_ID, pageText.c_str());
   const int textX = centerX - textWidth / 2;
-  const int textY = (indicatorTop + indicatorBottom) / 2 - renderer.getLineHeight(SMALL_FONT_ID) / 2;
+  const int textY = (indicatorTop + indicatorBottom) / 2 -
+                    renderer.getLineHeight(SMALL_FONT_ID) / 2;
 
   renderer.drawText(SMALL_FONT_ID, textX, textY, pageText.c_str());
 }
+
+void ScreenComponents::drawProgressBar(const GfxRenderer &renderer, const int x,
+                                       const int y, const int width,
+                                       const int height, const size_t current,
+                                       const size_t total) {
+  if (total == 0) {
+    return;
+  }
+
+  // Use 64-bit arithmetic to avoid overflow for large files
+  const int percent =
+      static_cast<int>((static_cast<uint64_t>(current) * 100) / total);
+
+  // Draw outline
+  renderer.drawRect(x, y, width, height);
+
+  // Draw filled portion
+  const int fillWidth = (width - 4) * percent / 100;
+  if (fillWidth > 0) {
+    renderer.fillRect(x + 2, y + 2, fillWidth, height - 4);
+  }
+
+  // Draw percentage text centered below bar
+  const std::string percentText = std::to_string(percent) + "%";
+  renderer.drawCenteredText(UI_10_FONT_ID, y + height + 15,
+                            percentText.c_str());
+}

src/ScreenComponents.h

@@ -1,24 +1,43 @@
 #pragma once
 
+#include <cstddef>
+#include <cstdint>
 #include <vector>
 
 class GfxRenderer;
 
 struct TabInfo {
-  const char* label;
+  const char *label;
   bool selected;
 };
 
 class ScreenComponents {
- public:
-  static void drawBattery(const GfxRenderer& renderer, int left, int top);
+public:
+  static void drawBattery(const GfxRenderer &renderer, int left, int top,
+                          bool showPercentage = true);
 
   // Draw a horizontal tab bar with underline indicator for selected tab
   // Returns the height of the tab bar (for positioning content below)
-  static int drawTabBar(const GfxRenderer& renderer, int y, const std::vector<TabInfo>& tabs);
+  static int drawTabBar(const GfxRenderer &renderer, int y,
+                        const std::vector<TabInfo> &tabs);
 
   // Draw a scroll/page indicator on the right side of the screen
   // Shows up/down arrows and current page fraction (e.g., "1/3")
-  static void drawScrollIndicator(const GfxRenderer& renderer, int currentPage, int totalPages, int contentTop,
+  static void drawScrollIndicator(const GfxRenderer &renderer, int currentPage,
+                                  int totalPages, int contentTop,
                                   int contentHeight);
+
+  /**
+   * Draw a progress bar with percentage text.
+   * @param renderer The graphics renderer
+   * @param x Left position of the bar
+   * @param y Top position of the bar
+   * @param width Width of the bar
+   * @param height Height of the bar
+   * @param current Current progress value
+   * @param total Total value for 100% progress
+   */
+  static void drawProgressBar(const GfxRenderer &renderer, int x, int y,
+                              int width, int height, size_t current,
+                              size_t total);
 };

src/activities/boot_sleep/SleepActivity.cpp

@@ -9,25 +9,16 @@
 #include "CrossPointState.h"
 #include "fontIds.h"
 #include "images/CrossLarge.h"
-
-namespace {
-// Check if path has XTC extension (.xtc or .xtch)
-bool isXtcFile(const std::string& path) {
-  if (path.length() < 4) return false;
-  std::string ext4 = path.substr(path.length() - 4);
-  if (ext4 == ".xtc") return true;
-  if (path.length() >= 5) {
-    std::string ext5 = path.substr(path.length() - 5);
-    if (ext5 == ".xtch") return true;
-  }
-  return false;
-}
-}  // namespace
+#include "util/StringUtils.h"
 
 void SleepActivity::onEnter() {
   Activity::onEnter();
   renderPopup("Entering Sleep...");
 
+  if (SETTINGS.sleepScreen == CrossPointSettings::SLEEP_SCREEN_MODE::BLANK) {
+    return renderBlankSleepScreen();
+  }
+
   if (SETTINGS.sleepScreen == CrossPointSettings::SLEEP_SCREEN_MODE::CUSTOM) {
     return renderCustomSleepScreen();
   }
@@ -58,7 +49,7 @@ void SleepActivity::renderCustomSleepScreen() const {
   auto dir = SdMan.open("/sleep");
   if (dir && dir.isDirectory()) {
     std::vector<std::string> files;
-    char name[128];
+    char name[500];
     // collect all valid BMP files
     for (auto file = dir.openNextFile(); file; file = dir.openNextFile()) {
       if (file.isDirectory()) {
@@ -95,7 +86,7 @@ void SleepActivity::renderCustomSleepScreen() const {
       if (SdMan.openFileForRead("SLP", filename, file)) {
         Serial.printf("[%lu] [SLP] Randomly loading: /sleep/%s\n", millis(), files[randomFileIndex].c_str());
         delay(100);
-        Bitmap bitmap(file);
+        Bitmap bitmap(file, true);
         if (bitmap.parseHeaders() == BmpReaderError::Ok) {
           renderBitmapSleepScreen(bitmap);
           dir.close();
@@ -110,7 +101,7 @@ void SleepActivity::renderCustomSleepScreen() const {
   // render a custom sleep screen instead of the default.
   FsFile file;
   if (SdMan.openFileForRead("SLP", "/sleep.bmp", file)) {
-    Bitmap bitmap(file);
+    Bitmap bitmap(file, true);
     if (bitmap.parseHeaders() == BmpReaderError::Ok) {
       Serial.printf("[%lu] [SLP] Loading: /sleep.bmp\n", millis());
       renderBitmapSleepScreen(bitmap);
@@ -142,20 +133,36 @@ void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
   int x, y;
   const auto pageWidth = renderer.getScreenWidth();
   const auto pageHeight = renderer.getScreenHeight();
+  float cropX = 0, cropY = 0;
 
+  Serial.printf("[%lu] [SLP] bitmap %d x %d, screen %d x %d\n", millis(), bitmap.getWidth(), bitmap.getHeight(),
+                pageWidth, pageHeight);
   if (bitmap.getWidth() > pageWidth || bitmap.getHeight() > pageHeight) {
     // image will scale, make sure placement is right
-    const float ratio = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
+    float ratio = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
     const float screenRatio = static_cast<float>(pageWidth) / static_cast<float>(pageHeight);
 
+    Serial.printf("[%lu] [SLP] bitmap ratio: %f, screen ratio: %f\n", millis(), ratio, screenRatio);
     if (ratio > screenRatio) {
       // image wider than viewport ratio, scaled down image needs to be centered vertically
+      if (SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP) {
+        cropX = 1.0f - (screenRatio / ratio);
+        Serial.printf("[%lu] [SLP] Cropping bitmap x: %f\n", millis(), cropX);
+        ratio = (1.0f - cropX) * static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
+      }
       x = 0;
-      y = (pageHeight - pageWidth / ratio) / 2;
+      y = std::round((static_cast<float>(pageHeight) - static_cast<float>(pageWidth) / ratio) / 2);
+      Serial.printf("[%lu] [SLP] Centering with ratio %f to y=%d\n", millis(), ratio, y);
     } else {
       // image taller than viewport ratio, scaled down image needs to be centered horizontally
-      x = (pageWidth - pageHeight * ratio) / 2;
+      if (SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP) {
+        cropY = 1.0f - (ratio / screenRatio);
+        Serial.printf("[%lu] [SLP] Cropping bitmap y: %f\n", millis(), cropY);
+        ratio = static_cast<float>(bitmap.getWidth()) / ((1.0f - cropY) * static_cast<float>(bitmap.getHeight()));
+      }
+      x = std::round((pageWidth - pageHeight * ratio) / 2);
       y = 0;
+      Serial.printf("[%lu] [SLP] Centering with ratio %f to x=%d\n", millis(), ratio, x);
     }
   } else {
     // center the image
@@ -163,21 +170,22 @@ void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
     y = (pageHeight - bitmap.getHeight()) / 2;
   }
 
+  Serial.printf("[%lu] [SLP] drawing to %d x %d\n", millis(), x, y);
   renderer.clearScreen();
-  renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
+  renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight, cropX, cropY);
   renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
 
   if (bitmap.hasGreyscale()) {
     bitmap.rewindToData();
     renderer.clearScreen(0x00);
     renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
-    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
+    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight, cropX, cropY);
     renderer.copyGrayscaleLsbBuffers();
 
     bitmap.rewindToData();
     renderer.clearScreen(0x00);
     renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
-    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight);
+    renderer.drawBitmap(bitmap, x, y, pageWidth, pageHeight, cropX, cropY);
     renderer.copyGrayscaleMsbBuffers();
 
     renderer.displayGrayBuffer();
@@ -191,9 +199,10 @@ void SleepActivity::renderCoverSleepScreen() const {
   }
 
   std::string coverBmpPath;
+  bool cropped = SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP;
 
-  // Check if the current book is XTC or EPUB
-  if (isXtcFile(APP_STATE.openEpubPath)) {
+  if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtc") ||
+      StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtch")) {
     // Handle XTC file
     Xtc lastXtc(APP_STATE.openEpubPath, "/.crosspoint");
     if (!lastXtc.load()) {
@@ -207,7 +216,7 @@ void SleepActivity::renderCoverSleepScreen() const {
     }
 
     coverBmpPath = lastXtc.getCoverBmpPath();
-  } else {
+  } else if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".epub")) {
     // Handle EPUB file
     Epub lastEpub(APP_STATE.openEpubPath, "/.crosspoint");
     if (!lastEpub.load()) {
@@ -215,12 +224,14 @@ void SleepActivity::renderCoverSleepScreen() const {
       return renderDefaultSleepScreen();
     }
 
-    if (!lastEpub.generateCoverBmp()) {
+    if (!lastEpub.generateCoverBmp(cropped)) {
       Serial.println("[SLP] Failed to generate cover bmp");
       return renderDefaultSleepScreen();
     }
 
-    coverBmpPath = lastEpub.getCoverBmpPath();
+    coverBmpPath = lastEpub.getCoverBmpPath(cropped);
+  } else {
+    return renderDefaultSleepScreen();
   }
 
   FsFile file;
@@ -234,3 +245,8 @@ void SleepActivity::renderCoverSleepScreen() const {
 
   renderDefaultSleepScreen();
 }
+
+void SleepActivity::renderBlankSleepScreen() const {
+  renderer.clearScreen();
+  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+}

src/activities/boot_sleep/SleepActivity.h

@@ -15,4 +15,5 @@ class SleepActivity final : public Activity {
   void renderCustomSleepScreen() const;
   void renderCoverSleepScreen() const;
   void renderBitmapSleepScreen(const Bitmap& bitmap) const;
+  void renderBlankSleepScreen() const;
 };

src/activities/browser/OpdsBookBrowserActivity.cpp

@@ -0,0 +1,408 @@
+#include "OpdsBookBrowserActivity.h"
+
+#include <GfxRenderer.h>
+#include <HardwareSerial.h>
+#include <WiFi.h>
+
+#include "CrossPointSettings.h"
+#include "MappedInputManager.h"
+#include "ScreenComponents.h"
+#include "activities/network/WifiSelectionActivity.h"
+#include "fontIds.h"
+#include "network/HttpDownloader.h"
+#include "util/StringUtils.h"
+#include "util/UrlUtils.h"
+
+namespace {
+constexpr int PAGE_ITEMS = 23;
+constexpr int SKIP_PAGE_MS = 700;
+constexpr char OPDS_ROOT_PATH[] = "opds";  // No leading slash - relative to server URL
+}  // namespace
+
+void OpdsBookBrowserActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<OpdsBookBrowserActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void OpdsBookBrowserActivity::onEnter() {
+  ActivityWithSubactivity::onEnter();
+
+  renderingMutex = xSemaphoreCreateMutex();
+  state = BrowserState::CHECK_WIFI;
+  entries.clear();
+  navigationHistory.clear();
+  currentPath = OPDS_ROOT_PATH;
+  selectorIndex = 0;
+  errorMessage.clear();
+  statusMessage = "Checking WiFi...";
+  updateRequired = true;
+
+  xTaskCreate(&OpdsBookBrowserActivity::taskTrampoline, "OpdsBookBrowserTask",
+              4096,               // Stack size (larger for HTTP operations)
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+
+  // Check WiFi and connect if needed, then fetch feed
+  checkAndConnectWifi();
+}
+
+void OpdsBookBrowserActivity::onExit() {
+  ActivityWithSubactivity::onExit();
+
+  // Turn off WiFi when exiting
+  WiFi.mode(WIFI_OFF);
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+  entries.clear();
+  navigationHistory.clear();
+}
+
+void OpdsBookBrowserActivity::loop() {
+  // Handle WiFi selection subactivity
+  if (state == BrowserState::WIFI_SELECTION) {
+    ActivityWithSubactivity::loop();
+    return;
+  }
+
+  // Handle error state - Confirm retries, Back goes back or home
+  if (state == BrowserState::ERROR) {
+    if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+      // Check if WiFi is still connected
+      if (WiFi.status() == WL_CONNECTED && WiFi.localIP() != IPAddress(0, 0, 0, 0)) {
+        // WiFi connected - just retry fetching the feed
+        Serial.printf("[%lu] [OPDS] Retry: WiFi connected, retrying fetch\n", millis());
+        state = BrowserState::LOADING;
+        statusMessage = "Loading...";
+        updateRequired = true;
+        fetchFeed(currentPath);
+      } else {
+        // WiFi not connected - launch WiFi selection
+        Serial.printf("[%lu] [OPDS] Retry: WiFi not connected, launching selection\n", millis());
+        launchWifiSelection();
+      }
+    } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
+      navigateBack();
+    }
+    return;
+  }
+
+  // Handle WiFi check state - only Back works
+  if (state == BrowserState::CHECK_WIFI) {
+    if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
+      onGoHome();
+    }
+    return;
+  }
+
+  // Handle loading state - only Back works
+  if (state == BrowserState::LOADING) {
+    if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
+      navigateBack();
+    }
+    return;
+  }
+
+  // Handle downloading state - no input allowed
+  if (state == BrowserState::DOWNLOADING) {
+    return;
+  }
+
+  // Handle browsing state
+  if (state == BrowserState::BROWSING) {
+    const bool prevReleased = mappedInput.wasReleased(MappedInputManager::Button::Up) ||
+                              mappedInput.wasReleased(MappedInputManager::Button::Left);
+    const bool nextReleased = mappedInput.wasReleased(MappedInputManager::Button::Down) ||
+                              mappedInput.wasReleased(MappedInputManager::Button::Right);
+    const bool skipPage = mappedInput.getHeldTime() > SKIP_PAGE_MS;
+
+    if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+      if (!entries.empty()) {
+        const auto& entry = entries[selectorIndex];
+        if (entry.type == OpdsEntryType::BOOK) {
+          downloadBook(entry);
+        } else {
+          navigateToEntry(entry);
+        }
+      }
+    } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
+      navigateBack();
+    } else if (prevReleased && !entries.empty()) {
+      if (skipPage) {
+        selectorIndex = ((selectorIndex / PAGE_ITEMS - 1) * PAGE_ITEMS + entries.size()) % entries.size();
+      } else {
+        selectorIndex = (selectorIndex + entries.size() - 1) % entries.size();
+      }
+      updateRequired = true;
+    } else if (nextReleased && !entries.empty()) {
+      if (skipPage) {
+        selectorIndex = ((selectorIndex / PAGE_ITEMS + 1) * PAGE_ITEMS) % entries.size();
+      } else {
+        selectorIndex = (selectorIndex + 1) % entries.size();
+      }
+      updateRequired = true;
+    }
+  }
+}
+
+void OpdsBookBrowserActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void OpdsBookBrowserActivity::render() const {
+  renderer.clearScreen();
+
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+
+  renderer.drawCenteredText(UI_12_FONT_ID, 15, "Calibre Library", true, EpdFontFamily::BOLD);
+
+  if (state == BrowserState::CHECK_WIFI) {
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2, statusMessage.c_str());
+    const auto labels = mappedInput.mapLabels("« Back", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == BrowserState::LOADING) {
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2, statusMessage.c_str());
+    const auto labels = mappedInput.mapLabels("« Back", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == BrowserState::ERROR) {
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2 - 20, "Error:");
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2 + 10, errorMessage.c_str());
+    const auto labels = mappedInput.mapLabels("« Back", "Retry", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == BrowserState::DOWNLOADING) {
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2 - 40, "Downloading...");
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2 - 10, statusMessage.c_str());
+    if (downloadTotal > 0) {
+      const int barWidth = pageWidth - 100;
+      constexpr int barHeight = 20;
+      constexpr int barX = 50;
+      const int barY = pageHeight / 2 + 20;
+      ScreenComponents::drawProgressBar(renderer, barX, barY, barWidth, barHeight, downloadProgress, downloadTotal);
+    }
+    renderer.displayBuffer();
+    return;
+  }
+
+  // Browsing state
+  // Show appropriate button hint based on selected entry type
+  const char* confirmLabel = "Open";
+  if (!entries.empty() && entries[selectorIndex].type == OpdsEntryType::BOOK) {
+    confirmLabel = "Download";
+  }
+  const auto labels = mappedInput.mapLabels("« Back", confirmLabel, "", "");
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+
+  if (entries.empty()) {
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight / 2, "No entries found");
+    renderer.displayBuffer();
+    return;
+  }
+
+  const auto pageStartIndex = selectorIndex / PAGE_ITEMS * PAGE_ITEMS;
+  renderer.fillRect(0, 60 + (selectorIndex % PAGE_ITEMS) * 30 - 2, pageWidth - 1, 30);
+
+  for (size_t i = pageStartIndex; i < entries.size() && i < static_cast<size_t>(pageStartIndex + PAGE_ITEMS); i++) {
+    const auto& entry = entries[i];
+
+    // Format display text with type indicator
+    std::string displayText;
+    if (entry.type == OpdsEntryType::NAVIGATION) {
+      displayText = "> " + entry.title;  // Folder/navigation indicator
+    } else {
+      // Book: "Title - Author" or just "Title"
+      displayText = entry.title;
+      if (!entry.author.empty()) {
+        displayText += " - " + entry.author;
+      }
+    }
+
+    auto item = renderer.truncatedText(UI_10_FONT_ID, displayText.c_str(), renderer.getScreenWidth() - 40);
+    renderer.drawText(UI_10_FONT_ID, 20, 60 + (i % PAGE_ITEMS) * 30, item.c_str(),
+                      i != static_cast<size_t>(selectorIndex));
+  }
+
+  renderer.displayBuffer();
+}
+
+void OpdsBookBrowserActivity::fetchFeed(const std::string& path) {
+  const char* serverUrl = SETTINGS.opdsServerUrl;
+  if (strlen(serverUrl) == 0) {
+    state = BrowserState::ERROR;
+    errorMessage = "No server URL configured";
+    updateRequired = true;
+    return;
+  }
+
+  std::string url = UrlUtils::buildUrl(serverUrl, path);
+  Serial.printf("[%lu] [OPDS] Fetching: %s\n", millis(), url.c_str());
+
+  std::string content;
+  if (!HttpDownloader::fetchUrl(url, content)) {
+    state = BrowserState::ERROR;
+    errorMessage = "Failed to fetch feed";
+    updateRequired = true;
+    return;
+  }
+
+  OpdsParser parser;
+  if (!parser.parse(content.c_str(), content.size())) {
+    state = BrowserState::ERROR;
+    errorMessage = "Failed to parse feed";
+    updateRequired = true;
+    return;
+  }
+
+  entries = parser.getEntries();
+  selectorIndex = 0;
+
+  if (entries.empty()) {
+    state = BrowserState::ERROR;
+    errorMessage = "No entries found";
+    updateRequired = true;
+    return;
+  }
+
+  state = BrowserState::BROWSING;
+  updateRequired = true;
+}
+
+void OpdsBookBrowserActivity::navigateToEntry(const OpdsEntry& entry) {
+  // Push current path to history before navigating
+  navigationHistory.push_back(currentPath);
+  currentPath = entry.href;
+
+  state = BrowserState::LOADING;
+  statusMessage = "Loading...";
+  entries.clear();
+  selectorIndex = 0;
+  updateRequired = true;
+
+  fetchFeed(currentPath);
+}
+
+void OpdsBookBrowserActivity::navigateBack() {
+  if (navigationHistory.empty()) {
+    // At root, go home
+    onGoHome();
+  } else {
+    // Go back to previous catalog
+    currentPath = navigationHistory.back();
+    navigationHistory.pop_back();
+
+    state = BrowserState::LOADING;
+    statusMessage = "Loading...";
+    entries.clear();
+    selectorIndex = 0;
+    updateRequired = true;
+
+    fetchFeed(currentPath);
+  }
+}
+
+void OpdsBookBrowserActivity::downloadBook(const OpdsEntry& book) {
+  state = BrowserState::DOWNLOADING;
+  statusMessage = book.title;
+  downloadProgress = 0;
+  downloadTotal = 0;
+  updateRequired = true;
+
+  // Build full download URL
+  std::string downloadUrl = UrlUtils::buildUrl(SETTINGS.opdsServerUrl, book.href);
+
+  // Create sanitized filename: "Title - Author.epub" or just "Title.epub" if no author
+  std::string baseName = book.title;
+  if (!book.author.empty()) {
+    baseName += " - " + book.author;
+  }
+  std::string filename = "/" + StringUtils::sanitizeFilename(baseName) + ".epub";
+
+  Serial.printf("[%lu] [OPDS] Downloading: %s -> %s\n", millis(), downloadUrl.c_str(), filename.c_str());
+
+  const auto result =
+      HttpDownloader::downloadToFile(downloadUrl, filename, [this](const size_t downloaded, const size_t total) {
+        downloadProgress = downloaded;
+        downloadTotal = total;
+        updateRequired = true;
+      });
+
+  if (result == HttpDownloader::OK) {
+    Serial.printf("[%lu] [OPDS] Download complete: %s\n", millis(), filename.c_str());
+    state = BrowserState::BROWSING;
+    updateRequired = true;
+  } else {
+    state = BrowserState::ERROR;
+    errorMessage = "Download failed";
+    updateRequired = true;
+  }
+}
+
+void OpdsBookBrowserActivity::checkAndConnectWifi() {
+  // Already connected? Verify connection is valid by checking IP
+  if (WiFi.status() == WL_CONNECTED && WiFi.localIP() != IPAddress(0, 0, 0, 0)) {
+    state = BrowserState::LOADING;
+    statusMessage = "Loading...";
+    updateRequired = true;
+    fetchFeed(currentPath);
+    return;
+  }
+
+  // Not connected - launch WiFi selection screen directly
+  launchWifiSelection();
+}
+
+void OpdsBookBrowserActivity::launchWifiSelection() {
+  state = BrowserState::WIFI_SELECTION;
+  updateRequired = true;
+
+  enterNewActivity(new WifiSelectionActivity(renderer, mappedInput,
+                                             [this](const bool connected) { onWifiSelectionComplete(connected); }));
+}
+
+void OpdsBookBrowserActivity::onWifiSelectionComplete(const bool connected) {
+  exitActivity();
+
+  if (connected) {
+    Serial.printf("[%lu] [OPDS] WiFi connected via selection, fetching feed\n", millis());
+    state = BrowserState::LOADING;
+    statusMessage = "Loading...";
+    updateRequired = true;
+    fetchFeed(currentPath);
+  } else {
+    Serial.printf("[%lu] [OPDS] WiFi selection cancelled/failed\n", millis());
+    // Force disconnect to ensure clean state for next retry
+    // This prevents stale connection status from interfering
+    WiFi.disconnect();
+    WiFi.mode(WIFI_OFF);
+    state = BrowserState::ERROR;
+    errorMessage = "WiFi connection failed";
+    updateRequired = true;
+  }
+}

src/activities/browser/OpdsBookBrowserActivity.h

@@ -0,0 +1,65 @@
+#pragma once
+#include <OpdsParser.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "../ActivityWithSubactivity.h"
+
+/**
+ * Activity for browsing and downloading books from an OPDS server.
+ * Supports navigation through catalog hierarchy and downloading EPUBs.
+ * When WiFi connection fails, launches WiFi selection to let user connect.
+ */
+class OpdsBookBrowserActivity final : public ActivityWithSubactivity {
+ public:
+  enum class BrowserState {
+    CHECK_WIFI,      // Checking WiFi connection
+    WIFI_SELECTION,  // WiFi selection subactivity is active
+    LOADING,         // Fetching OPDS feed
+    BROWSING,        // Displaying entries (navigation or books)
+    DOWNLOADING,     // Downloading selected EPUB
+    ERROR            // Error state with message
+  };
+
+  explicit OpdsBookBrowserActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
+                                   const std::function<void()>& onGoHome)
+      : ActivityWithSubactivity("OpdsBookBrowser", renderer, mappedInput), onGoHome(onGoHome) {}
+
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+
+ private:
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+
+  BrowserState state = BrowserState::LOADING;
+  std::vector<OpdsEntry> entries;
+  std::vector<std::string> navigationHistory;  // Stack of previous feed paths for back navigation
+  std::string currentPath;                     // Current feed path being displayed
+  int selectorIndex = 0;
+  std::string errorMessage;
+  std::string statusMessage;
+  size_t downloadProgress = 0;
+  size_t downloadTotal = 0;
+
+  const std::function<void()> onGoHome;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render() const;
+
+  void checkAndConnectWifi();
+  void launchWifiSelection();
+  void onWifiSelectionComplete(bool connected);
+  void fetchFeed(const std::string& path);
+  void navigateToEntry(const OpdsEntry& entry);
+  void navigateBack();
+  void downloadBook(const OpdsEntry& book);
+};

src/activities/home/HomeActivity.cpp

@@ -4,19 +4,28 @@
 #include <GfxRenderer.h>
 #include <SDCardManager.h>
 
+#include <cstring>
+#include <vector>
+
+#include "Battery.h"
+#include "CrossPointSettings.h"
 #include "CrossPointState.h"
 #include "MappedInputManager.h"
 #include "ScreenComponents.h"
 #include "fontIds.h"
+#include "util/StringUtils.h"
 
-void HomeActivity::taskTrampoline(void* param) {
-  auto* self = static_cast<HomeActivity*>(param);
+void HomeActivity::taskTrampoline(void *param) {
+  auto *self = static_cast<HomeActivity *>(param);
   self->displayTaskLoop();
 }
 
 int HomeActivity::getMenuItemCount() const {
-  int count = 3;  // Base: My Library, File transfer, Settings
-  if (hasContinueReading) count++;
+  int count = 3; // Base: My Library, File transfer, Settings
+  if (hasContinueReading)
+    count++;
+  if (hasOpdsUrl)
+    count++;
   return count;
 }
 
@@ -26,7 +35,11 @@ void HomeActivity::onEnter() {
   renderingMutex = xSemaphoreCreateMutex();
 
   // Check if we have a book to continue reading
-  hasContinueReading = !APP_STATE.openEpubPath.empty() && SdMan.exists(APP_STATE.openEpubPath.c_str());
+  hasContinueReading = !APP_STATE.openEpubPath.empty() &&
+                       SdMan.exists(APP_STATE.openEpubPath.c_str());
+
+  // Check if OPDS browser URL is configured
+  hasOpdsUrl = strlen(SETTINGS.opdsServerUrl) > 0;
 
   if (hasContinueReading) {
     // Extract filename from path for display
@@ -36,10 +49,8 @@ void HomeActivity::onEnter() {
       lastBookTitle = lastBookTitle.substr(lastSlash + 1);
     }
 
-    const std::string ext4 = lastBookTitle.length() >= 4 ? lastBookTitle.substr(lastBookTitle.length() - 4) : "";
-    const std::string ext5 = lastBookTitle.length() >= 5 ? lastBookTitle.substr(lastBookTitle.length() - 5) : "";
     // If epub, try to load the metadata for title/author
-    if (ext5 == ".epub") {
+    if (StringUtils::checkFileExtension(lastBookTitle, ".epub")) {
       Epub epub(APP_STATE.openEpubPath, "/.crosspoint");
       epub.load(false);
       if (!epub.getTitle().empty()) {
@@ -48,9 +59,9 @@ void HomeActivity::onEnter() {
       if (!epub.getAuthor().empty()) {
         lastBookAuthor = std::string(epub.getAuthor());
       }
-    } else if (ext5 == ".xtch") {
+    } else if (StringUtils::checkFileExtension(lastBookTitle, ".xtch")) {
       lastBookTitle.resize(lastBookTitle.length() - 5);
-    } else if (ext4 == ".xtc") {
+    } else if (StringUtils::checkFileExtension(lastBookTitle, ".xtc")) {
       lastBookTitle.resize(lastBookTitle.length() - 4);
     }
   }
@@ -61,17 +72,18 @@ void HomeActivity::onEnter() {
   updateRequired = true;
 
   xTaskCreate(&HomeActivity::taskTrampoline, "HomeActivityTask",
-              2048,               // Stack size
-              this,               // Parameters
-              1,                  // Priority
-              &displayTaskHandle  // Task handle
+              4096,              // Stack size
+              this,              // Parameters
+              1,                 // Priority
+              &displayTaskHandle // Task handle
   );
 }
 
 void HomeActivity::onExit() {
   Activity::onExit();
 
-  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
+  // Wait until not rendering to delete task to avoid killing mid-instruction to
+  // EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
   if (displayTaskHandle) {
     vTaskDelete(displayTaskHandle);
@@ -82,34 +94,34 @@ void HomeActivity::onExit() {
 }
 
 void HomeActivity::loop() {
-  const bool prevPressed = mappedInput.wasPressed(MappedInputManager::Button::Up) ||
-                           mappedInput.wasPressed(MappedInputManager::Button::Left);
-  const bool nextPressed = mappedInput.wasPressed(MappedInputManager::Button::Down) ||
-                           mappedInput.wasPressed(MappedInputManager::Button::Right);
+  const bool prevPressed =
+      mappedInput.wasPressed(MappedInputManager::Button::Up) ||
+      mappedInput.wasPressed(MappedInputManager::Button::Left);
+  const bool nextPressed =
+      mappedInput.wasPressed(MappedInputManager::Button::Down) ||
+      mappedInput.wasPressed(MappedInputManager::Button::Right);
 
   const int menuCount = getMenuItemCount();
 
   if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
-    if (hasContinueReading) {
-      // Menu: Continue Reading, My Library, File transfer, Settings
-      if (selectorIndex == 0) {
-        onContinueReading();
-      } else if (selectorIndex == 1) {
-        onMyLibraryOpen();
-      } else if (selectorIndex == 2) {
-        onFileTransferOpen();
-      } else if (selectorIndex == 3) {
-        onSettingsOpen();
-      }
-    } else {
-      // Menu: My Library, File transfer, Settings
-      if (selectorIndex == 0) {
-        onMyLibraryOpen();
-      } else if (selectorIndex == 1) {
-        onFileTransferOpen();
-      } else if (selectorIndex == 2) {
-        onSettingsOpen();
-      }
+    // Calculate dynamic indices based on which options are available
+    int idx = 0;
+    const int continueIdx = hasContinueReading ? idx++ : -1;
+    const int myLibraryIdx = idx++;
+    const int opdsLibraryIdx = hasOpdsUrl ? idx++ : -1;
+    const int fileTransferIdx = idx++;
+    const int settingsIdx = idx;
+
+    if (selectorIndex == continueIdx) {
+      onContinueReading();
+    } else if (selectorIndex == myLibraryIdx) {
+      onMyLibraryOpen();
+    } else if (selectorIndex == opdsLibraryIdx) {
+      onOpdsBrowserOpen();
+    } else if (selectorIndex == fileTransferIdx) {
+      onFileTransferOpen();
+    } else if (selectorIndex == settingsIdx) {
+      onSettingsOpen();
     }
   } else if (prevPressed) {
     selectorIndex = (selectorIndex + menuCount - 1) % menuCount;
@@ -163,10 +175,12 @@ void HomeActivity::render() const {
     constexpr int bookmarkY = bookY + 1;
 
     // Main bookmark body (solid)
-    renderer.fillRect(bookmarkX, bookmarkY, bookmarkWidth, bookmarkHeight, !bookSelected);
+    renderer.fillRect(bookmarkX, bookmarkY, bookmarkWidth, bookmarkHeight,
+                      !bookSelected);
 
-    // Carve out an inverted triangle notch at the bottom center to create angled points
-    const int notchHeight = bookmarkHeight / 2;  // depth of the notch
+    // Carve out an inverted triangle notch at the bottom center to create
+    // angled points
+    const int notchHeight = bookmarkHeight / 2; // depth of the notch
     for (int i = 0; i < notchHeight; ++i) {
       const int y = bookmarkY + bookmarkHeight - 1 - i;
       const int xStart = bookmarkX + i;
@@ -204,14 +218,16 @@ void HomeActivity::render() const {
     const int maxLineWidth = bookWidth - 40;
     const int spaceWidth = renderer.getSpaceWidth(UI_12_FONT_ID);
 
-    for (auto& i : words) {
+    for (auto &i : words) {
       // If we just hit the line limit (3), stop processing words
       if (lines.size() >= 3) {
         // Limit to 3 lines
         // Still have words left, so add ellipsis to last line
         lines.back().append("...");
 
-        while (!lines.back().empty() && renderer.getTextWidth(UI_12_FONT_ID, lines.back().c_str()) > maxLineWidth) {
+        while (!lines.back().empty() &&
+               renderer.getTextWidth(UI_12_FONT_ID, lines.back().c_str()) >
+                   maxLineWidth) {
           lines.back().resize(lines.back().size() - 5);
           lines.back().append("...");
         }
@@ -226,7 +242,8 @@ void HomeActivity::render() const {
         wordWidth = renderer.getTextWidth(UI_12_FONT_ID, i.c_str());
       }
 
-      int newLineWidth = renderer.getTextWidth(UI_12_FONT_ID, currentLine.c_str());
+      int newLineWidth =
+          renderer.getTextWidth(UI_12_FONT_ID, currentLine.c_str());
       if (newLineWidth > 0) {
         newLineWidth += spaceWidth;
       }
@@ -247,7 +264,8 @@ void HomeActivity::render() const {
     }
 
     // Book title text
-    int totalTextHeight = renderer.getLineHeight(UI_12_FONT_ID) * static_cast<int>(lines.size());
+    int totalTextHeight =
+        renderer.getLineHeight(UI_12_FONT_ID) * static_cast<int>(lines.size());
     if (!lastBookAuthor.empty()) {
       totalTextHeight += renderer.getLineHeight(UI_10_FONT_ID) * 3 / 2;
     }
@@ -255,8 +273,9 @@ void HomeActivity::render() const {
     // Vertically center the title block within the card
     int titleYStart = bookY + (bookHeight - totalTextHeight) / 2;
 
-    for (const auto& line : lines) {
-      renderer.drawCenteredText(UI_12_FONT_ID, titleYStart, line.c_str(), !bookSelected);
+    for (const auto &line : lines) {
+      renderer.drawCenteredText(UI_12_FONT_ID, titleYStart, line.c_str(),
+                                !bookSelected);
       titleYStart += renderer.getLineHeight(UI_12_FONT_ID);
     }
 
@@ -264,44 +283,60 @@ void HomeActivity::render() const {
       titleYStart += renderer.getLineHeight(UI_10_FONT_ID) / 2;
       std::string trimmedAuthor = lastBookAuthor;
       // Trim author if too long
-      while (renderer.getTextWidth(UI_10_FONT_ID, trimmedAuthor.c_str()) > maxLineWidth && !trimmedAuthor.empty()) {
+      while (renderer.getTextWidth(UI_10_FONT_ID, trimmedAuthor.c_str()) >
+                 maxLineWidth &&
+             !trimmedAuthor.empty()) {
         trimmedAuthor.resize(trimmedAuthor.size() - 5);
         trimmedAuthor.append("...");
       }
-      renderer.drawCenteredText(UI_10_FONT_ID, titleYStart, trimmedAuthor.c_str(), !bookSelected);
+      renderer.drawCenteredText(UI_10_FONT_ID, titleYStart,
+                                trimmedAuthor.c_str(), !bookSelected);
     }
 
-    renderer.drawCenteredText(UI_10_FONT_ID, bookY + bookHeight - renderer.getLineHeight(UI_10_FONT_ID) * 3 / 2,
+    renderer.drawCenteredText(UI_10_FONT_ID,
+                              bookY + bookHeight -
+                                  renderer.getLineHeight(UI_10_FONT_ID) * 3 / 2,
                               "Continue Reading", !bookSelected);
   } else {
     // No book to continue reading
-    const int y =
-        bookY + (bookHeight - renderer.getLineHeight(UI_12_FONT_ID) - renderer.getLineHeight(UI_10_FONT_ID)) / 2;
+    const int y = bookY + (bookHeight - renderer.getLineHeight(UI_12_FONT_ID) -
+                           renderer.getLineHeight(UI_10_FONT_ID)) /
+                              2;
     renderer.drawCenteredText(UI_12_FONT_ID, y, "No open book");
-    renderer.drawCenteredText(UI_10_FONT_ID, y + renderer.getLineHeight(UI_12_FONT_ID), "Start reading below");
+    renderer.drawCenteredText(UI_10_FONT_ID,
+                              y + renderer.getLineHeight(UI_12_FONT_ID),
+                              "Start reading below");
   }
 
   // --- Bottom menu tiles ---
-  // Menu tiles: My Library, File transfer, Settings
-  constexpr int menuTileCount = 3;
-  const int menuTileWidth = pageWidth - 2 * margin;
-  constexpr int menuTileHeight = 50;
-  constexpr int menuSpacing = 10;
-  const int totalMenuHeight = menuTileCount * menuTileHeight + (menuTileCount - 1) * menuSpacing;
+  // Build menu items dynamically
+  std::vector<const char *> menuItems = {"My Library", "File Transfer",
+                                         "Settings"};
+  if (hasOpdsUrl) {
+    // Insert Calibre Library after My Library
+    menuItems.insert(menuItems.begin() + 1, "Calibre Library");
+  }
 
-  int menuStartY = bookY + bookHeight + 20;
+  const int menuTileWidth = pageWidth - 2 * margin;
+  constexpr int menuTileHeight = 45;
+  constexpr int menuSpacing = 8;
+  const int totalMenuHeight =
+      static_cast<int>(menuItems.size()) * menuTileHeight +
+      (static_cast<int>(menuItems.size()) - 1) * menuSpacing;
+
+  int menuStartY = bookY + bookHeight + 15;
   // Ensure we don't collide with the bottom button legend
-  const int maxMenuStartY = pageHeight - bottomMargin - totalMenuHeight - margin;
+  const int maxMenuStartY =
+      pageHeight - bottomMargin - totalMenuHeight - margin;
   if (menuStartY > maxMenuStartY) {
     menuStartY = maxMenuStartY;
   }
 
-  constexpr const char* menuItems[3] = {"My Library", "File transfer", "Settings"};
-
-  for (int i = 0; i < menuTileCount; ++i) {
-    const int overallIndex = i + (getMenuItemCount() - menuTileCount);
+  for (size_t i = 0; i < menuItems.size(); ++i) {
+    const int overallIndex = static_cast<int>(i) + (hasContinueReading ? 1 : 0);
     constexpr int tileX = margin;
-    const int tileY = menuStartY + i * (menuTileHeight + menuSpacing);
+    const int tileY =
+        menuStartY + static_cast<int>(i) * (menuTileHeight + menuSpacing);
     const bool selected = selectorIndex == overallIndex;
 
     if (selected) {
@@ -310,20 +345,34 @@ void HomeActivity::render() const {
       renderer.drawRect(tileX, tileY, menuTileWidth, menuTileHeight);
     }
 
-    const char* label = menuItems[i];
+    const char *label = menuItems[i];
     const int textWidth = renderer.getTextWidth(UI_10_FONT_ID, label);
     const int textX = tileX + (menuTileWidth - textWidth) / 2;
     const int lineHeight = renderer.getLineHeight(UI_10_FONT_ID);
-    const int textY = tileY + (menuTileHeight - lineHeight) / 2;  // vertically centered assuming y is top of text
+    const int textY =
+        tileY + (menuTileHeight - lineHeight) /
+                    2; // vertically centered assuming y is top of text
 
-    // Invert text when the tile is selected, to contrast with the filled background
+    // Invert text when the tile is selected, to contrast with the filled
+    // background
     renderer.drawText(UI_10_FONT_ID, textX, textY, label, !selected);
   }
 
   const auto labels = mappedInput.mapLabels("", "Confirm", "Up", "Down");
-  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3,
+                           labels.btn4);
 
-  ScreenComponents::drawBattery(renderer, 20, pageHeight - 70);
+  const bool showBatteryPercentage =
+      SETTINGS.hideBatteryPercentage !=
+      CrossPointSettings::HIDE_BATTERY_PERCENTAGE::HIDE_ALWAYS;
+  // get percentage so we can align text properly
+  const uint16_t percentage = battery.readPercentage();
+  const auto percentageText =
+      showBatteryPercentage ? std::to_string(percentage) + "%" : "";
+  const auto batteryX =
+      pageWidth - 25 -
+      renderer.getTextWidth(SMALL_FONT_ID, percentageText.c_str());
+  ScreenComponents::drawBattery(renderer, batteryX, 10, showBatteryPercentage);
 
   renderer.displayBuffer();
 }

src/activities/home/HomeActivity.h

@@ -13,27 +13,31 @@ class HomeActivity final : public Activity {
   int selectorIndex = 0;
   bool updateRequired = false;
   bool hasContinueReading = false;
+  bool hasOpdsUrl = false;
   std::string lastBookTitle;
   std::string lastBookAuthor;
   const std::function<void()> onContinueReading;
   const std::function<void()> onMyLibraryOpen;
   const std::function<void()> onSettingsOpen;
   const std::function<void()> onFileTransferOpen;
+  const std::function<void()> onOpdsBrowserOpen;
 
-  static void taskTrampoline(void* param);
+  static void taskTrampoline(void *param);
   [[noreturn]] void displayTaskLoop();
   void render() const;
   int getMenuItemCount() const;
 
- public:
-  explicit HomeActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
-                        const std::function<void()>& onContinueReading, const std::function<void()>& onMyLibraryOpen,
-                        const std::function<void()>& onSettingsOpen, const std::function<void()>& onFileTransferOpen)
+public:
+  explicit HomeActivity(GfxRenderer &renderer, MappedInputManager &mappedInput,
+                        const std::function<void()> &onContinueReading,
+                        const std::function<void()> &onMyLibraryOpen,
+                        const std::function<void()> &onSettingsOpen,
+                        const std::function<void()> &onFileTransferOpen,
+                        const std::function<void()> &onOpdsBrowserOpen)
       : Activity("Home", renderer, mappedInput),
-        onContinueReading(onContinueReading),
-        onMyLibraryOpen(onMyLibraryOpen),
-        onSettingsOpen(onSettingsOpen),
-        onFileTransferOpen(onFileTransferOpen) {}
+        onContinueReading(onContinueReading), onMyLibraryOpen(onMyLibraryOpen),
+        onSettingsOpen(onSettingsOpen), onFileTransferOpen(onFileTransferOpen),
+        onOpdsBrowserOpen(onOpdsBrowserOpen) {}
   void onEnter() override;
   void onExit() override;
   void loop() override;

src/activities/network/CalibreWirelessActivity.cpp

@@ -0,0 +1,756 @@
+#include "CalibreWirelessActivity.h"
+
+#include <GfxRenderer.h>
+#include <HardwareSerial.h>
+#include <SDCardManager.h>
+#include <WiFi.h>
+
+#include <cstring>
+
+#include "MappedInputManager.h"
+#include "ScreenComponents.h"
+#include "fontIds.h"
+#include "util/StringUtils.h"
+
+namespace {
+constexpr uint16_t UDP_PORTS[] = {54982, 48123, 39001, 44044, 59678};
+constexpr uint16_t LOCAL_UDP_PORT = 8134;  // Port to receive responses
+}  // namespace
+
+void CalibreWirelessActivity::displayTaskTrampoline(void* param) {
+  auto* self = static_cast<CalibreWirelessActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void CalibreWirelessActivity::networkTaskTrampoline(void* param) {
+  auto* self = static_cast<CalibreWirelessActivity*>(param);
+  self->networkTaskLoop();
+}
+
+void CalibreWirelessActivity::onEnter() {
+  Activity::onEnter();
+
+  renderingMutex = xSemaphoreCreateMutex();
+  stateMutex = xSemaphoreCreateMutex();
+
+  state = WirelessState::DISCOVERING;
+  statusMessage = "Discovering Calibre...";
+  errorMessage.clear();
+  calibreHostname.clear();
+  calibreHost.clear();
+  calibrePort = 0;
+  calibreAltPort = 0;
+  currentFilename.clear();
+  currentFileSize = 0;
+  bytesReceived = 0;
+  inBinaryMode = false;
+  recvBuffer.clear();
+
+  updateRequired = true;
+
+  // Start UDP listener for Calibre responses
+  udp.begin(LOCAL_UDP_PORT);
+
+  // Create display task
+  xTaskCreate(&CalibreWirelessActivity::displayTaskTrampoline, "CalDisplayTask", 2048, this, 1, &displayTaskHandle);
+
+  // Create network task with larger stack for JSON parsing
+  xTaskCreate(&CalibreWirelessActivity::networkTaskTrampoline, "CalNetworkTask", 12288, this, 2, &networkTaskHandle);
+}
+
+void CalibreWirelessActivity::onExit() {
+  Activity::onExit();
+
+  // Turn off WiFi when exiting
+  WiFi.mode(WIFI_OFF);
+
+  // Stop UDP listening
+  udp.stop();
+
+  // Close TCP client if connected
+  if (tcpClient.connected()) {
+    tcpClient.stop();
+  }
+
+  // Close any open file
+  if (currentFile) {
+    currentFile.close();
+  }
+
+  // Acquire stateMutex before deleting network task to avoid race condition
+  xSemaphoreTake(stateMutex, portMAX_DELAY);
+  if (networkTaskHandle) {
+    vTaskDelete(networkTaskHandle);
+    networkTaskHandle = nullptr;
+  }
+  xSemaphoreGive(stateMutex);
+
+  // Acquire renderingMutex before deleting display task
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+
+  vSemaphoreDelete(stateMutex);
+  stateMutex = nullptr;
+}
+
+void CalibreWirelessActivity::loop() {
+  if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
+    onComplete();
+    return;
+  }
+}
+
+void CalibreWirelessActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(50 / portTICK_PERIOD_MS);
+  }
+}
+
+void CalibreWirelessActivity::networkTaskLoop() {
+  while (true) {
+    xSemaphoreTake(stateMutex, portMAX_DELAY);
+    const auto currentState = state;
+    xSemaphoreGive(stateMutex);
+
+    switch (currentState) {
+      case WirelessState::DISCOVERING:
+        listenForDiscovery();
+        break;
+
+      case WirelessState::CONNECTING:
+      case WirelessState::WAITING:
+      case WirelessState::RECEIVING:
+        handleTcpClient();
+        break;
+
+      case WirelessState::COMPLETE:
+      case WirelessState::DISCONNECTED:
+      case WirelessState::ERROR:
+        // Just wait, user will exit
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+        break;
+    }
+
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void CalibreWirelessActivity::listenForDiscovery() {
+  // Broadcast "hello" on all UDP discovery ports to find Calibre
+  for (const uint16_t port : UDP_PORTS) {
+    udp.beginPacket("255.255.255.255", port);
+    udp.write(reinterpret_cast<const uint8_t*>("hello"), 5);
+    udp.endPacket();
+  }
+
+  // Wait for Calibre's response
+  vTaskDelay(500 / portTICK_PERIOD_MS);
+
+  // Check for response
+  const int packetSize = udp.parsePacket();
+  if (packetSize > 0) {
+    char buffer[256];
+    const int len = udp.read(buffer, sizeof(buffer) - 1);
+    if (len > 0) {
+      buffer[len] = '\0';
+
+      // Parse Calibre's response format:
+      // "calibre wireless device client (on hostname);port,content_server_port"
+      // or just the hostname and port info
+      std::string response(buffer);
+
+      // Try to extract host and port
+      // Format: "calibre wireless device client (on HOSTNAME);PORT,..."
+      size_t onPos = response.find("(on ");
+      size_t closePos = response.find(')');
+      size_t semiPos = response.find(';');
+      size_t commaPos = response.find(',', semiPos);
+
+      if (semiPos != std::string::npos) {
+        // Get ports after semicolon (format: "port1,port2")
+        std::string portStr;
+        if (commaPos != std::string::npos && commaPos > semiPos) {
+          portStr = response.substr(semiPos + 1, commaPos - semiPos - 1);
+          // Get alternative port after comma
+          std::string altPortStr = response.substr(commaPos + 1);
+          // Trim whitespace and non-digits from alt port
+          size_t altEnd = 0;
+          while (altEnd < altPortStr.size() && altPortStr[altEnd] >= '0' && altPortStr[altEnd] <= '9') {
+            altEnd++;
+          }
+          if (altEnd > 0) {
+            calibreAltPort = static_cast<uint16_t>(std::stoi(altPortStr.substr(0, altEnd)));
+          }
+        } else {
+          portStr = response.substr(semiPos + 1);
+        }
+
+        // Trim whitespace from main port
+        while (!portStr.empty() && (portStr[0] == ' ' || portStr[0] == '\t')) {
+          portStr = portStr.substr(1);
+        }
+
+        if (!portStr.empty()) {
+          calibrePort = static_cast<uint16_t>(std::stoi(portStr));
+        }
+
+        // Get hostname if present, otherwise use sender IP
+        if (onPos != std::string::npos && closePos != std::string::npos && closePos > onPos + 4) {
+          calibreHostname = response.substr(onPos + 4, closePos - onPos - 4);
+        }
+      }
+
+      // Use the sender's IP as the host to connect to
+      calibreHost = udp.remoteIP().toString().c_str();
+      if (calibreHostname.empty()) {
+        calibreHostname = calibreHost;
+      }
+
+      if (calibrePort > 0) {
+        // Connect to Calibre's TCP server - try main port first, then alt port
+        setState(WirelessState::CONNECTING);
+        setStatus("Connecting to " + calibreHostname + "...");
+
+        // Small delay before connecting
+        vTaskDelay(100 / portTICK_PERIOD_MS);
+
+        bool connected = false;
+
+        // Try main port first
+        if (tcpClient.connect(calibreHost.c_str(), calibrePort, 5000)) {
+          connected = true;
+        }
+
+        // Try alternative port if main failed
+        if (!connected && calibreAltPort > 0) {
+          vTaskDelay(200 / portTICK_PERIOD_MS);
+          if (tcpClient.connect(calibreHost.c_str(), calibreAltPort, 5000)) {
+            connected = true;
+          }
+        }
+
+        if (connected) {
+          setState(WirelessState::WAITING);
+          setStatus("Connected to " + calibreHostname + "\nWaiting for commands...");
+        } else {
+          // Don't set error yet, keep trying discovery
+          setState(WirelessState::DISCOVERING);
+          setStatus("Discovering Calibre...\n(Connection failed, retrying)");
+          calibrePort = 0;
+          calibreAltPort = 0;
+        }
+      }
+    }
+  }
+}
+
+void CalibreWirelessActivity::handleTcpClient() {
+  if (!tcpClient.connected()) {
+    setState(WirelessState::DISCONNECTED);
+    setStatus("Calibre disconnected");
+    return;
+  }
+
+  if (inBinaryMode) {
+    receiveBinaryData();
+    return;
+  }
+
+  std::string message;
+  if (readJsonMessage(message)) {
+    // Parse opcode from JSON array format: [opcode, {...}]
+    // Find the opcode (first number after '[')
+    size_t start = message.find('[');
+    if (start != std::string::npos) {
+      start++;
+      size_t end = message.find(',', start);
+      if (end != std::string::npos) {
+        const int opcodeInt = std::stoi(message.substr(start, end - start));
+        if (opcodeInt < 0 || opcodeInt >= OpCode::ERROR) {
+          Serial.printf("[%lu] [CAL] Invalid opcode: %d\n", millis(), opcodeInt);
+          sendJsonResponse(OpCode::OK, "{}");
+          return;
+        }
+        const auto opcode = static_cast<OpCode>(opcodeInt);
+
+        // Extract data object (everything after the comma until the last ']')
+        size_t dataStart = end + 1;
+        size_t dataEnd = message.rfind(']');
+        std::string data = "";
+        if (dataEnd != std::string::npos && dataEnd > dataStart) {
+          data = message.substr(dataStart, dataEnd - dataStart);
+        }
+
+        handleCommand(opcode, data);
+      }
+    }
+  }
+}
+
+bool CalibreWirelessActivity::readJsonMessage(std::string& message) {
+  // Read available data into buffer
+  int available = tcpClient.available();
+  if (available > 0) {
+    // Limit buffer growth to prevent memory issues
+    if (recvBuffer.size() > 100000) {
+      recvBuffer.clear();
+      return false;
+    }
+    // Read in chunks
+    char buf[1024];
+    while (available > 0) {
+      int toRead = std::min(available, static_cast<int>(sizeof(buf)));
+      int bytesRead = tcpClient.read(reinterpret_cast<uint8_t*>(buf), toRead);
+      if (bytesRead > 0) {
+        recvBuffer.append(buf, bytesRead);
+        available -= bytesRead;
+      } else {
+        break;
+      }
+    }
+  }
+
+  if (recvBuffer.empty()) {
+    return false;
+  }
+
+  // Find '[' which marks the start of JSON
+  size_t bracketPos = recvBuffer.find('[');
+  if (bracketPos == std::string::npos) {
+    // No '[' found - if buffer is getting large, something is wrong
+    if (recvBuffer.size() > 1000) {
+      recvBuffer.clear();
+    }
+    return false;
+  }
+
+  // Try to extract length from digits before '['
+  // Calibre ALWAYS sends a length prefix, so if it's not valid digits, it's garbage
+  size_t msgLen = 0;
+  bool validPrefix = false;
+
+  if (bracketPos > 0 && bracketPos <= 12) {
+    // Check if prefix is all digits
+    bool allDigits = true;
+    for (size_t i = 0; i < bracketPos; i++) {
+      char c = recvBuffer[i];
+      if (c < '0' || c > '9') {
+        allDigits = false;
+        break;
+      }
+    }
+    if (allDigits) {
+      msgLen = std::stoul(recvBuffer.substr(0, bracketPos));
+      validPrefix = true;
+    }
+  }
+
+  if (!validPrefix) {
+    // Not a valid length prefix - discard everything up to '[' and treat '[' as start
+    if (bracketPos > 0) {
+      recvBuffer = recvBuffer.substr(bracketPos);
+    }
+    // Without length prefix, we can't reliably parse - wait for more data
+    // that hopefully starts with a proper length prefix
+    return false;
+  }
+
+  // Sanity check the message length
+  if (msgLen > 1000000) {
+    recvBuffer = recvBuffer.substr(bracketPos + 1);  // Skip past this '[' and try again
+    return false;
+  }
+
+  // Check if we have the complete message
+  size_t totalNeeded = bracketPos + msgLen;
+  if (recvBuffer.size() < totalNeeded) {
+    // Not enough data yet - wait for more
+    return false;
+  }
+
+  // Extract the message
+  message = recvBuffer.substr(bracketPos, msgLen);
+
+  // Keep the rest in buffer (may contain binary data or next message)
+  if (recvBuffer.size() > totalNeeded) {
+    recvBuffer = recvBuffer.substr(totalNeeded);
+  } else {
+    recvBuffer.clear();
+  }
+
+  return true;
+}
+
+void CalibreWirelessActivity::sendJsonResponse(const OpCode opcode, const std::string& data) {
+  // Format: length + [opcode, {data}]
+  std::string json = "[" + std::to_string(opcode) + "," + data + "]";
+  const std::string lengthPrefix = std::to_string(json.length());
+  json.insert(0, lengthPrefix);
+
+  tcpClient.write(reinterpret_cast<const uint8_t*>(json.c_str()), json.length());
+  tcpClient.flush();
+}
+
+void CalibreWirelessActivity::handleCommand(const OpCode opcode, const std::string& data) {
+  switch (opcode) {
+    case OpCode::GET_INITIALIZATION_INFO:
+      handleGetInitializationInfo(data);
+      break;
+    case OpCode::GET_DEVICE_INFORMATION:
+      handleGetDeviceInformation();
+      break;
+    case OpCode::FREE_SPACE:
+      handleFreeSpace();
+      break;
+    case OpCode::GET_BOOK_COUNT:
+      handleGetBookCount();
+      break;
+    case OpCode::SEND_BOOK:
+      handleSendBook(data);
+      break;
+    case OpCode::SEND_BOOK_METADATA:
+      handleSendBookMetadata(data);
+      break;
+    case OpCode::DISPLAY_MESSAGE:
+      handleDisplayMessage(data);
+      break;
+    case OpCode::NOOP:
+      handleNoop(data);
+      break;
+    case OpCode::SET_CALIBRE_DEVICE_INFO:
+    case OpCode::SET_CALIBRE_DEVICE_NAME:
+      // These set metadata about the connected Calibre instance.
+      // We don't need this info, just acknowledge receipt.
+      sendJsonResponse(OpCode::OK, "{}");
+      break;
+    case OpCode::SET_LIBRARY_INFO:
+      // Library metadata (name, UUID) - not needed for receiving books
+      sendJsonResponse(OpCode::OK, "{}");
+      break;
+    case OpCode::SEND_BOOKLISTS:
+      // Calibre asking us to send our book list. We report 0 books in
+      // handleGetBookCount, so this is effectively a no-op.
+      sendJsonResponse(OpCode::OK, "{}");
+      break;
+    case OpCode::TOTAL_SPACE:
+      handleFreeSpace();
+      break;
+    default:
+      Serial.printf("[%lu] [CAL] Unknown opcode: %d\n", millis(), opcode);
+      sendJsonResponse(OpCode::OK, "{}");
+      break;
+  }
+}
+
+void CalibreWirelessActivity::handleGetInitializationInfo(const std::string& data) {
+  setState(WirelessState::WAITING);
+  setStatus("Connected to " + calibreHostname +
+            "\nWaiting for transfer...\n\nIf transfer fails, enable\n'Ignore free space' in Calibre's\nSmartDevice "
+            "plugin settings.");
+
+  // Build response with device capabilities
+  // Format must match what Calibre expects from a smart device
+  std::string response = "{";
+  response += "\"appName\":\"CrossPoint\",";
+  response += "\"acceptedExtensions\":[\"epub\"],";
+  response += "\"cacheUsesLpaths\":true,";
+  response += "\"canAcceptLibraryInfo\":true,";
+  response += "\"canDeleteMultipleBooks\":true,";
+  response += "\"canReceiveBookBinary\":true,";
+  response += "\"canSendOkToSendbook\":true,";
+  response += "\"canStreamBooks\":true,";
+  response += "\"canStreamMetadata\":true,";
+  response += "\"canUseCachedMetadata\":true,";
+  // ccVersionNumber: Calibre Companion protocol version. 212 matches CC 5.4.20+.
+  // Using a known version ensures compatibility with Calibre's feature detection.
+  response += "\"ccVersionNumber\":212,";
+  // coverHeight: Max cover image height. We don't process covers, so this is informational only.
+  response += "\"coverHeight\":800,";
+  response += "\"deviceKind\":\"CrossPoint\",";
+  response += "\"deviceName\":\"CrossPoint\",";
+  response += "\"extensionPathLengths\":{\"epub\":37},";
+  response += "\"maxBookContentPacketLen\":4096,";
+  response += "\"passwordHash\":\"\",";
+  response += "\"useUuidFileNames\":false,";
+  response += "\"versionOK\":true";
+  response += "}";
+
+  sendJsonResponse(OpCode::OK, response);
+}
+
+void CalibreWirelessActivity::handleGetDeviceInformation() {
+  std::string response = "{";
+  response += "\"device_info\":{";
+  response += "\"device_store_uuid\":\"" + getDeviceUuid() + "\",";
+  response += "\"device_name\":\"CrossPoint Reader\",";
+  response += "\"device_version\":\"" CROSSPOINT_VERSION "\"";
+  response += "},";
+  response += "\"version\":1,";
+  response += "\"device_version\":\"" CROSSPOINT_VERSION "\"";
+  response += "}";
+
+  sendJsonResponse(OpCode::OK, response);
+}
+
+void CalibreWirelessActivity::handleFreeSpace() {
+  // TODO: Report actual SD card free space instead of hardcoded value
+  // Report 10GB free space for now
+  sendJsonResponse(OpCode::OK, "{\"free_space_on_device\":10737418240}");
+}
+
+void CalibreWirelessActivity::handleGetBookCount() {
+  // We report 0 books - Calibre will send books without checking for duplicates
+  std::string response = "{\"count\":0,\"willStream\":true,\"willScan\":false}";
+  sendJsonResponse(OpCode::OK, response);
+}
+
+void CalibreWirelessActivity::handleSendBook(const std::string& data) {
+  // Manually extract lpath and length from SEND_BOOK data
+  // Full JSON parsing crashes on large metadata, so we just extract what we need
+
+  // Extract "lpath" field - format: "lpath": "value"
+  std::string lpath;
+  size_t lpathPos = data.find("\"lpath\"");
+  if (lpathPos != std::string::npos) {
+    size_t colonPos = data.find(':', lpathPos + 7);
+    if (colonPos != std::string::npos) {
+      size_t quoteStart = data.find('"', colonPos + 1);
+      if (quoteStart != std::string::npos) {
+        size_t quoteEnd = data.find('"', quoteStart + 1);
+        if (quoteEnd != std::string::npos) {
+          lpath = data.substr(quoteStart + 1, quoteEnd - quoteStart - 1);
+        }
+      }
+    }
+  }
+
+  // Extract top-level "length" field - must track depth to skip nested objects
+  // The metadata contains nested "length" fields (e.g., cover image length)
+  size_t length = 0;
+  int depth = 0;
+  for (size_t i = 0; i < data.size(); i++) {
+    char c = data[i];
+    if (c == '{' || c == '[') {
+      depth++;
+    } else if (c == '}' || c == ']') {
+      depth--;
+    } else if (depth == 1 && c == '"') {
+      // At top level, check if this is "length"
+      if (i + 9 < data.size() && data.substr(i, 8) == "\"length\"") {
+        // Found top-level "length" - extract the number after ':'
+        size_t colonPos = data.find(':', i + 8);
+        if (colonPos != std::string::npos) {
+          size_t numStart = colonPos + 1;
+          while (numStart < data.size() && (data[numStart] == ' ' || data[numStart] == '\t')) {
+            numStart++;
+          }
+          size_t numEnd = numStart;
+          while (numEnd < data.size() && data[numEnd] >= '0' && data[numEnd] <= '9') {
+            numEnd++;
+          }
+          if (numEnd > numStart) {
+            length = std::stoul(data.substr(numStart, numEnd - numStart));
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  if (lpath.empty() || length == 0) {
+    sendJsonResponse(OpCode::ERROR, "{\"message\":\"Invalid book data\"}");
+    return;
+  }
+
+  // Extract filename from lpath
+  std::string filename = lpath;
+  const size_t lastSlash = filename.rfind('/');
+  if (lastSlash != std::string::npos) {
+    filename = filename.substr(lastSlash + 1);
+  }
+
+  // Sanitize and create full path
+  currentFilename = "/" + StringUtils::sanitizeFilename(filename);
+  if (!StringUtils::checkFileExtension(currentFilename, ".epub")) {
+    currentFilename += ".epub";
+  }
+  currentFileSize = length;
+  bytesReceived = 0;
+
+  setState(WirelessState::RECEIVING);
+  setStatus("Receiving: " + filename);
+
+  // Open file for writing
+  if (!SdMan.openFileForWrite("CAL", currentFilename.c_str(), currentFile)) {
+    setError("Failed to create file");
+    sendJsonResponse(OpCode::ERROR, "{\"message\":\"Failed to create file\"}");
+    return;
+  }
+
+  // Send OK to start receiving binary data
+  sendJsonResponse(OpCode::OK, "{}");
+
+  // Switch to binary mode
+  inBinaryMode = true;
+  binaryBytesRemaining = length;
+
+  // Check if recvBuffer has leftover data (binary file data that arrived with the JSON)
+  if (!recvBuffer.empty()) {
+    size_t toWrite = std::min(recvBuffer.size(), binaryBytesRemaining);
+    size_t written = currentFile.write(reinterpret_cast<const uint8_t*>(recvBuffer.data()), toWrite);
+    bytesReceived += written;
+    binaryBytesRemaining -= written;
+    recvBuffer = recvBuffer.substr(toWrite);
+    updateRequired = true;
+  }
+}
+
+void CalibreWirelessActivity::handleSendBookMetadata(const std::string& data) {
+  // We receive metadata after the book - just acknowledge
+  sendJsonResponse(OpCode::OK, "{}");
+}
+
+void CalibreWirelessActivity::handleDisplayMessage(const std::string& data) {
+  // Calibre may send messages to display
+  // Check messageKind - 1 means password error
+  if (data.find("\"messageKind\":1") != std::string::npos) {
+    setError("Password required");
+  }
+  sendJsonResponse(OpCode::OK, "{}");
+}
+
+void CalibreWirelessActivity::handleNoop(const std::string& data) {
+  // Check for ejecting flag
+  if (data.find("\"ejecting\":true") != std::string::npos) {
+    setState(WirelessState::DISCONNECTED);
+    setStatus("Calibre disconnected");
+  }
+  sendJsonResponse(OpCode::NOOP, "{}");
+}
+
+void CalibreWirelessActivity::receiveBinaryData() {
+  const int available = tcpClient.available();
+  if (available == 0) {
+    // Check if connection is still alive
+    if (!tcpClient.connected()) {
+      currentFile.close();
+      inBinaryMode = false;
+      setError("Transfer interrupted");
+    }
+    return;
+  }
+
+  uint8_t buffer[1024];
+  const size_t toRead = std::min(sizeof(buffer), binaryBytesRemaining);
+  const size_t bytesRead = tcpClient.read(buffer, toRead);
+
+  if (bytesRead > 0) {
+    currentFile.write(buffer, bytesRead);
+    bytesReceived += bytesRead;
+    binaryBytesRemaining -= bytesRead;
+    updateRequired = true;
+
+    if (binaryBytesRemaining == 0) {
+      // Transfer complete
+      currentFile.flush();
+      currentFile.close();
+      inBinaryMode = false;
+
+      setState(WirelessState::WAITING);
+      setStatus("Received: " + currentFilename + "\nWaiting for more...");
+
+      // Send OK to acknowledge completion
+      sendJsonResponse(OpCode::OK, "{}");
+    }
+  }
+}
+
+void CalibreWirelessActivity::render() const {
+  renderer.clearScreen();
+
+  const auto pageWidth = renderer.getScreenWidth();
+  const auto pageHeight = renderer.getScreenHeight();
+
+  // Draw header
+  renderer.drawCenteredText(UI_12_FONT_ID, 30, "Calibre Wireless", true, EpdFontFamily::BOLD);
+
+  // Draw IP address
+  const std::string ipAddr = WiFi.localIP().toString().c_str();
+  renderer.drawCenteredText(UI_10_FONT_ID, 60, ("IP: " + ipAddr).c_str());
+
+  // Draw status message
+  int statusY = pageHeight / 2 - 40;
+
+  // Split status message by newlines and draw each line
+  std::string status = statusMessage;
+  size_t pos = 0;
+  while ((pos = status.find('\n')) != std::string::npos) {
+    renderer.drawCenteredText(UI_10_FONT_ID, statusY, status.substr(0, pos).c_str());
+    statusY += 25;
+    status = status.substr(pos + 1);
+  }
+  if (!status.empty()) {
+    renderer.drawCenteredText(UI_10_FONT_ID, statusY, status.c_str());
+    statusY += 25;
+  }
+
+  // Draw progress if receiving
+  if (state == WirelessState::RECEIVING && currentFileSize > 0) {
+    const int barWidth = pageWidth - 100;
+    constexpr int barHeight = 20;
+    constexpr int barX = 50;
+    const int barY = statusY + 20;
+    ScreenComponents::drawProgressBar(renderer, barX, barY, barWidth, barHeight, bytesReceived, currentFileSize);
+  }
+
+  // Draw error if present
+  if (!errorMessage.empty()) {
+    renderer.drawCenteredText(UI_10_FONT_ID, pageHeight - 120, errorMessage.c_str());
+  }
+
+  // Draw button hints
+  const auto labels = mappedInput.mapLabels("Back", "", "", "");
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+
+  renderer.displayBuffer();
+}
+
+std::string CalibreWirelessActivity::getDeviceUuid() const {
+  // Generate a consistent UUID based on MAC address
+  uint8_t mac[6];
+  WiFi.macAddress(mac);
+
+  char uuid[37];
+  snprintf(uuid, sizeof(uuid), "%02x%02x%02x%02x-%02x%02x-4000-8000-%02x%02x%02x%02x%02x%02x", mac[0], mac[1], mac[2],
+           mac[3], mac[4], mac[5], mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+
+  return std::string(uuid);
+}
+
+void CalibreWirelessActivity::setState(WirelessState newState) {
+  xSemaphoreTake(stateMutex, portMAX_DELAY);
+  state = newState;
+  xSemaphoreGive(stateMutex);
+  updateRequired = true;
+}
+
+void CalibreWirelessActivity::setStatus(const std::string& message) {
+  statusMessage = message;
+  updateRequired = true;
+}
+
+void CalibreWirelessActivity::setError(const std::string& message) {
+  errorMessage = message;
+  setState(WirelessState::ERROR);
+}

src/activities/network/CalibreWirelessActivity.h

@@ -0,0 +1,135 @@
+#pragma once
+#include <SDCardManager.h>
+#include <WiFiClient.h>
+#include <WiFiUdp.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+#include <string>
+
+#include "activities/Activity.h"
+
+/**
+ * CalibreWirelessActivity implements Calibre's "wireless device" protocol.
+ * This allows Calibre desktop to send books directly to the device over WiFi.
+ *
+ * Protocol specification sourced from Calibre's smart device driver:
+ * https://github.com/kovidgoyal/calibre/blob/master/src/calibre/devices/smart_device_app/driver.py
+ *
+ * Protocol overview:
+ * 1. Device broadcasts "hello" on UDP ports 54982, 48123, 39001, 44044, 59678
+ * 2. Calibre responds with its TCP server address
+ * 3. Device connects to Calibre's TCP server
+ * 4. Calibre sends JSON commands with length-prefixed messages
+ * 5. Books are transferred as binary data after SEND_BOOK command
+ */
+class CalibreWirelessActivity final : public Activity {
+  // Calibre wireless device states
+  enum class WirelessState {
+    DISCOVERING,   // Listening for Calibre server broadcasts
+    CONNECTING,    // Establishing TCP connection
+    WAITING,       // Connected, waiting for commands
+    RECEIVING,     // Receiving a book file
+    COMPLETE,      // Transfer complete
+    DISCONNECTED,  // Calibre disconnected
+    ERROR          // Connection/transfer error
+  };
+
+  // Calibre protocol opcodes (from calibre/devices/smart_device_app/driver.py)
+  enum OpCode : uint8_t {
+    OK = 0,
+    SET_CALIBRE_DEVICE_INFO = 1,
+    SET_CALIBRE_DEVICE_NAME = 2,
+    GET_DEVICE_INFORMATION = 3,
+    TOTAL_SPACE = 4,
+    FREE_SPACE = 5,
+    GET_BOOK_COUNT = 6,
+    SEND_BOOKLISTS = 7,
+    SEND_BOOK = 8,
+    GET_INITIALIZATION_INFO = 9,
+    BOOK_DONE = 11,
+    NOOP = 12,  // Was incorrectly 18
+    DELETE_BOOK = 13,
+    GET_BOOK_FILE_SEGMENT = 14,
+    GET_BOOK_METADATA = 15,
+    SEND_BOOK_METADATA = 16,
+    DISPLAY_MESSAGE = 17,
+    CALIBRE_BUSY = 18,
+    SET_LIBRARY_INFO = 19,
+    ERROR = 20,
+  };
+
+  TaskHandle_t displayTaskHandle = nullptr;
+  TaskHandle_t networkTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  SemaphoreHandle_t stateMutex = nullptr;
+  bool updateRequired = false;
+
+  WirelessState state = WirelessState::DISCOVERING;
+  const std::function<void()> onComplete;
+
+  // UDP discovery
+  WiFiUDP udp;
+
+  // TCP connection (we connect to Calibre)
+  WiFiClient tcpClient;
+  std::string calibreHost;
+  uint16_t calibrePort = 0;
+  uint16_t calibreAltPort = 0;  // Alternative port (content server)
+  std::string calibreHostname;
+
+  // Transfer state
+  std::string currentFilename;
+  size_t currentFileSize = 0;
+  size_t bytesReceived = 0;
+  std::string statusMessage;
+  std::string errorMessage;
+
+  // Protocol state
+  bool inBinaryMode = false;
+  size_t binaryBytesRemaining = 0;
+  FsFile currentFile;
+  std::string recvBuffer;  // Buffer for incoming data (like KOReader)
+
+  static void displayTaskTrampoline(void* param);
+  static void networkTaskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  [[noreturn]] void networkTaskLoop();
+  void render() const;
+
+  // Network operations
+  void listenForDiscovery();
+  void handleTcpClient();
+  bool readJsonMessage(std::string& message);
+  void sendJsonResponse(OpCode opcode, const std::string& data);
+  void handleCommand(OpCode opcode, const std::string& data);
+  void receiveBinaryData();
+
+  // Protocol handlers
+  void handleGetInitializationInfo(const std::string& data);
+  void handleGetDeviceInformation();
+  void handleFreeSpace();
+  void handleGetBookCount();
+  void handleSendBook(const std::string& data);
+  void handleSendBookMetadata(const std::string& data);
+  void handleDisplayMessage(const std::string& data);
+  void handleNoop(const std::string& data);
+
+  // Utility
+  std::string getDeviceUuid() const;
+  void setState(WirelessState newState);
+  void setStatus(const std::string& message);
+  void setError(const std::string& message);
+
+ public:
+  explicit CalibreWirelessActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
+                                   const std::function<void()>& onComplete)
+      : Activity("CalibreWireless", renderer, mappedInput), onComplete(onComplete) {}
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+  bool preventAutoSleep() override { return true; }
+  bool skipLoopDelay() override { return true; }
+};

src/activities/reader/EpubReaderActivity.cpp

@@ -17,8 +17,6 @@ namespace {
 // pagesPerRefresh now comes from SETTINGS.getRefreshFrequency()
 constexpr unsigned long skipChapterMs = 700;
 constexpr unsigned long goHomeMs = 1000;
-constexpr int topPadding = 5;
-constexpr int horizontalPadding = 5;
 constexpr int statusBarMargin = 19;
 }  // namespace
 
@@ -156,6 +154,8 @@ void EpubReaderActivity::loop() {
   const bool prevReleased = mappedInput.wasReleased(MappedInputManager::Button::PageBack) ||
                             mappedInput.wasReleased(MappedInputManager::Button::Left);
   const bool nextReleased = mappedInput.wasReleased(MappedInputManager::Button::PageForward) ||
+                            (SETTINGS.shortPwrBtn == CrossPointSettings::SHORT_PWRBTN::PAGE_TURN &&
+                             mappedInput.wasReleased(MappedInputManager::Button::Power)) ||
                             mappedInput.wasReleased(MappedInputManager::Button::Right);
 
   if (!prevReleased && !nextReleased) {
@@ -255,9 +255,9 @@ void EpubReaderActivity::renderScreen() {
   int orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft;
   renderer.getOrientedViewableTRBL(&orientedMarginTop, &orientedMarginRight, &orientedMarginBottom,
                                    &orientedMarginLeft);
-  orientedMarginTop += topPadding;
-  orientedMarginLeft += horizontalPadding;
-  orientedMarginRight += horizontalPadding;
+  orientedMarginTop += SETTINGS.screenMargin;
+  orientedMarginLeft += SETTINGS.screenMargin;
+  orientedMarginRight += SETTINGS.screenMargin;
   orientedMarginBottom += statusBarMargin;
 
   if (!section) {
@@ -392,7 +392,7 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
 
   // grayscale rendering
   // TODO: Only do this if font supports it
-  {
+  if (SETTINGS.textAntiAliasing) {
     renderer.clearScreen(0x00);
     renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
     page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop);
@@ -421,6 +421,8 @@ void EpubReaderActivity::renderStatusBar(const int orientedMarginRight, const in
                            SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
   const bool showChapterTitle = SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::NO_PROGRESS ||
                                 SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
+  const bool showBatteryPercentage =
+      SETTINGS.hideBatteryPercentage == CrossPointSettings::HIDE_BATTERY_PERCENTAGE::HIDE_NEVER;
 
   // Position status bar near the bottom of the logical screen, regardless of orientation
   const auto screenHeight = renderer.getScreenHeight();
@@ -441,7 +443,7 @@ void EpubReaderActivity::renderStatusBar(const int orientedMarginRight, const in
   }
 
   if (showBattery) {
-    ScreenComponents::drawBattery(renderer, orientedMarginLeft, textY);
+    ScreenComponents::drawBattery(renderer, orientedMarginLeft + 1, textY, showBatteryPercentage);
   }
 
   if (showChapterTitle) {

src/activities/reader/EpubReaderChapterSelectionActivity.cpp

@@ -16,7 +16,9 @@ int EpubReaderChapterSelectionActivity::getPageItems() const {
   constexpr int lineHeight = 30;
 
   const int screenHeight = renderer.getScreenHeight();
-  const int availableHeight = screenHeight - startY;
+  const int endY = screenHeight - lineHeight;
+
+  const int availableHeight = endY - startY;
   int items = availableHeight / lineHeight;
 
   // Ensure we always have at least one item per page to avoid division by zero
@@ -134,5 +136,8 @@ void EpubReaderChapterSelectionActivity::renderScreen() {
                       tocIndex != selectorIndex);
   }
 
+  const auto labels = mappedInput.mapLabels("« Back", "Select", "Up", "Down");
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+
   renderer.displayBuffer();
 }

src/activities/reader/FileSelectionActivity.cpp

@@ -5,6 +5,7 @@
 
 #include "MappedInputManager.h"
 #include "fontIds.h"
+#include "util/StringUtils.h"
 
 namespace {
 constexpr int PAGE_ITEMS = 23;
@@ -29,7 +30,6 @@ void FileSelectionActivity::taskTrampoline(void* param) {
 
 void FileSelectionActivity::loadFiles() {
   files.clear();
-  selectorIndex = 0;
 
   auto root = SdMan.open(basepath.c_str());
   if (!root || !root.isDirectory()) {
@@ -39,7 +39,7 @@ void FileSelectionActivity::loadFiles() {
 
   root.rewindDirectory();
 
-  char name[128];
+  char name[500];
   for (auto file = root.openNextFile(); file; file = root.openNextFile()) {
     file.getName(name, sizeof(name));
     if (name[0] == '.' || strcmp(name, "System Volume Information") == 0) {
@@ -51,9 +51,8 @@ void FileSelectionActivity::loadFiles() {
       files.emplace_back(std::string(name) + "/");
     } else {
       auto filename = std::string(name);
-      std::string ext4 = filename.length() >= 4 ? filename.substr(filename.length() - 4) : "";
-      std::string ext5 = filename.length() >= 5 ? filename.substr(filename.length() - 5) : "";
-      if (ext5 == ".epub" || ext5 == ".xtch" || ext4 == ".xtc") {
+      if (StringUtils::checkFileExtension(filename, ".epub") || StringUtils::checkFileExtension(filename, ".xtch") ||
+          StringUtils::checkFileExtension(filename, ".xtc")) {
         files.emplace_back(filename);
       }
     }
@@ -124,6 +123,7 @@ void FileSelectionActivity::loop() {
     if (files[selectorIndex].back() == '/') {
       basepath += files[selectorIndex].substr(0, files[selectorIndex].length() - 1);
       loadFiles();
+      selectorIndex = 0;
       updateRequired = true;
     } else {
       onSelect(basepath + files[selectorIndex]);
@@ -132,9 +132,16 @@ void FileSelectionActivity::loop() {
     // Short press: go up one directory, or go home if at root
     if (mappedInput.getHeldTime() < GO_HOME_MS) {
       if (basepath != "/") {
+        const std::string oldPath = basepath;
+
         basepath.replace(basepath.find_last_of('/'), std::string::npos, "");
         if (basepath.empty()) basepath = "/";
         loadFiles();
+
+        const auto pos = oldPath.find_last_of('/');
+        const std::string dirName = oldPath.substr(pos + 1) + "/";
+        selectorIndex = findEntry(dirName);
+
         updateRequired = true;
       } else {
         onGoHome();
@@ -187,10 +194,16 @@ void FileSelectionActivity::render() const {
 
   const auto pageStartIndex = selectorIndex / PAGE_ITEMS * PAGE_ITEMS;
   renderer.fillRect(0, 60 + (selectorIndex % PAGE_ITEMS) * 30 - 2, pageWidth - 1, 30);
-  for (int i = pageStartIndex; i < files.size() && i < pageStartIndex + PAGE_ITEMS; i++) {
+  for (size_t i = pageStartIndex; i < files.size() && i < pageStartIndex + PAGE_ITEMS; i++) {
     auto item = renderer.truncatedText(UI_10_FONT_ID, files[i].c_str(), renderer.getScreenWidth() - 40);
     renderer.drawText(UI_10_FONT_ID, 20, 60 + (i % PAGE_ITEMS) * 30, item.c_str(), i != selectorIndex);
   }
 
   renderer.displayBuffer();
 }
+
+size_t FileSelectionActivity::findEntry(const std::string& name) const {
+  for (size_t i = 0; i < files.size(); i++)
+    if (files[i] == name) return i;
+  return 0;
+}

src/activities/reader/FileSelectionActivity.h

@@ -14,7 +14,7 @@ class FileSelectionActivity final : public Activity {
   SemaphoreHandle_t renderingMutex = nullptr;
   std::string basepath = "/";
   std::vector<std::string> files;
-  int selectorIndex = 0;
+  size_t selectorIndex = 0;
   bool updateRequired = false;
   const std::function<void(const std::string&)> onSelect;
   const std::function<void()> onGoHome;
@@ -24,6 +24,8 @@ class FileSelectionActivity final : public Activity {
   void render() const;
   void loadFiles();
 
+  size_t findEntry(const std::string& name) const;
+
  public:
   explicit FileSelectionActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
                                  const std::function<void(const std::string&)>& onSelect,

src/activities/reader/ReaderActivity.cpp

@@ -6,6 +6,7 @@
 #include "Xtc.h"
 #include "XtcReaderActivity.h"
 #include "activities/util/FullScreenMessageActivity.h"
+#include "util/StringUtils.h"
 
 std::string ReaderActivity::extractFolderPath(const std::string& filePath) {
   const auto lastSlash = filePath.find_last_of('/');
@@ -16,14 +17,7 @@ std::string ReaderActivity::extractFolderPath(const std::string& filePath) {
 }
 
 bool ReaderActivity::isXtcFile(const std::string& path) {
-  if (path.length() < 4) return false;
-  std::string ext4 = path.substr(path.length() - 4);
-  if (ext4 == ".xtc") return true;
-  if (path.length() >= 5) {
-    std::string ext5 = path.substr(path.length() - 5);
-    if (ext5 == ".xtch") return true;
-  }
-  return false;
+  return StringUtils::checkFileExtension(path, ".xtc") || StringUtils::checkFileExtension(path, ".xtch");
 }
 
 std::unique_ptr<Epub> ReaderActivity::loadEpub(const std::string& path) {

src/activities/reader/XtcReaderActivity.cpp

@@ -114,6 +114,8 @@ void XtcReaderActivity::loop() {
   const bool prevReleased = mappedInput.wasReleased(MappedInputManager::Button::PageBack) ||
                             mappedInput.wasReleased(MappedInputManager::Button::Left);
   const bool nextReleased = mappedInput.wasReleased(MappedInputManager::Button::PageForward) ||
+                            (SETTINGS.shortPwrBtn == CrossPointSettings::SHORT_PWRBTN::PAGE_TURN &&
+                             mappedInput.wasReleased(MappedInputManager::Button::Power)) ||
                             mappedInput.wasReleased(MappedInputManager::Button::Right);
 
   if (!prevReleased && !nextReleased) {

src/activities/reader/XtcReaderChapterSelectionActivity.cpp

@@ -14,7 +14,9 @@ int XtcReaderChapterSelectionActivity::getPageItems() const {
   constexpr int lineHeight = 30;
 
   const int screenHeight = renderer.getScreenHeight();
-  const int availableHeight = screenHeight - startY;
+  const int endY = screenHeight - lineHeight;
+
+  const int availableHeight = endY - startY;
   int items = availableHeight / lineHeight;
   if (items < 1) {
     items = 1;
@@ -147,5 +149,8 @@ void XtcReaderChapterSelectionActivity::renderScreen() {
     renderer.drawText(UI_10_FONT_ID, 20, 60 + (i % pageItems) * 30, title, i != selectorIndex);
   }
 
+  const auto labels = mappedInput.mapLabels("« Back", "Select", "Up", "Down");
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+
   renderer.displayBuffer();
 }

src/activities/settings/CalibreSettingsActivity.cpp

@@ -0,0 +1,169 @@
+#include "CalibreSettingsActivity.h"
+
+#include <GfxRenderer.h>
+#include <WiFi.h>
+
+#include <cstring>
+
+#include "CrossPointSettings.h"
+#include "MappedInputManager.h"
+#include "activities/network/CalibreWirelessActivity.h"
+#include "activities/network/WifiSelectionActivity.h"
+#include "activities/util/KeyboardEntryActivity.h"
+#include "fontIds.h"
+
+namespace {
+constexpr int MENU_ITEMS = 2;
+const char* menuNames[MENU_ITEMS] = {"Calibre Web URL", "Connect as Wireless Device"};
+}  // namespace
+
+void CalibreSettingsActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<CalibreSettingsActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void CalibreSettingsActivity::onEnter() {
+  ActivityWithSubactivity::onEnter();
+
+  renderingMutex = xSemaphoreCreateMutex();
+  selectedIndex = 0;
+  updateRequired = true;
+
+  xTaskCreate(&CalibreSettingsActivity::taskTrampoline, "CalibreSettingsTask",
+              4096,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+}
+
+void CalibreSettingsActivity::onExit() {
+  ActivityWithSubactivity::onExit();
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void CalibreSettingsActivity::loop() {
+  if (subActivity) {
+    subActivity->loop();
+    return;
+  }
+
+  if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
+    onBack();
+    return;
+  }
+
+  if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
+    handleSelection();
+    return;
+  }
+
+  if (mappedInput.wasPressed(MappedInputManager::Button::Up) ||
+      mappedInput.wasPressed(MappedInputManager::Button::Left)) {
+    selectedIndex = (selectedIndex + MENU_ITEMS - 1) % MENU_ITEMS;
+    updateRequired = true;
+  } else if (mappedInput.wasPressed(MappedInputManager::Button::Down) ||
+             mappedInput.wasPressed(MappedInputManager::Button::Right)) {
+    selectedIndex = (selectedIndex + 1) % MENU_ITEMS;
+    updateRequired = true;
+  }
+}
+
+void CalibreSettingsActivity::handleSelection() {
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+
+  if (selectedIndex == 0) {
+    // Calibre Web URL
+    exitActivity();
+    enterNewActivity(new KeyboardEntryActivity(
+        renderer, mappedInput, "Calibre Web URL", SETTINGS.opdsServerUrl, 10,
+        127,    // maxLength
+        false,  // not password
+        [this](const std::string& url) {
+          strncpy(SETTINGS.opdsServerUrl, url.c_str(), sizeof(SETTINGS.opdsServerUrl) - 1);
+          SETTINGS.opdsServerUrl[sizeof(SETTINGS.opdsServerUrl) - 1] = '\0';
+          SETTINGS.saveToFile();
+          exitActivity();
+          updateRequired = true;
+        },
+        [this]() {
+          exitActivity();
+          updateRequired = true;
+        }));
+  } else if (selectedIndex == 1) {
+    // Wireless Device - launch the activity (handles WiFi connection internally)
+    exitActivity();
+    if (WiFi.status() != WL_CONNECTED) {
+      enterNewActivity(new WifiSelectionActivity(renderer, mappedInput, [this](bool connected) {
+        exitActivity();
+        if (connected) {
+          enterNewActivity(new CalibreWirelessActivity(renderer, mappedInput, [this] {
+            exitActivity();
+            updateRequired = true;
+          }));
+        } else {
+          updateRequired = true;
+        }
+      }));
+    } else {
+      enterNewActivity(new CalibreWirelessActivity(renderer, mappedInput, [this] {
+        exitActivity();
+        updateRequired = true;
+      }));
+    }
+  }
+
+  xSemaphoreGive(renderingMutex);
+}
+
+void CalibreSettingsActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired && !subActivity) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void CalibreSettingsActivity::render() {
+  renderer.clearScreen();
+
+  const auto pageWidth = renderer.getScreenWidth();
+
+  // Draw header
+  renderer.drawCenteredText(UI_12_FONT_ID, 15, "Calibre", true, EpdFontFamily::BOLD);
+
+  // Draw selection highlight
+  renderer.fillRect(0, 60 + selectedIndex * 30 - 2, pageWidth - 1, 30);
+
+  // Draw menu items
+  for (int i = 0; i < MENU_ITEMS; i++) {
+    const int settingY = 60 + i * 30;
+    const bool isSelected = (i == selectedIndex);
+
+    renderer.drawText(UI_10_FONT_ID, 20, settingY, menuNames[i], !isSelected);
+
+    // Draw status for URL setting
+    if (i == 0) {
+      const char* status = (strlen(SETTINGS.opdsServerUrl) > 0) ? "[Set]" : "[Not Set]";
+      const auto width = renderer.getTextWidth(UI_10_FONT_ID, status);
+      renderer.drawText(UI_10_FONT_ID, pageWidth - 20 - width, settingY, status, !isSelected);
+    }
+  }
+
+  // Draw button hints
+  const auto labels = mappedInput.mapLabels("« Back", "Select", "", "");
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+
+  renderer.displayBuffer();
+}

src/activities/settings/CalibreSettingsActivity.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+
+#include "activities/ActivityWithSubactivity.h"
+
+/**
+ * Submenu for Calibre settings.
+ * Shows Calibre Web URL and Calibre Wireless Device options.
+ */
+class CalibreSettingsActivity final : public ActivityWithSubactivity {
+ public:
+  explicit CalibreSettingsActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
+                                   const std::function<void()>& onBack)
+      : ActivityWithSubactivity("CalibreSettings", renderer, mappedInput), onBack(onBack) {}
+
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+
+ private:
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+
+  int selectedIndex = 0;
+  const std::function<void()> onBack;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render();
+  void handleSelection();
+};

src/activities/settings/SettingsActivity.cpp

@@ -1,7 +1,11 @@
 #include "SettingsActivity.h"
 
 #include <GfxRenderer.h>
+#include <HardwareSerial.h>
 
+#include <cstring>
+
+#include "CalibreSettingsActivity.h"
 #include "CrossPointSettings.h"
 #include "MappedInputManager.h"
 #include "OtaUpdateActivity.h"
@@ -9,45 +13,35 @@
 
 // Define the static settings list
 namespace {
-constexpr int settingsCount = 14;
+constexpr int settingsCount = 19;
 const SettingInfo settingsList[settingsCount] = {
     // Should match with SLEEP_SCREEN_MODE
-    {"Sleep Screen", SettingType::ENUM, &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover"}},
-    {"Status Bar", SettingType::ENUM, &CrossPointSettings::statusBar, {"None", "No Progress", "Full"}},
-    {"Extra Paragraph Spacing", SettingType::TOGGLE, &CrossPointSettings::extraParagraphSpacing, {}},
-    {"Short Power Button Click", SettingType::TOGGLE, &CrossPointSettings::shortPwrBtn, {}},
-    {"Reading Orientation",
-     SettingType::ENUM,
-     &CrossPointSettings::orientation,
-     {"Portrait", "Landscape CW", "Inverted", "Landscape CCW"}},
-    {"Front Button Layout",
-     SettingType::ENUM,
-     &CrossPointSettings::frontButtonLayout,
-     {"Bck, Cnfrm, Lft, Rght", "Lft, Rght, Bck, Cnfrm", "Lft, Bck, Cnfrm, Rght"}},
-    {"Side Button Layout (reader)",
-     SettingType::ENUM,
-     &CrossPointSettings::sideButtonLayout,
-     {"Prev, Next", "Next, Prev"}},
-    {"Reader Font Family",
-     SettingType::ENUM,
-     &CrossPointSettings::fontFamily,
-     {"Bookerly", "Noto Sans", "Open Dyslexic"}},
-    {"Reader Font Size", SettingType::ENUM, &CrossPointSettings::fontSize, {"Small", "Medium", "Large", "X Large"}},
-    {"Reader Line Spacing", SettingType::ENUM, &CrossPointSettings::lineSpacing, {"Tight", "Normal", "Wide"}},
-    {"Reader Paragraph Alignment",
-     SettingType::ENUM,
-     &CrossPointSettings::paragraphAlignment,
-     {"Justify", "Left", "Center", "Right"}},
-    {"Time to Sleep",
-     SettingType::ENUM,
-     &CrossPointSettings::sleepTimeout,
-     {"1 min", "5 min", "10 min", "15 min", "30 min"}},
-    {"Refresh Frequency",
-     SettingType::ENUM,
-     &CrossPointSettings::refreshFrequency,
-     {"1 page", "5 pages", "10 pages", "15 pages", "30 pages"}},
-    {"Check for updates", SettingType::ACTION, nullptr, {}},
-};
+    SettingInfo::Enum("Sleep Screen", &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover", "None"}),
+    SettingInfo::Enum("Sleep Screen Cover Mode", &CrossPointSettings::sleepScreenCoverMode, {"Fit", "Crop"}),
+    SettingInfo::Enum("Status Bar", &CrossPointSettings::statusBar, {"None", "No Progress", "Full"}),
+    SettingInfo::Enum("Hide Battery %", &CrossPointSettings::hideBatteryPercentage, {"Never", "In Reader", "Always"}),
+    SettingInfo::Toggle("Extra Paragraph Spacing", &CrossPointSettings::extraParagraphSpacing),
+    SettingInfo::Toggle("Text Anti-Aliasing", &CrossPointSettings::textAntiAliasing),
+    SettingInfo::Enum("Short Power Button Click", &CrossPointSettings::shortPwrBtn, {"Ignore", "Sleep", "Page Turn"}),
+    SettingInfo::Enum("Reading Orientation", &CrossPointSettings::orientation,
+                      {"Portrait", "Landscape CW", "Inverted", "Landscape CCW"}),
+    SettingInfo::Enum("Front Button Layout", &CrossPointSettings::frontButtonLayout,
+                      {"Bck, Cnfrm, Lft, Rght", "Lft, Rght, Bck, Cnfrm", "Lft, Bck, Cnfrm, Rght"}),
+    SettingInfo::Enum("Side Button Layout (reader)", &CrossPointSettings::sideButtonLayout,
+                      {"Prev, Next", "Next, Prev"}),
+    SettingInfo::Enum("Reader Font Family", &CrossPointSettings::fontFamily,
+                      {"Bookerly", "Noto Sans", "Open Dyslexic"}),
+    SettingInfo::Enum("Reader Font Size", &CrossPointSettings::fontSize, {"Small", "Medium", "Large", "X Large"}),
+    SettingInfo::Enum("Reader Line Spacing", &CrossPointSettings::lineSpacing, {"Tight", "Normal", "Wide"}),
+    SettingInfo::Value("Reader Screen Margin", &CrossPointSettings::screenMargin, {5, 40, 5}),
+    SettingInfo::Enum("Reader Paragraph Alignment", &CrossPointSettings::paragraphAlignment,
+                      {"Justify", "Left", "Center", "Right"}),
+    SettingInfo::Enum("Time to Sleep", &CrossPointSettings::sleepTimeout,
+                      {"1 min", "5 min", "10 min", "15 min", "30 min"}),
+    SettingInfo::Enum("Refresh Frequency", &CrossPointSettings::refreshFrequency,
+                      {"1 page", "5 pages", "10 pages", "15 pages", "30 pages"}),
+    SettingInfo::Action("Calibre Settings"),
+    SettingInfo::Action("Check for updates")};
 }  // namespace
 
 void SettingsActivity::taskTrampoline(void* param) {
@@ -57,7 +51,6 @@ void SettingsActivity::taskTrampoline(void* param) {
 
 void SettingsActivity::onEnter() {
   Activity::onEnter();
-
   renderingMutex = xSemaphoreCreateMutex();
 
   // Reset selection to first item
@@ -67,7 +60,7 @@ void SettingsActivity::onEnter() {
   updateRequired = true;
 
   xTaskCreate(&SettingsActivity::taskTrampoline, "SettingsActivityTask",
-              2048,               // Stack size
+              4096,               // Stack size
               this,               // Parameters
               1,                  // Priority
               &displayTaskHandle  // Task handle
@@ -114,11 +107,9 @@ void SettingsActivity::loop() {
     updateRequired = true;
   } else if (mappedInput.wasPressed(MappedInputManager::Button::Down) ||
              mappedInput.wasPressed(MappedInputManager::Button::Right)) {
-    // Move selection down
-    if (selectedSettingIndex < settingsCount - 1) {
-      selectedSettingIndex++;
-      updateRequired = true;
-    }
+    // Move selection down (with wrap around)
+    selectedSettingIndex = (selectedSettingIndex < settingsCount - 1) ? (selectedSettingIndex + 1) : 0;
+    updateRequired = true;
   }
 }
 
@@ -137,8 +128,25 @@ void SettingsActivity::toggleCurrentSetting() {
   } else if (setting.type == SettingType::ENUM && setting.valuePtr != nullptr) {
     const uint8_t currentValue = SETTINGS.*(setting.valuePtr);
     SETTINGS.*(setting.valuePtr) = (currentValue + 1) % static_cast<uint8_t>(setting.enumValues.size());
+  } else if (setting.type == SettingType::VALUE && setting.valuePtr != nullptr) {
+    // Decreasing would also be nice for large ranges I think but oh well can't have everything
+    const int8_t currentValue = SETTINGS.*(setting.valuePtr);
+    // Wrap to minValue if exceeding setting value boundary
+    if (currentValue + setting.valueRange.step > setting.valueRange.max) {
+      SETTINGS.*(setting.valuePtr) = setting.valueRange.min;
+    } else {
+      SETTINGS.*(setting.valuePtr) = currentValue + setting.valueRange.step;
+    }
   } else if (setting.type == SettingType::ACTION) {
-    if (std::string(setting.name) == "Check for updates") {
+    if (strcmp(setting.name, "Calibre Settings") == 0) {
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      exitActivity();
+      enterNewActivity(new CalibreSettingsActivity(renderer, mappedInput, [this] {
+        exitActivity();
+        updateRequired = true;
+      }));
+      xSemaphoreGive(renderingMutex);
+    } else if (strcmp(setting.name, "Check for updates") == 0) {
       xSemaphoreTake(renderingMutex, portMAX_DELAY);
       exitActivity();
       enterNewActivity(new OtaUpdateActivity(renderer, mappedInput, [this] {
@@ -195,6 +203,8 @@ void SettingsActivity::render() const {
     } else if (settingsList[i].type == SettingType::ENUM && settingsList[i].valuePtr != nullptr) {
       const uint8_t value = SETTINGS.*(settingsList[i].valuePtr);
       valueText = settingsList[i].enumValues[value];
+    } else if (settingsList[i].type == SettingType::VALUE && settingsList[i].valuePtr != nullptr) {
+      valueText = std::to_string(SETTINGS.*(settingsList[i].valuePtr));
     }
     const auto width = renderer.getTextWidth(UI_10_FONT_ID, valueText.c_str());
     renderer.drawText(UI_10_FONT_ID, pageWidth - 20 - width, settingY, valueText.c_str(), i != selectedSettingIndex);

src/activities/settings/SettingsActivity.h

@@ -11,14 +11,37 @@
 
 class CrossPointSettings;
 
-enum class SettingType { TOGGLE, ENUM, ACTION };
+enum class SettingType { TOGGLE, ENUM, ACTION, VALUE };
 
 // Structure to hold setting information
 struct SettingInfo {
   const char* name;                        // Display name of the setting
   SettingType type;                        // Type of setting
-  uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings (for TOGGLE/ENUM)
+  uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings (for TOGGLE/ENUM/VALUE)
   std::vector<std::string> enumValues;
+
+  struct ValueRange {
+    uint8_t min;
+    uint8_t max;
+    uint8_t step;
+  };
+  // Bounds/step for VALUE type settings
+  ValueRange valueRange;
+
+  // Static constructors
+  static SettingInfo Toggle(const char* name, uint8_t CrossPointSettings::* ptr) {
+    return {name, SettingType::TOGGLE, ptr};
+  }
+
+  static SettingInfo Enum(const char* name, uint8_t CrossPointSettings::* ptr, std::vector<std::string> values) {
+    return {name, SettingType::ENUM, ptr, std::move(values)};
+  }
+
+  static SettingInfo Action(const char* name) { return {name, SettingType::ACTION, nullptr}; }
+
+  static SettingInfo Value(const char* name, uint8_t CrossPointSettings::* ptr, const ValueRange valueRange) {
+    return {name, SettingType::VALUE, ptr, {}, valueRange};
+  }
 };
 
 class SettingsActivity final : public ActivityWithSubactivity {

src/main.cpp

@@ -7,6 +7,8 @@
 #include <SPI.h>
 #include <builtinFonts/all.h>
 
+#include <cstring>
+
 #include "Battery.h"
 #include "CrossPointSettings.h"
 #include "CrossPointState.h"
@@ -14,6 +16,7 @@
 #include "RecentBooksStore.h"
 #include "activities/boot_sleep/BootActivity.h"
 #include "activities/boot_sleep/SleepActivity.h"
+#include "activities/browser/OpdsBookBrowserActivity.h"
 #include "activities/home/HomeActivity.h"
 #include "activities/home/MyLibraryActivity.h"
 #include "activities/network/CrossPointWebServerActivity.h"
@@ -24,14 +27,14 @@
 
 #define SPI_FQ 40000000
 // Display SPI pins (custom pins for XteinkX4, not hardware SPI defaults)
-#define EPD_SCLK 8   // SPI Clock
-#define EPD_MOSI 10  // SPI MOSI (Master Out Slave In)
-#define EPD_CS 21    // Chip Select
-#define EPD_DC 4     // Data/Command
-#define EPD_RST 5    // Reset
-#define EPD_BUSY 6   // Busy
+#define EPD_SCLK 8  // SPI Clock
+#define EPD_MOSI 10 // SPI MOSI (Master Out Slave In)
+#define EPD_CS 21   // Chip Select
+#define EPD_DC 4    // Data/Command
+#define EPD_RST 5   // Reset
+#define EPD_BUSY 6  // Busy
 
-#define UART0_RXD 20  // Used for USB connection detection
+#define UART0_RXD 20 // Used for USB connection detection
 
 #define SD_SPI_MISO 7
 
@@ -39,82 +42,98 @@ EInkDisplay einkDisplay(EPD_SCLK, EPD_MOSI, EPD_CS, EPD_DC, EPD_RST, EPD_BUSY);
 InputManager inputManager;
 MappedInputManager mappedInputManager(inputManager);
 GfxRenderer renderer(einkDisplay);
-Activity* currentActivity;
+Activity *currentActivity;
 
 // Fonts
 EpdFont bookerly12RegularFont(&bookerly_12_regular);
 EpdFont bookerly12BoldFont(&bookerly_12_bold);
 EpdFont bookerly12ItalicFont(&bookerly_12_italic);
 EpdFont bookerly12BoldItalicFont(&bookerly_12_bolditalic);
-EpdFontFamily bookerly12FontFamily(&bookerly12RegularFont, &bookerly12BoldFont, &bookerly12ItalicFont,
+EpdFontFamily bookerly12FontFamily(&bookerly12RegularFont, &bookerly12BoldFont,
+                                   &bookerly12ItalicFont,
                                    &bookerly12BoldItalicFont);
 EpdFont bookerly14RegularFont(&bookerly_14_regular);
 EpdFont bookerly14BoldFont(&bookerly_14_bold);
 EpdFont bookerly14ItalicFont(&bookerly_14_italic);
 EpdFont bookerly14BoldItalicFont(&bookerly_14_bolditalic);
-EpdFontFamily bookerly14FontFamily(&bookerly14RegularFont, &bookerly14BoldFont, &bookerly14ItalicFont,
+EpdFontFamily bookerly14FontFamily(&bookerly14RegularFont, &bookerly14BoldFont,
+                                   &bookerly14ItalicFont,
                                    &bookerly14BoldItalicFont);
 EpdFont bookerly16RegularFont(&bookerly_16_regular);
 EpdFont bookerly16BoldFont(&bookerly_16_bold);
 EpdFont bookerly16ItalicFont(&bookerly_16_italic);
 EpdFont bookerly16BoldItalicFont(&bookerly_16_bolditalic);
-EpdFontFamily bookerly16FontFamily(&bookerly16RegularFont, &bookerly16BoldFont, &bookerly16ItalicFont,
+EpdFontFamily bookerly16FontFamily(&bookerly16RegularFont, &bookerly16BoldFont,
+                                   &bookerly16ItalicFont,
                                    &bookerly16BoldItalicFont);
 EpdFont bookerly18RegularFont(&bookerly_18_regular);
 EpdFont bookerly18BoldFont(&bookerly_18_bold);
 EpdFont bookerly18ItalicFont(&bookerly_18_italic);
 EpdFont bookerly18BoldItalicFont(&bookerly_18_bolditalic);
-EpdFontFamily bookerly18FontFamily(&bookerly18RegularFont, &bookerly18BoldFont, &bookerly18ItalicFont,
+EpdFontFamily bookerly18FontFamily(&bookerly18RegularFont, &bookerly18BoldFont,
+                                   &bookerly18ItalicFont,
                                    &bookerly18BoldItalicFont);
 
 EpdFont notosans12RegularFont(&notosans_12_regular);
 EpdFont notosans12BoldFont(&notosans_12_bold);
 EpdFont notosans12ItalicFont(&notosans_12_italic);
 EpdFont notosans12BoldItalicFont(&notosans_12_bolditalic);
-EpdFontFamily notosans12FontFamily(&notosans12RegularFont, &notosans12BoldFont, &notosans12ItalicFont,
+EpdFontFamily notosans12FontFamily(&notosans12RegularFont, &notosans12BoldFont,
+                                   &notosans12ItalicFont,
                                    &notosans12BoldItalicFont);
 EpdFont notosans14RegularFont(&notosans_14_regular);
 EpdFont notosans14BoldFont(&notosans_14_bold);
 EpdFont notosans14ItalicFont(&notosans_14_italic);
 EpdFont notosans14BoldItalicFont(&notosans_14_bolditalic);
-EpdFontFamily notosans14FontFamily(&notosans14RegularFont, &notosans14BoldFont, &notosans14ItalicFont,
+EpdFontFamily notosans14FontFamily(&notosans14RegularFont, &notosans14BoldFont,
+                                   &notosans14ItalicFont,
                                    &notosans14BoldItalicFont);
 EpdFont notosans16RegularFont(&notosans_16_regular);
 EpdFont notosans16BoldFont(&notosans_16_bold);
 EpdFont notosans16ItalicFont(&notosans_16_italic);
 EpdFont notosans16BoldItalicFont(&notosans_16_bolditalic);
-EpdFontFamily notosans16FontFamily(&notosans16RegularFont, &notosans16BoldFont, &notosans16ItalicFont,
+EpdFontFamily notosans16FontFamily(&notosans16RegularFont, &notosans16BoldFont,
+                                   &notosans16ItalicFont,
                                    &notosans16BoldItalicFont);
 EpdFont notosans18RegularFont(&notosans_18_regular);
 EpdFont notosans18BoldFont(&notosans_18_bold);
 EpdFont notosans18ItalicFont(&notosans_18_italic);
 EpdFont notosans18BoldItalicFont(&notosans_18_bolditalic);
-EpdFontFamily notosans18FontFamily(&notosans18RegularFont, &notosans18BoldFont, &notosans18ItalicFont,
+EpdFontFamily notosans18FontFamily(&notosans18RegularFont, &notosans18BoldFont,
+                                   &notosans18ItalicFont,
                                    &notosans18BoldItalicFont);
 
 EpdFont opendyslexic8RegularFont(&opendyslexic_8_regular);
 EpdFont opendyslexic8BoldFont(&opendyslexic_8_bold);
 EpdFont opendyslexic8ItalicFont(&opendyslexic_8_italic);
 EpdFont opendyslexic8BoldItalicFont(&opendyslexic_8_bolditalic);
-EpdFontFamily opendyslexic8FontFamily(&opendyslexic8RegularFont, &opendyslexic8BoldFont, &opendyslexic8ItalicFont,
+EpdFontFamily opendyslexic8FontFamily(&opendyslexic8RegularFont,
+                                      &opendyslexic8BoldFont,
+                                      &opendyslexic8ItalicFont,
                                       &opendyslexic8BoldItalicFont);
 EpdFont opendyslexic10RegularFont(&opendyslexic_10_regular);
 EpdFont opendyslexic10BoldFont(&opendyslexic_10_bold);
 EpdFont opendyslexic10ItalicFont(&opendyslexic_10_italic);
 EpdFont opendyslexic10BoldItalicFont(&opendyslexic_10_bolditalic);
-EpdFontFamily opendyslexic10FontFamily(&opendyslexic10RegularFont, &opendyslexic10BoldFont, &opendyslexic10ItalicFont,
+EpdFontFamily opendyslexic10FontFamily(&opendyslexic10RegularFont,
+                                       &opendyslexic10BoldFont,
+                                       &opendyslexic10ItalicFont,
                                        &opendyslexic10BoldItalicFont);
 EpdFont opendyslexic12RegularFont(&opendyslexic_12_regular);
 EpdFont opendyslexic12BoldFont(&opendyslexic_12_bold);
 EpdFont opendyslexic12ItalicFont(&opendyslexic_12_italic);
 EpdFont opendyslexic12BoldItalicFont(&opendyslexic_12_bolditalic);
-EpdFontFamily opendyslexic12FontFamily(&opendyslexic12RegularFont, &opendyslexic12BoldFont, &opendyslexic12ItalicFont,
+EpdFontFamily opendyslexic12FontFamily(&opendyslexic12RegularFont,
+                                       &opendyslexic12BoldFont,
+                                       &opendyslexic12ItalicFont,
                                        &opendyslexic12BoldItalicFont);
 EpdFont opendyslexic14RegularFont(&opendyslexic_14_regular);
 EpdFont opendyslexic14BoldFont(&opendyslexic_14_bold);
 EpdFont opendyslexic14ItalicFont(&opendyslexic_14_italic);
 EpdFont opendyslexic14BoldItalicFont(&opendyslexic_14_bolditalic);
-EpdFontFamily opendyslexic14FontFamily(&opendyslexic14RegularFont, &opendyslexic14BoldFont, &opendyslexic14ItalicFont,
+EpdFontFamily opendyslexic14FontFamily(&opendyslexic14RegularFont,
+                                       &opendyslexic14BoldFont,
+                                       &opendyslexic14ItalicFont,
                                        &opendyslexic14BoldItalicFont);
 
 EpdFont smallFont(&notosans_8_regular);
@@ -140,27 +159,33 @@ void exitActivity() {
   }
 }
 
-void enterNewActivity(Activity* activity) {
+void enterNewActivity(Activity *activity) {
   currentActivity = activity;
   currentActivity->onEnter();
 }
 
 // Verify long press on wake-up from deep sleep
 void verifyWakeupLongPress() {
-  // Give the user up to 1000ms to start holding the power button, and must hold for SETTINGS.getPowerButtonDuration()
+  // Give the user up to 1000ms to start holding the power button, and must hold
+  // for SETTINGS.getPowerButtonDuration()
   const auto start = millis();
   bool abort = false;
-  // Subtract the current time, because inputManager only starts counting the HeldTime from the first update()
-  // This way, we remove the time we already took to reach here from the duration,
-  // assuming the button was held until now from millis()==0 (i.e. device start time).
+  // Subtract the current time, because inputManager only starts counting the
+  // HeldTime from the first update() This way, we remove the time we already
+  // took to reach here from the duration, assuming the button was held until
+  // now from millis()==0 (i.e. device start time).
   const uint16_t calibration = start;
   const uint16_t calibratedPressDuration =
-      (calibration < SETTINGS.getPowerButtonDuration()) ? SETTINGS.getPowerButtonDuration() - calibration : 1;
+      (calibration < SETTINGS.getPowerButtonDuration())
+          ? SETTINGS.getPowerButtonDuration() - calibration
+          : 1;
 
   inputManager.update();
   // Verify the user has actually pressed
-  while (!inputManager.isPressed(InputManager::BTN_POWER) && millis() - start < 1000) {
-    delay(10);  // only wait 10ms each iteration to not delay too much in case of short configured duration.
+  while (!inputManager.isPressed(InputManager::BTN_POWER) &&
+         millis() - start < 1000) {
+    delay(10); // only wait 10ms each iteration to not delay too much in case of
+               // short configured duration.
     inputManager.update();
   }
 
@@ -169,7 +194,8 @@ void verifyWakeupLongPress() {
     do {
       delay(10);
       inputManager.update();
-    } while (inputManager.isPressed(InputManager::BTN_POWER) && inputManager.getHeldTime() < calibratedPressDuration);
+    } while (inputManager.isPressed(InputManager::BTN_POWER) &&
+             inputManager.getHeldTime() < calibratedPressDuration);
     abort = inputManager.getHeldTime() < calibratedPressDuration;
   } else {
     abort = true;
@@ -178,7 +204,8 @@ void verifyWakeupLongPress() {
   if (abort) {
     // Button released too early. Returning to sleep.
     // IMPORTANT: Re-arm the wakeup trigger before sleeping again
-    esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
+    esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN,
+                                      ESP_GPIO_WAKEUP_GPIO_LOW);
     esp_deep_sleep_start();
   }
 }
@@ -197,41 +224,55 @@ void enterDeepSleep() {
   enterNewActivity(new SleepActivity(renderer, mappedInputManager));
 
   einkDisplay.deepSleep();
-  Serial.printf("[%lu] [   ] Power button press calibration value: %lu ms\n", millis(), t2 - t1);
+  Serial.printf("[%lu] [   ] Power button press calibration value: %lu ms\n",
+                millis(), t2 - t1);
   Serial.printf("[%lu] [   ] Entering deep sleep.\n", millis());
-  esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN, ESP_GPIO_WAKEUP_GPIO_LOW);
-  // Ensure that the power button has been released to avoid immediately turning back on if you're holding it
+  esp_deep_sleep_enable_gpio_wakeup(1ULL << InputManager::POWER_BUTTON_PIN,
+                                    ESP_GPIO_WAKEUP_GPIO_LOW);
+  // Ensure that the power button has been released to avoid immediately turning
+  // back on if you're holding it
   waitForPowerRelease();
   // Enter Deep Sleep
   esp_deep_sleep_start();
 }
 
 void onGoHome();
-void onGoToReader(const std::string& initialEpubPath) {
+void onGoToReader(const std::string &initialEpubPath) {
   exitActivity();
-  enterNewActivity(new ReaderActivity(renderer, mappedInputManager, initialEpubPath, onGoHome));
+  enterNewActivity(new ReaderActivity(renderer, mappedInputManager,
+                                      initialEpubPath, onGoHome));
 }
 void onContinueReading() { onGoToReader(APP_STATE.openEpubPath); }
 
 void onGoToFileTransfer() {
   exitActivity();
-  enterNewActivity(new CrossPointWebServerActivity(renderer, mappedInputManager, onGoHome));
+  enterNewActivity(
+      new CrossPointWebServerActivity(renderer, mappedInputManager, onGoHome));
 }
 
 void onGoToSettings() {
   exitActivity();
-  enterNewActivity(new SettingsActivity(renderer, mappedInputManager, onGoHome));
+  enterNewActivity(
+      new SettingsActivity(renderer, mappedInputManager, onGoHome));
 }
 
 void onGoToMyLibrary() {
   exitActivity();
-  enterNewActivity(new MyLibraryActivity(renderer, mappedInputManager, onGoHome, onGoToReader));
+  enterNewActivity(new MyLibraryActivity(renderer, mappedInputManager, onGoHome,
+                                         onGoToReader));
+}
+
+void onGoToBrowser() {
+  exitActivity();
+  enterNewActivity(
+      new OpdsBookBrowserActivity(renderer, mappedInputManager, onGoHome));
 }
 
 void onGoHome() {
   exitActivity();
-  enterNewActivity(
-      new HomeActivity(renderer, mappedInputManager, onContinueReading, onGoToMyLibrary, onGoToSettings, onGoToFileTransfer));
+  enterNewActivity(new HomeActivity(
+      renderer, mappedInputManager, onContinueReading, onGoToMyLibrary,
+      onGoToSettings, onGoToFileTransfer, onGoToBrowser));
 }
 
 void setupDisplayAndFonts() {
@@ -277,7 +318,8 @@ void setup() {
     Serial.printf("[%lu] [   ] SD card initialization failed\n", millis());
     setupDisplayAndFonts();
     exitActivity();
-    enterNewActivity(new FullScreenMessageActivity(renderer, mappedInputManager, "SD card error", EpdFontFamily::BOLD));
+    enterNewActivity(new FullScreenMessageActivity(
+        renderer, mappedInputManager, "SD card error", EpdFontFamily::BOLD));
     return;
   }
 
@@ -286,8 +328,11 @@ void setup() {
   // verify power button press duration after we've read settings.
   verifyWakeupLongPress();
 
-  // First serial output only here to avoid timing inconsistencies for power button press duration verification
-  Serial.printf("[%lu] [   ] Starting CrossPoint version " CROSSPOINT_VERSION "\n", millis());
+  // First serial output only here to avoid timing inconsistencies for power
+  // button press duration verification
+  Serial.printf("[%lu] [   ] Starting CrossPoint version " CROSSPOINT_VERSION
+                "\n",
+                millis());
 
   setupDisplayAndFonts();
 
@@ -300,7 +345,8 @@ void setup() {
   if (APP_STATE.openEpubPath.empty()) {
     onGoHome();
   } else {
-    // Clear app state to avoid getting into a boot loop if the epub doesn't load
+    // Clear app state to avoid getting into a boot loop if the epub doesn't
+    // load
     const auto path = APP_STATE.openEpubPath;
     APP_STATE.openEpubPath = "";
     APP_STATE.saveToFile();
@@ -319,21 +365,25 @@ void loop() {
   inputManager.update();
 
   if (Serial && millis() - lastMemPrint >= 10000) {
-    Serial.printf("[%lu] [MEM] Free: %d bytes, Total: %d bytes, Min Free: %d bytes\n", millis(), ESP.getFreeHeap(),
-                  ESP.getHeapSize(), ESP.getMinFreeHeap());
+    Serial.printf(
+        "[%lu] [MEM] Free: %d bytes, Total: %d bytes, Min Free: %d bytes\n",
+        millis(), ESP.getFreeHeap(), ESP.getHeapSize(), ESP.getMinFreeHeap());
     lastMemPrint = millis();
   }
 
-  // Check for any user activity (button press or release) or active background work
+  // Check for any user activity (button press or release) or active background
+  // work
   static unsigned long lastActivityTime = millis();
   if (inputManager.wasAnyPressed() || inputManager.wasAnyReleased() ||
       (currentActivity && currentActivity->preventAutoSleep())) {
-    lastActivityTime = millis();  // Reset inactivity timer
+    lastActivityTime = millis(); // Reset inactivity timer
   }
 
   const unsigned long sleepTimeoutMs = SETTINGS.getSleepTimeoutMs();
   if (millis() - lastActivityTime >= sleepTimeoutMs) {
-    Serial.printf("[%lu] [SLP] Auto-sleep triggered after %lu ms of inactivity\n", millis(), sleepTimeoutMs);
+    Serial.printf(
+        "[%lu] [SLP] Auto-sleep triggered after %lu ms of inactivity\n",
+        millis(), sleepTimeoutMs);
     enterDeepSleep();
     // This should never be hit as `enterDeepSleep` calls esp_deep_sleep_start
     return;
@@ -356,17 +406,18 @@ void loop() {
   if (loopDuration > maxLoopDuration) {
     maxLoopDuration = loopDuration;
     if (maxLoopDuration > 50) {
-      Serial.printf("[%lu] [LOOP] New max loop duration: %lu ms (activity: %lu ms)\n", millis(), maxLoopDuration,
-                    activityDuration);
+      Serial.printf(
+          "[%lu] [LOOP] New max loop duration: %lu ms (activity: %lu ms)\n",
+          millis(), maxLoopDuration, activityDuration);
     }
   }
 
   // Add delay at the end of the loop to prevent tight spinning
-  // When an activity requests skip loop delay (e.g., webserver running), use yield() for faster response
-  // Otherwise, use longer delay to save power
+  // When an activity requests skip loop delay (e.g., webserver running), use
+  // yield() for faster response Otherwise, use longer delay to save power
   if (currentActivity && currentActivity->skipLoopDelay()) {
-    yield();  // Give FreeRTOS a chance to run tasks, but return immediately
+    yield(); // Give FreeRTOS a chance to run tasks, but return immediately
   } else {
-    delay(10);  // Normal delay when no activity requires fast response
+    delay(10); // Normal delay when no activity requires fast response
   }
 }

src/network/CrossPointWebServer.cpp

@@ -194,7 +194,7 @@ void CrossPointWebServer::scanFiles(const char* path, const std::function<void(F
   Serial.printf("[%lu] [WEB] Scanning files in: %s\n", millis(), path);
 
   FsFile file = root.openNextFile();
-  char name[128];
+  char name[500];
   while (file) {
     file.getName(name, sizeof(name));
     auto fileName = String(name);

src/network/HttpDownloader.cpp

@@ -0,0 +1,128 @@
+#include "HttpDownloader.h"
+
+#include <HTTPClient.h>
+#include <HardwareSerial.h>
+#include <WiFiClientSecure.h>
+
+#include <memory>
+
+bool HttpDownloader::fetchUrl(const std::string& url, std::string& outContent) {
+  const std::unique_ptr<WiFiClientSecure> client(new WiFiClientSecure());
+  client->setInsecure();
+  HTTPClient http;
+
+  Serial.printf("[%lu] [HTTP] Fetching: %s\n", millis(), url.c_str());
+
+  http.begin(*client, url.c_str());
+  http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
+  http.addHeader("User-Agent", "CrossPoint-ESP32-" CROSSPOINT_VERSION);
+
+  const int httpCode = http.GET();
+  if (httpCode != HTTP_CODE_OK) {
+    Serial.printf("[%lu] [HTTP] Fetch failed: %d\n", millis(), httpCode);
+    http.end();
+    return false;
+  }
+
+  outContent = http.getString().c_str();
+  http.end();
+
+  Serial.printf("[%lu] [HTTP] Fetched %zu bytes\n", millis(), outContent.size());
+  return true;
+}
+
+HttpDownloader::DownloadError HttpDownloader::downloadToFile(const std::string& url, const std::string& destPath,
+                                                             ProgressCallback progress) {
+  const std::unique_ptr<WiFiClientSecure> client(new WiFiClientSecure());
+  client->setInsecure();
+  HTTPClient http;
+
+  Serial.printf("[%lu] [HTTP] Downloading: %s\n", millis(), url.c_str());
+  Serial.printf("[%lu] [HTTP] Destination: %s\n", millis(), destPath.c_str());
+
+  http.begin(*client, url.c_str());
+  http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS);
+  http.addHeader("User-Agent", "CrossPoint-ESP32-" CROSSPOINT_VERSION);
+
+  const int httpCode = http.GET();
+  if (httpCode != HTTP_CODE_OK) {
+    Serial.printf("[%lu] [HTTP] Download failed: %d\n", millis(), httpCode);
+    http.end();
+    return HTTP_ERROR;
+  }
+
+  const size_t contentLength = http.getSize();
+  Serial.printf("[%lu] [HTTP] Content-Length: %zu\n", millis(), contentLength);
+
+  // Remove existing file if present
+  if (SdMan.exists(destPath.c_str())) {
+    SdMan.remove(destPath.c_str());
+  }
+
+  // Open file for writing
+  FsFile file;
+  if (!SdMan.openFileForWrite("HTTP", destPath.c_str(), file)) {
+    Serial.printf("[%lu] [HTTP] Failed to open file for writing\n", millis());
+    http.end();
+    return FILE_ERROR;
+  }
+
+  // Get the stream for chunked reading
+  WiFiClient* stream = http.getStreamPtr();
+  if (!stream) {
+    Serial.printf("[%lu] [HTTP] Failed to get stream\n", millis());
+    file.close();
+    SdMan.remove(destPath.c_str());
+    http.end();
+    return HTTP_ERROR;
+  }
+
+  // Download in chunks
+  uint8_t buffer[DOWNLOAD_CHUNK_SIZE];
+  size_t downloaded = 0;
+  const size_t total = contentLength > 0 ? contentLength : 0;
+
+  while (http.connected() && (contentLength == 0 || downloaded < contentLength)) {
+    const size_t available = stream->available();
+    if (available == 0) {
+      delay(1);
+      continue;
+    }
+
+    const size_t toRead = available < DOWNLOAD_CHUNK_SIZE ? available : DOWNLOAD_CHUNK_SIZE;
+    const size_t bytesRead = stream->readBytes(buffer, toRead);
+
+    if (bytesRead == 0) {
+      break;
+    }
+
+    const size_t written = file.write(buffer, bytesRead);
+    if (written != bytesRead) {
+      Serial.printf("[%lu] [HTTP] Write failed: wrote %zu of %zu bytes\n", millis(), written, bytesRead);
+      file.close();
+      SdMan.remove(destPath.c_str());
+      http.end();
+      return FILE_ERROR;
+    }
+
+    downloaded += bytesRead;
+
+    if (progress && total > 0) {
+      progress(downloaded, total);
+    }
+  }
+
+  file.close();
+  http.end();
+
+  Serial.printf("[%lu] [HTTP] Downloaded %zu bytes\n", millis(), downloaded);
+
+  // Verify download size if known
+  if (contentLength > 0 && downloaded != contentLength) {
+    Serial.printf("[%lu] [HTTP] Size mismatch: got %zu, expected %zu\n", millis(), downloaded, contentLength);
+    SdMan.remove(destPath.c_str());
+    return HTTP_ERROR;
+  }
+
+  return OK;
+}

src/network/HttpDownloader.h

@@ -0,0 +1,42 @@
+#pragma once
+#include <SDCardManager.h>
+
+#include <functional>
+#include <string>
+
+/**
+ * HTTP client utility for fetching content and downloading files.
+ * Wraps WiFiClientSecure and HTTPClient for HTTPS requests.
+ */
+class HttpDownloader {
+ public:
+  using ProgressCallback = std::function<void(size_t downloaded, size_t total)>;
+
+  enum DownloadError {
+    OK = 0,
+    HTTP_ERROR,
+    FILE_ERROR,
+    ABORTED,
+  };
+
+  /**
+   * Fetch text content from a URL.
+   * @param url The URL to fetch
+   * @param outContent The fetched content (output)
+   * @return true if fetch succeeded, false on error
+   */
+  static bool fetchUrl(const std::string& url, std::string& outContent);
+
+  /**
+   * Download a file to the SD card.
+   * @param url The URL to download
+   * @param destPath The destination path on SD card
+   * @param progress Optional progress callback
+   * @return DownloadError indicating success or failure type
+   */
+  static DownloadError downloadToFile(const std::string& url, const std::string& destPath,
+                                      ProgressCallback progress = nullptr);
+
+ private:
+  static constexpr size_t DOWNLOAD_CHUNK_SIZE = 1024;
+};

src/util/StringUtils.cpp

@@ -0,0 +1,52 @@
+#include "StringUtils.h"
+
+#include <cstring>
+
+namespace StringUtils {
+
+std::string sanitizeFilename(const std::string& name, size_t maxLength) {
+  std::string result;
+  result.reserve(name.size());
+
+  for (char c : name) {
+    // Replace invalid filename characters with underscore
+    if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
+      result += '_';
+    } else if (c >= 32 && c < 127) {
+      // Keep printable ASCII characters
+      result += c;
+    }
+    // Skip non-printable characters
+  }
+
+  // Trim leading/trailing spaces and dots
+  size_t start = result.find_first_not_of(" .");
+  if (start == std::string::npos) {
+    return "book";  // Fallback if name is all invalid characters
+  }
+  size_t end = result.find_last_not_of(" .");
+  result = result.substr(start, end - start + 1);
+
+  // Limit filename length
+  if (result.length() > maxLength) {
+    result.resize(maxLength);
+  }
+
+  return result.empty() ? "book" : result;
+}
+
+bool checkFileExtension(const std::string& fileName, const char* extension) {
+  if (fileName.length() < strlen(extension)) {
+    return false;
+  }
+
+  const std::string fileExt = fileName.substr(fileName.length() - strlen(extension));
+  for (size_t i = 0; i < fileExt.length(); i++) {
+    if (tolower(fileExt[i]) != tolower(extension[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace StringUtils

src/util/StringUtils.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string>
+
+namespace StringUtils {
+
+/**
+ * Sanitize a string for use as a filename.
+ * Replaces invalid characters with underscores, trims spaces/dots,
+ * and limits length to maxLength characters.
+ */
+std::string sanitizeFilename(const std::string& name, size_t maxLength = 100);
+
+/**
+ * Check if the given filename ends with the specified extension (case-insensitive).
+ */
+bool checkFileExtension(const std::string& fileName, const char* extension);
+
+}  // namespace StringUtils

src/util/UrlUtils.cpp

@@ -0,0 +1,41 @@
+#include "UrlUtils.h"
+
+namespace UrlUtils {
+
+std::string ensureProtocol(const std::string& url) {
+  if (url.find("://") == std::string::npos) {
+    return "http://" + url;
+  }
+  return url;
+}
+
+std::string extractHost(const std::string& url) {
+  const size_t protocolEnd = url.find("://");
+  if (protocolEnd == std::string::npos) {
+    // No protocol, find first slash
+    const size_t firstSlash = url.find('/');
+    return firstSlash == std::string::npos ? url : url.substr(0, firstSlash);
+  }
+  // Find the first slash after the protocol
+  const size_t hostStart = protocolEnd + 3;
+  const size_t pathStart = url.find('/', hostStart);
+  return pathStart == std::string::npos ? url : url.substr(0, pathStart);
+}
+
+std::string buildUrl(const std::string& serverUrl, const std::string& path) {
+  const std::string urlWithProtocol = ensureProtocol(serverUrl);
+  if (path.empty()) {
+    return urlWithProtocol;
+  }
+  if (path[0] == '/') {
+    // Absolute path - use just the host
+    return extractHost(urlWithProtocol) + path;
+  }
+  // Relative path - append to server URL
+  if (urlWithProtocol.back() == '/') {
+    return urlWithProtocol + path;
+  }
+  return urlWithProtocol + "/" + path;
+}
+
+}  // namespace UrlUtils

src/util/UrlUtils.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <string>
+
+namespace UrlUtils {
+
+/**
+ * Prepend http:// if no protocol specified (server will redirect to https if needed)
+ */
+std::string ensureProtocol(const std::string& url);
+
+/**
+ * Extract host with protocol from URL (e.g., "http://example.com" from "http://example.com/path")
+ */
+std::string extractHost(const std::string& url);
+
+/**
+ * Build full URL from server URL and path.
+ * If path starts with /, it's an absolute path from the host root.
+ * Otherwise, it's relative to the server URL.
+ */
+std::string buildUrl(const std::string& serverUrl, const std::string& path);
+
+}  // namespace UrlUtils