react-native-smooth-clip-view 0.2.6 → 0.2.8

package/ios/SmoothClipRegistry.mm

@@ -43,6 +43,7 @@
 - (BOOL)smoothClipCanDisplay;
 - (BOOL)smoothClipHasPendingInstall;
 - (double)smoothClipSpringContinuationVelocity;
+- (void)smoothClipClearVelocitySamples;
 @end
 
 namespace smoothclip {
@@ -56,6 +57,10 @@ enum class AnimationKind { Timing, Spring, Keyframes };
 struct ActiveAnimation {
   int32_t animationId;
   std::unordered_set<ViewKey> participants;
+  // Hosts that installed this id and temporarily lost displayability. They
+  // may rejoin the same remainder; completion is false if any remain
+  // unresolved when the run ends or unregister.
+  std::unordered_set<ViewKey> suspendedParticipants;
   bool finished = true;
   AnimationKind kind = AnimationKind::Timing;
   // Geometry the transition started from. Used when a view must join the
@@ -69,10 +74,10 @@ struct ActiveAnimation {
   // False while the animation is latched. Two ways in: built before any host
   // view could display (pre-registration, or a host in a detached subtree), or
   // re-latched by unregisterView when the last DISPLAYABLE host left
-  // mid-flight. Started by whichever of registerView, viewBecameDisplayable
-  // (window attach or first layout) or joinActiveAnimation first finds a host
-  // that can produce a frame; each rebases startedAt through
-  // startLatchedAnimation. startedAt is only meaningful once started.
+  // mid-flight. Started by whichever registration/displayability update or
+  // joinActiveAnimation first finds a host that can produce a frame; each
+  // rebases startedAt through startLatchedAnimation. startedAt is only
+  // meaningful once started.
   bool started = false;
 };
 
@@ -98,6 +103,41 @@ std::unordered_map<uint64_t, DriverState> &registry() {
   return value;
 }
 
+// The transitions must be observed for the whole process lifetime, not per
+// view: the state below is process-global, and a notification delivered while
+// no SmoothClipView happens to be alive (the last host unmounted during
+// inactivity, or the app backgrounded between screens) must still land.
+// View-held observers die with their views and left the flag permanently
+// stale in exactly those windows.
+void installApplicationStateObservers() {
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    NSNotificationCenter *center = NSNotificationCenter.defaultCenter;
+    [center addObserverForName:UIApplicationWillResignActiveNotification
+                        object:nil
+                         queue:nil
+                    usingBlock:^(NSNotification *) {
+                      applicationWillResignActive();
+                    }];
+    [center addObserverForName:UIApplicationDidBecomeActiveNotification
+                        object:nil
+                         queue:nil
+                    usingBlock:^(NSNotification *) {
+                      applicationDidBecomeActive();
+                    }];
+  });
+}
+
+bool &applicationActiveState() {
+  installApplicationStateObservers();
+  // The first SmoothClipView can be created after the app already entered the
+  // background, too late to observe WillResignActive. Seed from UIKit rather
+  // than assuming foreground so that first registration cannot start offscreen.
+  static bool active = UIApplication.sharedApplication.applicationState ==
+      UIApplicationStateActive;
+  return active;
+}
+
 CompletionSink &completionSink() {
   static CompletionSink sink;
   return sink;
@@ -176,7 +216,9 @@ void emitStandaloneCompletion(
 #endif
 }
 
-Presentation canonicalFrozenPresentation(DriverState &state) {
+Presentation canonicalFrozenPresentation(
+    DriverState &state,
+    SmoothClipView *preferred = nil) {
   // A latched animation never rendered, so state.latest already holds its
   // target; freezing there would jump the clip. Freeze at the start instead.
   Presentation canonical =
@@ -184,17 +226,35 @@ Presentation canonicalFrozenPresentation(DriverState &state) {
       ? state.animation->start
       : state.latest;
   bool hasCanonical = false;
+  bool hasParticipantFallback = false;
+  Presentation participantFallback{{0, 0, 0, 0, 0}, 0, 0};
   for (const ViewKey key : state.views) {
     // Freeze every view (the teardown side effect must reach all of them),
     // but only a laid-out view may define the canonical geometry — an
     // unlaid-out one reports {0,0,0,0} and would collapse the clip.
     SmoothClipView *candidate = viewForKey(key);
     const Presentation frozen = [candidate smoothClipFreezePresentation];
-    if (!hasCanonical && [candidate smoothClipIsJoinable]) {
+    if (candidate == preferred && [candidate smoothClipIsJoinable]) {
+      canonical = frozen;
+      hasCanonical = true;
+    } else if (!hasCanonical && [candidate smoothClipIsJoinable]) {
       canonical = frozen;
       hasCanonical = true;
+    } else if (!hasParticipantFallback && state.animation.has_value() &&
+               (state.animation->participants.count(key) > 0 ||
+                state.animation->suspendedParticipants.count(key) > 0)) {
+      // An installed participant whose HOST just lost its size still holds
+      // real mid-flight geometry on its clip layer (host bounds do not feed
+      // the clip container). Without this fallback, a sole running host
+      // resized to zero froze the re-latch at state.latest — the target —
+      // and the resumed animation snapped to its endpoint.
+      hasParticipantFallback = true;
+      participantFallback = frozen;
     }
   }
+  if (!hasCanonical && hasParticipantFallback) {
+    canonical = participantFallback;
+  }
   return canonical;
 }
 
@@ -219,7 +279,8 @@ void finishIfNoInstalledParticipants(uint64_t driverId, DriverState &state) {
     return;
   }
   const int32_t animationId = state.animation->animationId;
-  const bool finished = state.animation->finished;
+  const bool finished = state.animation->finished &&
+      state.animation->suspendedParticipants.empty();
   // A detached/unlaid-out view can have a requested animation without any CA
   // delegate capable of completing it. Once every installed animation ends,
   // make those deferred views statically correct and invalidate their pending
@@ -231,12 +292,16 @@ void finishIfNoInstalledParticipants(uint64_t driverId, DriverState &state) {
   emitCompletion(driverId, state, animationId, finished);
 }
 
-void applyPresentation(DriverState &state, Presentation presentation) {
+void applyPresentation(
+    DriverState &state,
+    Presentation presentation,
+    bool recordVelocitySample = true) {
   state.latest = presentation;
   state.hasLatest = true;
   state.ownership = Ownership::Interactive;
   for (const ViewKey key : state.views) {
-    [viewForKey(key) smoothClipApplyPresentation:presentation];
+    [viewForKey(key) smoothClipApplyPresentation:presentation
+                              recordVelocitySample:recordVelocitySample];
   }
 }
 
@@ -324,7 +389,10 @@ void dispatchActiveAnimationJoin(
                                      durationMs:remainingMs
                                     animationId:active.animationId];
   }
-  if (installed) active.participants.insert(key);
+  if (installed) {
+    active.participants.insert(key);
+    active.suspendedParticipants.erase(key);
+  }
 }
 
 // An animation may only start once a registered view can actually produce a
@@ -339,10 +407,83 @@ bool anyDisplayableView(const DriverState &state) {
   return false;
 }
 
+void relatchActiveAnimation(
+    uint64_t driverId,
+    DriverState &state,
+    SmoothClipView *preferred = nil) {
+  if (!state.animation.has_value() || !state.animation->started) return;
+  auto &active = *state.animation;
+  double springVelocity = 0;
+  if (active.kind == AnimationKind::Spring) {
+    SmoothClipView *source = preferred;
+    if (source == nil ||
+        active.participants.count(keyForView(source)) == 0) {
+      source = active.participants.empty()
+          ? nil
+          : viewForKey(*active.participants.begin());
+    }
+    if (source != nil) {
+      springVelocity = [source smoothClipSpringContinuationVelocity];
+    }
+  }
+  const Presentation frozen = canonicalFrozenPresentation(state, preferred);
+  // Captured before the migration below: only hosts that were ALREADY
+  // suspended are unresolved. The active participants being frozen right now
+  // rendered every frame up to this instant.
+  const bool hadUnresolvedSuspended = !active.suspendedParticipants.empty();
+  active.suspendedParticipants.insert(
+      active.participants.begin(), active.participants.end());
+  active.participants.clear();
+
+  const double elapsedMs = MAX(
+      0, (CACurrentMediaTime() - active.startedAt) * 1000.0);
+  const double progress = active.durationMs <= 0
+      ? 1
+      : MIN(1, MAX(0, elapsedMs / active.durationMs));
+  if (active.kind == AnimationKind::Timing) {
+    active.timing = timingRemainder(active.timing, progress).animation;
+    active.durationMs = active.timing.durationMs;
+  } else if (active.kind == AnimationKind::Keyframes) {
+    const KeyframeContinuation continuation = keyframeContinuation(
+        active.keyframes,
+        frozen,
+        state.latest,
+        active.durationMs,
+        progress);
+    active.keyframes = continuation.frames;
+    active.durationMs = continuation.durationMs;
+  } else {
+    active.spring.inheritVelocity = false;
+    active.spring.initialVelocity = springVelocity;
+  }
+
+  if (state.destroyed ||
+      (active.kind != AnimationKind::Spring && active.durationMs <= 0)) {
+    // A residual trimmed to zero means the curve fully elapsed while a host
+    // displayed every frame — only the asynchronous didStop was outstanding
+    // when this freeze arrived. Report that run honestly instead of stamping
+    // the freeze-path false; hosts that were suspended before the freeze are
+    // unresolved and still poison it.
+    const bool ranToEnd = !state.destroyed && progress >= 1 &&
+        active.finished && !hadUnresolvedSuspended;
+    // Deferred peers hold pending installs for this id; invalidate them and
+    // finalize statically at the target, exactly as the didStop completion
+    // path does. Frozen participants already have no animation to cancel.
+    for (const ViewKey key : state.views) {
+      [viewForKey(key) smoothClipCancelAnimationUsingTarget:YES];
+    }
+    state.ownership = Ownership::Interactive;
+    emitCompletion(driverId, state, active.animationId, ranToEnd);
+    return;
+  }
+  active.start = frozen;
+  active.started = false;
+}
+
 // Starts a latched animation: rebases the clock so no progress was burned
 // while no view could display, then dispatches the join to every registered
 // view. Views that still cannot display defer their install per-view and
-// resume via viewBecameDisplayable.
+// resume via a later positive displayability update.
 void startLatchedAnimation(DriverState &state) {
   state.animation->startedAt = CACurrentMediaTime();
   state.animation->started = true;
@@ -352,13 +493,39 @@ void startLatchedAnimation(DriverState &state) {
   const Presentation start = state.animation->start;
   for (const ViewKey key : state.views) {
     SmoothClipView *participant = viewForKey(key);
-    [participant smoothClipApplyPresentation:start];
+    [participant smoothClipApplyPresentation:start recordVelocitySample:NO];
     dispatchActiveAnimationJoin(state, participant, key, start);
   }
 }
 
 } // namespace
 
+bool applicationIsActive() {
+  return applicationActiveState();
+}
+
+void applicationWillResignActive() {
+  NSCAssert(NSThread.isMainThread, @"SmoothClip registry is main-thread only");
+  if (!applicationActiveState()) return;
+  applicationActiveState() = false;
+  for (auto &[driverId, state] : registry()) {
+    relatchActiveAnimation(driverId, state);
+  }
+}
+
+void applicationDidBecomeActive() {
+  NSCAssert(NSThread.isMainThread, @"SmoothClip registry is main-thread only");
+  if (applicationActiveState()) return;
+  applicationActiveState() = true;
+  for (auto &[driverId, state] : registry()) {
+    (void)driverId;
+    if (state.animation.has_value() && !state.animation->started &&
+        anyDisplayableView(state)) {
+      startLatchedAnimation(state);
+    }
+  }
+}
+
 void setCompletionCallback(
     const void *owner,
     CompletionCallback callback) {
@@ -394,8 +561,8 @@ void registerView(
   const bool hasLatch = hasAnimation && !state.animation->started;
   // A latch may only start once this view can produce a visible frame; a
   // registration from a detached subtree (transparentModal before its view
-  // controller is presented) keeps the latch held and viewBecameDisplayable
-  // starts it inside the attach commit.
+  // controller is presented) keeps the latch held; the positive
+  // displayability update starts it inside the attach commit.
   const bool startsLatch = hasLatch && [view smoothClipCanDisplay];
   const bool shouldReplay =
       hasAnimation && state.animation->started && !state.views.empty();
@@ -425,7 +592,7 @@ void registerView(
       state.views.end()) {
     state.views.push_back(key);
   }
-  [view smoothClipApplyPresentation:visible];
+  [view smoothClipApplyPresentation:visible recordVelocitySample:NO];
   if (startsLatch) {
     // Rebase the join clock and dispatch to every registered view. Only views
     // that actually install their CA groups become completion participants.
@@ -436,7 +603,7 @@ void registerView(
   dispatchActiveAnimationJoin(state, view, key, visible, reference);
 }
 
-void viewBecameDisplayable(uint64_t driverId, SmoothClipView *view) {
+void viewDisplayabilityChanged(uint64_t driverId, SmoothClipView *view) {
   NSCAssert(NSThread.isMainThread, @"SmoothClip registry is main-thread only");
   auto iterator = registry().find(driverId);
   if (iterator == registry().end()) return;
@@ -447,15 +614,25 @@ void viewBecameDisplayable(uint64_t driverId, SmoothClipView *view) {
       state.views.end()) {
     return;
   }
+  if (![view smoothClipCanDisplay]) {
+    if (!state.animation->started) return;
+    if (state.animation->participants.count(key) == 0) return;
+    if (!anyDisplayableView(state)) {
+      relatchActiveAnimation(driverId, state, view);
+      return;
+    }
+    [view smoothClipFreezePresentation];
+    state.animation->participants.erase(key);
+    state.animation->suspendedParticipants.insert(key);
+    return;
+  }
   if (!state.animation->started) {
-    if (![view smoothClipCanDisplay]) return;
     startLatchedAnimation(state);
     return;
   }
-  // A running animation whose install this view deferred while it could not
-  // display: resume through the standard mid-flight join (original clock —
-  // late joiners stay in sync with peers that were already rendering).
-  if ([view smoothClipHasPendingInstall]) {
+  // A deferred or suspended host joins from the registry's rebased remainder.
+  if ([view smoothClipHasPendingInstall] ||
+      state.animation->suspendedParticipants.count(key) > 0) {
     joinActiveAnimation(driverId, view);
   }
 }
@@ -503,7 +680,7 @@ bool joinActiveAnimation(uint64_t driverId, SmoothClipView *view) {
   const Presentation visible = reference != nil
       ? [reference smoothClipCurrentPresentation]
       : state.animation->start;
-  [view smoothClipApplyPresentation:visible];
+  [view smoothClipApplyPresentation:visible recordVelocitySample:NO];
   dispatchActiveAnimationJoin(state, view, key, visible, reference);
   return true;
 }
@@ -515,117 +692,33 @@ void unregisterView(uint64_t driverId, SmoothClipView *view) {
 
   auto &state = iterator->second;
   const ViewKey key = keyForView(view);
-  state.views.erase(
-      std::remove(state.views.begin(), state.views.end(), key),
-      state.views.end());
-  if (state.animation.has_value() &&
-      state.animation->participants.erase(key) > 0) {
-    state.animation->finished = false;
-    if (!state.animation->started) {
-      // A held latch remains pending for the next displayable registration.
-      // Removing this participant also makes any late callback a no-op.
-    } else if (!anyDisplayableView(state)) {
-      auto &active = *state.animation;
-      // Freeze before removing/reusing the layer. stopLayerAnimation invalidates
-      // its delegate, and erasing the participant above independently rejects
-      // any callback already queued by CoreAnimation.
-      //
-      // The freeze is a teardown side effect that must reach the departing
-      // view either way, but only a laid-out view may *define* the frozen
-      // geometry — smoothClipCurrentPresentation reports {0,0,0,0} for one
-      // that never laid out, and re-latching there would resume the animation
-      // out of a collapsed clip. Same filter canonicalFrozenPresentation uses:
-      // this view if joinable, else a laid-out survivor, else the start.
-      double springContinuationVelocity = 0;
-      if (active.kind == AnimationKind::Spring &&
-          [view smoothClipIsJoinable]) {
-        springContinuationVelocity =
-            [view smoothClipSpringContinuationVelocity];
-      }
-      const Presentation frozen = [view smoothClipFreezePresentation];
-      Presentation visible = active.start;
-      if ([view smoothClipIsJoinable]) {
-        visible = frozen;
-      } else {
-        for (const ViewKey candidate : state.views) {
-          SmoothClipView *candidateView = viewForKey(candidate);
-          if (![candidateView smoothClipIsJoinable]) continue;
-          visible = [candidateView smoothClipCurrentPresentation];
-          if (active.kind == AnimationKind::Spring) {
-            springContinuationVelocity =
-                [candidateView smoothClipSpringContinuationVelocity];
-          }
+  bool installed = false;
+  if (state.animation.has_value()) {
+    installed = state.animation->participants.count(key) > 0 ||
+        state.animation->suspendedParticipants.count(key) > 0;
+    if (state.animation->started &&
+        state.animation->participants.count(key) > 0) {
+      bool otherDisplayable = false;
+      for (const ViewKey candidate : state.views) {
+        if (candidate != key && [viewForKey(candidate) smoothClipCanDisplay]) {
+          otherDisplayable = true;
           break;
         }
       }
-      const double elapsedMs =
-          (CACurrentMediaTime() - active.startedAt) * 1000.0;
-      const double remainingMs = MAX(0, active.durationMs - elapsedMs);
-      const bool canResume = !state.destroyed &&
-          (active.kind == AnimationKind::Spring || remainingMs > 0);
-      if (!canResume) {
-        // The animation ends here; without releasing ownership a host that
-        // remounts on this driver later would drop every interactive update.
-        state.ownership = Ownership::Interactive;
-        emitCompletion(driverId, state, active.animationId, false);
-      } else {
-        // The last displayable host left mid-flight. A registered detached or
-        // unlaid-out peer must not let the animation finish invisibly.
-        // Completing here would leave `latest` at the target and statically
-        // snap any re-registering host straight to it. Re-latch instead:
-        // freeze the remaining animation at the visible geometry resolved
-        // above so the next displayable host resumes it with the true
-        // remaining time. Ownership stays Native — the pending animation
-        // still owns rendering intent; destroyDriver cancels a latch that
-        // never finds a host, so the completion cannot hang.
-        if (active.kind == AnimationKind::Timing) {
-          const double progress = active.durationMs <= 0
-              ? 1
-              : MIN(1, MAX(0, elapsedMs / active.durationMs));
-          active.timing = timingRemainder(active.timing, progress).animation;
-          active.durationMs = active.timing.durationMs;
-        } else if (active.kind == AnimationKind::Keyframes) {
-          const double progress = active.durationMs <= 0
-              ? 1
-              : MIN(1, MAX(0, elapsedMs / active.durationMs));
-          std::vector<Keyframe> remaining;
-          remaining.push_back({0, visible});
-          for (const Keyframe &frame : active.keyframes) {
-            if (frame.offset <= progress) continue;
-            const double offset = (frame.offset - progress) / (1 - progress);
-            remaining.push_back({offset, frame.presentation});
-          }
-          if (remaining.size() == 1) remaining.push_back({1, state.latest});
-          active.keyframes = std::move(remaining);
-          active.durationMs = remainingMs;
-        } else if (active.kind == AnimationKind::Spring) {
-          // The departing view resolved `inherit` before installing its CA
-          // spring. Re-express that spring's analytic velocity against the
-          // frozen remaining distance, so the resumed spring has the same
-          // physical derivative instead of restarting at rest.
-          active.spring.inheritVelocity = false;
-          active.spring.initialVelocity = springContinuationVelocity;
-        }
-        active.start = visible;
-        active.started = false;
+      if (!otherDisplayable) {
+        relatchActiveAnimation(driverId, state, view);
       }
-    } else if (state.animation->participants.empty()) {
-      // Every participant has either reported its stop or unregistered, yet a
-      // registered host can still display. viewAnimationDidStop is the only
-      // other exhaustion path and it can never run again for this id, so
-      // nothing is left to complete the animation: end it here.
-      //
-      // Reachable only with several hosts on one driver, where per-view spring
-      // settling durations let one host finish while another is still running
-      // (smoothClipAnimateSpring resolves 'inherit' per view, and
-      // springSettlingDurationWithVelocity derives the group duration from it).
-      //
-      // This branch MUST stay below the displayability test. A sole host that
-      // unregisters mid-flight also empties `participants`, and that case must
-      // RE-LATCH rather than complete — the next displayable host resuming the
-      // remainder is the entire point of the latch. Testing displayability
-      // first keeps the one-view-per-driver path on the branch above, which
-      // makes this one unreachable for a single host by construction.
+    }
+  }
+
+  state.views.erase(
+      std::remove(state.views.begin(), state.views.end(), key),
+      state.views.end());
+  if (state.animation.has_value()) {
+    state.animation->participants.erase(key);
+    state.animation->suspendedParticipants.erase(key);
+    if (installed) state.animation->finished = false;
+    if (state.animation->started && state.animation->participants.empty()) {
       finishIfNoInstalledParticipants(driverId, state);
     }
   }
@@ -753,7 +846,7 @@ int32_t animateTiming(
   prepareAnimation(driverId, state, start, presentation);
 
   if (shouldReduceMotion(animation.reduceMotion) || animation.durationMs <= 0) {
-    applyPresentation(state, presentation);
+    applyPresentation(state, presentation, false);
     emitCompletion(driverId, state, animationId, true);
     return animationId;
   }
@@ -815,7 +908,7 @@ int32_t animateSpring(
   prepareAnimation(driverId, state, start, presentation);
 
   if (shouldReduceMotion(animation.reduceMotion)) {
-    applyPresentation(state, presentation);
+    applyPresentation(state, presentation, false);
     emitCompletion(driverId, state, animationId, true);
     return animationId;
   }
@@ -872,7 +965,7 @@ int32_t animateKeyframes(
   const Presentation resolvedStart = resolvedAnimationStart(state, start);
   prepareAnimation(driverId, state, start, presentation);
   if (shouldReduceMotion(reduceMotion) || durationMs <= 0) {
-    applyPresentation(state, presentation);
+    applyPresentation(state, presentation, false);
     emitCompletion(driverId, state, animationId, true);
     return animationId;
   }
@@ -977,6 +1070,12 @@ void destroyDriver(uint64_t driverId) {
   if (iterator == registry().end()) return;
   auto &state = iterator->second;
   cancelActive(driverId, state, false);
+  // A destroyed driver's interaction history must not seed a revived
+  // incarnation: the revival seed would otherwise pair with these samples and
+  // refresh the staleness clock with motion no finger produced.
+  for (const ViewKey key : state.views) {
+    [viewForKey(key) smoothClipClearVelocitySamples];
+  }
   if (state.views.empty()) {
     registry().erase(iterator);
   } else {