Merge remote-tracking branch 'facebook/master'

Author: hannahmbanana

AsyncDisplayKit.xcodeproj/project.pbxproj

@@ -10,6 +10,7 @@
 #import "ASCollectionInternal.h"
 #import "ASCollectionViewLayoutFacilitatorProtocol.h"
 #import "ASDisplayNode+Subclasses.h"
+#import "ASEnvironmentInternal.h"
 #import "ASRangeControllerUpdateRangeProtocol+Beta.h"
 #include <vector>
 
@@ -53,6 +54,9 @@ - (void)setTuningParameters:(ASRangeTuningParameters)tuningParameters forRangeTy
 #endif
 
 @interface ASCollectionNode ()
+{
+  ASDN::RecursiveMutex _environmentStateLock;
+}
 @property (nonatomic) _ASCollectionPendingState *pendingState;
 @end
 
@@ -244,4 +248,6 @@ - (void)reloadDataImmediately
   [self.view reloadDataImmediately];
 }
 
+ASEnvironmentCollectionTableSetEnvironmentState(_environmentStateLock)
+
 @end

AsyncDisplayKit/ASCollectionNode.mm

@@ -342,7 +342,7 @@ NS_ASSUME_NONNULL_BEGIN
  * This is a node-based UICollectionViewDataSource.
  */
 #define ASCollectionViewDataSource ASCollectionDataSource
-@protocol ASCollectionDataSource <ASCommonCollectionViewDataSource, NSObject>
+@protocol ASCollectionDataSource <ASCommonCollectionViewDataSource>
 
 @optional
 

AsyncDisplayKit/ASCollectionView.h

@@ -91,7 +91,7 @@ - (instancetype)init
 #pragma mark -
 #pragma mark ASCollectionView.
 
