//

// ASCollectionView.mm

// AsyncDisplayKit

//

// Copyright (c) 2014-present, Facebook, Inc. All rights reserved.

// This source code is licensed under the BSD-style license found in the

// LICENSE file in the root directory of this source tree. An additional grant

// of patent rights can be found in the PATENTS file in the same directory.

//

#import "ASAssert.h"

#import "ASAvailability.h"

#import "ASBatchFetching.h"

#import "ASDelegateProxy.h"

#import "ASCellNode+Internal.h"

#import "ASCollectionDataController.h"

#import "ASCollectionViewLayoutController.h"

#import "ASCollectionViewFlowLayoutInspector.h"

#import "ASDisplayNodeExtras.h"

#import "ASDisplayNode+FrameworkPrivate.h"

#import "ASInternalHelpers.h"

#import "UICollectionViewLayout+ASConvenience.h"

#import "ASRangeController.h"

#import "ASCollectionNode.h"

#import "_ASDisplayLayer.h"

#import "ASCollectionViewLayoutFacilitatorProtocol.h"

#import "ASSectionContext.h"

#import "ASCollectionView+Undeprecated.h"

/**

* A macro to get self.collectionNode and assign it to a local variable, or return

* the given value if nil.

*

* Previously we would set ASCollectionNode's dataSource & delegate to nil

* during dealloc. However, our asyncDelegate & asyncDataSource must be set on the

* main thread, so if the node is deallocated off-main, we won't learn about the change

* until later on. Since our @c collectionNode parameter to delegate methods (e.g.

* collectionNode:didEndDisplayingItemWithNode:) is nonnull, it's important that we never

* unintentionally pass nil (this will crash in Swift, in production). So we can use

* this macro to ensure that our node is still alive before calling out to the user

* on its behalf.

*/

#define GET_COLLECTIONNODE_OR_RETURN(__var, __val) \

ASCollectionNode *__var = self.collectionNode; \

if (__var == nil) { \

return __val; \

}

/// What, if any, invalidation should we perform during the next -layoutSubviews.

typedef NS_ENUM(NSUInteger, ASCollectionViewInvalidationStyle) {

/// Perform no invalidation.

ASCollectionViewInvalidationStyleNone,

/// Perform invalidation with animation (use an empty batch update).

ASCollectionViewInvalidationStyleWithoutAnimation,

/// Perform invalidation without animation (use -invalidateLayout).

ASCollectionViewInvalidationStyleWithAnimation,

};

static const NSUInteger kASCollectionViewAnimationNone = UITableViewRowAnimationNone;

static NSString * const kCellReuseIdentifier = @"_ASCollectionViewCell";

#pragma mark -

#pragma mark ASCellNode<->UICollectionViewCell bridging.

@class _ASCollectionViewCell;

@interface _ASCollectionViewCell : UICollectionViewCell

@property (nonatomic, weak) ASCellNode *node;

@property (nonatomic, strong) UICollectionViewLayoutAttributes *layoutAttributes;

@end

@implementation _ASCollectionViewCell

- (void)setNode:(ASCellNode *)node

{

ASDisplayNodeAssertMainThread();

node.layoutAttributes = _layoutAttributes;

_node = node;

self.backgroundColor = node.backgroundColor;

self.clipsToBounds = node.clipsToBounds;

[node __setSelectedFromUIKit:self.selected];

[node __setHighlightedFromUIKit:self.highlighted];

}

- (void)setSelected:(BOOL)selected

{

[super setSelected:selected];

[_node __setSelectedFromUIKit:selected];

}

- (void)setHighlighted:(BOOL)highlighted

{

[super setHighlighted:highlighted];

[_node __setHighlightedFromUIKit:highlighted];

}

- (void)setLayoutAttributes:(UICollectionViewLayoutAttributes *)layoutAttributes

{

_layoutAttributes = layoutAttributes;

_node.layoutAttributes = layoutAttributes;

}

- (void)prepareForReuse

{

self.layoutAttributes = nil;

// Need to clear node pointer before UIKit calls setSelected:NO / setHighlighted:NO on its cells

self.node = nil;

[super prepareForReuse];

}

/**

* In the initial case, this is called by UICollectionView during cell dequeueing, before

* we get a chance to assign a node to it, so we must be sure to set these layout attributes

* on our node when one is next assigned to us in @c setNode: . Since there may be cases when we _do_ already

* have our node assigned e.g. during a layout update for existing cells, we also attempt

* to update it now.

*/

- (void)applyLayoutAttributes:(UICollectionViewLayoutAttributes *)layoutAttributes

{

self.layoutAttributes = layoutAttributes;

}

@end

#pragma mark -

#pragma mark ASCollectionView.

