#import "ASDisplayNodeInternal.h"

#import "ASDisplayNode+Subclasses.h"

#import "ASDisplayNode+FrameworkPrivate.h"

#import "ASDisplayNode+Beta.h"

#import <objc/runtime.h>

#import <deque>

#import "_ASAsyncTransaction.h"

#import "_ASAsyncTransactionContainer+Private.h"

#import "_ASPendingState.h"

#import "_ASDisplayView.h"

#import "_ASScopeTimer.h"

#import "_ASCoreAnimationExtras.h"

#import "ASDisplayNodeLayoutContext.h"

#import "ASDisplayNodeExtras.h"

#import "ASTraitCollection.h"

#import "ASEqualityHelpers.h"

#import "ASRunLoopQueue.h"

#import "ASEnvironmentInternal.h"

#import "ASInternalHelpers.h"

#import "ASLayout.h"

#import "ASLayoutSpec.h"

#import "ASCellNode.h"

NSInteger const ASDefaultDrawingPriority = ASDefaultTransactionPriority;

NSString * const ASRenderingEngineDidDisplayScheduledNodesNotification = @"ASRenderingEngineDidDisplayScheduledNodes";

NSString * const ASRenderingEngineDidDisplayNodesScheduledBeforeTimestamp = @"ASRenderingEngineDidDisplayNodesScheduledBeforeTimestamp";

@interface ASDisplayNode () <UIGestureRecognizerDelegate, _ASDisplayLayerDelegate, _ASTransitionContextCompletionDelegate>

- (void)_staticInitialize;

#define LOG(...)

#if TIME_DISPLAYNODE_OPS

#define TIME_SCOPED(outVar) ASDN::ScopeTimer t(outVar)

#else

#define TIME_SCOPED(outVar)

#endif

@implementation ASDisplayNode

@dynamic spacingAfter, spacingBefore, flexGrow, flexShrink, flexBasis, alignSelf, ascender, descender, sizeRange, layoutPosition;

@synthesize name = _name;

@synthesize preferredFrameSize = _preferredFrameSize;

@synthesize isFinalLayoutable = _isFinalLayoutable;

@synthesize threadSafeBounds = _threadSafeBounds;

static BOOL usesImplicitHierarchyManagement = NO;

+ (BOOL)usesImplicitHierarchyManagement

{

return usesImplicitHierarchyManagement;

}

+ (void)setUsesImplicitHierarchyManagement:(BOOL)enabled

{

usesImplicitHierarchyManagement = enabled;

}

BOOL ASDisplayNodeSubclassOverridesSelector(Class subclass, SEL selector)

{

return ASSubclassOverridesSelector([ASDisplayNode class], subclass, selector);

}

BOOL ASDisplayNodeNeedsSpecialPropertiesHandlingForFlags(ASDisplayNodeFlags flags)

{

return flags.synchronous && !flags.layerBacked;

}

_ASPendingState *ASDisplayNodeGetPendingState(ASDisplayNode *node)

{

ASDN::MutexLocker l(node->_propertyLock);

_ASPendingState *result = node->_pendingViewState;

if (result == nil) {

result = [[_ASPendingState alloc] init];

node->_pendingViewState = result;

}

return result;

}

static struct ASDisplayNodeFlags GetASDisplayNodeFlags(Class c, ASDisplayNode *instance)

{

ASDisplayNodeCAssertNotNil(c, @"class is required");

struct ASDisplayNodeFlags flags = {0};

flags.isInHierarchy = NO;

flags.displaysAsynchronously = YES;

flags.shouldAnimateSizeChanges = YES;

flags.implementsDrawRect = ([c respondsToSelector:@selector(drawRect:withParameters:isCancelled:isRasterizing:)] ? 1 : 0);

flags.implementsImageDisplay = ([c respondsToSelector:@selector(displayWithParameters:isCancelled:)] ? 1 : 0);

if (instance) {

flags.implementsDrawParameters = ([instance respondsToSelector:@selector(drawParametersForAsyncLayer:)] ? 1 : 0);

flags.implementsInstanceDrawRect = ([instance respondsToSelector:@selector(drawRect:withParameters:isCancelled:isRasterizing:)] ? 1 : 0);

flags.implementsInstanceImageDisplay = ([instance respondsToSelector:@selector(displayWithParameters:isCancelled:)] ? 1 : 0);

} else {

flags.implementsDrawParameters = ([c instancesRespondToSelector:@selector(drawParametersForAsyncLayer:)] ? 1 : 0);

flags.implementsInstanceDrawRect = ([c instancesRespondToSelector:@selector(drawRect:withParameters:isCancelled:isRasterizing:)] ? 1 : 0);

flags.implementsInstanceImageDisplay = ([c instancesRespondToSelector:@selector(displayWithParameters:isCancelled:)] ? 1 : 0);

}

return flags;

}

