@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.1

package/ios/Animations/ANNAnimationRules.h

@@ -0,0 +1,72 @@
+#import <Foundation/Foundation.h>
+
+@class ANNEnterExitScreenAnimationOptions;
+@class ANNElementTransitionOptions;
+@class ANNModalAnimationOptions;
+@class ANNSharedElementTransitionOptions;
+@class ANNStackAnimationOptions;
+@class ANNViewAnimationOptions;
+@class Double;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The duration of a property, an element and a shared pair when the options give none, in seconds.
+FOUNDATION_EXPORT const NSTimeInterval ANNAnimationDefaultDuration;
+
+/// How long a custom forward transition waits for its content and targets, in seconds: 0,5 s.
+FOUNDATION_EXPORT const NSTimeInterval ANNCustomTransitionWaitLimit;
+
+/// The one place of the rules on the animation options: what plays, what makes a transition the core's own, how long it
+/// lasts. Pure: options in, answers out.
+@interface ANNAnimationRules : NSObject
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// A property animates: `from` or `to` has a value.
++ (BOOL)propertyPlaysFrom:(nullable Double *)from to:(nullable Double *)to;
+
+/// A side plays: not `enabled: false` (for the sides that have the flag) and at least one property animates.
++ (BOOL)sidePlays:(nullable ANNViewAnimationOptions *)side;
+
+/// The side, when it plays; else nil (a side without its own animation doesn't move).
++ (nullable ANNViewAnimationOptions *)playingSide:(nullable ANNViewAnimationOptions *)side;
+
+/// A stack's change (push, pop, setStackRoot) has its own animation: `content.enter` or `content.exit` plays, or a
+/// list of shared elements or elements is not empty. `topBar`, `bottomTabs` and `zoom` never make it own; `[]` is no
+/// list.
++ (BOOL)stackIsOwn:(nullable ANNStackAnimationOptions *)animation;
+
+/// A modal's show or dismissal has its own animation: `enter` or `exit` plays, or a list is not empty.
++ (BOOL)modalIsOwn:(nullable ANNModalAnimationOptions *)animation;
+
+/// A `setRoot` has its own animation: a side plays (`'none'` turns both off).
++ (BOOL)rootPlays:(nullable ANNEnterExitScreenAnimationOptions *)animation;
+
+/// `showModal.enter.enabled: false`, `dismissModal.exit.enabled: false`: the whole command goes without an animation;
+/// the root's `enter.enabled: false` shows it at once.
++ (BOOL)sideIsDisabled:(nullable ANNViewAnimationOptions *)side;
+
+/// The lists have an item.
++ (BOOL)hasElements:(nullable NSArray<ANNElementTransitionOptions *> *)elements
+             shared:(nullable NSArray<ANNSharedElementTransitionOptions *> *)shared;
+
+/// The custom transition's wait after a command's own wait of `commandLimit` that started at `started` (host time; 0:
+/// none ran): what is left of the command's limit, at least the 0,1 s test; `ANNCustomTransitionWaitLimit` when no such
+/// wait ran.
++ (NSTimeInterval)customWaitLimitAfterWaitStartedAt:(CFTimeInterval)started
+                                       commandLimit:(NSTimeInterval)commandLimit;
+
+#pragma mark - Lengths
+
+/// The latest end of a side's playing properties: max(`startDelay` + `duration`), 300 ms where `duration` is unset; 0
+/// when nothing plays. Seconds.
++ (NSTimeInterval)lengthOfSide:(nullable ANNViewAnimationOptions *)side;
+
+/// The latest end of the configured elements' animating properties and of the shared pairs (300 ms defaults). Seconds.
++ (NSTimeInterval)lengthOfElements:(nullable NSArray<ANNElementTransitionOptions *> *)elements
+                            shared:(nullable NSArray<ANNSharedElementTransitionOptions *> *)shared;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Animations/ANNAnimationRules.mm

