Merge 94411049c8 into da4d3b5ea5

Implemented tabbed display for Chapters/Footnotes.
Merge remote-tracking branch 'origin/master' into feat/reader-toc-tabs
2026-02-04 22:57:50 +03:00 · 2026-01-27 21:14:52 +00:00 · 2026-01-27 23:14:23 +02:00 · 2026-01-27 21:48:48 +02:00 · 2026-01-28 04:50:15 +11:00 · 2026-01-27 19:25:56 +02:00
31 changed files with 953 additions and 955 deletions
--- a/.gitignore
+++ b/.gitignore
@ -6,4 +6,6 @@ lib/EpdFont/fontsrc
 *.generated.h
 .vs
 build
-**/__pycache__/
+**/__pycache__/
+/compile_commands.json
+/.cache
--- a/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
+++ b/lib/Epub/Epub/parsers/ChapterHtmlSlimParser.cpp
@ -368,69 +368,46 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
    }
  }

-  if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
-    // TODO: Start processing image tags
-    std::string alt;
-    if (atts != nullptr) {
-      for (int i = 0; atts[i]; i += 2) {
-        if (strcmp(atts[i], "alt") == 0) {
-          alt = "[Image: " + std::string(atts[i + 1]) + "]";
-        }
-      }
-      Serial.printf("[%lu] [EHP] Image alt: %s\n", millis(), alt.c_str());
-
-      self->startNewTextBlock(TextBlock::CENTER_ALIGN);
-      self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
-      self->depth += 1;
-      self->characterData(userData, alt.c_str(), alt.length());
-
-    } else {
-      // Skip for now
-      self->skipUntilDepth = self->depth;
-      self->depth += 1;
-      return;
-    }
-  }
-
  // Special handling for tables - show placeholder text instead of dropping silently
  if (strcmp(name, "table") == 0) {
    // Add placeholder text
    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
-    if (self->currentTextBlock) {
-      self->currentTextBlock->addWord("[Table omitted]", EpdFontFamily::ITALIC);
-    }

-    // Skip table contents
-    self->skipUntilDepth = self->depth;
+    self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
+    // Advance depth before processing character data (like you would for a element with text)
    self->depth += 1;
+    self->characterData(userData, "[Table omitted]", strlen("[Table omitted]"));
+
+    // Skip table contents (skip until parent as we pre-advanced depth above)
+    self->skipUntilDepth = self->depth - 1;
    return;
  }

  if (matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS)) {
    // TODO: Start processing image tags
-    std::string alt;
+    std::string alt = "[Image]";
    if (atts != nullptr) {
      for (int i = 0; atts[i]; i += 2) {
        if (strcmp(atts[i], "alt") == 0) {
-          // add " " (counts as whitespace) at the end of alt
-          //  so the corresponding text block ends.
-          // TODO: A zero-width breaking space would be more appropriate (once/if we support it)
-          alt = "[Image: " + std::string(atts[i + 1]) + "] ";
+          if (strlen(atts[i + 1]) > 0) {
+            alt = "[Image: " + std::string(atts[i + 1]) + "]";
+          }
+          break;
        }
      }
-      Serial.printf("[%lu] [EHP] Image alt: %s\n", millis(), alt.c_str());
-
-      self->startNewTextBlock(TextBlock::CENTER_ALIGN);
-      self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
-      self->depth += 1;
-      self->characterData(userData, alt.c_str(), alt.length());
-      return;
-    } else {
-      // Skip for now
-      self->skipUntilDepth = self->depth;
-      self->depth += 1;
-      return;
    }
+
+    Serial.printf("[%lu] [EHP] Image alt: %s\n", millis(), alt.c_str());
+
+    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
+    self->italicUntilDepth = min(self->italicUntilDepth, self->depth);
+    // Advance depth before processing character data (like you would for a element with text)
+    self->depth += 1;
+    self->characterData(userData, alt.c_str(), alt.length());
+
+    // Skip table contents (skip until parent as we pre-advanced depth above)
+    self->skipUntilDepth = self->depth - 1;
+    return;
  }

  if (matches(name, SKIP_TAGS, NUM_SKIP_TAGS)) {
@ -454,25 +431,43 @@ void XMLCALL ChapterHtmlSlimParser::startElement(void* userData, const XML_Char*
  if (matches(name, HEADER_TAGS, NUM_HEADER_TAGS)) {
    self->startNewTextBlock(TextBlock::CENTER_ALIGN);
    self->boldUntilDepth = std::min(self->boldUntilDepth, self->depth);
-  } else if (matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS)) {
+    self->depth += 1;
+    return;
+  }
+
+  if (matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS)) {
    if (strcmp(name, "br") == 0) {
      if (self->partWordBufferIndex > 0) {
        // flush word preceding <br/> to currentTextBlock before calling startNewTextBlock
        self->flushPartWordBuffer();
      }
      self->startNewTextBlock(self->currentTextBlock->getStyle());
-    } else {
-      self->startNewTextBlock((TextBlock::Style)self->paragraphAlignment);
-      if (strcmp(name, "li") == 0) {
-        self->currentTextBlock->addWord("\xe2\x80\xa2", EpdFontFamily::REGULAR);
-      }
+      self->depth += 1;
+      return;
    }
-  } else if (matches(name, BOLD_TAGS, NUM_BOLD_TAGS)) {
-    self->boldUntilDepth = std::min(self->boldUntilDepth, self->depth);
-  } else if (matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS)) {
-    self->italicUntilDepth = std::min(self->italicUntilDepth, self->depth);
+
+    self->startNewTextBlock(static_cast<TextBlock::Style>(self->paragraphAlignment));
+    if (strcmp(name, "li") == 0) {
+      self->currentTextBlock->addWord("\xe2\x80\xa2", EpdFontFamily::REGULAR);
+    }
+
+    self->depth += 1;
+    return;
  }

+  if (matches(name, BOLD_TAGS, NUM_BOLD_TAGS)) {
+    self->boldUntilDepth = std::min(self->boldUntilDepth, self->depth);
+    self->depth += 1;
+    return;
+  }
+
+  if (matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS)) {
+    self->italicUntilDepth = std::min(self->italicUntilDepth, self->depth);
+    self->depth += 1;
+    return;
+  }
+
+  // Unprocessed tag, just increasing depth and continue forward
  self->depth += 1;
 }

