#import <AsyncDisplayKit/ASAssert.h>

#import <AsyncDisplayKit/ASAvailability.h>

#import <AsyncDisplayKit/ASBatchFetching.h>

#import <AsyncDisplayKit/ASDelegateProxy.h>

#import <AsyncDisplayKit/ASCellNode+Internal.h>

#import <AsyncDisplayKit/ASCollectionDataController.h>

#import <AsyncDisplayKit/ASCollectionInternal.h>

#import <AsyncDisplayKit/ASCollectionViewLayoutController.h>

#import <AsyncDisplayKit/ASCollectionViewFlowLayoutInspector.h>

#import <AsyncDisplayKit/ASDisplayNodeExtras.h>

#import <AsyncDisplayKit/ASDisplayNode+FrameworkPrivate.h>

#import <AsyncDisplayKit/ASInternalHelpers.h>

#import <AsyncDisplayKit/UICollectionViewLayout+ASConvenience.h>

#import <AsyncDisplayKit/ASRangeController.h>

#import <AsyncDisplayKit/ASCollectionNode.h>

#import <AsyncDisplayKit/_ASCollectionViewCell.h>

#import <AsyncDisplayKit/_ASDisplayLayer.h>

#import <AsyncDisplayKit/ASCollectionViewLayoutFacilitatorProtocol.h>

#import <AsyncDisplayKit/ASSectionContext.h>

#import <AsyncDisplayKit/ASCollectionView+Undeprecated.h>

#import <AsyncDisplayKit/_ASHierarchyChangeSet.h>

#define GET_COLLECTIONNODE_OR_RETURN(__var, __val) \

ASCollectionNode *__var = self.collectionNode; \

if (__var == nil) { \

return __val; \

}

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 kReuseIdentifier = @"_ASCollectionReuseIdentifier";

#pragma mark -

#pragma mark ASCollectionView.

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

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;