@@ -0,0 +1,122 @@
+#import "ANNAnimationRules.h"
+#import "ANNBottomTabsAnimationOptions.h"
+#import "ANNModalAnimationOptions.h"
+#import "ANNScreenAnimationOptions.h"
+#import "ANNStackAnimationOptions.h"
+#import "ANNTopBarAnimationOptions.h"
+#import "ANNTrack.h"
+#import "ANNViewAnimationOptions.h"
+#import <QuartzCore/QuartzCore.h>
+
+const NSTimeInterval ANNAnimationDefaultDuration = 0.3;
+const NSTimeInterval ANNCustomTransitionWaitLimit = 0.5;
+
+// The custom wait's test of a destination that is ready already: the least it takes.
+static const NSTimeInterval ANNCustomTransitionWaitLeast = 0.1;
+
+@implementation ANNAnimationRules
+
++ (BOOL)propertyPlaysFrom:(Double *)from to:(Double *)to {
+    return from.hasValue || to.hasValue;
+}
+
++ (NSTimeInterval)customWaitLimitAfterWaitStartedAt:(CFTimeInterval)started
+                                       commandLimit:(NSTimeInterval)commandLimit {
+    if (started <= 0) {
+        return ANNCustomTransitionWaitLimit;
+    }
+    NSTimeInterval left = commandLimit - (CACurrentMediaTime() - started);
+    return MAX(left, ANNCustomTransitionWaitLeast);
+}
+
++ (BOOL)sideIsDisabled:(ANNViewAnimationOptions *)side {
+    Bool *enabled = nil;
+    if ([side isKindOfClass:ANNScreenAnimationOptions.class]) {
+        enabled = ((ANNScreenAnimationOptions *)side).enabled;
+    } else if ([side isKindOfClass:ANNTopBarAnimationOptions.class]) {
+        enabled = ((ANNTopBarAnimationOptions *)side).enabled;
+    } else if ([side isKindOfClass:ANNBottomTabsAnimationOptions.class]) {
+        enabled = ((ANNBottomTabsAnimationOptions *)side).enabled;
+    }
+    return enabled.hasValue && !enabled.get;
+}
+
++ (BOOL)sidePlays:(ANNViewAnimationOptions *)side {
+    if (!side || [self sideIsDisabled:side]) {
+        return NO;
+    }
+    for (ANNAnimationPropertyOptions *property in side.animatedProperties) {
+        if ([self propertyPlaysFrom:property.from to:property.to]) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
++ (ANNViewAnimationOptions *)playingSide:(ANNViewAnimationOptions *)side {
+    return [self sidePlays:side] ? side : nil;
+}
+
++ (BOOL)hasElements:(NSArray<ANNElementTransitionOptions *> *)elements
+             shared:(NSArray<ANNSharedElementTransitionOptions *> *)shared {
+    return elements.count > 0 || shared.count > 0;
+}
+
++ (BOOL)stackIsOwn:(ANNStackAnimationOptions *)animation {
+    if (!animation) {
+        return NO;
+    }
+    return [self sidePlays:animation.content.enter] || [self sidePlays:animation.content.exit] ||
+           [self hasElements:animation.elementTransitions
+                      shared:animation.sharedElementTransitions];
+}
+
++ (BOOL)modalIsOwn:(ANNModalAnimationOptions *)animation {
+    if (!animation) {
+        return NO;
+    }
+    return [self sidePlays:animation.enter] || [self sidePlays:animation.exit] ||
+           [self hasElements:animation.elementTransitions
+                      shared:animation.sharedElementTransitions];
+}
+
++ (BOOL)rootPlays:(ANNEnterExitScreenAnimationOptions *)animation {
+    return [self sidePlays:animation.enter] || [self sidePlays:animation.exit];
+}
+
++ (NSTimeInterval)endOfDuration:(Double *)duration delay:(Double *)delay {
+    return ANNSecondsOf(delay, 0) + ANNSecondsOf(duration, ANNAnimationDefaultDuration);
+}
+
++ (NSTimeInterval)lengthOfSide:(ANNViewAnimationOptions *)side {
+    if (![self sidePlays:side]) {
+        return 0;
+    }
+    NSTimeInterval length = 0;
+    for (ANNAnimationPropertyOptions *property in side.animatedProperties) {
+        if ([self propertyPlaysFrom:property.from to:property.to]) {
+            length = MAX(length, [self endOfDuration:property.duration delay:property.startDelay]);
+        }
+    }
+    return length;
+}
+
++ (NSTimeInterval)lengthOfElements:(NSArray<ANNElementTransitionOptions *> *)elements
+                            shared:(NSArray<ANNSharedElementTransitionOptions *> *)shared {
+    NSTimeInterval length = 0;
+    for (ANNElementTransitionOptions *element in elements) {
+        for (ANNElementAnimationOptions *property in element.animatedProperties) {
+            if ([self propertyPlaysFrom:property.from to:property.to]) {
+                NSTimeInterval end = [self endOfDuration:property.duration
+                                                   delay:property.startDelay];
+                length = MAX(length, end);
+            }
+        }
+    }
+    for (ANNSharedElementTransitionOptions *pair in shared) {
+        length = MAX(length, [self endOfDuration:pair.duration delay:pair.startDelay]);
+    }
+    return length;
+}
+
+@end

package/ios/Animations/ANNFrameDriver.h

@@ -0,0 +1,46 @@
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// What a frame driver moves: a view's properties (`ANNViewTracks`), an element, a shared element's copy. Each frame it
+/// writes its values at the time from the transition's start; past its end it holds its end values.
+@protocol ANNFrameClient <NSObject>
+
+/// The values at `time`, in seconds from the start of the transition.
+- (void)applyAtTime:(NSTimeInterval)time;
+
+/// The time from which the client holds its end values.
+@property(nonatomic, readonly) NSTimeInterval endTime;
+
+/// Every value the client wrote goes back as it was read before the transition (also at a cancel); a client that made
+/// views of its own removes them. Once; later calls do nothing.
+- (void)restore;
+
+@end
+
+/// The frames of one running transition: one `CADisplayLink` in the common modes of the run loop, so frames go on while
+/// a finger drags a scroll view; the time is the link's `targetTimestamp` from the start (monotonic host time). Each
+/// frame every client writes its values; once the time reached `length` and every client its end, the clients write
+/// their ends, the link stops and `done` runs once. No `CATransaction` waits. Main queue.
+@interface ANNFrameDriver : NSObject
+
+- (instancetype)initWithClients:(NSArray<id<ANNFrameClient>> *)clients
+                         length:(NSTimeInterval)length NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+/// The clients write their values of time 0 now (the first frame shows the start values), and the frames start. `done`
+/// comes on a later frame, never inside this call.
+- (void)startWithDone:(dispatch_block_t)done;
+
+/// The transition stops where it is (a destroy, a reload, a newer `setRoot`): the clients write their end values, the
+/// link stops, `done` never runs. The caller restores the clients.
+- (void)cancel;
+
+/// The frames run.
+@property(nonatomic, readonly) BOOL isRunning;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Animations/ANNFrameDriver.mm

@@ -0,0 +1,126 @@
+#import "ANNFrameDriver.h"
+#import "ANNAssert.h"
+#import "ANNCurve.h"
+#import <QuartzCore/QuartzCore.h>
+
+// The display link holds its target strongly and the run loop holds the link: the driver is reached weakly, so a driver
+// nobody keeps any more stops at its next frame.
+@interface ANNFrameTarget : NSObject
+@property(nonatomic, weak) id owner;
+@end
+
+@interface ANNFrameDriver ()
+- (void)frame:(CADisplayLink *)link;
+@end
+
+@implementation ANNFrameTarget
+
+- (void)frame:(CADisplayLink *)link {
+    ANNFrameDriver *driver = _owner;
+    if (!driver) {
+        [link invalidate];
+        return;
+    }
+    [driver frame:link];
+}
+
+@end
+
+@implementation ANNFrameDriver {
+    NSArray<id<ANNFrameClient>> *_clients;
+    NSTimeInterval _length;
+    CADisplayLink *_link;
+    CFTimeInterval _start;
+    dispatch_block_t _done;
+    // The driver keeps itself while its frames run: the transition that started it needn't.
+    ANNFrameDriver *_running;
+}
+
+- (instancetype)initWithClients:(NSArray<id<ANNFrameClient>> *)clients
+                         length:(NSTimeInterval)length {
+    if (self = [super init]) {
+        _clients = [clients copy];
+        NSTimeInterval end = length > 0 ? length : 0;
+        for (id<ANNFrameClient> client in _clients) {
+            end = MAX(end, client.endTime);
+        }
+        _length = end;
+    }
+    return self;
+}
+
+- (BOOL)isRunning {
+    return _link != nil;
+}
+
+- (void)startWithDone:(dispatch_block_t)done {
+    ANNAssertMainQueue();
+#if DEBUG
+    ANNCurveSelfCheck();
+#endif
+    if (_link) {
+        return;
+    }
+    _done = [done copy];
+    _running = self;
+    [self applyAtTime:0];
+    ANNFrameTarget *target = [ANNFrameTarget new];
+    target.owner = self;
+    _link = [CADisplayLink displayLinkWithTarget:target selector:@selector(frame:)];
+    [_link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    _start = CACurrentMediaTime();
+}
+
+- (void)frame:(CADisplayLink *)link {
+    if (link != _link) {
+        [link invalidate];
+        return;
+    }
+    NSTimeInterval time = link.targetTimestamp - _start;
+    if (time < 0) {
+        time = 0;
+    }
+    if (time >= _length) {
+        [self applyAtTime:_length];
+        [self stop];
+        dispatch_block_t done = _done;
+        _done = nil;
+        _running = nil;
+        if (done) {
+            done();
+        }
+        return;
+    }
+    [self applyAtTime:time];
+}
+
+- (void)applyAtTime:(NSTimeInterval)time {
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    for (id<ANNFrameClient> client in _clients) {
+        [client applyAtTime:time];
+    }
+    [CATransaction commit];
+}
+
+- (void)stop {
+    [_link invalidate];
+    _link = nil;
+}
+
+- (void)cancel {
+    ANNAssertMainQueue();
+    if (!_link) {
+        return;
+    }
+    [self applyAtTime:_length];
+    [self stop];
+    _done = nil;
+    _running = nil;
+}
+
+- (void)dealloc {
+    [_link invalidate];
+}
+
+@end

package/ios/Animations/ANNTransitionAnimator.h

@@ -0,0 +1,34 @@
+#import <UIKit/UIKit.h>
+
+@class ANNTransitionPlan;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The one transition object of the core's custom transitions, for the stack (its navigation delegate) and for modals
+/// (their transitioning delegate). UIKit's duration is the plan's length, so the bars move along with it.
+///
+/// The views are the context's (`viewForKey:`), not the controllers': a popover's is its presentation view, and a
+/// screen under a modal is in the transition only for a full-screen modal. The arriving view goes into the container
+/// above the leaving one (push, `setStackRoot`, show) or below it (pop, dismissal), gets its final frame and lays out
+/// (React gets its final size), and hides (alpha 0) until the start; a forward transition starts after its wait
+/// (`ANNTransitionWait`), a backward one at once. Then one frame driver moves the sides that play, the elements in
+/// place and the shared elements' copies; a side that doesn't play doesn't move. At the end, before
+/// `completeTransition:`, the elements get their values back, the copies go and the React views show again, and both
+/// views get back the transform and the alpha they had. Never interactive, never cancelled; `completeTransition:` never
+/// comes inside `animateTransition:`. Main queue.
+@interface ANNTransitionAnimator : NSObject <UIViewControllerAnimatedTransitioning>
+
+- (instancetype)initWithPlan:(ANNTransitionPlan *)plan NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@property(nonatomic, strong, readonly) ANNTransitionPlan *plan;
+
+/// A destroy or a reload during the transition: the wait or the frames stop at the end state, every value written goes
+/// back, and the transition completes so that UIKit isn't left half way. Nothing once it completed.
+- (void)cancel;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Animations/ANNTransitionAnimator.mm

@@ -0,0 +1,293 @@
+#import "ANNTransitionAnimator.h"
+#import "ANNAssert.h"
+#import "ANNComponentViewController.h"
+#import "ANNElementFinder.h"
+#import "ANNElementTransition.h"
+#import "ANNFrameDriver.h"
+#import "ANNSharedElementFlight.h"
+#import "ANNStackQueue.h"
+#import "ANNTransitionPlan.h"
+#import "ANNTransitionWait.h"
+#import "ANNViewAnimationOptions.h"
+#import "ANNViewTracks.h"
+#import "UIViewController+LayoutProtocol.h"
+
+// The screens of a node that lays out in the transition take their root frame for the final size now: a stack lays out
+// its new top only after UIKit's start, which comes inside this transition (finding 9).
+static void ANNUpdateRootLayoutOf(UIViewController *node) {
+    for (ANNComponentViewController *screen in ANNStackScreensOfEntry(node)) {
+        [screen updateRootLayout];
+    }
+}
+
+@implementation ANNTransitionAnimator {
+    id<UIViewControllerContextTransitioning> _context;
+    UIView *_arriving;
+    UIView *_leaving;
+    CGFloat _arrivingAlpha;
+    CGFloat _leavingAlpha;
+    CATransform3D _arrivingTransform;
+    CATransform3D _leavingTransform;
+    ANNTransitionWait *_wait;
+    ANNFrameDriver *_driver;
+    NSArray<id<ANNFrameClient>> *_clients;
+    BOOL _began;
+    BOOL _completed;
+    // The container's views of the transition that got a depth for it, and the depth each had.
+    NSArray<UIView *> *_depthViews;
+    NSArray<NSNumber *> *_depthsBefore;
+}
+
+- (instancetype)initWithPlan:(ANNTransitionPlan *)plan {
+    if (self = [super init]) {
+        _plan = plan;
+    }
+    return self;
+}
+
+#pragma mark - UIViewControllerAnimatedTransitioning
+
+- (NSTimeInterval)transitionDuration:(id<UIViewControllerContextTransitioning>)transitionContext {
+    return _plan.length;
+}
+
+- (void)animateTransition:(id<UIViewControllerContextTransitioning>)transitionContext {
+    ANNAssertMainQueue();
+    _context = transitionContext;
+    UIView *container = transitionContext.containerView;
+    UIViewController *fromController =
+        [transitionContext viewControllerForKey:UITransitionContextFromViewControllerKey];
+    UIViewController *toController =
+        [transitionContext viewControllerForKey:UITransitionContextToViewControllerKey];
+    UIView *fromView = [transitionContext viewForKey:UITransitionContextFromViewKey];
+    UIView *toView = [transitionContext viewForKey:UITransitionContextToViewKey];
+    ANNTransitionKind kind = _plan.kind;
+    // The modal itself is always in its transition; the screen under it only where the context gives its view.
+    if (!toView && kind == ANNTransitionKindPresent) {
+        toView = toController.view;
+    }
+    if (!fromView && kind == ANNTransitionKindDismiss) {
+        fromView = fromController.view;
+    }
+    _arriving = toView;
+    _leaving = fromView;
+    // A view the presentation controller placed already (a popover's) stays where it is.
+    if (toView && !toView.superview) {
+        if (_plan.isForward) {
+            if (fromView.superview == container) {
+                [container insertSubview:toView aboveSubview:fromView];
+            } else {
+                [container addSubview:toView];
+            }
+        } else if (fromView.superview == container) {
+            [container insertSubview:toView belowSubview:fromView];
+        } else {
+            [container insertSubview:toView atIndex:0];
+        }
+    }
+    if (toView) {
+        // A presentation view around the controller's (a popover's) is placed by its presentation controller.
+        if (toView == toController.view) {
+            CGRect frame = [transitionContext finalFrameForViewController:toController];
+            if (!CGRectIsEmpty(frame)) {
+                toView.frame = frame;
+            }
+        }
+        [toView layoutIfNeeded];
+        if (toController) {
+            ANNUpdateRootLayoutOf(toController);
+        }
+        // The alpha the arriving view had, before it hides to the start: the core's waits never change it (a waiting
+        // view is parked, not hidden).
+        _arrivingAlpha = toView.alpha;
+        _arrivingTransform = toView.layer.transform;
+        toView.alpha = 0;
+    }
+    if (fromView) {
+        _leavingAlpha = fromView.alpha;
+        _leavingTransform = fromView.layer.transform;
+    }
+    __weak ANNTransitionAnimator *weakSelf = self;
+    if (_plan.waits) {
+        _wait = [[ANNTransitionWait alloc] initWithPlan:_plan];
+        [_wait startThen:^{
+          [weakSelf begin];
+        }];
+        return;
+    }
+    [self begin];
+}
+
+- (void)animationEnded:(BOOL)transitionCompleted {
+    _wait = nil;
+    _driver = nil;
+    _clients = nil;
+}
+
+#pragma mark - The frames
+
+- (void)begin {
+    if (_began || _completed || !_context) {
+        return;
+    }
+    _began = YES;
+    _wait = nil;
+    UIView *container = _context.containerView;
+    UIView *leavingRoot = [ANNElementFinder searchRootOf:_plan.fromNode];
+    UIView *arrivingRoot = [ANNElementFinder searchRootOf:_plan.toNode];
+    NSMutableArray<id<ANNFrameClient>> *clients = [NSMutableArray new];
+    // The shared pairs first: their geometry and pictures are taken while the screens are still at rest.
+    NSArray<ANNSharedElementFlight *> *flights =
+        [ANNSharedElementFlight flightsOf:_plan.sharedElements
+                              leavingRoot:leavingRoot
+                             arrivingRoot:arrivingRoot
+                                container:container];
+    NSArray<ANNElementTransition *> *elements =
+        [ANNElementTransition transitionsOf:_plan.elements
+                                leavingRoot:leavingRoot
+                               arrivingRoot:arrivingRoot];
+    ANNViewTracks *arrivingTracks = nil;
+    ANNViewTracks *leavingTracks = nil;
+    if (_plan.enter && _arriving) {
+        arrivingTracks = [[ANNViewTracks alloc] initWithView:_arriving
+                                                        side:_plan.enter
+                                                 alphaBefore:_arrivingAlpha];
+    }
+    if (_plan.exit && _leaving) {
+        leavingTracks = [[ANNViewTracks alloc] initWithView:_leaving
+                                                       side:_plan.exit
+                                                alphaBefore:_leavingAlpha];
+    }
+    switch (_plan.screenFade) {
+        case ANNScreenFadeArrivingIn:
+            if (_arriving) {
+                arrivingTracks = [[ANNViewTracks alloc] initWithView:_arriving
+                                                            fadeFrom:0
+                                                                  to:_arrivingAlpha
+                                                            duration:_plan.screenFadeDuration
+                                                         alphaBefore:_arrivingAlpha];
+            }
+            break;
+        case ANNScreenFadeLeavingOut:
+            if (_leaving) {
+                leavingTracks = [[ANNViewTracks alloc] initWithView:_leaving
+                                                           fadeFrom:_leavingAlpha
+                                                                 to:0
+                                                           duration:_plan.screenFadeDuration
+                                                        alphaBefore:_leavingAlpha];
+            }
+            break;
+        case ANNScreenFadeNone:
+            break;
+    }
+    BOOL nothingPlays = !arrivingTracks.hasTracks && !leavingTracks.hasTracks &&
+                        flights.count == 0 && elements.count == 0;
+    // A dismissed popover with nothing to play fades out over the length.
+    if (nothingPlays && _plan.fadesWhenNothingPlays && _leaving && _plan.length > 0) {
+        leavingTracks = [[ANNViewTracks alloc] initWithView:_leaving
+                                                   fadeFrom:_leavingAlpha
+                                                         to:0
+                                                   duration:_plan.length
+                                                alphaBefore:_leavingAlpha];
+    }
+    // The arriving view shows from the start with its own alpha unless a track moves it.
+    if (_arriving && !arrivingTracks.animatesAlpha) {
+        _arriving.alpha = _arrivingAlpha;
+    }
+    if (arrivingTracks.hasTracks) {
+        [clients addObject:arrivingTracks];
+    }
+    if (leavingTracks.hasTracks) {
+        [clients addObject:leavingTracks];
+    }
+    [clients addObjectsFromArray:elements];
+    [clients addObjectsFromArray:flights];
+    _clients = clients;
+    if ([self tilts]) {
+        [self orderInDepthIn:container flights:flights];
+    }
+    __weak ANNTransitionAnimator *weakSelf = self;
+    _driver = [[ANNFrameDriver alloc] initWithClients:clients length:_plan.length];
+    [_driver startWithDone:^{
+      [weakSelf complete];
+    }];
+}
+
+// A side tilts (`rotationX`, `rotationY`): Core Animation would cut the tilted screen with the other one in 3D, while
+// Android draws views in their order.
+static BOOL ANNSideTilts(ANNViewAnimationOptions *side) {
+    return side.rotationX.from.hasValue || side.rotationX.to.hasValue ||
+           side.rotationY.from.hasValue || side.rotationY.to.hasValue;
+}
+
+- (BOOL)tilts {
+    return ANNSideTilts(_plan.enter) || ANNSideTilts(_plan.exit);
+}
+
+// The transition's own views in the container (the screens' or presentation views, the copies; never a React view) get
+// depths in their order, apart by more than any tilt reaches, so each one is drawn over the ones before it as on
+// Android; `complete` puts the depths back.
+- (void)orderInDepthIn:(UIView *)container flights:(NSArray<ANNSharedElementFlight *> *)flights {
+    NSHashTable<UIView *> *own = [NSHashTable weakObjectsHashTable];
+    if (_arriving) {
+        [own addObject:_arriving];
+    }
+    if (_leaving) {
+        [own addObject:_leaving];
+    }
+    for (ANNSharedElementFlight *flight in flights) {
+        [own addObject:flight.copyView];
+    }
+    CGFloat step = MAX(container.bounds.size.width, container.bounds.size.height);
+    NSMutableArray<UIView *> *views = [NSMutableArray new];
+    NSMutableArray<NSNumber *> *depths = [NSMutableArray new];
+    for (UIView *view in container.subviews) {
+        if (![own containsObject:view]) {
+            continue;
+        }
+        [views addObject:view];
+        [depths addObject:@(view.layer.zPosition)];
+        view.layer.zPosition = step * views.count;
+    }
+    _depthViews = views;
+    _depthsBefore = depths;
+}
+
+// Everything the transition wrote goes back before UIKit completes it.
+- (void)complete {
+    if (_completed || !_context) {
+        return;
+    }
+    _completed = YES;
+    for (NSUInteger index = 0; index < _depthViews.count; index++) {
+        _depthViews[index].layer.zPosition = (CGFloat)_depthsBefore[index].doubleValue;
+    }
+    _depthViews = nil;
+    for (id<ANNFrameClient> client in _clients) {
+        [client restore];
+    }
+    if (_arriving) {
+        _arriving.alpha = _arrivingAlpha;
+        _arriving.layer.transform = _arrivingTransform;
+    }
+    if (_leaving) {
+        _leaving.alpha = _leavingAlpha;
+        _leaving.layer.transform = _leavingTransform;
+    }
+    id<UIViewControllerContextTransitioning> context = _context;
+    _context = nil;
+    [context completeTransition:!context.transitionWasCancelled];
+}
+
+- (void)cancel {
+    ANNAssertMainQueue();
+    if (_completed || !_context) {
+        return;
+    }
+    [_wait cancel];
+    _wait = nil;
+    [_driver cancel];
+    [self complete];
+}
+
+@end