316 lines
15 KiB
Swift
316 lines
15 KiB
Swift
//
|
|
// HomeTimelineViewModel+Diffable.swift
|
|
// Mastodon
|
|
//
|
|
// Created by sxiaojian on 2021/2/7.
|
|
//
|
|
|
|
import os.log
|
|
import UIKit
|
|
import CoreData
|
|
import CoreDataStack
|
|
|
|
extension HomeTimelineViewModel {
|
|
|
|
func setupDiffableDataSource(
|
|
tableView: UITableView,
|
|
statusTableViewCellDelegate: StatusTableViewCellDelegate,
|
|
timelineMiddleLoaderTableViewCellDelegate: TimelineMiddleLoaderTableViewCellDelegate
|
|
) {
|
|
diffableDataSource = StatusSection.diffableDataSource(
|
|
tableView: tableView,
|
|
context: context,
|
|
configuration: StatusSection.Configuration(
|
|
statusTableViewCellDelegate: statusTableViewCellDelegate,
|
|
timelineMiddleLoaderTableViewCellDelegate: timelineMiddleLoaderTableViewCellDelegate,
|
|
filterContext: .home,
|
|
activeFilters: context.statusFilterService.$activeFilters
|
|
)
|
|
)
|
|
|
|
// make initial snapshot animation smooth
|
|
var snapshot = NSDiffableDataSourceSnapshot<StatusSection, StatusItem>()
|
|
snapshot.appendSections([.main])
|
|
diffableDataSource?.apply(snapshot)
|
|
|
|
fetchedResultsController.$records
|
|
.receive(on: DispatchQueue.main)
|
|
.sink { [weak self] records in
|
|
guard let self = self else { return }
|
|
guard let diffableDataSource = self.diffableDataSource else { return }
|
|
self.logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): incoming \(records.count) objects")
|
|
Task {
|
|
let start = CACurrentMediaTime()
|
|
defer {
|
|
let end = CACurrentMediaTime()
|
|
self.logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): cost \(end - start, format: .fixed(precision: 4))s to process \(records.count) feeds")
|
|
}
|
|
let oldSnapshot = diffableDataSource.snapshot()
|
|
var newSnapshot: NSDiffableDataSourceSnapshot<StatusSection, StatusItem> = {
|
|
let newItems = records.map { record in
|
|
StatusItem.feed(record: record)
|
|
}
|
|
var snapshot = NSDiffableDataSourceSnapshot<StatusSection, StatusItem>()
|
|
snapshot.appendSections([.main])
|
|
snapshot.appendItems(newItems, toSection: .main)
|
|
return snapshot
|
|
}()
|
|
|
|
let parentManagedObjectContext = self.context.managedObjectContext
|
|
let managedObjectContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
|
|
managedObjectContext.parent = parentManagedObjectContext
|
|
try? await managedObjectContext.perform {
|
|
let anchors: [Feed] = {
|
|
let request = Feed.sortedFetchRequest
|
|
request.predicate = NSCompoundPredicate(andPredicateWithSubpredicates: [
|
|
Feed.hasMorePredicate(),
|
|
self.fetchedResultsController.predicate,
|
|
])
|
|
do {
|
|
return try managedObjectContext.fetch(request)
|
|
} catch {
|
|
assertionFailure(error.localizedDescription)
|
|
return []
|
|
}
|
|
}()
|
|
|
|
let itemIdentifiers = newSnapshot.itemIdentifiers
|
|
for (index, item) in itemIdentifiers.enumerated() {
|
|
guard case let .feed(record) = item else { continue }
|
|
guard anchors.contains(where: { feed in feed.objectID == record.objectID }) else { continue }
|
|
let isLast = index + 1 == itemIdentifiers.count
|
|
if isLast {
|
|
newSnapshot.insertItems([.bottomLoader], afterItem: item)
|
|
} else {
|
|
newSnapshot.insertItems([.feedLoader(record: record)], afterItem: item)
|
|
}
|
|
}
|
|
}
|
|
|
|
let hasChanges = newSnapshot.itemIdentifiers != oldSnapshot.itemIdentifiers
|
|
if !hasChanges {
|
|
self.logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): snapshot not changes")
|
|
self.didLoadLatest.send()
|
|
return
|
|
} else {
|
|
self.logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): snapshot has changes")
|
|
}
|
|
|
|
guard let difference = await self.calculateReloadSnapshotDifference(
|
|
tableView: tableView,
|
|
oldSnapshot: oldSnapshot,
|
|
newSnapshot: newSnapshot
|
|
) else {
|
|
await self.updateSnapshotUsingReloadData(snapshot: newSnapshot)
|
|
self.didLoadLatest.send()
|
|
self.logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): applied new snapshot")
|
|
return
|
|
}
|
|
|
|
await self.updateSnapshotUsingReloadData(snapshot: newSnapshot)
|
|
await tableView.scrollToRow(at: difference.targetIndexPath, at: .top, animated: false)
|
|
var contentOffset = await tableView.contentOffset
|
|
contentOffset.y = await tableView.contentOffset.y - difference.sourceDistanceToTableViewTopEdge
|
|
await tableView.setContentOffset(contentOffset, animated: false)
|
|
self.didLoadLatest.send()
|
|
self.logger.log(level: .debug, "\((#file as NSString).lastPathComponent, privacy: .public)[\(#line, privacy: .public)], \(#function, privacy: .public): applied new snapshot")
|
|
} // end Task
|
|
}
|
|
.store(in: &disposeBag)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
extension HomeTimelineViewModel {
|
|
|
|
@MainActor func updateDataSource(
|
|
snapshot: NSDiffableDataSourceSnapshot<StatusSection, StatusItem>,
|
|
animatingDifferences: Bool
|
|
) async {
|
|
diffableDataSource?.apply(snapshot, animatingDifferences: animatingDifferences)
|
|
}
|
|
|
|
@MainActor func updateSnapshotUsingReloadData(
|
|
snapshot: NSDiffableDataSourceSnapshot<StatusSection, StatusItem>
|
|
) async {
|
|
if #available(iOS 15.0, *) {
|
|
await self.diffableDataSource?.applySnapshotUsingReloadData(snapshot)
|
|
} else {
|
|
diffableDataSource?.applySnapshot(snapshot, animated: false, completion: nil)
|
|
}
|
|
}
|
|
|
|
struct Difference<T> {
|
|
let item: T
|
|
let sourceIndexPath: IndexPath
|
|
let sourceDistanceToTableViewTopEdge: CGFloat
|
|
let targetIndexPath: IndexPath
|
|
}
|
|
|
|
@MainActor private func calculateReloadSnapshotDifference<S: Hashable, T: Hashable>(
|
|
tableView: UITableView,
|
|
oldSnapshot: NSDiffableDataSourceSnapshot<S, T>,
|
|
newSnapshot: NSDiffableDataSourceSnapshot<S, T>
|
|
) -> Difference<T>? {
|
|
guard let sourceIndexPath = (tableView.indexPathsForVisibleRows ?? []).sorted().first else { return nil }
|
|
let rectForSourceItemCell = tableView.rectForRow(at: sourceIndexPath)
|
|
let sourceDistanceToTableViewTopEdge = tableView.convert(rectForSourceItemCell, to: nil).origin.y - tableView.safeAreaInsets.top
|
|
|
|
guard sourceIndexPath.section < oldSnapshot.numberOfSections,
|
|
sourceIndexPath.row < oldSnapshot.numberOfItems(inSection: oldSnapshot.sectionIdentifiers[sourceIndexPath.section])
|
|
else { return nil }
|
|
|
|
let sectionIdentifier = oldSnapshot.sectionIdentifiers[sourceIndexPath.section]
|
|
let item = oldSnapshot.itemIdentifiers(inSection: sectionIdentifier)[sourceIndexPath.row]
|
|
|
|
guard let targetIndexPathRow = newSnapshot.indexOfItem(item),
|
|
let newSectionIdentifier = newSnapshot.sectionIdentifier(containingItem: item),
|
|
let targetIndexPathSection = newSnapshot.indexOfSection(newSectionIdentifier)
|
|
else { return nil }
|
|
|
|
let targetIndexPath = IndexPath(row: targetIndexPathRow, section: targetIndexPathSection)
|
|
|
|
return Difference(
|
|
item: item,
|
|
sourceIndexPath: sourceIndexPath,
|
|
sourceDistanceToTableViewTopEdge: sourceDistanceToTableViewTopEdge,
|
|
targetIndexPath: targetIndexPath
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//// MARK: - NSFetchedResultsControllerDelegate
|
|
//extension HomeTimelineViewModel: NSFetchedResultsControllerDelegate {
|
|
//
|
|
// func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
|
|
// os_log("%{public}s[%{public}ld], %{public}s", ((#file as NSString).lastPathComponent), #line, #function)
|
|
// }
|
|
//
|
|
// func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChangeContentWith snapshot: NSDiffableDataSourceSnapshotReference) {
|
|
// os_log("%{public}s[%{public}ld], %{public}s", ((#file as NSString).lastPathComponent), #line, #function)
|
|
//
|
|
// guard let tableView = self.tableView else { return }
|
|
// guard let navigationBar = self.contentOffsetAdjustableTimelineViewControllerDelegate?.navigationBar() else { return }
|
|
//
|
|
// guard let diffableDataSource = self.diffableDataSource else { return }
|
|
// let oldSnapshot = diffableDataSource.snapshot()
|
|
//
|
|
// let predicate = fetchedResultsController.fetchRequest.predicate
|
|
// let parentManagedObjectContext = fetchedResultsController.managedObjectContext
|
|
// let managedObjectContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
|
|
// managedObjectContext.parent = parentManagedObjectContext
|
|
//
|
|
// managedObjectContext.perform {
|
|
// var shouldAddBottomLoader = false
|
|
//
|
|
// let timelineIndexes: [HomeTimelineIndex] = {
|
|
// let request = HomeTimelineIndex.sortedFetchRequest
|
|
// request.returnsObjectsAsFaults = false
|
|
// request.predicate = predicate
|
|
// do {
|
|
// return try managedObjectContext.fetch(request)
|
|
// } catch {
|
|
// assertionFailure(error.localizedDescription)
|
|
// return []
|
|
// }
|
|
// }()
|
|
//
|
|
// // that's will be the most fastest fetch because of upstream just update and no modify needs consider
|
|
//
|
|
// var oldSnapshotAttributeDict: [NSManagedObjectID : Item.StatusAttribute] = [:]
|
|
//
|
|
// for item in oldSnapshot.itemIdentifiers {
|
|
// guard case let .homeTimelineIndex(objectID, attribute) = item else { continue }
|
|
// oldSnapshotAttributeDict[objectID] = attribute
|
|
// }
|
|
//
|
|
// var newTimelineItems: [Item] = []
|
|
//
|
|
// for (i, timelineIndex) in timelineIndexes.enumerated() {
|
|
// let attribute = oldSnapshotAttributeDict[timelineIndex.objectID] ?? Item.StatusAttribute()
|
|
// attribute.isSeparatorLineHidden = false
|
|
//
|
|
// // append new item into snapshot
|
|
// newTimelineItems.append(.homeTimelineIndex(objectID: timelineIndex.objectID, attribute: attribute))
|
|
//
|
|
// let isLast = i == timelineIndexes.count - 1
|
|
// switch (isLast, timelineIndex.hasMore) {
|
|
// case (false, true):
|
|
// newTimelineItems.append(.homeMiddleLoader(upperTimelineIndexAnchorObjectID: timelineIndex.objectID))
|
|
// attribute.isSeparatorLineHidden = true
|
|
// case (true, true):
|
|
// shouldAddBottomLoader = true
|
|
// default:
|
|
// break
|
|
// }
|
|
// } // end for
|
|
//
|
|
// var newSnapshot = NSDiffableDataSourceSnapshot<StatusSection, Item>()
|
|
// newSnapshot.appendSections([.main])
|
|
// newSnapshot.appendItems(newTimelineItems, toSection: .main)
|
|
//
|
|
// let endSnapshot = CACurrentMediaTime()
|
|
//
|
|
// DispatchQueue.main.async {
|
|
// if shouldAddBottomLoader, !(self.loadLatestStateMachine.currentState is LoadOldestState.NoMore) {
|
|
// newSnapshot.appendItems([.bottomLoader], toSection: .main)
|
|
// }
|
|
//
|
|
// guard let difference = self.calculateReloadSnapshotDifference(navigationBar: navigationBar, tableView: tableView, oldSnapshot: oldSnapshot, newSnapshot: newSnapshot) else {
|
|
// diffableDataSource.apply(newSnapshot)
|
|
// self.isFetchingLatestTimeline.value = false
|
|
// return
|
|
// }
|
|
//
|
|
// diffableDataSource.reloadData(snapshot: newSnapshot) {
|
|
// tableView.scrollToRow(at: difference.targetIndexPath, at: .top, animated: false)
|
|
// tableView.contentOffset.y = tableView.contentOffset.y - difference.offset
|
|
// self.isFetchingLatestTimeline.value = false
|
|
// }
|
|
//
|
|
// let end = CACurrentMediaTime()
|
|
// os_log("%{public}s[%{public}ld], %{public}s: calculate home timeline layout cost %.2fs", ((#file as NSString).lastPathComponent), #line, #function, end - endSnapshot)
|
|
// }
|
|
// } // end perform
|
|
// }
|
|
//
|
|
// private struct Difference<T> {
|
|
// let item: T
|
|
// let sourceIndexPath: IndexPath
|
|
// let targetIndexPath: IndexPath
|
|
// let offset: CGFloat
|
|
// }
|
|
//
|
|
// private func calculateReloadSnapshotDifference<T: Hashable>(
|
|
// navigationBar: UINavigationBar,
|
|
// tableView: UITableView,
|
|
// oldSnapshot: NSDiffableDataSourceSnapshot<StatusSection, T>,
|
|
// newSnapshot: NSDiffableDataSourceSnapshot<StatusSection, T>
|
|
// ) -> Difference<T>? {
|
|
// guard oldSnapshot.numberOfItems != 0 else { return nil }
|
|
//
|
|
// // old snapshot not empty. set source index path to first item if not match
|
|
// let sourceIndexPath = UIViewController.topVisibleTableViewCellIndexPath(in: tableView, navigationBar: navigationBar) ?? IndexPath(row: 0, section: 0)
|
|
//
|
|
// guard sourceIndexPath.row < oldSnapshot.itemIdentifiers(inSection: .main).count else { return nil }
|
|
//
|
|
// let timelineItem = oldSnapshot.itemIdentifiers(inSection: .main)[sourceIndexPath.row]
|
|
// guard let itemIndex = newSnapshot.itemIdentifiers(inSection: .main).firstIndex(of: timelineItem) else { return nil }
|
|
// let targetIndexPath = IndexPath(row: itemIndex, section: 0)
|
|
//
|
|
// let offset = UIViewController.tableViewCellOriginOffsetToWindowTop(in: tableView, at: sourceIndexPath, navigationBar: navigationBar)
|
|
// return Difference(
|
|
// item: timelineItem,
|
|
// sourceIndexPath: sourceIndexPath,
|
|
// targetIndexPath: targetIndexPath,
|
|
// offset: offset
|
|
// )
|
|
// }
|
|
//
|
|
//}
|