396 lines
16 KiB
Swift
396 lines
16 KiB
Swift
|
|
import UIKit
|
|
|
|
protocol RDEpubReaderCachePolicyProviding {
|
|
var shouldAvoidReaderPageCaching: Bool { get }
|
|
}
|
|
|
|
/// 页面视图被缓存彻底丢弃（旋转失效、窗口裁剪）时的即时清理钩子，
|
|
/// 让持有重资源的页面（如活 WKWebView）不必等 dealloc 就能拆除内容。
|
|
/// 实现方在之后再次被 configure 时必须能恢复可用。
|
|
protocol RDEpubReaderPageResourceReleasing {
|
|
func releaseResources()
|
|
}
|
|
|
|
/// 页面进入或离开当前阅读视口时的生命周期通知。
|
|
/// 持有音视频等持续运行资源的页面应在离开时暂停，在重新进入时恢复。
|
|
protocol RDEpubReaderPageVisibilityHandling: AnyObject {
|
|
func readerPageVisibilityDidChange(isVisible: Bool)
|
|
}
|
|
|
|
final class RDEpubReaderPreloadController {
|
|
|
|
var radius: Int = 2
|
|
|
|
private let preloadHostView = UIView()
|
|
|
|
private var preloadedPageViews: [Int: UIView] = [:]
|
|
|
|
private var pageCurlCachedViews: [Int: UIView] = [:]
|
|
|
|
private var cacheSignature: CacheSignature?
|
|
|
|
struct Environment {
|
|
|
|
let displayType: RDEpubReaderView.DisplayType
|
|
|
|
let isLandscape: Bool
|
|
|
|
let pagesPerScreen: Int
|
|
|
|
let boundsSize: CGSize
|
|
|
|
let landscapeDualPageEnabled: Bool
|
|
|
|
let coverPageIndex: Int?
|
|
|
|
let totalPages: Int
|
|
|
|
let spreadResolver: RDEpubReaderSpreadResolver
|
|
}
|
|
|
|
private struct CacheSignature: Equatable {
|
|
|
|
let displayType: RDEpubReaderView.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) {
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.invalidate",
|
|
"clearing pageCurlCached=\(pageCurlCachedViews.keys.sorted()) preloaded=\(preloadedPageViews.keys.sorted())"
|
|
)
|
|
pageCurlCachedViews.values.forEach { discard($0) }
|
|
preloadedPageViews.values.forEach { discard($0) }
|
|
pageCurlCachedViews.removeAll()
|
|
preloadedPageViews.removeAll()
|
|
cacheSignature = currentCacheSignature(environment)
|
|
}
|
|
|
|
func pageViewForDisplay(
|
|
pageNum: Int,
|
|
environment: Environment,
|
|
contentViewProvider: (Int, UIView?) -> UIView?
|
|
) -> UIView {
|
|
let view: UIView
|
|
if let reusableView = detachedReusablePageView(for: pageNum) {
|
|
view = reusableView
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.pageViewForDisplay",
|
|
"cache HIT page=\(pageNum) view=\(RDEpubReaderTapDebug.describe(reusableView))"
|
|
)
|
|
} else {
|
|
view = contentViewProvider(pageNum, nil) ?? UIView()
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.pageViewForDisplay",
|
|
"cache MISS page=\(pageNum) created=\(RDEpubReaderTapDebug.describe(view))"
|
|
)
|
|
}
|
|
if shouldCache(view: view, for: pageNum, environment: environment) {
|
|
pageCurlCachedViews[pageNum] = view
|
|
} else {
|
|
pageCurlCachedViews.removeValue(forKey: pageNum)
|
|
}
|
|
return view
|
|
}
|
|
|
|
func takePreloadedView(for pageNum: Int) -> UIView? {
|
|
let preloaded = preloadedPageViews.removeValue(forKey: pageNum)
|
|
preloaded?.removeFromSuperview()
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.takePreloadedView",
|
|
"cache \(preloaded == nil ? "MISS" : "HIT") page=\(pageNum) view=\(RDEpubReaderTapDebug.describe(preloaded))"
|
|
)
|
|
return preloaded
|
|
}
|
|
|
|
func updatePageVisibility(visibleViewIdentifiers: Set<ObjectIdentifier>) {
|
|
let cachedViews = pageCurlCachedViews.merging(preloadedPageViews) { current, _ in current }
|
|
var notifiedViews = Set<ObjectIdentifier>()
|
|
|
|
// Cache entries are never the authority for activation: UIPageViewController
|
|
// can create two views for the same page number. Keep every non-winning
|
|
// instance suspended; the reader activates only its actually attached view.
|
|
for view in cachedViews.values {
|
|
let identifier = ObjectIdentifier(view)
|
|
guard !visibleViewIdentifiers.contains(identifier),
|
|
notifiedViews.insert(identifier).inserted else { continue }
|
|
(view as? RDEpubReaderPageVisibilityHandling)?
|
|
.readerPageVisibilityDidChange(isVisible: false)
|
|
}
|
|
}
|
|
|
|
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(spreadPageNumbers(startingAt: pageNum, environment: environment))
|
|
trimCachedPageViews(keeping: keepSet)
|
|
guard !targets.isEmpty else { return }
|
|
|
|
ensureHostView(in: parentView)
|
|
preloadHostView.frame = parentView.bounds
|
|
|
|
for targetPage in targets {
|
|
if let liveCached = pageCurlCachedViews[targetPage],
|
|
liveCached.superview != nil,
|
|
liveCached.superview !== preloadHostView {
|
|
// 该页视图仍挂在翻页控制器的相邻页缓存上，内容已就绪。
|
|
// 以前这里会误删缓存条目并创建一个从零加载的副本顶替，
|
|
// 重内容页翻过去时拿到的是仍在加载的副本，表现为翻页后闪烁重置。
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.prime",
|
|
"skip live page=\(targetPage) view=\(RDEpubReaderTapDebug.describe(liveCached))"
|
|
)
|
|
continue
|
|
}
|
|
let contentView: UIView
|
|
if let existing = preloadedPageViews[targetPage], existing.superview === preloadHostView {
|
|
contentView = existing
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.prime",
|
|
"cache HIT(preloaded) page=\(targetPage) view=\(RDEpubReaderTapDebug.describe(existing))"
|
|
)
|
|
} else if let cached = pageCurlCachedViews.removeValue(forKey: targetPage), cached.superview == nil {
|
|
contentView = cached
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.prime",
|
|
"cache HIT(pageCurl) page=\(targetPage) view=\(RDEpubReaderTapDebug.describe(cached))"
|
|
)
|
|
} else {
|
|
guard let providedView = contentViewProvider(targetPage, nil) else {
|
|
// 页面提供者明确禁止预加载时不能塞入空白占位缓存，
|
|
// 否则真实展示会直接命中白页而不再请求实际内容。
|
|
preloadedPageViews.removeValue(forKey: targetPage)
|
|
pageCurlCachedViews.removeValue(forKey: targetPage)
|
|
continue
|
|
}
|
|
contentView = providedView
|
|
RDEpubReaderTapDebug.log(
|
|
"PreloadController.prime",
|
|
"cache MISS page=\(targetPage) created=\(RDEpubReaderTapDebug.describe(contentView))"
|
|
)
|
|
}
|
|
(contentView as? RDEpubReaderPageVisibilityHandling)?
|
|
.readerPageVisibilityDidChange(isVisible: false)
|
|
let shouldCacheContentView = shouldCache(view: contentView, for: targetPage, environment: environment)
|
|
if shouldCacheContentView {
|
|
preloadedPageViews[targetPage] = contentView
|
|
} else {
|
|
preloadedPageViews.removeValue(forKey: targetPage)
|
|
}
|
|
if contentView.superview !== preloadHostView {
|
|
contentView.removeFromSuperview()
|
|
preloadHostView.addSubview(contentView)
|
|
}
|
|
contentView.frame = preloadHostView.bounds
|
|
if !shouldCacheContentView {
|
|
contentView.removeFromSuperview()
|
|
}
|
|
}
|
|
}
|
|
|
|
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 != RDEpubReaderView.blankPageNum
|
|
&& pageNum != RDEpubReaderView.blankEndPageNum
|
|
&& pageNum < environment.totalPages
|
|
}
|
|
|
|
private func shouldCache(view: UIView, for pageNum: Int, environment: Environment) -> Bool {
|
|
guard shouldCachePage(pageNum, environment: environment) else { return false }
|
|
if let policyProvider = view as? RDEpubReaderCachePolicyProviding {
|
|
return !policyProvider.shouldAvoidReaderPageCaching
|
|
}
|
|
return true
|
|
}
|
|
|
|
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 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 {
|
|
discard(value)
|
|
}
|
|
return keep
|
|
}
|
|
|
|
preloadedPageViews = preloadedPageViews.filter { key, value in
|
|
let keep = pageNumbers.contains(key)
|
|
if !keep {
|
|
discard(value)
|
|
}
|
|
return keep
|
|
}
|
|
}
|
|
|
|
private func discard(_ view: UIView) {
|
|
// 只有闲置视图（未挂载或还在预加载宿主里）才能立即拆除内容；
|
|
// 挂在子 VC / cell 上的视图可能正在展示或会被 UIPageViewController
|
|
// 的缓存重新呈现，提前拆除会让翻页露出空白页。这类视图交由持有方
|
|
// 释放后经 deinit 自然回收（弱代理已保证无保留环）。
|
|
let isHeldOutsidePreloadHost = view.superview != nil && view.superview !== preloadHostView
|
|
(view as? RDEpubReaderPageVisibilityHandling)?
|
|
.readerPageVisibilityDidChange(isVisible: false)
|
|
view.removeFromSuperview()
|
|
if !isHeldOutsidePreloadHost {
|
|
(view as? RDEpubReaderPageResourceReleasing)?.releaseResources()
|
|
}
|
|
}
|
|
|
|
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()
|
|
}
|
|
}
|