static ASDisplayNodeMethodOverrides GetASDisplayNodeMethodOverrides(Class c)

{

ASDisplayNodeCAssertNotNil(c, @"class is required");

ASDisplayNodeMethodOverrides overrides = ASDisplayNodeMethodOverrideNone;

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesBegan:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesBegan;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesMoved:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesMoved;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesCancelled:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesCancelled;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(touchesEnded:withEvent:))) {

overrides |= ASDisplayNodeMethodOverrideTouchesEnded;

}

if (ASDisplayNodeSubclassOverridesSelector(c, @selector(layoutSpecThatFits:))) {

overrides |= ASDisplayNodeMethodOverrideLayoutSpecThatFits;

}

return overrides;

}

// At most a layoutSpecBlock or one of the three layout methods is overridden

#define __ASDisplayNodeCheckForLayoutMethodOverrides \

ASDisplayNodeAssert(_layoutSpecBlock != NULL || \

(ASDisplayNodeSubclassOverridesSelector(self.class, @selector(calculateSizeThatFits:)) ? 1 : 0) \

+ (ASDisplayNodeSubclassOverridesSelector(self.class, @selector(layoutSpecThatFits:)) ? 1 : 0) \

+ (ASDisplayNodeSubclassOverridesSelector(self.class, @selector(calculateLayoutThatFits:)) ? 1 : 0) <= 1, \

@"Subclass %@ must at least provide a layoutSpecBlock or override at most one of the three layout methods: calculateLayoutThatFits, layoutSpecThatFits or calculateSizeThatFits", NSStringFromClass(self.class))

+ (void)initialize

{

if (self != [ASDisplayNode class]) {

// Subclasses should never override these

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(calculatedSize)), @"Subclass %@ must not override calculatedSize method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(calculatedLayout)), @"Subclass %@ must not override calculatedLayout method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(measure:)), @"Subclass %@ must not override measure method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(measureWithSizeRange:)), @"Subclass %@ must not override measureWithSizeRange method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(recursivelyClearContents)), @"Subclass %@ must not override recursivelyClearContents method", NSStringFromClass(self));

ASDisplayNodeAssert(!ASDisplayNodeSubclassOverridesSelector(self, @selector(recursivelyClearFetchedData)), @"Subclass %@ must not override recursivelyClearFetchedData method", NSStringFromClass(self));

}

// Below we are pre-calculating values per-class and dynamically adding a method (_staticInitialize) to populate these values

// when each instance is constructed. These values don't change for each class, so there is significant performance benefit

// in doing it here. +initialize is guaranteed to be called before any instance method so it is safe to add this method here.

// Note that we take care to detect if the class overrides +respondsToSelector: or -respondsToSelector and take the slow path

// (recalculating for each instance) to make sure we are always correct.

BOOL classOverridesRespondsToSelector = ASSubclassOverridesClassSelector([NSObject class], self, @selector(respondsToSelector:));

BOOL instancesOverrideRespondsToSelector = ASSubclassOverridesSelector([NSObject class], self, @selector(respondsToSelector:));

struct ASDisplayNodeFlags flags = GetASDisplayNodeFlags(self, nil);

ASDisplayNodeMethodOverrides methodOverrides = GetASDisplayNodeMethodOverrides(self);