-@interface ASCollectionView () <ASRangeControllerDataSource, ASRangeControllerDelegate, ASDataControllerSource, ASCellNodeLayoutDelegate, ASDelegateProxyInterceptor, ASBatchFetchingScrollView> {
+@interface ASCollectionView () <ASRangeControllerDataSource, ASRangeControllerDelegate, ASDataControllerSource, ASCellNodeLayoutDelegate, ASDelegateProxyInterceptor, ASBatchFetchingScrollView, ASDataControllerEnvironmentDelegate> {
   ASCollectionViewProxy *_proxyDataSource;
   ASCollectionViewProxy *_proxyDelegate;
 
@@ -225,6 +225,7 @@ - (instancetype)_initWithFrame:(CGRect)frame collectionViewLayout:(UICollectionV
   _dataController = [[ASCollectionDataController alloc] initWithAsyncDataFetching:NO];
   _dataController.delegate = _rangeController;
   _dataController.dataSource = self;
+  _dataController.environmentDelegate = self;
 
   _batchContext = [[ASBatchContext alloc] init];
 
@@ -343,10 +344,10 @@ - (void)setAsyncDataSource:(id<ASCollectionViewDataSource>)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
   // 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 nil out
-  // super.dataSource in this case because calls to ASCollectionViewProxy will start failing and cause crashes.
-
-  super.dataSource = nil;
+  // 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];
@@ -375,13 +376,9 @@ - (void)setAsyncDelegate:(id<ASCollectionViewDelegate>)asyncDelegate
 {
   // 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 _proxyDelegate still exists. It's really important to nil out
-  // super.delegate in this case because calls to ASCollectionViewProxy will start failing and cause crashes.
-  
-  // Order is important here, the asyncDelegate must be callable while nilling super.delegate to avoid random crashes
-  // in UIScrollViewAccessibility.
-
-  super.delegate = nil;
+  // 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;
@@ -921,6 +918,14 @@ - (void)dataControllerUnlockDataSource
   }
 }
 
+- (id<ASEnvironment>)dataControllerEnvironment
+{
+  if (self.collectionNode) {
+    return self.collectionNode;
+  }
+  return self.strongCollectionNode;
+}
+
 #pragma mark - ASCollectionViewDataControllerSource Supplementary view support
 
 - (ASCellNode *)dataController:(ASCollectionDataController *)dataController supplementaryNodeOfKind:(NSString *)kind atIndexPath:(NSIndexPath *)indexPath

AsyncDisplayKit/ASCollectionView.mm

@@ -22,6 +22,7 @@
 #import "_ASCoreAnimationExtras.h"
 #import "ASDisplayNodeLayoutContext.h"
 #import "ASDisplayNodeExtras.h"
+#import "ASTraitCollection.h"
 #import "ASEqualityHelpers.h"
 #import "ASRunLoopQueue.h"
 #import "ASEnvironmentInternal.h"
@@ -2710,9 +2711,24 @@ - (BOOL)supportsUpwardPropagation
   return ASEnvironmentStatePropagationEnabled();
 }
 
+- (BOOL)supportsTraitsCollectionPropagation
+{
+  return ASEnvironmentStateTraitCollectionPropagationEnabled();
+}
+
+- (ASEnvironmentTraitCollection)environmentTraitCollection
+{
+  return _environmentState.traitCollection;
+}
+
 ASEnvironmentLayoutOptionsForwarding
 ASEnvironmentLayoutExtensibilityForwarding
 
+- (ASTraitCollection *)asyncTraitCollection
+{
+  ASDN::MutexLocker l(_propertyLock);
+  return [ASTraitCollection traitCollectionWithASEnvironmentTraitCollection:_environmentState.traitCollection];
+}
 
 #if TARGET_OS_TV
 #pragma mark - UIFocusEnvironment Protocol (tvOS)

AsyncDisplayKit/ASDisplayNode.mm

@@ -117,13 +117,20 @@ typedef NS_ENUM(NSUInteger, ASMultiplexImageNodeErrorCode) {
  */
 @property (nullable, nonatomic, readonly) ASImageIdentifier displayedImageIdentifier;
 
+/**
+ * @abstract If the downloader implements progressive image rendering and this value is YES progressive renders of the
+ * image will be displayed as the image downloads. Regardless of this properties value, progress renders will
+ * only occur when the node is visible. Defaults to YES.
+ */
+@property (nonatomic, assign, readwrite) BOOL shouldRenderProgressImages;
+
 #if TARGET_OS_IOS
 /**
  * @abstract The image manager that this image node should use when requesting images from the Photos framework. If this is `nil` (the default), then `PHImageManager.defaultManager` is used.
  
  * @see `+[NSURL URLWithAssetLocalIdentifier:targetSize:contentMode:options:]` below.
  */
-@property (nonatomic, strong) PHImageManager *imageManager;
+@property (nullable, nonatomic, strong) PHImageManager *imageManager;
 #endif
 @end
 

AsyncDisplayKit/ASMultiplexImageNode.h

@@ -85,6 +85,10 @@ @interface ASMultiplexImageNode ()
   ASDN::RecursiveMutex _downloadIdentifierLock;
   id _downloadIdentifier;
 
+  // Properties
+  ASDN::RecursiveMutex _propertyLock;
+  BOOL _shouldRenderProgressImages;
+  
   //set on init only
   BOOL _downloaderSupportsNewProtocol;
   BOOL _downloaderImplementsSetProgress;
@@ -186,6 +190,8 @@ - (instancetype)initWithCache:(id<ASImageCacheProtocol>)cache downloader:(id<ASI
   _cacheSupportsNewProtocol = [cache respondsToSelector:@selector(cachedImageWithURL:callbackQueue:completion:)];
   _cacheSupportsClearing = [cache respondsToSelector:@selector(clearFetchedImageFromCacheWithURL:)];
 
+  _shouldRenderProgressImages = YES;
+  
   self.shouldBypassEnsureDisplay = YES;
 
   return self;
@@ -339,6 +345,27 @@ - (void)setDataSource:(id <ASMultiplexImageNodeDataSource>)dataSource
   #endif
 }
 
+
+- (void)setShouldRenderProgressImages:(BOOL)shouldRenderProgressImages
+{
+  ASDN::MutexLocker l(_propertyLock);
+  if (shouldRenderProgressImages == _shouldRenderProgressImages) {
+    return;
+  }
+  
+  _shouldRenderProgressImages = shouldRenderProgressImages;
+  
+  
+  ASDN::MutexUnlocker u(_propertyLock);
+  [self _updateProgressImageBlockOnDownloaderIfNeeded];
+}
+
+- (BOOL)shouldRenderProgressImages
+{
+  ASDN::MutexLocker l(_propertyLock);
+  return _shouldRenderProgressImages;
+}
+
 #pragma mark -
 
 #pragma mark -
@@ -436,8 +463,12 @@ - (UIImage *)_bestImmediatelyAvailableImageFromDataSource:(id *)imageIdentifierO
   }
 
   // Grab the best available image from the data source.
+  UIImage *existingImage = self.image;
   for (id imageIdentifier in _imageIdentifiers) {
-    UIImage *image = [_dataSource multiplexImageNode:self imageForImageIdentifier:imageIdentifier];
+    // If this image is already loaded, don't request it from the data source again because
+    // the data source may generate a new instance of UIImage that returns NO for isEqual:
+    // and we'll end up in an infinite loading loop.
+    UIImage *image = ASObjectIsEqual(imageIdentifier, _loadedImageIdentifier) ? existingImage : [_dataSource multiplexImageNode:self imageForImageIdentifier:imageIdentifier];
     if (image) {
       if (imageIdentifierOut) {
         *imageIdentifierOut = imageIdentifier;
@@ -458,32 +489,34 @@ - (UIImage *)_bestImmediatelyAvailableImageFromDataSource:(id *)imageIdentifierO
  */
 - (void)_updateProgressImageBlockOnDownloaderIfNeeded
 {
-    // Read our interface state before locking so that we don't lock super while holding our lock.
-    ASInterfaceState interfaceState = self.interfaceState;
-    ASDN::MutexLocker l(_downloadIdentifierLock);
-    
-    if (!_downloaderImplementsSetProgress || _downloadIdentifier == nil) {
+  BOOL shouldRenderProgressImages = self.shouldRenderProgressImages;
+  
+  // Read our interface state before locking so that we don't lock super while holding our lock.
+  ASInterfaceState interfaceState = self.interfaceState;
+  ASDN::MutexLocker l(_downloadIdentifierLock);
+  
+  if (!_downloaderImplementsSetProgress || _downloadIdentifier == nil) {
+    return;
+  }
+  
+  ASImageDownloaderProgressImage progress = nil;
+  if (shouldRenderProgressImages && ASInterfaceStateIncludesVisible(interfaceState)) {
+    __weak __typeof__(self) weakSelf = self;
+    progress = ^(UIImage * _Nonnull progressImage, CGFloat progress, id _Nullable downloadIdentifier) {
+      __typeof__(self) strongSelf = weakSelf;
+      if (strongSelf == nil) {
         return;
-    }
-
-    ASImageDownloaderProgressImage progress = nil;
-    if (ASInterfaceStateIncludesVisible(interfaceState)) {
-        __weak __typeof__(self) weakSelf = self;
-        progress = ^(UIImage * _Nonnull progressImage, CGFloat progress, id _Nullable downloadIdentifier) {
-            __typeof__(self) strongSelf = weakSelf;
-            if (strongSelf == nil) {
-                return;
-            }
-
-            ASDN::MutexLocker l(strongSelf->_downloadIdentifierLock);
-            //Getting a result back for a different download identifier, download must not have been successfully canceled
-            if (ASObjectIsEqual(strongSelf->_downloadIdentifier, downloadIdentifier) == NO && downloadIdentifier != nil) {
-                return;
-            }
-            strongSelf.image = progressImage;
-        };
-    }
-    [_downloader setProgressImageBlock:progress callbackQueue:dispatch_get_main_queue() withDownloadIdentifier:_downloadIdentifier];
+      }
+      
+      ASDN::MutexLocker l(strongSelf->_downloadIdentifierLock);
+      //Getting a result back for a different download identifier, download must not have been successfully canceled
+      if (ASObjectIsEqual(strongSelf->_downloadIdentifier, downloadIdentifier) == NO && downloadIdentifier != nil) {
+        return;
+      }
+      strongSelf.image = progressImage;
+    };
+  }
+  [_downloader setProgressImageBlock:progress callbackQueue:dispatch_get_main_queue() withDownloadIdentifier:_downloadIdentifier];
 }
 
 - (void)_clearImage

AsyncDisplayKit/ASMultiplexImageNode.mm

@@ -0,0 +1,15 @@
+//
+//  ASNavigationController.h
+//  Pods
+//
+//  Created by Garrett Moon on 4/27/16.
+//
+//
+
+#import <UIKit/UIKit.h>
+
+#import "ASVisibilityProtocols.h"
+
+@interface ASNavigationController : UINavigationController <ASManagesChildVisibilityDepth>
+
+@end

AsyncDisplayKit/ASNavigationController.h

@@ -0,0 +1,93 @@
+//
+//  ASNavigationController.m
+//  Pods
+//
+//  Created by Garrett Moon on 4/27/16.
+//
+//
+
+#import "ASNavigationController.h"
+
+@implementation ASNavigationController
+{
+  BOOL _parentManagesVisibilityDepth;
+  NSInteger _visibilityDepth;
+}
+
+ASVisibilityDidMoveToParentViewController;
+
+ASVisibilityViewWillAppear;
+
+ASVisibilityViewDidDisappearImplementation;
+
+ASVisibilitySetVisibilityDepth;
+
+ASVisibilityDepthImplementation;
+
+- (void)visibilityDepthDidChange
+{
+  for (UIViewController *viewController in self.viewControllers) {
+    if ([viewController conformsToProtocol:@protocol(ASVisibilityDepth)]) {
+      [(id <ASVisibilityDepth>)viewController visibilityDepthDidChange];
+    }
+  }
+}
+
+- (NSInteger)visibilityDepthOfChildViewController:(UIViewController *)childViewController
+{
+  NSUInteger viewControllerIndex = [self.viewControllers indexOfObject:childViewController];
+  NSAssert(viewControllerIndex != NSNotFound, @"childViewController is not in the navigation stack.");
+  
+  if (viewControllerIndex == self.viewControllers.count - 1) {
+    //view controller is at the top, just return our own visibility depth.
+    return [self visibilityDepth];
+  } else if (viewControllerIndex == 0) {
+    //view controller is the root view controller. Can be accessed by holding the back button.
+    return [self visibilityDepth] + 1;
+  }
+  
+  return [self visibilityDepth] + self.viewControllers.count - 1 - viewControllerIndex;
+}
+
+#pragma mark - UIKit overrides
+
+- (NSArray *)popToViewController:(UIViewController *)viewController animated:(BOOL)animated
+{
+  NSArray *viewControllers = [super popToViewController:viewController animated:animated];
+  [self visibilityDepthDidChange];
+  return viewControllers;
+}
+
+- (NSArray *)popToRootViewControllerAnimated:(BOOL)animated
+{
+  NSArray *viewControllers = [super popToRootViewControllerAnimated:animated];
+  [self visibilityDepthDidChange];
+  return viewControllers;
+}
+
+- (void)setViewControllers:(NSArray *)viewControllers
+{
+  [super setViewControllers:viewControllers];
+  [self visibilityDepthDidChange];
+}
+
+- (void)setViewControllers:(NSArray *)viewControllers animated:(BOOL)animated
+{
+  [super setViewControllers:viewControllers animated:animated];
+  [self visibilityDepthDidChange];
+}
+
+- (void)pushViewController:(UIViewController *)viewController animated:(BOOL)animated
+{
+  [super pushViewController:viewController animated:animated];
+  [self visibilityDepthDidChange];
+}
+
+- (UIViewController *)popViewControllerAnimated:(BOOL)animated
+{
+  UIViewController *viewController = [super popViewControllerAnimated:animated];
+  [self visibilityDepthDidChange];
+  return viewController;
+}
+
+@end

AsyncDisplayKit/ASNavigationController.m

@@ -73,6 +73,13 @@ NS_ASSUME_NONNULL_BEGIN
  */
 @property (nonatomic, assign, readwrite) BOOL shouldCacheImage;
 
+/**
+ * If the downloader implements progressive image rendering and this value is YES progressive renders of the
+ * image will be displayed as the image downloads. Regardless of this properties value, progress renders will
+ * only occur when the node is visible. Defaults to YES.
+ */
+@property (nonatomic, assign, readwrite) BOOL shouldRenderProgressImages;
+
 /**
  * The image quality of the current image. This is a number between 0 and 1 and can be used to track
  * progressive progress. Calculated by dividing number of bytes / expected number of total bytes.