[ASCollectionView] Add Method to Wait for Updates During Next Layout Pass

AsyncDisplayKit/ASCollectionView.h

@@ -51,6 +51,16 @@ NS_ASSUME_NONNULL_BEGIN
 @property (nonatomic, weak) id<ASCollectionDelegate>   asyncDelegate;
 @property (nonatomic, weak) id<ASCollectionDataSource> asyncDataSource;
 
+/**
+ * Tell the collection view that, during the next layoutSubviews pass, it should block the
+ * main thread and wait for all items to be up-to-date.
+ *
+ * @discussion This is useful when you want to ensure that the user never sees an empty
+ * collection view. It is better to call this than to explicitly wait using `waitUntilAllUpdatesAreCommitted`
+ * because the collection view's size may not be correct until the layout pass.
+ */
+- (void)waitForUpdatesDuringNextLayoutPass;
+
 /**
  * Tuning parameters for a range type in full mode.
  *

AsyncDisplayKit/ASCollectionView.mm

@@ -98,6 +98,8 @@ @interface ASCollectionView () <ASRangeControllerDataSource, ASRangeControllerDe
   NSMutableSet *_cellsForVisibilityUpdates;
   id<ASCollectionViewLayoutFacilitatorProtocol> _layoutFacilitator;
 
+  BOOL _isInSuperLayoutSubviews;
+  BOOL _waitsForUpdatesDuringNextLayout;
   BOOL _performingBatchUpdates;
   NSUInteger _superBatchUpdateCount;
   NSMutableArray *_batchUpdateBlocks;
@@ -283,21 +285,27 @@ - (void)dealloc
 
 - (void)reloadDataWithCompletion:(void (^)())completion
 {
-  ASPerformBlockOnMainThread(^{
-    _superIsPendingDataLoad = YES;
-    [super reloadData];
-  });
+  ASDisplayNodeAssertMainThread();
+
+  _superIsPendingDataLoad = YES;
   [_dataController reloadDataWithAnimationOptions:kASCollectionViewAnimationNone completion:completion];
+  if (_isInSuperLayoutSubviews && _waitsForUpdatesDuringNextLayout) {
+    _waitsForUpdatesDuringNextLayout = NO;
+    [self waitUntilAllUpdatesAreCommitted];
+  }
+  [super reloadData];
 }
 
 - (void)reloadData
 {
+  ASDisplayNodeAssertMainThread();
   [self reloadDataWithCompletion:nil];
 }
 
 - (void)reloadDataImmediately
 {
   ASDisplayNodeAssertMainThread();
+
   _superIsPendingDataLoad = YES;
   [_dataController reloadDataImmediatelyWithAnimationOptions:kASCollectionViewAnimationNone];
   [super reloadData];
@@ -311,6 +319,11 @@ - (void)relayoutItems
 - (void)waitUntilAllUpdatesAreCommitted
 {
   ASDisplayNodeAssertMainThread();
+
+  if (_dataController.initialReloadDataHasBeenCalled == NO) {
+    [_dataController reloadDataWithAnimationOptions:kASCollectionViewAnimationNone completion:nil];
+  }
+
   [_dataController waitUntilAllUpdatesAreCommitted];
 }
 
@@ -520,6 +533,12 @@ - (void)selectItemAtIndexPath:(NSIndexPath *)indexPath animated:(BOOL)animated s
   [super selectItemAtIndexPath:indexPath animated:animated scrollPosition:scrollPosition];
 }
 
+- (void)waitForUpdatesDuringNextLayoutPass
+{
+  ASDisplayNodeAssertMainThread();
+  _waitsForUpdatesDuringNextLayout = YES;
+}
+
 #pragma mark Internal
 
 /**
@@ -870,8 +889,17 @@ - (void)layoutSubviews
       break;
   }
 
+  // If we've already done our initial reload, we can just wait now.
+  // Otherwise we will wait after our initial reloadData (during [super layoutSubviews])
+  if (_dataController.initialReloadDataHasBeenCalled && _waitsForUpdatesDuringNextLayout) {
+    _waitsForUpdatesDuringNextLayout = NO;
+    [self waitUntilAllUpdatesAreCommitted];
+  }
+
   // To ensure _maxSizeForNodesConstrainedSize is up-to-date for every usage, this call to super must be done last
+  _isInSuperLayoutSubviews = YES;
   [super layoutSubviews];
+  _isInSuperLayoutSubviews = NO;
 
   // Update range controller immediately if possible & needed.
   // Calling -updateIfNeeded in here with self.window == nil (early in the collection view's life)

AsyncDisplayKit/ASTableView.h

@@ -47,6 +47,16 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (instancetype)initWithFrame:(CGRect)frame style:(UITableViewStyle)style;
 
+/**
+ * Tell the table view that, during the next layoutSubviews pass, it should block the
+ * main thread and wait for all rows to be up-to-date.
+ *
+ * @discussion This is useful when you want to ensure that the user never sees an empty
+ * table view. It is better to call this than to explicitly wait using `waitUntilAllUpdatesAreCommitted`
+ * because the table view's size may not be correct until the layout pass.
+ */
+- (void)waitForUpdatesDuringNextLayoutPass;
+
 /**
  * Tuning parameters for a range type in full mode.
  *
@@ -162,7 +172,7 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)endUpdatesAnimated:(BOOL)animated completion:(void (^ _Nullable)(BOOL completed))completion;
 
 /**
- *  Blocks execution of the main thread until all section and row updates are committed. This method must be called from the main thread.
+ * Blocks execution of the main thread until all section and row updates are committed. This method must be called from the main thread.
  */
 - (void)waitUntilAllUpdatesAreCommitted;
 