IMP staticInitialize = imp_implementationWithBlock(^(ASDisplayNode *node) {

node->_flags = (classOverridesRespondsToSelector || instancesOverrideRespondsToSelector) ? GetASDisplayNodeFlags(node.class, node) : flags;

node->_methodOverrides = (classOverridesRespondsToSelector) ? GetASDisplayNodeMethodOverrides(node.class) : methodOverrides;

});

class_replaceMethod(self, @selector(_staticInitialize), staticInitialize, "v:@");

}

+ (void)load

{

// Ensure this value is cached on the main thread before needed in the background.

ASScreenScale();

}

+ (BOOL)layerBackedNodesEnabled

{

return YES;

}

+ (Class)viewClass

{

return [_ASDisplayView class];

}

+ (Class)layerClass

{

return [_ASDisplayLayer class];

}

+ (void)scheduleNodeForRecursiveDisplay:(ASDisplayNode *)node

{

static dispatch_once_t onceToken;

static ASRunLoopQueue<ASDisplayNode *> *renderQueue;

dispatch_once(&onceToken, ^{

renderQueue = [[ASRunLoopQueue<ASDisplayNode *> alloc] initWithRunLoop:CFRunLoopGetMain()

andHandler:^(ASDisplayNode * _Nonnull dequeuedItem, BOOL isQueueDrained) {

CFAbsoluteTime timestamp = isQueueDrained ? CFAbsoluteTimeGetCurrent() : 0;

[dequeuedItem _recursivelyTriggerDisplayAndBlock:NO];

if (isQueueDrained) {

[[NSNotificationCenter defaultCenter] postNotificationName:ASRenderingEngineDidDisplayScheduledNodesNotification

object:nil

userInfo:@{ASRenderingEngineDidDisplayNodesScheduledBeforeTimestamp: @(timestamp)}];

}

}];

});

[renderQueue enqueue:node];

}

#pragma mark - Lifecycle

- (void)_staticInitialize

{

ASDisplayNodeAssert(NO, @"_staticInitialize must be overridden");

}

- (void)_initializeInstance

{

[self _staticInitialize];

_contentsScaleForDisplay = ASScreenScale();

_displaySentinel = [[ASSentinel alloc] init];

_preferredFrameSize = CGSizeZero;

_environmentState = ASEnvironmentStateMakeDefault();

}

- (instancetype)init

{

if (!(self = [super init]))

return nil;

[self _initializeInstance];

return self;

}

- (instancetype)initWithViewClass:(Class)viewClass

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssert([viewClass isSubclassOfClass:[UIView class]], @"should initialize with a subclass of UIView");

[self _initializeInstance];

_viewClass = viewClass;

_flags.synchronous = ![viewClass isSubclassOfClass:[_ASDisplayView class]];

return self;

}

- (instancetype)initWithLayerClass:(Class)layerClass

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssert([layerClass isSubclassOfClass:[CALayer class]], @"should initialize with a subclass of CALayer");

[self _initializeInstance];

_layerClass = layerClass;

_flags.synchronous = ![layerClass isSubclassOfClass:[_ASDisplayLayer class]];

_flags.layerBacked = YES;

return self;

}

- (instancetype)initWithViewBlock:(ASDisplayNodeViewBlock)viewBlock

{

return [self initWithViewBlock:viewBlock didLoadBlock:nil];

}

- (instancetype)initWithViewBlock:(ASDisplayNodeViewBlock)viewBlock didLoadBlock:(ASDisplayNodeDidLoadBlock)didLoadBlock

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssertNotNil(viewBlock, @"should initialize with a valid block that returns a UIView");

[self _initializeInstance];

_viewBlock = viewBlock;

_nodeLoadedBlock = didLoadBlock;

_flags.synchronous = YES;

return self;

}

- (instancetype)initWithLayerBlock:(ASDisplayNodeLayerBlock)layerBlock

{

return [self initWithLayerBlock:layerBlock didLoadBlock:nil];

}

- (instancetype)initWithLayerBlock:(ASDisplayNodeLayerBlock)layerBlock didLoadBlock:(ASDisplayNodeDidLoadBlock)didLoadBlock

{

if (!(self = [super init]))

return nil;

ASDisplayNodeAssertNotNil(layerBlock, @"should initialize with a valid block that returns a CALayer");

[self _initializeInstance];

_layerBlock = layerBlock;

_nodeLoadedBlock = didLoadBlock;

_flags.synchronous = YES;

_flags.layerBacked = YES;

return self;

}

