From 24736eaa50dda5ac4fdecbf5afedcef8ef700ae3 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sat, 3 Jan 2026 21:59:58 -0500 Subject: [PATCH 01/12] Pretty sure it works but kosync is down right now even on my other devices --- lib/KOReaderSync/KOReaderCredentialStore.cpp | 111 +++++ lib/KOReaderSync/KOReaderCredentialStore.h | 49 ++ lib/KOReaderSync/KOReaderDocumentId.cpp | 69 +++ lib/KOReaderSync/KOReaderDocumentId.h | 36 ++ lib/KOReaderSync/KOReaderSyncClient.cpp | 177 ++++++++ lib/KOReaderSync/KOReaderSyncClient.h | 67 +++ lib/KOReaderSync/ProgressMapper.cpp | 125 ++++++ lib/KOReaderSync/ProgressMapper.h | 72 +++ src/activities/reader/EpubReaderActivity.cpp | 14 +- .../EpubReaderChapterSelectionActivity.cpp | 86 +++- .../EpubReaderChapterSelectionActivity.h | 28 +- .../reader/KOReaderSyncActivity.cpp | 423 ++++++++++++++++++ src/activities/reader/KOReaderSyncActivity.h | 95 ++++ .../settings/KOReaderAuthActivity.cpp | 167 +++++++ .../settings/KOReaderAuthActivity.h | 44 ++ src/activities/settings/SettingsActivity.cpp | 140 +++++- src/main.cpp | 2 + 17 files changed, 1671 insertions(+), 34 deletions(-) create mode 100644 lib/KOReaderSync/KOReaderCredentialStore.cpp create mode 100644 lib/KOReaderSync/KOReaderCredentialStore.h create mode 100644 lib/KOReaderSync/KOReaderDocumentId.cpp create mode 100644 lib/KOReaderSync/KOReaderDocumentId.h create mode 100644 lib/KOReaderSync/KOReaderSyncClient.cpp create mode 100644 lib/KOReaderSync/KOReaderSyncClient.h create mode 100644 lib/KOReaderSync/ProgressMapper.cpp create mode 100644 lib/KOReaderSync/ProgressMapper.h create mode 100644 src/activities/reader/KOReaderSyncActivity.cpp create mode 100644 src/activities/reader/KOReaderSyncActivity.h create mode 100644 src/activities/settings/KOReaderAuthActivity.cpp create mode 100644 src/activities/settings/KOReaderAuthActivity.h diff --git a/lib/KOReaderSync/KOReaderCredentialStore.cpp b/lib/KOReaderSync/KOReaderCredentialStore.cpp new file mode 100644 index 00000000..b9cbc564 --- /dev/null +++ b/lib/KOReaderSync/KOReaderCredentialStore.cpp @@ -0,0 +1,111 @@ +#include "KOReaderCredentialStore.h" + +#include +#include +#include +#include + +// Initialize the static instance +KOReaderCredentialStore KOReaderCredentialStore::instance; + +namespace { +// File format version +constexpr uint8_t KOREADER_FILE_VERSION = 1; + +// KOReader credentials file path +constexpr char KOREADER_FILE[] = "/.crosspoint/koreader.bin"; + +// Obfuscation key - "KOReader" in ASCII +// This is NOT cryptographic security, just prevents casual file reading +constexpr uint8_t OBFUSCATION_KEY[] = {0x4B, 0x4F, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72}; +constexpr size_t KEY_LENGTH = sizeof(OBFUSCATION_KEY); +} // namespace + +void KOReaderCredentialStore::obfuscate(std::string& data) const { + for (size_t i = 0; i < data.size(); i++) { + data[i] ^= OBFUSCATION_KEY[i % KEY_LENGTH]; + } +} + +bool KOReaderCredentialStore::saveToFile() const { + // Make sure the directory exists + SdMan.mkdir("/.crosspoint"); + + FsFile file; + if (!SdMan.openFileForWrite("KRS", KOREADER_FILE, file)) { + return false; + } + + // Write header + serialization::writePod(file, KOREADER_FILE_VERSION); + + // Write username (plaintext - not particularly sensitive) + serialization::writeString(file, username); + Serial.printf("[%lu] [KRS] Saving username: %s\n", millis(), username.c_str()); + + // Write password (obfuscated) + std::string obfuscatedPwd = password; + obfuscate(obfuscatedPwd); + serialization::writeString(file, obfuscatedPwd); + + file.close(); + Serial.printf("[%lu] [KRS] Saved KOReader credentials to file\n", millis()); + return true; +} + +bool KOReaderCredentialStore::loadFromFile() { + FsFile file; + if (!SdMan.openFileForRead("KRS", KOREADER_FILE, file)) { + Serial.printf("[%lu] [KRS] No credentials file found\n", millis()); + return false; + } + + // Read and verify version + uint8_t version; + serialization::readPod(file, version); + if (version != KOREADER_FILE_VERSION) { + Serial.printf("[%lu] [KRS] Unknown file version: %u\n", millis(), version); + file.close(); + return false; + } + + // Read username + serialization::readString(file, username); + + // Read and deobfuscate password + serialization::readString(file, password); + obfuscate(password); // XOR is symmetric, so same function deobfuscates + + file.close(); + Serial.printf("[%lu] [KRS] Loaded KOReader credentials for user: %s\n", millis(), username.c_str()); + return true; +} + +void KOReaderCredentialStore::setCredentials(const std::string& user, const std::string& pass) { + username = user; + password = pass; + Serial.printf("[%lu] [KRS] Set credentials for user: %s\n", millis(), user.c_str()); +} + +std::string KOReaderCredentialStore::getMd5Password() const { + if (password.empty()) { + return ""; + } + + // Calculate MD5 hash of password using ESP32's MD5Builder + MD5Builder md5; + md5.begin(); + md5.add(password.c_str()); + md5.calculate(); + + return md5.toString().c_str(); +} + +bool KOReaderCredentialStore::hasCredentials() const { return !username.empty() && !password.empty(); } + +void KOReaderCredentialStore::clearCredentials() { + username.clear(); + password.clear(); + saveToFile(); + Serial.printf("[%lu] [KRS] Cleared KOReader credentials\n", millis()); +} diff --git a/lib/KOReaderSync/KOReaderCredentialStore.h b/lib/KOReaderSync/KOReaderCredentialStore.h new file mode 100644 index 00000000..0d3332fa --- /dev/null +++ b/lib/KOReaderSync/KOReaderCredentialStore.h @@ -0,0 +1,49 @@ +#pragma once +#include + +/** + * Singleton class for storing KOReader sync credentials on the SD card. + * Credentials are stored in /sd/.crosspoint/koreader.bin with basic + * XOR obfuscation to prevent casual reading (not cryptographically secure). + */ +class KOReaderCredentialStore { + private: + static KOReaderCredentialStore instance; + std::string username; + std::string password; + + // Private constructor for singleton + KOReaderCredentialStore() = default; + + // XOR obfuscation (symmetric - same for encode/decode) + void obfuscate(std::string& data) const; + + public: + // Delete copy constructor and assignment + KOReaderCredentialStore(const KOReaderCredentialStore&) = delete; + KOReaderCredentialStore& operator=(const KOReaderCredentialStore&) = delete; + + // Get singleton instance + static KOReaderCredentialStore& getInstance() { return instance; } + + // Save/load from SD card + bool saveToFile() const; + bool loadFromFile(); + + // Credential management + void setCredentials(const std::string& user, const std::string& pass); + const std::string& getUsername() const { return username; } + const std::string& getPassword() const { return password; } + + // Get MD5 hash of password for API authentication + std::string getMd5Password() const; + + // Check if credentials are set + bool hasCredentials() const; + + // Clear credentials + void clearCredentials(); +}; + +// Helper macro to access credential store +#define KOREADER_STORE KOReaderCredentialStore::getInstance() diff --git a/lib/KOReaderSync/KOReaderDocumentId.cpp b/lib/KOReaderSync/KOReaderDocumentId.cpp new file mode 100644 index 00000000..f75d7c8f --- /dev/null +++ b/lib/KOReaderSync/KOReaderDocumentId.cpp @@ -0,0 +1,69 @@ +#include "KOReaderDocumentId.h" + +#include +#include +#include + +size_t KOReaderDocumentId::getOffset(int i) { + // Offset = 1024 << (2*i) + // For i = -1: 1024 >> 2 = 256 + // For i >= 0: 1024 << (2*i) + if (i < 0) { + return CHUNK_SIZE >> (-2 * i); + } + return CHUNK_SIZE << (2 * i); +} + +std::string KOReaderDocumentId::calculate(const std::string& filePath) { + FsFile file; + if (!SdMan.openFileForRead("KODoc", filePath, file)) { + Serial.printf("[%lu] [KODoc] Failed to open file: %s\n", millis(), filePath.c_str()); + return ""; + } + + const size_t fileSize = file.fileSize(); + Serial.printf("[%lu] [KODoc] Calculating hash for file: %s (size: %zu)\n", millis(), filePath.c_str(), fileSize); + + // Initialize MD5 builder + MD5Builder md5; + md5.begin(); + + // Buffer for reading chunks + uint8_t buffer[CHUNK_SIZE]; + size_t totalBytesRead = 0; + + // Read from each offset (i = -1 to 10) + for (int i = -1; i < OFFSET_COUNT - 1; i++) { + const size_t offset = getOffset(i); + + // Skip if offset is beyond file size + if (offset >= fileSize) { + continue; + } + + // Seek to offset + if (!file.seekSet(offset)) { + Serial.printf("[%lu] [KODoc] Failed to seek to offset %zu\n", millis(), offset); + continue; + } + + // Read up to CHUNK_SIZE bytes + const size_t bytesToRead = std::min(CHUNK_SIZE, fileSize - offset); + const size_t bytesRead = file.read(buffer, bytesToRead); + + if (bytesRead > 0) { + md5.add(buffer, bytesRead); + totalBytesRead += bytesRead; + } + } + + file.close(); + + // Calculate final hash + md5.calculate(); + std::string result = md5.toString().c_str(); + + Serial.printf("[%lu] [KODoc] Hash calculated: %s (from %zu bytes)\n", millis(), result.c_str(), totalBytesRead); + + return result; +} diff --git a/lib/KOReaderSync/KOReaderDocumentId.h b/lib/KOReaderSync/KOReaderDocumentId.h new file mode 100644 index 00000000..434b9b63 --- /dev/null +++ b/lib/KOReaderSync/KOReaderDocumentId.h @@ -0,0 +1,36 @@ +#pragma once +#include + +/** + * Calculate KOReader document ID (partial MD5 hash). + * + * KOReader identifies documents using a partial MD5 hash of the file content. + * The algorithm reads 1024 bytes at specific offsets and computes the MD5 hash + * of the concatenated data. + * + * Offsets are calculated as: 1024 << (2*i) for i = -1 to 10 + * Producing: 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304, + * 16777216, 67108864, 268435456, 1073741824 bytes + * + * If an offset is beyond the file size, it is skipped. + */ +class KOReaderDocumentId { + public: + /** + * Calculate the KOReader document hash for a file. + * + * @param filePath Path to the file (typically an EPUB) + * @return 32-character lowercase hex string, or empty string on failure + */ + static std::string calculate(const std::string& filePath); + + private: + // Size of each chunk to read at each offset + static constexpr size_t CHUNK_SIZE = 1024; + + // Number of offsets to try (i = -1 to 10, so 12 offsets) + static constexpr int OFFSET_COUNT = 12; + + // Calculate offset for index i: 1024 << (2*i) + static size_t getOffset(int i); +}; diff --git a/lib/KOReaderSync/KOReaderSyncClient.cpp b/lib/KOReaderSync/KOReaderSyncClient.cpp new file mode 100644 index 00000000..028957f8 --- /dev/null +++ b/lib/KOReaderSync/KOReaderSyncClient.cpp @@ -0,0 +1,177 @@ +#include "KOReaderSyncClient.h" + +#include +#include +#include +#include +#include + +#include "KOReaderCredentialStore.h" + +namespace { +// Base URL for KOReader sync server +constexpr char BASE_URL[] = "https://sync.koreader.rocks:443"; + +// Device identifier for CrossPoint reader +constexpr char DEVICE_NAME[] = "CrossPoint"; +constexpr char DEVICE_ID[] = "crosspoint-reader"; + +void addAuthHeaders(HTTPClient& http) { + http.addHeader("Accept", "application/vnd.koreader.v1+json"); + http.addHeader("x-auth-user", KOREADER_STORE.getUsername().c_str()); + http.addHeader("x-auth-key", KOREADER_STORE.getMd5Password().c_str()); +} +} // namespace + +KOReaderSyncClient::Error KOReaderSyncClient::authenticate() { + if (!KOREADER_STORE.hasCredentials()) { + Serial.printf("[%lu] [KOSync] No credentials configured\n", millis()); + return NO_CREDENTIALS; + } + + const std::unique_ptr client(new WiFiClientSecure); + client->setInsecure(); + HTTPClient http; + + std::string url = std::string(BASE_URL) + "/users/auth"; + Serial.printf("[%lu] [KOSync] Authenticating: %s\n", millis(), url.c_str()); + + http.begin(*client, url.c_str()); + addAuthHeaders(http); + + const int httpCode = http.GET(); + http.end(); + + Serial.printf("[%lu] [KOSync] Auth response: %d\n", millis(), httpCode); + + if (httpCode == 200) { + return OK; + } else if (httpCode == 401) { + return AUTH_FAILED; + } else if (httpCode < 0) { + return NETWORK_ERROR; + } + return SERVER_ERROR; +} + +KOReaderSyncClient::Error KOReaderSyncClient::getProgress(const std::string& documentHash, + KOReaderProgress& outProgress) { + if (!KOREADER_STORE.hasCredentials()) { + Serial.printf("[%lu] [KOSync] No credentials configured\n", millis()); + return NO_CREDENTIALS; + } + + const std::unique_ptr client(new WiFiClientSecure); + client->setInsecure(); + HTTPClient http; + + std::string url = std::string(BASE_URL) + "/syncs/progress/" + documentHash; + Serial.printf("[%lu] [KOSync] Getting progress: %s\n", millis(), url.c_str()); + + http.begin(*client, url.c_str()); + addAuthHeaders(http); + + const int httpCode = http.GET(); + + if (httpCode == 200) { + // Parse JSON response + JsonDocument doc; + const DeserializationError error = deserializeJson(doc, *client); + http.end(); + + if (error) { + Serial.printf("[%lu] [KOSync] JSON parse failed: %s\n", millis(), error.c_str()); + return JSON_ERROR; + } + + outProgress.document = documentHash; + outProgress.progress = doc["progress"].as(); + outProgress.percentage = doc["percentage"].as(); + outProgress.device = doc["device"].as(); + outProgress.deviceId = doc["device_id"].as(); + outProgress.timestamp = doc["timestamp"].as(); + + Serial.printf("[%lu] [KOSync] Got progress: %.2f%% at %s\n", millis(), outProgress.percentage * 100, + outProgress.progress.c_str()); + return OK; + } + + http.end(); + + Serial.printf("[%lu] [KOSync] Get progress response: %d\n", millis(), httpCode); + + if (httpCode == 401) { + return AUTH_FAILED; + } else if (httpCode == 404) { + return NOT_FOUND; + } else if (httpCode < 0) { + return NETWORK_ERROR; + } + return SERVER_ERROR; +} + +KOReaderSyncClient::Error KOReaderSyncClient::updateProgress(const KOReaderProgress& progress) { + if (!KOREADER_STORE.hasCredentials()) { + Serial.printf("[%lu] [KOSync] No credentials configured\n", millis()); + return NO_CREDENTIALS; + } + + const std::unique_ptr client(new WiFiClientSecure); + client->setInsecure(); + HTTPClient http; + + std::string url = std::string(BASE_URL) + "/syncs/progress"; + Serial.printf("[%lu] [KOSync] Updating progress: %s\n", millis(), url.c_str()); + + http.begin(*client, url.c_str()); + addAuthHeaders(http); + http.addHeader("Content-Type", "application/json"); + + // Build JSON body (timestamp not required per API spec) + JsonDocument doc; + doc["document"] = progress.document; + doc["progress"] = progress.progress; + doc["percentage"] = progress.percentage; + doc["device"] = DEVICE_NAME; + doc["device_id"] = DEVICE_ID; + + std::string body; + serializeJson(doc, body); + + Serial.printf("[%lu] [KOSync] Request body: %s\n", millis(), body.c_str()); + + const int httpCode = http.PUT(body.c_str()); + http.end(); + + Serial.printf("[%lu] [KOSync] Update progress response: %d\n", millis(), httpCode); + + if (httpCode == 200 || httpCode == 202) { + return OK; + } else if (httpCode == 401) { + return AUTH_FAILED; + } else if (httpCode < 0) { + return NETWORK_ERROR; + } + return SERVER_ERROR; +} + +const char* KOReaderSyncClient::errorString(Error error) { + switch (error) { + case OK: + return "Success"; + case NO_CREDENTIALS: + return "No credentials configured"; + case NETWORK_ERROR: + return "Network error"; + case AUTH_FAILED: + return "Authentication failed"; + case SERVER_ERROR: + return "Server error (try again later)"; + case JSON_ERROR: + return "JSON parse error"; + case NOT_FOUND: + return "No progress found"; + default: + return "Unknown error"; + } +} diff --git a/lib/KOReaderSync/KOReaderSyncClient.h b/lib/KOReaderSync/KOReaderSyncClient.h new file mode 100644 index 00000000..6a75843c --- /dev/null +++ b/lib/KOReaderSync/KOReaderSyncClient.h @@ -0,0 +1,67 @@ +#pragma once +#include + +/** + * Progress data from KOReader sync server. + */ +struct KOReaderProgress { + std::string document; // Document hash + std::string progress; // XPath-like progress string + float percentage; // Progress percentage (0.0 to 1.0) + std::string device; // Device name + std::string deviceId; // Device ID + int64_t timestamp; // Unix timestamp of last update +}; + +/** + * HTTP client for KOReader sync API. + * + * Base URL: https://sync.koreader.rocks:443/ + * + * API Endpoints: + * GET /users/auth - Authenticate (validate credentials) + * GET /syncs/progress/:document - Get progress for a document + * PUT /syncs/progress - Update progress for a document + * + * Authentication: + * x-auth-user: username + * x-auth-key: MD5 hash of password + */ +class KOReaderSyncClient { + public: + enum Error { + OK = 0, + NO_CREDENTIALS, + NETWORK_ERROR, + AUTH_FAILED, + SERVER_ERROR, + JSON_ERROR, + NOT_FOUND + }; + + /** + * Authenticate with the sync server (validate credentials). + * @return OK on success, error code on failure + */ + static Error authenticate(); + + /** + * Get reading progress for a document. + * @param documentHash The document hash (from KOReaderDocumentId) + * @param outProgress Output: the progress data + * @return OK on success, NOT_FOUND if no progress exists, error code on failure + */ + static Error getProgress(const std::string& documentHash, KOReaderProgress& outProgress); + + /** + * Update reading progress for a document. + * @param progress The progress data to upload + * @return OK on success, error code on failure + */ + static Error updateProgress(const KOReaderProgress& progress); + + /** + * Get human-readable error message. + */ + static const char* errorString(Error error); +}; diff --git a/lib/KOReaderSync/ProgressMapper.cpp b/lib/KOReaderSync/ProgressMapper.cpp new file mode 100644 index 00000000..f4c4f8d9 --- /dev/null +++ b/lib/KOReaderSync/ProgressMapper.cpp @@ -0,0 +1,125 @@ +#include "ProgressMapper.h" + +#include + +#include +#include + +KOReaderPosition ProgressMapper::toKOReader(const std::shared_ptr& epub, const CrossPointPosition& pos) { + KOReaderPosition result; + + // Calculate page progress within current spine item + float intraSpineProgress = 0.0f; + if (pos.totalPages > 0) { + intraSpineProgress = static_cast(pos.pageNumber) / static_cast(pos.totalPages); + } + + // Calculate overall book progress (0-100 from Epub, convert to 0.0-1.0) + const uint8_t progressPercent = epub->calculateProgress(pos.spineIndex, intraSpineProgress); + result.percentage = static_cast(progressPercent) / 100.0f; + + // Generate XPath with estimated paragraph position based on page + result.xpath = generateXPath(pos.spineIndex, pos.pageNumber, pos.totalPages); + + // Get chapter info for logging + const int tocIndex = epub->getTocIndexForSpineIndex(pos.spineIndex); + const std::string chapterName = (tocIndex >= 0) ? epub->getTocItem(tocIndex).title : "unknown"; + + Serial.printf("[%lu] [ProgressMapper] CrossPoint -> KOReader: chapter='%s', page=%d/%d -> %.2f%% at %s\n", millis(), + chapterName.c_str(), pos.pageNumber, pos.totalPages, result.percentage * 100, result.xpath.c_str()); + + return result; +} + +CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epub, const KOReaderPosition& koPos, + int totalPagesInSpine) { + CrossPointPosition result; + result.spineIndex = 0; + result.pageNumber = 0; + result.totalPages = totalPagesInSpine; + + const size_t bookSize = epub->getBookSize(); + if (bookSize == 0) { + Serial.printf("[%lu] [ProgressMapper] Book size is 0\n", millis()); + return result; + } + + // First, try to get spine index from XPath (DocFragment) + int xpathSpineIndex = parseDocFragmentIndex(koPos.xpath); + if (xpathSpineIndex >= 0 && xpathSpineIndex < epub->getSpineItemsCount()) { + result.spineIndex = xpathSpineIndex; + Serial.printf("[%lu] [ProgressMapper] Got spine index from XPath: %d\n", millis(), result.spineIndex); + } else { + // Fall back to percentage-based lookup + const size_t targetBytes = static_cast(bookSize * koPos.percentage); + + // Find the spine item that contains this byte position + for (int i = 0; i < epub->getSpineItemsCount(); i++) { + const size_t cumulativeSize = epub->getCumulativeSpineItemSize(i); + if (cumulativeSize >= targetBytes) { + result.spineIndex = i; + break; + } + } + Serial.printf("[%lu] [ProgressMapper] Got spine index from percentage (%.2f%%): %d\n", millis(), + koPos.percentage * 100, result.spineIndex); + } + + // Estimate page number within the spine item using percentage + if (totalPagesInSpine > 0 && result.spineIndex < epub->getSpineItemsCount()) { + // Calculate what percentage through the spine item we should be + const size_t prevCumSize = (result.spineIndex > 0) ? epub->getCumulativeSpineItemSize(result.spineIndex - 1) : 0; + const size_t currentCumSize = epub->getCumulativeSpineItemSize(result.spineIndex); + const size_t spineSize = currentCumSize - prevCumSize; + + if (spineSize > 0) { + const size_t targetBytes = static_cast(bookSize * koPos.percentage); + const size_t bytesIntoSpine = (targetBytes > prevCumSize) ? (targetBytes - prevCumSize) : 0; + const float intraSpineProgress = static_cast(bytesIntoSpine) / static_cast(spineSize); + + // Clamp to valid range + const float clampedProgress = std::max(0.0f, std::min(1.0f, intraSpineProgress)); + result.pageNumber = static_cast(clampedProgress * totalPagesInSpine); + + // Ensure page number is valid + result.pageNumber = std::max(0, std::min(result.pageNumber, totalPagesInSpine - 1)); + } + } + + Serial.printf("[%lu] [ProgressMapper] KOReader -> CrossPoint: %.2f%% at %s -> spine=%d, page=%d\n", millis(), + koPos.percentage * 100, koPos.xpath.c_str(), result.spineIndex, result.pageNumber); + + return result; +} + +std::string ProgressMapper::generateXPath(int spineIndex, int pageNumber, int totalPages) { + // KOReader uses 1-based DocFragment indices + // Estimate paragraph number based on page position + // Assume ~3 paragraphs per page on average for e-reader screens + constexpr int paragraphsPerPage = 3; + const int estimatedParagraph = (pageNumber * paragraphsPerPage) + 1; // 1-based + + return "/body/DocFragment[" + std::to_string(spineIndex + 1) + "]/body/p[" + std::to_string(estimatedParagraph) + "]"; +} + +int ProgressMapper::parseDocFragmentIndex(const std::string& xpath) { + // Look for DocFragment[N] pattern + const size_t start = xpath.find("DocFragment["); + if (start == std::string::npos) { + return -1; + } + + const size_t numStart = start + 12; // Length of "DocFragment[" + const size_t numEnd = xpath.find(']', numStart); + if (numEnd == std::string::npos) { + return -1; + } + + try { + const int docFragmentIndex = std::stoi(xpath.substr(numStart, numEnd - numStart)); + // KOReader uses 1-based indices, we use 0-based + return docFragmentIndex - 1; + } catch (...) { + return -1; + } +} diff --git a/lib/KOReaderSync/ProgressMapper.h b/lib/KOReaderSync/ProgressMapper.h new file mode 100644 index 00000000..d508ff01 --- /dev/null +++ b/lib/KOReaderSync/ProgressMapper.h @@ -0,0 +1,72 @@ +#pragma once +#include + +#include +#include + +/** + * CrossPoint position representation. + */ +struct CrossPointPosition { + int spineIndex; // Current spine item (chapter) index + int pageNumber; // Current page within the spine item + int totalPages; // Total pages in the current spine item +}; + +/** + * KOReader position representation. + */ +struct KOReaderPosition { + std::string xpath; // XPath-like progress string + float percentage; // Progress percentage (0.0 to 1.0) +}; + +/** + * Maps between CrossPoint and KOReader position formats. + * + * CrossPoint tracks position as (spineIndex, pageNumber). + * KOReader uses XPath-like strings + percentage. + * + * Since CrossPoint discards HTML structure during parsing, we generate + * synthetic XPath strings based on spine index, using percentage as the + * primary sync mechanism. + */ +class ProgressMapper { + public: + /** + * Convert CrossPoint position to KOReader format. + * + * @param epub The EPUB book + * @param pos CrossPoint position + * @return KOReader position + */ + static KOReaderPosition toKOReader(const std::shared_ptr& epub, const CrossPointPosition& pos); + + /** + * Convert KOReader position to CrossPoint format. + * + * Note: The returned pageNumber may be approximate since different + * rendering settings produce different page counts. + * + * @param epub The EPUB book + * @param koPos KOReader position + * @param totalPagesInSpine Total pages in the target spine item (for page estimation) + * @return CrossPoint position + */ + static CrossPointPosition toCrossPoint(const std::shared_ptr& epub, const KOReaderPosition& koPos, + int totalPagesInSpine = 0); + + private: + /** + * Generate XPath for KOReader compatibility. + * Format: /body/DocFragment[spineIndex+1]/body/p[estimatedParagraph] + * Paragraph is estimated based on page position within the chapter. + */ + static std::string generateXPath(int spineIndex, int pageNumber, int totalPages); + + /** + * Parse DocFragment index from XPath string. + * Returns -1 if not found. + */ + static int parseDocFragmentIndex(const std::string& xpath); +}; diff --git a/src/activities/reader/EpubReaderActivity.cpp b/src/activities/reader/EpubReaderActivity.cpp index d3cd5016..fb4cf6c2 100644 --- a/src/activities/reader/EpubReaderActivity.cpp +++ b/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); } diff --git a/src/activities/reader/EpubReaderChapterSelectionActivity.cpp b/src/activities/reader/EpubReaderChapterSelectionActivity.cpp index 63f1e5a7..49c3051f 100644 --- a/src/activities/reader/EpubReaderChapterSelectionActivity.cpp +++ b/src/activities/reader/EpubReaderChapterSelectionActivity.cpp @@ -2,14 +2,25 @@ #include +#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(); diff --git a/src/activities/reader/EpubReaderChapterSelectionActivity.h b/src/activities/reader/EpubReaderChapterSelectionActivity.h index cf3f1905..4bfef6da 100644 --- a/src/activities/reader/EpubReaderChapterSelectionActivity.h +++ b/src/activities/reader/EpubReaderChapterSelectionActivity.h @@ -6,36 +6,50 @@ #include -#include "../Activity.h" +#include "../ActivityWithSubactivity.h" -class EpubReaderChapterSelectionActivity final : public Activity { +class EpubReaderChapterSelectionActivity final : public ActivityWithSubactivity { std::shared_ptr 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 onGoBack; const std::function onSelectSpineIndex; + const std::function 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, const int currentSpineIndex, - const std::function& onGoBack, - const std::function& onSelectSpineIndex) - : Activity("EpubReaderChapterSelection", renderer, mappedInput), + const std::shared_ptr& epub, const std::string& epubPath, + const int currentSpineIndex, const int currentPage, + const int totalPagesInSpine, const std::function& onGoBack, + const std::function& onSelectSpineIndex, + const std::function& 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; diff --git a/src/activities/reader/KOReaderSyncActivity.cpp b/src/activities/reader/KOReaderSyncActivity.cpp new file mode 100644 index 00000000..f267e124 --- /dev/null +++ b/src/activities/reader/KOReaderSyncActivity.cpp @@ -0,0 +1,423 @@ +#include "KOReaderSyncActivity.h" + +#include +#include +#include + +#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(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(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; + } +} diff --git a/src/activities/reader/KOReaderSyncActivity.h b/src/activities/reader/KOReaderSyncActivity.h new file mode 100644 index 00000000..7f1948d1 --- /dev/null +++ b/src/activities/reader/KOReaderSyncActivity.h @@ -0,0 +1,95 @@ +#pragma once +#include +#include +#include +#include + +#include +#include + +#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; + using OnSyncCompleteCallback = std::function; + + explicit KOReaderSyncActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, + const std::shared_ptr& 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; + 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(); +}; diff --git a/src/activities/settings/KOReaderAuthActivity.cpp b/src/activities/settings/KOReaderAuthActivity.cpp new file mode 100644 index 00000000..8681812f --- /dev/null +++ b/src/activities/settings/KOReaderAuthActivity.cpp @@ -0,0 +1,167 @@ +#include "KOReaderAuthActivity.h" + +#include +#include + +#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(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(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(); + } + } +} diff --git a/src/activities/settings/KOReaderAuthActivity.h b/src/activities/settings/KOReaderAuthActivity.h new file mode 100644 index 00000000..a6ed0d3e --- /dev/null +++ b/src/activities/settings/KOReaderAuthActivity.h @@ -0,0 +1,44 @@ +#pragma once +#include +#include +#include + +#include + +#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& 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 onComplete; + + void onWifiSelectionComplete(bool success); + void performAuthentication(); + + static void taskTrampoline(void* param); + [[noreturn]] void displayTaskLoop(); + void render(); +}; diff --git a/src/activities/settings/SettingsActivity.cpp b/src/activities/settings/SettingsActivity.cpp index a242389d..979648a8 100644 --- a/src/activities/settings/SettingsActivity.cpp +++ b/src/activities/settings/SettingsActivity.cpp @@ -3,13 +3,16 @@ #include #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 diff --git a/src/main.cpp b/src/main.cpp index e81448bd..73de236c 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -10,6 +10,7 @@ #include "Battery.h" #include "CrossPointSettings.h" #include "CrossPointState.h" +#include "KOReaderCredentialStore.h" #include "MappedInputManager.h" #include "activities/boot_sleep/BootActivity.h" #include "activities/boot_sleep/SleepActivity.h" @@ -276,6 +277,7 @@ void setup() { } SETTINGS.loadFromFile(); + KOREADER_STORE.loadFromFile(); // verify power button press duration after we've read settings. verifyWakeupLongPress(); From a1be4bbfacf28936224456a6c763b5a99d133ee3 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sat, 3 Jan 2026 22:02:06 -0500 Subject: [PATCH 02/12] Apply clang-format fixes --- lib/KOReaderSync/KOReaderSyncClient.cpp | 3 ++- lib/KOReaderSync/KOReaderSyncClient.h | 22 ++++++------------- lib/KOReaderSync/ProgressMapper.h | 6 ++--- .../reader/KOReaderSyncActivity.cpp | 19 +++++++++------- 4 files changed, 23 insertions(+), 27 deletions(-) diff --git a/lib/KOReaderSync/KOReaderSyncClient.cpp b/lib/KOReaderSync/KOReaderSyncClient.cpp index 028957f8..8fa7fc34 100644 --- a/lib/KOReaderSync/KOReaderSyncClient.cpp +++ b/lib/KOReaderSync/KOReaderSyncClient.cpp @@ -1,9 +1,10 @@ #include "KOReaderSyncClient.h" #include -#include #include +#include #include + #include #include "KOReaderCredentialStore.h" diff --git a/lib/KOReaderSync/KOReaderSyncClient.h b/lib/KOReaderSync/KOReaderSyncClient.h index 6a75843c..a9bc5c09 100644 --- a/lib/KOReaderSync/KOReaderSyncClient.h +++ b/lib/KOReaderSync/KOReaderSyncClient.h @@ -5,12 +5,12 @@ * Progress data from KOReader sync server. */ struct KOReaderProgress { - std::string document; // Document hash - std::string progress; // XPath-like progress string - float percentage; // Progress percentage (0.0 to 1.0) - std::string device; // Device name - std::string deviceId; // Device ID - int64_t timestamp; // Unix timestamp of last update + std::string document; // Document hash + std::string progress; // XPath-like progress string + float percentage; // Progress percentage (0.0 to 1.0) + std::string device; // Device name + std::string deviceId; // Device ID + int64_t timestamp; // Unix timestamp of last update }; /** @@ -29,15 +29,7 @@ struct KOReaderProgress { */ class KOReaderSyncClient { public: - enum Error { - OK = 0, - NO_CREDENTIALS, - NETWORK_ERROR, - AUTH_FAILED, - SERVER_ERROR, - JSON_ERROR, - NOT_FOUND - }; + enum Error { OK = 0, NO_CREDENTIALS, NETWORK_ERROR, AUTH_FAILED, SERVER_ERROR, JSON_ERROR, NOT_FOUND }; /** * Authenticate with the sync server (validate credentials). diff --git a/lib/KOReaderSync/ProgressMapper.h b/lib/KOReaderSync/ProgressMapper.h index d508ff01..694549da 100644 --- a/lib/KOReaderSync/ProgressMapper.h +++ b/lib/KOReaderSync/ProgressMapper.h @@ -8,9 +8,9 @@ * CrossPoint position representation. */ struct CrossPointPosition { - int spineIndex; // Current spine item (chapter) index - int pageNumber; // Current page within the spine item - int totalPages; // Total pages in the current spine item + int spineIndex; // Current spine item (chapter) index + int pageNumber; // Current page within the spine item + int totalPages; // Total pages in the current spine item }; /** diff --git a/src/activities/reader/KOReaderSyncActivity.cpp b/src/activities/reader/KOReaderSyncActivity.cpp index f267e124..80bb3b27 100644 --- a/src/activities/reader/KOReaderSyncActivity.cpp +++ b/src/activities/reader/KOReaderSyncActivity.cpp @@ -207,8 +207,8 @@ void KOReaderSyncActivity::onEnter() { // Launch WiFi selection subactivity Serial.printf("[%lu] [KOSync] Launching WifiSelectionActivity...\n", millis()); - enterNewActivity( - new WifiSelectionActivity(renderer, mappedInput, [this](const bool connected) { onWifiSelectionComplete(connected); })); + enterNewActivity(new WifiSelectionActivity(renderer, mappedInput, + [this](const bool connected) { onWifiSelectionComplete(connected); })); } void KOReaderSyncActivity::onExit() { @@ -275,10 +275,11 @@ void KOReaderSyncActivity::render() { // 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)); + 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); @@ -286,7 +287,8 @@ void KOReaderSyncActivity::render() { 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); + 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()) { @@ -301,7 +303,8 @@ void KOReaderSyncActivity::render() { 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); + 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 From 70b856f86cd72a6ce9b32d256d62cdda54c263fe Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sat, 3 Jan 2026 22:23:23 -0500 Subject: [PATCH 03/12] Subscreen instead of conditional visibility --- .../settings/KOReaderSettingsActivity.cpp | 179 ++++++++++++++++++ .../settings/KOReaderSettingsActivity.h | 36 ++++ src/activities/settings/SettingsActivity.cpp | 143 ++------------ 3 files changed, 235 insertions(+), 123 deletions(-) create mode 100644 src/activities/settings/KOReaderSettingsActivity.cpp create mode 100644 src/activities/settings/KOReaderSettingsActivity.h diff --git a/src/activities/settings/KOReaderSettingsActivity.cpp b/src/activities/settings/KOReaderSettingsActivity.cpp new file mode 100644 index 00000000..71e608bb --- /dev/null +++ b/src/activities/settings/KOReaderSettingsActivity.cpp @@ -0,0 +1,179 @@ +#include "KOReaderSettingsActivity.h" + +#include +#include + +#include "KOReaderAuthActivity.h" +#include "KOReaderCredentialStore.h" +#include "MappedInputManager.h" +#include "activities/util/KeyboardEntryActivity.h" +#include "fontIds.h" + +namespace { +constexpr int MENU_ITEMS = 3; +const char* menuNames[MENU_ITEMS] = {"Username", "Password", "Authenticate"}; +} // namespace + +void KOReaderSettingsActivity::taskTrampoline(void* param) { + auto* self = static_cast(param); + self->displayTaskLoop(); +} + +void KOReaderSettingsActivity::onEnter() { + ActivityWithSubactivity::onEnter(); + + renderingMutex = xSemaphoreCreateMutex(); + selectedIndex = 0; + updateRequired = true; + + xTaskCreate(&KOReaderSettingsActivity::taskTrampoline, "KOReaderSettingsTask", + 4096, // Stack size + this, // Parameters + 1, // Priority + &displayTaskHandle // Task handle + ); +} + +void KOReaderSettingsActivity::onExit() { + ActivityWithSubactivity::onExit(); + + xSemaphoreTake(renderingMutex, portMAX_DELAY); + if (displayTaskHandle) { + vTaskDelete(displayTaskHandle); + displayTaskHandle = nullptr; + } + vSemaphoreDelete(renderingMutex); + renderingMutex = nullptr; +} + +void KOReaderSettingsActivity::loop() { + if (subActivity) { + subActivity->loop(); + return; + } + + if (mappedInput.wasPressed(MappedInputManager::Button::Back)) { + onBack(); + return; + } + + if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) { + handleSelection(); + return; + } + + if (mappedInput.wasPressed(MappedInputManager::Button::Up) || + mappedInput.wasPressed(MappedInputManager::Button::Left)) { + selectedIndex = (selectedIndex + MENU_ITEMS - 1) % MENU_ITEMS; + updateRequired = true; + } else if (mappedInput.wasPressed(MappedInputManager::Button::Down) || + mappedInput.wasPressed(MappedInputManager::Button::Right)) { + selectedIndex = (selectedIndex + 1) % MENU_ITEMS; + updateRequired = true; + } +} + +void KOReaderSettingsActivity::handleSelection() { + xSemaphoreTake(renderingMutex, portMAX_DELAY); + + if (selectedIndex == 0) { + // Username + 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; + })); + } else if (selectedIndex == 1) { + // Password + exitActivity(); + enterNewActivity(new KeyboardEntryActivity( + renderer, mappedInput, "KOReader Password", KOREADER_STORE.getPassword(), 10, + 64, // maxLength + false, // show characters + [this](const std::string& password) { + KOREADER_STORE.setCredentials(KOREADER_STORE.getUsername(), password); + KOREADER_STORE.saveToFile(); + exitActivity(); + updateRequired = true; + }, + [this]() { + exitActivity(); + updateRequired = true; + })); + } else if (selectedIndex == 2) { + // Authenticate + if (!KOREADER_STORE.hasCredentials()) { + // Can't authenticate without credentials - just show message briefly + xSemaphoreGive(renderingMutex); + return; + } + exitActivity(); + enterNewActivity(new KOReaderAuthActivity(renderer, mappedInput, [this] { + exitActivity(); + updateRequired = true; + })); + } + + xSemaphoreGive(renderingMutex); +} + +void KOReaderSettingsActivity::displayTaskLoop() { + while (true) { + if (updateRequired && !subActivity) { + updateRequired = false; + xSemaphoreTake(renderingMutex, portMAX_DELAY); + render(); + xSemaphoreGive(renderingMutex); + } + vTaskDelay(10 / portTICK_PERIOD_MS); + } +} + +void KOReaderSettingsActivity::render() { + renderer.clearScreen(); + + const auto pageWidth = renderer.getScreenWidth(); + + // Draw header + renderer.drawCenteredText(UI_12_FONT_ID, 15, "KOReader Sync", true, EpdFontFamily::BOLD); + + // Draw selection highlight + renderer.fillRect(0, 60 + selectedIndex * 30 - 2, pageWidth - 1, 30); + + // Draw menu items + for (int i = 0; i < MENU_ITEMS; i++) { + const int settingY = 60 + i * 30; + const bool isSelected = (i == selectedIndex); + + renderer.drawText(UI_10_FONT_ID, 20, settingY, menuNames[i], !isSelected); + + // Draw status for username/password + const char* status = ""; + if (i == 0) { + status = KOREADER_STORE.getUsername().empty() ? "[Not Set]" : "[Set]"; + } else if (i == 1) { + status = KOREADER_STORE.getPassword().empty() ? "[Not Set]" : "[Set]"; + } else if (i == 2) { + status = KOREADER_STORE.hasCredentials() ? "" : "[Set credentials first]"; + } + + const auto width = renderer.getTextWidth(UI_10_FONT_ID, status); + renderer.drawText(UI_10_FONT_ID, pageWidth - 20 - width, settingY, status, !isSelected); + } + + // Draw button hints + const auto labels = mappedInput.mapLabels("« Back", "Select", "", ""); + renderer.drawButtonHints(UI_10_FONT_ID, labels.btn1, labels.btn2, labels.btn3, labels.btn4); + + renderer.displayBuffer(); +} diff --git a/src/activities/settings/KOReaderSettingsActivity.h b/src/activities/settings/KOReaderSettingsActivity.h new file mode 100644 index 00000000..2bedf034 --- /dev/null +++ b/src/activities/settings/KOReaderSettingsActivity.h @@ -0,0 +1,36 @@ +#pragma once +#include +#include +#include + +#include + +#include "activities/ActivityWithSubactivity.h" + +/** + * Submenu for KOReader Sync settings. + * Shows username, password, and authenticate options. + */ +class KOReaderSettingsActivity final : public ActivityWithSubactivity { + public: + explicit KOReaderSettingsActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, + const std::function& onBack) + : ActivityWithSubactivity("KOReaderSettings", renderer, mappedInput), onBack(onBack) {} + + void onEnter() override; + void onExit() override; + void loop() override; + + private: + TaskHandle_t displayTaskHandle = nullptr; + SemaphoreHandle_t renderingMutex = nullptr; + bool updateRequired = false; + + int selectedIndex = 0; + const std::function onBack; + + static void taskTrampoline(void* param); + [[noreturn]] void displayTaskLoop(); + void render(); + void handleSelection(); +}; diff --git a/src/activities/settings/SettingsActivity.cpp b/src/activities/settings/SettingsActivity.cpp index 979648a8..9bc65bfb 100644 --- a/src/activities/settings/SettingsActivity.cpp +++ b/src/activities/settings/SettingsActivity.cpp @@ -1,18 +1,17 @@ #include "SettingsActivity.h" #include +#include #include "CrossPointSettings.h" -#include "KOReaderAuthActivity.h" -#include "KOReaderCredentialStore.h" +#include "KOReaderSettingsActivity.h" #include "MappedInputManager.h" #include "OtaUpdateActivity.h" -#include "activities/util/KeyboardEntryActivity.h" #include "fontIds.h" // Define the static settings list namespace { -constexpr int settingsCount = 18; +constexpr int settingsCount = 15; const SettingInfo settingsList[settingsCount] = { // Should match with SLEEP_SCREEN_MODE {"Sleep Screen", SettingType::ENUM, &CrossPointSettings::sleepScreen, {"Dark", "Light", "Custom", "Cover"}}, @@ -49,56 +48,9 @@ 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, {}}, + {"KOReader Sync", 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) { @@ -157,17 +109,16 @@ void SettingsActivity::loop() { return; } - // Handle navigation (using visible settings count) - const int visibleCount = getVisibleSettingsCount(); + // Handle navigation if (mappedInput.wasPressed(MappedInputManager::Button::Up) || mappedInput.wasPressed(MappedInputManager::Button::Left)) { // Move selection up (with wrap-around) - selectedSettingIndex = (selectedSettingIndex > 0) ? (selectedSettingIndex - 1) : (visibleCount - 1); + selectedSettingIndex = (selectedSettingIndex > 0) ? (selectedSettingIndex - 1) : (settingsCount - 1); updateRequired = true; } else if (mappedInput.wasPressed(MappedInputManager::Button::Down) || mappedInput.wasPressed(MappedInputManager::Button::Right)) { // Move selection down - if (selectedSettingIndex < visibleCount - 1) { + if (selectedSettingIndex < settingsCount - 1) { selectedSettingIndex++; updateRequired = true; } @@ -175,13 +126,11 @@ void SettingsActivity::loop() { } void SettingsActivity::toggleCurrentSetting() { - // Convert visible index to actual index - const int actualIndex = visibleToActualIndex(selectedSettingIndex); - if (actualIndex < 0 || actualIndex >= settingsCount) { + if (selectedSettingIndex < 0 || selectedSettingIndex >= settingsCount) { return; } - const auto& setting = settingsList[actualIndex]; + const auto& setting = settingsList[selectedSettingIndex]; if (setting.type == SettingType::TOGGLE && setting.valuePtr != nullptr) { // Toggle the boolean value using the member pointer @@ -191,7 +140,7 @@ void SettingsActivity::toggleCurrentSetting() { const uint8_t currentValue = SETTINGS.*(setting.valuePtr); SETTINGS.*(setting.valuePtr) = (currentValue + 1) % static_cast(setting.enumValues.size()); } else if (setting.type == SettingType::ACTION) { - if (std::string(setting.name) == "Check for updates") { + if (strcmp(setting.name, "Check for updates") == 0) { xSemaphoreTake(renderingMutex, portMAX_DELAY); exitActivity(); enterNewActivity(new OtaUpdateActivity(renderer, mappedInput, [this] { @@ -199,50 +148,10 @@ void SettingsActivity::toggleCurrentSetting() { updateRequired = true; })); xSemaphoreGive(renderingMutex); - } else if (std::string(setting.name) == "KOReader Username") { + } else if (strcmp(setting.name, "KOReader Sync") == 0) { 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] { + enterNewActivity(new KOReaderSettingsActivity(renderer, mappedInput, [this] { exitActivity(); updateRequired = true; })); @@ -281,39 +190,27 @@ void SettingsActivity::render() const { // Draw selection highlight renderer.fillRect(0, 60 + selectedSettingIndex * 30 - 2, pageWidth - 1, 30); - // Draw only visible settings - int visibleIndex = 0; + // Draw all settings for (int i = 0; i < settingsCount; i++) { - if (!isSettingVisible(i)) { - continue; - } - - const int settingY = 60 + visibleIndex * 30; // 30 pixels between settings - const bool isSelected = (visibleIndex == selectedSettingIndex); + const int settingY = 60 + i * 30; // 30 pixels between settings + const bool isSelected = (i == selectedSettingIndex); // Draw setting name renderer.drawText(UI_10_FONT_ID, 20, settingY, settingsList[i].name, !isSelected); // Draw value based on setting type - std::string valueText = ""; + std::string valueText; if (settingsList[i].type == SettingType::TOGGLE && settingsList[i].valuePtr != nullptr) { const bool value = SETTINGS.*(settingsList[i].valuePtr); valueText = value ? "ON" : "OFF"; } 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(), !isSelected); - - visibleIndex++; + if (!valueText.empty()) { + 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(), !isSelected); + } } // Draw version text above button hints From 38de0532664cc7728aafe3dd2f2468bba9babf04 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sat, 3 Jan 2026 22:23:41 -0500 Subject: [PATCH 04/12] Apply clang-format fixes --- src/activities/settings/KOReaderSettingsActivity.cpp | 1 + src/activities/settings/SettingsActivity.cpp | 1 + 2 files changed, 2 insertions(+) diff --git a/src/activities/settings/KOReaderSettingsActivity.cpp b/src/activities/settings/KOReaderSettingsActivity.cpp index 71e608bb..9a6c0f98 100644 --- a/src/activities/settings/KOReaderSettingsActivity.cpp +++ b/src/activities/settings/KOReaderSettingsActivity.cpp @@ -1,6 +1,7 @@ #include "KOReaderSettingsActivity.h" #include + #include #include "KOReaderAuthActivity.h" diff --git a/src/activities/settings/SettingsActivity.cpp b/src/activities/settings/SettingsActivity.cpp index 9bc65bfb..3d960773 100644 --- a/src/activities/settings/SettingsActivity.cpp +++ b/src/activities/settings/SettingsActivity.cpp @@ -1,6 +1,7 @@ #include "SettingsActivity.h" #include + #include #include "CrossPointSettings.h" From d75d911c1b8fc6cbecab604cdf86efe25a7820d1 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sun, 4 Jan 2026 00:55:14 -0500 Subject: [PATCH 05/12] Fixing something CI failed at --- src/activities/reader/KOReaderSyncActivity.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/activities/reader/KOReaderSyncActivity.h b/src/activities/reader/KOReaderSyncActivity.h index 7f1948d1..dd61ffa5 100644 --- a/src/activities/reader/KOReaderSyncActivity.h +++ b/src/activities/reader/KOReaderSyncActivity.h @@ -36,6 +36,9 @@ class KOReaderSyncActivity final : public ActivityWithSubactivity { currentSpineIndex(currentSpineIndex), currentPage(currentPage), totalPagesInSpine(totalPagesInSpine), + remoteProgress{}, + remotePosition{}, + localProgress{}, onCancel(std::move(onCancel)), onSyncComplete(std::move(onSyncComplete)) {} From ae34fc76e1ecabad909cff5a1a24d689db10523c Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sun, 4 Jan 2026 23:02:48 -0500 Subject: [PATCH 06/12] support for 3rd party server urls --- lib/KOReaderSync/KOReaderCredentialStore.cpp | 45 +++++++++++++++++-- lib/KOReaderSync/KOReaderCredentialStore.h | 8 ++++ lib/KOReaderSync/KOReaderSyncClient.cpp | 9 ++-- .../settings/KOReaderSettingsActivity.cpp | 25 +++++++++-- 4 files changed, 75 insertions(+), 12 deletions(-) diff --git a/lib/KOReaderSync/KOReaderCredentialStore.cpp b/lib/KOReaderSync/KOReaderCredentialStore.cpp index b9cbc564..6eb37ac8 100644 --- a/lib/KOReaderSync/KOReaderCredentialStore.cpp +++ b/lib/KOReaderSync/KOReaderCredentialStore.cpp @@ -15,6 +15,9 @@ constexpr uint8_t KOREADER_FILE_VERSION = 1; // KOReader credentials file path constexpr char KOREADER_FILE[] = "/.crosspoint/koreader.bin"; +// Default sync server URL +constexpr char DEFAULT_SERVER_URL[] = "https://sync.koreader.rocks:443"; + // Obfuscation key - "KOReader" in ASCII // This is NOT cryptographic security, just prevents casual file reading constexpr uint8_t OBFUSCATION_KEY[] = {0x4B, 0x4F, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72}; @@ -48,6 +51,9 @@ bool KOReaderCredentialStore::saveToFile() const { obfuscate(obfuscatedPwd); serialization::writeString(file, obfuscatedPwd); + // Write server URL + serialization::writeString(file, serverUrl); + file.close(); Serial.printf("[%lu] [KRS] Saved KOReader credentials to file\n", millis()); return true; @@ -70,11 +76,26 @@ bool KOReaderCredentialStore::loadFromFile() { } // Read username - serialization::readString(file, username); + if (file.available()) { + serialization::readString(file, username); + } else { + username.clear(); + } // Read and deobfuscate password - serialization::readString(file, password); - obfuscate(password); // XOR is symmetric, so same function deobfuscates + if (file.available()) { + serialization::readString(file, password); + obfuscate(password); // XOR is symmetric, so same function deobfuscates + } else { + password.clear(); + } + + // Read server URL + if (file.available()) { + serialization::readString(file, serverUrl); + } else { + serverUrl.clear(); + } file.close(); Serial.printf("[%lu] [KRS] Loaded KOReader credentials for user: %s\n", millis(), username.c_str()); @@ -109,3 +130,21 @@ void KOReaderCredentialStore::clearCredentials() { saveToFile(); Serial.printf("[%lu] [KRS] Cleared KOReader credentials\n", millis()); } + +void KOReaderCredentialStore::setServerUrl(const std::string& url) { + serverUrl = url; + Serial.printf("[%lu] [KRS] Set server URL: %s\n", millis(), url.empty() ? "(default)" : url.c_str()); +} + +std::string KOReaderCredentialStore::getBaseUrl() const { + if (serverUrl.empty()) { + return DEFAULT_SERVER_URL; + } + + // Normalize URL: add https:// if no protocol specified + if (serverUrl.find("://") == std::string::npos) { + return "https://" + serverUrl; + } + + return serverUrl; +} diff --git a/lib/KOReaderSync/KOReaderCredentialStore.h b/lib/KOReaderSync/KOReaderCredentialStore.h index 0d3332fa..488f23b0 100644 --- a/lib/KOReaderSync/KOReaderCredentialStore.h +++ b/lib/KOReaderSync/KOReaderCredentialStore.h @@ -11,6 +11,7 @@ class KOReaderCredentialStore { static KOReaderCredentialStore instance; std::string username; std::string password; + std::string serverUrl; // Custom sync server URL (empty = default) // Private constructor for singleton KOReaderCredentialStore() = default; @@ -43,6 +44,13 @@ class KOReaderCredentialStore { // Clear credentials void clearCredentials(); + + // Server URL management + void setServerUrl(const std::string& url); + const std::string& getServerUrl() const { return serverUrl; } + + // Get base URL for API calls (with https:// normalization, falls back to default) + std::string getBaseUrl() const; }; // Helper macro to access credential store diff --git a/lib/KOReaderSync/KOReaderSyncClient.cpp b/lib/KOReaderSync/KOReaderSyncClient.cpp index 8fa7fc34..91515cd9 100644 --- a/lib/KOReaderSync/KOReaderSyncClient.cpp +++ b/lib/KOReaderSync/KOReaderSyncClient.cpp @@ -10,9 +10,6 @@ #include "KOReaderCredentialStore.h" namespace { -// Base URL for KOReader sync server -constexpr char BASE_URL[] = "https://sync.koreader.rocks:443"; - // Device identifier for CrossPoint reader constexpr char DEVICE_NAME[] = "CrossPoint"; constexpr char DEVICE_ID[] = "crosspoint-reader"; @@ -34,7 +31,7 @@ KOReaderSyncClient::Error KOReaderSyncClient::authenticate() { client->setInsecure(); HTTPClient http; - std::string url = std::string(BASE_URL) + "/users/auth"; + std::string url = KOREADER_STORE.getBaseUrl() + "/users/auth"; Serial.printf("[%lu] [KOSync] Authenticating: %s\n", millis(), url.c_str()); http.begin(*client, url.c_str()); @@ -66,7 +63,7 @@ KOReaderSyncClient::Error KOReaderSyncClient::getProgress(const std::string& doc client->setInsecure(); HTTPClient http; - std::string url = std::string(BASE_URL) + "/syncs/progress/" + documentHash; + std::string url = KOREADER_STORE.getBaseUrl() + "/syncs/progress/" + documentHash; Serial.printf("[%lu] [KOSync] Getting progress: %s\n", millis(), url.c_str()); http.begin(*client, url.c_str()); @@ -121,7 +118,7 @@ KOReaderSyncClient::Error KOReaderSyncClient::updateProgress(const KOReaderProgr client->setInsecure(); HTTPClient http; - std::string url = std::string(BASE_URL) + "/syncs/progress"; + std::string url = KOREADER_STORE.getBaseUrl() + "/syncs/progress"; Serial.printf("[%lu] [KOSync] Updating progress: %s\n", millis(), url.c_str()); http.begin(*client, url.c_str()); diff --git a/src/activities/settings/KOReaderSettingsActivity.cpp b/src/activities/settings/KOReaderSettingsActivity.cpp index 9a6c0f98..4b16e966 100644 --- a/src/activities/settings/KOReaderSettingsActivity.cpp +++ b/src/activities/settings/KOReaderSettingsActivity.cpp @@ -11,8 +11,8 @@ #include "fontIds.h" namespace { -constexpr int MENU_ITEMS = 3; -const char* menuNames[MENU_ITEMS] = {"Username", "Password", "Authenticate"}; +constexpr int MENU_ITEMS = 4; +const char* menuNames[MENU_ITEMS] = {"Username", "Password", "Sync Server URL", "Authenticate"}; } // namespace void KOReaderSettingsActivity::taskTrampoline(void* param) { @@ -112,6 +112,23 @@ void KOReaderSettingsActivity::handleSelection() { updateRequired = true; })); } else if (selectedIndex == 2) { + // Sync Server URL + exitActivity(); + enterNewActivity(new KeyboardEntryActivity( + renderer, mappedInput, "Sync Server URL", KOREADER_STORE.getServerUrl(), 10, + 128, // maxLength - URLs can be long + false, // not password + [this](const std::string& url) { + KOREADER_STORE.setServerUrl(url); + KOREADER_STORE.saveToFile(); + exitActivity(); + updateRequired = true; + }, + [this]() { + exitActivity(); + updateRequired = true; + })); + } else if (selectedIndex == 3) { // Authenticate if (!KOREADER_STORE.hasCredentials()) { // Can't authenticate without credentials - just show message briefly @@ -158,13 +175,15 @@ void KOReaderSettingsActivity::render() { renderer.drawText(UI_10_FONT_ID, 20, settingY, menuNames[i], !isSelected); - // Draw status for username/password + // Draw status for each item const char* status = ""; if (i == 0) { status = KOREADER_STORE.getUsername().empty() ? "[Not Set]" : "[Set]"; } else if (i == 1) { status = KOREADER_STORE.getPassword().empty() ? "[Not Set]" : "[Set]"; } else if (i == 2) { + status = KOREADER_STORE.getServerUrl().empty() ? "[Not Set]" : "[Set]"; + } else if (i == 3) { status = KOREADER_STORE.hasCredentials() ? "" : "[Set credentials first]"; } From 77bb97339d1b72d440d59690ffee2aa1ac57544b Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sun, 4 Jan 2026 23:48:42 -0500 Subject: [PATCH 07/12] Add a setting for document matching method --- lib/KOReaderSync/KOReaderCredentialStore.cpp | 18 ++++++++ lib/KOReaderSync/KOReaderCredentialStore.h | 14 +++++- lib/KOReaderSync/KOReaderDocumentId.cpp | 27 +++++++++++ lib/KOReaderSync/KOReaderDocumentId.h | 11 ++++- .../EpubReaderChapterSelectionActivity.cpp | 45 +++++++++++-------- .../EpubReaderChapterSelectionActivity.h | 11 ++++- .../reader/KOReaderSyncActivity.cpp | 19 ++++++-- .../settings/KOReaderSettingsActivity.cpp | 14 +++++- 8 files changed, 133 insertions(+), 26 deletions(-) diff --git a/lib/KOReaderSync/KOReaderCredentialStore.cpp b/lib/KOReaderSync/KOReaderCredentialStore.cpp index 6eb37ac8..f73cc325 100644 --- a/lib/KOReaderSync/KOReaderCredentialStore.cpp +++ b/lib/KOReaderSync/KOReaderCredentialStore.cpp @@ -54,6 +54,9 @@ bool KOReaderCredentialStore::saveToFile() const { // Write server URL serialization::writeString(file, serverUrl); + // Write match method + serialization::writePod(file, static_cast(matchMethod)); + file.close(); Serial.printf("[%lu] [KRS] Saved KOReader credentials to file\n", millis()); return true; @@ -97,6 +100,15 @@ bool KOReaderCredentialStore::loadFromFile() { serverUrl.clear(); } + // Read match method + if (file.available()) { + uint8_t method; + serialization::readPod(file, method); + matchMethod = static_cast(method); + } else { + matchMethod = DocumentMatchMethod::FILENAME; + } + file.close(); Serial.printf("[%lu] [KRS] Loaded KOReader credentials for user: %s\n", millis(), username.c_str()); return true; @@ -148,3 +160,9 @@ std::string KOReaderCredentialStore::getBaseUrl() const { return serverUrl; } + +void KOReaderCredentialStore::setMatchMethod(DocumentMatchMethod method) { + matchMethod = method; + Serial.printf("[%lu] [KRS] Set match method: %s\n", millis(), + method == DocumentMatchMethod::FILENAME ? "Filename" : "Binary"); +} diff --git a/lib/KOReaderSync/KOReaderCredentialStore.h b/lib/KOReaderSync/KOReaderCredentialStore.h index 488f23b0..d1709660 100644 --- a/lib/KOReaderSync/KOReaderCredentialStore.h +++ b/lib/KOReaderSync/KOReaderCredentialStore.h @@ -1,6 +1,13 @@ #pragma once +#include #include +// Document matching method for KOReader sync +enum class DocumentMatchMethod : uint8_t { + FILENAME = 0, // Match by filename (simpler, works across different file sources) + BINARY = 1, // Match by partial MD5 of file content (more accurate, but files must be identical) +}; + /** * Singleton class for storing KOReader sync credentials on the SD card. * Credentials are stored in /sd/.crosspoint/koreader.bin with basic @@ -11,7 +18,8 @@ class KOReaderCredentialStore { static KOReaderCredentialStore instance; std::string username; std::string password; - std::string serverUrl; // Custom sync server URL (empty = default) + std::string serverUrl; // Custom sync server URL (empty = default) + DocumentMatchMethod matchMethod = DocumentMatchMethod::FILENAME; // Default to filename for compatibility // Private constructor for singleton KOReaderCredentialStore() = default; @@ -51,6 +59,10 @@ class KOReaderCredentialStore { // Get base URL for API calls (with https:// normalization, falls back to default) std::string getBaseUrl() const; + + // Document matching method + void setMatchMethod(DocumentMatchMethod method); + DocumentMatchMethod getMatchMethod() const { return matchMethod; } }; // Helper macro to access credential store diff --git a/lib/KOReaderSync/KOReaderDocumentId.cpp b/lib/KOReaderSync/KOReaderDocumentId.cpp index f75d7c8f..2c52464c 100644 --- a/lib/KOReaderSync/KOReaderDocumentId.cpp +++ b/lib/KOReaderSync/KOReaderDocumentId.cpp @@ -4,6 +4,33 @@ #include #include +namespace { +// Extract filename from path (everything after last '/') +std::string getFilename(const std::string& path) { + const size_t pos = path.rfind('/'); + if (pos == std::string::npos) { + return path; + } + return path.substr(pos + 1); +} +} // namespace + +std::string KOReaderDocumentId::calculateFromFilename(const std::string& filePath) { + const std::string filename = getFilename(filePath); + if (filename.empty()) { + return ""; + } + + MD5Builder md5; + md5.begin(); + md5.add(filename.c_str()); + md5.calculate(); + + std::string result = md5.toString().c_str(); + Serial.printf("[%lu] [KODoc] Filename hash: %s (from '%s')\n", millis(), result.c_str(), filename.c_str()); + return result; +} + size_t KOReaderDocumentId::getOffset(int i) { // Offset = 1024 << (2*i) // For i = -1: 1024 >> 2 = 256 diff --git a/lib/KOReaderSync/KOReaderDocumentId.h b/lib/KOReaderSync/KOReaderDocumentId.h index 434b9b63..2b6189e2 100644 --- a/lib/KOReaderSync/KOReaderDocumentId.h +++ b/lib/KOReaderSync/KOReaderDocumentId.h @@ -17,13 +17,22 @@ class KOReaderDocumentId { public: /** - * Calculate the KOReader document hash for a file. + * Calculate the KOReader document hash for a file (binary/content-based). * * @param filePath Path to the file (typically an EPUB) * @return 32-character lowercase hex string, or empty string on failure */ static std::string calculate(const std::string& filePath); + /** + * Calculate document hash from filename only (filename-based sync mode). + * This is simpler and works when files have the same name across devices. + * + * @param filePath Path to the file (only the filename portion is used) + * @return 32-character lowercase hex MD5 of the filename + */ + static std::string calculateFromFilename(const std::string& filePath); + private: // Size of each chunk to read at each offset static constexpr size_t CHUNK_SIZE = 1024; diff --git a/src/activities/reader/EpubReaderChapterSelectionActivity.cpp b/src/activities/reader/EpubReaderChapterSelectionActivity.cpp index 49c3051f..d20c1645 100644 --- a/src/activities/reader/EpubReaderChapterSelectionActivity.cpp +++ b/src/activities/reader/EpubReaderChapterSelectionActivity.cpp @@ -10,15 +10,26 @@ 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 +bool EpubReaderChapterSelectionActivity::hasSyncOption() const { return KOREADER_STORE.hasCredentials(); } + 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; + // 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 { @@ -52,12 +63,12 @@ void EpubReaderChapterSelectionActivity::onEnter() { renderingMutex = xSemaphoreCreateMutex(); // Account for sync option offset when finding current TOC index - const int syncOffset = KOREADER_STORE.hasCredentials() ? 1 : 0; + const int syncOffset = hasSyncOption() ? 1 : 0; selectorIndex = epub->getTocIndexForSpineIndex(currentSpineIndex); if (selectorIndex == -1) { selectorIndex = 0; } - selectorIndex += syncOffset; // Offset for sync option + selectorIndex += syncOffset; // Offset for top sync option // Trigger first update updateRequired = true; @@ -114,17 +125,16 @@ 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)) { - // Check if sync option is selected - if (syncOffset > 0 && selectorIndex == SYNC_ITEM_INDEX) { + // Check if sync option is selected (first or last item) + if (isSyncItem(selectorIndex)) { launchSyncActivity(); return; } - // Get TOC index (account for sync offset) - const int tocIndex = selectorIndex - syncOffset; + // Get TOC index (account for top sync offset) + const int tocIndex = tocIndexFromItemIndex(selectorIndex); const auto newSpineIndex = epub->getSpineIndexForTocIndex(tocIndex); if (newSpineIndex == -1) { onGoBack(); @@ -168,7 +178,6 @@ 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); @@ -181,12 +190,12 @@ void EpubReaderChapterSelectionActivity::renderScreen() { const int displayY = 60 + (itemIndex % pageItems) * 30; const bool isSelected = (itemIndex == selectorIndex); - if (syncOffset > 0 && itemIndex == SYNC_ITEM_INDEX) { - // Draw sync option + if (isSyncItem(itemIndex)) { + // Draw sync option (at top or bottom) renderer.drawText(UI_10_FONT_ID, 20, displayY, ">> Sync Progress", !isSelected); } else { - // Draw TOC item (account for sync offset) - const int tocIndex = itemIndex - syncOffset; + // Draw TOC item (account for top sync offset) + const int tocIndex = tocIndexFromItemIndex(itemIndex); auto item = epub->getTocItem(tocIndex); renderer.drawText(UI_10_FONT_ID, 20 + (item.level - 1) * 15, displayY, item.title.c_str(), !isSelected); } diff --git a/src/activities/reader/EpubReaderChapterSelectionActivity.h b/src/activities/reader/EpubReaderChapterSelectionActivity.h index 4bfef6da..255f0cea 100644 --- a/src/activities/reader/EpubReaderChapterSelectionActivity.h +++ b/src/activities/reader/EpubReaderChapterSelectionActivity.h @@ -26,9 +26,18 @@ class EpubReaderChapterSelectionActivity final : public ActivityWithSubactivity // This adapts automatically when switching between portrait and landscape. int getPageItems() const; - // Total items including the sync option + // 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; + static void taskTrampoline(void* param); [[noreturn]] void displayTaskLoop(); void renderScreen(); diff --git a/src/activities/reader/KOReaderSyncActivity.cpp b/src/activities/reader/KOReaderSyncActivity.cpp index 80bb3b27..59ae4eed 100644 --- a/src/activities/reader/KOReaderSyncActivity.cpp +++ b/src/activities/reader/KOReaderSyncActivity.cpp @@ -12,6 +12,11 @@ namespace { void syncTimeWithNTP() { + // Stop SNTP if already running (can't reconfigure while running) + if (esp_sntp_enabled()) { + esp_sntp_stop(); + } + // Configure SNTP esp_sntp_setoperatingmode(ESP_SNTP_OPMODE_POLL); esp_sntp_setservername(0, "pool.ntp.org"); @@ -67,8 +72,12 @@ void KOReaderSyncActivity::onWifiSelectionComplete(const bool success) { } void KOReaderSyncActivity::performSync() { - // Calculate document hash - documentHash = KOReaderDocumentId::calculate(epubPath); + // Calculate document hash based on user's preferred method + if (KOREADER_STORE.getMatchMethod() == DocumentMatchMethod::FILENAME) { + documentHash = KOReaderDocumentId::calculateFromFilename(epubPath); + } else { + documentHash = KOReaderDocumentId::calculate(epubPath); + } if (documentHash.empty()) { xSemaphoreTake(renderingMutex, portMAX_DELAY); state = SYNC_FAILED; @@ -413,7 +422,11 @@ void KOReaderSyncActivity::loop() { if (mappedInput.wasPressed(MappedInputManager::Button::Confirm)) { // Calculate hash if not done yet if (documentHash.empty()) { - documentHash = KOReaderDocumentId::calculate(epubPath); + if (KOREADER_STORE.getMatchMethod() == DocumentMatchMethod::FILENAME) { + documentHash = KOReaderDocumentId::calculateFromFilename(epubPath); + } else { + documentHash = KOReaderDocumentId::calculate(epubPath); + } } performUpload(); } diff --git a/src/activities/settings/KOReaderSettingsActivity.cpp b/src/activities/settings/KOReaderSettingsActivity.cpp index 4b16e966..b186e51a 100644 --- a/src/activities/settings/KOReaderSettingsActivity.cpp +++ b/src/activities/settings/KOReaderSettingsActivity.cpp @@ -11,8 +11,8 @@ #include "fontIds.h" namespace { -constexpr int MENU_ITEMS = 4; -const char* menuNames[MENU_ITEMS] = {"Username", "Password", "Sync Server URL", "Authenticate"}; +constexpr int MENU_ITEMS = 5; +const char* menuNames[MENU_ITEMS] = {"Username", "Password", "Sync Server URL", "Document Matching", "Authenticate"}; } // namespace void KOReaderSettingsActivity::taskTrampoline(void* param) { @@ -129,6 +129,14 @@ void KOReaderSettingsActivity::handleSelection() { updateRequired = true; })); } else if (selectedIndex == 3) { + // Document Matching - toggle between Filename and Binary + const auto current = KOREADER_STORE.getMatchMethod(); + const auto newMethod = (current == DocumentMatchMethod::FILENAME) ? DocumentMatchMethod::BINARY + : DocumentMatchMethod::FILENAME; + KOREADER_STORE.setMatchMethod(newMethod); + KOREADER_STORE.saveToFile(); + updateRequired = true; + } else if (selectedIndex == 4) { // Authenticate if (!KOREADER_STORE.hasCredentials()) { // Can't authenticate without credentials - just show message briefly @@ -184,6 +192,8 @@ void KOReaderSettingsActivity::render() { } else if (i == 2) { status = KOREADER_STORE.getServerUrl().empty() ? "[Not Set]" : "[Set]"; } else if (i == 3) { + status = KOREADER_STORE.getMatchMethod() == DocumentMatchMethod::FILENAME ? "[Filename]" : "[Binary]"; + } else if (i == 4) { status = KOREADER_STORE.hasCredentials() ? "" : "[Set credentials first]"; } From a382341ac51f12a3ac0455836f96d5acf3efc3a3 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sun, 4 Jan 2026 23:52:25 -0500 Subject: [PATCH 08/12] fixes pushes progress --- lib/KOReaderSync/ProgressMapper.cpp | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/lib/KOReaderSync/ProgressMapper.cpp b/lib/KOReaderSync/ProgressMapper.cpp index f4c4f8d9..a1e2b4f7 100644 --- a/lib/KOReaderSync/ProgressMapper.cpp +++ b/lib/KOReaderSync/ProgressMapper.cpp @@ -94,12 +94,9 @@ CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epu std::string ProgressMapper::generateXPath(int spineIndex, int pageNumber, int totalPages) { // KOReader uses 1-based DocFragment indices - // Estimate paragraph number based on page position - // Assume ~3 paragraphs per page on average for e-reader screens - constexpr int paragraphsPerPage = 3; - const int estimatedParagraph = (pageNumber * paragraphsPerPage) + 1; // 1-based - - return "/body/DocFragment[" + std::to_string(spineIndex + 1) + "]/body/p[" + std::to_string(estimatedParagraph) + "]"; + // Use a simple xpath pointing to the DocFragment - KOReader will use the percentage for fine positioning + // Avoid specifying paragraph numbers as they may not exist in the target document + return "/body/DocFragment[" + std::to_string(spineIndex + 1) + "]/body"; } int ProgressMapper::parseDocFragmentIndex(const std::string& xpath) { From ba6257a8c98a7a8b1d9f714927d6d2c9aeb2cc88 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Sun, 4 Jan 2026 23:52:35 -0500 Subject: [PATCH 09/12] Apply clang-format fixes --- src/activities/settings/KOReaderSettingsActivity.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/activities/settings/KOReaderSettingsActivity.cpp b/src/activities/settings/KOReaderSettingsActivity.cpp index b186e51a..1ede2cda 100644 --- a/src/activities/settings/KOReaderSettingsActivity.cpp +++ b/src/activities/settings/KOReaderSettingsActivity.cpp @@ -131,8 +131,8 @@ void KOReaderSettingsActivity::handleSelection() { } else if (selectedIndex == 3) { // Document Matching - toggle between Filename and Binary const auto current = KOREADER_STORE.getMatchMethod(); - const auto newMethod = (current == DocumentMatchMethod::FILENAME) ? DocumentMatchMethod::BINARY - : DocumentMatchMethod::FILENAME; + const auto newMethod = + (current == DocumentMatchMethod::FILENAME) ? DocumentMatchMethod::BINARY : DocumentMatchMethod::FILENAME; KOREADER_STORE.setMatchMethod(newMethod); KOREADER_STORE.saveToFile(); updateRequired = true; From f36d89cd18bb8c458826513b6331106ca05036ba Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Tue, 13 Jan 2026 03:53:45 -0500 Subject: [PATCH 10/12] dont round % and default to start of chapter not end --- lib/Epub/Epub.cpp | 11 ++--- lib/Epub/Epub.h | 2 +- lib/KOReaderSync/ProgressMapper.cpp | 41 ++++++++----------- src/activities/reader/EpubReaderActivity.cpp | 8 ++-- .../reader/KOReaderSyncActivity.cpp | 4 +- 5 files changed, 32 insertions(+), 34 deletions(-) diff --git a/lib/Epub/Epub.cpp b/lib/Epub/Epub.cpp index 234344d7..7c6e0658 100644 --- a/lib/Epub/Epub.cpp +++ b/lib/Epub/Epub.cpp @@ -539,14 +539,15 @@ int Epub::getSpineIndexForTextReference() const { return 0; } -// Calculate progress in book -uint8_t Epub::calculateProgress(const int currentSpineIndex, const float currentSpineRead) const { +// Calculate progress in book (returns 0.0-1.0) +float Epub::calculateProgress(const int currentSpineIndex, const float currentSpineRead) const { const size_t bookSize = getBookSize(); if (bookSize == 0) { - return 0; + return 0.0f; } const size_t prevChapterSize = (currentSpineIndex >= 1) ? getCumulativeSpineItemSize(currentSpineIndex - 1) : 0; const size_t curChapterSize = getCumulativeSpineItemSize(currentSpineIndex) - prevChapterSize; - const size_t sectionProgSize = currentSpineRead * curChapterSize; - return round(static_cast(prevChapterSize + sectionProgSize) / bookSize * 100.0); + const float sectionProgSize = currentSpineRead * static_cast(curChapterSize); + const float totalProgress = static_cast(prevChapterSize) + sectionProgSize; + return totalProgress / static_cast(bookSize); } diff --git a/lib/Epub/Epub.h b/lib/Epub/Epub.h index a6555e7e..e18acfd5 100644 --- a/lib/Epub/Epub.h +++ b/lib/Epub/Epub.h @@ -60,5 +60,5 @@ class Epub { int getSpineIndexForTextReference() const; size_t getBookSize() const; - uint8_t calculateProgress(int currentSpineIndex, float currentSpineRead) const; + float calculateProgress(int currentSpineIndex, float currentSpineRead) const; }; diff --git a/lib/KOReaderSync/ProgressMapper.cpp b/lib/KOReaderSync/ProgressMapper.cpp index a1e2b4f7..3f946961 100644 --- a/lib/KOReaderSync/ProgressMapper.cpp +++ b/lib/KOReaderSync/ProgressMapper.cpp @@ -14,9 +14,8 @@ KOReaderPosition ProgressMapper::toKOReader(const std::shared_ptr& epub, c intraSpineProgress = static_cast(pos.pageNumber) / static_cast(pos.totalPages); } - // Calculate overall book progress (0-100 from Epub, convert to 0.0-1.0) - const uint8_t progressPercent = epub->calculateProgress(pos.spineIndex, intraSpineProgress); - result.percentage = static_cast(progressPercent) / 100.0f; + // Calculate overall book progress (0.0-1.0) + result.percentage = epub->calculateProgress(pos.spineIndex, intraSpineProgress); // Generate XPath with estimated paragraph position based on page result.xpath = generateXPath(pos.spineIndex, pos.pageNumber, pos.totalPages); @@ -48,9 +47,11 @@ CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epu int xpathSpineIndex = parseDocFragmentIndex(koPos.xpath); if (xpathSpineIndex >= 0 && xpathSpineIndex < epub->getSpineItemsCount()) { result.spineIndex = xpathSpineIndex; - Serial.printf("[%lu] [ProgressMapper] Got spine index from XPath: %d\n", millis(), result.spineIndex); + // When we have XPath, go to page 0 of the spine - byte-based page calculation is unreliable + result.pageNumber = 0; + Serial.printf("[%lu] [ProgressMapper] Got spine index from XPath: %d (page=0)\n", millis(), result.spineIndex); } else { - // Fall back to percentage-based lookup + // Fall back to percentage-based lookup for both spine and page const size_t targetBytes = static_cast(bookSize * koPos.percentage); // Find the spine item that contains this byte position @@ -63,26 +64,20 @@ CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epu } Serial.printf("[%lu] [ProgressMapper] Got spine index from percentage (%.2f%%): %d\n", millis(), koPos.percentage * 100, result.spineIndex); - } - // Estimate page number within the spine item using percentage - if (totalPagesInSpine > 0 && result.spineIndex < epub->getSpineItemsCount()) { - // Calculate what percentage through the spine item we should be - const size_t prevCumSize = (result.spineIndex > 0) ? epub->getCumulativeSpineItemSize(result.spineIndex - 1) : 0; - const size_t currentCumSize = epub->getCumulativeSpineItemSize(result.spineIndex); - const size_t spineSize = currentCumSize - prevCumSize; + // Estimate page number within the spine item using percentage (only when no XPath) + if (totalPagesInSpine > 0 && result.spineIndex < epub->getSpineItemsCount()) { + const size_t prevCumSize = (result.spineIndex > 0) ? epub->getCumulativeSpineItemSize(result.spineIndex - 1) : 0; + const size_t currentCumSize = epub->getCumulativeSpineItemSize(result.spineIndex); + const size_t spineSize = currentCumSize - prevCumSize; - if (spineSize > 0) { - const size_t targetBytes = static_cast(bookSize * koPos.percentage); - const size_t bytesIntoSpine = (targetBytes > prevCumSize) ? (targetBytes - prevCumSize) : 0; - const float intraSpineProgress = static_cast(bytesIntoSpine) / static_cast(spineSize); - - // Clamp to valid range - const float clampedProgress = std::max(0.0f, std::min(1.0f, intraSpineProgress)); - result.pageNumber = static_cast(clampedProgress * totalPagesInSpine); - - // Ensure page number is valid - result.pageNumber = std::max(0, std::min(result.pageNumber, totalPagesInSpine - 1)); + if (spineSize > 0) { + const size_t bytesIntoSpine = (targetBytes > prevCumSize) ? (targetBytes - prevCumSize) : 0; + const float intraSpineProgress = static_cast(bytesIntoSpine) / static_cast(spineSize); + const float clampedProgress = std::max(0.0f, std::min(1.0f, intraSpineProgress)); + result.pageNumber = static_cast(clampedProgress * totalPagesInSpine); + result.pageNumber = std::max(0, std::min(result.pageNumber, totalPagesInSpine - 1)); + } } } diff --git a/src/activities/reader/EpubReaderActivity.cpp b/src/activities/reader/EpubReaderActivity.cpp index 2c9998e9..18a3d0a9 100644 --- a/src/activities/reader/EpubReaderActivity.cpp +++ b/src/activities/reader/EpubReaderActivity.cpp @@ -438,11 +438,13 @@ void EpubReaderActivity::renderStatusBar(const int orientedMarginRight, const in if (showProgress) { // Calculate progress in book const float sectionChapterProg = static_cast(section->currentPage) / section->pageCount; - const uint8_t bookProgress = epub->calculateProgress(currentSpineIndex, sectionChapterProg); + const float bookProgress = epub->calculateProgress(currentSpineIndex, sectionChapterProg) * 100; // Right aligned text for progress counter - const std::string progress = std::to_string(section->currentPage + 1) + "/" + std::to_string(section->pageCount) + - " " + std::to_string(bookProgress) + "%"; + char progressStr[32]; + snprintf(progressStr, sizeof(progressStr), "%d/%d %.1f%%", section->currentPage + 1, section->pageCount, + bookProgress); + const std::string progress = progressStr; progressTextWidth = renderer.getTextWidth(SMALL_FONT_ID, progress.c_str()); renderer.drawText(SMALL_FONT_ID, renderer.getScreenWidth() - orientedMarginRight - progressTextWidth, textY, progress.c_str()); diff --git a/src/activities/reader/KOReaderSyncActivity.cpp b/src/activities/reader/KOReaderSyncActivity.cpp index 59ae4eed..4a85f23d 100644 --- a/src/activities/reader/KOReaderSyncActivity.cpp +++ b/src/activities/reader/KOReaderSyncActivity.cpp @@ -296,7 +296,7 @@ void KOReaderSyncActivity::render() { 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, + snprintf(remotePageStr, sizeof(remotePageStr), " Page %d, %.2f%% overall", remotePosition.pageNumber + 1, remoteProgress.percentage * 100); renderer.drawText(UI_10_FONT_ID, 20, 210, remotePageStr); @@ -312,7 +312,7 @@ void KOReaderSyncActivity::render() { 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, + snprintf(localPageStr, sizeof(localPageStr), " Page %d/%d, %.2f%% overall", currentPage + 1, totalPagesInSpine, localProgress.percentage * 100); renderer.drawText(UI_10_FONT_ID, 20, 320, localPageStr); From 614b000c310980c4132a91fd15e3c40b6d1263b7 Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Tue, 13 Jan 2026 04:04:44 -0500 Subject: [PATCH 11/12] Remove logs --- lib/KOReaderSync/ProgressMapper.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/lib/KOReaderSync/ProgressMapper.cpp b/lib/KOReaderSync/ProgressMapper.cpp index 3f946961..2c15ab71 100644 --- a/lib/KOReaderSync/ProgressMapper.cpp +++ b/lib/KOReaderSync/ProgressMapper.cpp @@ -3,7 +3,6 @@ #include #include -#include KOReaderPosition ProgressMapper::toKOReader(const std::shared_ptr& epub, const CrossPointPosition& pos) { KOReaderPosition result; @@ -39,7 +38,6 @@ CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epu const size_t bookSize = epub->getBookSize(); if (bookSize == 0) { - Serial.printf("[%lu] [ProgressMapper] Book size is 0\n", millis()); return result; } @@ -49,7 +47,6 @@ CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epu result.spineIndex = xpathSpineIndex; // When we have XPath, go to page 0 of the spine - byte-based page calculation is unreliable result.pageNumber = 0; - Serial.printf("[%lu] [ProgressMapper] Got spine index from XPath: %d (page=0)\n", millis(), result.spineIndex); } else { // Fall back to percentage-based lookup for both spine and page const size_t targetBytes = static_cast(bookSize * koPos.percentage); @@ -62,8 +59,6 @@ CrossPointPosition ProgressMapper::toCrossPoint(const std::shared_ptr& epu break; } } - Serial.printf("[%lu] [ProgressMapper] Got spine index from percentage (%.2f%%): %d\n", millis(), - koPos.percentage * 100, result.spineIndex); // Estimate page number within the spine item using percentage (only when no XPath) if (totalPagesInSpine > 0 && result.spineIndex < epub->getSpineItemsCount()) { From b32bf51f0ac5d062f157ce8e6de9a7f497f77beb Mon Sep 17 00:00:00 2001 From: Justin Mitchell Date: Wed, 14 Jan 2026 11:57:07 -0500 Subject: [PATCH 12/12] Allows koreader sync to run over http --- lib/KOReaderSync/KOReaderCredentialStore.cpp | 4 +- lib/KOReaderSync/KOReaderCredentialStore.h | 2 +- lib/KOReaderSync/KOReaderSyncClient.cpp | 61 +++++++++++++------ .../settings/KOReaderSettingsActivity.cpp | 10 ++- 4 files changed, 53 insertions(+), 24 deletions(-) diff --git a/lib/KOReaderSync/KOReaderCredentialStore.cpp b/lib/KOReaderSync/KOReaderCredentialStore.cpp index f73cc325..c5737809 100644 --- a/lib/KOReaderSync/KOReaderCredentialStore.cpp +++ b/lib/KOReaderSync/KOReaderCredentialStore.cpp @@ -153,9 +153,9 @@ std::string KOReaderCredentialStore::getBaseUrl() const { return DEFAULT_SERVER_URL; } - // Normalize URL: add https:// if no protocol specified + // Normalize URL: add http:// if no protocol specified (local servers typically don't have SSL) if (serverUrl.find("://") == std::string::npos) { - return "https://" + serverUrl; + return "http://" + serverUrl; } return serverUrl; diff --git a/lib/KOReaderSync/KOReaderCredentialStore.h b/lib/KOReaderSync/KOReaderCredentialStore.h index d1709660..998101a2 100644 --- a/lib/KOReaderSync/KOReaderCredentialStore.h +++ b/lib/KOReaderSync/KOReaderCredentialStore.h @@ -57,7 +57,7 @@ class KOReaderCredentialStore { void setServerUrl(const std::string& url); const std::string& getServerUrl() const { return serverUrl; } - // Get base URL for API calls (with https:// normalization, falls back to default) + // Get base URL for API calls (with http:// normalization if no protocol, falls back to default) std::string getBaseUrl() const; // Document matching method diff --git a/lib/KOReaderSync/KOReaderSyncClient.cpp b/lib/KOReaderSync/KOReaderSyncClient.cpp index 91515cd9..32379f28 100644 --- a/lib/KOReaderSync/KOReaderSyncClient.cpp +++ b/lib/KOReaderSync/KOReaderSyncClient.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -19,6 +20,10 @@ void addAuthHeaders(HTTPClient& http) { http.addHeader("x-auth-user", KOREADER_STORE.getUsername().c_str()); http.addHeader("x-auth-key", KOREADER_STORE.getMd5Password().c_str()); } + +bool isHttpsUrl(const std::string& url) { + return url.rfind("https://", 0) == 0; +} } // namespace KOReaderSyncClient::Error KOReaderSyncClient::authenticate() { @@ -27,14 +32,20 @@ KOReaderSyncClient::Error KOReaderSyncClient::authenticate() { return NO_CREDENTIALS; } - const std::unique_ptr client(new WiFiClientSecure); - client->setInsecure(); - HTTPClient http; - std::string url = KOREADER_STORE.getBaseUrl() + "/users/auth"; Serial.printf("[%lu] [KOSync] Authenticating: %s\n", millis(), url.c_str()); - http.begin(*client, url.c_str()); + HTTPClient http; + std::unique_ptr secureClient; + WiFiClient plainClient; + + if (isHttpsUrl(url)) { + secureClient.reset(new WiFiClientSecure); + secureClient->setInsecure(); + http.begin(*secureClient, url.c_str()); + } else { + http.begin(plainClient, url.c_str()); + } addAuthHeaders(http); const int httpCode = http.GET(); @@ -59,24 +70,32 @@ KOReaderSyncClient::Error KOReaderSyncClient::getProgress(const std::string& doc return NO_CREDENTIALS; } - const std::unique_ptr client(new WiFiClientSecure); - client->setInsecure(); - HTTPClient http; - std::string url = KOREADER_STORE.getBaseUrl() + "/syncs/progress/" + documentHash; Serial.printf("[%lu] [KOSync] Getting progress: %s\n", millis(), url.c_str()); - http.begin(*client, url.c_str()); + HTTPClient http; + std::unique_ptr secureClient; + WiFiClient plainClient; + + if (isHttpsUrl(url)) { + secureClient.reset(new WiFiClientSecure); + secureClient->setInsecure(); + http.begin(*secureClient, url.c_str()); + } else { + http.begin(plainClient, url.c_str()); + } addAuthHeaders(http); const int httpCode = http.GET(); if (httpCode == 200) { - // Parse JSON response - JsonDocument doc; - const DeserializationError error = deserializeJson(doc, *client); + // Parse JSON response from response string + String responseBody = http.getString(); http.end(); + JsonDocument doc; + const DeserializationError error = deserializeJson(doc, responseBody); + if (error) { Serial.printf("[%lu] [KOSync] JSON parse failed: %s\n", millis(), error.c_str()); return JSON_ERROR; @@ -114,14 +133,20 @@ KOReaderSyncClient::Error KOReaderSyncClient::updateProgress(const KOReaderProgr return NO_CREDENTIALS; } - const std::unique_ptr client(new WiFiClientSecure); - client->setInsecure(); - HTTPClient http; - std::string url = KOREADER_STORE.getBaseUrl() + "/syncs/progress"; Serial.printf("[%lu] [KOSync] Updating progress: %s\n", millis(), url.c_str()); - http.begin(*client, url.c_str()); + HTTPClient http; + std::unique_ptr secureClient; + WiFiClient plainClient; + + if (isHttpsUrl(url)) { + secureClient.reset(new WiFiClientSecure); + secureClient->setInsecure(); + http.begin(*secureClient, url.c_str()); + } else { + http.begin(plainClient, url.c_str()); + } addAuthHeaders(http); http.addHeader("Content-Type", "application/json"); diff --git a/src/activities/settings/KOReaderSettingsActivity.cpp b/src/activities/settings/KOReaderSettingsActivity.cpp index 1ede2cda..6eb22c8e 100644 --- a/src/activities/settings/KOReaderSettingsActivity.cpp +++ b/src/activities/settings/KOReaderSettingsActivity.cpp @@ -112,14 +112,18 @@ void KOReaderSettingsActivity::handleSelection() { updateRequired = true; })); } else if (selectedIndex == 2) { - // Sync Server URL + // Sync Server URL - prefill with https:// if empty to save typing + const std::string currentUrl = KOREADER_STORE.getServerUrl(); + const std::string prefillUrl = currentUrl.empty() ? "https://" : currentUrl; exitActivity(); enterNewActivity(new KeyboardEntryActivity( - renderer, mappedInput, "Sync Server URL", KOREADER_STORE.getServerUrl(), 10, + renderer, mappedInput, "Sync Server URL", prefillUrl, 10, 128, // maxLength - URLs can be long false, // not password [this](const std::string& url) { - KOREADER_STORE.setServerUrl(url); + // Clear if user just left the prefilled https:// + const std::string urlToSave = (url == "https://" || url == "http://") ? "" : url; + KOREADER_STORE.setServerUrl(urlToSave); KOREADER_STORE.saveToFile(); exitActivity(); updateRequired = true;