@ -746,7 +741,8 @@ void XMLCALL ChapterHtmlSlimParser::endElement(void* userData, const XML_Char* n
  if (self->partWordBufferIndex > 0) {
    const bool shouldBreakText =
        matches(name, BLOCK_TAGS, NUM_BLOCK_TAGS) || matches(name, HEADER_TAGS, NUM_HEADER_TAGS) ||
-        matches(name, BOLD_TAGS, NUM_BOLD_TAGS) || matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS) || self->depth == 1;
+        matches(name, BOLD_TAGS, NUM_BOLD_TAGS) || matches(name, ITALIC_TAGS, NUM_ITALIC_TAGS) ||
+        strcmp(name, "table") == 0 || matches(name, IMAGE_TAGS, NUM_IMAGE_TAGS) || self->depth == 1;

    if (shouldBreakText) {
      self->flushPartWordBuffer();
--- a/lib/GfxRenderer/GfxRenderer.cpp
+++ b/lib/GfxRenderer/GfxRenderer.cpp
@ -10,19 +10,19 @@ void GfxRenderer::rotateCoordinates(const int x, const int y, int* rotatedX, int
      // Logical portrait (480x800) → panel (800x480)
      // Rotation: 90 degrees clockwise
      *rotatedX = y;
-      *rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - x;
+      *rotatedY = HalDisplay::DISPLAY_HEIGHT - 1 - x;
      break;
    }
    case LandscapeClockwise: {
      // Logical landscape (800x480) rotated 180 degrees (swap top/bottom and left/right)
-      *rotatedX = EInkDisplay::DISPLAY_WIDTH - 1 - x;
-      *rotatedY = EInkDisplay::DISPLAY_HEIGHT - 1 - y;
+      *rotatedX = HalDisplay::DISPLAY_WIDTH - 1 - x;
+      *rotatedY = HalDisplay::DISPLAY_HEIGHT - 1 - y;
      break;
    }
    case PortraitInverted: {
      // Logical portrait (480x800) → panel (800x480)
      // Rotation: 90 degrees counter-clockwise
-      *rotatedX = EInkDisplay::DISPLAY_WIDTH - 1 - y;
+      *rotatedX = HalDisplay::DISPLAY_WIDTH - 1 - y;
      *rotatedY = x;
      break;
    }
@ -36,7 +36,7 @@ void GfxRenderer::rotateCoordinates(const int x, const int y, int* rotatedX, int
 }

 void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
-  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  uint8_t* frameBuffer = display.getFrameBuffer();

  // Early return if no framebuffer is set
  if (!frameBuffer) {
@ -49,14 +49,13 @@ void GfxRenderer::drawPixel(const int x, const int y, const bool state) const {
  rotateCoordinates(x, y, &rotatedX, &rotatedY);

  // Bounds checking against physical panel dimensions
-  if (rotatedX < 0 || rotatedX >= EInkDisplay::DISPLAY_WIDTH || rotatedY < 0 ||
-      rotatedY >= EInkDisplay::DISPLAY_HEIGHT) {
+  if (rotatedX < 0 || rotatedX >= HalDisplay::DISPLAY_WIDTH || rotatedY < 0 || rotatedY >= HalDisplay::DISPLAY_HEIGHT) {
    Serial.printf("[%lu] [GFX] !! Outside range (%d, %d) -> (%d, %d)\n", millis(), x, y, rotatedX, rotatedY);
    return;
  }

  // Calculate byte position and bit position
-  const uint16_t byteIndex = rotatedY * EInkDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
+  const uint16_t byteIndex = rotatedY * HalDisplay::DISPLAY_WIDTH_BYTES + (rotatedX / 8);
  const uint8_t bitPosition = 7 - (rotatedX % 8);  // MSB first

  if (state) {
@ -164,7 +163,7 @@ void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, co
      break;
  }
  // TODO: Rotate bits
-  einkDisplay.drawImage(bitmap, rotatedX, rotatedY, width, height);
+  display.drawImage(bitmap, rotatedX, rotatedY, width, height);
 }

 void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight,
@ -399,22 +398,20 @@ void GfxRenderer::fillPolygon(const int* xPoints, const int* yPoints, int numPoi
  free(nodeX);
 }

-void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); }
+void GfxRenderer::clearScreen(const uint8_t color) const { display.clearScreen(color); }

 void GfxRenderer::invertScreen() const {
-  uint8_t* buffer = einkDisplay.getFrameBuffer();
+  uint8_t* buffer = display.getFrameBuffer();
  if (!buffer) {
    Serial.printf("[%lu] [GFX] !! No framebuffer in invertScreen\n", millis());
    return;
  }
-  for (int i = 0; i < EInkDisplay::BUFFER_SIZE; i++) {
+  for (int i = 0; i < HalDisplay::BUFFER_SIZE; i++) {
    buffer[i] = ~buffer[i];
  }
 }

-void GfxRenderer::displayBuffer(const EInkDisplay::RefreshMode refreshMode) const {
-  einkDisplay.displayBuffer(refreshMode);
-}
+void GfxRenderer::displayBuffer(const HalDisplay::RefreshMode refreshMode) const { display.displayBuffer(refreshMode); }

 std::string GfxRenderer::truncatedText(const int fontId, const char* text, const int maxWidth,
                                       const EpdFontFamily::Style style) const {
@ -433,13 +430,13 @@ int GfxRenderer::getScreenWidth() const {
    case Portrait:
    case PortraitInverted:
      // 480px wide in portrait logical coordinates
-      return EInkDisplay::DISPLAY_HEIGHT;
+      return HalDisplay::DISPLAY_HEIGHT;
    case LandscapeClockwise:
    case LandscapeCounterClockwise:
      // 800px wide in landscape logical coordinates
-      return EInkDisplay::DISPLAY_WIDTH;
+      return HalDisplay::DISPLAY_WIDTH;
  }
-  return EInkDisplay::DISPLAY_HEIGHT;
+  return HalDisplay::DISPLAY_HEIGHT;
 }

 int GfxRenderer::getScreenHeight() const {
@ -447,13 +444,13 @@ int GfxRenderer::getScreenHeight() const {
    case Portrait:
    case PortraitInverted:
      // 800px tall in portrait logical coordinates
-      return EInkDisplay::DISPLAY_WIDTH;
+      return HalDisplay::DISPLAY_WIDTH;
    case LandscapeClockwise:
    case LandscapeCounterClockwise:
      // 480px tall in landscape logical coordinates
-      return EInkDisplay::DISPLAY_HEIGHT;
+      return HalDisplay::DISPLAY_HEIGHT;
  }
-  return EInkDisplay::DISPLAY_WIDTH;
+  return HalDisplay::DISPLAY_WIDTH;
 }

 int GfxRenderer::getSpaceWidth(const int fontId) const {
@ -653,17 +650,18 @@ void GfxRenderer::drawTextRotated90CW(const int fontId, const int x, const int y
  }
 }

-uint8_t* GfxRenderer::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
+uint8_t* GfxRenderer::getFrameBuffer() const { return display.getFrameBuffer(); }

-size_t GfxRenderer::getBufferSize() { return EInkDisplay::BUFFER_SIZE; }
+size_t GfxRenderer::getBufferSize() { return HalDisplay::BUFFER_SIZE; }

-void GfxRenderer::grayscaleRevert() const { einkDisplay.grayscaleRevert(); }
+// unused
+// void GfxRenderer::grayscaleRevert() const { display.grayscaleRevert(); }

-void GfxRenderer::copyGrayscaleLsbBuffers() const { einkDisplay.copyGrayscaleLsbBuffers(einkDisplay.getFrameBuffer()); }
+void GfxRenderer::copyGrayscaleLsbBuffers() const { display.copyGrayscaleLsbBuffers(display.getFrameBuffer()); }

-void GfxRenderer::copyGrayscaleMsbBuffers() const { einkDisplay.copyGrayscaleMsbBuffers(einkDisplay.getFrameBuffer()); }
+void GfxRenderer::copyGrayscaleMsbBuffers() const { display.copyGrayscaleMsbBuffers(display.getFrameBuffer()); }

-void GfxRenderer::displayGrayBuffer() const { einkDisplay.displayGrayBuffer(); }
+void GfxRenderer::displayGrayBuffer() const { display.displayGrayBuffer(); }

 void GfxRenderer::freeBwBufferChunks() {
  for (auto& bwBufferChunk : bwBufferChunks) {
@ -681,7 +679,7 @@ void GfxRenderer::freeBwBufferChunks() {
 * Returns true if buffer was stored successfully, false if allocation failed.
 */
 bool GfxRenderer::storeBwBuffer() {
-  const uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  const uint8_t* frameBuffer = display.getFrameBuffer();
  if (!frameBuffer) {
    Serial.printf("[%lu] [GFX] !! No framebuffer in storeBwBuffer\n", millis());
    return false;
@ -736,7 +734,7 @@ void GfxRenderer::restoreBwBuffer() {
    return;
  }

-  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  uint8_t* frameBuffer = display.getFrameBuffer();
  if (!frameBuffer) {
    Serial.printf("[%lu] [GFX] !! No framebuffer in restoreBwBuffer\n", millis());
    freeBwBufferChunks();
@ -755,7 +753,7 @@ void GfxRenderer::restoreBwBuffer() {
    memcpy(frameBuffer + offset, bwBufferChunks[i], BW_BUFFER_CHUNK_SIZE);
  }

-  einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
+  display.cleanupGrayscaleBuffers(frameBuffer);

  freeBwBufferChunks();
  Serial.printf("[%lu] [GFX] Restored and freed BW buffer chunks\n", millis());
@ -766,9 +764,9 @@ void GfxRenderer::restoreBwBuffer() {
 * Use this when BW buffer was re-rendered instead of stored/restored.
 */
 void GfxRenderer::cleanupGrayscaleWithFrameBuffer() const {
-  uint8_t* frameBuffer = einkDisplay.getFrameBuffer();
+  uint8_t* frameBuffer = display.getFrameBuffer();
  if (frameBuffer) {
-    einkDisplay.cleanupGrayscaleBuffers(frameBuffer);
+    display.cleanupGrayscaleBuffers(frameBuffer);
  }
 }

--- a/lib/GfxRenderer/GfxRenderer.h
+++ b/lib/GfxRenderer/GfxRenderer.h
@ -1,7 +1,7 @@
 #pragma once

-#include <EInkDisplay.h>
 #include <EpdFontFamily.h>
+#include <HalDisplay.h>

 #include <map>

@ -21,11 +21,11 @@ class GfxRenderer {

 private:
  static constexpr size_t BW_BUFFER_CHUNK_SIZE = 8000;  // 8KB chunks to allow for non-contiguous memory
-  static constexpr size_t BW_BUFFER_NUM_CHUNKS = EInkDisplay::BUFFER_SIZE / BW_BUFFER_CHUNK_SIZE;
-  static_assert(BW_BUFFER_CHUNK_SIZE * BW_BUFFER_NUM_CHUNKS == EInkDisplay::BUFFER_SIZE,
+  static constexpr size_t BW_BUFFER_NUM_CHUNKS = HalDisplay::BUFFER_SIZE / BW_BUFFER_CHUNK_SIZE;
+  static_assert(BW_BUFFER_CHUNK_SIZE * BW_BUFFER_NUM_CHUNKS == HalDisplay::BUFFER_SIZE,
                "BW buffer chunking does not line up with display buffer size");

-  EInkDisplay& einkDisplay;
+  HalDisplay& display;
  RenderMode renderMode;
  Orientation orientation;
  uint8_t* bwBufferChunks[BW_BUFFER_NUM_CHUNKS] = {nullptr};
@ -36,7 +36,7 @@ class GfxRenderer {
  void rotateCoordinates(int x, int y, int* rotatedX, int* rotatedY) const;

 public:
-  explicit GfxRenderer(EInkDisplay& einkDisplay) : einkDisplay(einkDisplay), renderMode(BW), orientation(Portrait) {}
+  explicit GfxRenderer(HalDisplay& halDisplay) : display(halDisplay), renderMode(BW), orientation(Portrait) {}
  ~GfxRenderer() { freeBwBufferChunks(); }

  static constexpr int VIEWABLE_MARGIN_TOP = 9;
@ -54,7 +54,7 @@ class GfxRenderer {
  // Screen ops
  int getScreenWidth() const;
  int getScreenHeight() const;
-  void displayBuffer(EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH) const;
+  void displayBuffer(HalDisplay::RefreshMode refreshMode = HalDisplay::FAST_REFRESH) const;
  // EXPERIMENTAL: Windowed update - display only a rectangular region
  void displayWindow(int x, int y, int width, int height) const;
  void invertScreen() const;
--- a/lib/hal/HalDisplay.cpp
+++ b/lib/hal/HalDisplay.cpp
@ -0,0 +1,51 @@
+#include <HalDisplay.h>
+#include <HalGPIO.h>
+
+#define SD_SPI_MISO 7
+
+HalDisplay::HalDisplay() : einkDisplay(EPD_SCLK, EPD_MOSI, EPD_CS, EPD_DC, EPD_RST, EPD_BUSY) {}
+
+HalDisplay::~HalDisplay() {}
+
+void HalDisplay::begin() { einkDisplay.begin(); }
+
+void HalDisplay::clearScreen(uint8_t color) const { einkDisplay.clearScreen(color); }
+
+void HalDisplay::drawImage(const uint8_t* imageData, uint16_t x, uint16_t y, uint16_t w, uint16_t h,
+                           bool fromProgmem) const {
+  einkDisplay.drawImage(imageData, x, y, w, h, fromProgmem);
+}
+
+EInkDisplay::RefreshMode convertRefreshMode(HalDisplay::RefreshMode mode) {
+  switch (mode) {
+    case HalDisplay::FULL_REFRESH:
+      return EInkDisplay::FULL_REFRESH;
+    case HalDisplay::HALF_REFRESH:
+      return EInkDisplay::HALF_REFRESH;
+    case HalDisplay::FAST_REFRESH:
+    default:
+      return EInkDisplay::FAST_REFRESH;
+  }
+}
+
+void HalDisplay::displayBuffer(HalDisplay::RefreshMode mode) { einkDisplay.displayBuffer(convertRefreshMode(mode)); }
+
+void HalDisplay::refreshDisplay(HalDisplay::RefreshMode mode, bool turnOffScreen) {
+  einkDisplay.refreshDisplay(convertRefreshMode(mode), turnOffScreen);
+}
+
+void HalDisplay::deepSleep() { einkDisplay.deepSleep(); }
+
+uint8_t* HalDisplay::getFrameBuffer() const { return einkDisplay.getFrameBuffer(); }
+
+void HalDisplay::copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer) {
+  einkDisplay.copyGrayscaleBuffers(lsbBuffer, msbBuffer);
+}
+
+void HalDisplay::copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer) { einkDisplay.copyGrayscaleLsbBuffers(lsbBuffer); }
+
+void HalDisplay::copyGrayscaleMsbBuffers(const uint8_t* msbBuffer) { einkDisplay.copyGrayscaleMsbBuffers(msbBuffer); }
+
+void HalDisplay::cleanupGrayscaleBuffers(const uint8_t* bwBuffer) { einkDisplay.cleanupGrayscaleBuffers(bwBuffer); }
+
+void HalDisplay::displayGrayBuffer() { einkDisplay.displayGrayBuffer(); }
--- a/lib/hal/HalDisplay.h
+++ b/lib/hal/HalDisplay.h
@ -0,0 +1,52 @@
+#pragma once
+#include <Arduino.h>
+#include <EInkDisplay.h>
+
+class HalDisplay {
+ public:
+  // Constructor with pin configuration
+  HalDisplay();
+
+  // Destructor
+  ~HalDisplay();
+
+  // Refresh modes
+  enum RefreshMode {
+    FULL_REFRESH,  // Full refresh with complete waveform
+    HALF_REFRESH,  // Half refresh (1720ms) - balanced quality and speed
+    FAST_REFRESH   // Fast refresh using custom LUT
+  };
+
+  // Initialize the display hardware and driver
+  void begin();
+
+  // Display dimensions
+  static constexpr uint16_t DISPLAY_WIDTH = EInkDisplay::DISPLAY_WIDTH;
+  static constexpr uint16_t DISPLAY_HEIGHT = EInkDisplay::DISPLAY_HEIGHT;
+  static constexpr uint16_t DISPLAY_WIDTH_BYTES = DISPLAY_WIDTH / 8;
+  static constexpr uint32_t BUFFER_SIZE = DISPLAY_WIDTH_BYTES * DISPLAY_HEIGHT;
+
+  // Frame buffer operations
+  void clearScreen(uint8_t color = 0xFF) const;
+  void drawImage(const uint8_t* imageData, uint16_t x, uint16_t y, uint16_t w, uint16_t h,
+                 bool fromProgmem = false) const;
+
+  void displayBuffer(RefreshMode mode = RefreshMode::FAST_REFRESH);
+  void refreshDisplay(RefreshMode mode = RefreshMode::FAST_REFRESH, bool turnOffScreen = false);
+
+  // Power management
+  void deepSleep();
+
+  // Access to frame buffer
+  uint8_t* getFrameBuffer() const;
+
+  void copyGrayscaleBuffers(const uint8_t* lsbBuffer, const uint8_t* msbBuffer);
+  void copyGrayscaleLsbBuffers(const uint8_t* lsbBuffer);
+  void copyGrayscaleMsbBuffers(const uint8_t* msbBuffer);
+  void cleanupGrayscaleBuffers(const uint8_t* bwBuffer);
+
+  void displayGrayBuffer();
+
+ private:
+  EInkDisplay einkDisplay;
+};
--- a/lib/hal/HalGPIO.cpp
+++ b/lib/hal/HalGPIO.cpp
@ -0,0 +1,55 @@
+#include <HalGPIO.h>
+#include <SPI.h>
+#include <esp_sleep.h>
+
+void HalGPIO::begin() {
+  inputMgr.begin();
+  SPI.begin(EPD_SCLK, SPI_MISO, EPD_MOSI, EPD_CS);
+  pinMode(BAT_GPIO0, INPUT);
+  pinMode(UART0_RXD, INPUT);
+}
+
+void HalGPIO::update() { inputMgr.update(); }
+
+bool HalGPIO::isPressed(uint8_t buttonIndex) const { return inputMgr.isPressed(buttonIndex); }
+
+bool HalGPIO::wasPressed(uint8_t buttonIndex) const { return inputMgr.wasPressed(buttonIndex); }
+
+bool HalGPIO::wasAnyPressed() const { return inputMgr.wasAnyPressed(); }
+
+bool HalGPIO::wasReleased(uint8_t buttonIndex) const { return inputMgr.wasReleased(buttonIndex); }
+
+bool HalGPIO::wasAnyReleased() const { return inputMgr.wasAnyReleased(); }
+
+unsigned long HalGPIO::getHeldTime() const { return inputMgr.getHeldTime(); }
+
+void HalGPIO::startDeepSleep() {
+  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
+  while (inputMgr.isPressed(BTN_POWER)) {
+    delay(50);
+    inputMgr.update();
+  }
+  // Enter Deep Sleep
+  esp_deep_sleep_start();
+}
+
+int HalGPIO::getBatteryPercentage() const {
+  static const BatteryMonitor battery = BatteryMonitor(BAT_GPIO0);
+  return battery.readPercentage();
+}
+
+bool HalGPIO::isUsbConnected() const {
+  // U0RXD/GPIO20 reads HIGH when USB is connected
+  return digitalRead(UART0_RXD) == HIGH;
+}
+
+bool HalGPIO::isWakeupByPowerButton() const {
+  const auto wakeupCause = esp_sleep_get_wakeup_cause();
+  const auto resetReason = esp_reset_reason();
+  if (isUsbConnected()) {
+    return wakeupCause == ESP_SLEEP_WAKEUP_GPIO;
+  } else {
+    return (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED) && (resetReason == ESP_RST_POWERON);
+  }
+}
--- a/lib/hal/HalGPIO.h
+++ b/lib/hal/HalGPIO.h
@ -0,0 +1,61 @@
+#pragma once
+
+#include <Arduino.h>
+#include <BatteryMonitor.h>
+#include <InputManager.h>
+
+// 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 SPI_MISO 7  // SPI MISO, shared between SD card and display (Master In Slave Out)
+
+#define BAT_GPIO0 0  // Battery voltage
+
+#define UART0_RXD 20  // Used for USB connection detection
+
+class HalGPIO {
+#if CROSSPOINT_EMULATED == 0
+  InputManager inputMgr;
+#endif
+
+ public:
+  HalGPIO() = default;
+
+  // Start button GPIO and setup SPI for screen and SD card
+  void begin();
+
+  // Button input methods
+  void update();
+  bool isPressed(uint8_t buttonIndex) const;
+  bool wasPressed(uint8_t buttonIndex) const;
+  bool wasAnyPressed() const;
+  bool wasReleased(uint8_t buttonIndex) const;
+  bool wasAnyReleased() const;
+  unsigned long getHeldTime() const;
+
+  // Setup wake up GPIO and enter deep sleep
+  void startDeepSleep();
+
+  // Get battery percentage (range 0-100)
+  int getBatteryPercentage() const;
+
+  // Check if USB is connected
+  bool isUsbConnected() const;
+
+  // Check if wakeup was caused by power button press
+  bool isWakeupByPowerButton() const;
+
+  // Button indices
+  static constexpr uint8_t BTN_BACK = 0;
+  static constexpr uint8_t BTN_CONFIRM = 1;
+  static constexpr uint8_t BTN_LEFT = 2;
+  static constexpr uint8_t BTN_RIGHT = 3;
+  static constexpr uint8_t BTN_UP = 4;
+  static constexpr uint8_t BTN_DOWN = 5;
+  static constexpr uint8_t BTN_POWER = 6;
+};
--- a/platformio.ini
+++ b/platformio.ini
@ -2,7 +2,7 @@
 default_envs = default

 [crosspoint]
-version = 0.15.0
+version = 0.16.0

 [base]
 platform = espressif32 @ 6.12.0
--- a/src/MappedInputManager.cpp
+++ b/src/MappedInputManager.cpp
@ -19,20 +19,20 @@ struct SideLayoutMap {

 // Order matches CrossPointSettings::FRONT_BUTTON_LAYOUT.
 constexpr FrontLayoutMap kFrontLayouts[] = {
-    {InputManager::BTN_BACK, InputManager::BTN_CONFIRM, InputManager::BTN_LEFT, InputManager::BTN_RIGHT},
-    {InputManager::BTN_LEFT, InputManager::BTN_RIGHT, InputManager::BTN_BACK, InputManager::BTN_CONFIRM},
-    {InputManager::BTN_CONFIRM, InputManager::BTN_LEFT, InputManager::BTN_BACK, InputManager::BTN_RIGHT},
-    {InputManager::BTN_BACK, InputManager::BTN_CONFIRM, InputManager::BTN_RIGHT, InputManager::BTN_LEFT},
+    {HalGPIO::BTN_BACK, HalGPIO::BTN_CONFIRM, HalGPIO::BTN_LEFT, HalGPIO::BTN_RIGHT},
+    {HalGPIO::BTN_LEFT, HalGPIO::BTN_RIGHT, HalGPIO::BTN_BACK, HalGPIO::BTN_CONFIRM},
+    {HalGPIO::BTN_CONFIRM, HalGPIO::BTN_LEFT, HalGPIO::BTN_BACK, HalGPIO::BTN_RIGHT},
+    {HalGPIO::BTN_BACK, HalGPIO::BTN_CONFIRM, HalGPIO::BTN_RIGHT, HalGPIO::BTN_LEFT},
 };

 // Order matches CrossPointSettings::SIDE_BUTTON_LAYOUT.
 constexpr SideLayoutMap kSideLayouts[] = {
-    {InputManager::BTN_UP, InputManager::BTN_DOWN},
-    {InputManager::BTN_DOWN, InputManager::BTN_UP},
+    {HalGPIO::BTN_UP, HalGPIO::BTN_DOWN},
+    {HalGPIO::BTN_DOWN, HalGPIO::BTN_UP},
 };
 }  // namespace

-bool MappedInputManager::mapButton(const Button button, bool (InputManager::*fn)(uint8_t) const) const {
+bool MappedInputManager::mapButton(const Button button, bool (HalGPIO::*fn)(uint8_t) const) const {
  const auto frontLayout = static_cast<CrossPointSettings::FRONT_BUTTON_LAYOUT>(SETTINGS.frontButtonLayout);
  const auto sideLayout = static_cast<CrossPointSettings::SIDE_BUTTON_LAYOUT>(SETTINGS.sideButtonLayout);
  const auto& front = kFrontLayouts[frontLayout];
@ -40,41 +40,39 @@ bool MappedInputManager::mapButton(const Button button, bool (InputManager::*fn)

  switch (button) {
    case Button::Back:
-      return (inputManager.*fn)(front.back);
+      return (gpio.*fn)(front.back);
    case Button::Confirm:
-      return (inputManager.*fn)(front.confirm);
+      return (gpio.*fn)(front.confirm);
    case Button::Left:
-      return (inputManager.*fn)(front.left);
+      return (gpio.*fn)(front.left);
    case Button::Right:
-      return (inputManager.*fn)(front.right);
+      return (gpio.*fn)(front.right);
    case Button::Up:
-      return (inputManager.*fn)(InputManager::BTN_UP);
+      return (gpio.*fn)(HalGPIO::BTN_UP);
    case Button::Down:
-      return (inputManager.*fn)(InputManager::BTN_DOWN);
+      return (gpio.*fn)(HalGPIO::BTN_DOWN);
    case Button::Power:
-      return (inputManager.*fn)(InputManager::BTN_POWER);
+      return (gpio.*fn)(HalGPIO::BTN_POWER);
    case Button::PageBack:
-      return (inputManager.*fn)(side.pageBack);
+      return (gpio.*fn)(side.pageBack);
    case Button::PageForward:
-      return (inputManager.*fn)(side.pageForward);
+      return (gpio.*fn)(side.pageForward);
  }

  return false;
 }

-bool MappedInputManager::wasPressed(const Button button) const { return mapButton(button, &InputManager::wasPressed); }
+bool MappedInputManager::wasPressed(const Button button) const { return mapButton(button, &HalGPIO::wasPressed); }

-bool MappedInputManager::wasReleased(const Button button) const {
-  return mapButton(button, &InputManager::wasReleased);
-}
+bool MappedInputManager::wasReleased(const Button button) const { return mapButton(button, &HalGPIO::wasReleased); }

-bool MappedInputManager::isPressed(const Button button) const { return mapButton(button, &InputManager::isPressed); }
+bool MappedInputManager::isPressed(const Button button) const { return mapButton(button, &HalGPIO::isPressed); }

-bool MappedInputManager::wasAnyPressed() const { return inputManager.wasAnyPressed(); }
+bool MappedInputManager::wasAnyPressed() const { return gpio.wasAnyPressed(); }

-bool MappedInputManager::wasAnyReleased() const { return inputManager.wasAnyReleased(); }
+bool MappedInputManager::wasAnyReleased() const { return gpio.wasAnyReleased(); }

-unsigned long MappedInputManager::getHeldTime() const { return inputManager.getHeldTime(); }
+unsigned long MappedInputManager::getHeldTime() const { return gpio.getHeldTime(); }

 MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const char* confirm, const char* previous,
                                                         const char* next) const {
@ -91,4 +89,4 @@ MappedInputManager::Labels MappedInputManager::mapLabels(const char* back, const
    default:
      return {back, confirm, previous, next};
  }
-}
+}
--- a/src/MappedInputManager.h
+++ b/src/MappedInputManager.h
@ -1,6 +1,6 @@
 #pragma once

-#include <InputManager.h>
+#include <HalGPIO.h>

 class MappedInputManager {
 public:
@ -13,7 +13,7 @@ class MappedInputManager {
    const char* btn4;
  };

-  explicit MappedInputManager(InputManager& inputManager) : inputManager(inputManager) {}
+  explicit MappedInputManager(HalGPIO& gpio) : gpio(gpio) {}

  bool wasPressed(Button button) const;
  bool wasReleased(Button button) const;
@ -24,7 +24,7 @@ class MappedInputManager {
  Labels mapLabels(const char* back, const char* confirm, const char* previous, const char* next) const;

 private:
-  InputManager& inputManager;
+  HalGPIO& gpio;

-  bool mapButton(Button button, bool (InputManager::*fn)(uint8_t) const) const;
+  bool mapButton(Button button, bool (HalGPIO::*fn)(uint8_t) const) const;
 };
--- a/src/RecentBooksStore.cpp
+++ b/src/RecentBooksStore.cpp
@ -7,22 +7,23 @@
 #include <algorithm>

 namespace {
-constexpr uint8_t RECENT_BOOKS_FILE_VERSION = 1;
+constexpr uint8_t RECENT_BOOKS_FILE_VERSION = 2;
 constexpr char RECENT_BOOKS_FILE[] = "/.crosspoint/recent.bin";
 constexpr int MAX_RECENT_BOOKS = 10;
 }  // namespace

 RecentBooksStore RecentBooksStore::instance;

-void RecentBooksStore::addBook(const std::string& path) {
+void RecentBooksStore::addBook(const std::string& path, const std::string& title, const std::string& author) {
  // Remove existing entry if present
-  auto it = std::find(recentBooks.begin(), recentBooks.end(), path);
+  auto it =
+      std::find_if(recentBooks.begin(), recentBooks.end(), [&](const RecentBook& book) { return book.path == path; });
  if (it != recentBooks.end()) {
    recentBooks.erase(it);
  }

  // Add to front
-  recentBooks.insert(recentBooks.begin(), path);
+  recentBooks.insert(recentBooks.begin(), {path, title, author});

  // Trim to max size
  if (recentBooks.size() > MAX_RECENT_BOOKS) {
@ -46,7 +47,9 @@ bool RecentBooksStore::saveToFile() const {
  serialization::writePod(outputFile, count);

  for (const auto& book : recentBooks) {
-    serialization::writeString(outputFile, book);
+    serialization::writeString(outputFile, book.path);
+    serialization::writeString(outputFile, book.title);
+    serialization::writeString(outputFile, book.author);
  }

  outputFile.close();
@ -63,24 +66,41 @@ bool RecentBooksStore::loadFromFile() {
  uint8_t version;
  serialization::readPod(inputFile, version);
  if (version != RECENT_BOOKS_FILE_VERSION) {
-    Serial.printf("[%lu] [RBS] Deserialization failed: Unknown version %u\n", millis(), version);
-    inputFile.close();
-    return false;
-  }
+    if (version == 1) {
+      // Old version, just read paths
+      uint8_t count;
+      serialization::readPod(inputFile, count);
+      recentBooks.clear();
+      recentBooks.reserve(count);
+      for (uint8_t i = 0; i < count; i++) {
+        std::string path;
+        serialization::readString(inputFile, path);
+        // Title and author will be empty, they will be filled when the book is
+        // opened again
+        recentBooks.push_back({path, "", ""});
+      }
+    } else {
+      Serial.printf("[%lu] [RBS] Deserialization failed: Unknown version %u\n", millis(), version);
+      inputFile.close();
+      return false;
+    }
+  } else {
+    uint8_t count;
+    serialization::readPod(inputFile, count);

-  uint8_t count;
-  serialization::readPod(inputFile, count);
+    recentBooks.clear();
+    recentBooks.reserve(count);

-  recentBooks.clear();
-  recentBooks.reserve(count);
-
-  for (uint8_t i = 0; i < count; i++) {
-    std::string path;
-    serialization::readString(inputFile, path);
-    recentBooks.push_back(path);
+    for (uint8_t i = 0; i < count; i++) {
+      std::string path, title, author;
+      serialization::readString(inputFile, path);
+      serialization::readString(inputFile, title);
+      serialization::readString(inputFile, author);
+      recentBooks.push_back({path, title, author});
+    }
  }

  inputFile.close();
-  Serial.printf("[%lu] [RBS] Recent books loaded from file (%d entries)\n", millis(), count);
+  Serial.printf("[%lu] [RBS] Recent books loaded from file (%d entries)\n", millis(), recentBooks.size());
  return true;
 }
--- a/src/RecentBooksStore.h
+++ b/src/RecentBooksStore.h
@ -2,11 +2,19 @@
 #include <string>
 #include <vector>

+struct RecentBook {
+  std::string path;
+  std::string title;
+  std::string author;
+
+  bool operator==(const RecentBook& other) const { return path == other.path; }
+};
+
 class RecentBooksStore {
  // Static instance
  static RecentBooksStore instance;

-  std::vector<std::string> recentBooks;
+  std::vector<RecentBook> recentBooks;

 public:
  ~RecentBooksStore() = default;
@ -14,11 +22,11 @@ class RecentBooksStore {
  // Get singleton instance
  static RecentBooksStore& getInstance() { return instance; }

-  // Add a book path to the recent list (moves to front if already exists)
-  void addBook(const std::string& path);
+  // Add a book to the recent list (moves to front if already exists)
+  void addBook(const std::string& path, const std::string& title, const std::string& author);

-  // Get the list of recent book paths (most recent first)
-  const std::vector<std::string>& getBooks() const { return recentBooks; }
+  // Get the list of recent books (most recent first)
+  const std::vector<RecentBook>& getBooks() const { return recentBooks; }

  // Get the count of recent books
  int getCount() const { return static_cast<int>(recentBooks.size()); }
--- a/src/activities/boot_sleep/SleepActivity.cpp
+++ b/src/activities/boot_sleep/SleepActivity.cpp
@ -133,7 +133,7 @@ void SleepActivity::renderDefaultSleepScreen() const {
    renderer.invertScreen();
  }

-  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+  renderer.displayBuffer(HalDisplay::HALF_REFRESH);
 }

 void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
@ -189,7 +189,7 @@ void SleepActivity::renderBitmapSleepScreen(const Bitmap& bitmap) const {
    renderer.invertScreen();
  }

-  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+  renderer.displayBuffer(HalDisplay::HALF_REFRESH);

  if (hasGreyscale) {
    bitmap.rewindToData();
@ -280,5 +280,5 @@ void SleepActivity::renderCoverSleepScreen() const {

 void SleepActivity::renderBlankSleepScreen() const {
  renderer.clearScreen();
-  renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+  renderer.displayBuffer(HalDisplay::HALF_REFRESH);
 }
--- a/src/activities/home/MyLibraryActivity.cpp
+++ b/src/activities/home/MyLibraryActivity.cpp
@ -16,6 +16,7 @@ namespace {
 constexpr int TAB_BAR_Y = 15;
 constexpr int CONTENT_START_Y = 60;
 constexpr int LINE_HEIGHT = 30;
+constexpr int RECENTS_LINE_HEIGHT = 65;  // Increased for two-line items
 constexpr int LEFT_MARGIN = 20;
 constexpr int RIGHT_MARGIN = 40;  // Extra space for scroll indicator

@ -47,7 +48,7 @@ int MyLibraryActivity::getPageItems() const {

 int MyLibraryActivity::getCurrentItemCount() const {
  if (currentTab == Tab::Recent) {
-    return static_cast<int>(bookTitles.size());
+    return static_cast<int>(recentBooks.size());
  }
  return static_cast<int>(files.size());
 }
@ -65,34 +66,16 @@ int MyLibraryActivity::getCurrentPage() const {
 }

 void MyLibraryActivity::loadRecentBooks() {
-  constexpr size_t MAX_RECENT_BOOKS = 20;
-
-  bookTitles.clear();
-  bookPaths.clear();
+  recentBooks.clear();
  const auto& books = RECENT_BOOKS.getBooks();
-  bookTitles.reserve(std::min(books.size(), MAX_RECENT_BOOKS));
-  bookPaths.reserve(std::min(books.size(), MAX_RECENT_BOOKS));
-
-  for (const auto& path : books) {
-    // Limit to maximum number of recent books
-    if (bookTitles.size() >= MAX_RECENT_BOOKS) {
-      break;
-    }
+  recentBooks.reserve(books.size());

+  for (const auto& book : books) {
    // Skip if file no longer exists
-    if (!SdMan.exists(path.c_str())) {
+    if (!SdMan.exists(book.path.c_str())) {
      continue;
    }
-
-    // Extract filename from path for display
-    std::string title = path;
-    const size_t lastSlash = title.find_last_of('/');
-    if (lastSlash != std::string::npos) {
-      title = title.substr(lastSlash + 1);
-    }
-
-    bookTitles.push_back(title);
-    bookPaths.push_back(path);
+    recentBooks.push_back(book);
  }
 }

@ -176,8 +159,6 @@ void MyLibraryActivity::onExit() {
  vSemaphoreDelete(renderingMutex);
  renderingMutex = nullptr;

-  bookTitles.clear();
-  bookPaths.clear();
  files.clear();
 }

@ -207,8 +188,8 @@ void MyLibraryActivity::loop() {
  // Confirm button - open selected item
  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
    if (currentTab == Tab::Recent) {
-      if (!bookPaths.empty() && selectorIndex < static_cast<int>(bookPaths.size())) {
-        onSelectBook(bookPaths[selectorIndex], currentTab);
+      if (!recentBooks.empty() && selectorIndex < static_cast<int>(recentBooks.size())) {
+        onSelectBook(recentBooks[selectorIndex].path, currentTab);
      }
    } else {
      // Files tab
@ -333,7 +314,7 @@ void MyLibraryActivity::render() const {
 void MyLibraryActivity::renderRecentTab() const {
  const auto pageWidth = renderer.getScreenWidth();
  const int pageItems = getPageItems();
-  const int bookCount = static_cast<int>(bookTitles.size());
+  const int bookCount = static_cast<int>(recentBooks.size());

  if (bookCount == 0) {
    renderer.drawText(UI_10_FONT_ID, LEFT_MARGIN, CONTENT_START_Y, "No recent books");
@ -343,14 +324,37 @@ void MyLibraryActivity::renderRecentTab() const {
  const auto pageStartIndex = selectorIndex / pageItems * pageItems;

  // Draw selection highlight
-  renderer.fillRect(0, CONTENT_START_Y + (selectorIndex % pageItems) * LINE_HEIGHT - 2, pageWidth - RIGHT_MARGIN,
-                    LINE_HEIGHT);
+  renderer.fillRect(0, CONTENT_START_Y + (selectorIndex % pageItems) * RECENTS_LINE_HEIGHT - 2,
+                    pageWidth - RIGHT_MARGIN, RECENTS_LINE_HEIGHT);

  // Draw items
  for (int i = pageStartIndex; i < bookCount && i < pageStartIndex + pageItems; i++) {
-    auto item = renderer.truncatedText(UI_10_FONT_ID, bookTitles[i].c_str(), pageWidth - LEFT_MARGIN - RIGHT_MARGIN);
-    renderer.drawText(UI_10_FONT_ID, LEFT_MARGIN, CONTENT_START_Y + (i % pageItems) * LINE_HEIGHT, item.c_str(),
-                      i != selectorIndex);
+    const auto& book = recentBooks[i];
+    const int y = CONTENT_START_Y + (i % pageItems) * RECENTS_LINE_HEIGHT;
+
+    // Line 1: Title
+    std::string title = book.title;
+    if (title.empty()) {
+      // Fallback for older entries or files without metadata
+      title = book.path;
+      const size_t lastSlash = title.find_last_of('/');
+      if (lastSlash != std::string::npos) {
+        title = title.substr(lastSlash + 1);
+      }
+      const size_t dot = title.find_last_of('.');
+      if (dot != std::string::npos) {
+        title.resize(dot);
+      }
+    }
+    auto truncatedTitle = renderer.truncatedText(UI_12_FONT_ID, title.c_str(), pageWidth - LEFT_MARGIN - RIGHT_MARGIN);
+    renderer.drawText(UI_12_FONT_ID, LEFT_MARGIN, y + 2, truncatedTitle.c_str(), i != selectorIndex);
+
+    // Line 2: Author
+    if (!book.author.empty()) {
+      auto truncatedAuthor =
+          renderer.truncatedText(UI_10_FONT_ID, book.author.c_str(), pageWidth - LEFT_MARGIN - RIGHT_MARGIN);
+      renderer.drawText(UI_10_FONT_ID, LEFT_MARGIN, y + 32, truncatedAuthor.c_str(), i != selectorIndex);
+    }
  }
 }

--- a/src/activities/home/MyLibraryActivity.h
+++ b/src/activities/home/MyLibraryActivity.h
@ -8,6 +8,7 @@
 #include <vector>

 #include "../Activity.h"
+#include "RecentBooksStore.h"

 class MyLibraryActivity final : public Activity {
 public:
@ -22,8 +23,7 @@ class MyLibraryActivity final : public Activity {
  bool updateRequired = false;

  // Recent tab state
-  std::vector<std::string> bookTitles;  // Display titles for each book
-  std::vector<std::string> bookPaths;   // Paths for each visible book (excludes missing)
+  std::vector<RecentBook> recentBooks;

  // Files tab state (from FileSelectionActivity)
  std::string basepath = "/";
--- a/src/activities/reader/EpubReaderActivity.cpp
+++ b/src/activities/reader/EpubReaderActivity.cpp
@ -7,9 +7,7 @@

 #include "CrossPointSettings.h"
 #include "CrossPointState.h"
-#include "EpubReaderChapterSelectionActivity.h"
-#include "EpubReaderFootnotesActivity.h"
-#include "EpubReaderMenuActivity.h"
+#include "EpubReaderTocActivity.h"
 #include "MappedInputManager.h"
 #include "RecentBooksStore.h"
 #include "ScreenComponents.h"
@ -86,7 +84,7 @@ void EpubReaderActivity::onEnter() {
  // Save current epub as last opened epub and add to recent books
  APP_STATE.openEpubPath = epub->getPath();
  APP_STATE.saveToFile();
-  RECENT_BOOKS.addBook(epub->getPath());
+  RECENT_BOOKS.addBook(epub->getPath(), epub->getTitle(), epub->getAuthor());

  // Trigger first update
  updateRequired = true;
@ -131,65 +129,41 @@ void EpubReaderActivity::loop() {
    const int currentPage = section ? section->currentPage : 0;
    const int totalPages = section ? section->pageCount : 0;

-    // Show menu instead of direct chapter selection, to allow access to footnotes
+    // Show consolidated TOC activity (Chapters and Footnotes)
    exitActivity();
-    enterNewActivity(new EpubReaderMenuActivity(
-        this->renderer, this->mappedInput,
+    enterNewActivity(new EpubReaderTocActivity(
+        this->renderer, this->mappedInput, epub, epub->getPath(), currentSpineIndex, currentPage, totalPages,
+        currentPageFootnotes,
        [this] {
-          // onGoBack from menu
-          updateRequired = true;
-          // Re-enter reader activity logic if needed (handled by stack)
-          // Actually ActivityWithSubactivity handles subActivity exit naturally
+          // onGoBack
          exitActivity();
+          updateRequired = true;
        },
-        [this, currentPage, totalPages](EpubReaderMenuActivity::MenuOption option) {
-          // onSelectOption - handle menu choice
-          if (option == EpubReaderMenuActivity::CHAPTERS) {
-            // Show chapter selection
-            exitActivity();
-            enterNewActivity(new EpubReaderChapterSelectionActivity(
-                this->renderer, this->mappedInput, epub, epub->getPath(), currentSpineIndex, currentPage, totalPages,
-                [this] {
-                  exitActivity();
-                  updateRequired = true;
-                },
-                [this](int newSpineIndex) {
-                  if (currentSpineIndex != newSpineIndex) {
-                    currentSpineIndex = newSpineIndex;
-                    nextPageNumber = 0;
-                    section.reset();
-                  }
-                  exitActivity();
-                  updateRequired = true;
-                },
-                [this](int newSpineIndex, int newPage) {
-                  // Handle sync position
-                  if (currentSpineIndex != newSpineIndex || (section && section->currentPage != newPage)) {
-                    currentSpineIndex = newSpineIndex;
-                    nextPageNumber = newPage;
-                    section.reset();
-                  }
-                  exitActivity();
-                  updateRequired = true;
-                }));
-          } else if (option == EpubReaderMenuActivity::FOOTNOTES) {
-            // Show footnotes page with current page notes
-            exitActivity();
-            enterNewActivity(new EpubReaderFootnotesActivity(
-                this->renderer, this->mappedInput,
-                currentPageFootnotes,  // Pass collected footnotes (reference)
-                [this] {
-                  // onGoBack from footnotes
-                  exitActivity();
-                  updateRequired = true;
-                },
-                [this](const char* href) {
-                  // onSelectFootnote - navigate to the footnote location
-                  navigateToHref(href, true);  // true = save current position
-                  exitActivity();
-                  updateRequired = true;
-                }));
+        [this](int newSpineIndex) {
+          // onSelectSpineIndex
+          if (currentSpineIndex != newSpineIndex) {
+            currentSpineIndex = newSpineIndex;
+            nextPageNumber = 0;
+            section.reset();
          }
+          exitActivity();
+          updateRequired = true;
+        },
+        [this](const char* href) {
+          // onSelectFootnote
+          navigateToHref(href, true);
+          exitActivity();
+          updateRequired = true;
+        },
+        [this](int newSpineIndex, int newPage) {
+          // onSyncPosition
+          if (currentSpineIndex != newSpineIndex || (section && section->currentPage != newPage)) {
+            currentSpineIndex = newSpineIndex;
+            nextPageNumber = newPage;
+            section.reset();
+          }
+          exitActivity();
+          updateRequired = true;
        }));
    xSemaphoreGive(renderingMutex);
  }
@ -386,7 +360,7 @@ void EpubReaderActivity::renderScreen() {
      auto progressCallback = [this, barX, barY, barWidth, barHeight](int progress) {
        const int fillWidth = (barWidth - 2) * progress / 100;
        renderer.fillRect(barX + 1, barY + 1, fillWidth, barHeight - 2, true);
-        renderer.displayBuffer(EInkDisplay::FAST_REFRESH);
+        renderer.displayBuffer(HalDisplay::FAST_REFRESH);
      };

      if (!section->createSectionFile(SETTINGS.getReaderFontId(), SETTINGS.getReaderLineCompression(),
@ -485,7 +459,7 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page, const int or
  page->render(renderer, SETTINGS.getReaderFontId(), orientedMarginLeft, orientedMarginTop);
  renderStatusBar(orientedMarginRight, orientedMarginBottom, orientedMarginLeft);
  if (pagesUntilFullRefresh <= 1) {
-    renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+    renderer.displayBuffer(HalDisplay::HALF_REFRESH);
    pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
  } else {
    renderer.displayBuffer();
--- a/src/activities/reader/EpubReaderActivity.h
+++ b/src/activities/reader/EpubReaderActivity.h
@ -5,7 +5,7 @@
 #include <freertos/semphr.h>
 #include <freertos/task.h>

-#include "EpubReaderFootnotesActivity.h"
+#include "FootnotesData.h"
 #include "activities/ActivityWithSubactivity.h"

 class EpubReaderActivity final : public ActivityWithSubactivity {
--- a/src/activities/reader/EpubReaderChapterSelectionActivity.cpp
+++ b/src/activities/reader/EpubReaderChapterSelectionActivity.cpp
@ -1,265 +0,0 @@
-#include "EpubReaderChapterSelectionActivity.h"
-
-#include <GfxRenderer.h>
-
-#include "KOReaderCredentialStore.h"
-#include "KOReaderSyncActivity.h"
-#include "MappedInputManager.h"
-#include "fontIds.h"
-
-namespace {
-// Time threshold for treating a long press as a page-up/page-down
-constexpr int SKIP_PAGE_MS = 700;
-}  // namespace
-
-bool EpubReaderChapterSelectionActivity::hasSyncOption() const { return KOREADER_STORE.hasCredentials(); }
-
-int EpubReaderChapterSelectionActivity::getTotalItems() const {
-  // Add 2 for sync options (top and bottom) if credentials are configured
-  const int syncCount = hasSyncOption() ? 2 : 0;
-  return epub->getTocItemsCount() + syncCount;
-}
-
-bool EpubReaderChapterSelectionActivity::isSyncItem(int index) const {
-  if (!hasSyncOption()) return false;
-  // First item and last item are sync options
-  return index == 0 || index == getTotalItems() - 1;
-}
-
-int EpubReaderChapterSelectionActivity::tocIndexFromItemIndex(int itemIndex) const {
-  // Account for the sync option at the top
-  const int offset = hasSyncOption() ? 1 : 0;
-  return itemIndex - offset;
-}
-
-int EpubReaderChapterSelectionActivity::getPageItems() const {
-  // Layout constants used in renderScreen
-  constexpr int startY = 60;
-  constexpr int lineHeight = 30;
-
-  const int screenHeight = renderer.getScreenHeight();
-  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
-  if (items < 1) {
-    items = 1;
-  }
-  return items;
-}
-
-void EpubReaderChapterSelectionActivity::taskTrampoline(void* param) {
-  auto* self = static_cast<EpubReaderChapterSelectionActivity*>(param);
-  self->displayTaskLoop();
-}
-
-void EpubReaderChapterSelectionActivity::buildFilteredChapterList() {
-  filteredSpineIndices.clear();
-
-  for (int i = 0; i < epub->getSpineItemsCount(); i++) {
-    // Skip footnote pages
-    if (epub->shouldHideFromToc(i)) {
-      Serial.printf("[%lu] [CHAP] Hiding footnote page at spine index: %d\n", millis(), i);
-      continue;
-    }
-
-    // Skip pages without TOC entry (unnamed pages)
-    int tocIndex = epub->getTocIndexForSpineIndex(i);
-    if (tocIndex == -1) {
-      Serial.printf("[%lu] [CHAP] Hiding unnamed page at spine index: %d\n", millis(), i);
-      continue;
-    }
-
-    filteredSpineIndices.push_back(i);
-  }
-
-  Serial.printf("[%lu] [CHAP] Filtered chapters: %d out of %d\n", millis(), filteredSpineIndices.size(),
-                epub->getSpineItemsCount());
-}
-
-void EpubReaderChapterSelectionActivity::onEnter() {
-  ActivityWithSubactivity::onEnter();
-
-  if (!epub) {
-    return;
-  }
-
-  renderingMutex = xSemaphoreCreateMutex();
-
-  // Build filtered chapter list (excluding footnote pages)
-  buildFilteredChapterList();
-
-  // Find the index in filtered list that corresponds to currentSpineIndex
-  selectorIndex = 0;
-  for (size_t i = 0; i < filteredSpineIndices.size(); i++) {
-    if (filteredSpineIndices[i] == currentSpineIndex) {
-      selectorIndex = i;
-      break;
-    }
-  }
-
-  // Account for sync option offset when finding current TOC index (if applicable)
-  // For simplicity, if we are using the filtered list, we might just put "Sync" at the top of THAT list?
-  // But wait, the filtered list is spine indices.
-  // The master logic used TOC indices directly.
-  // Let's adapt: We will display the filtered list.
-  // If sync is enabled, we prepend/append it to the selector range.
-
-  if (hasSyncOption()) {
-    selectorIndex += 1;  // Offset for top sync option
-  }
-
-  // Trigger first update
-  updateRequired = true;
-  xTaskCreate(&EpubReaderChapterSelectionActivity::taskTrampoline, "EpubReaderChapterSelectionActivityTask",
-              4096,               // Stack size
-              this,               // Parameters
-              1,                  // Priority
-              &displayTaskHandle  // Task handle
-  );
-}
-
-void EpubReaderChapterSelectionActivity::onExit() {
-  ActivityWithSubactivity::onExit();
-
-  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
-  xSemaphoreTake(renderingMutex, portMAX_DELAY);
-  if (displayTaskHandle) {
-    vTaskDelete(displayTaskHandle);
-    displayTaskHandle = nullptr;
-  }
-  vSemaphoreDelete(renderingMutex);
-  renderingMutex = nullptr;
-}
-
-void EpubReaderChapterSelectionActivity::launchSyncActivity() {
-  xSemaphoreTake(renderingMutex, portMAX_DELAY);
-  exitActivity();
-  enterNewActivity(new KOReaderSyncActivity(
-      renderer, mappedInput, epub, epubPath, currentSpineIndex, currentPage, totalPagesInSpine,
-      [this]() {
-        // On cancel
-        exitActivity();
-        updateRequired = true;
-      },
-      [this](int newSpineIndex, int newPage) {
-        // On sync complete
-        exitActivity();
-        onSyncPosition(newSpineIndex, newPage);
-      }));
-  xSemaphoreGive(renderingMutex);
-}
-
-void EpubReaderChapterSelectionActivity::loop() {
-  if (subActivity) {
-    subActivity->loop();
-    return;
-  }
-
-  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;
-  const int pageItems = getPageItems();
-
-  // Total items = filtered chapters + sync options
-  const int syncCount = hasSyncOption() ? 2 : 0;
-  const int totalItems = filteredSpineIndices.size() + syncCount;
-
-  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
-    // Check if sync option is selected
-    if (hasSyncOption()) {
-      if (selectorIndex == 0 || selectorIndex == totalItems - 1) {
-        launchSyncActivity();
-        return;
-      }
-    }
-
-    // It's a chapter. Calculate index in filtered list.
-    int filteredIndex = selectorIndex;
-    if (hasSyncOption()) filteredIndex -= 1;  // Remove top sync offset
-
-    if (filteredIndex >= 0 && filteredIndex < filteredSpineIndices.size()) {
-      onSelectSpineIndex(filteredSpineIndices[filteredIndex]);
-    }
-  } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
-    onGoBack();
-  } else if (prevReleased) {
-    if (skipPage) {
-      selectorIndex = ((selectorIndex / pageItems - 1) * pageItems + totalItems) % totalItems;
-    } else {
-      selectorIndex = (selectorIndex + totalItems - 1) % totalItems;
-    }
-    updateRequired = true;
-  } else if (nextReleased) {
-    if (skipPage) {
-      selectorIndex = ((selectorIndex / pageItems + 1) * pageItems) % totalItems;
-    } else {
-      selectorIndex = (selectorIndex + 1) % totalItems;
-    }
-    updateRequired = true;
-  }
-}
-
-void EpubReaderChapterSelectionActivity::displayTaskLoop() {
-  while (true) {
-    if (updateRequired && !subActivity) {
-      updateRequired = false;
-      xSemaphoreTake(renderingMutex, portMAX_DELAY);
-      renderScreen();
-      xSemaphoreGive(renderingMutex);
-    }
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-  }
-}
-
-void EpubReaderChapterSelectionActivity::renderScreen() {
-  renderer.clearScreen();
-
-  const auto pageWidth = renderer.getScreenWidth();
-  const int pageItems = getPageItems();
-  const int totalItems = getTotalItems();
-
-  const std::string title =
-      renderer.truncatedText(UI_12_FONT_ID, epub->getTitle().c_str(), pageWidth - 40, EpdFontFamily::BOLD);
-  renderer.drawCenteredText(UI_12_FONT_ID, 15, title.c_str(), true, EpdFontFamily::BOLD);
-
-  const auto pageStartIndex = selectorIndex / pageItems * pageItems;
-  renderer.fillRect(0, 60 + (selectorIndex % pageItems) * 30 - 2, pageWidth - 1, 30);
-
-  for (int i = 0; i < pageItems; i++) {
-    int itemIndex = pageStartIndex + i;
-    if (itemIndex >= totalItems) break;
-
-    const int displayY = 60 + i * 30;
-    const bool isSelected = (itemIndex == selectorIndex);
-
-    if (isSyncItem(itemIndex)) {
-      renderer.drawText(UI_10_FONT_ID, 20, displayY, ">> Sync Progress", !isSelected);
-    } else {
-      const int tocIndex = tocIndexFromItemIndex(itemIndex);
-
-      if (tocIndex == -1) {
-        renderer.drawText(UI_10_FONT_ID, 20, displayY, "Unnamed", !isSelected);
-      } else {
-        // Master's rendering logic
-        auto item = epub->getTocItem(tocIndex);
-
-        const int indentSize = 20 + (item.level - 1) * 15;
-        const std::string chapterName =
-            renderer.truncatedText(UI_10_FONT_ID, item.title.c_str(), pageWidth - 40 - indentSize);
-
-        renderer.drawText(UI_10_FONT_ID, indentSize, displayY, chapterName.c_str(), !isSelected);
-      }
-    }
-  }
-
-  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();
-}
--- a/src/activities/reader/EpubReaderChapterSelectionActivity.h
+++ b/src/activities/reader/EpubReaderChapterSelectionActivity.h
@ -1,70 +0,0 @@
-#pragma once
-#include <Epub.h>
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-#include <freertos/task.h>
-
-#include <memory>
-#include <vector>
-
-#include "../ActivityWithSubactivity.h"
-
-class EpubReaderChapterSelectionActivity final : public ActivityWithSubactivity {
-  std::shared_ptr<Epub> epub;
-  std::string epubPath;
-  TaskHandle_t displayTaskHandle = nullptr;
-  SemaphoreHandle_t renderingMutex = nullptr;
-  int currentSpineIndex = 0;
-  int currentPage = 0;
-  int totalPagesInSpine = 0;
-  int selectorIndex = 0;
-  bool updateRequired = false;
-  const std::function<void()> onGoBack;
-  const std::function<void(int newSpineIndex)> onSelectSpineIndex;
-  const std::function<void(int newSpineIndex, int newPage)> onSyncPosition;
-
-  // Number of items that fit on a page, derived from logical screen height.
-  // This adapts automatically when switching between portrait and landscape.
-  int getPageItems() const;
-
-  // Total items including sync options (top and bottom)
-  int getTotalItems() const;
-
-  // Check if sync option is available (credentials configured)
-  bool hasSyncOption() const;
-
-  // Check if given item index is a sync option (first or last)
-  bool isSyncItem(int index) const;
-
-  // Convert item index to TOC index (accounting for top sync option offset)
-  int tocIndexFromItemIndex(int itemIndex) const;
-
-  // Filtered list of spine indices (excluding footnote pages)
-  std::vector<int> filteredSpineIndices;
-
-  static void taskTrampoline(void* param);
-  [[noreturn]] void displayTaskLoop();
-  void renderScreen();
-  void buildFilteredChapterList();
-  void launchSyncActivity();
-
- public:
-  explicit EpubReaderChapterSelectionActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
-                                              const std::shared_ptr<Epub>& epub, const std::string& epubPath,
-                                              const int currentSpineIndex, const int currentPage,
-                                              const int totalPagesInSpine, const std::function<void()>& onGoBack,
-                                              const std::function<void(int newSpineIndex)>& onSelectSpineIndex,
-                                              const std::function<void(int newSpineIndex, int newPage)>& onSyncPosition)
-      : ActivityWithSubactivity("EpubReaderChapterSelection", renderer, mappedInput),
-        epub(epub),
-        epubPath(epubPath),
-        currentSpineIndex(currentSpineIndex),
-        currentPage(currentPage),
-        totalPagesInSpine(totalPagesInSpine),
-        onGoBack(onGoBack),
-        onSelectSpineIndex(onSelectSpineIndex),
-        onSyncPosition(onSyncPosition) {}
-  void onEnter() override;
-  void onExit() override;
-  void loop() override;
-};
--- a/src/activities/reader/EpubReaderFootnotesActivity.cpp
+++ b/src/activities/reader/EpubReaderFootnotesActivity.cpp
@ -1,91 +0,0 @@
-#include "EpubReaderFootnotesActivity.h"
-
-#include <EpdFontFamily.h>
-#include <GfxRenderer.h>
-
-#include "MappedInputManager.h"
-#include "fontIds.h"
-
-void EpubReaderFootnotesActivity::onEnter() {
-  selectedIndex = 0;
-  render();
-}
-
-void EpubReaderFootnotesActivity::onExit() {
-  // Nothing to clean up
-}
-
-void EpubReaderFootnotesActivity::loop() {
-  if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
-    onGoBack();
-    return;
-  }
-
-  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
-    const FootnoteEntry* entry = footnotes.getEntry(selectedIndex);
-    if (entry) {
-      Serial.printf("[%lu] [FNS] Selected footnote: %s -> %s\n", millis(), entry->number, entry->href);
-      onSelectFootnote(entry->href);
-    }
-    return;
-  }
-
-  bool needsRedraw = false;
-
-  if (mappedInput.wasPressed(MappedInputManager::Button::Up)) {
-    if (selectedIndex > 0) {
-      selectedIndex--;
-      needsRedraw = true;
-    }
-  }
-
-  if (mappedInput.wasPressed(MappedInputManager::Button::Down)) {
-    if (selectedIndex < footnotes.getCount() - 1) {
-      selectedIndex++;
-      needsRedraw = true;
-    }
-  }
-
-  if (needsRedraw) {
-    render();
-  }
-}
-
-void EpubReaderFootnotesActivity::render() {
-  renderer.clearScreen();
-
-  constexpr int startY = 50;
-  constexpr int lineHeight = 40;
-  constexpr int marginLeft = 20;
-
-  // Title
-  renderer.drawText(UI_12_FONT_ID, marginLeft, 20, "Footnotes", EpdFontFamily::BOLD);
-
-  if (footnotes.getCount() == 0) {
-    renderer.drawText(SMALL_FONT_ID, marginLeft, startY + 20, "No footnotes on this page");
-    renderer.displayBuffer();
-    return;
-  }
-
-  // Display footnotes
-  for (int i = 0; i < footnotes.getCount(); i++) {
-    const FootnoteEntry* entry = footnotes.getEntry(i);
-    if (!entry) continue;
-
-    const int y = startY + i * lineHeight;
-
-    // Draw selection indicator (arrow)
-    if (i == selectedIndex) {
-      renderer.drawText(UI_12_FONT_ID, marginLeft - 10, y, ">", EpdFontFamily::BOLD);
-      renderer.drawText(UI_12_FONT_ID, marginLeft + 10, y, entry->number, EpdFontFamily::BOLD);
-    } else {
-      renderer.drawText(UI_12_FONT_ID, marginLeft + 10, y, entry->number);
-    }
-  }
-
-  // Instructions at bottom
-  renderer.drawText(SMALL_FONT_ID, marginLeft, renderer.getScreenHeight() - 40,
-                    "UP/DOWN: Select  CONFIRM: Go to footnote  BACK: Return");
-
-  renderer.displayBuffer();
-}
--- a/src/activities/reader/EpubReaderFootnotesActivity.h
+++ b/src/activities/reader/EpubReaderFootnotesActivity.h
@ -1,72 +0,0 @@
-#pragma once
-#include <cstring>
-#include <functional>
-#include <memory>
-
-#include "../../lib/Epub/Epub/FootnoteEntry.h"
-#include "../Activity.h"
-
-class FootnotesData {
- private:
-  FootnoteEntry entries[16];
-  int count;
-
- public:
-  FootnotesData() : count(0) {
-    for (int i = 0; i < 16; i++) {
-      entries[i].number[0] = '\0';
-      entries[i].href[0] = '\0';
-    }
-  }
-
-  void addFootnote(const char* number, const char* href) {
-    if (count < 16 && number && href) {
-      strncpy(entries[count].number, number, 2);
-      entries[count].number[2] = '\0';
-      strncpy(entries[count].href, href, 63);
-      entries[count].href[63] = '\0';
-      count++;
-    }
-  }
-
-  void clear() {
-    count = 0;
-    for (int i = 0; i < 16; i++) {
-      entries[i].number[0] = '\0';
-      entries[i].href[0] = '\0';
-    }
-  }
-
-  int getCount() const { return count; }
-
-  const FootnoteEntry* getEntry(int index) const {
-    if (index >= 0 && index < count) {
-      return &entries[index];
-    }
-    return nullptr;
-  }
-};
-
-class EpubReaderFootnotesActivity final : public Activity {
-  const FootnotesData& footnotes;
-  const std::function<void()> onGoBack;
-  const std::function<void(const char*)> onSelectFootnote;
-  int selectedIndex;
-
- public:
-  EpubReaderFootnotesActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, const FootnotesData& footnotes,
-                              const std::function<void()>& onGoBack,
-                              const std::function<void(const char*)>& onSelectFootnote)
-      : Activity("EpubReaderFootnotes", renderer, mappedInput),
-        footnotes(footnotes),
-        onGoBack(onGoBack),
-        onSelectFootnote(onSelectFootnote),
-        selectedIndex(0) {}
-
-  void onEnter() override;
-  void onExit() override;
-  void loop() override;
-
- private:
-  void render();
-};
--- a/src/activities/reader/EpubReaderMenuActivity.cpp
+++ b/src/activities/reader/EpubReaderMenuActivity.cpp
@ -1,96 +0,0 @@
-#include "EpubReaderMenuActivity.h"
-
-#include <EpdFontFamily.h>
-#include <GfxRenderer.h>
-
-#include "MappedInputManager.h"
-#include "fontIds.h"
-
-constexpr int MENU_ITEMS_COUNT = 2;
-
-void EpubReaderMenuActivity::taskTrampoline(void* param) {
-  auto* self = static_cast<EpubReaderMenuActivity*>(param);
-  self->displayTaskLoop();
-}
-
-void EpubReaderMenuActivity::onEnter() {
-  renderingMutex = xSemaphoreCreateMutex();
-  selectorIndex = 0;
-
-  // Trigger first update
-  updateRequired = true;
-  xTaskCreate(&EpubReaderMenuActivity::taskTrampoline, "EpubReaderMenuTask",
-              2048,               // Stack size
-              this,               // Parameters
-              1,                  // Priority
-              &displayTaskHandle  // Task handle
-  );
-}
-
-void EpubReaderMenuActivity::onExit() {
-  // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
-  xSemaphoreTake(renderingMutex, portMAX_DELAY);
-  if (displayTaskHandle) {
-    vTaskDelete(displayTaskHandle);
-    displayTaskHandle = nullptr;
-  }
-  vSemaphoreDelete(renderingMutex);
-  renderingMutex = nullptr;
-}
-
-void EpubReaderMenuActivity::loop() {
-  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);
-
-  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
-    onSelectOption(static_cast<MenuOption>(selectorIndex));
-  } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
-    onGoBack();
-  } else if (prevReleased) {
-    selectorIndex = (selectorIndex + MENU_ITEMS_COUNT - 1) % MENU_ITEMS_COUNT;
-    updateRequired = true;
-  } else if (nextReleased) {
-    selectorIndex = (selectorIndex + 1) % MENU_ITEMS_COUNT;
-    updateRequired = true;
-  }
-}
-
-void EpubReaderMenuActivity::displayTaskLoop() {
-  while (true) {
-    if (updateRequired) {
-      updateRequired = false;
-      xSemaphoreTake(renderingMutex, portMAX_DELAY);
-      renderScreen();
-      xSemaphoreGive(renderingMutex);
-    }
-    vTaskDelay(10 / portTICK_PERIOD_MS);
-  }
-}
-
-void EpubReaderMenuActivity::renderScreen() {
-  renderer.clearScreen();
-
-  const auto pageWidth = renderer.getScreenWidth();
-  renderer.drawCenteredText(UI_12_FONT_ID, 10, "Menu", true, EpdFontFamily::BOLD);
-
-  const char* menuItems[MENU_ITEMS_COUNT] = {"Go to chapter", "View footnotes"};
-
-  const int startY = 100;
-  const int itemHeight = 40;
-
-  for (int i = 0; i < MENU_ITEMS_COUNT; i++) {
-    const int y = startY + i * itemHeight;
-
-    // Draw selection indicator
-    if (i == selectorIndex) {
-      renderer.fillRect(10, y + 2, pageWidth - 20, itemHeight - 4);
-      renderer.drawText(UI_12_FONT_ID, 30, y, menuItems[i], false);
-    } else {
-      renderer.drawText(UI_12_FONT_ID, 30, y, menuItems[i], true);
-    }
-  }
-
-  renderer.displayBuffer();
-}
--- a/src/activities/reader/EpubReaderMenuActivity.h
+++ b/src/activities/reader/EpubReaderMenuActivity.h
@ -1,33 +0,0 @@
-#pragma once
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-#include <freertos/task.h>
-
-#include "../Activity.h"
-
-class EpubReaderMenuActivity final : public Activity {
- public:
-  enum MenuOption { CHAPTERS, FOOTNOTES };
-
- private:
-  TaskHandle_t displayTaskHandle = nullptr;
-  SemaphoreHandle_t renderingMutex = nullptr;
-  int selectorIndex = 0;
-  bool updateRequired = false;
-  const std::function<void()> onGoBack;
-  const std::function<void(MenuOption option)> onSelectOption;
-
-  static void taskTrampoline(void* param);
-  [[noreturn]] void displayTaskLoop();
-  void renderScreen();
-
- public:
-  explicit EpubReaderMenuActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
-                                  const std::function<void()>& onGoBack,
-                                  const std::function<void(MenuOption option)>& onSelectOption)
-      : Activity("EpubReaderMenu", renderer, mappedInput), onGoBack(onGoBack), onSelectOption(onSelectOption) {}
-
-  void onEnter() override;
-  void onExit() override;
-  void loop() override;
-};
--- a/src/activities/reader/EpubReaderTocActivity.cpp
+++ b/src/activities/reader/EpubReaderTocActivity.cpp
@ -0,0 +1,312 @@
+#include "EpubReaderTocActivity.h"
+
+#include <EpdFontFamily.h>
+#include <GfxRenderer.h>
+
+#include "KOReaderCredentialStore.h"
+#include "KOReaderSyncActivity.h"
+#include "MappedInputManager.h"
+#include "ScreenComponents.h"
+#include "fontIds.h"
+
+namespace {
+constexpr int TAB_BAR_Y = 15;
+constexpr int CONTENT_START_Y = 60;
+constexpr int CHAPTER_LINE_HEIGHT = 30;
+constexpr int FOOTNOTE_LINE_HEIGHT = 40;
+constexpr int SKIP_PAGE_MS = 700;
+}  // namespace
+
+void EpubReaderTocActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<EpubReaderTocActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void EpubReaderTocActivity::onEnter() {
+  ActivityWithSubactivity::onEnter();
+  renderingMutex = xSemaphoreCreateMutex();
+
+  // Init chapters state
+  buildFilteredChapterList();
+  chaptersSelectorIndex = 0;
+  for (size_t i = 0; i < filteredSpineIndices.size(); i++) {
+    if (filteredSpineIndices[i] == currentSpineIndex) {
+      chaptersSelectorIndex = i;
+      break;
+    }
+  }
+  if (hasSyncOption()) {
+    chaptersSelectorIndex += 1;
+  }
+
+  // Init footnotes state
+  footnotesSelectedIndex = 0;
+
+  updateRequired = true;
+  xTaskCreate(&EpubReaderTocActivity::taskTrampoline, "EpubReaderTocTask", 4096, this, 1, &displayTaskHandle);
+}
+
+void EpubReaderTocActivity::onExit() {
+  ActivityWithSubactivity::onExit();
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void EpubReaderTocActivity::launchSyncActivity() {
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  exitActivity();
+  enterNewActivity(new KOReaderSyncActivity(
+      renderer, mappedInput, this->epub, epubPath, currentSpineIndex, currentPage, totalPagesInSpine,
+      [this]() {
+        exitActivity();
+        this->updateRequired = true;
+      },
+      [this](int newSpineIndex, int newPage) {
+        exitActivity();
+        this->onSyncPosition(newSpineIndex, newPage);
+      }));
+  xSemaphoreGive(renderingMutex);
+}
+
+void EpubReaderTocActivity::loop() {
+  if (subActivity) {
+    subActivity->loop();
+    return;
+  }
+
+  if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
+    onGoBack();
+    return;
+  }
+
+  const bool leftReleased = mappedInput.wasReleased(MappedInputManager::Button::Left);
+  const bool rightReleased = mappedInput.wasReleased(MappedInputManager::Button::Right);
+
+  if (leftReleased && currentTab == Tab::FOOTNOTES) {
+    currentTab = Tab::CHAPTERS;
+    updateRequired = true;
+    return;
+  }
+  if (rightReleased && currentTab == Tab::CHAPTERS) {
+    currentTab = Tab::FOOTNOTES;
+    updateRequired = true;
+    return;
+  }
+
+  if (currentTab == Tab::CHAPTERS) {
+    loopChapters();
+  } else {
+    loopFootnotes();
+  }
+}
+
+void EpubReaderTocActivity::loopChapters() {
+  const bool upReleased = mappedInput.wasReleased(MappedInputManager::Button::Up);
+  const bool downReleased = mappedInput.wasReleased(MappedInputManager::Button::Down);
+  const bool skipPage = mappedInput.getHeldTime() > SKIP_PAGE_MS;
+  const int totalItems = getChaptersTotalItems();
+
+  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+    if (isSyncItem(chaptersSelectorIndex)) {
+      launchSyncActivity();
+      return;
+    }
+
+    int filteredIndex = chaptersSelectorIndex;
+
+    if (hasSyncOption() && chaptersSelectorIndex > 0) filteredIndex -= 1;
+
+    if (filteredIndex >= 0 && filteredIndex < static_cast<int>(filteredSpineIndices.size())) {
+      onSelectSpineIndex(filteredSpineIndices[filteredIndex]);
+    }
+  } else if (mappedInput.wasReleased(MappedInputManager::Button::Back)) {
+    onGoBack();
+  } else if (upReleased) {
+    if (totalItems > 0) {
+      if (skipPage) {
+        // TODO: implement page-skip navigation once page size is available
+      }
+      chaptersSelectorIndex = (chaptersSelectorIndex + totalItems - 1) % totalItems;
+      updateRequired = true;
+    }
+  } else if (downReleased) {
+    if (totalItems > 0) {
+      if (skipPage) {
+        // TODO: implement page-skip navigation once page size is available
+      }
+      chaptersSelectorIndex = (chaptersSelectorIndex + 1) % totalItems;
+      updateRequired = true;
+    }
+  }
+}
+
+void EpubReaderTocActivity::loopFootnotes() {
+  bool needsRedraw = false;
+  if (mappedInput.wasPressed(MappedInputManager::Button::Up)) {
+    if (footnotesSelectedIndex > 0) {
+      footnotesSelectedIndex--;
+      needsRedraw = true;
+    }
+  }
+  if (mappedInput.wasPressed(MappedInputManager::Button::Down)) {
+    if (footnotesSelectedIndex < footnotes.getCount() - 1) {
+      footnotesSelectedIndex++;
+      needsRedraw = true;
+    }
+  }
+  if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+    const FootnoteEntry* entry = footnotes.getEntry(footnotesSelectedIndex);
+    if (entry) {
+      onSelectFootnote(entry->href);
+    }
+  }
+  if (needsRedraw) {
+    updateRequired = true;
+  }
+}
+
+void EpubReaderTocActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired && !subActivity) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      renderScreen();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void EpubReaderTocActivity::renderScreen() {
+  renderer.clearScreen();
+
+  std::vector<TabInfo> tabs = {{"Chapters", currentTab == Tab::CHAPTERS}, {"Footnotes", currentTab == Tab::FOOTNOTES}};
+  ScreenComponents::drawTabBar(renderer, TAB_BAR_Y, tabs);
+
+  const int screenHeight = renderer.getScreenHeight();
+  const int contentHeight = screenHeight - CONTENT_START_Y - 60;
+
+  if (currentTab == Tab::CHAPTERS) {
+    renderChapters(CONTENT_START_Y, contentHeight);
+  } else {
+    renderFootnotes(CONTENT_START_Y, contentHeight);
+  }
+
+  ScreenComponents::drawScrollIndicator(renderer, getCurrentPage(), getTotalPages(), CONTENT_START_Y, contentHeight);
+
+  const auto labels = mappedInput.mapLabels("« Back", "Select", "< Tab", "Tab >");
+  renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+  renderer.drawSideButtonHints(UI_10_FONT_ID, ">", "<");
+
+  renderer.displayBuffer();
+}
+
+void EpubReaderTocActivity::renderChapters(int contentTop, int contentHeight) {
+  const auto pageWidth = renderer.getScreenWidth();
+  const int pageItems = getChaptersPageItems(contentHeight);
+  const int totalItems = getChaptersTotalItems();
+  const auto pageStartIndex = chaptersSelectorIndex / pageItems * pageItems;
+
+  renderer.fillRect(0, contentTop + (chaptersSelectorIndex % pageItems) * CHAPTER_LINE_HEIGHT - 2, pageWidth - 1,
+                    CHAPTER_LINE_HEIGHT);
+
+  for (int i = 0; i < pageItems; i++) {
+    int itemIndex = pageStartIndex + i;
+    if (itemIndex >= totalItems) break;
+
+    const int displayY = contentTop + i * CHAPTER_LINE_HEIGHT;
+    const bool isSelected = (itemIndex == chaptersSelectorIndex);
+
+    if (isSyncItem(itemIndex)) {
+      renderer.drawText(UI_10_FONT_ID, 20, displayY, ">> Sync Progress", !isSelected);
+    } else {
+      int filteredIndex = itemIndex;
+      if (hasSyncOption()) filteredIndex -= 1;
+
+      if (filteredIndex >= 0 && filteredIndex < static_cast<int>(filteredSpineIndices.size())) {
+        int spineIndex = filteredSpineIndices[filteredIndex];
+        int tocIndex = this->epub->getTocIndexForSpineIndex(spineIndex);
+        if (tocIndex == -1) {
+          renderer.drawText(UI_10_FONT_ID, 20, displayY, "Unnamed", !isSelected);
+        } else {
+          auto item = this->epub->getTocItem(tocIndex);
+          const int indentSize = 20 + (item.level - 1) * 15;
+          const std::string chapterName =
+              renderer.truncatedText(UI_10_FONT_ID, item.title.c_str(), pageWidth - 40 - indentSize);
+          renderer.drawText(UI_10_FONT_ID, indentSize, displayY, chapterName.c_str(), !isSelected);
+        }
+      }
+    }
+  }
+}
+
+void EpubReaderTocActivity::renderFootnotes(int contentTop, int contentHeight) {
+  const int marginLeft = 20;
+  if (footnotes.getCount() == 0) {
+    renderer.drawText(SMALL_FONT_ID, marginLeft, contentTop + 20, "No footnotes on this page");
+    return;
+  }
+  for (int i = 0; i < footnotes.getCount(); i++) {
+    const FootnoteEntry* entry = footnotes.getEntry(i);
+    if (!entry) continue;
+    const int y = contentTop + i * FOOTNOTE_LINE_HEIGHT;
+    if (i == footnotesSelectedIndex) {
+      renderer.drawText(UI_12_FONT_ID, marginLeft - 10, y, ">", EpdFontFamily::BOLD);
+      renderer.drawText(UI_12_FONT_ID, marginLeft + 10, y, entry->number, EpdFontFamily::BOLD);
+    } else {
+      renderer.drawText(UI_12_FONT_ID, marginLeft + 10, y, entry->number);
+    }
+  }
+}
+
+void EpubReaderTocActivity::buildFilteredChapterList() {
+  filteredSpineIndices.clear();
+  for (int i = 0; i < this->epub->getSpineItemsCount(); i++) {
+    if (this->epub->shouldHideFromToc(i)) continue;
+    int tocIndex = this->epub->getTocIndexForSpineIndex(i);
+    if (tocIndex == -1) continue;
+    filteredSpineIndices.push_back(i);
+  }
+}
+
+bool EpubReaderTocActivity::hasSyncOption() const { return KOREADER_STORE.hasCredentials(); }
+
+bool EpubReaderTocActivity::isSyncItem(int index) const {
+  if (!hasSyncOption()) return false;
+  return index == 0 || index == getChaptersTotalItems() - 1;
+}
+
+int EpubReaderTocActivity::getChaptersTotalItems() const {
+  const int syncCount = hasSyncOption() ? 2 : 0;
+  return filteredSpineIndices.size() + syncCount;
+}
+
+int EpubReaderTocActivity::getChaptersPageItems(int contentHeight) const {
+  int items = contentHeight / CHAPTER_LINE_HEIGHT;
+  return (items < 1) ? 1 : items;
+}
+
+int EpubReaderTocActivity::getCurrentPage() const {
+  if (currentTab == Tab::CHAPTERS) {
+    const int availableHeight = renderer.getScreenHeight() - 120;
+    const int itemsPerPage = availableHeight / CHAPTER_LINE_HEIGHT;
+    return chaptersSelectorIndex / (itemsPerPage > 0 ? itemsPerPage : 1) + 1;
+  }
+  return 1;
+}
+
+int EpubReaderTocActivity::getTotalPages() const {
+  if (currentTab == Tab::CHAPTERS) {
+    const int availableHeight = renderer.getScreenHeight() - 120;
+    const int itemsPerPage = availableHeight / CHAPTER_LINE_HEIGHT;
+    const int totalItems = getChaptersTotalItems();
+    if (totalItems == 0) return 1;
+    return (totalItems + itemsPerPage - 1) / (itemsPerPage > 0 ? itemsPerPage : 1);
+  }
+  return 1;
+}
--- a/src/activities/reader/EpubReaderTocActivity.h
+++ b/src/activities/reader/EpubReaderTocActivity.h
@ -0,0 +1,90 @@
+#pragma once
+#include <Epub.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <memory>
+#include <vector>
+
+#include "../ActivityWithSubactivity.h"
+#include "FootnotesData.h"
+
+class EpubReaderTocActivity final : public ActivityWithSubactivity {
+ public:
+  enum class Tab { CHAPTERS, FOOTNOTES };
+
+ private:
+  std::shared_ptr<Epub> epub;
+  std::string epubPath;
+  const FootnotesData& footnotes;
+
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+
+  int currentSpineIndex = 0;
+  int currentPage = 0;
+  int totalPagesInSpine = 0;
+
+  Tab currentTab = Tab::CHAPTERS;
+  bool updateRequired = false;
+
+  // Chapters tab state
+  int chaptersSelectorIndex = 0;
+  std::vector<int> filteredSpineIndices;
+
+  // Footnotes tab state
+  int footnotesSelectedIndex = 0;
+
+  // Callbacks
+  const std::function<void()> onGoBack;
+  const std::function<void(int newSpineIndex)> onSelectSpineIndex;
+  const std::function<void(const char* href)> onSelectFootnote;
+  const std::function<void(int newSpineIndex, int newPage)> onSyncPosition;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void renderScreen();
+
+  // Tab-specific methods
+  void loopChapters();
+  void loopFootnotes();
+  void renderChapters(int contentTop, int contentHeight);
+  void renderFootnotes(int contentTop, int contentHeight);
+
+  // Chapters helpers
+  void buildFilteredChapterList();
+  bool hasSyncOption() const;
+  bool isSyncItem(int index) const;
+  int getChaptersTotalItems() const;
+  int getChaptersPageItems(int contentHeight) const;
+  int tocIndexFromItemIndex(int itemIndex) const;
+
+  // Indicator helpers
+  int getCurrentPage() const;
+  int getTotalPages() const;
+
+ public:
+  EpubReaderTocActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, const std::shared_ptr<Epub>& epub_ptr,
+                        const std::string& epubPath, int currentSpineIndex, int currentPage, int totalPagesInSpine,
+                        const FootnotesData& footnotes, std::function<void()> onGoBack,
+                        std::function<void(int)> onSelectSpineIndex, std::function<void(const char*)> onSelectFootnote,
+                        std::function<void(int, int)> onSyncPosition)
+      : ActivityWithSubactivity("EpubReaderToc", renderer, mappedInput),
+        epub(epub_ptr),
+        epubPath(epubPath),
+        currentSpineIndex(currentSpineIndex),
+        currentPage(currentPage),
+        totalPagesInSpine(totalPagesInSpine),
+        footnotes(footnotes),
+        onGoBack(onGoBack),
+        onSelectSpineIndex(onSelectSpineIndex),
+        onSelectFootnote(onSelectFootnote),
+        onSyncPosition(onSyncPosition) {}
+
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+
+  void launchSyncActivity();
+};
--- a/src/activities/reader/FootnotesData.h
+++ b/src/activities/reader/FootnotesData.h
@ -0,0 +1,45 @@
+#pragma once
+#include <Epub/FootnoteEntry.h>
+
+#include <cstring>
+
+class FootnotesData {
+ private:
+  FootnoteEntry entries[16];
+  int count;
+
+ public:
+  FootnotesData() : count(0) {
+    for (int i = 0; i < 16; i++) {
+      entries[i].number[0] = '\0';
+      entries[i].href[0] = '\0';
+    }
+  }
+
+  void addFootnote(const char* number, const char* href) {
+    if (count < 16 && number && href) {
+      strncpy(entries[count].number, number, 2);
+      entries[count].number[2] = '\0';
+      strncpy(entries[count].href, href, 63);
+      entries[count].href[63] = '\0';
+      count++;
+    }
+  }
+
+  void clear() {
+    count = 0;
+    for (int i = 0; i < 16; i++) {
+      entries[i].number[0] = '\0';
+      entries[i].href[0] = '\0';
+    }
+  }
+
+  int getCount() const { return count; }
+
+  const FootnoteEntry* getEntry(int index) const {
+    if (index >= 0 && index < count) {
+      return &entries[index];
+    }
+    return nullptr;
+  }
+};
--- a/src/activities/reader/TxtReaderActivity.cpp
+++ b/src/activities/reader/TxtReaderActivity.cpp
@ -60,7 +60,7 @@ void TxtReaderActivity::onEnter() {
  // Save current txt as last opened file and add to recent books
  APP_STATE.openEpubPath = txt->getPath();
  APP_STATE.saveToFile();
-  RECENT_BOOKS.addBook(txt->getPath());
+  RECENT_BOOKS.addBook(txt->getPath(), "", "");

  // Trigger first update
  updateRequired = true;
@ -256,7 +256,7 @@ void TxtReaderActivity::buildPageIndex() {
      // Fill progress bar
      const int fillWidth = (barWidth - 2) * progressPercent / 100;
      renderer.fillRect(barX + 1, barY + 1, fillWidth, barHeight - 2, true);
-      renderer.displayBuffer(EInkDisplay::FAST_REFRESH);
+      renderer.displayBuffer(HalDisplay::FAST_REFRESH);
    }

    // Yield to other tasks periodically
@ -484,7 +484,7 @@ void TxtReaderActivity::renderPage() {
  renderStatusBar(orientedMarginRight, orientedMarginBottom, orientedMarginLeft);

  if (pagesUntilFullRefresh <= 1) {
-    renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+    renderer.displayBuffer(HalDisplay::HALF_REFRESH);
    pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
  } else {
    renderer.displayBuffer();
--- a/src/activities/reader/XtcReaderActivity.cpp
+++ b/src/activities/reader/XtcReaderActivity.cpp
@ -45,7 +45,7 @@ void XtcReaderActivity::onEnter() {
  // Save current XTC as last opened book and add to recent books
  APP_STATE.openEpubPath = xtc->getPath();
  APP_STATE.saveToFile();
-  RECENT_BOOKS.addBook(xtc->getPath());
+  RECENT_BOOKS.addBook(xtc->getPath(), xtc->getTitle(), xtc->getAuthor());

  // Trigger first update
  updateRequired = true;
@ -276,7 +276,7 @@ void XtcReaderActivity::renderPage() {

    // Display BW with conditional refresh based on pagesUntilFullRefresh
    if (pagesUntilFullRefresh <= 1) {
-      renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+      renderer.displayBuffer(HalDisplay::HALF_REFRESH);
      pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
    } else {
      renderer.displayBuffer();
@ -356,7 +356,7 @@ void XtcReaderActivity::renderPage() {

  // Display with appropriate refresh
  if (pagesUntilFullRefresh <= 1) {
-    renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+    renderer.displayBuffer(HalDisplay::HALF_REFRESH);
    pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
  } else {
    renderer.displayBuffer();
--- a/src/activities/util/FullScreenMessageActivity.h
+++ b/src/activities/util/FullScreenMessageActivity.h
@ -1,6 +1,6 @@
 #pragma once
-#include <EInkDisplay.h>
 #include <EpdFontFamily.h>
+#include <HalDisplay.h>

 #include <string>
 #include <utility>
@ -10,12 +10,12 @@
 class FullScreenMessageActivity final : public Activity {
  std::string text;
  EpdFontFamily::Style style;
-  EInkDisplay::RefreshMode refreshMode;
+  HalDisplay::RefreshMode refreshMode;

 public:
  explicit FullScreenMessageActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::string text,
                                     const EpdFontFamily::Style style = EpdFontFamily::REGULAR,
-                                     const EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH)
+                                     const HalDisplay::RefreshMode refreshMode = HalDisplay::FAST_REFRESH)
      : Activity("FullScreenMessage", renderer, mappedInput),
        text(std::move(text)),
        style(style),
--- a/src/main.cpp
+++ b/src/main.cpp
@ -1,8 +1,8 @@
 #include <Arduino.h>
-#include <EInkDisplay.h>
 #include <Epub.h>
 #include <GfxRenderer.h>
-#include <InputManager.h>
+#include <HalDisplay.h>
+#include <HalGPIO.h>
 #include <SDCardManager.h>
 #include <SPI.h>
 #include <builtinFonts/all.h>
@ -26,23 +26,10 @@
 #include "activities/util/FullScreenMessageActivity.h"
 #include "fontIds.h"

-#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 UART0_RXD 20  // Used for USB connection detection
-
-#define SD_SPI_MISO 7
-
-EInkDisplay einkDisplay(EPD_SCLK, EPD_MOSI, EPD_CS, EPD_DC, EPD_RST, EPD_BUSY);
-InputManager inputManager;
-MappedInputManager mappedInputManager(inputManager);
-GfxRenderer renderer(einkDisplay);
+HalDisplay display;
+HalGPIO gpio;
+MappedInputManager mappedInputManager(gpio);
+GfxRenderer renderer(display);
 Activity* currentActivity;

 // Fonts
@ -170,21 +157,20 @@ void verifyPowerButtonDuration() {
  const uint16_t calibratedPressDuration =
      (calibration < SETTINGS.getPowerButtonDuration()) ? SETTINGS.getPowerButtonDuration() - calibration : 1;

-  inputManager.update();
-  // Verify the user has actually pressed
+  gpio.update();
  // Needed because inputManager.isPressed() may take up to ~500ms to return the correct state
-  while (!inputManager.isPressed(InputManager::BTN_POWER) && millis() - start < 1000) {
+  while (!gpio.isPressed(HalGPIO::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();
+    gpio.update();
  }

  t2 = millis();
-  if (inputManager.isPressed(InputManager::BTN_POWER)) {
+  if (gpio.isPressed(HalGPIO::BTN_POWER)) {
    do {
      delay(10);
-      inputManager.update();
-    } while (inputManager.isPressed(InputManager::BTN_POWER) && inputManager.getHeldTime() < calibratedPressDuration);
-    abort = inputManager.getHeldTime() < calibratedPressDuration;
+      gpio.update();
+    } while (gpio.isPressed(HalGPIO::BTN_POWER) && gpio.getHeldTime() < calibratedPressDuration);
+    abort = gpio.getHeldTime() < calibratedPressDuration;
  } else {
    abort = true;
  }
@ -192,16 +178,15 @@ void verifyPowerButtonDuration() {
  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_start();
+    gpio.startDeepSleep();
  }
 }

 void waitForPowerRelease() {
-  inputManager.update();
-  while (inputManager.isPressed(InputManager::BTN_POWER)) {
+  gpio.update();
+  while (gpio.isPressed(HalGPIO::BTN_POWER)) {
    delay(50);
-    inputManager.update();
+    gpio.update();
  }
 }

@ -210,14 +195,11 @@ void enterDeepSleep() {
  exitActivity();
  enterNewActivity(new SleepActivity(renderer, mappedInputManager));

-  einkDisplay.deepSleep();
+  display.deepSleep();
  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
-  waitForPowerRelease();
-  // Enter Deep Sleep
-  esp_deep_sleep_start();
+
+  gpio.startDeepSleep();
 }

 void onGoHome();
@ -261,7 +243,7 @@ void onGoHome() {
 }

 void setupDisplayAndFonts() {
-  einkDisplay.begin();
+  display.begin();
  Serial.printf("[%lu] [   ] Display initialized\n", millis());
  renderer.insertFont(BOOKERLY_14_FONT_ID, bookerly14FontFamily);
 #ifndef OMIT_FONTS
@ -284,27 +266,13 @@ void setupDisplayAndFonts() {
  Serial.printf("[%lu] [   ] Fonts setup\n", millis());
 }

-bool isUsbConnected() {
-  // U0RXD/GPIO20 reads HIGH when USB is connected
-  return digitalRead(UART0_RXD) == HIGH;
-}
-
-bool isWakeupByPowerButton() {
-  const auto wakeupCause = esp_sleep_get_wakeup_cause();
-  const auto resetReason = esp_reset_reason();
-  if (isUsbConnected()) {
-    return wakeupCause == ESP_SLEEP_WAKEUP_GPIO;
-  } else {
-    return (wakeupCause == ESP_SLEEP_WAKEUP_UNDEFINED) && (resetReason == ESP_RST_POWERON);
-  }
-}
-
 void setup() {
  t1 = millis();

+  gpio.begin();
+
  // Only start serial if USB connected
-  pinMode(UART0_RXD, INPUT);
-  if (isUsbConnected()) {
+  if (gpio.isUsbConnected()) {
    Serial.begin(115200);
    // Wait up to 3 seconds for Serial to be ready to catch early logs
    unsigned long start = millis();
@ -313,13 +281,6 @@ void setup() {
    }
  }

-  inputManager.begin();
-  // Initialize pins
-  pinMode(BAT_GPIO0, INPUT);
-
-  // Initialize SPI with custom pins
-  SPI.begin(EPD_SCLK, SD_SPI_MISO, EPD_MOSI, EPD_CS);
-
  // SD Card Initialization
  // We need 6 open files concurrently when parsing a new chapter
  if (!SdMan.begin()) {
@ -333,7 +294,7 @@ void setup() {
  SETTINGS.loadFromFile();
  KOREADER_STORE.loadFromFile();

-  if (isWakeupByPowerButton()) {
+  if (gpio.isWakeupByPowerButton()) {
    // For normal wakeups, verify power button press duration
    Serial.printf("[%lu] [   ] Verifying power button press duration\n", millis());
    verifyPowerButtonDuration();
@ -370,7 +331,7 @@ void loop() {
  const unsigned long loopStartTime = millis();
  static unsigned long lastMemPrint = 0;

-  inputManager.update();
+  gpio.update();

  if (Serial && millis() - lastMemPrint >= 10000) {
    Serial.printf("[%lu] [MEM] Free: %d bytes, Total: %d bytes, Min Free: %d bytes\n", millis(), ESP.getFreeHeap(),
@ -380,8 +341,7 @@ void loop() {

  // 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())) {
+  if (gpio.wasAnyPressed() || gpio.wasAnyReleased() || (currentActivity && currentActivity->preventAutoSleep())) {
    lastActivityTime = millis();  // Reset inactivity timer
  }

@ -393,8 +353,7 @@ void loop() {
    return;
  }

-  if (inputManager.isPressed(InputManager::BTN_POWER) &&
-      inputManager.getHeldTime() > SETTINGS.getPowerButtonDuration()) {
+  if (gpio.isPressed(HalGPIO::BTN_POWER) && gpio.getHeldTime() > SETTINGS.getPowerButtonDuration()) {
    enterDeepSleep();
    // This should never be hit as `enterDeepSleep` calls esp_deep_sleep_start
    return;
Author	SHA1	Message	Date
Uri Tauber	f9a4df695b	Merge `94411049c8` into `da4d3b5ea5`	2026-01-27 21:14:52 +00:00
Uri Tauber	94411049c8	Implemented tabbed display for Chapters/Footnotes.	2026-01-27 23:14:23 +02:00
Uri Tauber	fea56d385e	Merge remote-tracking branch 'origin/master' into feat/reader-toc-tabs	2026-01-27 21:48:48 +02:00
Xuan-Son Nguyen	da4d3b5ea5	feat: add HalDisplay and HalGPIO (#522 ) Some checks failed CI / build (push) Has been cancelled Details ## Summary Extracted some changes from https://github.com/crosspoint-reader/crosspoint-reader/pull/500 to make reviewing easier This PR adds HAL (Hardware Abstraction Layer) for display and GPIO components, making it easier to write a stub or an emulated implementation of the hardware. SD card HAL will be added via another PR, because it's a bit more tricky. --- ### AI Usage While CrossPoint doesn't have restrictions on AI tools in contributing, please be transparent about their usage as it helps set the right context for reviewers. Did you use AI tools to help write this code? NO	2026-01-28 04:50:15 +11:00
Uri Tauber	62f9a863c9	refactor: use static design for reader TOC to avoid memory fragmentation	2026-01-27 19:25:56 +02:00
Eliz	172916afd4	feat: Display epub metadata on Recents (#511 ) * What is the goal of this PR? Implement a metadata viewer for the Recents screen * What changes are included? \| Recents \| Files \| \| --- \| --- \| \| <img alt="image" src="https://github.com/user-attachments/assets/e0f2d816-ddce-4a2e-bd4a-cd431d0e6532" /> \| <img alt="image" src="https://github.com/user-attachments/assets/3225cdce-d501-4175-bc92-73cb8bfe7a41" /> \| For the Files screen, I have not made any changes on purpose. For the Recents screen, we now display the Book title and author. If it is a file with no epub metadata like txt or md, we display the file name without the file extension. --- Did you use AI tools to help write this code? _< YES >_ Although I went trough all the code manually and made changes as well, please be aware the majority of the code is AI generated. --------- Co-authored-by: Eliz Kilic <elizk@google.com>	2026-01-28 04:25:42 +11:00
Dave Allie	ebcd813ff6	chore: Cut release 0.16.0	2026-01-28 04:08:04 +11:00
Dave Allie	712c566664	fix: Correctly render italics on image alt placeholders (#569 ) ## Summary * Correctly render italics on image alt placeholders * Parser incorrectly handled depth of self-closing tags * Self-closing tags immediately call start and end tag ## Additional Context * Previously, it would incorrectly make the whole chapter bold/italics, or not italicised the image alt --- ### AI Usage While CrossPoint doesn't have restrictions on AI tools in contributing, please be transparent about their usage as it helps set the right context for reviewers. Did you use AI tools to help write this code? No	2026-01-28 03:33:36 +11:00
Boris Faure	5894ae5afe	chore: .gitignore: add compile_commands.json & .cache (#568 ) ## Summary * What is the goal of this PR? Quality of Life * What changes are included? Add compile_commands.json & .cache to .gitignore . Both are use by clangd that can help IDE support. Run `pio run --target compiledb` to generate `compile_commands.json`. --- ### AI Usage While CrossPoint doesn't have restrictions on AI tools in contributing, please be transparent about their usage as it helps set the right context for reviewers. Did you use AI tools to help write this code? _NO_	2026-01-28 03:32:33 +11:00
Uri Tauber	8bfc55d1dc	Fix stupid merge duplication I missed	2026-01-27 18:17:31 +02:00
Uri Tauber	1286fc15ec	feat: consolidate reader menu into tabbed TOC view	2026-01-27 17:58:02 +02:00