AsyncDisplayKit/ASTableView.mm

@@ -122,6 +122,8 @@ @interface ASTableView () <ASRangeControllerDataSource, ASRangeControllerDelegat
    */
   CALayer *_retainedLayer;
 
+  BOOL _waitsForUpdatesDuringNextLayout;
+  BOOL _isInSuperLayoutSubviews;
   CGFloat _nodesConstrainedWidth;
   BOOL _ignoreNodesConstrainedWidthChange;
   BOOL _queuedNodeHeightUpdate;
@@ -269,8 +271,7 @@ - (void)dealloc
   [self setAsyncDataSource:nil];
 }
 
-#pragma mark -
-#pragma mark Overrides
+#pragma mark - Overrides
 
 - (void)setDataSource:(id<UITableViewDataSource>)dataSource
 {
@@ -284,6 +285,8 @@ - (void)setDelegate:(id<UITableViewDelegate>)delegate
   ASDisplayNodeAssert(delegate == nil, @"ASTableView uses asyncDelegate, not UITableView's delegate property.");
 }
 
+#pragma mark - Public
+
 - (void)setAsyncDataSource:(id<ASTableViewDataSource>)asyncDataSource
 {
   // Note: It's common to check if the value hasn't changed and short-circuit but we aren't doing that here to handle
@@ -361,10 +364,14 @@ - (void)proxyTargetHasDeallocated:(ASDelegateProxy *)proxy
 
 - (void)reloadDataWithCompletion:(void (^)())completion
 {
-  ASPerformBlockOnMainThread(^{
-    [super reloadData];
-  });
+  ASDisplayNodeAssertMainThread();
+
   [_dataController reloadDataWithAnimationOptions:UITableViewRowAnimationNone completion:completion];
+  if (_isInSuperLayoutSubviews && _waitsForUpdatesDuringNextLayout) {
+    _waitsForUpdatesDuringNextLayout = NO;
+    [self waitUntilAllUpdatesAreCommitted];
+  }
+  [super reloadData];
 }
 
 - (void)reloadData
@@ -384,6 +391,12 @@ - (void)relayoutItems
   [_dataController relayoutAllNodes];
 }
 
+- (void)waitForUpdatesDuringNextLayoutPass
+{
+  ASDisplayNodeAssertMainThread();
+  _waitsForUpdatesDuringNextLayout = YES;
+}
+
 - (void)setTuningParameters:(ASRangeTuningParameters)tuningParameters forRangeType:(ASLayoutRangeType)rangeType
 {
   [_rangeController setTuningParameters:tuningParameters forRangeMode:ASLayoutRangeModeFull rangeType:rangeType];
@@ -455,6 +468,11 @@ - (void)endUpdatesAnimated:(BOOL)animated completion:(void (^)(BOOL completed))c
 - (void)waitUntilAllUpdatesAreCommitted
 {
   ASDisplayNodeAssertMainThread();
+
+  if (_dataController.initialReloadDataHasBeenCalled == NO) {
+    [_dataController reloadDataWithAnimationOptions:UITableViewRowAnimationNone completion:nil];
+  }
+
   [_dataController waitUntilAllUpdatesAreCommitted];
 }
 
@@ -498,8 +516,17 @@ - (void)layoutSubviews
     }
   }
 
+  // If we've already done our initial reload, we can just wait now.
+  // Otherwise we will wait after our initial reloadData (during [super layoutSubviews])
+  if (_dataController.initialReloadDataHasBeenCalled && _waitsForUpdatesDuringNextLayout) {
+    _waitsForUpdatesDuringNextLayout = NO;
+    [self waitUntilAllUpdatesAreCommitted];
+  }
+
   // To ensure _nodesConstrainedWidth is up-to-date for every usage, this call to super must be done last
+  _isInSuperLayoutSubviews = YES;
   [super layoutSubviews];
+  _isInSuperLayoutSubviews = NO;
   [_rangeController updateIfNeeded];
 }