Dequeue cells more than default UICollectionView dequeued cells

Question

Is there a way to dequeue more cells than default UICollectionView dequeued cells? For example in the picture below UICollectionView dequeues showing cell, one before and one after. Is there a way to dequeue more than this three cells?func collectionView(_ collectionView: UICollectionView, prefetchItemsAt indexPaths: [IndexPath]) { print("Prefetch: \(indexPaths)") }

only gives me one indexpath after. What I need is to create four or five cells after and before showing cells to Implement my functionality before cell is shown.

Dequeue is called when needed: ~when the cell needs to be shown. This avoid loading more than necessary (and it means less CPU uses, so faster, so less battery, etc.). Although, by expanding the contentSize of your collectionView, you might be able to force that dequeue. Because it's more in fact when the cell enters the contentSize part if I remember correctly. Then a few more tricks would be needed to avoid not showing some top/bottom part of the collectionView content. — Larme
@Paulw11 as I already said prefetching gives me one indexpath ahead. What I need is to be able to access cells further more than one indexpath ahead like four or five — Omid Kia
@MartinR each of my cells contain an instance of AVPlayer to play a video. I need a cell to be instantiated fully with AVPlayer to be prepared and played whenever it's visible. — Omid Kia
@Larme I guess increasing the contentSize would result in creating unwanted white space at the bottom of my collectionView which I suppose is not a clean workaround of this matter — Omid Kia

Tarun Tyagi Tarun Tyagi · Accepted Answer · 2021-07-16T09:53:19

An official Apple sample code shows a technique that you might find useful. Instead of relying on UICollectionView to receive callbacks and load data as needed, you can observe scrolling and based on contentOffset value, you will know how much look ahead you need.

Copy pasting relevant parts here in case link isn't available for a future reader. All of this lives inside a UICollectionViewController subclass - it can be adapted to work with any UIScrollView in general.

func scrollViewDidScroll(_ scrollView: UIScrollView) {
    // This is your trigger point
    updateCachedAssets()
}

var fetchResult: PHFetchResult<PHAsset>!
fileprivate let imageManager = PHCachingImageManager()
fileprivate let thumbnailSize: CGSize = CGSize(width: 100, height: 100)
fileprivate var previousPreheatRect = CGRect.zero
fileprivate func updateCachedAssets() {
    // Update only if the view is visible.
    guard isViewLoaded && view.window != nil else { return }
    
    // The window you prepare ahead of time is twice the height of the visible rect.
    let visibleRect = CGRect(origin: collectionView!.contentOffset, size: collectionView!.bounds.size)
    let preheatRect = visibleRect.insetBy(dx: 0, dy: -0.5 * visibleRect.height)
        
    // Update only if the visible area is significantly different from the last preheated area.
    let delta = abs(preheatRect.midY - previousPreheatRect.midY)
    guard delta > view.bounds.height / 3 else { return }
    
    // Compute the assets to start and stop caching.
    let (addedRects, removedRects) = differencesBetweenRects(previousPreheatRect, preheatRect)
    let addedAssets = addedRects
        .flatMap { rect in collectionView!.indexPathsForElements(in: rect) }
        .map { indexPath in fetchResult.object(at: indexPath.item) }
    let removedAssets = removedRects
        .flatMap { rect in collectionView!.indexPathsForElements(in: rect) }
        .map { indexPath in fetchResult.object(at: indexPath.item) }
        
    // Update the assets the PHCachingImageManager is caching.
    imageManager.startCachingImages(for: addedAssets,
                                    targetSize: thumbnailSize, contentMode: .aspectFill, options: nil)
    imageManager.stopCachingImages(for: removedAssets,
                                   targetSize: thumbnailSize, contentMode: .aspectFill, options: nil)
    // Store the computed rectangle for future comparison.
    previousPreheatRect = preheatRect
}

fileprivate func differencesBetweenRects(_ old: CGRect, _ new: CGRect) -> (added: [CGRect], removed: [CGRect]) {
    if old.intersects(new) {
        var added = [CGRect]()
        if new.maxY > old.maxY {
            added += [CGRect(x: new.origin.x, y: old.maxY,
                             width: new.width, height: new.maxY - old.maxY)]
        }
        if old.minY > new.minY {
            added += [CGRect(x: new.origin.x, y: new.minY,
                             width: new.width, height: old.minY - new.minY)]
        }
        var removed = [CGRect]()
        if new.maxY < old.maxY {
            removed += [CGRect(x: new.origin.x, y: new.maxY,
                               width: new.width, height: old.maxY - new.maxY)]
        }
        if old.minY < new.minY {
            removed += [CGRect(x: new.origin.x, y: old.minY,
                               width: new.width, height: new.minY - old.minY)]
        }
        return (added, removed)
    } else {
        return ([new], [old])
    }
}

Notes

The code is several years old and you will need to adapt this to your requirements.

You can adjust the preheatRect compute to be what fits your needs.
// The window you prepare ahead of time is twice the height of the visible rect.
let visibleRect = CGRect(origin: collectionView!.contentOffset, size: collectionView!.bounds.size)
let preheatRect = visibleRect.insetBy(dx: 0, dy: -0.5 * visibleRect.height)
The sample implements this preheatRect logic for preloading PHAsset thumbnails. You need to adapt your dataSource to a similar style and start/stop loading your resources.

Dequeue cells more than default UICollectionView dequeued cells

1 Answers

Notes