@interface ASCollectionView () <ASRangeControllerDataSource, ASRangeControllerDelegate, ASCollectionDataControllerSource, ASCellNodeInteractionDelegate, ASDelegateProxyInterceptor, ASBatchFetchingScrollView, ASDataControllerEnvironmentDelegate, ASCALayerExtendedDelegate> {

ASCollectionViewProxy *_proxyDataSource;

ASCollectionViewProxy *_proxyDelegate;

ASCollectionDataController *_dataController;

ASRangeController *_rangeController;

ASCollectionViewLayoutController *_layoutController;

id<ASCollectionViewLayoutInspecting> _defaultLayoutInspector;

__weak id<ASCollectionViewLayoutInspecting> _layoutInspector;

NSMutableSet *_cellsForVisibilityUpdates;

id<ASCollectionViewLayoutFacilitatorProtocol> _layoutFacilitator;

BOOL _performingBatchUpdates;

NSUInteger _superBatchUpdateCount;

NSMutableArray *_batchUpdateBlocks;

BOOL _isDeallocating;

ASBatchContext *_batchContext;

CGSize _lastBoundsSizeUsedForMeasuringNodes;

BOOL _ignoreNextBoundsSizeChangeForMeasuringNodes;

NSMutableSet *_registeredSupplementaryKinds;

CGPoint _deceleratingVelocity;

ASCollectionViewInvalidationStyle _nextLayoutInvalidationStyle;

/**

* Our layer, retained. Under iOS < 9, when collection views are removed from the hierarchy,

* their layers may be deallocated and become dangling pointers. This puts the collection view

* into a very dangerous state where pretty much any call will crash it. So we manually retain our layer.

*

* You should never access this, and it will be nil under iOS >= 9.

*/

CALayer *_retainedLayer;

/**

* If YES, the `UICollectionView` will reload its data on next layout pass so we should not forward any updates to it.

* Rationale:

* In `reloadData`, a collection view invalidates its data and marks itself as needing reload, and waits until `layoutSubviews` to requery its data source.

* This can lead to data inconsistency problems.

* Say you have an empty collection view. You call `reloadData`, then immediately insert an item into your data source and call `insertItemsAtIndexPaths:[0,0]`.

* You will get an assertion failure saying `Invalid number of items in section 0.

* The number of items after the update (1) must be equal to the number of items before the update (1) plus or minus the items added and removed (1 added, 0 removed).`

* The collection view never queried your data source before the update to see that it actually had 0 items.

*/

BOOL _superIsPendingDataLoad;

/**

* It's important that we always check for batch fetching at least once, but also

* that we do not check for batch fetching for empty updates (as that may cause an infinite

* loop of batch fetching, where the batch completes and performBatchUpdates: is called without

* actually making any changes.) So to handle the case where a collection is completely empty

* (0 sections) we always check at least once after each update (initial reload is the first update.)

*/

BOOL _hasEverCheckedForBatchFetchingDueToUpdate;

struct {

unsigned int scrollViewDidScroll:1;

unsigned int scrollViewWillBeginDragging:1;

unsigned int scrollViewDidEndDragging:1;

unsigned int scrollViewWillEndDragging:1;

unsigned int collectionViewWillDisplayNodeForItem:1;

unsigned int collectionViewWillDisplayNodeForItemDeprecated:1;

unsigned int collectionViewDidEndDisplayingNodeForItem:1;

unsigned int collectionViewShouldSelectItem:1;

unsigned int collectionViewDidSelectItem:1;

unsigned int collectionViewShouldDeselectItem:1;

unsigned int collectionViewDidDeselectItem:1;

unsigned int collectionViewShouldHighlightItem:1;

unsigned int collectionViewDidHighlightItem:1;

unsigned int collectionViewDidUnhighlightItem:1;

unsigned int collectionViewShouldShowMenuForItem:1;

unsigned int collectionViewCanPerformActionForItem:1;

unsigned int collectionViewPerformActionForItem:1;

unsigned int collectionViewWillBeginBatchFetch:1;

unsigned int shouldBatchFetchForCollectionView:1;

unsigned int collectionNodeWillDisplayItem:1;

unsigned int collectionNodeDidEndDisplayingItem:1;

unsigned int collectionNodeShouldSelectItem:1;

unsigned int collectionNodeDidSelectItem:1;

unsigned int collectionNodeShouldDeselectItem:1;

unsigned int collectionNodeDidDeselectItem:1;

unsigned int collectionNodeShouldHighlightItem:1;

unsigned int collectionNodeDidHighlightItem:1;

unsigned int collectionNodeDidUnhighlightItem:1;

unsigned int collectionNodeShouldShowMenuForItem:1;

unsigned int collectionNodeCanPerformActionForItem:1;

unsigned int collectionNodePerformActionForItem:1;

unsigned int collectionNodeWillBeginBatchFetch:1;

unsigned int collectionNodeWillDisplaySupplementaryElement:1;

unsigned int collectionNodeDidEndDisplayingSupplementaryElement:1;

unsigned int shouldBatchFetchForCollectionNode:1;

} _asyncDelegateFlags;

struct {

unsigned int collectionViewNodeForItem:1;

unsigned int collectionViewNodeBlockForItem:1;

unsigned int collectionViewNodeForSupplementaryElement:1;

unsigned int numberOfSectionsInCollectionView:1;

unsigned int collectionViewNumberOfItemsInSection:1;

unsigned int collectionNodeNodeForItem:1;

unsigned int collectionNodeNodeBlockForItem:1;

unsigned int collectionNodeNodeForSupplementaryElement:1;

unsigned int numberOfSectionsInCollectionNode:1;

unsigned int collectionNodeNumberOfItemsInSection:1;

unsigned int collectionNodeContextForSection:1;

} _asyncDataSourceFlags;

struct {

unsigned int didChangeCollectionViewDataSource:1;

unsigned int didChangeCollectionViewDelegate:1;

} _layoutInspectorFlags;

}

@property (nonatomic, weak) ASCollectionNode *collectionNode;

@end

@interface ASCollectionNode ()

- (instancetype)_initWithCollectionView:(ASCollectionView *)collectionView;

@end

@implementation ASCollectionView

{

__weak id<ASCollectionDelegate> _asyncDelegate;

__weak id<ASCollectionDataSource> _asyncDataSource;

}

// Using _ASDisplayLayer ensures things like -layout are properly forwarded to ASCollectionNode.

+ (Class)layerClass

{

return [_ASDisplayLayer class];

}

#pragma mark -

#pragma mark Lifecycle.

- (instancetype)initWithCollectionViewLayout:(UICollectionViewLayout *)layout

{

return [self initWithFrame:CGRectZero collectionViewLayout:layout];

}

- (instancetype)initWithFrame:(CGRect)frame collectionViewLayout:(UICollectionViewLayout *)layout

{

return [self _initWithFrame:frame collectionViewLayout:layout layoutFacilitator:nil eventLog:nil];

}

