refactor: split reader architecture and chrome handling

2026-05-31 21:47:54 +08:00
parent ea21c6a831
commit 44202357c0
80 changed files with 10635 additions and 8522 deletions
@@ -0,0 +1,281 @@
+import UIKit
+
+final class RDEPUBReaderRuntime {
+    private unowned let context: RDEPUBReaderContext
+
+    lazy var loadCoordinator = RDEPUBReaderLoadCoordinator(context: context)
+    lazy var paginationCoordinator = RDEPUBReaderPaginationCoordinator(context: context)
+    lazy var locationCoordinator = RDEPUBReaderLocationCoordinator(context: context)
+    lazy var searchCoordinator = RDEPUBReaderSearchCoordinator(context: context)
+    lazy var chromeCoordinator = RDEPUBReaderChromeCoordinator(context: context)
+    lazy var annotationCoordinator = RDEPUBReaderAnnotationCoordinator(context: context)
+    lazy var viewportMonitor = RDEPUBReaderViewportMonitor(context: context)
+
+    init(context: RDEPUBReaderContext) {
+        self.context = context
+    }
+
+    func makeTopToolView() -> RDEPUBReaderTopToolView {
+        chromeCoordinator.makeTopToolView()
+    }
+
+    func makeBottomToolView() -> RDEPUBReaderBottomToolView {
+        chromeCoordinator.makeBottomToolView()
+    }
+
+    func startInitialLoadIfNeeded() {
+        loadCoordinator.startInitialLoadIfNeeded()
+    }
+
+    func reloadBook() {
+        guard let readerView = context.readerView else { return }
+        context.didStartInitialLoad = false
+        context.parser = nil
+        context.publication = nil
+        context.clearActiveSnapshot()
+        context.readingSession = nil
+        context.textBook = nil
+        context.activeBookmarks = []
+        context.activeHighlights = []
+        context.searchState = nil
+        viewportMonitor.resetForReload()
+        annotationCoordinator.updateCurrentSelection(nil)
+        readerView.reloadData()
+        startInitialLoadIfNeeded()
+    }
+
+    func go(to location: RDEPUBLocation, animated: Bool = false) -> Bool {
+        locationCoordinator.restoreReadingLocation(location, animated: animated)
+    }
+
+    @discardableResult
+    func go(toPageNumber pageNumber: Int, animated: Bool = false) -> Bool {
+        guard let controller = context.controller,
+              let readerView = context.readerView,
+              pageNumber > 0 else {
+            return false
+        }
+
+        if context.textBook != nil {
+            guard let location = controller.resolvedTextLocation(forPageNumber: pageNumber) else {
+                return false
+            }
+            return locationCoordinator.restoreReadingLocation(location, animated: animated)
+        }
+
+        guard context.activePages.indices.contains(pageNumber - 1) else {
+            return false
+        }
+        readerView.transitionToPage(pageNum: pageNumber - 1, animated: animated)
+        if let location = locationCoordinator.currentVisibleLocation() {
+            context.persist(location: location)
+        }
+        return true
+    }
+
+    func clearSelection() {
+        annotationCoordinator.updateCurrentSelection(nil)
+    }
+
+    func bookmark(withID id: String) -> RDEPUBBookmark? {
+        annotationCoordinator.bookmark(withID: id)
+    }
+
+    func highlight(withID id: String) -> RDEPUBHighlight? {
+        annotationCoordinator.highlight(withID: id)
+    }
+
+    @discardableResult
+    func addHighlight(
+        from selection: RDEPUBSelection? = nil,
+        color: String = "#F8E16C",
+        note: String? = nil
+    ) -> RDEPUBHighlight? {
+        annotationCoordinator.addHighlight(from: selection, color: color, note: note)
+    }
+
+    @discardableResult
+    func addAnnotation(
+        from selection: RDEPUBSelection? = nil,
+        style: RDEPUBHighlightStyle,
+        color: String = "#F8E16C",
+        note: String? = nil
+    ) -> RDEPUBHighlight? {
+        annotationCoordinator.addAnnotation(from: selection, style: style, color: color, note: note)
+    }
+
+    @discardableResult
+    func upsertHighlight(_ highlight: RDEPUBHighlight) -> RDEPUBHighlight? {
+        annotationCoordinator.upsertHighlight(highlight)
+    }
+
+    @discardableResult
+    func removeHighlight(id: String) -> RDEPUBHighlight? {
+        annotationCoordinator.removeHighlight(id: id)
+    }
+
+    @discardableResult
+    func updateHighlightNote(id: String, note: String?) -> RDEPUBHighlight? {
+        annotationCoordinator.updateHighlightNote(id: id, note: note)
+    }
+
+    @discardableResult
+    func go(toHighlightID id: String, animated: Bool = true) -> Bool {
+        annotationCoordinator.go(toHighlightID: id, animated: animated)
+    }
+
+    func removeAllHighlights() {
+        annotationCoordinator.removeAllHighlights()
+    }
+
+    @discardableResult
+    func addBookmark(note: String? = nil) -> RDEPUBBookmark? {
+        annotationCoordinator.addBookmark(note: note)
+    }
+
+    @discardableResult
+    func toggleBookmark(note: String? = nil) -> RDEPUBBookmark? {
+        annotationCoordinator.toggleBookmark(note: note)
+    }
+
+    @discardableResult
+    func removeBookmark(id: String) -> RDEPUBBookmark? {
+        annotationCoordinator.removeBookmark(id: id)
+    }
+
+    @discardableResult
+    func go(toBookmarkID id: String, animated: Bool = true) -> Bool {
+        annotationCoordinator.go(toBookmarkID: id, animated: animated)
+    }
+
+    func updateBookmarkChrome() {
+        annotationCoordinator.updateBookmarkChrome()
+    }
+
+    func presentBookmarksManager() {
+        annotationCoordinator.presentBookmarksManager()
+    }
+
+    func presentHighlightsManager() {
+        annotationCoordinator.presentHighlightsManager()
+    }
+
+    func presentAnnotationCreation() {
+        annotationCoordinator.presentAnnotationCreation()
+    }
+
+    func handleSelectionMenuAction(_ action: RDEPUBAnnotationMenuAction, selection: RDEPUBSelection?) {
+        annotationCoordinator.handleSelectionMenuAction(action, selection: selection)
+    }
+
+    func search(keyword: String) {
+        searchCoordinator.search(keyword: keyword)
+    }
+
+    @discardableResult
+    func searchNext() -> Bool {
+        searchCoordinator.searchNext()
+    }
+
+    @discardableResult
+    func searchPrevious() -> Bool {
+        searchCoordinator.searchPrevious()
+    }
+
+    func clearSearch() {
+        searchCoordinator.clearSearch()
+    }
+
+    func searchPresentation(for page: EPUBPage) -> RDEPUBSearchPresentation? {
+        searchCoordinator.searchPresentation(for: page)
+    }
+
+    func updateReaderChrome() {
+        chromeCoordinator.updateReaderChrome()
+    }
+
+    func presentSettings() {
+        chromeCoordinator.presentSettings()
+    }
+
+    func presentTableOfContents() {
+        chromeCoordinator.presentTableOfContents()
+    }
+
+    func handleBackAction() {
+        chromeCoordinator.handleBackAction()
+    }
+
+    func loadPublication() {
+        loadCoordinator.loadPublication()
+    }
+
+    func applyParsedPublication(
+        parser: RDEPUBParser,
+        publication: RDEPUBPublication,
+        bookIdentifier: String,
+        restoreLocation: RDEPUBLocation?,
+        bookmarks: [RDEPUBBookmark],
+        highlights: [RDEPUBHighlight]
+    ) {
+        loadCoordinator.applyParsedPublication(
+            parser: parser,
+            publication: publication,
+            bookIdentifier: bookIdentifier,
+            restoreLocation: restoreLocation,
+            bookmarks: bookmarks,
+            highlights: highlights
+        )
+    }
+
+    func paginatePublication(restoreLocation: RDEPUBLocation?) {
+        paginationCoordinator.paginatePublication(restoreLocation: restoreLocation)
+    }
+
+    func applyTextBook(_ textBook: RDEPUBTextBook, restoreLocation: RDEPUBLocation?) {
+        paginationCoordinator.applyTextBook(textBook, restoreLocation: restoreLocation)
+    }
+
+    func applyPaginationSnapshot(
+        _ snapshot: (pages: [EPUBPage], chapters: [EPUBChapterInfo]),
+        restoreLocation: RDEPUBLocation?
+    ) {
+        paginationCoordinator.applyPaginationSnapshot(snapshot, restoreLocation: restoreLocation)
+    }
+
+    func finishPagination(restoreLocation: RDEPUBLocation?) {
+        paginationCoordinator.finishPagination(restoreLocation: restoreLocation)
+    }
+
+    func repaginatePreservingCurrentLocation() {
+        paginationCoordinator.repaginatePreservingCurrentLocation()
+    }
+
+    func refreshVisibleContentPreservingLocation() {
+        paginationCoordinator.refreshVisibleContentPreservingLocation()
+    }
+
+    func rebuildExternalTextBook() {
+        paginationCoordinator.rebuildExternalTextBook()
+    }
+
+    @discardableResult
+    func restoreReadingLocation(_ location: RDEPUBLocation, animated: Bool = false) -> Bool {
+        locationCoordinator.restoreReadingLocation(location, animated: animated)
+    }
+
+    func currentVisibleLocation() -> RDEPUBLocation? {
+        locationCoordinator.currentVisibleLocation()
+    }
+
+    func currentViewportSignature() -> RDEPUBViewportSignature? {
+        viewportMonitor.currentViewportSignature()
+    }
+
+    func handleViewportChangeIfNeeded(
+        reason: RDEPUBViewportChangeReason,
+        viewportSignature: RDEPUBViewportSignature? = nil
+    ) {
+        viewportMonitor.handleViewportChangeIfNeeded(reason: reason, viewportSignature: viewportSignature)
+    }
+}