- (void)dealloc

{

ASDisplayNodeAssertMainThread();

// Synchronous nodes may not be able to call the hierarchy notifications, so only enforce for regular nodes.

ASDisplayNodeAssert(_flags.synchronous || !ASInterfaceStateIncludesVisible(_interfaceState), @"Node should always be marked invisible before deallocating; interfaceState: %lu, %@", (unsigned long)_interfaceState, self);

self.asyncLayer.asyncDelegate = nil;

_view.asyncdisplaykit_node = nil;

_layer.asyncdisplaykit_node = nil;

// Remove any subnodes so they lose their connection to the now deallocated parent. This can happen

// because subnodes do not retain their supernode, but subnodes can legitimately remain alive if another

// thing outside the view hierarchy system (e.g. async display, controller code, etc). keeps a retained

// reference to subnodes.

for (ASDisplayNode *subnode in _subnodes)

[subnode __setSupernode:nil];

_view = nil;

_subnodes = nil;

if (_flags.layerBacked)

_layer.delegate = nil;

_layer = nil;

[self __setSupernode:nil];

_pendingViewState = nil;

_displaySentinel = nil;

_pendingDisplayNodes = nil;

}

#pragma mark - Core

- (void)__unloadNode

{

ASDisplayNodeAssertThreadAffinity(self);

ASDisplayNodeAssert([self isNodeLoaded], @"Implementation shouldn't call __unloadNode if not loaded: %@", self);

ASDN::MutexLocker l(_propertyLock);

if (_flags.layerBacked)

_pendingViewState = [_ASPendingState pendingViewStateFromLayer:_layer];

else

_pendingViewState = [_ASPendingState pendingViewStateFromView:_view];

[_view removeFromSuperview];

_view = nil;

if (_flags.layerBacked)

_layer.delegate = nil;

[_layer removeFromSuperlayer];

_layer = nil;

}

- (void)__loadNode

{

[self layer];

}

- (BOOL)__shouldLoadViewOrLayer

{

return !(_hierarchyState & ASHierarchyStateRasterized);

}

- (BOOL)__shouldSize

{

return YES;

}

- (UIView *)_viewToLoad

{

UIView *view;

ASDN::MutexLocker l(_propertyLock);

if (_viewBlock) {

view = _viewBlock();

ASDisplayNodeAssertNotNil(view, @"View block returned nil");

ASDisplayNodeAssert(![view isKindOfClass:[_ASDisplayView class]], @"View block should return a synchronously displayed view");

_viewBlock = nil;

_viewClass = [view class];

} else {

if (!_viewClass) {

_viewClass = [self.class viewClass];

}

view = [[_viewClass alloc] init];

}

return view;

}

- (CALayer *)_layerToLoad

{

CALayer *layer;

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(_flags.layerBacked, @"_layerToLoad is only for layer-backed nodes");

if (_layerBlock) {

layer = _layerBlock();

ASDisplayNodeAssertNotNil(layer, @"Layer block returned nil");

ASDisplayNodeAssert(![layer isKindOfClass:[_ASDisplayLayer class]], @"Layer block should return a synchronously displayed layer");

_layerBlock = nil;

_layerClass = [layer class];

} else {

if (!_layerClass) {

_layerClass = [self.class layerClass];

}

layer = [[_layerClass alloc] init];

}

return layer;

}

- (void)_loadViewOrLayerIsLayerBacked:(BOOL)isLayerBacked

{

ASDN::MutexLocker l(_propertyLock);

if (self._isDeallocating) {

return;

}

if (![self __shouldLoadViewOrLayer]) {

return;

}

if (isLayerBacked) {

TIME_SCOPED(_debugTimeToCreateView);

_layer = [self _layerToLoad];

_layer.delegate = self;

} else {

TIME_SCOPED(_debugTimeToCreateView);

_view = [self _viewToLoad];

_view.asyncdisplaykit_node = self;

_layer = _view.layer;

}

_layer.asyncdisplaykit_node = self;

self.asyncLayer.asyncDelegate = self;

{

TIME_SCOPED(_debugTimeToApplyPendingState);

[self _applyPendingStateToViewOrLayer];

}

{

TIME_SCOPED(_debugTimeToAddSubnodeViews);

[self _addSubnodeViewsAndLayers];

}

{

TIME_SCOPED(_debugTimeForDidLoad);

[self __didLoad];

}

}

