Pretty sure it works but kosync is down right now even on my other devices

src/activities/reader/EpubReaderActivity.cpp

@@ -120,9 +120,11 @@ void EpubReaderActivity::loop() {
   if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
     // Don't start activity transition while rendering
     xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    const int currentPage = section ? section->currentPage : 0;
+    const int totalPages = section ? section->pageCount : 0;
     exitActivity();
     enterNewActivity(new EpubReaderChapterSelectionActivity(
-        this->renderer, this->mappedInput, epub, currentSpineIndex,
+        this->renderer, this->mappedInput, epub, epub->getPath(), currentSpineIndex, currentPage, totalPages,
         [this] {
           exitActivity();
           updateRequired = true;
@@ -135,6 +137,16 @@ void EpubReaderActivity::loop() {
           }
           exitActivity();
           updateRequired = true;
+        },
+        [this](const int newSpineIndex, const int newPage) {
+          // Handle sync position
+          if (currentSpineIndex != newSpineIndex || (section && section->currentPage != newPage)) {
+            currentSpineIndex = newSpineIndex;
+            nextPageNumber = newPage;
+            section.reset();
+          }
+          exitActivity();
+          updateRequired = true;
         }));
     xSemaphoreGive(renderingMutex);
   }

src/activities/reader/EpubReaderChapterSelectionActivity.cpp

@@ -2,14 +2,25 @@
 
 #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;
+
+// Sync option is shown at index 0 if credentials are configured
+constexpr int SYNC_ITEM_INDEX = 0;
 }  // namespace
 
