port: upstream PR #1342 - Book Info screen, richer metadata, safer controls

Ports upstream PR #1342 (feat: Add Book Info screen, richer metadata,
and safer file-browser controls) with mod-specific adaptations:

- Parse and cache series, seriesIndex, description from EPUB OPF
- Bump book.bin cache version to 6 for new metadata fields
- Add BookInfoActivity (new screen) accessible via Right button in FileBrowser
- Add ManageBook menu via Left button in FileBrowser (replaces upstream hidden delete)
- Guard all delete/archive actions with ConfirmationActivity (10 call sites)
- Add inputArmed gating to ConfirmationActivity to prevent accidental confirmation
- Safe deserialization: readString now returns bool with MAX_STRING_LENGTH guard
- Add series field to RecentBooksStore with JSON and binary serialization
- Add i18n keys: STR_BOOK_INFO, STR_AUTHOR, STR_SERIES, STR_FILE_SIZE, etc.

Made-with: Cursor

src/activities/home/BookInfoActivity.cpp

@@ -0,0 +1,160 @@
+#include "BookInfoActivity.h"
+
+#include <Epub.h>
+#include <FsHelpers.h>
+#include <GfxRenderer.h>
+#include <HalStorage.h>
+#include <I18n.h>
+#include <Logging.h>
+
+#include "components/UITheme.h"
+#include "fontIds.h"
+
+void BookInfoActivity::onEnter() {
+  Activity::onEnter();
+
+  std::string fileName = filePath;
+  const size_t lastSlash = filePath.rfind('/');
+  if (lastSlash != std::string::npos) {
+    fileName = filePath.substr(lastSlash + 1);
+  }
+
+  FsFile file;
+  if (Storage.openFileForRead("BIF", filePath, file)) {
+    fileSize = file.fileSize();
+    file.close();
+  }
+
+  if (FsHelpers::hasEpubExtension(fileName)) {
+    Epub epub(filePath, "/.crosspoint");
+    if (epub.load(false, true)) {
+      title = epub.getTitle();
+      author = epub.getAuthor();
+      series = epub.getSeries();
+      seriesIndex = epub.getSeriesIndex();
+      description = epub.getDescription();
+      language = epub.getLanguage();
+    }
+  }
+
+  if (title.empty()) {
+    title = fileName;
+  }
+
+  requestUpdate();
+}
+
+void BookInfoActivity::onExit() { Activity::onExit(); }
+
+void BookInfoActivity::loop() {
+  if (mappedInput.wasReleased(MappedInputManager::Button::Back) ||
+      mappedInput.wasReleased(MappedInputManager::Button::Confirm)) {
+    ActivityResult r;
+    r.isCancelled = true;
+    setResult(std::move(r));
+    finish();
+    return;
+  }
+
+  if (mappedInput.wasReleased(MappedInputManager::Button::Down)) {
+    if (scrollOffset + renderer.getScreenHeight() < contentHeight) {
+      scrollOffset += renderer.getScreenHeight() / 3;
+      requestUpdate();
+    }
+  }
+
+  if (mappedInput.wasReleased(MappedInputManager::Button::Up)) {
+    if (scrollOffset > 0) {
+      scrollOffset -= renderer.getScreenHeight() / 3;
+      if (scrollOffset < 0) scrollOffset = 0;
+      requestUpdate();
+    }
+  }
+}
+
+void BookInfoActivity::render(RenderLock&&) {
+  renderer.clearScreen();
+
+  const int pageW = renderer.getScreenWidth();
+  const int pageH = renderer.getScreenHeight();
+  constexpr int margin = 20;
+  constexpr int labelValueGap = 4;
+  constexpr int sectionGap = 14;
+  constexpr int maxWrappedLines = 30;
+  const int contentW = pageW - margin * 2;
+  const int lineH10 = renderer.getLineHeight(UI_10_FONT_ID);
+  const int lineH12 = renderer.getLineHeight(UI_12_FONT_ID);
+  int y = margin - scrollOffset;
+
+  auto drawLabel = [&](const char* label) {
+    renderer.drawText(UI_10_FONT_ID, margin, y, label, true, EpdFontFamily::BOLD);
+    y += lineH10 + labelValueGap;
+  };
+
+  auto drawWrapped = [&](int fontId, const std::string& text, int lineH, EpdFontFamily::Style style) {
+    auto lines = renderer.wrappedText(fontId, text.c_str(), contentW, maxWrappedLines, style);
+    for (const auto& line : lines) {
+      renderer.drawText(fontId, margin, y, line.c_str(), true, style);
+      y += lineH;
+    }
+    y += sectionGap;
+  };
+
+  // Title
+  drawWrapped(UI_12_FONT_ID, title, lineH12, EpdFontFamily::BOLD);
+
+  // Author
+  if (!author.empty()) {
+    drawLabel(tr(STR_AUTHOR));
+    drawWrapped(UI_12_FONT_ID, author, lineH12, EpdFontFamily::REGULAR);
+  }
+
+  // Series
+  if (!series.empty()) {
+    drawLabel(tr(STR_SERIES));
+    std::string seriesStr = series;
+    if (!seriesIndex.empty()) {
+      seriesStr += " #" + seriesIndex;
+    }
+    drawWrapped(UI_12_FONT_ID, seriesStr, lineH12, EpdFontFamily::REGULAR);
+  }
+
+  // Language
+  if (!language.empty()) {
+    drawLabel(tr(STR_LANGUAGE));
+    drawWrapped(UI_12_FONT_ID, language, lineH12, EpdFontFamily::REGULAR);
+  }
+
+  // File size
+  if (fileSize > 0) {
+    drawLabel(tr(STR_FILE_SIZE));
+    drawWrapped(UI_12_FONT_ID, formatFileSize(fileSize), lineH12, EpdFontFamily::REGULAR);
+  }
+
+  // Description
+  if (!description.empty()) {
+    drawLabel(tr(STR_DESCRIPTION));
+    drawWrapped(UI_12_FONT_ID, description, lineH12, EpdFontFamily::REGULAR);
+  }
+
+  contentHeight = y + scrollOffset;
+
+  // Button hints
+  const char* scrollHint = contentHeight > pageH ? tr(STR_DIR_DOWN) : "";
+  const auto labels = mappedInput.mapLabels(tr(STR_BACK), "", scrollHint, "");
+  GUI.drawButtonHints(renderer, labels.btn1, labels.btn2, labels.btn3, labels.btn4);
+
+  renderer.displayBuffer();
+}
+
+std::string BookInfoActivity::formatFileSize(size_t bytes) {
+  char buf[32];
+  if (bytes < 1024) {
+    snprintf(buf, sizeof(buf), "%u B", static_cast<unsigned>(bytes));
+  } else if (bytes < 1024 * 1024) {
+    snprintf(buf, sizeof(buf), "%.1f KB", static_cast<float>(bytes) / 1024.0f);
+  } else {
+    snprintf(buf, sizeof(buf), "%.1f MB", static_cast<float>(bytes) / (1024.0f * 1024.0f));
+  }
+  return buf;
+}