- (UIView *)view

{

ASDisplayNodeAssert(!_flags.layerBacked, @"Call to -view undefined on layer-backed nodes");

if (_flags.layerBacked) {

return nil;

}

if (!_view) {

ASDisplayNodeAssertMainThread();

[self _loadViewOrLayerIsLayerBacked:NO];

}

return _view;

}

- (CALayer *)layer

{

if (!_layer) {

ASDisplayNodeAssertMainThread();

if (!_flags.layerBacked) {

return self.view.layer;

}

[self _loadViewOrLayerIsLayerBacked:YES];

}

return _layer;

}

- (_ASDisplayView *)ensureAsyncView

{

return _flags.synchronous ? nil : (_ASDisplayView *)self.view;

}

- (_ASDisplayLayer *)asyncLayer

{

ASDN::MutexLocker l(_propertyLock);

return [_layer isKindOfClass:[_ASDisplayLayer class]] ? (_ASDisplayLayer *)_layer : nil;

}

- (BOOL)isNodeLoaded

{

if (ASDisplayNodeThreadIsMain()) {

// Because the view and layer can only be created and destroyed on Main, that is also the only thread

// where the state of this property can change. As an optimization, we can avoid locking.

return (_view != nil || (_layer != nil && _flags.layerBacked));

} else {

ASDN::MutexLocker l(_propertyLock);

return (_view != nil || (_layer != nil && _flags.layerBacked));

}

}

- (NSString *)name

{

ASDN::MutexLocker l(_propertyLock);

return _name;

}

- (void)setName:(NSString *)name

{

ASDN::MutexLocker l(_propertyLock);

if (!ASObjectIsEqual(_name, name)) {

_name = [name copy];

}

}

- (BOOL)isSynchronous

{

return _flags.synchronous;

}

- (void)setSynchronous:(BOOL)flag

{

_flags.synchronous = flag;

}

- (void)setLayerBacked:(BOOL)isLayerBacked

{

if (![self.class layerBackedNodesEnabled]) return;

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(!_view && !_layer, @"Cannot change isLayerBacked after layer or view has loaded");

ASDisplayNodeAssert(!_viewBlock && !_layerBlock, @"Cannot change isLayerBacked when a layer or view block is provided");

ASDisplayNodeAssert(!_viewClass && !_layerClass, @"Cannot change isLayerBacked when a layer or view class is provided");

if (isLayerBacked != _flags.layerBacked && !_view && !_layer) {

_flags.layerBacked = isLayerBacked;

}

}

- (BOOL)isLayerBacked

{

ASDN::MutexLocker l(_propertyLock);

return _flags.layerBacked;

}

#pragma mark - Layout measurement calculation

- (CGSize)measure:(CGSize)constrainedSize

{

return [self measureWithSizeRange:ASSizeRangeMake(CGSizeZero, constrainedSize)].size;

}

- (ASLayout *)measureWithSizeRange:(ASSizeRange)constrainedSize

{

ASDN::MutexLocker l(_propertyLock);

if (! [self shouldMeasureWithSizeRange:constrainedSize]) {

return _layout;

}

[self cancelLayoutTransitionsInProgress];

ASLayout *previousLayout = _layout;

ASSizeRange previousConstrainedSize = _constrainedSize;

ASLayout *newLayout = [self calculateLayoutThatFits:constrainedSize];

if (ASHierarchyStateIncludesLayoutPending(_hierarchyState)) {

_pendingLayoutContext = [[ASDisplayNodeLayoutContext alloc] initWithNode:self

pendingLayout:newLayout

pendingConstrainedSize:constrainedSize

previousLayout:previousLayout

previousConstrainedSize:previousConstrainedSize];

} else {

ASDisplayNodeLayoutContext *layoutContext;

if (self.usesImplicitHierarchyManagement) {

layoutContext = [[ASDisplayNodeLayoutContext alloc] initWithNode:self

pendingLayout:newLayout

pendingConstrainedSize:constrainedSize

previousLayout:previousLayout

previousConstrainedSize:previousConstrainedSize];

}

[self applyLayout:newLayout constrainedSize:constrainedSize layoutContext:layoutContext];

[self _completeLayoutCalculation];

}

return newLayout;

}