- (instancetype)_initWithFrame:(CGRect)frame collectionViewLayout:(UICollectionViewLayout *)layout layoutFacilitator:(id<ASCollectionViewLayoutFacilitatorProtocol>)layoutFacilitator eventLog:(ASEventLog *)eventLog

{

if (!(self = [super initWithFrame:frame collectionViewLayout:layout]))

return nil;

// Disable UICollectionView prefetching.

// Experiments done by Instagram show that this option being YES (default)

// when unused causes a significant hit to scroll performance.

// https://github.com/Instagram/IGListKit/issues/318

if (AS_AT_LEAST_IOS10) {

self.prefetchingEnabled = NO;

}

_layoutController = [[ASCollectionViewLayoutController alloc] initWithCollectionView:self];

_rangeController = [[ASRangeController alloc] init];

_rangeController.dataSource = self;

_rangeController.delegate = self;

_rangeController.layoutController = _layoutController;

_dataController = [[ASCollectionDataController alloc] initWithDataSource:self eventLog:eventLog];

_dataController.delegate = _rangeController;

_dataController.environmentDelegate = self;

_batchContext = [[ASBatchContext alloc] init];

_leadingScreensForBatching = 2.0;

_performingBatchUpdates = NO;

_batchUpdateBlocks = [NSMutableArray array];

_superIsPendingDataLoad = YES;

_lastBoundsSizeUsedForMeasuringNodes = self.bounds.size;

// If the initial size is 0, expect a size change very soon which is part of the initial configuration

// and should not trigger a relayout.

_ignoreNextBoundsSizeChangeForMeasuringNodes = CGSizeEqualToSize(_lastBoundsSizeUsedForMeasuringNodes, CGSizeZero);

_layoutFacilitator = layoutFacilitator;

_proxyDelegate = [[ASCollectionViewProxy alloc] initWithTarget:nil interceptor:self];

super.delegate = (id<UICollectionViewDelegate>)_proxyDelegate;

_proxyDataSource = [[ASCollectionViewProxy alloc] initWithTarget:nil interceptor:self];

super.dataSource = (id<UICollectionViewDataSource>)_proxyDataSource;

_registeredSupplementaryKinds = [NSMutableSet set];

_cellsForVisibilityUpdates = [NSMutableSet set];

self.backgroundColor = [UIColor whiteColor];

[self registerClass:[_ASCollectionViewCell class] forCellWithReuseIdentifier:kCellReuseIdentifier];

if (!AS_AT_LEAST_IOS9) {

_retainedLayer = self.layer;

}

return self;

}

- (void)dealloc

{

ASDisplayNodeAssertMainThread();

// Sometimes the UIKit classes can call back to their delegate even during deallocation, due to animation completion blocks etc.

_isDeallocating = YES;

[self setAsyncDelegate:nil];

[self setAsyncDataSource:nil];

// Data controller & range controller may own a ton of nodes, let's deallocate those off-main.

ASPerformBackgroundDeallocation(_dataController);

ASPerformBackgroundDeallocation(_rangeController);

}

#pragma mark -

#pragma mark Overrides.

- (void)reloadDataWithCompletion:(void (^)())completion

{

ASPerformBlockOnMainThread(^{

_superIsPendingDataLoad = YES;

[super reloadData];

});

[_dataController reloadDataWithAnimationOptions:kASCollectionViewAnimationNone completion:completion];

}

- (void)reloadData

{

[self reloadDataWithCompletion:nil];

}

- (void)scrollToItemAtIndexPath:(NSIndexPath *)indexPath atScrollPosition:(UICollectionViewScrollPosition)scrollPosition animated:(BOOL)animated

{

if ([self validateIndexPath:indexPath]) {

[super scrollToItemAtIndexPath:indexPath atScrollPosition:scrollPosition animated:animated];

}

}

- (void)reloadDataImmediately

{

ASDisplayNodeAssertMainThread();

_superIsPendingDataLoad = YES;

[_dataController reloadDataImmediatelyWithAnimationOptions:kASCollectionViewAnimationNone];

[super reloadData];

}

- (void)relayoutItems

{

[_dataController relayoutAllNodes];

}

- (void)waitUntilAllUpdatesAreCommitted

{

ASDisplayNodeAssertMainThread();

[_dataController waitUntilAllUpdatesAreCommitted];

}

- (void)setDataSource:(id<UICollectionViewDataSource>)dataSource

{

// UIKit can internally generate a call to this method upon changing the asyncDataSource; only assert for non-nil.

ASDisplayNodeAssert(dataSource == nil, @"ASCollectionView uses asyncDataSource, not UICollectionView's dataSource property.");

}

- (void)setDelegate:(id<UICollectionViewDelegate>)delegate

{

// Our UIScrollView superclass sets its delegate to nil on dealloc. Only assert if we get a non-nil value here.

ASDisplayNodeAssert(delegate == nil, @"ASCollectionView uses asyncDelegate, not UICollectionView's delegate property.");

}

- (void)proxyTargetHasDeallocated:(ASDelegateProxy *)proxy

{

if (proxy == _proxyDelegate) {

[self setAsyncDelegate:nil];

} else if (proxy == _proxyDataSource) {

[self setAsyncDataSource:nil];

}

}

- (id<ASCollectionDataSource>)asyncDataSource

{

return _asyncDataSource;

}

- (void)setAsyncDataSource:(id<ASCollectionDataSource>)asyncDataSource