+int EpubReaderChapterSelectionActivity::getTotalItems() const {
+  // Add 1 for sync option if credentials are configured
+  const int syncOffset = KOREADER_STORE.hasCredentials() ? 1 : 0;
+  return epub->getTocItemsCount() + syncOffset;
+}
+
 int EpubReaderChapterSelectionActivity::getPageItems() const {
   // Layout constants used in renderScreen
   constexpr int startY = 60;
@@ -32,17 +43,21 @@ void EpubReaderChapterSelectionActivity::taskTrampoline(void* param) {
 }
 
 void EpubReaderChapterSelectionActivity::onEnter() {
-  Activity::onEnter();
+  ActivityWithSubactivity::onEnter();
 
   if (!epub) {
     return;
   }
 
   renderingMutex = xSemaphoreCreateMutex();
+
+  // Account for sync option offset when finding current TOC index
+  const int syncOffset = KOREADER_STORE.hasCredentials() ? 1 : 0;
   selectorIndex = epub->getTocIndexForSpineIndex(currentSpineIndex);
   if (selectorIndex == -1) {
     selectorIndex = 0;
   }
+  selectorIndex += syncOffset;  // Offset for sync option
 
   // Trigger first update
   updateRequired = true;
@@ -55,7 +70,7 @@ void EpubReaderChapterSelectionActivity::onEnter() {
 }
 
 void EpubReaderChapterSelectionActivity::onExit() {
-  Activity::onExit();
+  ActivityWithSubactivity::onExit();
 
   // Wait until not rendering to delete task to avoid killing mid-instruction to EPD
   xSemaphoreTake(renderingMutex, portMAX_DELAY);
@@ -67,7 +82,30 @@ void EpubReaderChapterSelectionActivity::onExit() {
   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) ||
@@ -75,9 +113,19 @@ void EpubReaderChapterSelectionActivity::loop() {
 
   const bool skipPage = mappedInput.getHeldTime() > SKIP_PAGE_MS;
   const int pageItems = getPageItems();
+  const int totalItems = getTotalItems();
+  const int syncOffset = KOREADER_STORE.hasCredentials() ? 1 : 0;
 
   if (mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
-    const auto newSpineIndex = epub->getSpineIndexForTocIndex(selectorIndex);
+    // Check if sync option is selected
+    if (syncOffset > 0 && selectorIndex == SYNC_ITEM_INDEX) {
+      launchSyncActivity();
+      return;
+    }
+
+    // Get TOC index (account for sync offset)
+    const int tocIndex = selectorIndex - syncOffset;
+    const auto newSpineIndex = epub->getSpineIndexForTocIndex(tocIndex);
     if (newSpineIndex == -1) {
       onGoBack();
     } else {
@@ -87,17 +135,16 @@ void EpubReaderChapterSelectionActivity::loop() {
     onGoBack();
   } else if (prevReleased) {
     if (skipPage) {
-      selectorIndex =
-          ((selectorIndex / pageItems - 1) * pageItems + epub->getTocItemsCount()) % epub->getTocItemsCount();
+      selectorIndex = ((selectorIndex / pageItems - 1) * pageItems + totalItems) % totalItems;
     } else {
-      selectorIndex = (selectorIndex + epub->getTocItemsCount() - 1) % epub->getTocItemsCount();
+      selectorIndex = (selectorIndex + totalItems - 1) % totalItems;
     }
     updateRequired = true;
   } else if (nextReleased) {
     if (skipPage) {
-      selectorIndex = ((selectorIndex / pageItems + 1) * pageItems) % epub->getTocItemsCount();
+      selectorIndex = ((selectorIndex / pageItems + 1) * pageItems) % totalItems;
     } else {
-      selectorIndex = (selectorIndex + 1) % epub->getTocItemsCount();
+      selectorIndex = (selectorIndex + 1) % totalItems;
     }
     updateRequired = true;
   }
@@ -105,7 +152,7 @@ void EpubReaderChapterSelectionActivity::loop() {
 
 void EpubReaderChapterSelectionActivity::displayTaskLoop() {
   while (true) {
-    if (updateRequired) {
+    if (updateRequired && !subActivity) {
       updateRequired = false;
       xSemaphoreTake(renderingMutex, portMAX_DELAY);
       renderScreen();
@@ -120,6 +167,8 @@ void EpubReaderChapterSelectionActivity::renderScreen() {
 
   const auto pageWidth = renderer.getScreenWidth();
   const int pageItems = getPageItems();
+  const int totalItems = getTotalItems();
+  const int syncOffset = KOREADER_STORE.hasCredentials() ? 1 : 0;
 
   const std::string title =
       renderer.truncatedText(UI_12_FONT_ID, epub->getTitle().c_str(), pageWidth - 40, EpdFontFamily::BOLD);
@@ -127,11 +176,20 @@ void EpubReaderChapterSelectionActivity::renderScreen() {
 
   const auto pageStartIndex = selectorIndex / pageItems * pageItems;
   renderer.fillRect(0, 60 + (selectorIndex % pageItems) * 30 - 2, pageWidth - 1, 30);
-  for (int tocIndex = pageStartIndex; tocIndex < epub->getTocItemsCount() && tocIndex < pageStartIndex + pageItems;
-       tocIndex++) {
-    auto item = epub->getTocItem(tocIndex);
-    renderer.drawText(UI_10_FONT_ID, 20 + (item.level - 1) * 15, 60 + (tocIndex % pageItems) * 30, item.title.c_str(),
-                      tocIndex != selectorIndex);
+
+  for (int itemIndex = pageStartIndex; itemIndex < totalItems && itemIndex < pageStartIndex + pageItems; itemIndex++) {
+    const int displayY = 60 + (itemIndex % pageItems) * 30;
+    const bool isSelected = (itemIndex == selectorIndex);
+
+    if (syncOffset > 0 && itemIndex == SYNC_ITEM_INDEX) {
+      // Draw sync option
+      renderer.drawText(UI_10_FONT_ID, 20, displayY, ">> Sync Progress", !isSelected);
+    } else {
+      // Draw TOC item (account for sync offset)
+      const int tocIndex = itemIndex - syncOffset;
+      auto item = epub->getTocItem(tocIndex);
+      renderer.drawText(UI_10_FONT_ID, 20 + (item.level - 1) * 15, displayY, item.title.c_str(), !isSelected);
+    }
   }
 
   renderer.displayBuffer();

src/activities/reader/EpubReaderChapterSelectionActivity.h

@@ -6,36 +6,50 @@
 
 #include <memory>
 
-#include "../Activity.h"
+#include "../ActivityWithSubactivity.h"
 
-class EpubReaderChapterSelectionActivity final : public Activity {
+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 the sync option
+  int getTotalItems() const;
+
   static void taskTrampoline(void* param);
   [[noreturn]] void displayTaskLoop();
   void renderScreen();
+  void launchSyncActivity();
 
  public:
   explicit EpubReaderChapterSelectionActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
-                                              const std::shared_ptr<Epub>& epub, const int currentSpineIndex,
-                                              const std::function<void()>& onGoBack,
-                                              const std::function<void(int newSpineIndex)>& onSelectSpineIndex)
-      : Activity("EpubReaderChapterSelection", renderer, 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) {}
+        onSelectSpineIndex(onSelectSpineIndex),
+        onSyncPosition(onSyncPosition) {}
   void onEnter() override;
   void onExit() override;
   void loop() override;

src/activities/reader/KOReaderSyncActivity.cpp

@@ -0,0 +1,423 @@
+#include "KOReaderSyncActivity.h"
+
+#include <GfxRenderer.h>
+#include <WiFi.h>
+#include <esp_sntp.h>
+
+#include "KOReaderCredentialStore.h"
+#include "KOReaderDocumentId.h"
+#include "MappedInputManager.h"
+#include "activities/network/WifiSelectionActivity.h"
+#include "fontIds.h"
+
+namespace {
+void syncTimeWithNTP() {
+  // Configure SNTP
+  esp_sntp_setoperatingmode(ESP_SNTP_OPMODE_POLL);
+  esp_sntp_setservername(0, "pool.ntp.org");
+  esp_sntp_init();
+
+  // Wait for time to sync (with timeout)
+  int retry = 0;
+  const int maxRetries = 50;  // 5 seconds max
+  while (sntp_get_sync_status() != SNTP_SYNC_STATUS_COMPLETED && retry < maxRetries) {
+    vTaskDelay(100 / portTICK_PERIOD_MS);
+    retry++;
+  }
+
+  if (retry < maxRetries) {
+    Serial.printf("[%lu] [KOSync] NTP time synced\n", millis());
+  } else {
+    Serial.printf("[%lu] [KOSync] NTP sync timeout, using fallback\n", millis());
+  }
+}
+}  // namespace
+
+void KOReaderSyncActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<KOReaderSyncActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void KOReaderSyncActivity::onWifiSelectionComplete(const bool success) {
+  exitActivity();
+
+  if (!success) {
+    Serial.printf("[%lu] [KOSync] WiFi connection failed, exiting\n", millis());
+    onCancel();
+    return;
+  }
+
+  Serial.printf("[%lu] [KOSync] WiFi connected, starting sync\n", millis());
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  state = SYNCING;
+  statusMessage = "Syncing time...";
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+
+  // Sync time with NTP before making API requests
+  syncTimeWithNTP();
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  statusMessage = "Calculating document hash...";
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+
+  performSync();
+}
+
+void KOReaderSyncActivity::performSync() {
+  // Calculate document hash
+  documentHash = KOReaderDocumentId::calculate(epubPath);
+  if (documentHash.empty()) {
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    state = SYNC_FAILED;
+    statusMessage = "Failed to calculate document hash";
+    xSemaphoreGive(renderingMutex);
+    updateRequired = true;
+    return;
+  }
+
+  Serial.printf("[%lu] [KOSync] Document hash: %s\n", millis(), documentHash.c_str());
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  statusMessage = "Fetching remote progress...";
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+  vTaskDelay(10 / portTICK_PERIOD_MS);
+
+  // Fetch remote progress
+  const auto result = KOReaderSyncClient::getProgress(documentHash, remoteProgress);
+
+  if (result == KOReaderSyncClient::NOT_FOUND) {
+    // No remote progress - offer to upload
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    state = NO_REMOTE_PROGRESS;
+    hasRemoteProgress = false;
+    xSemaphoreGive(renderingMutex);
+    updateRequired = true;
+    return;
+  }
+
+  if (result != KOReaderSyncClient::OK) {
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    state = SYNC_FAILED;
+    statusMessage = KOReaderSyncClient::errorString(result);
+    xSemaphoreGive(renderingMutex);
+    updateRequired = true;
+    return;
+  }
+
+  // Convert remote progress to CrossPoint position
+  hasRemoteProgress = true;
+  KOReaderPosition koPos = {remoteProgress.progress, remoteProgress.percentage};
+  remotePosition = ProgressMapper::toCrossPoint(epub, koPos, totalPagesInSpine);
+
+  // Calculate local progress in KOReader format (for display)
+  CrossPointPosition localPos = {currentSpineIndex, currentPage, totalPagesInSpine};
+  localProgress = ProgressMapper::toKOReader(epub, localPos);
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  state = SHOWING_RESULT;
+  selectedOption = 0;  // Default to "Apply"
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+}
+
+void KOReaderSyncActivity::performUpload() {
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  state = UPLOADING;
+  statusMessage = "Uploading progress...";
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+  vTaskDelay(10 / portTICK_PERIOD_MS);
+
+  // Convert current position to KOReader format
+  CrossPointPosition localPos = {currentSpineIndex, currentPage, totalPagesInSpine};
+  KOReaderPosition koPos = ProgressMapper::toKOReader(epub, localPos);
+
+  KOReaderProgress progress;
+  progress.document = documentHash;
+  progress.progress = koPos.xpath;
+  progress.percentage = koPos.percentage;
+
+  const auto result = KOReaderSyncClient::updateProgress(progress);
+
+  if (result != KOReaderSyncClient::OK) {
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    state = SYNC_FAILED;
+    statusMessage = KOReaderSyncClient::errorString(result);
+    xSemaphoreGive(renderingMutex);
+    updateRequired = true;
+    return;
+  }
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  state = UPLOAD_COMPLETE;
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+}
+
+void KOReaderSyncActivity::onEnter() {
+  ActivityWithSubactivity::onEnter();
+
+  renderingMutex = xSemaphoreCreateMutex();
+
+  xTaskCreate(&KOReaderSyncActivity::taskTrampoline, "KOSyncTask",
+              4096,               // Stack size (larger for network operations)
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+
+  // Check for credentials first
+  if (!KOREADER_STORE.hasCredentials()) {
+    state = NO_CREDENTIALS;
+    updateRequired = true;
+    return;
+  }
+
+  // Turn on WiFi
+  Serial.printf("[%lu] [KOSync] Turning on WiFi...\n", millis());
+  WiFi.mode(WIFI_STA);
+
+  // Check if already connected
+  if (WiFi.status() == WL_CONNECTED) {
+    Serial.printf("[%lu] [KOSync] Already connected to WiFi\n", millis());
+    state = SYNCING;
+    statusMessage = "Syncing time...";
+    updateRequired = true;
+
+    // Perform sync directly (will be handled in loop)
+    xTaskCreate(
+        [](void* param) {
+          auto* self = static_cast<KOReaderSyncActivity*>(param);
+          // Sync time first
+          syncTimeWithNTP();
+          xSemaphoreTake(self->renderingMutex, portMAX_DELAY);
+          self->statusMessage = "Calculating document hash...";
+          xSemaphoreGive(self->renderingMutex);
+          self->updateRequired = true;
+          self->performSync();
+          vTaskDelete(nullptr);
+        },
+        "SyncTask", 4096, this, 1, nullptr);
+    return;
+  }
+
+  // Launch WiFi selection subactivity
+  Serial.printf("[%lu] [KOSync] Launching WifiSelectionActivity...\n", millis());
+  enterNewActivity(
+      new WifiSelectionActivity(renderer, mappedInput, [this](const bool connected) { onWifiSelectionComplete(connected); }));
+}
+
+void KOReaderSyncActivity::onExit() {
+  ActivityWithSubactivity::onExit();
+
+  // Turn off wifi
+  WiFi.disconnect(false);
+  delay(100);
+  WiFi.mode(WIFI_OFF);
+  delay(100);
+
+  // Wait until not rendering to delete task
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void KOReaderSyncActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void KOReaderSyncActivity::render() {
+  if (subActivity) {
+    return;
+  }
+
+  const auto pageWidth = renderer.getScreenWidth();
+
+  renderer.clearScreen();
+  renderer.drawCenteredText(UI_12_FONT_ID, 15, "KOReader Sync", true, EpdFontFamily::BOLD);
+
+  if (state == NO_CREDENTIALS) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 280, "No credentials configured", true, EpdFontFamily::BOLD);
+    renderer.drawCenteredText(UI_10_FONT_ID, 320, "Set up KOReader account in Settings");
+
+    const auto labels = mappedInput.mapLabels("Back", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == SYNCING || state == UPLOADING) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 300, statusMessage.c_str(), true, EpdFontFamily::BOLD);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == SHOWING_RESULT) {
+    // Show comparison
+    renderer.drawCenteredText(UI_10_FONT_ID, 120, "Progress found!", true, EpdFontFamily::BOLD);
+
+    // Get chapter names from TOC
+    const int remoteTocIndex = epub->getTocIndexForSpineIndex(remotePosition.spineIndex);
+    const int localTocIndex = epub->getTocIndexForSpineIndex(currentSpineIndex);
+    const std::string remoteChapter =
+        (remoteTocIndex >= 0) ? epub->getTocItem(remoteTocIndex).title : ("Section " + std::to_string(remotePosition.spineIndex + 1));
+    const std::string localChapter =
+        (localTocIndex >= 0) ? epub->getTocItem(localTocIndex).title : ("Section " + std::to_string(currentSpineIndex + 1));
+
+    // Remote progress - chapter and page
+    renderer.drawText(UI_10_FONT_ID, 20, 160, "Remote:", true);
+    char remoteChapterStr[128];
+    snprintf(remoteChapterStr, sizeof(remoteChapterStr), "  %s", remoteChapter.c_str());
+    renderer.drawText(UI_10_FONT_ID, 20, 185, remoteChapterStr);
+    char remotePageStr[64];
+    snprintf(remotePageStr, sizeof(remotePageStr), "  Page %d, %.0f%% overall", remotePosition.pageNumber + 1, remoteProgress.percentage * 100);
+    renderer.drawText(UI_10_FONT_ID, 20, 210, remotePageStr);
+
+    if (!remoteProgress.device.empty()) {
+      char deviceStr[64];
+      snprintf(deviceStr, sizeof(deviceStr), "  From: %s", remoteProgress.device.c_str());
+      renderer.drawText(UI_10_FONT_ID, 20, 235, deviceStr);
+    }
+
+    // Local progress - chapter and page
+    renderer.drawText(UI_10_FONT_ID, 20, 270, "Local:", true);
+    char localChapterStr[128];
+    snprintf(localChapterStr, sizeof(localChapterStr), "  %s", localChapter.c_str());
+    renderer.drawText(UI_10_FONT_ID, 20, 295, localChapterStr);
+    char localPageStr[64];
+    snprintf(localPageStr, sizeof(localPageStr), "  Page %d/%d, %.0f%% overall", currentPage + 1, totalPagesInSpine, localProgress.percentage * 100);
+    renderer.drawText(UI_10_FONT_ID, 20, 320, localPageStr);
+
+    // Options
+    const int optionY = 350;
+    const int optionHeight = 30;
+
+    // Apply option
+    if (selectedOption == 0) {
+      renderer.fillRect(0, optionY - 2, pageWidth - 1, optionHeight);
+    }
+    renderer.drawText(UI_10_FONT_ID, 20, optionY, "Apply remote progress", selectedOption != 0);
+
+    // Upload option
+    if (selectedOption == 1) {
+      renderer.fillRect(0, optionY + optionHeight - 2, pageWidth - 1, optionHeight);
+    }
+    renderer.drawText(UI_10_FONT_ID, 20, optionY + optionHeight, "Upload local progress", selectedOption != 1);
+
+    // Cancel option
+    if (selectedOption == 2) {
+      renderer.fillRect(0, optionY + optionHeight * 2 - 2, pageWidth - 1, optionHeight);
+    }
+    renderer.drawText(UI_10_FONT_ID, 20, optionY + optionHeight * 2, "Cancel", selectedOption != 2);
+
+    const auto labels = mappedInput.mapLabels("", "Select", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == NO_REMOTE_PROGRESS) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 280, "No remote progress found", true, EpdFontFamily::BOLD);
+    renderer.drawCenteredText(UI_10_FONT_ID, 320, "Upload current position?");
+
+    const auto labels = mappedInput.mapLabels("Cancel", "Upload", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == UPLOAD_COMPLETE) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 300, "Progress uploaded!", true, EpdFontFamily::BOLD);
+
+    const auto labels = mappedInput.mapLabels("Back", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == SYNC_FAILED) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 280, "Sync failed", true, EpdFontFamily::BOLD);
+    renderer.drawCenteredText(UI_10_FONT_ID, 320, statusMessage.c_str());
+
+    const auto labels = mappedInput.mapLabels("Back", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+}
+
+void KOReaderSyncActivity::loop() {
+  if (subActivity) {
+    subActivity->loop();
+    return;
+  }
+
+  if (state == NO_CREDENTIALS || state == SYNC_FAILED || state == UPLOAD_COMPLETE) {
+    if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
+      onCancel();
+    }
+    return;
+  }
+
+  if (state == SHOWING_RESULT) {
+    // Navigate options
+    if (mappedInput.wasPressed(MappedInputManager::Button::Up) ||
+        mappedInput.wasPressed(MappedInputManager::Button::Left)) {
+      selectedOption = (selectedOption + 2) % 3;  // Wrap around
+      updateRequired = true;
+    } else if (mappedInput.wasPressed(MappedInputManager::Button::Down) ||
+               mappedInput.wasPressed(MappedInputManager::Button::Right)) {
+      selectedOption = (selectedOption + 1) % 3;
+      updateRequired = true;
+    }
+
+    if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
+      if (selectedOption == 0) {
+        // Apply remote progress
+        onSyncComplete(remotePosition.spineIndex, remotePosition.pageNumber);
+      } else if (selectedOption == 1) {
+        // Upload local progress
+        performUpload();
+      } else {
+        // Cancel
+        onCancel();
+      }
+    }
+
+    if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
+      onCancel();
+    }
+    return;
+  }
+
+  if (state == NO_REMOTE_PROGRESS) {
+    if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
+      // Calculate hash if not done yet
+      if (documentHash.empty()) {
+        documentHash = KOReaderDocumentId::calculate(epubPath);
+      }
+      performUpload();
+    }
+
+    if (mappedInput.wasPressed(MappedInputManager::Button::Back)) {
+      onCancel();
+    }
+    return;
+  }
+}

src/activities/reader/KOReaderSyncActivity.h

@@ -0,0 +1,95 @@
+#pragma once
+#include <Epub.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+#include <memory>
+
+#include "KOReaderSyncClient.h"
+#include "ProgressMapper.h"
+#include "activities/ActivityWithSubactivity.h"
+
+/**
+ * Activity for syncing reading progress with KOReader sync server.
+ *
+ * Flow:
+ * 1. Connect to WiFi (if not connected)
+ * 2. Calculate document hash
+ * 3. Fetch remote progress
+ * 4. Show comparison and options (Apply/Upload/Cancel)
+ * 5. Apply or upload progress
+ */
+class KOReaderSyncActivity final : public ActivityWithSubactivity {
+ public:
+  using OnCancelCallback = std::function<void()>;
+  using OnSyncCompleteCallback = std::function<void(int newSpineIndex, int newPageNumber)>;
+
+  explicit KOReaderSyncActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
+                                const std::shared_ptr<Epub>& epub, const std::string& epubPath, int currentSpineIndex,
+                                int currentPage, int totalPagesInSpine, OnCancelCallback onCancel,
+                                OnSyncCompleteCallback onSyncComplete)
+      : ActivityWithSubactivity("KOReaderSync", renderer, mappedInput),
+        epub(epub),
+        epubPath(epubPath),
+        currentSpineIndex(currentSpineIndex),
+        currentPage(currentPage),
+        totalPagesInSpine(totalPagesInSpine),
+        onCancel(std::move(onCancel)),
+        onSyncComplete(std::move(onSyncComplete)) {}
+
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+  bool preventAutoSleep() override { return state == CONNECTING || state == SYNCING; }
+
+ private:
+  enum State {
+    WIFI_SELECTION,
+    CONNECTING,
+    SYNCING,
+    SHOWING_RESULT,
+    UPLOADING,
+    UPLOAD_COMPLETE,
+    NO_REMOTE_PROGRESS,
+    SYNC_FAILED,
+    NO_CREDENTIALS
+  };
+
+  std::shared_ptr<Epub> epub;
+  std::string epubPath;
+  int currentSpineIndex;
+  int currentPage;
+  int totalPagesInSpine;
+
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+
+  State state = WIFI_SELECTION;
+  std::string statusMessage;
+  std::string documentHash;
+
+  // Remote progress data
+  bool hasRemoteProgress = false;
+  KOReaderProgress remoteProgress;
+  CrossPointPosition remotePosition;
+
+  // Local progress as KOReader format (for display)
+  KOReaderPosition localProgress;
+
+  // Selection in result screen (0=Apply, 1=Upload, 2=Cancel)
+  int selectedOption = 0;
+
+  OnCancelCallback onCancel;
+  OnSyncCompleteCallback onSyncComplete;
+
+  void onWifiSelectionComplete(bool success);
+  void performSync();
+  void performUpload();
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render();
+};

src/activities/settings/KOReaderAuthActivity.cpp

@@ -0,0 +1,167 @@
+#include "KOReaderAuthActivity.h"
+
+#include <GfxRenderer.h>
+#include <WiFi.h>
+
+#include "KOReaderCredentialStore.h"
+#include "KOReaderSyncClient.h"
+#include "MappedInputManager.h"
+#include "activities/network/WifiSelectionActivity.h"
+#include "fontIds.h"
+
+void KOReaderAuthActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<KOReaderAuthActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void KOReaderAuthActivity::onWifiSelectionComplete(const bool success) {
+  exitActivity();
+
+  if (!success) {
+    xSemaphoreTake(renderingMutex, portMAX_DELAY);
+    state = FAILED;
+    errorMessage = "WiFi connection failed";
+    xSemaphoreGive(renderingMutex);
+    updateRequired = true;
+    return;
+  }
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  state = AUTHENTICATING;
+  statusMessage = "Authenticating...";
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+
+  performAuthentication();
+}
+
+void KOReaderAuthActivity::performAuthentication() {
+  const auto result = KOReaderSyncClient::authenticate();
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (result == KOReaderSyncClient::OK) {
+    state = SUCCESS;
+    statusMessage = "Successfully authenticated!";
+  } else {
+    state = FAILED;
+    errorMessage = KOReaderSyncClient::errorString(result);
+  }
+  xSemaphoreGive(renderingMutex);
+  updateRequired = true;
+}
+
+void KOReaderAuthActivity::onEnter() {
+  ActivityWithSubactivity::onEnter();
+
+  renderingMutex = xSemaphoreCreateMutex();
+
+  xTaskCreate(&KOReaderAuthActivity::taskTrampoline, "KOAuthTask",
+              4096,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+
+  // Turn on WiFi
+  WiFi.mode(WIFI_STA);
+
+  // Check if already connected
+  if (WiFi.status() == WL_CONNECTED) {
+    state = AUTHENTICATING;
+    statusMessage = "Authenticating...";
+    updateRequired = true;
+
+    // Perform authentication in a separate task
+    xTaskCreate(
+        [](void* param) {
+          auto* self = static_cast<KOReaderAuthActivity*>(param);
+          self->performAuthentication();
+          vTaskDelete(nullptr);
+        },
+        "AuthTask", 4096, this, 1, nullptr);
+    return;
+  }
+
+  // Launch WiFi selection
+  enterNewActivity(new WifiSelectionActivity(renderer, mappedInput,
+                                             [this](const bool connected) { onWifiSelectionComplete(connected); }));
+}
+
+void KOReaderAuthActivity::onExit() {
+  ActivityWithSubactivity::onExit();
+
+  // Turn off wifi
+  WiFi.disconnect(false);
+  delay(100);
+  WiFi.mode(WIFI_OFF);
+  delay(100);
+
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+}
+
+void KOReaderAuthActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired && !subActivity) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      render();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void KOReaderAuthActivity::render() {
+  if (subActivity) {
+    return;
+  }
+
+  renderer.clearScreen();
+  renderer.drawCenteredText(UI_12_FONT_ID, 15, "KOReader Auth", true, EpdFontFamily::BOLD);
+
+  if (state == AUTHENTICATING) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 300, statusMessage.c_str(), true, EpdFontFamily::BOLD);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == SUCCESS) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 280, "Success!", true, EpdFontFamily::BOLD);
+    renderer.drawCenteredText(UI_10_FONT_ID, 320, "KOReader sync is ready to use");
+
+    const auto labels = mappedInput.mapLabels("Done", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+
+  if (state == FAILED) {
+    renderer.drawCenteredText(UI_10_FONT_ID, 280, "Authentication Failed", true, EpdFontFamily::BOLD);
+    renderer.drawCenteredText(UI_10_FONT_ID, 320, errorMessage.c_str());
+
+    const auto labels = mappedInput.mapLabels("Back", "", "", "");
+    renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+    renderer.displayBuffer();
+    return;
+  }
+}
+
+void KOReaderAuthActivity::loop() {
+  if (subActivity) {
+    subActivity->loop();
+    return;
+  }
+
+  if (state == SUCCESS || state == FAILED) {
+    if (mappedInput.wasPressed(MappedInputManager::Button::Back) ||
+        mappedInput.wasPressed(MappedInputManager::Button::Confirm)) {
+      onComplete();
+    }
+  }
+}

src/activities/settings/KOReaderAuthActivity.h

@@ -0,0 +1,44 @@
+#pragma once
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <functional>
+
+#include "activities/ActivityWithSubactivity.h"
+
+/**
+ * Activity for testing KOReader credentials.
+ * Connects to WiFi and authenticates with the KOReader sync server.
+ */
+class KOReaderAuthActivity final : public ActivityWithSubactivity {
+ public:
+  explicit KOReaderAuthActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,
+                                const std::function<void()>& onComplete)
+      : ActivityWithSubactivity("KOReaderAuth", renderer, mappedInput), onComplete(onComplete) {}
+
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+  bool preventAutoSleep() override { return state == CONNECTING || state == AUTHENTICATING; }
+
+ private:
+  enum State { WIFI_SELECTION, CONNECTING, AUTHENTICATING, SUCCESS, FAILED };
+
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  bool updateRequired = false;
+
+  State state = WIFI_SELECTION;
+  std::string statusMessage;
+  std::string errorMessage;
+
+  const std::function<void()> onComplete;
+
+  void onWifiSelectionComplete(bool success);
+  void performAuthentication();
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void render();
+};

src/activities/settings/SettingsActivity.cpp

@@ -3,13 +3,16 @@
 #include <GfxRenderer.h>
 
 #include "CrossPointSettings.h"
+#include "KOReaderAuthActivity.h"
+#include "KOReaderCredentialStore.h"
 #include "MappedInputManager.h"
 #include "OtaUpdateActivity.h"
+#include "activities/util/KeyboardEntryActivity.h"
 #include "fontIds.h"
 
 // Define the static settings list
 namespace {
-constexpr int settingsCount = 14;
+constexpr int settingsCount = 18;
 const SettingInfo settingsList[settingsCount] = {
     // Should match with SLEEP_SCREEN_MODE
     {"Sleep Screen", SettingType::ENUM, &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover"}},
@@ -46,8 +49,56 @@ const SettingInfo settingsList[settingsCount] = {
      SettingType::ENUM,
      &CrossPointSettings::refreshFrequency,
      {"1 page", "5 pages", "10 pages", "15 pages", "30 pages"}},
+    {"KOReader Username", SettingType::ACTION, nullptr, {}},
+    {"KOReader Password", SettingType::ACTION, nullptr, {}},
+    {"Authenticate KOReader", SettingType::ACTION, nullptr, {}},
     {"Check for updates", SettingType::ACTION, nullptr, {}},
 };
+
+// Check if a setting should be visible
+bool isSettingVisible(int index) {
+  // Hide "Authenticate KOReader" if credentials are not set
+  if (std::string(settingsList[index].name) == "Authenticate KOReader") {
+    return KOREADER_STORE.hasCredentials();
+  }
+  return true;
+}
+
+// Get visible settings count
+int getVisibleSettingsCount() {
+  int count = 0;
+  for (int i = 0; i < settingsCount; i++) {
+    if (isSettingVisible(i)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+// Convert visible index to actual settings index
+int visibleToActualIndex(int visibleIndex) {
+  int count = 0;
+  for (int i = 0; i < settingsCount; i++) {
+    if (isSettingVisible(i)) {
+      if (count == visibleIndex) {
+        return i;
+      }
+      count++;
+    }
+  }
+  return -1;
+}
+
+// Convert actual index to visible index
+int actualToVisibleIndex(int actualIndex) {
+  int count = 0;
+  for (int i = 0; i < actualIndex; i++) {
+    if (isSettingVisible(i)) {
+      count++;
+    }
+  }
+  return count;
+}
 }  // namespace
 
 void SettingsActivity::taskTrampoline(void* param) {
@@ -106,16 +157,17 @@ void SettingsActivity::loop() {
     return;
   }
 
-  // Handle navigation
+  // Handle navigation (using visible settings count)
+  const int visibleCount = getVisibleSettingsCount();
   if (mappedInput.wasPressed(MappedInputManager::Button::Up) ||
       mappedInput.wasPressed(MappedInputManager::Button::Left)) {
     // Move selection up (with wrap-around)
-    selectedSettingIndex = (selectedSettingIndex > 0) ? (selectedSettingIndex - 1) : (settingsCount - 1);
+    selectedSettingIndex = (selectedSettingIndex > 0) ? (selectedSettingIndex - 1) : (visibleCount - 1);
     updateRequired = true;
   } else if (mappedInput.wasPressed(MappedInputManager::Button::Down) ||
              mappedInput.wasPressed(MappedInputManager::Button::Right)) {
     // Move selection down
-    if (selectedSettingIndex < settingsCount - 1) {
+    if (selectedSettingIndex < visibleCount - 1) {
       selectedSettingIndex++;
       updateRequired = true;
     }
@@ -123,12 +175,13 @@ void SettingsActivity::loop() {
 }
 
 void SettingsActivity::toggleCurrentSetting() {
-  // Validate index
-  if (selectedSettingIndex < 0 || selectedSettingIndex >= settingsCount) {
+  // Convert visible index to actual index
+  const int actualIndex = visibleToActualIndex(selectedSettingIndex);
+  if (actualIndex < 0 || actualIndex >= settingsCount) {
     return;
   }
 
-  const auto& setting = settingsList[selectedSettingIndex];
+  const auto& setting = settingsList[actualIndex];
 
   if (setting.type == SettingType::TOGGLE && setting.valuePtr != nullptr) {
     // Toggle the boolean value using the member pointer
@@ -146,6 +199,54 @@ void SettingsActivity::toggleCurrentSetting() {
         updateRequired = true;
       }));
       xSemaphoreGive(renderingMutex);
+    } else if (std::string(setting.name) == "KOReader Username") {
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      exitActivity();
+      enterNewActivity(new KeyboardEntryActivity(
+          renderer, mappedInput, "KOReader Username", KOREADER_STORE.getUsername(), 10,
+          64,     // maxLength
+          false,  // not password
+          [this](const std::string& username) {
+            KOREADER_STORE.setCredentials(username, KOREADER_STORE.getPassword());
+            KOREADER_STORE.saveToFile();
+            exitActivity();
+            updateRequired = true;
+          },
+          [this]() {
+            exitActivity();
+            updateRequired = true;
+          }));
+      xSemaphoreGive(renderingMutex);
+    } else if (std::string(setting.name) == "KOReader Password") {
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      exitActivity();
+      enterNewActivity(new KeyboardEntryActivity(
+          renderer, mappedInput, "KOReader Password", KOREADER_STORE.getPassword(), 10,
+          64,     // maxLength
+          false,  // not password mode - show characters
+          [this](const std::string& password) {
+            KOREADER_STORE.setCredentials(KOREADER_STORE.getUsername(), password);
+            KOREADER_STORE.saveToFile();
+            exitActivity();
+            updateRequired = true;
+          },
+          [this]() {
+            exitActivity();
+            updateRequired = true;
+          }));
+      xSemaphoreGive(renderingMutex);
+    } else if (std::string(setting.name) == "Authenticate KOReader") {
+      // Only allow if credentials are set
+      if (!KOREADER_STORE.hasCredentials()) {
+        return;
+      }
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      exitActivity();
+      enterNewActivity(new KOReaderAuthActivity(renderer, mappedInput, [this] {
+        exitActivity();
+        updateRequired = true;
+      }));
+      xSemaphoreGive(renderingMutex);
     }
   } else {
     // Only toggle if it's a toggle type and has a value pointer
@@ -177,15 +278,21 @@ void SettingsActivity::render() const {
   // Draw header
   renderer.drawCenteredText(UI_12_FONT_ID, 15, "Settings", true, EpdFontFamily::BOLD);
 
-  // Draw selection
+  // Draw selection highlight
   renderer.fillRect(0, 60 + selectedSettingIndex * 30 - 2, pageWidth - 1, 30);
 
-  // Draw all settings
+  // Draw only visible settings
+  int visibleIndex = 0;
   for (int i = 0; i < settingsCount; i++) {
-    const int settingY = 60 + i * 30;  // 30 pixels between settings
+    if (!isSettingVisible(i)) {
+      continue;
+    }
+
+    const int settingY = 60 + visibleIndex * 30;  // 30 pixels between settings
+    const bool isSelected = (visibleIndex == selectedSettingIndex);
 
     // Draw setting name
-    renderer.drawText(UI_10_FONT_ID, 20, settingY, settingsList[i].name, i != selectedSettingIndex);
+    renderer.drawText(UI_10_FONT_ID, 20, settingY, settingsList[i].name, !isSelected);
 
     // Draw value based on setting type
     std::string valueText = "";
@@ -195,9 +302,18 @@ void SettingsActivity::render() const {
     } else if (settingsList[i].type == SettingType::ENUM && settingsList[i].valuePtr != nullptr) {
       const uint8_t value = SETTINGS.*(settingsList[i].valuePtr);
       valueText = settingsList[i].enumValues[value];
+    } else if (settingsList[i].type == SettingType::ACTION) {
+      // Show status for KOReader settings
+      if (std::string(settingsList[i].name) == "KOReader Username") {
+        valueText = KOREADER_STORE.getUsername().empty() ? "[Not Set]" : "[Set]";
+      } else if (std::string(settingsList[i].name) == "KOReader Password") {
+        valueText = KOREADER_STORE.getPassword().empty() ? "[Not Set]" : "[Set]";
+      }
     }
     const auto width = renderer.getTextWidth(UI_10_FONT_ID, valueText.c_str());
-    renderer.drawText(UI_10_FONT_ID, pageWidth - 20 - width, settingY, valueText.c_str(), i != selectedSettingIndex);
+    renderer.drawText(UI_10_FONT_ID, pageWidth - 20 - width, settingY, valueText.c_str(), !isSelected);
+
+    visibleIndex++;
   }
 
   // Draw version text above button hints