- (BOOL)shouldMeasureWithSizeRange:(ASSizeRange)constrainedSize

{

ASDN::MutexLocker l(_propertyLock);

if (![self __shouldSize]) {

return NO;

}

if (ASHierarchyStateIncludesLayoutPending(_hierarchyState)) {

ASLayoutableContext context = ASLayoutableGetCurrentContext();

if (ASLayoutableContextIsNull(context) || _pendingTransitionID != context.transitionID) {

return NO;

}

}

// only calculate the size if

// - we haven't already

// - the constrained size range is different

return (!_flags.isMeasured || !ASSizeRangeEqualToSizeRange(constrainedSize, _constrainedSize));

}

#pragma mark - Layout Transition

- (void)transitionLayoutWithAnimation:(BOOL)animated

shouldMeasureAsync:(BOOL)shouldMeasureAsync

measurementCompletion:(void(^)())completion

{

ASSizeRange currentConstrainedSize = _constrainedSize;

[self invalidateCalculatedLayout];

[self transitionLayoutWithSizeRange:currentConstrainedSize

animated:animated

shouldMeasureAsync:shouldMeasureAsync

measurementCompletion:completion];

}

- (void)transitionLayoutWithSizeRange:(ASSizeRange)constrainedSize

animated:(BOOL)animated

shouldMeasureAsync:(BOOL)shouldMeasureAsync

measurementCompletion:(void(^)())completion

{

ASDisplayNodeAssertMainThread();

if (! [self shouldMeasureWithSizeRange:constrainedSize]) {

return;

}

{

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(ASHierarchyStateIncludesLayoutPending(_hierarchyState) == NO, @"Can't start a transition when one of the supernodes is performing one.");

}

int32_t transitionID = [self _startNewTransition];

ASDisplayNodePerformBlockOnEverySubnode(self, ^(ASDisplayNode * _Nonnull node) {

ASDisplayNodeAssert([node _hasTransitionInProgress] == NO, @"Can't start a transition when one of the subnodes is performing one.");

node.hierarchyState |= ASHierarchyStateLayoutPending;

node.pendingTransitionID = transitionID;

});

void (^transitionBlock)() = ^{

if ([self _shouldAbortTransitionWithID:transitionID]) {

return;

}

ASLayout *newLayout;

{

ASLayoutableSetCurrentContext(ASLayoutableContextMake(transitionID, NO));

ASDN::MutexLocker l(_propertyLock);

BOOL disableImplicitHierarchyManagement = self.usesImplicitHierarchyManagement == NO;

self.usesImplicitHierarchyManagement = YES; // Temporary flag for 1.9.x

newLayout = [self calculateLayoutThatFits:constrainedSize];

if (disableImplicitHierarchyManagement) {

self.usesImplicitHierarchyManagement = NO; // Temporary flag for 1.9.x

}

ASLayoutableClearCurrentContext();

}

if ([self _shouldAbortTransitionWithID:transitionID]) {

return;

}

ASPerformBlockOnMainThread(^{

// Grab _propertyLock here to make sure this transition isn't invalidated

// right after it passed the validation test and before it proceeds

ASDN::MutexLocker l(_propertyLock);

if ([self _shouldAbortTransitionWithID:transitionID]) {

return;

}

ASLayout *previousLayout = _layout;

ASSizeRange previousConstrainedSize = _constrainedSize;

[self applyLayout:newLayout constrainedSize:constrainedSize layoutContext:nil];

ASDisplayNodePerformBlockOnEverySubnode(self, ^(ASDisplayNode * _Nonnull node) {

[node applyPendingLayoutContext];

[node _completeLayoutCalculation];

node.hierarchyState &= (~ASHierarchyStateLayoutPending);

});

[self _finishOrCancelTransition];

if (completion) {

completion();

}

_pendingLayoutContext = [[ASDisplayNodeLayoutContext alloc] initWithNode:self

pendingLayout:newLayout

pendingConstrainedSize:constrainedSize

previousLayout:previousLayout

previousConstrainedSize:previousConstrainedSize];

[_pendingLayoutContext applySubnodeInsertions];

_transitionContext = [[_ASTransitionContext alloc] initWithAnimation:animated

layoutDelegate:_pendingLayoutContext

completionDelegate:self];

[self animateLayoutTransition:_transitionContext];

});

};

if (shouldMeasureAsync) {

ASPerformBlockOnBackgroundThread(transitionBlock);

} else {

transitionBlock();

}

}

