shenandshen
6f75b083f7
- 新增 RDEPUBReaderSearchCoordinator 与 RDEPUBSelectionState 管理搜索和选中状态 - 新增 BookmarkChromeStateTests、NavigationBackwardTests、SelectionAnnotateTests 等 UI 测试 - 新增多个边界测试 epub 样本（损坏结构、空归档、缺失文件、流式外链验证） - 重构阅读器 chrome 状态管理，统一 tool bar 与 search bar 交互 - 优化大书分页缓存策略（RDEPUBChapterSummaryDiskCache、RDEPUBPageCountCache） - 移除废弃的 RDEPUBLocationConverter 和 RDEPUBPageBreakPolicy - 更新 epub-bridge.js 与 JS bridge 通信协议 - 全面更新现有 UI 测试以适配新的 helper 和状态管理
363 lines
15 KiB
Swift
363 lines
15 KiB
Swift
// RDEPUBReaderController+DataSource.swift
|
|
// EPUB 阅读器数据源与代理实现
|
|
// 实现 RDReaderDataSource 和 RDReaderDelegate 协议，为阅读器视图提供页面数量、
|
|
// 页面内容视图、页码变化通知、屏幕方向变化处理等核心数据与事件支持。
|
|
|
|
import UIKit
|
|
|
|
/// RDEPUBReaderController 数据源与代理扩展
|
|
///
|
|
/// 本文件实现 RDReaderDataSource 和 RDReaderDelegate 协议，为阅读器视图提供页面数量、
|
|
/// 页面内容视图、页码变化通知、屏幕方向变化处理等核心数据与事件支持。
|
|
|
|
// MARK: - RDReaderView 数据源与代理
|
|
|
|
extension RDEPUBReaderController: RDReaderDataSource, RDReaderDelegate {
|
|
/// 返回阅读器总页数
|
|
public func pageCountOfReaderView(readerView: RDReaderView) -> Int {
|
|
readerContext.bookPageMap?.totalPages ?? textBook?.pages.count ?? activePages.count
|
|
}
|
|
|
|
/// 为指定页码创建或复用内容视图（优先文本渲染，回退 Web 渲染）
|
|
public func pageContentView(readerView: RDReaderView, pageNum: Int, containerView: UIView?) -> UIView {
|
|
if readerContext.bookPageMap != nil {
|
|
_ = runtime.prepareOnDemandChapter(forAbsolutePageNumber: pageNum + 1)
|
|
if let resolvedPage = runtime.pageResolver.resolvePage(absolutePageIndex: pageNum) {
|
|
let contentView = (containerView as? RDEPUBTextContentView) ?? RDEPUBTextContentView()
|
|
contentView.delegate = self
|
|
contentView.configure(
|
|
page: resolvedPage.page,
|
|
pageNumber: pageNum + 1,
|
|
totalPages: pageCountOfReaderView(readerView: readerView),
|
|
configuration: configuration,
|
|
highlights: textHighlights(for: resolvedPage.page),
|
|
searchState: searchState(for: resolvedPage.page)
|
|
)
|
|
return contentView
|
|
}
|
|
}
|
|
|
|
if let textBook, let page = textBook.page(at: pageNum + 1) {
|
|
let contentView = (containerView as? RDEPUBTextContentView) ?? RDEPUBTextContentView()
|
|
contentView.delegate = self
|
|
contentView.configure(
|
|
page: page,
|
|
pageNumber: pageNum + 1,
|
|
totalPages: textBook.pages.count,
|
|
configuration: configuration,
|
|
highlights: textHighlights(for: page),
|
|
searchState: searchState(for: page)
|
|
)
|
|
return contentView
|
|
}
|
|
|
|
guard let publication,
|
|
let request = request(for: pageNum) else {
|
|
return containerView ?? UIView()
|
|
}
|
|
|
|
let contentView = (containerView as? RDEPUBWebContentView) ?? RDEPUBWebContentView()
|
|
contentView.delegate = self
|
|
contentView.configure(
|
|
publication: publication,
|
|
request: request,
|
|
pageNumber: pageNum + 1,
|
|
totalPages: activePages.count,
|
|
theme: configuration.theme
|
|
)
|
|
return contentView
|
|
}
|
|
|
|
/// 返回页面内容视图的重用标识符（区分文本与 Web 渲染）
|
|
public func pageIdentifier(readerView: RDReaderView, pageNum: Int) -> String? {
|
|
(textBook == nil && readerContext.bookPageMap == nil)
|
|
? NSStringFromClass(RDEPUBWebContentView.self)
|
|
: NSStringFromClass(RDEPUBTextContentView.self)
|
|
}
|
|
|
|
/// 获取指定文本页面上的高亮标注列表
|
|
private func textHighlights(for page: RDEPUBTextPage) -> [RDEPUBHighlight] {
|
|
if let textBook,
|
|
let chapterData = textBook.chapterData(for: page.href) {
|
|
return chapterData.highlights(on: page, from: activeHighlights)
|
|
}
|
|
|
|
guard let publication else {
|
|
return activeHighlights.filter { $0.location.href == page.href }
|
|
}
|
|
let pageHref = publication.resourceResolver.normalizedHref(page.href) ?? page.href
|
|
return activeHighlights.filter {
|
|
(publication.resourceResolver.normalizedHref($0.location.href) ?? $0.location.href) == pageHref
|
|
}
|
|
}
|
|
|
|
/// 返回当前文本页需要展示的搜索状态。
|
|
/// 这里会先按页过滤命中结果，并把 currentMatchIndex 重映射到当前页内的局部索引，
|
|
/// 这样渲染层不需要再关心 href 规范化差异。
|
|
private func searchState(for page: RDEPUBTextPage) -> RDEPUBSearchState? {
|
|
guard let globalSearchState = searchState else { return nil }
|
|
|
|
let matches: [RDEPUBSearchMatch]
|
|
let currentMatchIndex: Int?
|
|
|
|
if let chapterData = chapterData(for: page),
|
|
let resolvedState = resolvedSearchState(
|
|
for: page,
|
|
chapterData: chapterData,
|
|
globalSearchState: globalSearchState
|
|
) {
|
|
matches = resolvedState.matches
|
|
currentMatchIndex = resolvedState.currentMatchIndex
|
|
} else {
|
|
matches = globalSearchState.matches.filter { searchMatch in
|
|
searchMatchBelongsToPage(searchMatch, page: page)
|
|
}
|
|
currentMatchIndex = globalSearchState.currentMatch.flatMap { currentMatch in
|
|
matches.firstIndex(of: currentMatch)
|
|
}
|
|
}
|
|
guard !matches.isEmpty || globalSearchState.currentMatch != nil else {
|
|
return globalSearchState.matches.isEmpty ? globalSearchState : nil
|
|
}
|
|
return RDEPUBSearchState(
|
|
keyword: globalSearchState.keyword,
|
|
matches: matches,
|
|
currentMatchIndex: currentMatchIndex
|
|
)
|
|
}
|
|
|
|
private func resolvedSearchState(
|
|
for page: RDEPUBTextPage,
|
|
chapterData: RDEPUBChapterData,
|
|
globalSearchState: RDEPUBSearchState
|
|
) -> RDEPUBSearchState? {
|
|
let normalizedKeyword = globalSearchState.keyword.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !normalizedKeyword.isEmpty else {
|
|
return globalSearchState.matches.isEmpty ? globalSearchState : nil
|
|
}
|
|
|
|
let normalizedHref = normalizedPageHref(for: page)
|
|
let exactMatches = exactChapterSearchMatches(
|
|
in: chapterData,
|
|
keyword: normalizedKeyword,
|
|
normalizedHref: normalizedHref
|
|
)
|
|
let pageMatches = exactMatches.filter { match in
|
|
guard let rangeLocation = match.rangeLocation else { return false }
|
|
let range = NSRange(location: rangeLocation, length: max(match.rangeLength, 1))
|
|
return NSIntersectionRange(range, page.contentRange).length > 0
|
|
}
|
|
|
|
let currentLocalMatchIndex = globalSearchState.currentMatch?.localMatchIndex
|
|
let currentMatchIndex = currentLocalMatchIndex.flatMap { localMatchIndex in
|
|
pageMatches.firstIndex(where: { $0.localMatchIndex == localMatchIndex })
|
|
}
|
|
|
|
guard !pageMatches.isEmpty || currentMatchIndex != nil else {
|
|
return globalSearchState.matches.isEmpty ? globalSearchState : nil
|
|
}
|
|
|
|
return RDEPUBSearchState(
|
|
keyword: globalSearchState.keyword,
|
|
matches: pageMatches,
|
|
currentMatchIndex: currentMatchIndex
|
|
)
|
|
}
|
|
|
|
private func exactChapterSearchMatches(
|
|
in chapterData: RDEPUBChapterData,
|
|
keyword: String,
|
|
normalizedHref: String
|
|
) -> [RDEPUBSearchMatch] {
|
|
let source = chapterData.attributedContent.string as NSString
|
|
let fullLength = source.length
|
|
guard fullLength > 0 else { return [] }
|
|
|
|
var matches: [RDEPUBSearchMatch] = []
|
|
var localMatchIndex = 0
|
|
var searchRange = NSRange(location: 0, length: fullLength)
|
|
|
|
while searchRange.length > 0 {
|
|
let foundRange = source.range(of: keyword, options: [.caseInsensitive], range: searchRange)
|
|
guard foundRange.location != NSNotFound else { break }
|
|
|
|
let progressionDenominator = max(fullLength - 1, 1)
|
|
let progression = Double(foundRange.location) / Double(progressionDenominator)
|
|
matches.append(
|
|
RDEPUBSearchMatch(
|
|
href: normalizedHref,
|
|
progression: progression,
|
|
previewText: previewText(in: source, matchRange: foundRange),
|
|
localMatchIndex: localMatchIndex,
|
|
rangeLocation: foundRange.location,
|
|
rangeLength: max(foundRange.length, 1),
|
|
rangeAnchor: chapterData.rangeAnchor(for: foundRange)
|
|
)
|
|
)
|
|
|
|
localMatchIndex += 1
|
|
let nextLocation = foundRange.location + max(foundRange.length, 1)
|
|
if nextLocation >= fullLength {
|
|
break
|
|
}
|
|
searchRange = NSRange(location: nextLocation, length: fullLength - nextLocation)
|
|
}
|
|
|
|
return matches
|
|
}
|
|
|
|
private func previewText(in text: NSString, matchRange: NSRange) -> String {
|
|
let previewRadius = 12
|
|
let start = max(matchRange.location - previewRadius, 0)
|
|
let end = min(matchRange.location + matchRange.length + previewRadius, text.length)
|
|
let range = NSRange(location: start, length: max(end - start, 0))
|
|
return text.substring(with: range).trimmingCharacters(in: .whitespacesAndNewlines)
|
|
}
|
|
|
|
private func chapterData(for page: RDEPUBTextPage) -> RDEPUBChapterData? {
|
|
if let textBook,
|
|
let chapterData = textBook.chapterData(for: page.href) {
|
|
return chapterData
|
|
}
|
|
|
|
guard let runtimeChapter = runtime.chapterRuntimeStore.chapterData(for: page.spineIndex) else {
|
|
return nil
|
|
}
|
|
return makeChapterData(from: runtimeChapter, chapterIndex: page.chapterIndex)
|
|
}
|
|
|
|
private func makeChapterData(
|
|
from runtimeChapter: RDEPUBRuntimeChapter,
|
|
chapterIndex: Int
|
|
) -> RDEPUBChapterData {
|
|
let textChapter = RDEPUBTextChapter(
|
|
chapterIndex: chapterIndex,
|
|
spineIndex: runtimeChapter.spineIndex,
|
|
href: runtimeChapter.href,
|
|
title: runtimeChapter.title,
|
|
attributedContent: runtimeChapter.typesetAttributedString,
|
|
fragmentOffsets: runtimeChapter.chapterOffsetMap.fragmentOffsets,
|
|
pageBreakReasons: runtimeChapter.pages.map(\.metadata.breakReason),
|
|
pages: runtimeChapter.pages
|
|
)
|
|
return RDEPUBChapterData(
|
|
chapter: textChapter,
|
|
indexTable: RDEPUBTextIndexTable(chapters: [textChapter])
|
|
)
|
|
}
|
|
|
|
private func searchMatchBelongsToPage(_ searchMatch: RDEPUBSearchMatch, page: RDEPUBTextPage) -> Bool {
|
|
if let textBook,
|
|
let chapterData = textBook.chapterData(for: page.href),
|
|
let range = chapterData.absoluteRange(for: searchMatch) {
|
|
return NSIntersectionRange(range, page.contentRange).length > 0
|
|
}
|
|
|
|
let pageHref = normalizedPageHref(for: page)
|
|
let matchHref = normalizedSearchHref(searchMatch.href)
|
|
guard pageHref == matchHref else { return false }
|
|
|
|
guard let rangeLocation = searchMatch.rangeLocation else {
|
|
return false
|
|
}
|
|
let range = NSRange(location: rangeLocation, length: searchMatch.rangeLength)
|
|
return NSIntersectionRange(range, page.contentRange).length > 0
|
|
}
|
|
|
|
private func normalizedPageHref(for page: RDEPUBTextPage) -> String {
|
|
guard let publication else { return page.href }
|
|
return publication.resourceResolver.normalizedHref(page.href) ?? page.href
|
|
}
|
|
|
|
private func normalizedSearchHref(_ href: String) -> String {
|
|
guard let publication else { return href }
|
|
return publication.resourceResolver.normalizedHref(href) ?? href
|
|
}
|
|
|
|
/// 根据规范化 href 获取文本章节数据
|
|
func textChapterData(forNormalizedHref href: String) -> RDEPUBChapterData? {
|
|
readerContext.textChapterData(forNormalizedHref: href)
|
|
}
|
|
|
|
/// 返回阅读器顶部工具视图
|
|
public func topToolView(readerView: RDReaderView) -> UIView? {
|
|
topToolView
|
|
}
|
|
|
|
/// 返回阅读器底部工具视图
|
|
public func bottomToolView(readerView: RDReaderView) -> UIView? {
|
|
bottomToolView
|
|
}
|
|
|
|
/// 页码变化回调：清除选区、同步阅读状态、检测到达末尾
|
|
public func pageNum(readerView: RDReaderView, pageNum: Int) {
|
|
readerContext.markUserNavigationActivity()
|
|
updateCurrentSelection(nil)
|
|
reconcileTextPaginationSizeIfNeeded(for: pageNum)
|
|
|
|
// 用户开始导航时，应用后台解析完成的完整 map
|
|
runtime.applyPendingFullPageMapIfNeeded()
|
|
|
|
if readerContext.bookPageMap != nil {
|
|
_ = runtime.prepareOnDemandChapter(forAbsolutePageNumber: pageNum + 1)
|
|
runtime.extendPartialBookPageMapIfNeeded(currentPageNumber: pageNum + 1)
|
|
}
|
|
|
|
let totalPages = pageCountOfReaderView(readerView: readerView)
|
|
if totalPages > 0, pageNum == totalPages - 1 {
|
|
delegate?.epubReaderDidReachEnd(self)
|
|
}
|
|
|
|
if (textBook != nil || readerContext.bookPageMap != nil),
|
|
let location = resolvedTextLocation(forPageNumber: pageNum + 1) {
|
|
persist(location: location)
|
|
synchronizeTextReadingState(pageNumber: pageNum + 1, location: location)
|
|
return
|
|
}
|
|
|
|
if let location = fallbackLocation(for: pageNum) {
|
|
persist(location: location)
|
|
}
|
|
if readingSession?.navigatorState == .jumping || readingSession?.navigatorState == .moving {
|
|
readingSession?.transition(to: .idle)
|
|
}
|
|
}
|
|
|
|
/// 屏幕方向即将变化回调，捕获待恢复的展示位置
|
|
public func readerViewOrientationWillChange(readerView: RDReaderView, isLandscape: Bool) {
|
|
_ = isLandscape
|
|
runtime.viewportMonitor.capturePendingPresentationRestoreLocation()
|
|
}
|
|
|
|
/// 检测页面尺寸变化并触发重新分页（避免布局错乱）
|
|
private func reconcileTextPaginationSizeIfNeeded(for pageNum: Int) {
|
|
guard textBook != nil || readerContext.bookPageMap != nil,
|
|
!isRepaginating,
|
|
!isReconcilingTextPaginationSize,
|
|
pageNum >= 0,
|
|
let lastTextPaginationPageSize else {
|
|
return
|
|
}
|
|
|
|
let resolvedSize = readerView.resolvedSinglePageSize(pageNum: pageNum)
|
|
guard resolvedSize.width > 0,
|
|
resolvedSize.height > 0 else {
|
|
return
|
|
}
|
|
|
|
let sizeChanged = abs(resolvedSize.width - lastTextPaginationPageSize.width) > 0.5
|
|
|| abs(resolvedSize.height - lastTextPaginationPageSize.height) > 0.5
|
|
guard sizeChanged else {
|
|
return
|
|
}
|
|
|
|
isReconcilingTextPaginationSize = true
|
|
DispatchQueue.main.async { [weak self] in
|
|
guard let self else { return }
|
|
self.isReconcilingTextPaginationSize = false
|
|
guard (self.textBook != nil || self.readerContext.bookPageMap != nil), !self.isRepaginating else { return }
|
|
self.repaginatePreservingCurrentLocation()
|
|
}
|
|
}
|
|
}
|