@apexnative/navigation 1.0.0-alpha.6 → 1.0.0-alpha.8

package/ios/Animations/ANNFrameDriver.h

@@ -1,27 +1,47 @@
+#import <QuartzCore/QuartzCore.h>
 #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.
+/// What a frame driver moves: a view's properties (`ANNViewTracks`), an element, a shared element's copy. It gives its
+/// values for the whole transition at once, as Core Animation's animations on its layers (`ANNKeyframes`); past its end
+/// they hold its end values.
 @protocol ANNFrameClient <NSObject>
 
-/// The values at `time`, in seconds from the start of the transition.
-- (void)applyAtTime:(NSTimeInterval)time;
+/// The client's animations for a transition of `length` seconds go onto its layers, all inside the driver's
+/// transaction, so they start together.
+- (void)addAnimationsWithLength:(NSTimeInterval)length;
 
 /// 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.
+/// The client's animations go, every value it wrote goes back as it was read before the transition (also at a
+/// cancel), and 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.
+/// The times a client samples its values at, in seconds from the start: 0, every 1/120 s up to `end` (wider apart for
+/// a transition over 20 s, 2400 samples at most), each of `marks` within it (a track's start and end, a swap's), `end`
+/// and `length`; ascending, without repeats. The values between two samples are linear, so a kink of a track falls on
+/// a sample.
+FOUNDATION_EXPORT NSArray<NSNumber *> *ANNSampleTimes(NSTimeInterval end, NSTimeInterval length,
+                                                      NSArray<NSNumber *> *marks);
+
+/// The animation of `keyPath` through `values` at `times` (from `ANNSampleTimes`) over `length` seconds: linear
+/// between them, holding the first value before and the last after (until it is removed). Nil for no length, and for
+/// values and times that don't pair up.
+FOUNDATION_EXPORT CAKeyframeAnimation *_Nullable ANNKeyframes(NSString *keyPath, NSArray *values,
+                                                              NSArray<NSNumber *> *times,
+                                                              NSTimeInterval length);
+
+/// The key of the core's animation of `keyPath` on a layer, for its `restore`.
+FOUNDATION_EXPORT NSString *ANNAnimationKey(NSString *keyPath);
+
+/// The frames of one running transition, in Core Animation: every client adds its animations in one transaction, which
+/// starts them together at its commit; the render server plays them, so a busy main queue no longer stops the
+/// transition. Once every animation ended (or was removed) and `length` passed, `done` runs once on the main queue.
+/// Main queue.
 @interface ANNFrameDriver : NSObject
 
 - (instancetype)initWithClients:(NSArray<id<ANNFrameClient>> *)clients