/**

CALayer *_retainedLayer;

/**

BOOL _superIsPendingDataLoad;

/**

BOOL _hasEverCheckedForBatchFetchingDueToUpdate;

/**

_ASHierarchyChangeSet *_changeSet;

/**

NSInteger _batchUpdateCount;

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;

// Whether this delegate conforms to ASCollectionDataSourceInterop

unsigned int interop: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 collectionNodeSupplementaryElementKindsInSection:1;

unsigned int numberOfSectionsInCollectionNode:1;

unsigned int collectionNodeNumberOfItemsInSection:1;

unsigned int collectionNodeContextForSection:1;

// Whether this data source conforms to ASCollectionDataSourceInterop

unsigned int interop:1;

} _asyncDataSourceFlags;

struct {

unsigned int didChangeCollectionViewDataSource:1;

unsigned int didChangeCollectionViewDelegate:1;

} _layoutInspectorFlags;

}

@implementation ASCollectionView

{

__weak id<ASCollectionDelegate> _asyncDelegate;

__weak id<ASCollectionDataSource> _asyncDataSource;

}

+ (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:kReuseIdentifier];

if (!AS_AT_LEAST_IOS9) {

_retainedLayer = self.layer;

}

return self;

}

- (void)dealloc

{

ASDisplayNodeAssertMainThread();

ASDisplayNodeCAssert(_batchUpdateCount == 0, @"ASCollectionView deallocated in the middle of a batch update.");

// 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();

if (_batchUpdateCount > 0) {

// This assertion will be enabled soon.

// ASDisplayNodeFailAssert(@"Should not call %@ during batch update", NSStringFromSelector(_cmd));

return;

}

[_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. We also allow this when we're doing interop.

ASDisplayNodeAssert(_asyncDelegateFlags.interop || 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. We also allow this when we're doing interop.

ASDisplayNodeAssert(_asyncDelegateFlags.interop || 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];

_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:)];

_asyncDataSourceFlags.collectionNodeSupplementaryElementKindsInSection = [_asyncDataSource respondsToSelector:@selector(collectionNode:supplementaryElementKindsInSection:)];

_asyncDataSourceFlags.interop = [_asyncDataSource conformsToProtocol:@protocol(ASCollectionDataSourceInterop)];

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];

_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:)];

_asyncDelegateFlags.interop = [_asyncDelegate conformsToProtocol:@protocol(ASCollectionDelegateInterop)];

}

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;

}

}

- (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

- (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)beginUpdates

{

ASDisplayNodeAssertMainThread();

// _changeSet must be available during batch update

ASDisplayNodeAssertTrue((_batchUpdateCount > 0) == (_changeSet != nil));

if (_batchUpdateCount == 0) {

_changeSet = [[_ASHierarchyChangeSet alloc] initWithOldData:[_dataController itemCountsFromDataSource]];

}

_batchUpdateCount++;

}

- (void)endUpdatesAnimated:(BOOL)animated completion:(nullable void (^)(BOOL))completion

{

ASDisplayNodeAssertMainThread();

ASDisplayNodeAssertNotNil(_changeSet, @"_changeSet must be available when batch update ends");

_batchUpdateCount--;

// Prevent calling endUpdatesAnimated:completion: in an unbalanced way

NSAssert(_batchUpdateCount >= 0, @"endUpdatesAnimated:completion: called without having a balanced beginUpdates call");

[_changeSet addCompletionHandler:completion];

if (_batchUpdateCount == 0) {

[_dataController updateWithChangeSet:_changeSet animated:animated];

_changeSet = nil;

}

}

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

{

ASDisplayNodeAssertMainThread();

[self beginUpdates];

if (updates) {

updates();

}

[self 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:kReuseIdentifier];

}

- (void)insertSections:(NSIndexSet *)sections

{

ASDisplayNodeAssertMainThread();

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

[self performBatchUpdates:^{

[_changeSet insertSections:sections animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

- (void)deleteSections:(NSIndexSet *)sections

{

ASDisplayNodeAssertMainThread();

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

[self performBatchUpdates:^{

[_changeSet deleteSections:sections animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

- (void)reloadSections:(NSIndexSet *)sections

{

ASDisplayNodeAssertMainThread();

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

[self performBatchUpdates:^{

[_changeSet reloadSections:sections animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

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

{

ASDisplayNodeAssertMainThread();

[self performBatchUpdates:^{

[_changeSet moveSection:section toSection:newSection animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

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

{

ASDisplayNodeAssertMainThread();

return [_dataController contextForSection:section];

}

- (void)insertItemsAtIndexPaths:(NSArray *)indexPaths

{

ASDisplayNodeAssertMainThread();

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

[self performBatchUpdates:^{

[_changeSet insertItems:indexPaths animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

- (void)deleteItemsAtIndexPaths:(NSArray *)indexPaths

{

ASDisplayNodeAssertMainThread();

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

[self performBatchUpdates:^{

[_changeSet deleteItems:indexPaths animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

- (void)reloadItemsAtIndexPaths:(NSArray *)indexPaths

{

ASDisplayNodeAssertMainThread();

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

[self performBatchUpdates:^{

[_changeSet reloadItems:indexPaths animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

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

{

ASDisplayNodeAssertMainThread();

[self performBatchUpdates:^{

[_changeSet moveItemAtIndexPath:indexPath toIndexPath:newIndexPath animationOptions:kASCollectionViewAnimationNone];

} completion:nil];

}

#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];

}

- (CGSize)collectionView:(UICollectionView *)collectionView layout:(UICollectionViewLayout *)layout referenceSizeForHeaderInSection:(NSInteger)section

{

ASCellNode *cell = [self supplementaryNodeForElementKind:UICollectionElementKindSectionHeader

atIndexPath:[NSIndexPath indexPathForItem:0 inSection:section]];

if (cell.shouldUseUIKitCell && _asyncDelegateFlags.interop) {

if ([_asyncDelegate respondsToSelector:@selector(collectionView:layout:referenceSizeForHeaderInSection:)]) {

return [(id)_asyncDelegate collectionView:collectionView layout:layout referenceSizeForHeaderInSection:section];

}

}

return cell.calculatedSize;

}

- (CGSize)collectionView:(UICollectionView *)collectionView layout:(UICollectionViewLayout *)layout referenceSizeForFooterInSection:(NSInteger)section

{

ASCellNode *cell = [self supplementaryNodeForElementKind:UICollectionElementKindSectionFooter

atIndexPath:[NSIndexPath indexPathForItem:0 inSection:section]];

if (cell.shouldUseUIKitCell && _asyncDelegateFlags.interop) {

if ([_asyncDelegate respondsToSelector:@selector(collectionView:layout:referenceSizeForFooterInSection:)]) {

return [(id)_asyncDelegate collectionView:collectionView layout:layout referenceSizeForFooterInSection:section];

}

}

return cell.calculatedSize;

}

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

{

UICollectionReusableView *view = nil;

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

if (node.shouldUseUIKitCell && _asyncDataSourceFlags.interop) {

view = [(id<ASCollectionDataSourceInterop>)_asyncDataSource collectionView:collectionView viewForSupplementaryElementOfKind:kind atIndexPath:indexPath];

} else {

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

if ([_registeredSupplementaryKinds containsObject:kind] == NO) {

[self registerSupplementaryNodeOfKind:kind];

}

view = [self dequeueReusableSupplementaryViewOfKind:kind withReuseIdentifier:kReuseIdentifier forIndexPath:indexPath];

if (node) {

[_rangeController configureContentView:view forCellNode:node];

}

}

return view;

}

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

{

UICollectionViewCell *cell = nil;

ASCellNode *node = [self nodeForItemAtIndexPath:indexPath];

if (node.shouldUseUIKitCell && _asyncDataSourceFlags.interop) {

cell = [(id<ASCollectionDataSourceInterop>)_asyncDataSource collectionView:collectionView cellForItemAtIndexPath:indexPath];

} else {

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

cell = [self dequeueReusableCellWithReuseIdentifier:kReuseIdentifier forIndexPath:indexPath];

[(_ASCollectionViewCell *)cell setNode:node];

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

}

return cell;

}

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

{

// Since _ASCollectionViewCell is not available for subclassing, this is faster than isKindOfClass:

// We must exit early here, because only _ASCollectionViewCell implements the -node accessor method.

if ([cell class] != [_ASCollectionViewCell class]) {

if (_asyncDelegateFlags.interop) {

[(id <ASCollectionDelegateInterop>)_asyncDelegate collectionView:collectionView willDisplayCell:cell forItemAtIndexPath:indexPath];

}

[_rangeController setNeedsUpdate];

return;

}

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 && self.collectionNode != nil) {

[_asyncDelegate collectionNode:self.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

{

// Since _ASCollectionViewCell is not available for subclassing, this is faster than isKindOfClass:

// We must exit early here, because only _ASCollectionViewCell implements the -node accessor method.

if ([cell class] != [_ASCollectionViewCell class]) {

if (_asyncDelegateFlags.interop) {

[(id <ASCollectionDelegateInterop>)_asyncDelegate collectionView:collectionView didEndDisplayingCell:cell forItemAtIndexPath:indexPath];

}

[_rangeController setNeedsUpdate];

return;

}

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) {