1007 lines
42 KiB
Swift
1007 lines
42 KiB
Swift
//
|
||
// RDReaderView.swift
|
||
// RDReaderDemo
|
||
//
|
||
// Created by yangsq on 2021/8/6.
|
||
//
|
||
|
||
import UIKit
|
||
|
||
|
||
@objc public protocol RDReaderDataSource: NSObjectProtocol {
|
||
func pageCountOfReaderView(readerView: RDReaderView) -> Int
|
||
func pageContentView(readerView: RDReaderView, pageNum: Int, containerView: UIView?) -> UIView
|
||
func pageIdentifier(readerView: RDReaderView, pageNum: Int) -> String?
|
||
@objc optional func topToolView(readerView: RDReaderView) -> UIView?
|
||
@objc optional func bottomToolView(readerView: RDReaderView) -> UIView?
|
||
}
|
||
|
||
@objc public protocol RDReaderDelegate: NSObjectProtocol {
|
||
func pageNum(readerView: RDReaderView, pageNum: Int)
|
||
/// 横竖屏切换时回调，可在此重新分页
|
||
@objc optional func readerViewOrientationWillChange(readerView: RDReaderView, isLandscape: Bool)
|
||
}
|
||
|
||
extension RDReaderView {
|
||
public enum DisplayType {
|
||
case pageCurl
|
||
case horizontalScroll
|
||
case verticalScroll
|
||
}
|
||
|
||
/// 翻页方向
|
||
public enum PageDirection {
|
||
/// 从左往右翻页（默认，适用于中文/英文书籍）
|
||
case leftToRight
|
||
/// 从右往左翻页（适用于日文漫画等）
|
||
case rightToLeft
|
||
}
|
||
}
|
||
|
||
public class RDReaderView: UIView {
|
||
|
||
enum TapEvent {
|
||
case none, left, center, right
|
||
}
|
||
|
||
private lazy var pageViewController: UIPageViewController = {
|
||
let pageVC = UIPageViewController(transitionStyle: .pageCurl, navigationOrientation: .horizontal, options: nil)
|
||
pageVC.delegate = self
|
||
pageVC.dataSource = self
|
||
return pageVC
|
||
}()
|
||
|
||
private lazy var layout: RDReaderFlowLayout = {
|
||
let layout = RDReaderFlowLayout(displayType: .horizontalScroll)
|
||
layout.dataSource = self
|
||
layout.delegate = self
|
||
return layout
|
||
}()
|
||
|
||
private lazy var collectionView: UICollectionView = {
|
||
|
||
let collectionView = UICollectionView(frame: .zero, collectionViewLayout: layout)
|
||
collectionView.backgroundColor = UIColor.clear
|
||
return collectionView
|
||
}()
|
||
|
||
public var currentPage: Int = -1 {
|
||
didSet {
|
||
if let delegate = delegate, currentPage != oldValue, delegate.responds(to: #selector(RDReaderDelegate.pageNum(readerView:pageNum:))) {
|
||
delegate.pageNum(readerView: self, pageNum: currentPage)
|
||
}
|
||
}
|
||
}
|
||
|
||
private(set) lazy var tapGestureRecognizer: UITapGestureRecognizer = {
|
||
let tap = UITapGestureRecognizer(target: self, action: #selector(tapAction(tap:)))
|
||
return tap
|
||
}()
|
||
|
||
private var tapEvent: TapEvent = .none {
|
||
didSet {
|
||
let isRTL = pageDirection == .rightToLeft
|
||
switch tapEvent {
|
||
case .left:
|
||
if currentDisplayType != .pageCurl {
|
||
if isRTL { goNextPage() } else { goPreviousPage() }
|
||
}
|
||
case .right:
|
||
if currentDisplayType != .pageCurl {
|
||
if isRTL { goPreviousPage() } else { goNextPage() }
|
||
}
|
||
case .center:
|
||
tapCenter()
|
||
default:
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
private func goNextPage() {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
if pagesPerScreen > 1 {
|
||
if let target = adjacentDualPage(from: currentPage, forward: true) {
|
||
transitionToPage(pageNum: target, animated: true)
|
||
}
|
||
} else if currentPage + 1 < totalPages {
|
||
transitionToPage(pageNum: currentPage + 1, animated: true)
|
||
}
|
||
}
|
||
|
||
private func goPreviousPage() {
|
||
if pagesPerScreen > 1 {
|
||
if let target = adjacentDualPage(from: currentPage, forward: false) {
|
||
transitionToPage(pageNum: target, animated: true)
|
||
}
|
||
} else if currentPage - 1 >= 0 {
|
||
transitionToPage(pageNum: currentPage - 1, animated: true)
|
||
}
|
||
}
|
||
|
||
public weak var dataSource: RDReaderDataSource? = nil
|
||
public weak var delegate: RDReaderDelegate? = nil
|
||
public var currentDisplayType: RDReaderView.DisplayType = .pageCurl
|
||
public var toolViewAnimationDuration: TimeInterval = 0.3
|
||
/// 是否启用横屏双页显示
|
||
public var landscapeDualPageEnabled: Bool = false
|
||
/// 翻页方向，默认从左往右（.leftToRight）
|
||
public var pageDirection: RDReaderView.PageDirection = .leftToRight
|
||
/// 横屏双页模式下，封面页的索引。设置后该页在横屏时独占一屏，后续页面两两配对。
|
||
/// 设为 nil 表示没有封面页（所有页面正常两两配对）。
|
||
public var coverPageIndex: Int? = nil
|
||
|
||
/// 是否启用了封面页独占
|
||
private var hasCoverPage: Bool {
|
||
return coverPageIndex != nil
|
||
}
|
||
|
||
/// 当前是否横屏
|
||
private var isLandscape: Bool {
|
||
return bounds.width > bounds.height
|
||
}
|
||
|
||
/// 每屏显示的页数
|
||
public var pagesPerScreen: Int {
|
||
if !landscapeDualPageEnabled { return 1 }
|
||
if currentDisplayType == .verticalScroll { return 1 }
|
||
return isLandscape ? 2 : 1
|
||
}
|
||
|
||
/// 判断某页在横屏双页模式下是否独占一屏（封面页）
|
||
/// - Parameter pageNum: 页码
|
||
/// - Returns: 是否独占一屏
|
||
public func isFullScreenPage(_ pageNum: Int) -> Bool {
|
||
guard landscapeDualPageEnabled, isLandscape, let coverIndex = coverPageIndex else { return false }
|
||
return pageNum == coverIndex
|
||
}
|
||
|
||
/// 根据逻辑页码计算横屏双页模式下的配对信息
|
||
/// 封面页独占一屏，后续页面两两配对
|
||
/// - Parameter pageNum: 逻辑页码
|
||
/// - Returns: (左页码, 右页码(可选))
|
||
private func dualPagePair(for pageNum: Int) -> (left: Int, right: Int?) {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
if let coverIndex = coverPageIndex {
|
||
if pageNum == coverIndex {
|
||
// 封面页独占一屏
|
||
return (coverIndex, nil)
|
||
}
|
||
// 封面之后的页面：偏移1后两两配对
|
||
// 例如封面是0页，则 1+2, 3+4, 5+6...
|
||
let adjustedIndex = pageNum - (coverIndex + 1) // 跳过封面后的偏移
|
||
let pairStart = coverIndex + 1 + (adjustedIndex / 2) * 2
|
||
let left = pairStart
|
||
let right = pairStart + 1 < totalPages ? pairStart + 1 : nil
|
||
return (left, right)
|
||
} else {
|
||
// 无封面页：正常两两配对 0+1, 2+3, 4+5...
|
||
let left = (pageNum / 2) * 2
|
||
let right = left + 1 < totalPages ? left + 1 : nil
|
||
return (left, right)
|
||
}
|
||
}
|
||
|
||
/// 计算横屏双页下，某页往前/后翻一屏后的起始页码
|
||
/// - Parameters:
|
||
/// - pageNum: 当前页码
|
||
/// - forward: 是否向后翻
|
||
/// - Returns: 目标页码，nil 表示到头了
|
||
private func adjacentDualPage(from pageNum: Int, forward: Bool) -> Int? {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
let pair = dualPagePair(for: pageNum)
|
||
if forward {
|
||
let nextStart = (pair.right ?? pair.left) + 1
|
||
return nextStart < totalPages ? nextStart : nil
|
||
} else {
|
||
let prevEnd = pair.left - 1
|
||
guard prevEnd >= 0 else { return nil }
|
||
return dualPagePair(for: prevEnd).left
|
||
}
|
||
}
|
||
|
||
private var previousIsLandscape: Bool?
|
||
|
||
private var contentViews = [String : UIView.Type]()
|
||
private var willPreviousTransitionToViewController: UIViewController? = nil
|
||
private var willNextTransitionToViewController: UIViewController? = nil
|
||
private var willTransitionToViewController: UIViewController? = nil
|
||
private var topToolView: UIView?
|
||
private var bottomToolView: UIView?
|
||
private var isShowToolView: Bool = false
|
||
private var isTransitioning: Bool = false
|
||
private var didBuildUI = false
|
||
private let preloadHostView = UIView()
|
||
private var preloadedPageViews: [Int: UIView] = [:]
|
||
private var pageCurlCachedViews: [Int: UIView] = [:]
|
||
private var predictedPageDirection: Bool?
|
||
public var preloadRadius: Int = 1
|
||
private var cacheSignature: CacheSignature?
|
||
|
||
/// 用于 pageCurl 双页模式下封面页旁边的空白页
|
||
static let blankPageNum = Int.max
|
||
/// 用于 pageCurl 双页模式下末尾不成对页旁边的空白页
|
||
static let blankEndPageNum = Int.max - 1
|
||
|
||
private struct CacheSignature: Equatable {
|
||
let displayType: DisplayType
|
||
let isLandscape: Bool
|
||
let pagesPerScreen: Int
|
||
let boundsSize: CGSize
|
||
}
|
||
|
||
override init(frame: CGRect) {
|
||
super.init(frame: frame)
|
||
}
|
||
|
||
public override func layoutSubviews() {
|
||
super.layoutSubviews()
|
||
guard bounds.width > 0, bounds.height > 0 else { return }
|
||
preloadHostView.frame = bounds
|
||
let nowLandscape = isLandscape
|
||
if let prev = previousIsLandscape, prev != nowLandscape {
|
||
previousIsLandscape = nowLandscape
|
||
// 延迟到下一个 RunLoop 执行，避免在 layoutSubviews 中嵌套触发 reloadData/layoutIfNeeded
|
||
// 造成 collectionView 中间态尺寸不一致的问题
|
||
DispatchQueue.main.async { [weak self] in
|
||
guard let self = self else { return }
|
||
self.orientationChanged(isNowLandscape: nowLandscape)
|
||
}
|
||
} else if previousIsLandscape == nil {
|
||
previousIsLandscape = nowLandscape
|
||
layout.isLandscapeDualPage = landscapeDualPageEnabled && nowLandscape
|
||
}
|
||
}
|
||
|
||
/// 横竖屏切换处理
|
||
/// - Parameter isNowLandscape: 当前是否为横屏
|
||
private func orientationChanged(isNowLandscape: Bool) {
|
||
let savedPage = max(0, currentPage)
|
||
// 1. 通知代理方向变化。正文级重分页由上层控制器统一接管，这里只保留容器级刷新钩子。
|
||
delegate?.readerViewOrientationWillChange?(readerView: self, isLandscape: isNowLandscape)
|
||
// 2. 更新布局的横屏双页标记
|
||
layout.isLandscapeDualPage = landscapeDualPageEnabled && isNowLandscape
|
||
layout.coverPageIndex = coverPageIndex
|
||
|
||
switch currentDisplayType {
|
||
case .pageCurl:
|
||
// 仿真翻页：通过 spineLocation 原生支持双页，需要重建 PageViewController
|
||
rebuildPageViewController()
|
||
transitionToPage(pageNum: savedPage)
|
||
primePageCache(around: savedPage, preferredForward: predictedPageDirection)
|
||
default:
|
||
// 滚动模式：禁用动画防止旋转过渡中出现尺寸抖动
|
||
UIView.performWithoutAnimation {
|
||
// 强制使布局完全失效并重新计算
|
||
collectionView.collectionViewLayout.invalidateLayout()
|
||
collectionView.reloadData()
|
||
collectionView.layoutIfNeeded()
|
||
// 3. 根据保存的页码恢复滚动位置
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
let safePage = min(savedPage, max(0, totalPages - 1))
|
||
let targetOffset = layout.currentContentOffset(count: safePage)
|
||
collectionView.setContentOffset(targetOffset, animated: false)
|
||
primePageCache(around: safePage, preferredForward: predictedPageDirection)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 创建带指定 spine 位置的 UIPageViewController
|
||
/// - Parameter isDualPage: 是否双页模式（横屏时书脊在中间：.mid）
|
||
private func createPageViewController(isDualPage: Bool) -> UIPageViewController {
|
||
let options: [UIPageViewController.OptionsKey: Any]?
|
||
if isDualPage {
|
||
options = [.spineLocation: NSNumber(value: UIPageViewController.SpineLocation.mid.rawValue)]
|
||
} else {
|
||
options = nil
|
||
}
|
||
let pageVC = UIPageViewController(transitionStyle: .pageCurl, navigationOrientation: .horizontal, options: options)
|
||
pageVC.delegate = self
|
||
pageVC.dataSource = self
|
||
pageVC.isDoubleSided = isDualPage
|
||
return pageVC
|
||
}
|
||
|
||
/// 重建 UIPageViewController。横竖屏切换时需要重建，因为 spineLocation 只能在初始化时设置
|
||
private func rebuildPageViewController() {
|
||
detachPageViewControllerIfNeeded()
|
||
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape
|
||
let pageVC = createPageViewController(isDualPage: isDualPage)
|
||
pageViewController = pageVC
|
||
attachPageViewControllerIfNeeded()
|
||
}
|
||
|
||
// MARK: - UIPageViewController Fault Detection
|
||
|
||
private func detectPageViewControllerFault(_ pageVC: UIPageViewController) -> Bool {
|
||
guard currentDisplayType == .pageCurl else { return false }
|
||
let expectedCount = (landscapeDualPageEnabled && isLandscape) ? 2 : 1
|
||
guard let viewControllers = pageVC.viewControllers,
|
||
viewControllers.count == expectedCount else {
|
||
return true
|
||
}
|
||
|
||
let childViewControllers = viewControllers.compactMap { $0 as? RDReaderPageChildViewController }
|
||
guard childViewControllers.count == expectedCount else {
|
||
return true
|
||
}
|
||
|
||
if expectedCount == 1 {
|
||
return childViewControllers.first?.pageNum != currentPage
|
||
}
|
||
|
||
let expectedPair = dualPagePair(for: currentPage)
|
||
let expectedRightPage = expectedPair.right
|
||
?? (isFullScreenPage(expectedPair.left) ? RDReaderView.blankPageNum : RDReaderView.blankEndPageNum)
|
||
return childViewControllers[0].pageNum != expectedPair.left
|
||
|| childViewControllers[1].pageNum != expectedRightPage
|
||
}
|
||
|
||
private func patchPageViewControllerFault() {
|
||
guard currentPage >= 0 else { return }
|
||
DispatchQueue.main.async { [weak self] in
|
||
guard let self else { return }
|
||
self.invalidatePageCaches()
|
||
self.rebuildPageViewController()
|
||
self.transitionToPage(pageNum: self.currentPage, animated: false)
|
||
}
|
||
}
|
||
|
||
// MARK: - Preload / Forecast
|
||
|
||
private func ensurePreloadHostView() {
|
||
guard preloadHostView.superview == nil else { return }
|
||
preloadHostView.isHidden = true
|
||
preloadHostView.isUserInteractionEnabled = false
|
||
preloadHostView.clipsToBounds = true
|
||
preloadHostView.frame = bounds
|
||
preloadHostView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
|
||
insertSubview(preloadHostView, at: 0)
|
||
}
|
||
|
||
private func shouldCachePage(_ pageNum: Int) -> Bool {
|
||
pageNum >= 0
|
||
&& pageNum != RDReaderView.blankPageNum
|
||
&& pageNum != RDReaderView.blankEndPageNum
|
||
&& pageNum < (dataSource?.pageCountOfReaderView(readerView: self) ?? 0)
|
||
}
|
||
|
||
private func currentCacheSignature() -> CacheSignature {
|
||
CacheSignature(
|
||
displayType: currentDisplayType,
|
||
isLandscape: isLandscape,
|
||
pagesPerScreen: pagesPerScreen,
|
||
boundsSize: bounds.size
|
||
)
|
||
}
|
||
|
||
private func invalidatePageCaches() {
|
||
pageCurlCachedViews.values.forEach { $0.removeFromSuperview() }
|
||
preloadedPageViews.values.forEach { $0.removeFromSuperview() }
|
||
pageCurlCachedViews.removeAll()
|
||
preloadedPageViews.removeAll()
|
||
cacheSignature = currentCacheSignature()
|
||
}
|
||
|
||
private func refreshCacheSignatureIfNeeded() {
|
||
let signature = currentCacheSignature()
|
||
if cacheSignature != signature {
|
||
invalidatePageCaches()
|
||
} else if cacheSignature == nil {
|
||
cacheSignature = signature
|
||
}
|
||
}
|
||
|
||
private func spreadStart(for pageNum: Int) -> Int? {
|
||
guard shouldCachePage(pageNum) else { return nil }
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape && currentDisplayType != .verticalScroll
|
||
guard isDualPage else { return pageNum }
|
||
return dualPagePair(for: pageNum).left
|
||
}
|
||
|
||
private func spreadPageNumbers(startingAt pageNum: Int) -> Set<Int> {
|
||
guard shouldCachePage(pageNum) else { return [] }
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape && currentDisplayType != .verticalScroll
|
||
guard isDualPage else { return [pageNum] }
|
||
let pair = dualPagePair(for: pageNum)
|
||
var pages: Set<Int> = [pair.left]
|
||
if let right = pair.right, shouldCachePage(right) {
|
||
pages.insert(right)
|
||
}
|
||
return pages
|
||
}
|
||
|
||
private func adjacentSpreadStart(from pageNum: Int, forward: Bool) -> Int? {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
guard totalPages > 0,
|
||
let spreadStart = spreadStart(for: pageNum) else {
|
||
return nil
|
||
}
|
||
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape && currentDisplayType != .verticalScroll
|
||
guard isDualPage else {
|
||
let target = forward ? spreadStart + 1 : spreadStart - 1
|
||
return shouldCachePage(target) ? target : nil
|
||
}
|
||
|
||
if forward {
|
||
return adjacentDualPage(from: spreadStart, forward: true)
|
||
}
|
||
|
||
let pair = dualPagePair(for: spreadStart)
|
||
let prevEnd = pair.left - 1
|
||
guard prevEnd >= 0 else { return nil }
|
||
return dualPagePair(for: prevEnd).left
|
||
}
|
||
|
||
private func visiblePageNumbers(for anchorPage: Int) -> Set<Int> {
|
||
spreadPageNumbers(startingAt: anchorPage)
|
||
}
|
||
|
||
private func pageViewForDisplay(pageNum: Int) -> UIView {
|
||
if let cached = pageCurlCachedViews[pageNum] {
|
||
return cached
|
||
}
|
||
if let preloaded = preloadedPageViews.removeValue(forKey: pageNum) {
|
||
preloaded.removeFromSuperview()
|
||
pageCurlCachedViews[pageNum] = preloaded
|
||
return preloaded
|
||
}
|
||
let view = dataSource?.pageContentView(readerView: self, pageNum: pageNum, containerView: nil) ?? UIView()
|
||
pageCurlCachedViews[pageNum] = view
|
||
return view
|
||
}
|
||
|
||
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?) -> [Int] {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
guard totalPages > 0, shouldCachePage(pageNum) else { return [] }
|
||
|
||
var targets = Set<Int>()
|
||
|
||
var previousAnchor = pageNum
|
||
for _ in 0..<max(preloadRadius, 0) {
|
||
guard let prev = adjacentSpreadStart(from: previousAnchor, forward: false) else { break }
|
||
targets.formUnion(spreadPageNumbers(startingAt: prev))
|
||
previousAnchor = prev
|
||
}
|
||
|
||
var nextAnchor = pageNum
|
||
for _ in 0..<max(preloadRadius, 0) {
|
||
guard let next = adjacentSpreadStart(from: nextAnchor, forward: true) else { break }
|
||
targets.formUnion(spreadPageNumbers(startingAt: next))
|
||
nextAnchor = next
|
||
}
|
||
|
||
if let preferredForward,
|
||
let edgeAnchor = preferredForward ? adjacentSpreadStart(from: nextAnchor, forward: true)
|
||
: adjacentSpreadStart(from: previousAnchor, forward: false) {
|
||
targets.formUnion(spreadPageNumbers(startingAt: edgeAnchor))
|
||
}
|
||
|
||
return targets.sorted()
|
||
}
|
||
|
||
private func primePageCache(around pageNum: Int, preferredForward: Bool? = nil) {
|
||
refreshCacheSignatureIfNeeded()
|
||
let targets = forecastTargets(around: pageNum, preferredForward: preferredForward)
|
||
let keepSet = Set(targets).union(visiblePageNumbers(for: pageNum))
|
||
trimCachedPageViews(keeping: keepSet)
|
||
guard !targets.isEmpty else { return }
|
||
|
||
ensurePreloadHostView()
|
||
preloadHostView.frame = bounds
|
||
|
||
for targetPage in targets {
|
||
let existing = preloadedPageViews[targetPage] ?? pageCurlCachedViews.removeValue(forKey: targetPage)
|
||
let contentView = dataSource?.pageContentView(readerView: self, pageNum: targetPage, containerView: existing) ?? existing ?? UIView()
|
||
preloadedPageViews[targetPage] = contentView
|
||
if contentView.superview !== preloadHostView {
|
||
contentView.removeFromSuperview()
|
||
preloadHostView.addSubview(contentView)
|
||
}
|
||
contentView.frame = preloadHostView.bounds
|
||
}
|
||
}
|
||
|
||
public override func didMoveToSuperview() {
|
||
super.didMoveToSuperview()
|
||
|
||
if superview != nil {
|
||
makeUI()
|
||
}
|
||
}
|
||
|
||
private func attachPageViewControllerIfNeeded() {
|
||
guard let parentViewController = self.ss_superViewController else { return }
|
||
|
||
var didAddToParent = false
|
||
if pageViewController.parent !== parentViewController {
|
||
if pageViewController.parent != nil {
|
||
pageViewController.willMove(toParent: nil)
|
||
pageViewController.view.removeFromSuperview()
|
||
pageViewController.removeFromParent()
|
||
}
|
||
parentViewController.addChild(pageViewController)
|
||
didAddToParent = true
|
||
}
|
||
|
||
pageViewController.view.frame = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
|
||
pageViewController.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
|
||
if pageViewController.view.superview !== self {
|
||
insertSubview(pageViewController.view, at: 0)
|
||
}
|
||
|
||
if didAddToParent {
|
||
pageViewController.didMove(toParent: parentViewController)
|
||
}
|
||
}
|
||
|
||
private func detachPageViewControllerIfNeeded() {
|
||
if pageViewController.parent != nil {
|
||
pageViewController.willMove(toParent: nil)
|
||
}
|
||
pageViewController.view.removeFromSuperview()
|
||
if pageViewController.parent != nil {
|
||
pageViewController.removeFromParent()
|
||
}
|
||
}
|
||
|
||
private func makeUI() {
|
||
guard !didBuildUI else {
|
||
if currentDisplayType == .pageCurl {
|
||
attachPageViewControllerIfNeeded()
|
||
}
|
||
return
|
||
}
|
||
didBuildUI = true
|
||
|
||
collectionView.dataSource = self
|
||
collectionView.register(UICollectionViewCell.self, forCellWithReuseIdentifier: NSStringFromClass(UICollectionViewCell.self))
|
||
collectionView.frame = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
|
||
collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
|
||
|
||
if currentDisplayType == .pageCurl {
|
||
attachPageViewControllerIfNeeded()
|
||
}
|
||
ensurePreloadHostView()
|
||
cacheSignature = currentCacheSignature()
|
||
|
||
addGestureRecognizer(tapGestureRecognizer)
|
||
// 不取消底层触摸事件，确保工具栏按钮（返回等）的 touchUpInside 能正常触发
|
||
tapGestureRecognizer.cancelsTouchesInView = false
|
||
|
||
}
|
||
|
||
@objc private func tapAction(tap: UITapGestureRecognizer) {
|
||
let point = tap.location(in: tap.view)
|
||
if isShowToolView {
|
||
let hitView = hitTest(point, with: nil)
|
||
if let top = topToolView, isHitView(hitView, inside: top, point: point) { return }
|
||
if let bottom = bottomToolView, isHitView(hitView, inside: bottom, point: point) { return }
|
||
}
|
||
let viewFrame = tap.view!.frame
|
||
let leftFrame = CGRect(x: 0, y: 0, width: viewFrame.width / 3, height: viewFrame.height)
|
||
let centerFrame = CGRect(x: viewFrame.width / 3, y: 0, width: viewFrame.width / 3, height: viewFrame.height)
|
||
let rightFrame = CGRect(x: viewFrame.width * 2 / 3, y: 0, width: viewFrame.width / 3, height: viewFrame.height)
|
||
if leftFrame.contains(point) {
|
||
if isShowToolView {
|
||
tapEvent = .center
|
||
} else {
|
||
tapEvent = .left
|
||
}
|
||
}
|
||
|
||
if centerFrame.contains(point) {
|
||
tapEvent = .center
|
||
}
|
||
|
||
if rightFrame.contains(point) {
|
||
if isShowToolView {
|
||
tapEvent = .center
|
||
} else {
|
||
tapEvent = .right
|
||
}
|
||
}
|
||
}
|
||
|
||
private func tapCenter() {
|
||
isShowToolView = !isShowToolView
|
||
if isShowToolView {
|
||
if let topToolView = topToolView {
|
||
addSubview(topToolView)
|
||
topToolView.translatesAutoresizingMaskIntoConstraints = false
|
||
NSLayoutConstraint.activate([
|
||
topToolView.leadingAnchor.constraint(equalTo: leadingAnchor),
|
||
topToolView.trailingAnchor.constraint(equalTo: trailingAnchor),
|
||
topToolView.topAnchor.constraint(equalTo: topAnchor)
|
||
])
|
||
layoutIfNeeded()
|
||
topToolView.transform = CGAffineTransform(translationX: 0, y: -topToolView.bounds.height)
|
||
UIView.animate(withDuration: toolViewAnimationDuration) {
|
||
topToolView.transform = .identity
|
||
}
|
||
}
|
||
|
||
if let bottomToolView = bottomToolView {
|
||
addSubview(bottomToolView)
|
||
bottomToolView.translatesAutoresizingMaskIntoConstraints = false
|
||
NSLayoutConstraint.activate([
|
||
bottomToolView.leadingAnchor.constraint(equalTo: leadingAnchor),
|
||
bottomToolView.trailingAnchor.constraint(equalTo: trailingAnchor),
|
||
bottomToolView.bottomAnchor.constraint(equalTo: bottomAnchor)
|
||
])
|
||
layoutIfNeeded()
|
||
bottomToolView.transform = CGAffineTransform(translationX: 0, y: bottomToolView.bounds.height)
|
||
UIView.animate(withDuration: toolViewAnimationDuration) {
|
||
bottomToolView.transform = .identity
|
||
}
|
||
}
|
||
|
||
collectionView.isUserInteractionEnabled = false
|
||
pageViewController.view.isUserInteractionEnabled = false
|
||
} else {
|
||
if let topToolView = topToolView {
|
||
UIView.animate(withDuration: toolViewAnimationDuration, animations: {
|
||
topToolView.transform = CGAffineTransform(translationX: 0, y: -topToolView.bounds.height)
|
||
}) { _ in
|
||
topToolView.removeFromSuperview()
|
||
}
|
||
}
|
||
|
||
if let bottomToolView = bottomToolView {
|
||
UIView.animate(withDuration: toolViewAnimationDuration, animations: {
|
||
bottomToolView.transform = CGAffineTransform(translationX: 0, y: bottomToolView.bounds.height)
|
||
}) { _ in
|
||
bottomToolView.removeFromSuperview()
|
||
}
|
||
}
|
||
|
||
collectionView.isUserInteractionEnabled = true
|
||
pageViewController.view.isUserInteractionEnabled = true
|
||
}
|
||
}
|
||
|
||
private func isHitView(_ hitView: UIView?, inside toolView: UIView, point: CGPoint) -> Bool {
|
||
if toolView.frame.contains(point) {
|
||
return true
|
||
}
|
||
|
||
guard let hitView else { return false }
|
||
return hitView === toolView || hitView.isDescendant(of: toolView)
|
||
}
|
||
|
||
/// 切换翻页模式（仿真/水平滚动/上下滚动）
|
||
/// 会重建底层视图（PageViewController 或 CollectionView），并恢复到当前页
|
||
public func switchReaderDisplayType(_ displayType: RDReaderView.DisplayType) {
|
||
let previousDisplayType = currentDisplayType
|
||
self.currentDisplayType = displayType
|
||
if currentPage == -1 {
|
||
currentPage = 0
|
||
}
|
||
if previousDisplayType != displayType {
|
||
invalidatePageCaches()
|
||
}
|
||
// 同步横屏双页标记到布局
|
||
layout.isLandscapeDualPage = landscapeDualPageEnabled && isLandscape
|
||
layout.coverPageIndex = coverPageIndex
|
||
switch displayType {
|
||
case .pageCurl:
|
||
self.collectionView.removeFromSuperview()
|
||
self.collectionView.transform = .identity
|
||
attachPageViewControllerIfNeeded()
|
||
rebuildPageViewController()
|
||
transitionToPage(pageNum: currentPage)
|
||
primePageCache(around: currentPage, preferredForward: predictedPageDirection)
|
||
default:
|
||
detachPageViewControllerIfNeeded()
|
||
// RTL 水平模式翻转 collectionView
|
||
if pageDirection == .rightToLeft && displayType != .verticalScroll {
|
||
collectionView.transform = CGAffineTransform(scaleX: -1, y: 1)
|
||
} else {
|
||
collectionView.transform = .identity
|
||
}
|
||
// 确保 collectionView frame 正确后再触发布局计算
|
||
collectionView.frame = CGRect(x: 0, y: 0, width: frame.width, height: frame.height)
|
||
insertSubview(self.collectionView, at: 0)
|
||
layout.displayType = displayType
|
||
transitionToPage(pageNum: currentPage)
|
||
primePageCache(around: currentPage, preferredForward: predictedPageDirection)
|
||
}
|
||
}
|
||
|
||
/// 跳转到指定页码
|
||
/// - Parameters:
|
||
/// - pageNum: 目标页码（item 索引）
|
||
/// - animated: 是否动画过渡
|
||
public func transitionToPage(pageNum: Int, animated: Bool = false) {
|
||
switch currentDisplayType {
|
||
case .pageCurl:
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape
|
||
// RTL 时动画方向需要反转
|
||
let direction: UIPageViewController.NavigationDirection
|
||
if pageDirection == .rightToLeft {
|
||
direction = pageNum > currentPage ? .reverse : .forward
|
||
} else {
|
||
direction = pageNum > currentPage ? .forward : .reverse
|
||
}
|
||
if isDualPage {
|
||
let pair = dualPagePair(for: pageNum)
|
||
let leftContent = pageViewForDisplay(pageNum: pair.left)
|
||
let leftVC = RDReaderPageChildViewController(contentView: leftContent, pageNum: pair.left)
|
||
if let rightPage = pair.right {
|
||
let rightContent = pageViewForDisplay(pageNum: rightPage)
|
||
let rightVC = RDReaderPageChildViewController(contentView: rightContent, pageNum: rightPage)
|
||
pageViewController.setViewControllers([leftVC, rightVC], direction: animated ? direction : .forward, animated: animated, completion: nil)
|
||
} else {
|
||
// 封面页独占或奇数最后一页：右侧放空白页
|
||
let blankNum = isFullScreenPage(pair.left) ? RDReaderView.blankPageNum : RDReaderView.blankEndPageNum
|
||
let emptyVC = RDReaderPageChildViewController(contentView: UIView(), pageNum: blankNum)
|
||
pageViewController.setViewControllers([leftVC, emptyVC], direction: animated ? direction : .forward, animated: animated, completion: nil)
|
||
}
|
||
currentPage = pair.left
|
||
primePageCache(around: pair.left, preferredForward: predictedPageDirection)
|
||
} else {
|
||
let contentView = pageViewForDisplay(pageNum: pageNum)
|
||
let vc = RDReaderPageChildViewController(contentView: contentView, pageNum: pageNum)
|
||
pageViewController.setViewControllers([vc], direction: animated ? direction : .forward, animated: animated, completion: nil)
|
||
currentPage = pageNum
|
||
primePageCache(around: pageNum, preferredForward: predictedPageDirection)
|
||
}
|
||
default:
|
||
collectionView.reloadData()
|
||
collectionView.layoutIfNeeded()
|
||
collectionView.setContentOffset(layout.currentContentOffset(count: pageNum), animated: animated)
|
||
currentPage = pageNum
|
||
primePageCache(around: pageNum, preferredForward: predictedPageDirection)
|
||
}
|
||
}
|
||
|
||
public func reloadData() {
|
||
switchReaderDisplayType(currentDisplayType)
|
||
topToolView = self.dataSource?.topToolView?(readerView: self)
|
||
bottomToolView = self.dataSource?.bottomToolView?(readerView: self)
|
||
}
|
||
|
||
|
||
required init?(coder: NSCoder) {
|
||
fatalError("init(coder:) has not been implemented")
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
extension RDReaderView: UIPageViewControllerDataSource, UIPageViewControllerDelegate {
|
||
|
||
private func makeSinglePageChildVC(for pageNum: Int) -> RDReaderPageChildViewController {
|
||
if pageNum == RDReaderView.blankPageNum || pageNum == RDReaderView.blankEndPageNum {
|
||
return RDReaderPageChildViewController(contentView: UIView(), pageNum: pageNum)
|
||
}
|
||
let contentView = pageViewForDisplay(pageNum: pageNum)
|
||
return RDReaderPageChildViewController(contentView: contentView, pageNum: pageNum)
|
||
}
|
||
|
||
/// 计算某页的"下一页"页码（考虑封面页插入空白页）
|
||
private func nextPageNum(after pageNum: Int, isDualPage: Bool) -> Int? {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
|
||
// 末尾空白页之后没有更多页
|
||
if pageNum == RDReaderView.blankEndPageNum {
|
||
return nil
|
||
}
|
||
|
||
if isDualPage, let coverIndex = coverPageIndex {
|
||
if pageNum == coverIndex {
|
||
return RDReaderView.blankPageNum
|
||
}
|
||
if pageNum == RDReaderView.blankPageNum {
|
||
let firstContent = coverIndex + 1
|
||
return firstContent < totalPages ? firstContent : nil
|
||
}
|
||
}
|
||
|
||
let next = pageNum + 1
|
||
if next < totalPages {
|
||
return next
|
||
}
|
||
|
||
// pageNum 是最后一页，检查在双页模式下是否需要空白页配对
|
||
if isDualPage {
|
||
if let coverIndex = coverPageIndex {
|
||
// 有封面时：封面之后的页面两两配对，偶数偏移=左页需要配对
|
||
let adjustedIndex = pageNum - (coverIndex + 1)
|
||
if adjustedIndex >= 0 && adjustedIndex % 2 == 0 {
|
||
return RDReaderView.blankEndPageNum
|
||
}
|
||
} else {
|
||
// 无封面：偶数索引=左页需要配对
|
||
if pageNum % 2 == 0 {
|
||
return RDReaderView.blankEndPageNum
|
||
}
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
/// 计算某页的"上一页"页码（考虑封面页插入空白页）
|
||
private func prevPageNum(before pageNum: Int, isDualPage: Bool) -> Int? {
|
||
// 末尾空白页的前一页是最后一个真实页
|
||
if pageNum == RDReaderView.blankEndPageNum {
|
||
let totalPages = dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
return totalPages > 0 ? totalPages - 1 : nil
|
||
}
|
||
if isDualPage, let coverIndex = coverPageIndex {
|
||
if pageNum == RDReaderView.blankPageNum {
|
||
return coverIndex
|
||
}
|
||
if pageNum == coverIndex + 1 {
|
||
return RDReaderView.blankPageNum
|
||
}
|
||
}
|
||
let prev = pageNum - 1
|
||
return prev >= 0 ? prev : nil
|
||
}
|
||
|
||
public func pageViewController(_ pageViewController: UIPageViewController, viewControllerBefore viewController: UIViewController) -> UIViewController? {
|
||
guard let vc = viewController as? RDReaderPageChildViewController else { return nil }
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape
|
||
let isRTL = pageDirection == .rightToLeft
|
||
|
||
// RTL 时 before/after 语义互换：before（向右翻）= 下一页
|
||
let targetNum = isRTL
|
||
? nextPageNum(after: vc.pageNum, isDualPage: isDualPage)
|
||
: prevPageNum(before: vc.pageNum, isDualPage: isDualPage)
|
||
|
||
guard let num = targetNum else { return nil }
|
||
let targetVC = makeSinglePageChildVC(for: num)
|
||
willPreviousTransitionToViewController = targetVC
|
||
return targetVC
|
||
}
|
||
|
||
public func pageViewController(_ pageViewController: UIPageViewController, viewControllerAfter viewController: UIViewController) -> UIViewController? {
|
||
guard let vc = viewController as? RDReaderPageChildViewController else { return nil }
|
||
let isDualPage = landscapeDualPageEnabled && isLandscape
|
||
let isRTL = pageDirection == .rightToLeft
|
||
|
||
let targetNum = isRTL
|
||
? prevPageNum(before: vc.pageNum, isDualPage: isDualPage)
|
||
: nextPageNum(after: vc.pageNum, isDualPage: isDualPage)
|
||
|
||
guard let num = targetNum else { return nil }
|
||
let targetVC = makeSinglePageChildVC(for: num)
|
||
willNextTransitionToViewController = targetVC
|
||
return targetVC
|
||
}
|
||
|
||
public func pageViewController(_ pageViewController: UIPageViewController, didFinishAnimating finished: Bool, previousViewControllers: [UIViewController], transitionCompleted completed: Bool) {
|
||
if completed, let firstVC = pageViewController.viewControllers?.first as? RDReaderPageChildViewController {
|
||
let pn = firstVC.pageNum
|
||
if pn != RDReaderView.blankPageNum && pn != RDReaderView.blankEndPageNum {
|
||
currentPage = pn
|
||
primePageCache(around: pn, preferredForward: predictedPageDirection)
|
||
}
|
||
}
|
||
|
||
predictedPageDirection = nil
|
||
|
||
if detectPageViewControllerFault(pageViewController) {
|
||
patchPageViewControllerFault()
|
||
}
|
||
}
|
||
|
||
public func pageViewController(_ pageViewController: UIPageViewController, willTransitionTo pendingViewControllers: [UIViewController]) {
|
||
willTransitionToViewController = pendingViewControllers.first
|
||
if let target = pendingViewControllers.first as? RDReaderPageChildViewController,
|
||
target.pageNum != RDReaderView.blankPageNum,
|
||
target.pageNum != RDReaderView.blankEndPageNum {
|
||
predictedPageDirection = target.pageNum >= currentPage
|
||
primePageCache(around: target.pageNum, preferredForward: predictedPageDirection)
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
extension RDReaderView: UICollectionViewDataSource, RDReaderFlowLayoutDelegate, RDReaderFlowLayoutDataSoure {
|
||
public func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
|
||
|
||
|
||
if let identifer = self.dataSource?.pageIdentifier(readerView: self, pageNum: indexPath.row) {
|
||
|
||
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: identifer, for: IndexPath(item: indexPath.row, section: 0)) as! RDReaderContentCell
|
||
let preloadedView = preloadedPageViews.removeValue(forKey: indexPath.row)
|
||
preloadedView?.removeFromSuperview()
|
||
let reusableView = cell.containerView ?? preloadedView
|
||
let conttainerView = self.dataSource?.pageContentView(readerView: self, pageNum: indexPath.row, containerView: reusableView)
|
||
if let conttainerView = conttainerView {
|
||
cell.containerView = conttainerView
|
||
}
|
||
// RTL 水平模式：翻转 cell 内容使文字方向正常（collectionView 已整体翻转）
|
||
if pageDirection == .rightToLeft && currentDisplayType != .verticalScroll {
|
||
cell.contentView.transform = CGAffineTransform(scaleX: -1, y: 1)
|
||
} else {
|
||
cell.contentView.transform = .identity
|
||
}
|
||
return cell
|
||
}
|
||
|
||
let cell = collectionView.dequeueReusableCell(withReuseIdentifier: NSStringFromClass(UICollectionViewCell.self), for: indexPath)
|
||
|
||
return cell
|
||
}
|
||
|
||
public func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
|
||
return self.dataSource?.pageCountOfReaderView(readerView: self) ?? 0
|
||
}
|
||
|
||
public func pageNum(flowLayout: RDReaderFlowLayout, pageIndex: Int) {
|
||
currentPage = pageIndex
|
||
primePageCache(around: pageIndex, preferredForward: predictedPageDirection)
|
||
}
|
||
|
||
public func heigtOfVerticalScrollPage(flowLayout: RDReaderFlowLayout, pageIndex: Int) -> CGFloat? {
|
||
return nil
|
||
}
|
||
}
|
||
|
||
extension RDReaderView {
|
||
public func register(contentView: UIView.Type, contentViewWithReuseIdentifier identifier: String) {
|
||
contentViews[identifier] = contentView
|
||
collectionView.register(RDReaderContentCell.self, forCellWithReuseIdentifier: identifier)
|
||
}
|
||
|
||
|
||
public func dequeueReusableContentView(withReuseIdentifier identifier: String, for pageNum: Int) -> UIView {
|
||
if self.currentDisplayType != .pageCurl, let cell = self.collectionView.cellForItem(at: IndexPath(row: pageNum, section: 0)) as? RDReaderContentCell, let containerView = cell.containerView {
|
||
return containerView
|
||
}
|
||
let contentViewClass = contentViews[identifier]
|
||
assert(contentViewClass != nil, "请调用register(contentView：contentViewWithReuseIdentifier：）")
|
||
var contentView = contentViewClass!.init()
|
||
return contentView
|
||
}
|
||
|
||
public func pageContentView(pageNum: Int) -> UIView? {
|
||
if currentDisplayType == .pageCurl {
|
||
return (self.pageViewController.viewControllers?.first as? RDReaderPageChildViewController)?.contentView
|
||
} else {
|
||
let cell = collectionView.cellForItem(at: IndexPath(item: pageNum, section: 0)) as? RDReaderContentCell
|
||
return cell?.containerView
|
||
}
|
||
}
|
||
}
|
||
|
||
private var cellViewKey: Int8 = 0
|
||
extension UIView {
|
||
var ss_superViewController: UIViewController? {
|
||
var next = self.next
|
||
while next != nil {
|
||
if next is UIViewController {
|
||
return next as? UIViewController
|
||
} else {
|
||
next = next!.next
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
}
|