@@ -30,17 +50,37 @@ NS_ASSUME_NONNULL_BEGIN
 - (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.
+/// The clients add their animations, which start at the commit of the current transaction (the first frame shows the
+/// start values). `done` comes later, 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.
+/// The start of a transition that follows a gesture: the clients add their animations as `startWithDone:` does, under
+/// the time of `clock` (the transition's container), which stops. `setProgress:` shows them at a part of the length;
+/// `finishWithSpeed:` plays the rest and `rewindWithSpeed:` plays them back to the start, both in Core Animation. The
+/// other animations under `clock` stop with it. Before `done`, which comes once after either of them (never inside a
+/// call) with whether the transition finished, `clock` gets its time back; the caller restores the clients inside
+/// `done` (one commit with it), or they would show at the clock's time for a frame.
+- (void)startPausedOn:(CALayer *)clock done:(void (^)(BOOL finished))done;
+
+/// The animations show at `progress` (0 to 1) of the length. Nothing once the end plays.
+- (void)setProgress:(CGFloat)progress;
+
+/// The rest of the animations plays from where they show, `speed` times as fast as they would (1 or more).
+- (void)finishWithSpeed:(CGFloat)speed;
+
+/// The animations play back to their start, `speed` times as fast as they would (1 or more).
+- (void)rewindWithSpeed:(CGFloat)speed;
+
+/// The transition stops (a destroy, a reload, a newer `setRoot`): `done` never runs, and a stopped `clock` gets its
+/// time back. The caller restores the clients, which removes their animations, in the same commit.
 - (void)cancel;
 
-/// The frames run.
+/// The animations run.
 @property(nonatomic, readonly) BOOL isRunning;
 
+/// The seconds from the start to the end of the last client, the transition's own length at least.
+@property(nonatomic, readonly) NSTimeInterval length;
+
 @end
 
 NS_ASSUME_NONNULL_END

package/ios/Animations/ANNFrameDriver.mm

@@ -2,39 +2,84 @@
 #import "ANNAssert.h"
 #import "ANNCurve.h"
 #import "ANNTransformParts.h"
-#import <QuartzCore/QuartzCore.h>
+#include <cmath>
 
-// 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
+// The samples per second of a client's values: a frame of a 120 Hz display each.
+static const double ANNSamplesPerSecond = 120;
 
-@interface ANNFrameDriver ()
-- (void)frame:(CADisplayLink *)link;
-@end
+// At most this many samples per client: a longer transition samples less often.
+static const NSUInteger ANNMaxSamples = 2400;
 
-@implementation ANNFrameTarget
+NSArray<NSNumber *> *ANNSampleTimes(NSTimeInterval end, NSTimeInterval length,
+                                    NSArray<NSNumber *> *marks) {
+    end = MIN(MAX(end, 0), length);
+    NSMutableArray<NSNumber *> *candidates = [NSMutableArray arrayWithObject:@0];
+    double step = MAX(1 / ANNSamplesPerSecond, end / ANNMaxSamples);
+    NSUInteger count = (NSUInteger)std::floor(end / step);
+    for (NSUInteger index = 1; index <= count; index++) {
+        [candidates addObject:@(index * step)];
+    }
+    for (NSNumber *mark in marks) {
+        double time = mark.doubleValue;
+        if (std::isfinite(time) && time > 0 && time < end) {
+            [candidates addObject:mark];
+        }
+    }
+    [candidates addObject:@(end)];
+    [candidates addObject:@(length)];
+    [candidates sortUsingSelector:@selector(compare:)];
+    NSMutableArray<NSNumber *> *times = [NSMutableArray arrayWithCapacity:candidates.count];
+    for (NSNumber *time in candidates) {
+        // Samples closer than a microsecond are one.
+        if (times.count == 0 || time.doubleValue - times.lastObject.doubleValue > 1e-6) {
+            [times addObject:time];
+        }
+    }
+    return times;
+}
 
-- (void)frame:(CADisplayLink *)link {
-    ANNFrameDriver *driver = _owner;
-    if (!driver) {
-        [link invalidate];
-        return;
+CAKeyframeAnimation *ANNKeyframes(NSString *keyPath, NSArray *values, NSArray<NSNumber *> *times,
+                                  NSTimeInterval length) {
+    if (length <= 0 || values.count == 0 || values.count != times.count) {
+        return nil;
+    }
+    NSMutableArray<NSNumber *> *keyTimes = [NSMutableArray arrayWithCapacity:times.count];
+    for (NSNumber *time in times) {
+        [keyTimes addObject:@(MIN(MAX(time.doubleValue / length, 0.0), 1.0))];
     }
-    [driver frame:link];
+    CAKeyframeAnimation *animation = [CAKeyframeAnimation animationWithKeyPath:keyPath];
+    animation.values = values;
+    animation.keyTimes = keyTimes;
+    animation.calculationMode = kCAAnimationLinear;
+    animation.duration = length;
+    animation.fillMode = kCAFillModeBoth;
+    animation.removedOnCompletion = NO;
+    return animation;
 }
 
-@end
+NSString *ANNAnimationKey(NSString *keyPath) {
+    return [@"ApexNavigation." stringByAppendingString:keyPath];
+}
 
 @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;
+    BOOL _running;
+    BOOL _starting;
+    // When the animations were added; they start at the commit of the current transaction, a moment later.
+    CFTimeInterval _start;
+    // The driver keeps itself while its animations run: the transition that started it needn't.
+    ANNFrameDriver *_keep;
+    // A transition that follows a gesture: the layer whose time stops, its timing before, the clock's time the
+    // animations started at, the `done` that tells how it ended, and whether its end plays.
+    CALayer *_clock;
+    float _clockSpeed;
+    CFTimeInterval _clockBegin;
+    CFTimeInterval _clockOffset;
+    CFTimeInterval _base;
+    void (^_pausedDone)(BOOL finished);
+    BOOL _ending;
 }
 
 - (instancetype)initWithClients:(NSArray<id<ANNFrameClient>> *)clients
@@ -51,7 +96,11 @@
 }
 
 - (BOOL)isRunning {
-    return _link != nil;
+    return _running;
+}
+
+- (NSTimeInterval)length {
+    return _length;
 }
 
 - (void)startWithDone:(dispatch_block_t)done {
@@ -60,69 +109,174 @@
     ANNCurveSelfCheck();
     ANNTransformPartsSelfCheck();
 #endif
-    if (_link) {
+    if (_running || _done || _pausedDone) {
         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];
+    _running = YES;
+    _keep = self;
+    _starting = YES;
     _start = CACurrentMediaTime();
+    __weak ANNFrameDriver *weakSelf = self;
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    // Called once every animation added in this transaction ended or was removed (with its layer too), and at once
+    // without any.
+    [CATransaction setCompletionBlock:^{
+      [weakSelf animationsEnded];
+    }];
+    @try {
+        for (id<ANNFrameClient> client in _clients) {
+            [client addAnimationsWithLength:_length];
+        }
+    } @finally {
+        [CATransaction commit];
+        _starting = NO;
+    }
 }
 
-- (void)frame:(CADisplayLink *)link {
-    if (link != _link) {
-        [link invalidate];
+- (void)animationsEnded {
+    if (!_running) {
         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();
-        }
+    // `done` never comes inside `startWithDone:`, nor before the length passed: a transition with nothing to play (no
+    // client, every element skipped) or whose animations went early still takes its time, as on Android.
+    __weak ANNFrameDriver *weakSelf = self;
+    NSTimeInterval left = _length - (CACurrentMediaTime() - _start);
+    if (_starting || left > 0) {
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(MAX(left, 0) * NSEC_PER_SEC)),
+                       dispatch_get_main_queue(), ^{
+                         [weakSelf animationsEnded];
+                       });
         return;
     }
-    [self applyAtTime:time];
+    _running = NO;
+    dispatch_block_t done = _done;
+    _done = nil;
+    _keep = nil;
+    if (done) {
+        done();
+    }
+}
+
+- (void)cancel {
+    ANNAssertMainQueue();
+    if (!_running) {
+        return;
+    }
+    _running = NO;
+    _done = nil;
+    _pausedDone = nil;
+    _keep = nil;
+    [self releaseClock];
 }
 
-- (void)applyAtTime:(NSTimeInterval)time {
+#pragma mark - Following a gesture
+
+- (void)startPausedOn:(CALayer *)clock done:(void (^)(BOOL finished))done {
+    ANNAssertMainQueue();
+    if (_running || _done || _pausedDone) {
+        return;
+    }
+    _pausedDone = [done copy];
+    _running = YES;
+    _keep = self;
+    _clock = clock;
+    _clockSpeed = clock.speed;
+    _clockBegin = clock.beginTime;
+    _clockOffset = clock.timeOffset;
+    // The clock stops at its time now: what else animates under it holds still, and the animations added now start
+    // there (Core Animation gives an animation without a begin time the layer's time at the commit).
+    _base = [clock convertTime:CACurrentMediaTime() fromLayer:nil];
     [CATransaction begin];
     [CATransaction setDisableActions:YES];
-    for (id<ANNFrameClient> client in _clients) {
-        [client applyAtTime:time];
+    clock.speed = 0;
+    clock.beginTime = 0;
+    clock.timeOffset = _base;
+    @try {
+        for (id<ANNFrameClient> client in _clients) {
+            [client addAnimationsWithLength:_length];
+        }
+    } @finally {
+        [CATransaction commit];
+    }
+}
+
+- (void)setProgress:(CGFloat)progress {
+    ANNAssertMainQueue();
+    if (!_running || !_pausedDone || _ending) {
+        return;
     }
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    _clock.timeOffset = _base + MIN(MAX(progress, 0.0), 1.0) * _length;
     [CATransaction commit];
 }
 
-- (void)stop {
-    [_link invalidate];
-    _link = nil;
+- (void)finishWithSpeed:(CGFloat)speed {
+    [self playOnForward:YES speed:speed];
 }
 
-- (void)cancel {
+- (void)rewindWithSpeed:(CGFloat)speed {
+    [self playOnForward:NO speed:speed];
+}
+
+// The clock runs again from where it shows, forward or back, and `done` comes once it reached the end or the start.
+- (void)playOnForward:(BOOL)forward speed:(CGFloat)speed {
     ANNAssertMainQueue();
-    if (!_link) {
+    if (!_running || !_pausedDone || _ending) {
         return;
     }
-    [self applyAtTime:_length];
-    [self stop];
-    _done = nil;
-    _running = nil;
+    _ending = YES;
+    speed = MAX(speed, 1.0);
+    CALayer *clock = _clock;
+    CFTimeInterval at = clock.timeOffset - _base;
+    CFTimeInterval left = forward ? _length - at : at;
+    CALayer *parent = clock.superlayer;
+    CFTimeInterval now = parent ? [parent convertTime:CACurrentMediaTime() fromLayer:nil]
+                                : CACurrentMediaTime();
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    // The clock's time is (parent's time - beginTime) * speed + timeOffset: it goes on from where it shows.
+    clock.beginTime = now;
+    clock.speed = (float)(forward ? speed : -speed);
+    [CATransaction commit];
+    __weak ANNFrameDriver *weakSelf = self;
+    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(MAX(left / speed, 0) * NSEC_PER_SEC)),
+                   dispatch_get_main_queue(), ^{
+                     [weakSelf pausedEndedForward:forward];
+                   });
 }
 
-- (void)dealloc {
-    [_link invalidate];
+- (void)pausedEndedForward:(BOOL)forward {
+    if (!_running || !_pausedDone) {
+        return;
+    }
+    _running = NO;
+    void (^done)(BOOL) = _pausedDone;
+    _pausedDone = nil;
+    _keep = nil;
+    // The clock's time back and the caller's restore in one commit: between two, the animations would show at the
+    // clock's own time for a frame (past their end, or part way).
+    [CATransaction begin];
+    [self releaseClock];
+    done(forward);
+    [CATransaction commit];
+}
+
+// The clock gets back the timing it had before the gesture.
+- (void)releaseClock {
+    CALayer *clock = _clock;
+    _clock = nil;
+    if (!clock) {
+        return;
+    }
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    clock.speed = _clockSpeed;
+    clock.beginTime = _clockBegin;
+    clock.timeOffset = _clockOffset;
+    [CATransaction commit];
 }
 
 @end

package/ios/Animations/ANNTransitionAnimator.h

@@ -12,10 +12,10 @@ NS_ASSUME_NONNULL_BEGIN
 /// 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.
+/// place and the shared elements' copies, in Core Animation; a side that doesn't play doesn't move. At the end, before
+/// `completeTransition:`, the animations go, the copies go and the React views show again, and both views get back the
+/// transform and the alpha they had. Only a pop of the swipe back follows a gesture (`animateFollowingGesture:`) and
+/// can end where it began; `completeTransition:` never comes inside `animateTransition:`. Main queue.
 @interface ANNTransitionAnimator : NSObject <UIViewControllerAnimatedTransitioning>
 
 - (instancetype)initWithPlan:(ANNTransitionPlan *)plan NS_DESIGNATED_INITIALIZER;
@@ -25,8 +25,29 @@ NS_ASSUME_NONNULL_BEGIN
 
 @property(nonatomic, strong, readonly) ANNTransitionPlan *plan;
 
+/// The start of an interactive transition (a pop of the swipe back, which never waits): as `animateTransition:`, with
+/// the frames held at their start until `setProgress:` moves them (`ANNFrameDriver startPausedOn:`); then
+/// `finishWithSpeed:` or `rewindWithSpeed:`, after the context's own finish or cancel, plays the end.
+- (void)animateFollowingGesture:(id<UIViewControllerContextTransitioning>)transitionContext;
+
+/// The frames show at `progress` (0 to 1) of the length.
+- (void)setProgress:(CGFloat)progress;
+
+/// The rest plays (`speed` times as fast, 1 or more), and the transition completes.
+- (void)finishWithSpeed:(CGFloat)speed;
+
+/// The frames play back to the start (`speed` times as fast, 1 or more), and the transition completes cancelled.
+- (void)rewindWithSpeed:(CGFloat)speed;
+
+/// The seconds the frames take: the plan's length, or the end of a longer element.
+@property(nonatomic, readonly) NSTimeInterval length;
+
+/// The transition completed (or was never started).
+@property(nonatomic, readonly) BOOL isCompleted;
+
 /// 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.
+/// back, and the transition completes so that UIKit isn't left half way (an interactive one finishes first). Nothing
+/// once it completed.
 - (void)cancel;
 
 @end

package/ios/Animations/ANNTransitionAnimator.mm

@@ -33,6 +33,9 @@ static void ANNUpdateRootLayoutOf(UIViewController *node) {
     NSArray<id<ANNFrameClient>> *_clients;
     BOOL _began;
     BOOL _completed;
+    // The transition follows a gesture (`animateFollowingGesture:`), and its end was chosen.
+    BOOL _followsGesture;
+    BOOL _endChosen;
     // The container's views of the transition that got a depth for it, and the depth each had.
     NSArray<UIView *> *_depthViews;
     NSArray<NSNumber *> *_depthsBefore;
@@ -118,6 +121,33 @@ static void ANNUpdateRootLayoutOf(UIViewController *node) {
     [self begin];
 }
 
+- (void)animateFollowingGesture:(id<UIViewControllerContextTransitioning>)transitionContext {
+    _followsGesture = YES;
+    [self animateTransition:transitionContext];
+}
+
+- (void)setProgress:(CGFloat)progress {
+    [_driver setProgress:progress];
+}
+
+- (void)finishWithSpeed:(CGFloat)speed {
+    _endChosen = YES;
+    [_driver finishWithSpeed:speed];
+}
+
+- (void)rewindWithSpeed:(CGFloat)speed {
+    _endChosen = YES;
+    [_driver rewindWithSpeed:speed];
+}
+
+- (NSTimeInterval)length {
+    return _driver ? _driver.length : _plan.length;
+}
+
+- (BOOL)isCompleted {
+    return _completed || !_context;
+}
+
 - (void)animationEnded:(BOOL)transitionCompleted {
     _wait = nil;
     _driver = nil;
@@ -187,8 +217,9 @@ static void ANNUpdateRootLayoutOf(UIViewController *node) {
                                                    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) {
+    // The arriving view gets its own alpha back: an `opacity` animation of its tracks shows over it from the start, in
+    // the same transaction.
+    if (_arriving) {
         _arriving.alpha = _arrivingAlpha;
     }
     if (arrivingTracks.hasTracks) {
@@ -197,7 +228,7 @@ static void ANNUpdateRootLayoutOf(UIViewController *node) {
     if (leavingTracks.hasTracks) {
         [clients addObject:leavingTracks];
     }
-    // Each element plays on its own: one whose frame fails goes back and stops, the others and the screens go on.
+    // Each element plays on its own: one whose animations fail goes back and stays, the others and the screens go on.
     for (ANNElementTransition *element in elements) {
         [clients addObject:[[ANNIsolatedElement alloc] initWithClient:element name:element.name]];
     }
@@ -210,6 +241,13 @@ static void ANNUpdateRootLayoutOf(UIViewController *node) {
     }
     __weak ANNTransitionAnimator *weakSelf = self;
     _driver = [[ANNFrameDriver alloc] initWithClients:clients length:_plan.length];
+    if (_followsGesture) {
+        [_driver startPausedOn:container.layer
+                          done:^(BOOL finished) {
+                            [weakSelf complete];
+                          }];
+        return;
+    }
     [_driver startWithDone:^{
       [weakSelf complete];
     }];
@@ -288,8 +326,16 @@ static BOOL ANNSideTilts(ANNViewAnimationOptions *side) {
     }
     [_wait cancel];
     _wait = nil;
+    // An interactive transition ends at its end state too: UIKit completes only one whose end was chosen.
+    if (_followsGesture && !_endChosen) {
+        _endChosen = YES;
+        [_context finishInteractiveTransition];
+    }
+    // A stopped clock gets its time back in the commit that removes the animations.
+    [CATransaction begin];
     [_driver cancel];
     [self complete];
+    [CATransaction commit];
 }
 
 @end

package/ios/Animations/ANNTransitionPlan.h

@@ -19,8 +19,8 @@ typedef NS_ENUM(NSInteger, ANNTransitionKind) {
     ANNTransitionKindDismiss,
 };
 
-/// The screen fade of a transition with elements and no screen animation of its own, or of a dismissed popover with
-/// nothing to play.
+/// The screen fade of a transition with elements and no screen animation of its own, of a dismissed popover with
+/// nothing to play, or of any transition while the system's Reduce Motion is on (then nothing else plays).
 typedef NS_ENUM(NSInteger, ANNScreenFade) {
     ANNScreenFadeNone,
     /// The arriving screen from 0 to its alpha.

package/ios/Animations/ANNTransitionPlan.mm

@@ -43,6 +43,16 @@ static const NSTimeInterval ANNElementsScreenFade = 0.3;
         length = MAX(length, [ANNAnimationRules lengthOfElements:_elements shared:_sharedElements]);
         length = MAX(length, _screenFadeDuration);
         _length = length;
+        // With the system's Reduce Motion on, nothing moves: the transition is a fade of the same length, the arriving
+        // screen in going forward, the leaving one out otherwise.
+        if (UIAccessibilityIsReduceMotionEnabled() && length > 0) {
+            _enter = nil;
+            _exit = nil;
+            _elements = @[];
+            _sharedElements = @[];
+            _screenFade = _isForward ? ANNScreenFadeArrivingIn : ANNScreenFadeLeavingOut;
+            _screenFadeDuration = length;
+        }
     }
     return self;
 }

package/ios/Animations/Elements/ANNElementFinder.h

@@ -69,8 +69,8 @@ FOUNDATION_EXPORT BOOL ANNElementStep(NSString *element, NS_NOESCAPE dispatch_bl
 /// The line in the log for the element named `element`, skipped for `reason`: it shows and hides with its screen.
 FOUNDATION_EXPORT void ANNElementSkipped(NSString *element, NSString *reason);
 
-/// An element's frames, each in `ANNElementStep`: after a frame that fails, the element's values go back
-/// (`-restore`), and it gets no frame more.
+/// An element's animations, made in `ANNElementStep`: when making them fails, the element's values go back
+/// (`-restore`) and it doesn't move; the rest of the transition plays.
 @interface ANNIsolatedElement : NSObject <ANNFrameClient>
 
 - (instancetype)initWithClient:(id<ANNFrameClient>)client

package/ios/Animations/Elements/ANNElementFinder.mm

@@ -182,13 +182,13 @@ BOOL ANNElementStep(NSString *element, NS_NOESCAPE dispatch_block_t work) {
 
 #pragma mark - ANNFrameClient
 
-- (void)applyAtTime:(NSTimeInterval)time {
+- (void)addAnimationsWithLength:(NSTimeInterval)length {
     if (_failed) {
         return;
     }
     id<ANNFrameClient> client = _client;
     if (!ANNElementStep(_name, ^{
-          [client applyAtTime:time];
+          [client addAnimationsWithLength:length];
         })) {
         _failed = YES;
         [self restore];

package/ios/Animations/Elements/ANNElementTransition.h

@@ -6,9 +6,9 @@
 
 NS_ASSUME_NONNULL_BEGIN
 
-/// One `elementTransitions[]` item on its React view: the view's own `transform` and `alpha` animate in place, its
-/// parents clip it as usual; at the end, at a cancel and at a destroy the values read before come back. Nothing else of
-/// the React view changes (no frame, no subview, never `layer.zPosition`).
+/// One `elementTransitions[]` item on its React view: its `transform` and `opacity` animate in place, its parents clip
+/// it as usual; at the end, at a cancel and at a destroy the animations go and the view shows its own values. Nothing
+/// of the React view is written (no value, no frame, no subview, never `layer.zPosition`).
 @interface ANNElementTransition : NSObject <ANNFrameClient>
 
 /// The items found: each `id` first in the leaving screen's React view, then in the arriving one; an item not found or

package/ios/Animations/Elements/ANNElementTransition.mm

@@ -58,8 +58,8 @@
 
 #pragma mark - ANNFrameClient
 
-- (void)applyAtTime:(NSTimeInterval)time {
-    [_tracks applyAtTime:time];
+- (void)addAnimationsWithLength:(NSTimeInterval)length {
+    [_tracks addAnimationsWithLength:length];
 }
 
 - (NSTimeInterval)endTime {