- (void)_completeLayoutCalculation

{

ASDN::MutexLocker l(_propertyLock);

[self calculatedLayoutDidChange];

// We generate placeholders at measureWithSizeRange: time so that a node is guaranteed to have a placeholder ready to go.

// This is also because measurement is usually asynchronous, but placeholders need to be set up synchronously.

// First measurement is guaranteed to be before the node is onscreen, so we can create the image async. but still have it appear sync.

if (_placeholderEnabled && [self _displaysAsynchronously] && self.contents == nil) {

// Zero-sized nodes do not require a placeholder.

CGSize layoutSize = (_layout ? _layout.size : CGSizeZero);

if (CGSizeEqualToSize(layoutSize, CGSizeZero)) {

return;

}

if (!_placeholderImage) {

_placeholderImage = [self placeholderImage];

}

}

}

- (void)calculatedLayoutDidChange

{

// subclass override

}

- (void)cancelLayoutTransitionsInProgress

{

ASDN::MutexLocker l(_propertyLock);

if ([self _hasTransitionInProgress]) {

// Cancel transition in progress

[self _finishOrCancelTransition];

// Tell subnodes to exit layout pending state and clear related properties

ASDisplayNodePerformBlockOnEverySubnode(self, ^(ASDisplayNode * _Nonnull node) {

node.hierarchyState &= (~ASHierarchyStateLayoutPending);

});

}

}

- (BOOL)usesImplicitHierarchyManagement

{

ASDN::MutexLocker l(_propertyLock);

return _usesImplicitHierarchyManagement ? : [[self class] usesImplicitHierarchyManagement];

}

- (void)setUsesImplicitHierarchyManagement:(BOOL)value

{

ASDN::MutexLocker l(_propertyLock);

_usesImplicitHierarchyManagement = value;

}

- (BOOL)_hasTransitionInProgress

{

ASDN::MutexLocker l(_propertyLock);

return _transitionInProgress;

}

- (int32_t)_startNewTransition

{

ASDN::MutexLocker l(_propertyLock);

_transitionInProgress = YES;

_transitionID = OSAtomicAdd32(1, &_transitionID);

return _transitionID;

}

- (void)_finishOrCancelTransition

{

ASDN::MutexLocker l(_propertyLock);

_transitionInProgress = NO;

}

- (BOOL)_shouldAbortTransitionWithID:(int32_t)transitionID

{

ASDN::MutexLocker l(_propertyLock);

return (!_transitionInProgress || _transitionID != transitionID);

}

- (void)animateLayoutTransition:(id<ASContextTransitioning>)context

{

[self __layoutSublayouts];

[context completeTransition:YES];

}

- (void)didCompleteLayoutTransition:(id<ASContextTransitioning>)context

{

[_pendingLayoutContext applySubnodeRemovals];

[self _completeLayoutCalculation];

_pendingLayoutContext = nil;

}

#pragma mark - _ASTransitionContextCompletionDelegate

- (void)transitionContext:(_ASTransitionContext *)context didComplete:(BOOL)didComplete

{

[self didCompleteLayoutTransition:context];

_transitionContext = nil;

}

#pragma mark - Asynchronous display

- (BOOL)displaysAsynchronously

{

ASDN::MutexLocker l(_propertyLock);

return [self _displaysAsynchronously];

}

- (BOOL)_displaysAsynchronously