{

// Changing super.dataSource will trigger a setNeedsLayout, so this must happen on the main thread.

ASDisplayNodeAssertMainThread();

// Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle

// the (common) case of nilling the asyncDataSource in the ViewController's dealloc. In this case our _asyncDataSource

// will return as nil (ARC magic) even though the _proxyDataSource still exists. It's really important to hold a strong

// reference to the old dataSource in this case because calls to ASCollectionViewProxy will start failing and cause crashes.

NS_VALID_UNTIL_END_OF_SCOPE id oldDataSource = super.dataSource;

if (asyncDataSource == nil) {

_asyncDataSource = nil;

_proxyDataSource = _isDeallocating ? nil : [[ASCollectionViewProxy alloc] initWithTarget:nil interceptor:self];

memset(&_asyncDataSourceFlags, 0, sizeof(_asyncDataSourceFlags));

} else {

_asyncDataSource = asyncDataSource;

_proxyDataSource = [[ASCollectionViewProxy alloc] initWithTarget:_asyncDataSource interceptor:self];

_asyncDataSourceFlags.collectionViewNodeForItem = [_asyncDataSource respondsToSelector:@selector(collectionView:nodeForItemAtIndexPath:)];

_asyncDataSourceFlags.collectionViewNodeBlockForItem = [_asyncDataSource respondsToSelector:@selector(collectionView:nodeBlockForItemAtIndexPath:)];

_asyncDataSourceFlags.numberOfSectionsInCollectionView = [_asyncDataSource respondsToSelector:@selector(numberOfSectionsInCollectionView:)];

_asyncDataSourceFlags.collectionViewNumberOfItemsInSection = [_asyncDataSource respondsToSelector:@selector(collectionView:numberOfItemsInSection:)];

_asyncDataSourceFlags.collectionViewNodeForSupplementaryElement = [_asyncDataSource respondsToSelector:@selector(collectionView:nodeForSupplementaryElementOfKind:atIndexPath:)];

_asyncDataSourceFlags.collectionNodeNodeForItem = [_asyncDataSource respondsToSelector:@selector(collectionNode:nodeForItemAtIndexPath:)];

_asyncDataSourceFlags.collectionNodeNodeBlockForItem = [_asyncDataSource respondsToSelector:@selector(collectionNode:nodeBlockForItemAtIndexPath:)];

_asyncDataSourceFlags.numberOfSectionsInCollectionNode = [_asyncDataSource respondsToSelector:@selector(numberOfSectionsInCollectionNode:)];

_asyncDataSourceFlags.collectionNodeNumberOfItemsInSection = [_asyncDataSource respondsToSelector:@selector(collectionNode:numberOfItemsInSection:)];

_asyncDataSourceFlags.collectionNodeContextForSection = [_asyncDataSource respondsToSelector:@selector(collectionNode:contextForSection:)];

_asyncDataSourceFlags.collectionNodeNodeForSupplementaryElement = [_asyncDataSource respondsToSelector:@selector(collectionNode:nodeForSupplementaryElementOfKind:atIndexPath:)];

ASDisplayNodeAssert(_asyncDataSourceFlags.collectionNodeNumberOfItemsInSection || _asyncDataSourceFlags.collectionViewNumberOfItemsInSection, @"Data source must implement collectionNode:numberOfItemsInSection:");

ASDisplayNodeAssert(_asyncDataSourceFlags.collectionNodeNodeBlockForItem

|| _asyncDataSourceFlags.collectionNodeNodeForItem

|| _asyncDataSourceFlags.collectionViewNodeBlockForItem

|| _asyncDataSourceFlags.collectionViewNodeForItem, @"Data source must implement collectionNode:nodeBlockForItemAtIndexPath: or collectionNode:nodeForItemAtIndexPath:");

}

_dataController.validationErrorSource = asyncDataSource;

super.dataSource = (id<UICollectionViewDataSource>)_proxyDataSource;

//Cache results of layoutInspector to ensure flags are up to date if getter lazily loads a new one.

id<ASCollectionViewLayoutInspecting> layoutInspector = self.layoutInspector;

if (_layoutInspectorFlags.didChangeCollectionViewDataSource) {

[layoutInspector didChangeCollectionViewDataSource:asyncDataSource];

}

}

- (id<ASCollectionDelegate>)asyncDelegate

{

return _asyncDelegate;

}

- (void)setAsyncDelegate:(id<ASCollectionDelegate>)asyncDelegate

