2142 lines
73 KiB
Swift
2142 lines
73 KiB
Swift
//
|
||
// RDReaderController.swift
|
||
// RDReaderDemo
|
||
//
|
||
// Created by yangsq on 2021/8/10.
|
||
//
|
||
|
||
import SSAlertSwift
|
||
import UIKit
|
||
|
||
/// 书籍来源类型
|
||
public enum BookSource {
|
||
/// TXT文件（Bundle内置）
|
||
case textFile
|
||
/// EPUB文件
|
||
case epubFile(url: URL)
|
||
}
|
||
|
||
public class RDReaderController: UIViewController {
|
||
private static let epubPaginationCacheStorageKey = "epubPaginationCache.key"
|
||
private static let epubValidationStateStorageKey =
|
||
"ssreader.epub.validation.state"
|
||
|
||
public lazy var topToolView: RDReaderTopToolView = {
|
||
let view = RDReaderTopToolView(
|
||
frame: CGRect(
|
||
x: 0,
|
||
y: 0,
|
||
width: view.frame.width,
|
||
height: 44 + UIApplication.shared.statusBarFrame.height
|
||
)
|
||
)
|
||
return view
|
||
}()
|
||
|
||
public lazy var bottomToolView: RDReaderBottomToolView = {
|
||
let view = RDReaderBottomToolView(
|
||
frame: CGRect(
|
||
x: 0,
|
||
y: 0,
|
||
width: view.frame.width,
|
||
height: 55 + RDReaderCommon.safeAreaInsets.bottom
|
||
)
|
||
)
|
||
return view
|
||
}()
|
||
|
||
public lazy var readerView: RDReaderView = {
|
||
let readerView = RDReaderView()
|
||
return readerView
|
||
}()
|
||
|
||
// MARK: - TXT模式数据
|
||
var chapterPages = [ChapterPage]()
|
||
var book = Book(desc: nil, chapters: [])
|
||
var currentChapterNum: Int = 0
|
||
|
||
// MARK: - EPUB模式数据
|
||
var epubParser: RDEPUBParser?
|
||
var epubPublication: RDEPUBPublication?
|
||
var epubSession: RDEPUBReadingSession?
|
||
var epubPaginator: RDEPUBPaginator?
|
||
var epubReadingProfile: RDEPUBReadingProfile?
|
||
var epubTextBook: LegacyRDEPUBTextBook?
|
||
var epubTOCItems: [EPUBTOCDisplayItem] = []
|
||
var epubHighlights: [RDEPUBHighlight] = []
|
||
var currentEPUBBookIdentifier: String?
|
||
private var epubPreloadViews: [Int: RDReaderEPUBContentView] = [:]
|
||
private var epubPageCurlViews: [Int: RDReaderEPUBContentView] = [:]
|
||
private var isBackgroundEPUBPaginationRunning = false
|
||
private var backgroundEPUBPaginationApplyWorkItem: DispatchWorkItem?
|
||
private var epubValidationRunStartedAt: Date?
|
||
private var epubValidationRunReason = "initialLoad"
|
||
|
||
private var epubPages: [EPUBPage] {
|
||
epubSession?.activePages ?? []
|
||
}
|
||
|
||
private var isTextEPUBMode: Bool {
|
||
epubReadingProfile == .textReflowable
|
||
}
|
||
|
||
private var epubChapters: [EPUBChapterInfo] {
|
||
epubSession?.activeChapters ?? []
|
||
}
|
||
|
||
var epubResolver: RDEPUBResourceResolver? {
|
||
epubSession?.resourceResolver ?? epubPublication?.resourceResolver
|
||
}
|
||
|
||
func storeEPUBValidationState(_ values: [String: Any]) {
|
||
var state =
|
||
UserDefaults.standard.dictionary(
|
||
forKey: Self.epubValidationStateStorageKey
|
||
) ?? [:]
|
||
values.forEach { state[$0.key] = $0.value }
|
||
state["timestamp"] = ISO8601DateFormatter().string(from: Date())
|
||
UserDefaults.standard
|
||
.set(state, forKey: Self.epubValidationStateStorageKey)
|
||
}
|
||
|
||
func beginEPUBValidationRun(
|
||
reason: String,
|
||
restoreLocation: RDEPUBLocation?
|
||
) {
|
||
epubValidationRunStartedAt = Date()
|
||
epubValidationRunReason = reason
|
||
|
||
var state = epubValidationSettingsSnapshot()
|
||
state["validationReason"] = reason
|
||
state["restoreRequestedHref"] = restoreLocation?.href ?? ""
|
||
state["restoreRequestedFragment"] = restoreLocation?.fragment ?? ""
|
||
storeEPUBValidationState(state)
|
||
}
|
||
|
||
func storeEPUBPaginationValidation(
|
||
mode: String,
|
||
stage: String,
|
||
pageCount: Int,
|
||
chapterCount: Int,
|
||
tocCount: Int,
|
||
restoreLocation: RDEPUBLocation?,
|
||
resolvedRestorePage: Int?
|
||
) {
|
||
var state = epubValidationSettingsSnapshot()
|
||
state["mode"] = mode
|
||
state["validationReason"] = epubValidationRunReason
|
||
state["paginationStage"] = stage
|
||
state["pageCount"] = pageCount
|
||
state["chapterCount"] = chapterCount
|
||
state["tocCount"] = tocCount
|
||
state["restoreRequestedHref"] = restoreLocation?.href ?? ""
|
||
state["restoreRequestedFragment"] = restoreLocation?.fragment ?? ""
|
||
state["restoreResolvedPage"] = resolvedRestorePage ?? 0
|
||
if let startedAt = epubValidationRunStartedAt {
|
||
state["paginationDurationMs"] = Int(
|
||
Date().timeIntervalSince(startedAt) * 1000
|
||
)
|
||
}
|
||
storeEPUBValidationState(state)
|
||
}
|
||
|
||
func storeEPUBTOCValidation(item: EPUBTOCDisplayItem, resolvedPage: Int?) {
|
||
storeEPUBValidationState([
|
||
"tocSelectionTitle": item.title,
|
||
"tocSelectionHref": item.href,
|
||
"tocSelectionDepth": item.depth,
|
||
"tocSelectionResolvedPage": resolvedPage ?? 0,
|
||
"tocSelectionCount": epubTOCItems.count,
|
||
])
|
||
}
|
||
|
||
func storeEPUBEndValidationState(pageNum: Int, reachedEndScreen: Bool) {
|
||
storeEPUBValidationState([
|
||
"lastVisitedPage": pageNum,
|
||
"didReachReadableEnd": true,
|
||
"didReachEndScreen": reachedEndScreen,
|
||
])
|
||
}
|
||
|
||
private func epubValidationSettingsSnapshot() -> [String: Any] {
|
||
[
|
||
"settingsTheme": RDReaderManager.shared.themeType.currentType
|
||
.rawValue,
|
||
"settingsFontSize": RDReaderManager.shared.fontValue.currentType,
|
||
"settingsLineSpacing": RDReaderManager.shared.lineSpaceType
|
||
.currentType.rawValue,
|
||
"settingsLineSpacingMultiple": RDReaderManager.shared.lineSpaceType
|
||
.currentType.mulitiple,
|
||
"settingsDisplayType": RDReaderManager.shared.pageCurlTypeType
|
||
.currentType.rawValue,
|
||
"settingsBrightness": RDReaderManager.shared.brightValue
|
||
.currentType,
|
||
]
|
||
}
|
||
|
||
private func currentReadableEPUBPageCount() -> Int {
|
||
isTextEPUBMode ? (epubTextBook?.pages.count ?? 0) : epubPages.count
|
||
}
|
||
|
||
private func resolvedEPUBRestorePageNumber(for location: RDEPUBLocation?)
|
||
-> Int?
|
||
{
|
||
guard let location else { return nil }
|
||
return epubSession?
|
||
.pageIndex(for: location, bookIdentifier: currentEPUBBookIdentifier)
|
||
.map { $0 + 1 }
|
||
}
|
||
|
||
/// 加载指示器
|
||
private lazy var loadingIndicator: UIActivityIndicatorView = {
|
||
let indicator: UIActivityIndicatorView
|
||
if #available(iOS 13.0, *) {
|
||
indicator = UIActivityIndicatorView(style: .large)
|
||
} else {
|
||
indicator = UIActivityIndicatorView(style: .whiteLarge)
|
||
}
|
||
indicator.hidesWhenStopped = true
|
||
indicator.color = .gray
|
||
return indicator
|
||
}()
|
||
|
||
private lazy var epubPaginationHostView: UIView = {
|
||
let hostView = UIView(frame: .zero)
|
||
hostView.alpha = 0.01
|
||
hostView.isUserInteractionEnabled = false
|
||
hostView.clipsToBounds = true
|
||
hostView.accessibilityElementsHidden = true
|
||
return hostView
|
||
}()
|
||
|
||
private lazy var epubPreloadHostView: UIView = {
|
||
let hostView = UIView(frame: .zero)
|
||
hostView.alpha = 0.01
|
||
hostView.isUserInteractionEnabled = false
|
||
hostView.clipsToBounds = true
|
||
hostView.accessibilityElementsHidden = true
|
||
return hostView
|
||
}()
|
||
|
||
var isReaderContentReady = false
|
||
|
||
/// 书籍来源，默认为TXT文件
|
||
var bookSource: BookSource = .textFile
|
||
|
||
/// 便捷初始化，指定EPUB文件
|
||
convenience init(epubURL: URL) {
|
||
self.init()
|
||
self.bookSource = .epubFile(url: epubURL)
|
||
}
|
||
|
||
public override func viewDidLoad() {
|
||
super.viewDidLoad()
|
||
makeUI()
|
||
|
||
switch bookSource {
|
||
case .textFile:
|
||
loadData()
|
||
isReaderContentReady = true
|
||
readerView.reloadData()
|
||
transitionToPage()
|
||
case .epubFile(let url):
|
||
loadEPUBData(url: url)
|
||
}
|
||
}
|
||
|
||
public override func viewWillAppear(_ animated: Bool) {
|
||
super.viewWillAppear(animated)
|
||
self.navigationController?
|
||
.setNavigationBarHidden(true, animated: animated)
|
||
}
|
||
|
||
public override func viewWillDisappear(_ animated: Bool) {
|
||
super.viewWillDisappear(animated)
|
||
self.navigationController?
|
||
.setNavigationBarHidden(false, animated: animated)
|
||
}
|
||
|
||
// MARK: - TXT数据加载
|
||
|
||
func loadData() {
|
||
updateReaderViewConfiguration()
|
||
epubPublication = nil
|
||
epubSession = nil
|
||
epubReadingProfile = nil
|
||
epubTextBook = nil
|
||
currentEPUBBookIdentifier = nil
|
||
epubTOCItems = []
|
||
epubHighlights = []
|
||
clearStagedBackgroundEPUBPagination()
|
||
clearEPUBPreloadCache()
|
||
let fontSize = RDReaderManager.shared.fontValue.currentType
|
||
let lineSapce = RDReaderManager.shared.lineSpaceType.currentType
|
||
let pageWidth: CGFloat
|
||
if readerView.pagesPerScreen > 1 {
|
||
pageWidth =
|
||
view.frame.width
|
||
/ CGFloat(
|
||
readerView.pagesPerScreen
|
||
) - 16 * 2
|
||
} else {
|
||
pageWidth = view.frame.width - 16 * 2
|
||
}
|
||
let pageSize = CGSize(
|
||
width: pageWidth,
|
||
height: view.frame.height - 40 * 2
|
||
)
|
||
let font = UIFont.systemFont(ofSize: fontSize)
|
||
let lineSpaceValue = lineSapce.mulitiple * 15
|
||
|
||
book = RDReaderManager.shared
|
||
.encodeTextFile(
|
||
font: font,
|
||
lineSapce: lineSpaceValue,
|
||
size: pageSize
|
||
)
|
||
chapterPages = book.chapters.reduce(
|
||
[],
|
||
{ result, chapter in
|
||
result + chapter.pages
|
||
}
|
||
)
|
||
}
|
||
|
||
func transitionToPage(rangeLocation: Int? = nil) {
|
||
var rangeLoc = RDReaderManager.shared.readProgress.currentType
|
||
if rangeLocation != nil {
|
||
rangeLoc = rangeLocation!
|
||
}
|
||
if let pageNum = chapterPages.firstIndex(
|
||
where: { chapterPage in
|
||
let chapter = self.book.chapters[chapterPage.chapterSort - 1]
|
||
let chapterRange = chapter.range
|
||
let range = NSMakeRange(
|
||
chapterRange.location + chapterPage.range.location,
|
||
chapterPage.range.length
|
||
)
|
||
return range.contains(rangeLoc)
|
||
})
|
||
{
|
||
readerView.transitionToPage(pageNum: pageNum + 1)
|
||
}
|
||
}
|
||
|
||
// MARK: - EPUB数据加载（异步）
|
||
|
||
func loadEPUBData(url: URL) {
|
||
isReaderContentReady = false
|
||
currentEPUBBookIdentifier = nil
|
||
epubTOCItems = []
|
||
epubHighlights = []
|
||
clearStagedBackgroundEPUBPagination()
|
||
clearEPUBPreloadCache()
|
||
// 显示加载指示器
|
||
showLoading()
|
||
|
||
// 1. 解析EPUB结构
|
||
let parser = RDEPUBParser()
|
||
do {
|
||
try parser.parse(epubURL: url)
|
||
} catch {
|
||
hideLoading()
|
||
print("EPUB解析失败: \(error.localizedDescription)")
|
||
return
|
||
}
|
||
self.epubParser = parser
|
||
let publication = parser.makePublication()
|
||
self.epubPublication = publication
|
||
let session = RDEPUBReadingSession(publication: publication)
|
||
session.transition(to: .loading)
|
||
self.epubSession = session
|
||
self.epubReadingProfile = publication.readingProfile
|
||
self.epubTextBook = nil
|
||
updateReaderViewConfiguration()
|
||
self.currentEPUBBookIdentifier =
|
||
parser.metadata.identifier ?? url.lastPathComponent
|
||
self.epubHighlights = storedEPUBHighlights()
|
||
let savedLocation = storedEPUBLocation()
|
||
beginEPUBValidationRun(
|
||
reason: "initialLoad",
|
||
restoreLocation: savedLocation
|
||
)
|
||
|
||
let debugBookName =
|
||
title ?? url.deletingPathExtension().lastPathComponent
|
||
print(
|
||
"[EPUB] Load book=\(debugBookName) profile=\(publication.readingProfile.rawValue) spine=\(parser.spine.count)"
|
||
)
|
||
storeEPUBValidationState([
|
||
"bookTitle": debugBookName,
|
||
"profile": publication.readingProfile.rawValue,
|
||
"spineCount": parser.spine.count,
|
||
"bookIdentifier": currentEPUBBookIdentifier ?? "",
|
||
])
|
||
|
||
if publication.readingProfile == .textReflowable {
|
||
loadEPUBTextBook(
|
||
parser: parser,
|
||
publication: publication,
|
||
restoreLocation: savedLocation
|
||
)
|
||
return
|
||
}
|
||
|
||
// 2. 使用WKWebView预计算每章页数
|
||
let layoutContext = currentEPUBLayoutContext()
|
||
let viewportSize = layoutContext.viewportSize
|
||
let preferences = RDReaderManager.shared.epubPreferences(
|
||
reflowableInsets: layoutContext.reflowableContentInsets,
|
||
fixedContentInset: layoutContext.fixedContentInset
|
||
)
|
||
if let cacheKey = epubPaginationCacheKey(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: preferences.reflowableContentInsets,
|
||
fontSize: preferences.fontSize,
|
||
lineHeightMultiple: preferences.lineHeightMultiple
|
||
),
|
||
let cachedPageCounts = cachedEPUBPageCounts(
|
||
for: cacheKey,
|
||
expectedSpineCount: parser.spine.count
|
||
)
|
||
{
|
||
finishEPUBPagination(
|
||
pageCounts: cachedPageCounts,
|
||
restoreLocation: savedLocation,
|
||
validationStage: "cache"
|
||
)
|
||
return
|
||
}
|
||
|
||
if parser.metadata.layout != .fixed {
|
||
let initialSpineIndex = initialEPUBSpineIndex(
|
||
for: savedLocation,
|
||
parser: parser
|
||
)
|
||
let paginator = RDEPUBPaginator()
|
||
self.epubPaginator = paginator
|
||
paginator.calculateSingleSpinePageCount(
|
||
parser: parser,
|
||
spineIndex: initialSpineIndex,
|
||
hostingView: ensureEPUBPaginationHostView(
|
||
viewportSize: viewportSize
|
||
),
|
||
presentation:
|
||
preferences
|
||
.presentationStyle(viewportSize: viewportSize)
|
||
) { [weak self] pageCount in
|
||
guard let self = self else { return }
|
||
var provisionalPageCounts = Array(
|
||
repeating: 1,
|
||
count: parser.spine.count
|
||
)
|
||
provisionalPageCounts[initialSpineIndex] = max(1, pageCount)
|
||
self.finishEPUBPagination(
|
||
pageCounts: provisionalPageCounts,
|
||
restoreLocation: savedLocation,
|
||
validationStage: "provisional"
|
||
)
|
||
self.epubPaginator = nil
|
||
self.startBackgroundEPUBPagination(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: preferences.reflowableContentInsets,
|
||
fontSize: preferences.fontSize,
|
||
lineHeightMultiple: preferences.lineHeightMultiple,
|
||
restoreLocation: savedLocation
|
||
)
|
||
}
|
||
return
|
||
}
|
||
|
||
let paginator = RDEPUBPaginator()
|
||
self.epubPaginator = paginator
|
||
|
||
paginator.calculate(
|
||
parser: parser,
|
||
hostingView: ensureEPUBPaginationHostView(
|
||
viewportSize: viewportSize
|
||
),
|
||
presentation:
|
||
preferences
|
||
.presentationStyle(viewportSize: viewportSize)
|
||
) { [weak self] pageCounts in
|
||
guard let self = self else { return }
|
||
if let cacheKey = self.epubPaginationCacheKey(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: preferences.reflowableContentInsets,
|
||
fontSize: preferences.fontSize,
|
||
lineHeightMultiple: preferences.lineHeightMultiple
|
||
) {
|
||
self.saveEPUBPageCounts(pageCounts, for: cacheKey)
|
||
}
|
||
self.finishEPUBPagination(
|
||
pageCounts: pageCounts,
|
||
restoreLocation: savedLocation,
|
||
validationStage: "initial"
|
||
)
|
||
self.epubPaginator = nil
|
||
}
|
||
}
|
||
|
||
/// 重新分页EPUB（字号/行距改变时）
|
||
func repaginateEPUB(reason: String = "repaginate") {
|
||
guard let parser = epubParser, let session = epubSession else { return }
|
||
updateReaderViewConfiguration()
|
||
session.transition(to: .repaginating)
|
||
|
||
isReaderContentReady = false
|
||
showLoading()
|
||
clearStagedBackgroundEPUBPagination()
|
||
clearEPUBPreloadCache()
|
||
|
||
let layoutContext = currentEPUBLayoutContext()
|
||
let viewportSize = layoutContext.viewportSize
|
||
let preferences = RDReaderManager.shared.epubPreferences(
|
||
reflowableInsets: layoutContext.reflowableContentInsets,
|
||
fixedContentInset: layoutContext.fixedContentInset
|
||
)
|
||
|
||
let savedLocation = storedEPUBLocation() ?? currentVisibleEPUBLocation()
|
||
beginEPUBValidationRun(reason: reason, restoreLocation: savedLocation)
|
||
if isTextEPUBMode, let publication = epubPublication {
|
||
loadEPUBTextBook(
|
||
parser: parser,
|
||
publication: publication,
|
||
restoreLocation: savedLocation
|
||
)
|
||
return
|
||
}
|
||
|
||
if let cacheKey = epubPaginationCacheKey(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: preferences.reflowableContentInsets,
|
||
fontSize: preferences.fontSize,
|
||
lineHeightMultiple: preferences.lineHeightMultiple
|
||
),
|
||
let cachedPageCounts = cachedEPUBPageCounts(
|
||
for: cacheKey,
|
||
expectedSpineCount: parser.spine.count
|
||
)
|
||
{
|
||
finishEPUBPagination(
|
||
pageCounts: cachedPageCounts,
|
||
restoreLocation: savedLocation,
|
||
validationStage: "cache"
|
||
)
|
||
return
|
||
}
|
||
|
||
if parser.metadata.layout != .fixed {
|
||
let initialSpineIndex = initialEPUBSpineIndex(
|
||
for: savedLocation,
|
||
parser: parser
|
||
)
|
||
let paginator = RDEPUBPaginator()
|
||
self.epubPaginator = paginator
|
||
paginator.calculateSingleSpinePageCount(
|
||
parser: parser,
|
||
spineIndex: initialSpineIndex,
|
||
hostingView: ensureEPUBPaginationHostView(
|
||
viewportSize: viewportSize
|
||
),
|
||
presentation:
|
||
preferences
|
||
.presentationStyle(viewportSize: viewportSize)
|
||
) { [weak self] pageCount in
|
||
guard let self = self else { return }
|
||
var provisionalPageCounts = Array(
|
||
repeating: 1,
|
||
count: parser.spine.count
|
||
)
|
||
provisionalPageCounts[initialSpineIndex] = max(1, pageCount)
|
||
self.finishEPUBPagination(
|
||
pageCounts: provisionalPageCounts,
|
||
restoreLocation: savedLocation,
|
||
validationStage: "provisional"
|
||
)
|
||
self.epubPaginator = nil
|
||
self.startBackgroundEPUBPagination(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: preferences.reflowableContentInsets,
|
||
fontSize: preferences.fontSize,
|
||
lineHeightMultiple: preferences.lineHeightMultiple,
|
||
restoreLocation: savedLocation
|
||
)
|
||
}
|
||
return
|
||
}
|
||
|
||
let paginator = RDEPUBPaginator()
|
||
self.epubPaginator = paginator
|
||
|
||
paginator.calculate(
|
||
parser: parser,
|
||
hostingView: ensureEPUBPaginationHostView(
|
||
viewportSize: viewportSize
|
||
),
|
||
presentation:
|
||
preferences
|
||
.presentationStyle(viewportSize: viewportSize)
|
||
) { [weak self] pageCounts in
|
||
guard let self = self else { return }
|
||
if let cacheKey = self.epubPaginationCacheKey(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: preferences.reflowableContentInsets,
|
||
fontSize: preferences.fontSize,
|
||
lineHeightMultiple: preferences.lineHeightMultiple
|
||
) {
|
||
self.saveEPUBPageCounts(pageCounts, for: cacheKey)
|
||
}
|
||
self.finishEPUBPagination(
|
||
pageCounts: pageCounts,
|
||
restoreLocation: savedLocation,
|
||
validationStage: "initial"
|
||
)
|
||
self.epubPaginator = nil
|
||
}
|
||
}
|
||
|
||
private func finishEPUBPagination(
|
||
pageCounts: [Int],
|
||
restoreLocation: RDEPUBLocation?,
|
||
validationStage: String
|
||
) {
|
||
guard let session = epubSession else { return }
|
||
let snapshot = session.makePaginationSnapshot(
|
||
pageCounts: pageCounts,
|
||
preferences: currentEPUBPreferences(),
|
||
layoutContext: currentEPUBLayoutContext()
|
||
)
|
||
applyEPUBPaginationSnapshot(
|
||
snapshot,
|
||
restoreLocation: restoreLocation,
|
||
hideLoadingIndicator: true,
|
||
validationStage: validationStage
|
||
)
|
||
}
|
||
|
||
private func applyEPUBPaginationSnapshot(
|
||
_ snapshot: (pages: [EPUBPage], chapters: [EPUBChapterInfo]),
|
||
restoreLocation: RDEPUBLocation?,
|
||
hideLoadingIndicator: Bool,
|
||
validationStage: String
|
||
) {
|
||
epubSession?.setActiveSnapshot(snapshot)
|
||
if let publication = epubPublication {
|
||
epubTOCItems = flattenedTOCItems(from: publication.tableOfContents)
|
||
}
|
||
storeEPUBPaginationValidation(
|
||
mode: epubReadingProfile?.rawValue ?? "unknown",
|
||
stage: validationStage,
|
||
pageCount: snapshot.pages.count,
|
||
chapterCount: snapshot.chapters.count,
|
||
tocCount: epubTOCItems.count,
|
||
restoreLocation: restoreLocation,
|
||
resolvedRestorePage: resolvedEPUBRestorePageNumber(
|
||
for: restoreLocation
|
||
)
|
||
)
|
||
isReaderContentReady = true
|
||
if hideLoadingIndicator {
|
||
hideLoading()
|
||
}
|
||
readerView.reloadData()
|
||
restoreEPUBLocation(restoreLocation)
|
||
if restoreLocation == nil {
|
||
epubSession?.transition(to: .idle)
|
||
}
|
||
}
|
||
|
||
private func queueBackgroundEPUBPaginationApplication(
|
||
pageCounts: [Int],
|
||
restoreLocation: RDEPUBLocation?
|
||
) {
|
||
guard let session = epubSession else { return }
|
||
let snapshot = session.makePaginationSnapshot(
|
||
pageCounts: pageCounts,
|
||
preferences: currentEPUBPreferences(),
|
||
layoutContext: currentEPUBLayoutContext()
|
||
)
|
||
epubSession?.stageSnapshot(snapshot, restoreLocation: restoreLocation)
|
||
schedulePendingBackgroundEPUBPaginationApplication()
|
||
}
|
||
|
||
private func schedulePendingBackgroundEPUBPaginationApplication() {
|
||
backgroundEPUBPaginationApplyWorkItem?.cancel()
|
||
let workItem = DispatchWorkItem { [weak self] in
|
||
self?.applyPendingBackgroundEPUBPaginationIfNeeded()
|
||
}
|
||
backgroundEPUBPaginationApplyWorkItem = workItem
|
||
DispatchQueue.main
|
||
.asyncAfter(deadline: .now() + 0.35, execute: workItem)
|
||
}
|
||
|
||
private func applyPendingBackgroundEPUBPaginationIfNeeded() {
|
||
if let staged = epubSession?.consumeStagedSnapshotIfAllowed() {
|
||
let restoreLocation =
|
||
staged.restoreLocation ?? storedEPUBLocation()
|
||
?? currentVisibleEPUBLocation()
|
||
backgroundEPUBPaginationApplyWorkItem = nil
|
||
applyEPUBPaginationSnapshot(
|
||
staged.snapshot,
|
||
restoreLocation: restoreLocation,
|
||
hideLoadingIndicator: false,
|
||
validationStage: "backgroundFinal"
|
||
)
|
||
return
|
||
}
|
||
guard epubSession?.stagedSnapshot() != nil else { return }
|
||
schedulePendingBackgroundEPUBPaginationApplication()
|
||
}
|
||
|
||
private func clearStagedBackgroundEPUBPagination() {
|
||
backgroundEPUBPaginationApplyWorkItem?.cancel()
|
||
backgroundEPUBPaginationApplyWorkItem = nil
|
||
epubSession?.clearStagedSnapshot()
|
||
}
|
||
|
||
private func initialEPUBSpineIndex(
|
||
for location: RDEPUBLocation?,
|
||
parser: RDEPUBParser
|
||
) -> Int {
|
||
let _ = parser
|
||
return epubSession?.initialSpineIndex(for: location) ?? 0
|
||
}
|
||
|
||
private func startBackgroundEPUBPagination(
|
||
parser: RDEPUBParser,
|
||
viewportSize: CGSize,
|
||
padding: UIEdgeInsets,
|
||
fontSize: CGFloat,
|
||
lineHeightMultiple: CGFloat,
|
||
restoreLocation: RDEPUBLocation?
|
||
) {
|
||
guard !isBackgroundEPUBPaginationRunning else { return }
|
||
isBackgroundEPUBPaginationRunning = true
|
||
|
||
let paginator = RDEPUBPaginator()
|
||
self.epubPaginator = paginator
|
||
let preferences = currentEPUBPreferences()
|
||
paginator.calculate(
|
||
parser: parser,
|
||
hostingView: ensureEPUBPaginationHostView(
|
||
viewportSize: viewportSize
|
||
),
|
||
presentation:
|
||
preferences
|
||
.presentationStyle(viewportSize: viewportSize)
|
||
) { [weak self] pageCounts in
|
||
guard let self = self else { return }
|
||
self.isBackgroundEPUBPaginationRunning = false
|
||
if let cacheKey = self.epubPaginationCacheKey(
|
||
parser: parser,
|
||
viewportSize: viewportSize,
|
||
padding: padding,
|
||
fontSize: fontSize,
|
||
lineHeightMultiple: lineHeightMultiple
|
||
) {
|
||
self.saveEPUBPageCounts(pageCounts, for: cacheKey)
|
||
}
|
||
let currentLocation =
|
||
self.storedEPUBLocation() ?? self.currentVisibleEPUBLocation()
|
||
?? restoreLocation
|
||
self.queueBackgroundEPUBPaginationApplication(
|
||
pageCounts: pageCounts,
|
||
restoreLocation: currentLocation
|
||
)
|
||
self.epubPaginator = nil
|
||
}
|
||
}
|
||
|
||
private func epubPaginationCacheKey(
|
||
parser: RDEPUBParser,
|
||
viewportSize: CGSize,
|
||
padding: UIEdgeInsets,
|
||
fontSize: CGFloat,
|
||
lineHeightMultiple: CGFloat
|
||
) -> String? {
|
||
let bookSignature: String
|
||
switch bookSource {
|
||
case .textFile:
|
||
return nil
|
||
case .epubFile(let url):
|
||
let attributes = try? FileManager.default.attributesOfItem(
|
||
atPath: url.path
|
||
)
|
||
let fileSize = (attributes?[.size] as? NSNumber)?.stringValue ?? "0"
|
||
let modifiedAt =
|
||
(attributes?[.modificationDate] as? Date)?.timeIntervalSince1970
|
||
?? 0
|
||
bookSignature = [
|
||
url.lastPathComponent,
|
||
fileSize,
|
||
String(format: "%.0f", modifiedAt),
|
||
]
|
||
.joined(separator: "|")
|
||
}
|
||
|
||
let layoutSignature = [
|
||
Int(viewportSize.width.rounded()).description,
|
||
Int(viewportSize.height.rounded()).description,
|
||
Int(padding.top.rounded()).description,
|
||
Int(padding.left.rounded()).description,
|
||
Int(padding.bottom.rounded()).description,
|
||
Int(padding.right.rounded()).description,
|
||
String(format: "%.2f", fontSize),
|
||
String(format: "%.2f", lineHeightMultiple),
|
||
String(readerView.pagesPerScreen),
|
||
parser.metadata.layout.rawValue,
|
||
String(parser.spine.count),
|
||
].joined(separator: "|")
|
||
|
||
return bookSignature + "|" + layoutSignature
|
||
}
|
||
|
||
private func cachedEPUBPageCounts(for key: String, expectedSpineCount: Int)
|
||
-> [Int]?
|
||
{
|
||
let cache =
|
||
UserDefaults.standard.dictionary(
|
||
forKey: Self.epubPaginationCacheStorageKey
|
||
) ?? [:]
|
||
let rawCounts = cache[key]
|
||
let counts: [Int]?
|
||
if let values = rawCounts as? [Int] {
|
||
counts = values
|
||
} else if let values = rawCounts as? [NSNumber] {
|
||
counts = values.map(\.intValue)
|
||
} else {
|
||
counts = nil
|
||
}
|
||
guard let counts, counts.count == expectedSpineCount else {
|
||
return nil
|
||
}
|
||
return counts.map { max(1, $0) }
|
||
}
|
||
|
||
private func saveEPUBPageCounts(_ pageCounts: [Int], for key: String) {
|
||
var cache =
|
||
UserDefaults.standard.dictionary(
|
||
forKey: Self.epubPaginationCacheStorageKey
|
||
) ?? [:]
|
||
cache[key] = pageCounts.map { max(1, $0) }
|
||
UserDefaults.standard
|
||
.set(cache, forKey: Self.epubPaginationCacheStorageKey)
|
||
}
|
||
|
||
private func currentEPUBLayoutContext() -> RDEPUBNavigatorLayoutContext {
|
||
let readerBounds =
|
||
readerView.bounds.size == .zero
|
||
? view.bounds.size : readerView.bounds.size
|
||
let safeAreaInsets = view.window?.safeAreaInsets ?? view.safeAreaInsets
|
||
return RDEPUBNavigatorLayoutContext(
|
||
containerSize: readerBounds,
|
||
pagesPerScreen: readerView.pagesPerScreen,
|
||
safeAreaInsets: safeAreaInsets,
|
||
userInterfaceIdiom: UIDevice.current.userInterfaceIdiom
|
||
)
|
||
}
|
||
|
||
private func currentEPUBPreferences(theme: RDReaderTheme? = nil)
|
||
-> RDEPUBPreferences
|
||
{
|
||
let layoutContext = currentEPUBLayoutContext()
|
||
return RDReaderManager.shared.epubPreferences(
|
||
theme: theme,
|
||
reflowableInsets: layoutContext.reflowableContentInsets,
|
||
fixedContentInset: layoutContext.fixedContentInset
|
||
)
|
||
}
|
||
|
||
private func renderRequest(
|
||
for pageNum: Int,
|
||
page: EPUBPage,
|
||
publication: RDEPUBPublication,
|
||
theme: RDReaderTheme
|
||
) -> RDEPUBRenderRequest? {
|
||
let preferences = currentEPUBPreferences(theme: theme)
|
||
let layoutContext = currentEPUBLayoutContext()
|
||
let targetLocation = epubSession?.pendingLocation(
|
||
forPageNumber: pageNum,
|
||
spineIndex: page.fixedSpread == nil ? page.spineIndex : nil
|
||
)
|
||
return preferences.renderRequest(
|
||
for: page,
|
||
publication: publication,
|
||
viewportSize: layoutContext.viewportSize,
|
||
targetLocation: targetLocation,
|
||
highlights: highlights(for: page.spineIndex)
|
||
)
|
||
}
|
||
|
||
private func updateReaderViewConfiguration() {
|
||
switch bookSource {
|
||
case .textFile:
|
||
readerView.landscapeDualPageEnabled = true
|
||
readerView.pageDirection = .rightToLeft
|
||
case .epubFile:
|
||
let isFixedLayout = epubPublication?.layout == .fixed
|
||
readerView.landscapeDualPageEnabled = !isFixedLayout
|
||
|
||
switch epubPublication?.readingProgression {
|
||
case .ltr:
|
||
readerView.pageDirection = .leftToRight
|
||
case .rtl:
|
||
readerView.pageDirection = .rightToLeft
|
||
case .some(.auto):
|
||
readerView.pageDirection = .rightToLeft
|
||
case .none:
|
||
readerView.pageDirection = .rightToLeft
|
||
}
|
||
|
||
let preferredDisplayType = effectiveDisplayType(
|
||
requested: RDReaderManager.shared.pageCurlTypeType.currentType
|
||
.value
|
||
)
|
||
if readerView.currentDisplayType != preferredDisplayType {
|
||
readerView.switchReaderDisplayType(preferredDisplayType)
|
||
}
|
||
}
|
||
}
|
||
|
||
private func effectiveDisplayType(requested: RDReaderView.DisplayType)
|
||
-> RDReaderView.DisplayType
|
||
{
|
||
guard epubPublication?.layout == .fixed else {
|
||
return requested
|
||
}
|
||
|
||
if requested == .pageCurl {
|
||
return .horizontalScroll
|
||
}
|
||
return requested
|
||
}
|
||
|
||
private func saveEPUBLocation(_ location: RDEPUBLocation) {
|
||
let scopedLocation = RDEPUBLocation(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
href: location.href,
|
||
progression: location.progression,
|
||
lastProgression: location.lastProgression,
|
||
fragment: location.fragment
|
||
)
|
||
guard
|
||
let data = try? JSONEncoder().encode(scopedLocation),
|
||
let json = String(data: data, encoding: .utf8)
|
||
else {
|
||
return
|
||
}
|
||
RDReaderManager.shared.epubReadLocation.currentType = json
|
||
}
|
||
|
||
private func saveEPUBSelection(_ selection: RDEPUBSelection?) {
|
||
guard let selection = selection, !selection.isEmpty else {
|
||
RDReaderManager.shared.epubSelection.currentType = ""
|
||
return
|
||
}
|
||
let scopedSelection = RDEPUBSelection(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
location: RDEPUBLocation(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
href: selection.location.href,
|
||
progression: selection.location.progression,
|
||
lastProgression: selection.location.lastProgression,
|
||
fragment: selection.location.fragment
|
||
),
|
||
text: selection.text,
|
||
rangeInfo: selection.rangeInfo,
|
||
createdAt: selection.createdAt
|
||
)
|
||
guard
|
||
let data = try? JSONEncoder().encode(scopedSelection),
|
||
let json = String(data: data, encoding: .utf8)
|
||
else {
|
||
return
|
||
}
|
||
RDReaderManager.shared.epubSelection.currentType = json
|
||
}
|
||
|
||
private func storedEPUBSelection() -> RDEPUBSelection? {
|
||
let json = RDReaderManager.shared.epubSelection.currentType
|
||
guard !json.isEmpty, let data = json.data(using: .utf8) else {
|
||
return nil
|
||
}
|
||
guard
|
||
let selection = try? JSONDecoder().decode(
|
||
RDEPUBSelection.self,
|
||
from: data
|
||
)
|
||
else {
|
||
return nil
|
||
}
|
||
guard selection.bookIdentifier == currentEPUBBookIdentifier else {
|
||
return nil
|
||
}
|
||
return selection
|
||
}
|
||
|
||
private func allStoredEPUBHighlights() -> [RDEPUBHighlight] {
|
||
let json = RDReaderManager.shared.epubHighlights.currentType
|
||
guard !json.isEmpty, let data = json.data(using: .utf8) else {
|
||
return []
|
||
}
|
||
return (try? JSONDecoder().decode([RDEPUBHighlight].self, from: data))
|
||
?? []
|
||
}
|
||
|
||
private func storedEPUBHighlights() -> [RDEPUBHighlight] {
|
||
allStoredEPUBHighlights()
|
||
.filter { $0.bookIdentifier == currentEPUBBookIdentifier }
|
||
}
|
||
|
||
private func saveEPUBHighlights(_ highlights: [RDEPUBHighlight]) {
|
||
let scopedHighlights = highlights.map { highlight in
|
||
RDEPUBHighlight(
|
||
id: highlight.id,
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
location: RDEPUBLocation(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
href: highlight.location.href,
|
||
progression: highlight.location.progression,
|
||
lastProgression: highlight.location.lastProgression,
|
||
fragment: highlight.location.fragment
|
||
),
|
||
text: highlight.text,
|
||
rangeInfo: highlight.rangeInfo,
|
||
color: highlight.color,
|
||
note: highlight.note,
|
||
createdAt: highlight.createdAt
|
||
)
|
||
}
|
||
let otherBookHighlights = allStoredEPUBHighlights().filter {
|
||
$0.bookIdentifier != currentEPUBBookIdentifier
|
||
}
|
||
let mergedHighlights = otherBookHighlights + scopedHighlights
|
||
guard let data = try? JSONEncoder().encode(mergedHighlights),
|
||
let json = String(data: data, encoding: .utf8)
|
||
else {
|
||
return
|
||
}
|
||
RDReaderManager.shared.epubHighlights.currentType = json
|
||
}
|
||
|
||
private func addHighlightFromCurrentSelection() {
|
||
guard let selection = storedEPUBSelection(),
|
||
let normalizedLocation = normalizedEPUBLocation(
|
||
selection.location
|
||
),
|
||
!selection.isEmpty
|
||
else {
|
||
return
|
||
}
|
||
|
||
let newHighlight = RDEPUBHighlight(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
location: normalizedLocation,
|
||
text: selection.text,
|
||
rangeInfo: selection.rangeInfo
|
||
)
|
||
var highlights = storedEPUBHighlights()
|
||
let isDuplicate = highlights.contains { highlight in
|
||
highlight.location.href == newHighlight.location.href
|
||
&& highlight.location.fragment == newHighlight.location.fragment
|
||
&& highlight.text == newHighlight.text
|
||
&& highlight.rangeInfo == newHighlight.rangeInfo
|
||
}
|
||
guard !isDuplicate else {
|
||
return
|
||
}
|
||
|
||
highlights.append(newHighlight)
|
||
epubHighlights = highlights
|
||
saveEPUBHighlights(highlights)
|
||
saveEPUBSelection(nil)
|
||
|
||
let currentLocation = currentVisibleEPUBLocation()
|
||
if isReaderContentReady {
|
||
readerView.reloadData()
|
||
restoreEPUBLocation(currentLocation)
|
||
}
|
||
}
|
||
|
||
private func storedEPUBLocation() -> RDEPUBLocation? {
|
||
let json = RDReaderManager.shared.epubReadLocation.currentType
|
||
guard !json.isEmpty, let data = json.data(using: .utf8) else {
|
||
return nil
|
||
}
|
||
guard
|
||
let location = try? JSONDecoder().decode(
|
||
RDEPUBLocation.self,
|
||
from: data
|
||
)
|
||
else {
|
||
return nil
|
||
}
|
||
guard location.bookIdentifier == currentEPUBBookIdentifier else {
|
||
return nil
|
||
}
|
||
return location
|
||
}
|
||
|
||
private func currentVisibleEPUBLocation() -> RDEPUBLocation? {
|
||
if isTextEPUBMode {
|
||
return epubTextBook?
|
||
.location(
|
||
forPageNumber: readerView.currentPage,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
}
|
||
if let location = epubSession?.currentReadingContext?.location {
|
||
return location
|
||
}
|
||
return epubSession?.currentVisibleLocation(
|
||
currentPageNumber: readerView.currentPage,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
}
|
||
|
||
private func pageContains(spineIndex: Int, in page: EPUBPage) -> Bool {
|
||
if let fixedSpread = page.fixedSpread {
|
||
return fixedSpread.resources
|
||
.contains(where: { $0.spineIndex == spineIndex })
|
||
}
|
||
return page.spineIndex == spineIndex
|
||
}
|
||
|
||
private func fallbackEPUBLocation(for page: EPUBPage) -> RDEPUBLocation? {
|
||
epubSession?
|
||
.fallbackLocation(
|
||
for: page,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
}
|
||
|
||
private func normalizedEPUBHref(
|
||
_ href: String,
|
||
relativeTo spineIndex: Int? = nil
|
||
) -> String? {
|
||
epubResolver?.normalizedHref(href, relativeToSpineIndex: spineIndex)
|
||
?? href.components(separatedBy: "#").first
|
||
}
|
||
|
||
private func normalizedEPUBLocation(
|
||
_ location: RDEPUBLocation,
|
||
relativeTo spineIndex: Int? = nil
|
||
) -> RDEPUBLocation? {
|
||
epubResolver?.normalizedLocation(
|
||
location,
|
||
relativeToSpineIndex: spineIndex,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
}
|
||
|
||
private func currentEPUBTOCIndex() -> Int {
|
||
guard !epubTOCItems.isEmpty else {
|
||
return currentChapterNum
|
||
}
|
||
if isTextEPUBMode {
|
||
let currentPageNumber = readerView.currentPage
|
||
guard currentPageNumber > 0 else {
|
||
return 0
|
||
}
|
||
return
|
||
epubTOCItems
|
||
.lastIndex(
|
||
where: {
|
||
($0.pageNumber ?? Int.max) <= currentPageNumber
|
||
}) ?? 0
|
||
}
|
||
let referenceLocation =
|
||
storedEPUBLocation() ?? currentVisibleEPUBLocation()
|
||
guard let location = referenceLocation,
|
||
let normalizedLocation = normalizedEPUBLocation(location)
|
||
else {
|
||
return 0
|
||
}
|
||
if let exactIndex = epubTOCItems.firstIndex(where: { item in
|
||
guard
|
||
let normalizedItem = normalizedEPUBLocation(
|
||
RDEPUBLocation(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
href: item.href,
|
||
progression: 0
|
||
)
|
||
)
|
||
else {
|
||
return false
|
||
}
|
||
return normalizedItem.href == normalizedLocation.href
|
||
&& normalizedItem.fragment == normalizedLocation.fragment
|
||
}) {
|
||
return exactIndex
|
||
}
|
||
if let pathIndex = epubTOCItems.lastIndex(where: { item in
|
||
guard
|
||
let normalizedItem = normalizedEPUBLocation(
|
||
RDEPUBLocation(
|
||
bookIdentifier: currentEPUBBookIdentifier,
|
||
href: item.href,
|
||
progression: 0
|
||
)
|
||
)
|
||
else {
|
||
return false
|
||
}
|
||
return normalizedItem.href == normalizedLocation.href
|
||
}) {
|
||
return pathIndex
|
||
}
|
||
return 0
|
||
}
|
||
|
||
private func pageIndex(for location: RDEPUBLocation) -> Int? {
|
||
epubSession?
|
||
.pageIndex(for: location, bookIdentifier: currentEPUBBookIdentifier)
|
||
}
|
||
|
||
private func highlights(for spineIndex: Int) -> [RDEPUBHighlight] {
|
||
guard let parser = epubParser,
|
||
parser.spine.indices
|
||
.contains(spineIndex)
|
||
else {
|
||
return []
|
||
}
|
||
let targetHref = normalizedEPUBHref(parser.spine[spineIndex].href)
|
||
return epubHighlights.filter { highlight in
|
||
normalizedEPUBHref(highlight.location.href) == targetHref
|
||
}
|
||
}
|
||
|
||
private func restoreEPUBLocationIfNeeded() {
|
||
restoreEPUBLocation(storedEPUBLocation())
|
||
}
|
||
|
||
func restoreEPUBLocation(_ location: RDEPUBLocation?) {
|
||
if isTextEPUBMode {
|
||
guard let location,
|
||
let targetPageNum = epubTextBook?.pageNumber(
|
||
for: location,
|
||
resolver: epubResolver ?? publicationFallbackResolver(),
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
else {
|
||
epubSession?.transition(to: .idle)
|
||
return
|
||
}
|
||
readerView.transitionToPage(pageNum: targetPageNum)
|
||
return
|
||
}
|
||
|
||
guard let session = epubSession,
|
||
let location = location,
|
||
let targetPageNum = session.queueNavigation(
|
||
to: location,
|
||
relativeToSpineIndex: nil,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
else {
|
||
epubSession?.transition(to: .idle)
|
||
return
|
||
}
|
||
readerView.transitionToPage(pageNum: targetPageNum)
|
||
}
|
||
|
||
private func navigateToEPUBLink(
|
||
_ location: RDEPUBLocation,
|
||
fromSpineIndex spineIndex: Int
|
||
) {
|
||
guard let session = epubSession,
|
||
let targetPageNum = session.queueNavigation(
|
||
to: location,
|
||
relativeToSpineIndex: spineIndex,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
else {
|
||
return
|
||
}
|
||
readerView.transitionToPage(pageNum: targetPageNum)
|
||
}
|
||
|
||
// MARK: - Loading Indicator
|
||
|
||
private func showLoading() {
|
||
view.addSubview(loadingIndicator)
|
||
loadingIndicator.center = view.center
|
||
loadingIndicator.startAnimating()
|
||
}
|
||
|
||
func hideLoading() {
|
||
loadingIndicator.stopAnimating()
|
||
loadingIndicator.removeFromSuperview()
|
||
}
|
||
|
||
private func ensureEPUBPaginationHostView(viewportSize: CGSize) -> UIView {
|
||
let hostFrame = CGRect(
|
||
x: -viewportSize.width - 32,
|
||
y: 0,
|
||
width: max(viewportSize.width, 1),
|
||
height: max(viewportSize.height, 1)
|
||
)
|
||
|
||
if epubPaginationHostView.superview == nil {
|
||
view.addSubview(epubPaginationHostView)
|
||
}
|
||
epubPaginationHostView.frame = hostFrame
|
||
view.sendSubviewToBack(epubPaginationHostView)
|
||
return epubPaginationHostView
|
||
}
|
||
|
||
private func ensureEPUBPreloadHostView(viewportSize: CGSize) -> UIView {
|
||
let hostFrame = CGRect(
|
||
x: -viewportSize.width - 32,
|
||
y: 0,
|
||
width: max(viewportSize.width, 1),
|
||
height: max(viewportSize.height, 1)
|
||
)
|
||
|
||
if epubPreloadHostView.superview == nil {
|
||
view.addSubview(epubPreloadHostView)
|
||
}
|
||
epubPreloadHostView.frame = hostFrame
|
||
view.sendSubviewToBack(epubPreloadHostView)
|
||
return epubPreloadHostView
|
||
}
|
||
|
||
private func clearEPUBPreloadCache() {
|
||
epubPreloadViews.values.forEach {
|
||
$0.releaseResources()
|
||
$0.removeFromSuperview()
|
||
}
|
||
epubPreloadViews.removeAll()
|
||
epubPageCurlViews.values.forEach {
|
||
$0.releaseResources()
|
||
$0.removeFromSuperview()
|
||
}
|
||
epubPageCurlViews.removeAll()
|
||
}
|
||
|
||
private func releaseEPUBPageViews(except keepPages: Set<Int>) {
|
||
epubPreloadViews.forEach { key, value in
|
||
guard !keepPages.contains(key) else { return }
|
||
value.releaseResources()
|
||
value.removeFromSuperview()
|
||
}
|
||
epubPreloadViews = epubPreloadViews.filter { key, _ in
|
||
keepPages.contains(key)
|
||
}
|
||
|
||
epubPageCurlViews.forEach { key, value in
|
||
guard !keepPages.contains(key) else { return }
|
||
value.releaseResources()
|
||
value.removeFromSuperview()
|
||
}
|
||
epubPageCurlViews = epubPageCurlViews.filter { key, _ in
|
||
keepPages.contains(key)
|
||
}
|
||
}
|
||
|
||
private func trimEPUBPageCurlCache(around pageNum: Int) {
|
||
let keepPages = Set(
|
||
[
|
||
pageNum - 1,
|
||
pageNum,
|
||
pageNum + 1,
|
||
].filter { index in
|
||
index > 0
|
||
&& index < pageCountOfReaderView(
|
||
readerView: readerView
|
||
) - 1
|
||
}
|
||
)
|
||
releaseEPUBPageViews(except: keepPages)
|
||
}
|
||
|
||
private func primeEPUBPageCache(around pageNum: Int) {
|
||
guard case .epubFile = bookSource,
|
||
let publication = epubPublication,
|
||
publication.layout != .fixed,
|
||
pageNum > 0,
|
||
pageNum < pageCountOfReaderView(readerView: readerView) - 1
|
||
else {
|
||
return
|
||
}
|
||
|
||
let validPages = Set(
|
||
[pageNum - 1, pageNum + 1].filter { index in
|
||
index > 0
|
||
&& index < pageCountOfReaderView(
|
||
readerView: readerView
|
||
) - 1
|
||
}
|
||
)
|
||
|
||
epubPreloadViews = epubPreloadViews.filter { key, value in
|
||
let shouldKeep = validPages.contains(key)
|
||
if !shouldKeep {
|
||
value.releaseResources()
|
||
value.removeFromSuperview()
|
||
}
|
||
return shouldKeep
|
||
}
|
||
|
||
let theme = RDReaderManager.shared.themeType.currentType.value
|
||
let viewportSize = currentEPUBLayoutContext().viewportSize
|
||
let preloadHostView = ensureEPUBPreloadHostView(
|
||
viewportSize: viewportSize
|
||
)
|
||
for targetPage in validPages.sorted() {
|
||
let contentView = configuredEPUBContentView(
|
||
pageNum: targetPage,
|
||
contentView: cachedEPUBPreloadView(pageNum: targetPage),
|
||
theme: theme,
|
||
publication: publication,
|
||
isInteractive: false
|
||
)
|
||
if contentView.superview == nil {
|
||
preloadHostView.addSubview(contentView)
|
||
contentView.frame = preloadHostView.bounds
|
||
}
|
||
}
|
||
}
|
||
|
||
private func cachedEPUBPreloadView(pageNum: Int) -> RDReaderEPUBContentView
|
||
{
|
||
if let cachedView = epubPreloadViews[pageNum] {
|
||
return cachedView
|
||
}
|
||
let contentView = RDReaderEPUBContentView()
|
||
epubPreloadViews[pageNum] = contentView
|
||
return contentView
|
||
}
|
||
|
||
private func cachedEPUBPageCurlView(pageNum: Int) -> RDReaderEPUBContentView
|
||
{
|
||
if let cachedView = epubPageCurlViews[pageNum] {
|
||
return cachedView
|
||
}
|
||
if let preloadedView = epubPreloadViews.removeValue(forKey: pageNum) {
|
||
preloadedView.removeFromSuperview()
|
||
epubPageCurlViews[pageNum] = preloadedView
|
||
return preloadedView
|
||
}
|
||
let contentView = RDReaderEPUBContentView()
|
||
epubPageCurlViews[pageNum] = contentView
|
||
return contentView
|
||
}
|
||
|
||
private func configuredEPUBContentView(
|
||
pageNum: Int,
|
||
contentView: RDReaderEPUBContentView,
|
||
theme: RDReaderTheme,
|
||
publication: RDEPUBPublication,
|
||
isInteractive: Bool = true
|
||
) -> RDReaderEPUBContentView {
|
||
let epubPage = epubPages[pageNum - 1]
|
||
contentView.delegate = isInteractive ? self : nil
|
||
contentView.backgroundColor = theme.contentBackgroudColor
|
||
contentView.pageNumLabel.textColor = theme.contentTextColor
|
||
contentView.pageNumLabel.text = "\(pageNum) / \(epubPages.count)"
|
||
|
||
let isFixedLayout = publication.layout == .fixed
|
||
guard
|
||
let request = renderRequest(
|
||
for: pageNum,
|
||
page: epubPage,
|
||
publication: publication,
|
||
theme: theme
|
||
)
|
||
else {
|
||
return contentView
|
||
}
|
||
|
||
contentView.load(publication: publication, request: request)
|
||
return contentView
|
||
}
|
||
|
||
// MARK: - UI Setup
|
||
|
||
func makeUI() {
|
||
|
||
readerView.delegate = self
|
||
readerView.dataSource = self
|
||
readerView.landscapeDualPageEnabled = true
|
||
readerView.coverPageIndex = 0
|
||
readerView.pageDirection = .rightToLeft
|
||
readerView.frame = CGRect(
|
||
x: 0,
|
||
y: 0,
|
||
width: view.frame.width,
|
||
height: view.frame.height
|
||
)
|
||
readerView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
|
||
view.addSubview(readerView)
|
||
|
||
readerView
|
||
.register(
|
||
contentView: RDReaderContentView.self,
|
||
contentViewWithReuseIdentifier: NSStringFromClass(
|
||
RDReaderContentView.self
|
||
)
|
||
)
|
||
readerView
|
||
.register(
|
||
contentView: RDReaderEPUBContentView.self,
|
||
contentViewWithReuseIdentifier: NSStringFromClass(
|
||
RDReaderEPUBContentView.self
|
||
)
|
||
)
|
||
readerView
|
||
.register(
|
||
contentView: RDReaderEPUBTextContentView.self,
|
||
contentViewWithReuseIdentifier: NSStringFromClass(
|
||
RDReaderEPUBTextContentView.self
|
||
)
|
||
)
|
||
readerView
|
||
.register(
|
||
contentView: RDReaderCoverView.self,
|
||
contentViewWithReuseIdentifier: NSStringFromClass(
|
||
RDReaderCoverView.self
|
||
)
|
||
)
|
||
readerView
|
||
.register(
|
||
contentView: RDReaderEndView.self,
|
||
contentViewWithReuseIdentifier: NSStringFromClass(
|
||
RDReaderEndView.self
|
||
)
|
||
)
|
||
|
||
topToolView.trigger { [weak self] event in
|
||
guard let self = self else { return }
|
||
switch event {
|
||
case .back:
|
||
self.navigationController?.popViewController(animated: true)
|
||
}
|
||
}
|
||
|
||
bottomToolView.trigger { [weak self] event in
|
||
guard let self = self else { return }
|
||
switch event {
|
||
case .chapterList:
|
||
self.showChapterListView()
|
||
case .highlight:
|
||
if case .epubFile = self.bookSource {
|
||
self.addHighlightFromCurrentSelection()
|
||
}
|
||
case .settings:
|
||
self.showEditView()
|
||
case .darkAndLight:
|
||
if RDReaderManager.shared.themeType.currentType != .dark {
|
||
RDReaderManager.shared.themeType.currentType = .dark
|
||
} else {
|
||
RDReaderManager.shared.themeType.currentType = .white
|
||
}
|
||
}
|
||
}
|
||
|
||
RDReaderManager.shared.themeType.observeChange { [weak self] theme in
|
||
guard let self = self else { return }
|
||
self.readerView.backgroundColor = theme.contentBackgroudColor
|
||
self.topToolView.backgroundColor = theme.toolBackgroudColor
|
||
self.bottomToolView.backgroundColor = theme.toolBackgroudColor
|
||
self.topToolView.lineView.backgroundColor = theme.toolLineColor
|
||
self.bottomToolView.lineView.backgroundColor = theme.toolLineColor
|
||
self.topToolView.backButton.tintColor = theme.toolControlTextColor
|
||
self.bottomToolView.chapterListButton.tintColor =
|
||
theme.toolControlTextColor
|
||
self.bottomToolView.highlightButton.tintColor =
|
||
theme.toolControlTextColor
|
||
self.bottomToolView.settingsButton.tintColor =
|
||
theme.toolControlTextColor
|
||
self.bottomToolView.lightModeButton.tintColor =
|
||
theme.toolControlTextColor
|
||
if self.isReaderContentReady {
|
||
self.readerView.reloadData()
|
||
}
|
||
}
|
||
|
||
RDReaderManager.shared.pageCurlTypeType
|
||
.observeChange { [weak self] type in
|
||
guard let self = self else { return }
|
||
self.readerView
|
||
.switchReaderDisplayType(
|
||
self.effectiveDisplayType(requested: type)
|
||
)
|
||
if case .epubFile = self.bookSource {
|
||
self.storeEPUBValidationState([
|
||
"validationReason": "displayTypeChanged",
|
||
"settingsDisplayType": RDReaderManager.shared
|
||
.pageCurlTypeType.currentType.rawValue,
|
||
"lastVisiblePage": self.readerView.currentPage,
|
||
])
|
||
}
|
||
}
|
||
|
||
RDReaderManager.shared.fontValue.observeChange { [weak self] _ in
|
||
guard let self = self else { return }
|
||
guard self.isReaderContentReady else { return }
|
||
switch self.bookSource {
|
||
case .textFile:
|
||
self.loadData()
|
||
self.readerView.reloadData()
|
||
case .epubFile:
|
||
self.repaginateEPUB(reason: "fontSizeChanged")
|
||
}
|
||
}
|
||
|
||
RDReaderManager.shared.lineSpaceType.observeChange { [weak self] _ in
|
||
guard let self = self else { return }
|
||
guard self.isReaderContentReady else { return }
|
||
switch self.bookSource {
|
||
case .textFile:
|
||
self.loadData()
|
||
self.readerView.reloadData()
|
||
case .epubFile:
|
||
self.repaginateEPUB(reason: "lineSpacingChanged")
|
||
}
|
||
}
|
||
}
|
||
|
||
func showChapterListView() {
|
||
switch bookSource {
|
||
case .textFile:
|
||
showTXTChapterList()
|
||
case .epubFile:
|
||
showEPUBChapterList()
|
||
}
|
||
}
|
||
|
||
private func showTXTChapterList() {
|
||
let chapterListVC = SSChapterListController(
|
||
chapters: self.book.chapters,
|
||
currentChapterNum: currentChapterNum
|
||
)
|
||
chapterListVC.view.ss_w = view.frame.width * 0.8
|
||
chapterListVC.view.ss_h = view.frame.height
|
||
|
||
let alertView = SSAlertView(
|
||
customView: chapterListVC.view,
|
||
fromViewController: self,
|
||
canPanDimiss: false
|
||
)
|
||
let animation = SSAlertDefaultAnmation(state: .fromLeft)
|
||
animation.isSpringShowAnimation = false
|
||
alertView.animation = animation
|
||
alertView.show()
|
||
|
||
chapterListVC.selectedChapter { [weak alertView, weak self] number in
|
||
guard let self = self else { return }
|
||
let chapter = self.book.chapters[number]
|
||
self.transitionToPage(rangeLocation: chapter.range.location)
|
||
alertView?.hide()
|
||
}
|
||
}
|
||
|
||
private func showEPUBChapterList() {
|
||
let currentIndex = currentEPUBTOCIndex()
|
||
let chapters: [Chapter]
|
||
if !epubTOCItems.isEmpty {
|
||
chapters =
|
||
epubTOCItems
|
||
.enumerated()
|
||
.map { (index, item) -> Chapter in
|
||
let indent = String(repeating: " ", count: item.depth)
|
||
return Chapter(
|
||
sort: index + 1,
|
||
title: indent + item.title,
|
||
pageCount: 0,
|
||
content: "",
|
||
pages: [],
|
||
range: NSMakeRange(0, 0)
|
||
)
|
||
}
|
||
} else if isTextEPUBMode, let textBook = epubTextBook {
|
||
chapters = textBook.chapters.enumerated().map { index, chapter in
|
||
Chapter(
|
||
sort: index + 1,
|
||
title: chapter.title,
|
||
pageCount: chapter.pages.count,
|
||
content: "",
|
||
pages: [],
|
||
range: NSMakeRange(0, 0)
|
||
)
|
||
}
|
||
} else {
|
||
chapters =
|
||
epubChapters
|
||
.enumerated()
|
||
.map { (index, info) -> Chapter in
|
||
Chapter(
|
||
sort: index + 1,
|
||
title: info.title,
|
||
pageCount: info.pageCount,
|
||
content: "",
|
||
pages: [],
|
||
range: NSMakeRange(0, 0)
|
||
)
|
||
}
|
||
}
|
||
let chapterListVC = SSChapterListController(
|
||
chapters: chapters,
|
||
currentChapterNum: currentIndex
|
||
)
|
||
chapterListVC.view.ss_w = view.frame.width * 0.8
|
||
chapterListVC.view.ss_h = view.frame.height
|
||
|
||
let alertView = SSAlertView(
|
||
customView: chapterListVC.view,
|
||
fromViewController: self,
|
||
canPanDimiss: false
|
||
)
|
||
let animation = SSAlertDefaultAnmation(state: .fromLeft)
|
||
animation.isSpringShowAnimation = false
|
||
alertView.animation = animation
|
||
alertView.show()
|
||
|
||
chapterListVC.selectedChapter { [weak alertView, weak self] number in
|
||
guard let self = self else { return }
|
||
if !self.epubTOCItems.isEmpty {
|
||
let item = self.epubTOCItems[number]
|
||
if self.isTextEPUBMode, let pageNumber = item.pageNumber {
|
||
self.storeEPUBTOCValidation(
|
||
item: item,
|
||
resolvedPage: pageNumber
|
||
)
|
||
self.readerView.transitionToPage(pageNum: pageNumber)
|
||
} else {
|
||
let location = RDEPUBLocation(
|
||
bookIdentifier: self.currentEPUBBookIdentifier,
|
||
href: item.href,
|
||
progression: 0,
|
||
fragment: nil
|
||
)
|
||
let fromSpineIndex =
|
||
self.readerView.currentPage > 0
|
||
&& self.epubPages.indices.contains(
|
||
self.readerView.currentPage - 1
|
||
)
|
||
? self.epubPages[self.readerView.currentPage - 1]
|
||
.spineIndex
|
||
: 0
|
||
let resolvedPage = self.epubSession?.pageIndex(
|
||
for: location,
|
||
bookIdentifier: self.currentEPUBBookIdentifier
|
||
).map {
|
||
$0 + 1
|
||
}
|
||
self.storeEPUBTOCValidation(
|
||
item: item,
|
||
resolvedPage: resolvedPage
|
||
)
|
||
self.navigateToEPUBLink(
|
||
location,
|
||
fromSpineIndex: fromSpineIndex
|
||
)
|
||
}
|
||
} else if self.isTextEPUBMode,
|
||
let textPage = self.epubTextBook?.pages.first(
|
||
where: {
|
||
$0.chapterIndex == number
|
||
})
|
||
{
|
||
self.readerView
|
||
.transitionToPage(pageNum: textPage.absolutePageIndex + 1)
|
||
} else if let pageIndex = self.epubPages.firstIndex(
|
||
where: {
|
||
$0.chapterIndex == number
|
||
})
|
||
{
|
||
self.readerView.transitionToPage(pageNum: pageIndex + 1)
|
||
}
|
||
alertView?.hide()
|
||
}
|
||
}
|
||
|
||
func showEditView() {
|
||
let customView = RDReaderEditView(
|
||
frame: CGRect(x: 0, y: 0, width: view.frame.width, height: 300)
|
||
)
|
||
customView.brightSlider
|
||
.setValue(
|
||
Float(RDReaderManager.shared.brightValue.currentType),
|
||
animated: false
|
||
)
|
||
customView.fontView.currentFontSize =
|
||
RDReaderManager.shared.fontValue.currentType
|
||
customView.lineSpaceView.currentType =
|
||
RDReaderManager.shared.lineSpaceType.currentType
|
||
customView.pageCurlTypeView.currentType =
|
||
RDReaderManager.shared.pageCurlTypeType.currentType
|
||
customView.colorView.currentType =
|
||
RDReaderManager.shared.themeType.currentType
|
||
|
||
let alertView = SSAlertView(
|
||
customView: customView,
|
||
fromViewController: self,
|
||
animation: SSAlertDefaultAnmation(state: .fromBottom),
|
||
canPanDimiss: false
|
||
)
|
||
alertView.show()
|
||
|
||
customView.brightSlider.trigger { event in
|
||
switch event {
|
||
case .valueDidChange(let value):
|
||
RDReaderManager.shared.brightValue.currentType = value
|
||
}
|
||
}
|
||
|
||
customView.fontView.trigger { event in
|
||
switch event {
|
||
case .fontSize(let size):
|
||
RDReaderManager.shared.fontValue.currentType = size
|
||
}
|
||
}
|
||
|
||
customView.lineSpaceView.trigger { event in
|
||
switch event {
|
||
case .chose(let type):
|
||
RDReaderManager.shared.lineSpaceType.currentType = type
|
||
}
|
||
}
|
||
|
||
customView.pageCurlTypeView.trigger { event in
|
||
switch event {
|
||
case .chose(let type):
|
||
RDReaderManager.shared.pageCurlTypeType.currentType = type
|
||
}
|
||
}
|
||
|
||
customView.colorView.trigger { event in
|
||
switch event {
|
||
case .chose(let type):
|
||
RDReaderManager.shared.themeType.currentType = type
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// MARK: - RDReaderDataSource & RDReaderDelegate
|
||
|
||
extension RDReaderController: RDReaderDataSource, RDReaderDelegate {
|
||
|
||
public func pageIdentifier(readerView: RDReaderView, pageNum: Int)
|
||
-> String?
|
||
{
|
||
if pageNum == 0 {
|
||
return NSStringFromClass(RDReaderCoverView.self)
|
||
} else if pageNum == pageCountOfReaderView(readerView: readerView) - 1 {
|
||
return NSStringFromClass(RDReaderEndView.self)
|
||
}
|
||
switch bookSource {
|
||
case .textFile:
|
||
return NSStringFromClass(RDReaderContentView.self)
|
||
case .epubFile:
|
||
return isTextEPUBMode
|
||
? NSStringFromClass(RDReaderEPUBTextContentView.self)
|
||
: NSStringFromClass(RDReaderEPUBContentView.self)
|
||
}
|
||
}
|
||
|
||
public func pageCountOfReaderView(readerView: RDReaderView) -> Int {
|
||
switch bookSource {
|
||
case .textFile:
|
||
return chapterPages.count + 2 // +cover +end
|
||
case .epubFile:
|
||
return
|
||
(isTextEPUBMode
|
||
? (epubTextBook?.pages.count ?? 0) : epubPages.count) + 2
|
||
}
|
||
}
|
||
|
||
public func pageContentView(
|
||
readerView: RDReaderView,
|
||
pageNum: Int,
|
||
containerView: UIView?
|
||
) -> UIView {
|
||
let totalPages = pageCountOfReaderView(readerView: readerView)
|
||
let theme = RDReaderManager.shared.themeType.currentType.value
|
||
|
||
// 封面页
|
||
if pageNum == 0 {
|
||
let contentView =
|
||
(containerView as? RDReaderCoverView) ?? RDReaderCoverView()
|
||
contentView.backgroundColor = theme.contentBackgroudColor
|
||
contentView.textLabel.textColor = theme.contentTextColor
|
||
switch bookSource {
|
||
case .textFile:
|
||
contentView.textLabel.text = book.desc
|
||
case .epubFile:
|
||
contentView.textLabel.text =
|
||
epubParser?.metadata.title ?? "EPUB"
|
||
if let coverImage = epubParser?.coverImage() {
|
||
contentView.imageV.image = coverImage
|
||
}
|
||
}
|
||
return contentView
|
||
}
|
||
|
||
// 结束页
|
||
if pageNum == totalPages - 1 {
|
||
let contentView =
|
||
(containerView as? RDReaderEndView) ?? RDReaderEndView()
|
||
contentView.backgroundColor = theme.contentBackgroudColor
|
||
return contentView
|
||
}
|
||
|
||
// 内容页
|
||
switch bookSource {
|
||
case .textFile:
|
||
return txtContentView(
|
||
pageNum: pageNum,
|
||
containerView: containerView,
|
||
theme: theme
|
||
)
|
||
case .epubFile:
|
||
return isTextEPUBMode
|
||
? epubTextContentView(
|
||
pageNum: pageNum,
|
||
containerView: containerView,
|
||
theme: theme
|
||
)
|
||
: epubContentView(
|
||
pageNum: pageNum,
|
||
containerView: containerView,
|
||
theme: theme
|
||
)
|
||
}
|
||
}
|
||
|
||
/// TXT内容页
|
||
private func txtContentView(
|
||
pageNum: Int,
|
||
containerView: UIView?,
|
||
theme: RDReaderTheme
|
||
) -> UIView {
|
||
let chapter = chapterPages[pageNum - 1]
|
||
let contentView =
|
||
(containerView as? RDReaderContentView) ?? RDReaderContentView()
|
||
contentView.textLabel.textColor = theme.contentTextColor
|
||
contentView.pageNumLabel.textColor = theme.contentTextColor
|
||
contentView.backgroundColor = theme.contentBackgroudColor
|
||
contentView.textLabel.attributedText = chapter.attrContent
|
||
contentView.pageNumLabel.text = "\(pageNum) / \(chapterPages.count)"
|
||
return contentView
|
||
}
|
||
|
||
/// EPUB内容页（WKWebView渲染）
|
||
private func epubContentView(
|
||
pageNum: Int,
|
||
containerView: UIView?,
|
||
theme: RDReaderTheme
|
||
) -> UIView {
|
||
guard let publication = epubPublication else {
|
||
return containerView ?? UIView()
|
||
}
|
||
|
||
let contentView: RDReaderEPUBContentView
|
||
if readerView.currentDisplayType == .pageCurl, containerView == nil {
|
||
contentView = cachedEPUBPageCurlView(pageNum: pageNum)
|
||
} else {
|
||
contentView =
|
||
(containerView as? RDReaderEPUBContentView)
|
||
?? RDReaderEPUBContentView()
|
||
}
|
||
|
||
return configuredEPUBContentView(
|
||
pageNum: pageNum,
|
||
contentView: contentView,
|
||
theme: theme,
|
||
publication: publication,
|
||
isInteractive: true
|
||
)
|
||
}
|
||
|
||
private func epubTextContentView(
|
||
pageNum: Int,
|
||
containerView: UIView?,
|
||
theme: RDReaderTheme
|
||
) -> UIView {
|
||
guard let page = epubTextBook?.page(at: pageNum) else {
|
||
return containerView ?? UIView()
|
||
}
|
||
let contentView =
|
||
(containerView as? RDReaderEPUBTextContentView)
|
||
?? RDReaderEPUBTextContentView()
|
||
contentView
|
||
.configure(
|
||
page: page,
|
||
pageNumber: pageNum,
|
||
totalPages: epubTextBook?.pages.count ?? 0,
|
||
theme: theme
|
||
)
|
||
return contentView
|
||
}
|
||
|
||
public func pageNum(readerView: RDReaderView, pageNum: Int) {
|
||
switch bookSource {
|
||
case .textFile:
|
||
if pageNum > 0 && chapterPages.count > pageNum - 1 {
|
||
let chapterPage = chapterPages[pageNum - 1]
|
||
let chapter = book.chapters[chapterPage.chapterSort - 1]
|
||
let chapterRange = chapter.range
|
||
let rangeLoc =
|
||
chapterRange.location + chapterPage.range.location
|
||
RDReaderManager.shared.readProgress.currentType = rangeLoc
|
||
currentChapterNum = chapterPage.chapterSort - 1
|
||
}
|
||
case .epubFile:
|
||
let readablePageCount = currentReadableEPUBPageCount()
|
||
if readablePageCount > 0 {
|
||
if pageNum == readablePageCount {
|
||
storeEPUBEndValidationState(
|
||
pageNum: pageNum,
|
||
reachedEndScreen: false
|
||
)
|
||
} else if pageNum == readablePageCount + 1 {
|
||
storeEPUBEndValidationState(
|
||
pageNum: pageNum,
|
||
reachedEndScreen: true
|
||
)
|
||
}
|
||
}
|
||
if isTextEPUBMode {
|
||
guard pageNum > 0,
|
||
let page = epubTextBook?.page(at: pageNum),
|
||
let location = epubTextBook?.location(
|
||
forPageNumber: pageNum,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
else {
|
||
return
|
||
}
|
||
currentChapterNum = page.chapterIndex
|
||
saveEPUBLocation(location)
|
||
saveEPUBSelection(nil)
|
||
epubSession?.transition(to: .idle)
|
||
return
|
||
}
|
||
|
||
if pageNum > 0 && epubPages.count > pageNum - 1 {
|
||
let epubPage = epubPages[pageNum - 1]
|
||
if epubSession?.navigatorState == .idle {
|
||
epubSession?.transition(to: .moving)
|
||
}
|
||
currentChapterNum = epubPage.chapterIndex
|
||
if let location = fallbackEPUBLocation(for: epubPage) {
|
||
saveEPUBLocation(location)
|
||
}
|
||
saveEPUBSelection(nil)
|
||
schedulePendingBackgroundEPUBPaginationApplication()
|
||
primeEPUBPageCache(around: pageNum)
|
||
trimEPUBPageCurlCache(around: pageNum)
|
||
if epubSession?.pendingNavigationPageNum == nil {
|
||
epubSession?.transition(to: .idle)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
public func topToolView(readerView: RDReaderView) -> UIView? {
|
||
return topToolView
|
||
}
|
||
|
||
public func bottomToolView(readerView: RDReaderView) -> UIView? {
|
||
return bottomToolView
|
||
}
|
||
|
||
/// 横竖屏切换时重新分页
|
||
public func readerViewOrientationWillChange(
|
||
readerView: RDReaderView,
|
||
isLandscape: Bool
|
||
) {
|
||
switch bookSource {
|
||
case .textFile:
|
||
loadData()
|
||
transitionToPage()
|
||
case .epubFile:
|
||
repaginateEPUB(reason: "orientationChanged")
|
||
}
|
||
}
|
||
}
|
||
|
||
extension RDReaderController: RDReaderEPUBContentViewDelegate {
|
||
func epubContentView(
|
||
_ contentView: RDReaderEPUBContentView,
|
||
didUpdateLocation location: RDEPUBLocation,
|
||
spineIndex: Int
|
||
) {
|
||
guard readerView.currentPage > 0,
|
||
epubPages.indices
|
||
.contains(readerView.currentPage - 1)
|
||
else {
|
||
return
|
||
}
|
||
let currentPage = epubPages[readerView.currentPage - 1]
|
||
guard
|
||
epubSession?
|
||
.pageContains(spineIndex: spineIndex, in: currentPage) == true
|
||
else {
|
||
return
|
||
}
|
||
saveEPUBLocation(location)
|
||
epubSession?.updateReadingContext(
|
||
pageNumber: readerView.currentPage,
|
||
location: location,
|
||
spineIndex: spineIndex,
|
||
chapterIndex: currentPage.chapterIndex,
|
||
bookIdentifier: currentEPUBBookIdentifier
|
||
)
|
||
}
|
||
|
||
func epubContentView(
|
||
_ contentView: RDReaderEPUBContentView,
|
||
didChangeSelection selection: RDEPUBSelection?,
|
||
spineIndex: Int
|
||
) {
|
||
guard readerView.currentPage > 0,
|
||
epubPages.indices
|
||
.contains(readerView.currentPage - 1)
|
||
else {
|
||
return
|
||
}
|
||
let currentPage = epubPages[readerView.currentPage - 1]
|
||
guard
|
||
epubSession?
|
||
.pageContains(spineIndex: spineIndex, in: currentPage) == true
|
||
else {
|
||
return
|
||
}
|
||
saveEPUBSelection(selection)
|
||
}
|
||
|
||
func epubContentView(
|
||
_ contentView: RDReaderEPUBContentView,
|
||
didActivateInternalLink location: RDEPUBLocation,
|
||
fromSpineIndex: Int
|
||
) {
|
||
saveEPUBSelection(nil)
|
||
navigateToEPUBLink(location, fromSpineIndex: fromSpineIndex)
|
||
}
|
||
|
||
func epubContentView(
|
||
_ contentView: RDReaderEPUBContentView,
|
||
didActivateExternalLink url: URL
|
||
) {
|
||
UIApplication.shared.open(url, options: [:], completionHandler: nil)
|
||
}
|
||
|
||
func epubContentView(
|
||
_ contentView: RDReaderEPUBContentView,
|
||
didLogJavaScriptError message: String
|
||
) {
|
||
print("EPUB JS Error: \(message)")
|
||
}
|
||
}
|