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,256 @@
+import UIKit
+
+final class RDReaderPreloadController {
+    var radius: Int = 1
+
+    private let preloadHostView = UIView()
+    private var preloadedPageViews: [Int: UIView] = [:]
+    private var pageCurlCachedViews: [Int: UIView] = [:]
+    private var cacheSignature: CacheSignature?
+
+    struct Environment {
+        let displayType: RDReaderView.DisplayType
+        let isLandscape: Bool
+        let pagesPerScreen: Int
+        let boundsSize: CGSize
+        let landscapeDualPageEnabled: Bool
+        let coverPageIndex: Int?
+        let totalPages: Int
+        let spreadResolver: RDReaderSpreadResolver
+    }
+
+    private struct CacheSignature: Equatable {
+        let displayType: RDReaderView.DisplayType
+        let isLandscape: Bool
+        let pagesPerScreen: Int
+        let boundsSize: CGSize
+    }
+
+    func setHostFrame(_ frame: CGRect) {
+        preloadHostView.frame = frame
+    }
+
+    func ensureHostView(in parentView: UIView) {
+        guard preloadHostView.superview == nil else { return }
+        preloadHostView.isHidden = true
+        preloadHostView.isUserInteractionEnabled = false
+        preloadHostView.clipsToBounds = true
+        preloadHostView.frame = parentView.bounds
+        preloadHostView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        parentView.insertSubview(preloadHostView, at: 0)
+    }
+
+    func initializeSignature(_ environment: Environment) {
+        cacheSignature = currentCacheSignature(environment)
+    }
+
+    func invalidate(environment: Environment) {
+        pageCurlCachedViews.values.forEach { $0.removeFromSuperview() }
+        preloadedPageViews.values.forEach { $0.removeFromSuperview() }
+        pageCurlCachedViews.removeAll()
+        preloadedPageViews.removeAll()
+        cacheSignature = currentCacheSignature(environment)
+    }
+
+    func pageViewForDisplay(
+        pageNum: Int,
+        environment: Environment,
+        contentViewProvider: (Int, UIView?) -> UIView?
+    ) -> UIView {
+        let reusableView = detachedReusablePageView(for: pageNum)
+        let view = contentViewProvider(pageNum, reusableView) ?? reusableView ?? UIView()
+        pageCurlCachedViews[pageNum] = view
+        return view
+    }
+
+    func takePreloadedView(for pageNum: Int) -> UIView? {
+        let preloaded = preloadedPageViews.removeValue(forKey: pageNum)
+        preloaded?.removeFromSuperview()
+        return preloaded
+    }
+
+    func prime(
+        around pageNum: Int,
+        preferredForward: Bool? = nil,
+        parentView: UIView,
+        environment: Environment,
+        contentViewProvider: (Int, UIView?) -> UIView?
+    ) {
+        refreshCacheSignatureIfNeeded(environment)
+        let targets = forecastTargets(around: pageNum, preferredForward: preferredForward, environment: environment)
+        let keepSet = Set(targets).union(visiblePageNumbers(for: pageNum, environment: environment))
+        trimCachedPageViews(keeping: keepSet)
+        guard !targets.isEmpty else { return }
+
+        ensureHostView(in: parentView)
+        preloadHostView.frame = parentView.bounds
+
+        for targetPage in targets {
+            let existing = detachedReusablePageView(for: targetPage)
+            let contentView = contentViewProvider(targetPage, existing) ?? existing ?? UIView()
+            preloadedPageViews[targetPage] = contentView
+            if contentView.superview !== preloadHostView {
+                contentView.removeFromSuperview()
+                preloadHostView.addSubview(contentView)
+            }
+            contentView.frame = preloadHostView.bounds
+        }
+    }
+
+    private func currentCacheSignature(_ environment: Environment) -> CacheSignature {
+        CacheSignature(
+            displayType: environment.displayType,
+            isLandscape: environment.isLandscape,
+            pagesPerScreen: environment.pagesPerScreen,
+            boundsSize: environment.boundsSize
+        )
+    }
+
+    private func refreshCacheSignatureIfNeeded(_ environment: Environment) {
+        let signature = currentCacheSignature(environment)
+        if cacheSignature != signature {
+            invalidate(environment: environment)
+        } else if cacheSignature == nil {
+            cacheSignature = signature
+        }
+    }
+
+    private func shouldCachePage(_ pageNum: Int, environment: Environment) -> Bool {
+        pageNum >= 0
+            && pageNum != RDReaderView.blankPageNum
+            && pageNum != RDReaderView.blankEndPageNum
+            && pageNum < environment.totalPages
+    }
+
+    private func isDualPage(environment: Environment) -> Bool {
+        environment.landscapeDualPageEnabled
+            && environment.isLandscape
+            && environment.displayType != .verticalScroll
+    }
+
+    private func spreadStart(for pageNum: Int, environment: Environment) -> Int? {
+        guard shouldCachePage(pageNum, environment: environment) else { return nil }
+        guard isDualPage(environment: environment) else { return pageNum }
+        return environment.spreadResolver.dualPagePair(
+            for: pageNum,
+            totalPages: environment.totalPages,
+            coverPageIndex: environment.coverPageIndex
+        ).left
+    }
+
+    private func spreadPageNumbers(startingAt pageNum: Int, environment: Environment) -> Set<Int> {
+        guard shouldCachePage(pageNum, environment: environment) else { return [] }
+        guard isDualPage(environment: environment) else { return [pageNum] }
+        let pair = environment.spreadResolver.dualPagePair(
+            for: pageNum,
+            totalPages: environment.totalPages,
+            coverPageIndex: environment.coverPageIndex
+        )
+        var pages: Set<Int> = [pair.left]
+        if let right = pair.right, shouldCachePage(right, environment: environment) {
+            pages.insert(right)
+        }
+        return pages
+    }
+
+    private func adjacentSpreadStart(from pageNum: Int, forward: Bool, environment: Environment) -> Int? {
+        guard environment.totalPages > 0,
+              let spreadStart = spreadStart(for: pageNum, environment: environment) else {
+            return nil
+        }
+
+        guard isDualPage(environment: environment) else {
+            let target = forward ? spreadStart + 1 : spreadStart - 1
+            return shouldCachePage(target, environment: environment) ? target : nil
+        }
+
+        if forward {
+            return environment.spreadResolver.adjacentDualPage(
+                from: spreadStart,
+                totalPages: environment.totalPages,
+                coverPageIndex: environment.coverPageIndex,
+                forward: true
+            )
+        }
+
+        let pair = environment.spreadResolver.dualPagePair(
+            for: spreadStart,
+            totalPages: environment.totalPages,
+            coverPageIndex: environment.coverPageIndex
+        )
+        let prevEnd = pair.left - 1
+        guard prevEnd >= 0 else { return nil }
+        return environment.spreadResolver.dualPagePair(
+            for: prevEnd,
+            totalPages: environment.totalPages,
+            coverPageIndex: environment.coverPageIndex
+        ).left
+    }
+
+    private func visiblePageNumbers(for anchorPage: Int, environment: Environment) -> Set<Int> {
+        spreadPageNumbers(startingAt: anchorPage, environment: environment)
+    }
+
+    private func detachedReusablePageView(for pageNum: Int) -> UIView? {
+        if let preloaded = preloadedPageViews.removeValue(forKey: pageNum) {
+            preloaded.removeFromSuperview()
+            return preloaded
+        }
+
+        guard let cached = pageCurlCachedViews[pageNum], cached.superview == nil else {
+            return nil
+        }
+
+        pageCurlCachedViews.removeValue(forKey: pageNum)
+        return cached
+    }
+
+    private func trimCachedPageViews(keeping pageNumbers: Set<Int>) {
+        pageCurlCachedViews = pageCurlCachedViews.filter { key, value in
+            let keep = pageNumbers.contains(key)
+            if !keep {
+                value.removeFromSuperview()
+            }
+            return keep
+        }
+
+        preloadedPageViews = preloadedPageViews.filter { key, value in
+            let keep = pageNumbers.contains(key)
+            if !keep {
+                value.removeFromSuperview()
+            }
+            return keep
+        }
+    }
+
+    private func forecastTargets(around pageNum: Int, preferredForward: Bool?, environment: Environment) -> [Int] {
+        guard environment.totalPages > 0,
+              shouldCachePage(pageNum, environment: environment) else {
+            return []
+        }
+
+        var targets = Set<Int>()
+
+        var previousAnchor = pageNum
+        for _ in 0..<max(radius, 0) {
+            guard let previous = adjacentSpreadStart(from: previousAnchor, forward: false, environment: environment) else { break }
+            targets.formUnion(spreadPageNumbers(startingAt: previous, environment: environment))
+            previousAnchor = previous
+        }
+
+        var nextAnchor = pageNum
+        for _ in 0..<max(radius, 0) {
+            guard let next = adjacentSpreadStart(from: nextAnchor, forward: true, environment: environment) else { break }
+            targets.formUnion(spreadPageNumbers(startingAt: next, environment: environment))
+            nextAnchor = next
+        }
+
+        if let preferredForward,
+           let edgeAnchor = preferredForward ? adjacentSpreadStart(from: nextAnchor, forward: true, environment: environment)
+                                             : adjacentSpreadStart(from: previousAnchor, forward: false, environment: environment) {
+            targets.formUnion(spreadPageNumbers(startingAt: edgeAnchor, environment: environment))
+        }
+
+        return targets.sorted()
+    }
+}