lib/Epub/Epub.cpp

@@ -148,18 +148,6 @@ bool Epub::load() {
     return false;
   }
 
-  // determine size of spine items
-  size_t spineItemsCount = getSpineItemsCount();
-  size_t spineItemsSize = 0;
-  for (size_t i = 0; i < spineItemsCount; i++) {
-    std::string spineItem = getSpineItem(i);
-    size_t s = 0;
-    getItemSize(spineItem, &s);
-    spineItemsSize += s;
-    cumulativeSpineItemSize.emplace_back(spineItemsSize);
-  }
-  Serial.printf("[%lu] [EBP] Book size: %u\n", millis(), spineItemsSize);
-
   Serial.printf("[%lu] [EBP] Loaded ePub: %s\n", millis(), filepath.c_str());
 
   return true;
@@ -267,8 +255,6 @@ bool Epub::getItemSize(const std::string& itemHref, size_t* size) const {
 
 int Epub::getSpineItemsCount() const { return spine.size(); }
 
-size_t Epub::getCumulativeSpineItemSize(const int spineIndex) const { return cumulativeSpineItemSize.at(spineIndex); }
-
 std::string& Epub::getSpineItem(const int spineIndex) {
   if (spineIndex < 0 || spineIndex >= spine.size()) {
     Serial.printf("[%lu] [EBP] getSpineItem index:%d is out of range\n", millis(), spineIndex);
@@ -316,14 +302,3 @@ int Epub::getTocIndexForSpineIndex(const int spineIndex) const {
   Serial.printf("[%lu] [EBP] TOC item not found\n", millis());
   return -1;
 }
-
-size_t Epub::getBookSize() const { return getCumulativeSpineItemSize(getSpineItemsCount() - 1); }
-
-// Calculate progress in book
-uint8_t Epub::calculateProgress(const int currentSpineIndex, const float currentSpineRead) {
-  size_t prevChapterSize = (currentSpineIndex >= 1) ? getCumulativeSpineItemSize(currentSpineIndex - 1) : 0;
-  size_t curChapterSize = getCumulativeSpineItemSize(currentSpineIndex) - prevChapterSize;
-  size_t bookSize = getBookSize();
-  size_t sectionProgSize = currentSpineRead * curChapterSize;
-  return round(static_cast<float>(prevChapterSize + sectionProgSize) / bookSize * 100.0);
-}

lib/Epub/Epub.h

@@ -20,8 +20,6 @@ class Epub {
   std::string filepath;
   // the spine of the EPUB file
   std::vector<std::pair<std::string, std::string>> spine;
-  // the file size of the spine items (proxy to book progress)
-  std::vector<size_t> cumulativeSpineItemSize;
   // the toc of the EPUB file
   std::vector<EpubTocEntry> toc;
   // the base path for items in the EPUB file
@@ -53,12 +51,8 @@ class Epub {
   bool getItemSize(const std::string& itemHref, size_t* size) const;
   std::string& getSpineItem(int spineIndex);
   int getSpineItemsCount() const;
-  size_t getCumulativeSpineItemSize(const int spineIndex) const;
+  EpubTocEntry& getTocItem(int tocTndex);
-  EpubTocEntry& getTocItem(int tocIndex);
   int getTocItemsCount() const;
   int getSpineIndexForTocIndex(int tocIndex) const;
   int getTocIndexForSpineIndex(int spineIndex) const;
-
-  size_t getBookSize() const;
-  uint8_t calculateProgress(const int currentSpineIndex, const float currentSpineRead);
 };

lib/Epub/Epub/Page.cpp

@@ -3,9 +3,7 @@
 #include <HardwareSerial.h>
 #include <Serialization.h>
 
-namespace {
 constexpr uint8_t PAGE_FILE_VERSION = 3;
-}
 
 void PageLine::render(GfxRenderer& renderer, const int fontId) { block->render(renderer, fontId, xPos, yPos); }
 

lib/Epub/Epub/Section.cpp

@@ -9,9 +9,7 @@
 #include "Page.h"
 #include "parsers/ChapterHtmlSlimParser.h"
 
-namespace {
 constexpr uint8_t SECTION_FILE_VERSION = 5;
-}
 
 void Section::onPageComplete(std::unique_ptr<Page> page) {
   const auto filePath = cachePath + "/page_" + std::to_string(pageCount) + ".bin";

src/CrossPointSettings.cpp

@@ -10,11 +10,9 @@
 // Initialize the static instance
 CrossPointSettings CrossPointSettings::instance;
 
-namespace {
 constexpr uint8_t SETTINGS_FILE_VERSION = 1;
 constexpr uint8_t SETTINGS_COUNT = 2;
 constexpr char SETTINGS_FILE[] = "/sd/.crosspoint/settings.bin";
-}  // namespace
 
 bool CrossPointSettings::saveToFile() const {
   // Make sure the directory exists

src/CrossPointState.cpp

@@ -6,12 +6,8 @@
 
 #include <fstream>
 
-namespace {
 constexpr uint8_t STATE_FILE_VERSION = 1;
 constexpr char STATE_FILE[] = "/sd/.crosspoint/state.bin";
-}  // namespace
-
-CrossPointState CrossPointState::instance;
 
 bool CrossPointState::saveToFile() const {
   std::ofstream outputFile(STATE_FILE);

src/CrossPointState.h

@@ -3,20 +3,11 @@
 #include <string>
 
 class CrossPointState {
-  // Static instance
-  static CrossPointState instance;
-
  public:
   std::string openEpubPath;
   ~CrossPointState() = default;
 
-  // Get singleton instance
-  static CrossPointState& getInstance() { return instance; }
-
   bool saveToFile() const;
 
   bool loadFromFile();
 };
-
-// Helper macro to access settings
-#define APP_STATE CrossPointState::getInstance()

src/activities/Activity.h

@@ -1,18 +0,0 @@
-#pragma once
-#include <InputManager.h>
-
-class GfxRenderer;
-
-class Activity {
- protected:
-  GfxRenderer& renderer;
-  InputManager& inputManager;
-
- public:
-  explicit Activity(GfxRenderer& renderer, InputManager& inputManager)
-      : renderer(renderer), inputManager(inputManager) {}
-  virtual ~Activity() = default;
-  virtual void onEnter() {}
-  virtual void onExit() {}
-  virtual void loop() {}
-};

src/activities/ActivityWithSubactivity.cpp

@@ -1,21 +0,0 @@
-#include "ActivityWithSubactivity.h"
-
-void ActivityWithSubactivity::exitActivity() {
-  if (subActivity) {
-    subActivity->onExit();
-    subActivity.reset();
-  }
-}
-
-void ActivityWithSubactivity::enterNewActivity(Activity* activity) {
-  subActivity.reset(activity);
-  subActivity->onEnter();
-}
-
-void ActivityWithSubactivity::loop() {
-  if (subActivity) {
-    subActivity->loop();
-  }
-}
-
-void ActivityWithSubactivity::onExit() { exitActivity(); }

src/activities/ActivityWithSubactivity.h

@@ -1,17 +0,0 @@
-#pragma once
-#include <memory>
-
-#include "Activity.h"
-
-class ActivityWithSubactivity : public Activity {
- protected:
-  std::unique_ptr<Activity> subActivity = nullptr;
-  void exitActivity();
-  void enterNewActivity(Activity* activity);
-
- public:
-  explicit ActivityWithSubactivity(GfxRenderer& renderer, InputManager& inputManager)
-      : Activity(renderer, inputManager) {}
-  void loop() override;
-  void onExit() override;
-};

src/activities/boot_sleep/BootActivity.h

@@ -1,8 +0,0 @@
-#pragma once
-#include "../Activity.h"
-
-class BootActivity final : public Activity {
- public:
-  explicit BootActivity(GfxRenderer& renderer, InputManager& inputManager) : Activity(renderer, inputManager) {}
-  void onEnter() override;
-};

src/activities/boot_sleep/SleepActivity.h

@@ -1,8 +0,0 @@
-#pragma once
-#include "../Activity.h"
-
-class SleepActivity final : public Activity {
- public:
-  explicit SleepActivity(GfxRenderer& renderer, InputManager& inputManager) : Activity(renderer, inputManager) {}
-  void onEnter() override;
-};

src/activities/home/HomeActivity.h

@@ -1,29 +0,0 @@
-#pragma once
-#include <freertos/FreeRTOS.h>
-#include <freertos/semphr.h>
-#include <freertos/task.h>
-
-#include <functional>
-
-#include "../Activity.h"
-
-class HomeActivity final : public Activity {
-  TaskHandle_t displayTaskHandle = nullptr;
-  SemaphoreHandle_t renderingMutex = nullptr;
-  int selectorIndex = 0;
-  bool updateRequired = false;
-  const std::function<void()> onReaderOpen;
-  const std::function<void()> onSettingsOpen;
-
-  static void taskTrampoline(void* param);
-  [[noreturn]] void displayTaskLoop();
-  void render() const;
-
- public:
-  explicit HomeActivity(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onReaderOpen,
-                        const std::function<void()>& onSettingsOpen)
-      : Activity(renderer, inputManager), onReaderOpen(onReaderOpen), onSettingsOpen(onSettingsOpen) {}
-  void onEnter() override;
-  void onExit() override;
-  void loop() override;
-};

src/activities/reader/ReaderActivity.cpp

@@ -1,68 +0,0 @@
-#include "ReaderActivity.h"
-
-#include <SD.h>
-
-#include "CrossPointState.h"
-#include "Epub.h"
-#include "EpubReaderActivity.h"
-#include "FileSelectionActivity.h"
-#include "activities/util/FullScreenMessageActivity.h"
-
-std::unique_ptr<Epub> ReaderActivity::loadEpub(const std::string& path) {
-  if (!SD.exists(path.c_str())) {
-    Serial.printf("[%lu] [   ] File does not exist: %s\n", millis(), path.c_str());
-    return nullptr;
-  }
-
-  auto epub = std::unique_ptr<Epub>(new Epub(path, "/.crosspoint"));
-  if (epub->load()) {
-    return epub;
-  }
-
-  Serial.printf("[%lu] [   ] Failed to load epub\n", millis());
-  return nullptr;
-}
-
-void ReaderActivity::onSelectEpubFile(const std::string& path) {
-  exitActivity();
-  enterNewActivity(new FullScreenMessageActivity(renderer, inputManager, "Loading..."));
-
-  auto epub = loadEpub(path);
-  if (epub) {
-    APP_STATE.openEpubPath = path;
-    APP_STATE.saveToFile();
-    onGoToEpubReader(std::move(epub));
-  } else {
-    exitActivity();
-    enterNewActivity(new FullScreenMessageActivity(renderer, inputManager, "Failed to load epub", REGULAR,
-                                                   EInkDisplay::HALF_REFRESH));
-    delay(2000);
-    onGoToFileSelection();
-  }
-}
-
-void ReaderActivity::onGoToFileSelection() {
-  exitActivity();
-  enterNewActivity(new FileSelectionActivity(
-      renderer, inputManager, [this](const std::string& path) { onSelectEpubFile(path); }, onGoBack));
-}
-
-void ReaderActivity::onGoToEpubReader(std::unique_ptr<Epub> epub) {
-  exitActivity();
-  enterNewActivity(new EpubReaderActivity(renderer, inputManager, std::move(epub), [this] { onGoToFileSelection(); }));
-}
-
-void ReaderActivity::onEnter() {
-  if (initialEpubPath.empty()) {
-    onGoToFileSelection();
-    return;
-  }
-
-  auto epub = loadEpub(initialEpubPath);
-  if (!epub) {
-    onGoBack();
-    return;
-  }
-
-  onGoToEpubReader(std::move(epub));
-}

src/activities/reader/ReaderActivity.h

@@ -1,24 +0,0 @@
-#pragma once
-#include <memory>
-
-#include "../ActivityWithSubactivity.h"
-
-class Epub;
-
-class ReaderActivity final : public ActivityWithSubactivity {
-  std::string initialEpubPath;
-  const std::function<void()> onGoBack;
-  static std::unique_ptr<Epub> loadEpub(const std::string& path);
-
-  void onSelectEpubFile(const std::string& path);
-  void onGoToFileSelection();
-  void onGoToEpubReader(std::unique_ptr<Epub> epub);
-
- public:
-  explicit ReaderActivity(GfxRenderer& renderer, InputManager& inputManager, std::string initialEpubPath,
-                          const std::function<void()>& onGoBack)
-      : ActivityWithSubactivity(renderer, inputManager),
-        initialEpubPath(std::move(initialEpubPath)),
-        onGoBack(onGoBack) {}
-  void onEnter() override;
-};

src/activities/util/FullScreenMessageActivity.h

@@ -1,21 +0,0 @@
-#pragma once
-#include <EInkDisplay.h>
-#include <EpdFontFamily.h>
-
-#include <string>
-#include <utility>
-
-#include "../Activity.h"
-
-class FullScreenMessageActivity final : public Activity {
-  std::string text;
-  EpdFontStyle style;
-  EInkDisplay::RefreshMode refreshMode;
-
- public:
-  explicit FullScreenMessageActivity(GfxRenderer& renderer, InputManager& inputManager, std::string text,
-                                     const EpdFontStyle style = REGULAR,
-                                     const EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH)
-      : Activity(renderer, inputManager), text(std::move(text)), style(style), refreshMode(refreshMode) {}
-  void onEnter() override;
-};

src/main.cpp

@@ -16,13 +16,14 @@
 #include "Battery.h"
 #include "CrossPointSettings.h"
 #include "CrossPointState.h"
-#include "activities/boot_sleep/BootActivity.h"
-#include "activities/boot_sleep/SleepActivity.h"
-#include "activities/home/HomeActivity.h"
-#include "activities/reader/ReaderActivity.h"
-#include "activities/settings/SettingsActivity.h"
-#include "activities/util/FullScreenMessageActivity.h"
 #include "config.h"
+#include "screens/BootLogoScreen.h"
+#include "screens/EpubReaderScreen.h"
+#include "screens/FileSelectionScreen.h"
+#include "screens/FullScreenMessageScreen.h"
+#include "screens/HomeScreen.h"
+#include "screens/SettingsScreen.h"
+#include "screens/SleepScreen.h"
 
 #define SPI_FQ 40000000
 // Display SPI pins (custom pins for XteinkX4, not hardware SPI defaults)
@@ -41,7 +42,8 @@
 EInkDisplay einkDisplay(EPD_SCLK, EPD_MOSI, EPD_CS, EPD_DC, EPD_RST, EPD_BUSY);
 InputManager inputManager;
 GfxRenderer renderer(einkDisplay);
-Activity* currentActivity;
+Screen* currentScreen;
+CrossPointState appState;
 
 // Fonts
 EpdFont bookerlyFont(&bookerly_2b);
@@ -65,16 +67,31 @@ constexpr unsigned long POWER_BUTTON_SLEEP_MS = 500;
 // Auto-sleep timeout (10 minutes of inactivity)
 constexpr unsigned long AUTO_SLEEP_TIMEOUT_MS = 10 * 60 * 1000;
 
-void exitActivity() {
+std::unique_ptr<Epub> loadEpub(const std::string& path) {
-  if (currentActivity) {
+  if (!SD.exists(path.c_str())) {
-    currentActivity->onExit();
+    Serial.printf("[%lu] [   ] File does not exist: %s\n", millis(), path.c_str());
-    delete currentActivity;
+    return nullptr;
+  }
+
+  auto epub = std::unique_ptr<Epub>(new Epub(path, "/.crosspoint"));
+  if (epub->load()) {
+    return epub;
+  }
+
+  Serial.printf("[%lu] [   ] Failed to load epub\n", millis());
+  return nullptr;
+}
+
+void exitScreen() {
+  if (currentScreen) {
+    currentScreen->onExit();
+    delete currentScreen;
   }
 }
 
-void enterNewActivity(Activity* activity) {
+void enterNewScreen(Screen* screen) {
-  currentActivity = activity;
+  currentScreen = screen;
-  currentActivity->onEnter();
+  currentScreen->onEnter();
 }
 
 // Verify long press on wake-up from deep sleep
@@ -118,8 +135,8 @@ void waitForPowerRelease() {
 
 // Enter deep sleep mode
 void enterDeepSleep() {
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new SleepActivity(renderer, inputManager));
+  enterNewScreen(new SleepScreen(renderer, inputManager));
 
   Serial.printf("[%lu] [   ] Power button released after a long press. Entering deep sleep.\n", millis());
   delay(1000);  // Allow Serial buffer to empty and display to update
@@ -134,20 +151,39 @@ void enterDeepSleep() {
 }
 
 void onGoHome();
-void onGoToReader(const std::string& initialEpubPath) {
+void onGoToFileSelection();
-  exitActivity();
+void onSelectEpubFile(const std::string& path) {
-  enterNewActivity(new ReaderActivity(renderer, inputManager, initialEpubPath, onGoHome));
+  exitScreen();
+  enterNewScreen(new FullScreenMessageScreen(renderer, inputManager, "Loading..."));
+
+  auto epub = loadEpub(path);
+  if (epub) {
+    appState.openEpubPath = path;
+    appState.saveToFile();
+    exitScreen();
+    enterNewScreen(new EpubReaderScreen(renderer, inputManager, std::move(epub), onGoToFileSelection));
+  } else {
+    exitScreen();
+    enterNewScreen(
+        new FullScreenMessageScreen(renderer, inputManager, "Failed to load epub", REGULAR, EInkDisplay::HALF_REFRESH));
+    delay(2000);
+    onGoToFileSelection();
+  }
+}
+
+void onGoToFileSelection() {
+  exitScreen();
+  enterNewScreen(new FileSelectionScreen(renderer, inputManager, onSelectEpubFile, onGoHome));
 }
-void onGoToReaderHome() { onGoToReader(std::string()); }
 
 void onGoToSettings() {
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new SettingsActivity(renderer, inputManager, onGoHome));
+  enterNewScreen(new SettingsScreen(renderer, inputManager, onGoHome));
 }
 
 void onGoHome() {
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new HomeActivity(renderer, inputManager, onGoToReaderHome, onGoToSettings));
+  enterNewScreen(new HomeScreen(renderer, inputManager, onGoToFileSelection, onGoToSettings));
 }
 
 void setup() {
@@ -173,20 +209,27 @@ void setup() {
   renderer.insertFont(SMALL_FONT_ID, smallFontFamily);
   Serial.printf("[%lu] [   ] Fonts setup\n", millis());
 
-  exitActivity();
+  exitScreen();
-  enterNewActivity(new BootActivity(renderer, inputManager));
+  enterNewScreen(new BootLogoScreen(renderer, inputManager));
 
   // SD Card Initialization
   SD.begin(SD_SPI_CS, SPI, SPI_FQ);
 
   SETTINGS.loadFromFile();
-  APP_STATE.loadFromFile();
+  appState.loadFromFile();
-  if (APP_STATE.openEpubPath.empty()) {
+  if (!appState.openEpubPath.empty()) {
-    onGoHome();
+    auto epub = loadEpub(appState.openEpubPath);
-  } else {
+    if (epub) {
-    onGoToReader(APP_STATE.openEpubPath);
+      exitScreen();
+      enterNewScreen(new EpubReaderScreen(renderer, inputManager, std::move(epub), onGoHome));
+      // Ensure we're not still holding the power button before leaving setup
+      waitForPowerRelease();
+      return;
+    }
   }
 
+  onGoHome();
+
   // Ensure we're not still holding the power button before leaving setup
   waitForPowerRelease();
 }
@@ -222,7 +265,7 @@ void loop() {
     return;
   }
 
-  if (currentActivity) {
+  if (currentScreen) {
-    currentActivity->loop();
+    currentScreen->handleInput();
   }
 }

src/screens/BootLogoScreen.cpp

@@ -1,11 +1,11 @@
-#include "BootActivity.h"
+#include "BootLogoScreen.h"
 
 #include <GfxRenderer.h>
 
 #include "config.h"
 #include "images/CrossLarge.h"
 
-void BootActivity::onEnter() {
+void BootLogoScreen::onEnter() {
   const auto pageWidth = GfxRenderer::getScreenWidth();
   const auto pageHeight = GfxRenderer::getScreenHeight();
 

src/screens/BootLogoScreen.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "Screen.h"
+
+class BootLogoScreen final : public Screen {
+ public:
+  explicit BootLogoScreen(GfxRenderer& renderer, InputManager& inputManager) : Screen(renderer, inputManager) {}
+  void onEnter() override;
+};

src/screens/EpubReaderChapterSelectionScreen.cpp

@@ -1,4 +1,4 @@
-#include "EpubReaderChapterSelectionActivity.h"
+#include "EpubReaderChapterSelectionScreen.h"
 
 #include <GfxRenderer.h>
 #include <SD.h>
@@ -8,12 +8,12 @@
 constexpr int PAGE_ITEMS = 24;
 constexpr int SKIP_PAGE_MS = 700;
 
-void EpubReaderChapterSelectionActivity::taskTrampoline(void* param) {
+void EpubReaderChapterSelectionScreen::taskTrampoline(void* param) {
-  auto* self = static_cast<EpubReaderChapterSelectionActivity*>(param);
+  auto* self = static_cast<EpubReaderChapterSelectionScreen*>(param);
   self->displayTaskLoop();
 }
 
-void EpubReaderChapterSelectionActivity::onEnter() {
+void EpubReaderChapterSelectionScreen::onEnter() {
   if (!epub) {
     return;
   }
@@ -23,7 +23,7 @@ void EpubReaderChapterSelectionActivity::onEnter() {
 
   // Trigger first update
   updateRequired = true;
-  xTaskCreate(&EpubReaderChapterSelectionActivity::taskTrampoline, "EpubReaderChapterSelectionActivityTask",
+  xTaskCreate(&EpubReaderChapterSelectionScreen::taskTrampoline, "EpubReaderChapterSelectionScreenTask",
               2048,               // Stack size
               this,               // Parameters
               1,                  // Priority
@@ -31,7 +31,7 @@ void EpubReaderChapterSelectionActivity::onEnter() {
   );
 }
 
-void EpubReaderChapterSelectionActivity::onExit() {
+void EpubReaderChapterSelectionScreen::onExit() {
   // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
   if (displayTaskHandle) {
@@ -42,7 +42,7 @@ void EpubReaderChapterSelectionActivity::onExit() {
   renderingMutex = nullptr;
 }
 
-void EpubReaderChapterSelectionActivity::loop() {
+void EpubReaderChapterSelectionScreen::handleInput() {
   const bool prevReleased =
       inputManager.wasReleased(InputManager::BTN_UP) || inputManager.wasReleased(InputManager::BTN_LEFT);
   const bool nextReleased =
@@ -72,7 +72,7 @@ void EpubReaderChapterSelectionActivity::loop() {
   }
 }
 
-void EpubReaderChapterSelectionActivity::displayTaskLoop() {
+void EpubReaderChapterSelectionScreen::displayTaskLoop() {
   while (true) {
     if (updateRequired) {
       updateRequired = false;
@@ -84,7 +84,7 @@ void EpubReaderChapterSelectionActivity::displayTaskLoop() {
   }
 }
 
-void EpubReaderChapterSelectionActivity::renderScreen() {
+void EpubReaderChapterSelectionScreen::renderScreen() {
   renderer.clearScreen();
 
   const auto pageWidth = renderer.getScreenWidth();

src/screens/EpubReaderChapterSelectionScreen.h

@@ -6,9 +6,9 @@
 
 #include <memory>
 
-#include "../Activity.h"
+#include "Screen.h"
 
-class EpubReaderChapterSelectionActivity final : public Activity {
+class EpubReaderChapterSelectionScreen final : public Screen {
   std::shared_ptr<Epub> epub;
   TaskHandle_t displayTaskHandle = nullptr;
   SemaphoreHandle_t renderingMutex = nullptr;
@@ -23,16 +23,16 @@ class EpubReaderChapterSelectionActivity final : public Activity {
   void renderScreen();
 
  public:
-  explicit EpubReaderChapterSelectionActivity(GfxRenderer& renderer, InputManager& inputManager,
+  explicit EpubReaderChapterSelectionScreen(GfxRenderer& renderer, InputManager& inputManager,
-                                              const std::shared_ptr<Epub>& epub, const int currentSpineIndex,
+                                            const std::shared_ptr<Epub>& epub, const int currentSpineIndex,
-                                              const std::function<void()>& onGoBack,
+                                            const std::function<void()>& onGoBack,
-                                              const std::function<void(int newSpineIndex)>& onSelectSpineIndex)
+                                            const std::function<void(int newSpineIndex)>& onSelectSpineIndex)
-      : Activity(renderer, inputManager),
+      : Screen(renderer, inputManager),
         epub(epub),
         currentSpineIndex(currentSpineIndex),
         onGoBack(onGoBack),
         onSelectSpineIndex(onSelectSpineIndex) {}
   void onEnter() override;
   void onExit() override;
-  void loop() override;
+  void handleInput() override;
 };

src/screens/EpubReaderScreen.cpp

@@ -1,4 +1,4 @@
-#include "EpubReaderActivity.h"
+#include "EpubReaderScreen.h"
 
 #include <Epub/Page.h>
 #include <GfxRenderer.h>
@@ -6,25 +6,23 @@
 
 #include "Battery.h"
 #include "CrossPointSettings.h"
-#include "EpubReaderChapterSelectionActivity.h"
+#include "EpubReaderChapterSelectionScreen.h"
 #include "config.h"
 
-namespace {
+constexpr int PAGES_PER_REFRESH = 15;
-constexpr int pagesPerRefresh = 15;
+constexpr unsigned long SKIP_CHAPTER_MS = 700;
-constexpr unsigned long skipChapterMs = 700;
 constexpr float lineCompression = 0.95f;
 constexpr int marginTop = 8;
 constexpr int marginRight = 10;
 constexpr int marginBottom = 22;
 constexpr int marginLeft = 10;
-}  // namespace
 
-void EpubReaderActivity::taskTrampoline(void* param) {
+void EpubReaderScreen::taskTrampoline(void* param) {
-  auto* self = static_cast<EpubReaderActivity*>(param);
+  auto* self = static_cast<EpubReaderScreen*>(param);
   self->displayTaskLoop();
 }
 
-void EpubReaderActivity::onEnter() {
+void EpubReaderScreen::onEnter() {
   if (!epub) {
     return;
   }
@@ -46,7 +44,7 @@ void EpubReaderActivity::onEnter() {
   // Trigger first update
   updateRequired = true;
 
-  xTaskCreate(&EpubReaderActivity::taskTrampoline, "EpubReaderActivityTask",
+  xTaskCreate(&EpubReaderScreen::taskTrampoline, "EpubReaderScreenTask",
               8192,               // Stack size
               this,               // Parameters
               1,                  // Priority
@@ -54,7 +52,7 @@ void EpubReaderActivity::onEnter() {
   );
 }
 
-void EpubReaderActivity::onExit() {
+void EpubReaderScreen::onExit() {
   // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
   if (displayTaskHandle) {
@@ -67,22 +65,22 @@ void EpubReaderActivity::onExit() {
   epub.reset();
 }
 
-void EpubReaderActivity::loop() {
+void EpubReaderScreen::handleInput() {
-  // Pass input responsibility to sub activity if exists
+  // Pass input responsibility to sub screen if exists
-  if (subAcitivity) {
+  if (subScreen) {
-    subAcitivity->loop();
+    subScreen->handleInput();
     return;
   }
 
-  // Enter chapter selection activity
+  // Enter chapter selection screen
   if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
-    // Don't start activity transition while rendering
+    // Don't start screen transition while rendering
     xSemaphoreTake(renderingMutex, portMAX_DELAY);
-    subAcitivity.reset(new EpubReaderChapterSelectionActivity(
+    subScreen.reset(new EpubReaderChapterSelectionScreen(
         this->renderer, this->inputManager, epub, currentSpineIndex,
         [this] {
-          subAcitivity->onExit();
+          subScreen->onExit();
-          subAcitivity.reset();
+          subScreen.reset();
           updateRequired = true;
         },
         [this](const int newSpineIndex) {
@@ -91,11 +89,11 @@ void EpubReaderActivity::loop() {
             nextPageNumber = 0;
             section.reset();
           }
-          subAcitivity->onExit();
+          subScreen->onExit();
-          subAcitivity.reset();
+          subScreen.reset();
           updateRequired = true;
         }));
-    subAcitivity->onEnter();
+    subScreen->onEnter();
     xSemaphoreGive(renderingMutex);
   }
 
@@ -121,7 +119,7 @@ void EpubReaderActivity::loop() {
     return;
   }
 
-  const bool skipChapter = inputManager.getHeldTime() > skipChapterMs;
+  const bool skipChapter = inputManager.getHeldTime() > SKIP_CHAPTER_MS;
 
   if (skipChapter) {
     // We don't want to delete the section mid-render, so grab the semaphore
@@ -167,7 +165,7 @@ void EpubReaderActivity::loop() {
   }
 }
 
-void EpubReaderActivity::displayTaskLoop() {
+void EpubReaderScreen::displayTaskLoop() {
   while (true) {
     if (updateRequired) {
       updateRequired = false;
@@ -180,7 +178,7 @@ void EpubReaderActivity::displayTaskLoop() {
 }
 
 // TODO: Failure handling
-void EpubReaderActivity::renderScreen() {
+void EpubReaderScreen::renderScreen() {
   if (!epub) {
     return;
   }
@@ -287,12 +285,12 @@ void EpubReaderActivity::renderScreen() {
   f.close();
 }
 
-void EpubReaderActivity::renderContents(std::unique_ptr<Page> page) {
+void EpubReaderScreen::renderContents(std::unique_ptr<Page> page) {
   page->render(renderer, READER_FONT_ID);
   renderStatusBar();
   if (pagesUntilFullRefresh <= 1) {
     renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
-    pagesUntilFullRefresh = pagesPerRefresh;
+    pagesUntilFullRefresh = PAGES_PER_REFRESH;
   } else {
     renderer.displayBuffer();
     pagesUntilFullRefresh--;
@@ -324,16 +322,10 @@ void EpubReaderActivity::renderContents(std::unique_ptr<Page> page) {
   renderer.restoreBwBuffer();
 }
 
-void EpubReaderActivity::renderStatusBar() const {
+void EpubReaderScreen::renderStatusBar() const {
   constexpr auto textY = 776;
-
-  // Calculate progress in book
-  float sectionChapterProg = static_cast<float>(section->currentPage) / section->pageCount;
-  uint8_t bookProgress = epub->calculateProgress(currentSpineIndex, sectionChapterProg);
-
   // Right aligned text for progress counter
-  const std::string progress = std::to_string(section->currentPage + 1) + "/" + std::to_string(section->pageCount) +
+  const std::string progress = std::to_string(section->currentPage + 1) + " / " + std::to_string(section->pageCount);
-                               "  " + std::to_string(bookProgress) + "%";
   const auto progressTextWidth = renderer.getTextWidth(SMALL_FONT_ID, progress.c_str());
   renderer.drawText(SMALL_FONT_ID, GfxRenderer::getScreenWidth() - marginRight - progressTextWidth, textY,
                     progress.c_str());

src/screens/EpubReaderScreen.h

@@ -5,14 +5,14 @@
 #include <freertos/semphr.h>
 #include <freertos/task.h>
 
-#include "../Activity.h"
+#include "Screen.h"
 
-class EpubReaderActivity final : public Activity {
+class EpubReaderScreen final : public Screen {
   std::shared_ptr<Epub> epub;
   std::unique_ptr<Section> section = nullptr;
   TaskHandle_t displayTaskHandle = nullptr;
   SemaphoreHandle_t renderingMutex = nullptr;
-  std::unique_ptr<Activity> subAcitivity = nullptr;
+  std::unique_ptr<Screen> subScreen = nullptr;
   int currentSpineIndex = 0;
   int nextPageNumber = 0;
   int pagesUntilFullRefresh = 0;
@@ -26,10 +26,10 @@ class EpubReaderActivity final : public Activity {
   void renderStatusBar() const;
 
  public:
-  explicit EpubReaderActivity(GfxRenderer& renderer, InputManager& inputManager, std::unique_ptr<Epub> epub,
+  explicit EpubReaderScreen(GfxRenderer& renderer, InputManager& inputManager, std::unique_ptr<Epub> epub,
-                              const std::function<void()>& onGoBack)
+                            const std::function<void()>& onGoBack)
-      : Activity(renderer, inputManager), epub(std::move(epub)), onGoBack(onGoBack) {}
+      : Screen(renderer, inputManager), epub(std::move(epub)), onGoBack(onGoBack) {}
   void onEnter() override;
   void onExit() override;
-  void loop() override;
+  void handleInput() override;
 };

src/screens/FileSelectionScreen.cpp

@@ -1,4 +1,4 @@
-#include "FileSelectionActivity.h"
+#include "FileSelectionScreen.h"
 
 #include <GfxRenderer.h>
 #include <SD.h>
@@ -15,12 +15,12 @@ void sortFileList(std::vector<std::string>& strs) {
   });
 }
 
-void FileSelectionActivity::taskTrampoline(void* param) {
+void FileSelectionScreen::taskTrampoline(void* param) {
-  auto* self = static_cast<FileSelectionActivity*>(param);
+  auto* self = static_cast<FileSelectionScreen*>(param);
   self->displayTaskLoop();
 }
 
-void FileSelectionActivity::loadFiles() {
+void FileSelectionScreen::loadFiles() {
   files.clear();
   selectorIndex = 0;
   auto root = SD.open(basepath.c_str());
@@ -42,7 +42,7 @@ void FileSelectionActivity::loadFiles() {
   sortFileList(files);
 }
 
-void FileSelectionActivity::onEnter() {
+void FileSelectionScreen::onEnter() {
   renderingMutex = xSemaphoreCreateMutex();
 
   basepath = "/";
@@ -52,7 +52,7 @@ void FileSelectionActivity::onEnter() {
   // Trigger first update
   updateRequired = true;
 
-  xTaskCreate(&FileSelectionActivity::taskTrampoline, "FileSelectionActivityTask",
+  xTaskCreate(&FileSelectionScreen::taskTrampoline, "FileSelectionScreenTask",
               2048,               // Stack size
               this,               // Parameters
               1,                  // Priority
@@ -60,7 +60,7 @@ void FileSelectionActivity::onEnter() {
   );
 }
 
-void FileSelectionActivity::onExit() {
+void FileSelectionScreen::onExit() {
   // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
   if (displayTaskHandle) {
@@ -72,7 +72,7 @@ void FileSelectionActivity::onExit() {
   files.clear();
 }
 
-void FileSelectionActivity::loop() {
+void FileSelectionScreen::handleInput() {
   const bool prevPressed =
       inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT);
   const bool nextPressed =
@@ -110,7 +110,7 @@ void FileSelectionActivity::loop() {
   }
 }
 
-void FileSelectionActivity::displayTaskLoop() {
+void FileSelectionScreen::displayTaskLoop() {
   while (true) {
     if (updateRequired) {
       updateRequired = false;
@@ -122,7 +122,7 @@ void FileSelectionActivity::displayTaskLoop() {
   }
 }
 
-void FileSelectionActivity::render() const {
+void FileSelectionScreen::render() const {
   renderer.clearScreen();
 
   const auto pageWidth = GfxRenderer::getScreenWidth();

src/screens/FileSelectionScreen.h

@@ -7,9 +7,9 @@
 #include <string>
 #include <vector>
 
-#include "../Activity.h"
+#include "Screen.h"
 
-class FileSelectionActivity final : public Activity {
+class FileSelectionScreen final : public Screen {
   TaskHandle_t displayTaskHandle = nullptr;
   SemaphoreHandle_t renderingMutex = nullptr;
   std::string basepath = "/";
@@ -25,11 +25,11 @@ class FileSelectionActivity final : public Activity {
   void loadFiles();
 
  public:
-  explicit FileSelectionActivity(GfxRenderer& renderer, InputManager& inputManager,
+  explicit FileSelectionScreen(GfxRenderer& renderer, InputManager& inputManager,
-                                 const std::function<void(const std::string&)>& onSelect,
+                               const std::function<void(const std::string&)>& onSelect,
-                                 const std::function<void()>& onGoHome)
+                               const std::function<void()>& onGoHome)
-      : Activity(renderer, inputManager), onSelect(onSelect), onGoHome(onGoHome) {}
+      : Screen(renderer, inputManager), onSelect(onSelect), onGoHome(onGoHome) {}
   void onEnter() override;
   void onExit() override;
-  void loop() override;
+  void handleInput() override;
 };

src/screens/FullScreenMessageScreen.cpp

@@ -1,10 +1,10 @@
-#include "FullScreenMessageActivity.h"
+#include "FullScreenMessageScreen.h"
 
 #include <GfxRenderer.h>
 
 #include "config.h"
 
-void FullScreenMessageActivity::onEnter() {
+void FullScreenMessageScreen::onEnter() {
   const auto height = renderer.getLineHeight(UI_FONT_ID);
   const auto top = (GfxRenderer::getScreenHeight() - height) / 2;
 

src/screens/FullScreenMessageScreen.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <EInkDisplay.h>
+#include <EpdFontFamily.h>
+
+#include <string>
+#include <utility>
+
+#include "Screen.h"
+
+class FullScreenMessageScreen final : public Screen {
+  std::string text;
+  EpdFontStyle style;
+  EInkDisplay::RefreshMode refreshMode;
+
+ public:
+  explicit FullScreenMessageScreen(GfxRenderer& renderer, InputManager& inputManager, std::string text,
+                                   const EpdFontStyle style = REGULAR,
+                                   const EInkDisplay::RefreshMode refreshMode = EInkDisplay::FAST_REFRESH)
+      : Screen(renderer, inputManager), text(std::move(text)), style(style), refreshMode(refreshMode) {}
+  void onEnter() override;
+};

src/screens/HomeScreen.cpp

@@ -1,20 +1,16 @@
-#include "HomeActivity.h"
+#include "HomeScreen.h"
 
 #include <GfxRenderer.h>
 #include <SD.h>
 
 #include "config.h"
 
-namespace {
+void HomeScreen::taskTrampoline(void* param) {
-constexpr int menuItemCount = 2;
+  auto* self = static_cast<HomeScreen*>(param);
-}
-
-void HomeActivity::taskTrampoline(void* param) {
-  auto* self = static_cast<HomeActivity*>(param);
   self->displayTaskLoop();
 }
 
-void HomeActivity::onEnter() {
+void HomeScreen::onEnter() {
   renderingMutex = xSemaphoreCreateMutex();
 
   selectorIndex = 0;
@@ -22,7 +18,7 @@ void HomeActivity::onEnter() {
   // Trigger first update
   updateRequired = true;
 
-  xTaskCreate(&HomeActivity::taskTrampoline, "HomeActivityTask",
+  xTaskCreate(&HomeScreen::taskTrampoline, "HomeScreenTask",
               2048,               // Stack size
               this,               // Parameters
               1,                  // Priority
@@ -30,7 +26,7 @@ void HomeActivity::onEnter() {
   );
 }
 
-void HomeActivity::onExit() {
+void HomeScreen::onExit() {
   // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
   if (displayTaskHandle) {
@@ -41,7 +37,7 @@ void HomeActivity::onExit() {
   renderingMutex = nullptr;
 }
 
-void HomeActivity::loop() {
+void HomeScreen::handleInput() {
   const bool prevPressed =
       inputManager.wasPressed(InputManager::BTN_UP) || inputManager.wasPressed(InputManager::BTN_LEFT);
   const bool nextPressed =
@@ -49,7 +45,7 @@ void HomeActivity::loop() {
 
   if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
     if (selectorIndex == 0) {
-      onReaderOpen();
+      onFileSelectionOpen();
     } else if (selectorIndex == 1) {
       onSettingsOpen();
     }
@@ -62,7 +58,7 @@ void HomeActivity::loop() {
   }
 }
 
-void HomeActivity::displayTaskLoop() {
+void HomeScreen::displayTaskLoop() {
   while (true) {
     if (updateRequired) {
       updateRequired = false;
@@ -74,7 +70,7 @@ void HomeActivity::displayTaskLoop() {
   }
 }
 
-void HomeActivity::render() const {
+void HomeScreen::render() const {
   renderer.clearScreen();
 
   const auto pageWidth = GfxRenderer::getScreenWidth();

src/screens/HomeScreen.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+
+#include "Screen.h"
+
+class HomeScreen final : public Screen {
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  int selectorIndex = 0;
+  bool updateRequired = false;
+  const std::function<void()> onFileSelectionOpen;
+  const std::function<void()> onSettingsOpen;
+
+  static constexpr int menuItemCount = 2;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render() const;
+
+ public:
+  explicit HomeScreen(GfxRenderer& renderer, InputManager& inputManager,
+                      const std::function<void()>& onFileSelectionOpen, const std::function<void()>& onSettingsOpen)
+      : Screen(renderer, inputManager), onFileSelectionOpen(onFileSelectionOpen), onSettingsOpen(onSettingsOpen) {}
+  void onEnter() override;
+  void onExit() override;
+  void handleInput() override;
+};

src/screens/Screen.h

@@ -0,0 +1,17 @@
+#pragma once
+#include <InputManager.h>
+
+class GfxRenderer;
+
+class Screen {
+ protected:
+  GfxRenderer& renderer;
+  InputManager& inputManager;
+
+ public:
+  explicit Screen(GfxRenderer& renderer, InputManager& inputManager) : renderer(renderer), inputManager(inputManager) {}
+  virtual ~Screen() = default;
+  virtual void onEnter() {}
+  virtual void onExit() {}
+  virtual void handleInput() {}
+};

src/screens/SettingsScreen.cpp

@@ -1,4 +1,4 @@
-#include "SettingsActivity.h"
+#include "SettingsScreen.h"
 
 #include <GfxRenderer.h>
 
@@ -7,16 +7,16 @@
 
 // Define the static settings list
 
-const SettingInfo SettingsActivity::settingsList[settingsCount] = {
+const SettingInfo SettingsScreen::settingsList[SettingsScreen::settingsCount] = {
     {"White Sleep Screen", &CrossPointSettings::whiteSleepScreen},
     {"Extra Paragraph Spacing", &CrossPointSettings::extraParagraphSpacing}};
 
-void SettingsActivity::taskTrampoline(void* param) {
+void SettingsScreen::taskTrampoline(void* param) {
-  auto* self = static_cast<SettingsActivity*>(param);
+  auto* self = static_cast<SettingsScreen*>(param);
   self->displayTaskLoop();
 }
 
-void SettingsActivity::onEnter() {
+void SettingsScreen::onEnter() {
   renderingMutex = xSemaphoreCreateMutex();
 
   // Reset selection to first item
@@ -25,7 +25,7 @@ void SettingsActivity::onEnter() {
   // Trigger first update
   updateRequired = true;
 
-  xTaskCreate(&SettingsActivity::taskTrampoline, "SettingsActivityTask",
+  xTaskCreate(&SettingsScreen::taskTrampoline, "SettingsScreenTask",
               2048,               // Stack size
               this,               // Parameters
               1,                  // Priority
@@ -33,7 +33,7 @@ void SettingsActivity::onEnter() {
   );
 }
 
-void SettingsActivity::onExit() {
+void SettingsScreen::onExit() {
   // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
   if (displayTaskHandle) {
@@ -44,7 +44,7 @@ void SettingsActivity::onExit() {
   renderingMutex = nullptr;
 }
 
-void SettingsActivity::loop() {
+void SettingsScreen::handleInput() {
   // Handle actions with early return
   if (inputManager.wasPressed(InputManager::BTN_CONFIRM)) {
     toggleCurrentSetting();
@@ -70,7 +70,7 @@ void SettingsActivity::loop() {
   }
 }
 
-void SettingsActivity::toggleCurrentSetting() {
+void SettingsScreen::toggleCurrentSetting() {
   // Validate index
   if (selectedSettingIndex < 0 || selectedSettingIndex >= settingsCount) {
     return;
@@ -84,7 +84,7 @@ void SettingsActivity::toggleCurrentSetting() {
   SETTINGS.saveToFile();
 }
 
-void SettingsActivity::displayTaskLoop() {
+void SettingsScreen::displayTaskLoop() {
   while (true) {
     if (updateRequired) {
       updateRequired = false;
@@ -96,7 +96,7 @@ void SettingsActivity::displayTaskLoop() {
   }
 }
 
-void SettingsActivity::render() const {
+void SettingsScreen::render() const {
   renderer.clearScreen();
 
   const auto pageWidth = GfxRenderer::getScreenWidth();

src/screens/SettingsScreen.h

@@ -7,7 +7,7 @@
 #include <string>
 #include <vector>
 
-#include "../Activity.h"
+#include "Screen.h"
 
 class CrossPointSettings;
 
@@ -17,7 +17,7 @@ struct SettingInfo {
   uint8_t CrossPointSettings::* valuePtr;  // Pointer to member in CrossPointSettings
 };
 
-class SettingsActivity final : public Activity {
+class SettingsScreen final : public Screen {
   TaskHandle_t displayTaskHandle = nullptr;
   SemaphoreHandle_t renderingMutex = nullptr;
   bool updateRequired = false;
@@ -34,9 +34,9 @@ class SettingsActivity final : public Activity {
   void toggleCurrentSetting();
 
  public:
-  explicit SettingsActivity(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onGoHome)
+  explicit SettingsScreen(GfxRenderer& renderer, InputManager& inputManager, const std::function<void()>& onGoHome)
-      : Activity(renderer, inputManager), onGoHome(onGoHome) {}
+      : Screen(renderer, inputManager), onGoHome(onGoHome) {}
   void onEnter() override;
   void onExit() override;
-  void loop() override;
+  void handleInput() override;
 };

src/screens/SleepScreen.cpp

@@ -1,4 +1,4 @@
-#include "SleepActivity.h"
+#include "SleepScreen.h"
 
 #include <GfxRenderer.h>
 
@@ -6,7 +6,7 @@
 #include "config.h"
 #include "images/CrossLarge.h"
 
-void SleepActivity::onEnter() {
+void SleepScreen::onEnter() {
   const auto pageWidth = GfxRenderer::getScreenWidth();
   const auto pageHeight = GfxRenderer::getScreenHeight();
 

src/screens/SleepScreen.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "Screen.h"
+
+class SleepScreen final : public Screen {
+ public:
+  explicit SleepScreen(GfxRenderer& renderer, InputManager& inputManager) : Screen(renderer, inputManager) {}
+  void onEnter() override;
+};