{

// Changing super.delegate will trigger a setNeedsLayout, so this must happen on the main thread.

ASDisplayNodeAssertMainThread();

// Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle

// the (common) case of nilling the asyncDelegate in the ViewController's dealloc. In this case our _asyncDelegate

// will return as nil (ARC magic) even though the _proxyDataSource still exists. It's really important to hold a strong

// reference to the old delegate in this case because calls to ASCollectionViewProxy will start failing and cause crashes.

NS_VALID_UNTIL_END_OF_SCOPE id oldDelegate = super.delegate;

if (asyncDelegate == nil) {

_asyncDelegate = nil;

_proxyDelegate = _isDeallocating ? nil : [[ASCollectionViewProxy alloc] initWithTarget:nil interceptor:self];

memset(&_asyncDelegateFlags, 0, sizeof(_asyncDelegateFlags));

} else {

_asyncDelegate = asyncDelegate;

_proxyDelegate = [[ASCollectionViewProxy alloc] initWithTarget:_asyncDelegate interceptor:self];

_asyncDelegateFlags.scrollViewDidScroll = [_asyncDelegate respondsToSelector:@selector(scrollViewDidScroll:)];

_asyncDelegateFlags.scrollViewWillEndDragging = [_asyncDelegate respondsToSelector:@selector(scrollViewWillEndDragging:withVelocity:targetContentOffset:)];

_asyncDelegateFlags.scrollViewWillBeginDragging = [_asyncDelegate respondsToSelector:@selector(scrollViewWillBeginDragging:)];

_asyncDelegateFlags.scrollViewDidEndDragging = [_asyncDelegate respondsToSelector:@selector(scrollViewDidEndDragging:willDecelerate:)];

_asyncDelegateFlags.collectionViewWillDisplayNodeForItem = [_asyncDelegate respondsToSelector:@selector(collectionView:willDisplayNode:forItemAtIndexPath:)];

if (_asyncDelegateFlags.collectionViewWillDisplayNodeForItem == NO) {

_asyncDelegateFlags.collectionViewWillDisplayNodeForItemDeprecated = [_asyncDelegate respondsToSelector:@selector(collectionView:willDisplayNodeForItemAtIndexPath:)];

}

_asyncDelegateFlags.collectionViewDidEndDisplayingNodeForItem = [_asyncDelegate respondsToSelector:@selector(collectionView:didEndDisplayingNode:forItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewWillBeginBatchFetch = [_asyncDelegate respondsToSelector:@selector(collectionView:willBeginBatchFetchWithContext:)];

_asyncDelegateFlags.shouldBatchFetchForCollectionView = [_asyncDelegate respondsToSelector:@selector(shouldBatchFetchForCollectionView:)];

_asyncDelegateFlags.collectionViewShouldSelectItem = [_asyncDelegate respondsToSelector:@selector(collectionView:shouldSelectItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewDidSelectItem = [_asyncDelegate respondsToSelector:@selector(collectionView:didSelectItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewShouldDeselectItem = [_asyncDelegate respondsToSelector:@selector(collectionView:shouldDeselectItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewDidDeselectItem = [_asyncDelegate respondsToSelector:@selector(collectionView:didDeselectItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewShouldHighlightItem = [_asyncDelegate respondsToSelector:@selector(collectionView:shouldHighlightItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewDidHighlightItem = [_asyncDelegate respondsToSelector:@selector(collectionView:didHighlightItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewDidUnhighlightItem = [_asyncDelegate respondsToSelector:@selector(collectionView:didUnhighlightItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewShouldShowMenuForItem = [_asyncDelegate respondsToSelector:@selector(collectionView:shouldShowMenuForItemAtIndexPath:)];

_asyncDelegateFlags.collectionViewCanPerformActionForItem = [_asyncDelegate respondsToSelector:@selector(collectionView:canPerformAction:forItemAtIndexPath:withSender:)];

_asyncDelegateFlags.collectionViewPerformActionForItem = [_asyncDelegate respondsToSelector:@selector(collectionView:performAction:forItemAtIndexPath:withSender:)];

_asyncDelegateFlags.collectionNodeWillDisplayItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:willDisplayItemWithNode:)];

_asyncDelegateFlags.collectionNodeDidEndDisplayingItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:didEndDisplayingItemWithNode:)];

_asyncDelegateFlags.collectionNodeWillBeginBatchFetch = [_asyncDelegate respondsToSelector:@selector(collectionNode:willBeginBatchFetchWithContext:)];

_asyncDelegateFlags.shouldBatchFetchForCollectionNode = [_asyncDelegate respondsToSelector:@selector(shouldBatchFetchForCollectionNode:)];

_asyncDelegateFlags.collectionNodeShouldSelectItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:shouldSelectItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeDidSelectItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:didSelectItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeShouldDeselectItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:shouldDeselectItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeDidDeselectItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:didDeselectItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeShouldHighlightItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:shouldHighlightItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeDidHighlightItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:didHighlightItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeDidUnhighlightItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:didUnhighlightItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeShouldShowMenuForItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:shouldShowMenuForItemAtIndexPath:)];

_asyncDelegateFlags.collectionNodeCanPerformActionForItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:canPerformAction:forItemAtIndexPath:sender:)];

_asyncDelegateFlags.collectionNodePerformActionForItem = [_asyncDelegate respondsToSelector:@selector(collectionNode:performAction:forItemAtIndexPath:sender:)];

}

super.delegate = (id<UICollectionViewDelegate>)_proxyDelegate;

//Cache results of layoutInspector to ensure flags are up to date if getter lazily loads a new one.

id<ASCollectionViewLayoutInspecting> layoutInspector = self.layoutInspector;

if (_layoutInspectorFlags.didChangeCollectionViewDelegate) {

[layoutInspector didChangeCollectionViewDelegate:asyncDelegate];

}

}

- (void)setCollectionViewLayout:(UICollectionViewLayout *)collectionViewLayout

{

[super setCollectionViewLayout:collectionViewLayout];

// Trigger recreation of layout inspector with new collection view layout

if (_layoutInspector != nil) {

_layoutInspector = nil;

[self layoutInspector];

}

}

- (id<ASCollectionViewLayoutInspecting>)layoutInspector

{

if (_layoutInspector == nil) {

UICollectionViewFlowLayout *layout = (UICollectionViewFlowLayout *)self.collectionViewLayout;

if (layout == nil) {

// Layout hasn't been set yet, we're still init'ing

return nil;

}

if ([layout asdk_isFlowLayout]) {

// Register the default layout inspector delegate for flow layouts only

_defaultLayoutInspector = [[ASCollectionViewFlowLayoutInspector alloc] initWithCollectionView:self flowLayout:layout];

} else {

// Register the default layout inspector delegate for custom collection view layouts

_defaultLayoutInspector = [[ASCollectionViewLayoutInspector alloc] initWithCollectionView:self];

}

// Explicitly call the setter to wire up the _layoutInspectorFlags

self.layoutInspector = _defaultLayoutInspector;

}

return _layoutInspector;

}

- (void)setLayoutInspector:(id<ASCollectionViewLayoutInspecting>)layoutInspector

{

_layoutInspector = layoutInspector;

_layoutInspectorFlags.didChangeCollectionViewDataSource = [_layoutInspector respondsToSelector:@selector(didChangeCollectionViewDataSource:)];

_layoutInspectorFlags.didChangeCollectionViewDelegate = [_layoutInspector respondsToSelector:@selector(didChangeCollectionViewDelegate:)];

}

- (void)setTuningParameters:(ASRangeTuningParameters)tuningParameters forRangeType:(ASLayoutRangeType)rangeType

{

[_rangeController setTuningParameters:tuningParameters forRangeMode:ASLayoutRangeModeFull rangeType:rangeType];

}

- (ASRangeTuningParameters)tuningParametersForRangeType:(ASLayoutRangeType)rangeType

{

return [_rangeController tuningParametersForRangeMode:ASLayoutRangeModeFull rangeType:rangeType];

}

- (void)setTuningParameters:(ASRangeTuningParameters)tuningParameters forRangeMode:(ASLayoutRangeMode)rangeMode rangeType:(ASLayoutRangeType)rangeType

{

[_rangeController setTuningParameters:tuningParameters forRangeMode:rangeMode rangeType:rangeType];

}

- (ASRangeTuningParameters)tuningParametersForRangeMode:(ASLayoutRangeMode)rangeMode rangeType:(ASLayoutRangeType)rangeType

{

return [_rangeController tuningParametersForRangeMode:rangeMode rangeType:rangeType];

}

- (CGSize)calculatedSizeForNodeAtIndexPath:(NSIndexPath *)indexPath

{

return [[self nodeForItemAtIndexPath:indexPath] calculatedSize];

}

- (NSArray<NSArray <ASCellNode *> *> *)completedNodes

{

return [_dataController completedNodes];

}

- (ASCellNode *)nodeForItemAtIndexPath:(NSIndexPath *)indexPath

{

return [_dataController nodeAtCompletedIndexPath:indexPath];

}

- (NSIndexPath *)convertIndexPathFromCollectionNode:(NSIndexPath *)indexPath waitingIfNeeded:(BOOL)wait

{

if (indexPath == nil) {

return nil;

}

// If this is a section index path, we don't currently have a method

// to do a mapping.

if (indexPath.item == NSNotFound) {

return indexPath;

} else {

ASCellNode *node = [_dataController nodeAtIndexPath:indexPath];

NSIndexPath *viewIndexPath = [self indexPathForNode:node];

if (viewIndexPath == nil && wait) {

[self waitUntilAllUpdatesAreCommitted];

viewIndexPath = [self indexPathForNode:node];

}

return viewIndexPath;

}

}

/**

* Asserts that the index path is a valid view-index-path, and returns it if so, nil otherwise.

*/

- (nullable NSIndexPath *)validateIndexPath:(nullable NSIndexPath *)indexPath

{

if (indexPath == nil) {

return nil;

}

NSInteger section = indexPath.section;

if (section >= self.numberOfSections) {

ASDisplayNodeFailAssert(@"Collection view index path has invalid section %lu, section count = %lu", (unsigned long)section, (unsigned long)self.numberOfSections);

return nil;

}

NSInteger item = indexPath.item;

// item == NSNotFound means e.g. "scroll to this section" and is acceptable

if (item != NSNotFound && item >= [self numberOfItemsInSection:section]) {

ASDisplayNodeFailAssert(@"Collection view index path has invalid item %lu in section %lu, item count = %lu", (unsigned long)indexPath.item, (unsigned long)section, (unsigned long)[self numberOfItemsInSection:section]);

return nil;

}

return indexPath;

}

- (NSIndexPath *)convertIndexPathToCollectionNode:(NSIndexPath *)indexPath

{

if ([self validateIndexPath:indexPath] == nil) {

return nil;

}

// If this is a section index path, we don't currently have a method

// to do a mapping.

if (indexPath.item == NSNotFound) {

return indexPath;

} else {

ASCellNode *node = [self nodeForItemAtIndexPath:indexPath];

return [_dataController indexPathForNode:node];

}

}

- (NSArray<NSIndexPath *> *)convertIndexPathsToCollectionNode:(NSArray<NSIndexPath *> *)indexPaths

{

if (indexPaths == nil) {

return nil;

}

NSMutableArray<NSIndexPath *> *indexPathsArray = [NSMutableArray arrayWithCapacity:indexPaths.count];

for (NSIndexPath *indexPathInView in indexPaths) {

NSIndexPath *indexPath = [self convertIndexPathToCollectionNode:indexPathInView];

if (indexPath != nil) {

[indexPathsArray addObject:indexPath];

}

}

return indexPathsArray;

}

- (ASCellNode *)supplementaryNodeForElementKind:(NSString *)elementKind atIndexPath:(NSIndexPath *)indexPath

{

return [_dataController supplementaryNodeOfKind:elementKind atIndexPath:indexPath];

}

- (NSIndexPath *)indexPathForNode:(ASCellNode *)cellNode

{

return [self validateIndexPath:[_dataController completedIndexPathForNode:cellNode]];

}

- (NSArray *)visibleNodes

{

NSArray *indexPaths = [self indexPathsForVisibleItems];

NSMutableArray *visibleNodes = [[NSMutableArray alloc] init];

for (NSIndexPath *indexPath in indexPaths) {

ASCellNode *node = [self nodeForItemAtIndexPath:indexPath];

if (node) {

// It is possible for UICollectionView to return indexPaths before the node is completed.

[visibleNodes addObject:node];

}

}

return visibleNodes;

}

#pragma mark Internal

/**

Performing nested batch updates with super (e.g. resizing a cell node & updating collection view during same frame)

can cause super to throw data integrity exceptions because it checks the data source counts before

the update is complete.

Always call [self _superPerform:] rather than [super performBatch:] so that we can keep our `superPerformingBatchUpdates` flag updated.

*/

- (void)_superPerformBatchUpdates:(void(^)())updates completion:(void(^)(BOOL finished))completion

{

ASDisplayNodeAssertMainThread();

_superBatchUpdateCount++;

[super performBatchUpdates:updates completion:completion];

_superBatchUpdateCount--;

}

#pragma mark Assertions.

- (ASDataController *)dataController

{

return _dataController;

}

- (void)performBatchAnimated:(BOOL)animated updates:(void (^)())updates completion:(void (^)(BOOL))completion

{

ASDisplayNodeAssertMainThread();

[_dataController beginUpdates];

if (updates) {

updates();

}

[_dataController endUpdatesAnimated:animated completion:completion];

}

- (void)performBatchUpdates:(void (^)())updates completion:(void (^)(BOOL))completion

{

// We capture the current state of whether animations are enabled if they don't provide us with one.

[self performBatchAnimated:[UIView areAnimationsEnabled] updates:updates completion:completion];

}

- (void)registerSupplementaryNodeOfKind:(NSString *)elementKind

{

ASDisplayNodeAssert(elementKind != nil, @"A kind is needed for supplementary node registration");

[_registeredSupplementaryKinds addObject:elementKind];

[self registerClass:[UICollectionReusableView class] forSupplementaryViewOfKind:elementKind

withReuseIdentifier:[self __reuseIdentifierForKind:elementKind]];

}

- (void)insertSections:(NSIndexSet *)sections

{

ASDisplayNodeAssertMainThread();

if (sections.count == 0) { return; }

[_dataController insertSections:sections withAnimationOptions:kASCollectionViewAnimationNone];

}

- (void)deleteSections:(NSIndexSet *)sections

{

ASDisplayNodeAssertMainThread();

if (sections.count == 0) { return; }

[_dataController deleteSections:sections withAnimationOptions:kASCollectionViewAnimationNone];

}

- (void)reloadSections:(NSIndexSet *)sections

{

ASDisplayNodeAssertMainThread();

if (sections.count == 0) { return; }

[_dataController reloadSections:sections withAnimationOptions:kASCollectionViewAnimationNone];

}

- (void)moveSection:(NSInteger)section toSection:(NSInteger)newSection

{

ASDisplayNodeAssertMainThread();

[_dataController moveSection:section toSection:newSection withAnimationOptions:kASCollectionViewAnimationNone];

}

- (id<ASSectionContext>)contextForSection:(NSInteger)section

{

ASDisplayNodeAssertMainThread();

return [_dataController contextForSection:section];

}

- (void)insertItemsAtIndexPaths:(NSArray *)indexPaths

{

ASDisplayNodeAssertMainThread();

if (indexPaths.count == 0) { return; }

[_dataController insertRowsAtIndexPaths:indexPaths withAnimationOptions:kASCollectionViewAnimationNone];

}

- (void)deleteItemsAtIndexPaths:(NSArray *)indexPaths

{

ASDisplayNodeAssertMainThread();

if (indexPaths.count == 0) { return; }

[_dataController deleteRowsAtIndexPaths:indexPaths withAnimationOptions:kASCollectionViewAnimationNone];

}

- (void)reloadItemsAtIndexPaths:(NSArray *)indexPaths

{

ASDisplayNodeAssertMainThread();

if (indexPaths.count == 0) { return; }

[_dataController reloadRowsAtIndexPaths:indexPaths withAnimationOptions:kASCollectionViewAnimationNone];

}

- (void)moveItemAtIndexPath:(NSIndexPath *)indexPath toIndexPath:(NSIndexPath *)newIndexPath

{

ASDisplayNodeAssertMainThread();

[_dataController moveRowAtIndexPath:indexPath toIndexPath:newIndexPath withAnimationOptions:kASCollectionViewAnimationNone];

}

- (NSString *)__reuseIdentifierForKind:(NSString *)kind

{

return [@"_ASCollectionSupplementaryView_" stringByAppendingString:kind];

}

#pragma mark -

#pragma mark Intercepted selectors.

- (NSInteger)numberOfSectionsInCollectionView:(UICollectionView *)collectionView

{

_superIsPendingDataLoad = NO;

return [_dataController completedNumberOfSections];

}

- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section

{

return [_dataController completedNumberOfRowsInSection:section];

}

- (CGSize)collectionView:(UICollectionView *)collectionView layout:(UICollectionViewLayout *)collectionViewLayout sizeForItemAtIndexPath:(NSIndexPath *)indexPath

{

return [[self nodeForItemAtIndexPath:indexPath] calculatedSize];

}

- (UICollectionReusableView *)collectionView:(UICollectionView *)collectionView viewForSupplementaryElementOfKind:(NSString *)kind atIndexPath:(NSIndexPath *)indexPath

{

NSString *identifier = [self __reuseIdentifierForKind:kind];

UICollectionReusableView *view = [self dequeueReusableSupplementaryViewOfKind:kind withReuseIdentifier:identifier forIndexPath:indexPath];

ASCellNode *node = [_dataController supplementaryNodeOfKind:kind atIndexPath:indexPath];

ASDisplayNodeAssert(node != nil, @"Supplementary node should exist. Kind = %@, indexPath = %@, collectionDataSource = %@", kind, indexPath, self);

[_rangeController configureContentView:view forCellNode:node];

return view;

}

- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath

{

_ASCollectionViewCell *cell = [self dequeueReusableCellWithReuseIdentifier:kCellReuseIdentifier forIndexPath:indexPath];

ASCellNode *node = [self nodeForItemAtIndexPath:indexPath];

cell.node = node;

[_rangeController configureContentView:cell.contentView forCellNode:node];

if (!AS_AT_LEAST_IOS8) {

// Even though UICV was introduced in iOS 6, and UITableView has always had the equivalent method,

// -willDisplayCell: was not introduced until iOS 8 for UICV. didEndDisplayingCell, however, is available.

[self collectionView:collectionView willDisplayCell:cell forItemAtIndexPath:indexPath];

}

return cell;

}

- (void)collectionView:(UICollectionView *)collectionView willDisplayCell:(_ASCollectionViewCell *)cell forItemAtIndexPath:(NSIndexPath *)indexPath

{

ASCellNode *cellNode = [cell node];

cellNode.scrollView = collectionView;

// Under iOS 10+, cells may be removed/re-added to the collection view without

// receiving prepareForReuse/applyLayoutAttributes, as an optimization for e.g.

// if the user is scrolling back and forth across a small set of items.

// In this case, we have to fetch the layout attributes manually.

// This may be possible under iOS < 10 but it has not been observed yet.

if (cell.layoutAttributes == nil) {

cell.layoutAttributes = [collectionView layoutAttributesForItemAtIndexPath:indexPath];

}

ASDisplayNodeAssertNotNil(cellNode, @"Expected node associated with cell that will be displayed not to be nil. indexPath: %@", indexPath);

if (_asyncDelegateFlags.collectionNodeWillDisplayItem) {

if (ASCollectionNode *collectionNode = self.collectionNode) {

[_asyncDelegate collectionNode:collectionNode willDisplayItemWithNode:cellNode];

}

} else if (_asyncDelegateFlags.collectionViewWillDisplayNodeForItem) {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

[_asyncDelegate collectionView:self willDisplayNode:cellNode forItemAtIndexPath:indexPath];

} else if (_asyncDelegateFlags.collectionViewWillDisplayNodeForItemDeprecated) {

[_asyncDelegate collectionView:self willDisplayNodeForItemAtIndexPath:indexPath];

}

#pragma clang diagnostic pop

[_rangeController setNeedsUpdate];

if (ASSubclassOverridesSelector([ASCellNode class], [cellNode class], @selector(cellNodeVisibilityEvent:inScrollView:withCellFrame:))) {

[_cellsForVisibilityUpdates addObject:cell];

}

}

- (void)collectionView:(UICollectionView *)collectionView didEndDisplayingCell:(_ASCollectionViewCell *)cell forItemAtIndexPath:(NSIndexPath *)indexPath

{

ASCellNode *cellNode = [cell node];

ASDisplayNodeAssertNotNil(cellNode, @"Expected node associated with removed cell not to be nil.");

if (_asyncDelegateFlags.collectionNodeDidEndDisplayingItem) {

if (ASCollectionNode *collectionNode = self.collectionNode) {

[_asyncDelegate collectionNode:collectionNode didEndDisplayingItemWithNode:cellNode];

}

} else if (_asyncDelegateFlags.collectionViewDidEndDisplayingNodeForItem) {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

[_asyncDelegate collectionView:self didEndDisplayingNode:cellNode forItemAtIndexPath:indexPath];

#pragma clang diagnostic pop

}

[_rangeController setNeedsUpdate];

[_cellsForVisibilityUpdates removeObject:cell];

cellNode.scrollView = nil;

cell.layoutAttributes = nil;

}

- (void)collectionView:(UICollectionView *)collectionView willDisplaySupplementaryView:(UICollectionReusableView *)view forElementKind:(NSString *)elementKind atIndexPath:(NSIndexPath *)indexPath

{

if (_asyncDelegateFlags.collectionNodeWillDisplaySupplementaryElement) {

GET_COLLECTIONNODE_OR_RETURN(collectionNode, (void)0);

ASCellNode *node = [self supplementaryNodeForElementKind:elementKind atIndexPath:indexPath];

ASDisplayNodeAssert([node.supplementaryElementKind isEqualToString:elementKind], @"Expected node for supplementary element to have kind '%@', got '%@'.", elementKind, node.supplementaryElementKind);

[_asyncDelegate collectionNode:collectionNode willDisplaySupplementaryElementWithNode:node];

}

}

- (void)collectionView:(UICollectionView *)collectionView didEndDisplayingSupplementaryView:(UICollectionReusableView *)view forElementOfKind:(NSString *)elementKind atIndexPath:(NSIndexPath *)indexPath

{

if (_asyncDelegateFlags.collectionNodeDidEndDisplayingSupplementaryElement) {

GET_COLLECTIONNODE_OR_RETURN(collectionNode, (void)0);

ASCellNode *node = [self supplementaryNodeForElementKind:elementKind atIndexPath:indexPath];

ASDisplayNodeAssert([node.supplementaryElementKind isEqualToString:elementKind], @"Expected node for supplementary element to have kind '%@', got '%@'.", elementKind, node.supplementaryElementKind);

[_asyncDelegate collectionNode:collectionNode didEndDisplayingSupplementaryElementWithNode:node];

}

}

- (BOOL)collectionView:(UICollectionView *)collectionView shouldSelectItemAtIndexPath:(NSIndexPath *)indexPath

{

if (_asyncDelegateFlags.collectionNodeShouldSelectItem) {

GET_COLLECTIONNODE_OR_RETURN(collectionNode, NO);

indexPath = [self convertIndexPathToCollectionNode:indexPath];

if (indexPath != nil) {

return [_asyncDelegate collectionNode:collectionNode shouldSelectItemAtIndexPath:indexPath];

}

} else if (_asyncDelegateFlags.collectionViewShouldSelectItem) {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

return [_asyncDelegate collectionView:self shouldSelectItemAtIndexPath:indexPath];

#pragma clang diagnostic pop

}

return YES;

}

- (void)collectionView:(UICollectionView *)collectionView didSelectItemAtIndexPath:(nonnull NSIndexPath *)indexPath

{

if (_asyncDelegateFlags.collectionNodeDidSelectItem) {

GET_COLLECTIONNODE_OR_RETURN(collectionNode, (void)0);

indexPath = [self convertIndexPathToCollectionNode:indexPath];

if (indexPath != nil) {

[_asyncDelegate collectionNode:collectionNode didSelectItemAtIndexPath:indexPath];

}

} else if (_asyncDelegateFlags.collectionViewDidSelectItem) {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

[_asyncDelegate collectionView:self didSelectItemAtIndexPath:indexPath];

#pragma clang diagnostic pop