{

ASDisplayNodeAssertThreadAffinity(self);

return _flags.synchronous == NO && _flags.displaysAsynchronously;

}

- (void)setDisplaysAsynchronously:(BOOL)displaysAsynchronously

{

ASDisplayNodeAssertThreadAffinity(self);

// Can't do this for synchronous nodes (using layers that are not _ASDisplayLayer and so we can't control display prevention/cancel)

if (_flags.synchronous)

return;

ASDN::MutexLocker l(_propertyLock);

if (_flags.displaysAsynchronously == displaysAsynchronously)

return;

_flags.displaysAsynchronously = displaysAsynchronously;

self.asyncLayer.displaysAsynchronously = displaysAsynchronously;

}

- (BOOL)shouldRasterizeDescendants

{

ASDN::MutexLocker l(_propertyLock);

ASDisplayNodeAssert(!((_hierarchyState & ASHierarchyStateRasterized) && _flags.shouldRasterizeDescendants),

@"Subnode of a rasterized node should not have redundant shouldRasterizeDescendants enabled");

return _flags.shouldRasterizeDescendants;

}

- (void)setShouldRasterizeDescendants:(BOOL)shouldRasterize

{

ASDisplayNodeAssertThreadAffinity(self);

{

ASDN::MutexLocker l(_propertyLock);

if (_flags.shouldRasterizeDescendants == shouldRasterize)

return;

_flags.shouldRasterizeDescendants = shouldRasterize;

}

if (self.isNodeLoaded) {

// Recursively tear down or build up subnodes.

// TODO: When disabling rasterization, preserve rasterized backing store as placeholderImage

// while the newly materialized subtree finishes rendering. Then destroy placeholderImage to save memory.

[self recursivelyClearContents];

ASDisplayNodePerformBlockOnEverySubnode(self, ^(ASDisplayNode *node) {

if (shouldRasterize) {

[node enterHierarchyState:ASHierarchyStateRasterized];

[node __unloadNode];

} else {

[node exitHierarchyState:ASHierarchyStateRasterized];

[node __loadNode];

}

});

if (!shouldRasterize) {

// At this point all of our subnodes have their layers or views recreated, but we haven't added

// them to ours yet. This is because our node is already loaded, and the above recursion

// is only performed on our subnodes -- not self.

[self _addSubnodeViewsAndLayers];

}

if (self.interfaceState & ASInterfaceStateVisible) {

// TODO: Change this to recursivelyEnsureDisplay - but need a variant that does not skip

// nodes that have shouldBypassEnsureDisplay set (such as image nodes) so they are rasterized.

[self recursivelyDisplayImmediately];

}

} else {

ASDisplayNodePerformBlockOnEverySubnode(self, ^(ASDisplayNode *node) {

if (shouldRasterize) {

[node enterHierarchyState:ASHierarchyStateRasterized];

} else {

[node exitHierarchyState:ASHierarchyStateRasterized];

}

});

}

}

- (CGFloat)contentsScaleForDisplay

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

return _contentsScaleForDisplay;

}

- (void)setContentsScaleForDisplay:(CGFloat)contentsScaleForDisplay

{

ASDisplayNodeAssertThreadAffinity(self);

ASDN::MutexLocker l(_propertyLock);

if (_contentsScaleForDisplay == contentsScaleForDisplay)

return;

_contentsScaleForDisplay = contentsScaleForDisplay;

}

- (void)applyPendingViewState

{

ASDisplayNodeAssertMainThread();

ASDN::MutexLocker l(_propertyLock);

// FIXME: Ideally we'd call this as soon as the node receives -setNeedsLayout

// but implicit hierarchy management would require us to modify the node tree

// in the background on a loaded node, which isn't currently supported.

if (_pendingViewState.hasSetNeedsLayout) {

[self __setNeedsLayout];

}

if (self.layerBacked) {

[_pendingViewState applyToLayer:self.layer];

} else {

BOOL specialPropertiesHandling = ASDisplayNodeNeedsSpecialPropertiesHandlingForFlags(_flags);

[_pendingViewState applyToView:self.view withSpecialPropertiesHandling:specialPropertiesHandling];

}

[_pendingViewState clearChanges];

}