react-native-smooth-clip-view 0.4.1 → 0.4.3

package/ios/SmoothClipRegistry.mm

@@ -44,6 +44,12 @@
                      animationId:(int32_t)animationId
                  sharedBeginTime:(CFTimeInterval)sharedBeginTime;
 - (void)smoothClipCancelAnimationUsingTarget:(BOOL)useTarget;
+- (BOOL)smoothClipPauseSpringAnimation:(int32_t)animationId
+                           atMediaTime:(CFTimeInterval)mediaTime;
+- (BOOL)smoothClipResumeSpringAnimation:(int32_t)animationId
+                            atMediaTime:(CFTimeInterval)mediaTime
+                             catchUpBy:(CFTimeInterval)catchUp;
+- (BOOL)smoothClipHasInstalledAnimation:(int32_t)animationId;
 - (BOOL)smoothClipIsJoinable;
 - (BOOL)smoothClipCanDisplay;
 - (double)smoothClipInheritedVelocityToPresentation:
@@ -76,6 +82,8 @@ struct ActiveAnimation {
   // False while a pre-ready run waits for its first displayable host. Host
   // loss after the run starts finishes it at the target.
   bool started = false;
+  bool exposedToInactivity = false;
+  bool needsForegroundReconciliation = false;
 };
 
 struct DriverState {
@@ -155,6 +163,11 @@ bool &applicationActiveState() {
   return active;
 }
 
+std::optional<CFTimeInterval> &applicationInactiveSince() {
+  static std::optional<CFTimeInterval> value;
+  return value;
+}
+
 CompletionSink &completionSink() {
   static CompletionSink sink;
   return sink;
@@ -185,6 +198,113 @@ std::vector<DriverSnapshot> cancelGroupInternal(
 void tryStartGroup(int32_t groupId);
 void finishGroupForHostLoss(int32_t groupId);
 DriverSnapshot snapshotForDriver(uint64_t driverId);
+SmoothClipView *viewForKey(ViewKey key);
+
+bool animationNeedsForegroundReconciliation(const DriverState &state) {
+  if (!state.animation.has_value()) return false;
+  const ActiveAnimation &animation = *state.animation;
+  if (animation.needsForegroundReconciliation) return true;
+  if (!animation.exposedToInactivity) return false;
+  if (animation.participants.empty()) return true;
+  for (const ViewKey key : animation.participants) {
+    if (![viewForKey(key)
+            smoothClipHasInstalledAnimation:animation.animationId]) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool groupNeedsForegroundReconciliation(int32_t groupId) {
+  const auto groupIterator = groupRegistry().find(groupId);
+  if (groupIterator == groupRegistry().end()) return false;
+  for (const uint64_t driverId : groupIterator->second.driverIds) {
+    const auto stateIterator = registry().find(driverId);
+    if (stateIterator != registry().end() &&
+        stateIterator->second.animation.has_value() &&
+        stateIterator->second.animation->groupId == groupId &&
+        animationNeedsForegroundReconciliation(stateIterator->second)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool pauseSpringForInactivity(
+    DriverState &state,
+    CFTimeInterval mediaTime) {
+  if (!state.animation.has_value() || !state.animation->started ||
+      state.animation->kind != AnimationKind::Spring) {
+    return true;
+  }
+  ActiveAnimation &animation = *state.animation;
+  if (animation.participants.empty()) {
+    animation.needsForegroundReconciliation = true;
+    return false;
+  }
+  bool paused = true;
+  for (const ViewKey key : animation.participants) {
+    paused = [viewForKey(key)
+        smoothClipPauseSpringAnimation:animation.animationId
+                           atMediaTime:mediaTime] && paused;
+  }
+  if (!paused) animation.needsForegroundReconciliation = true;
+  return paused;
+}
+
+bool resumeSpringAfterInactivity(
+    DriverState &state,
+    CFTimeInterval mediaTime,
+    CFTimeInterval catchUp) {
+  if (!state.animation.has_value() || !state.animation->started ||
+      state.animation->kind != AnimationKind::Spring) {
+    return true;
+  }
+  ActiveAnimation &animation = *state.animation;
+  bool resumed = !animation.participants.empty();
+  for (const ViewKey key : animation.participants) {
+    resumed = [viewForKey(key)
+        smoothClipResumeSpringAnimation:animation.animationId
+                            atMediaTime:mediaTime
+                             catchUpBy:catchUp] && resumed;
+  }
+  if (!resumed) animation.needsForegroundReconciliation = true;
+  return resumed;
+}
+
+bool resumeGroupSpringsAfterInactivity(
+    int32_t groupId,
+    CFTimeInterval mediaTime,
+    CFTimeInterval catchUp) {
+  const auto groupIterator = groupRegistry().find(groupId);
+  if (groupIterator == groupRegistry().end()) return false;
+  bool resumed = true;
+  for (const uint64_t driverId : groupIterator->second.driverIds) {
+    const auto stateIterator = registry().find(driverId);
+    if (stateIterator == registry().end() ||
+        !stateIterator->second.animation.has_value() ||
+        stateIterator->second.animation->groupId != groupId) {
+      return false;
+    }
+    resumed = resumeSpringAfterInactivity(
+        stateIterator->second, mediaTime, catchUp) && resumed;
+  }
+  return resumed;
+}
+
+void clearGroupInactivityExposure(int32_t groupId) {
+  const auto groupIterator = groupRegistry().find(groupId);
+  if (groupIterator == groupRegistry().end()) return;
+  for (const uint64_t driverId : groupIterator->second.driverIds) {
+    const auto stateIterator = registry().find(driverId);
+    if (stateIterator != registry().end() &&
+        stateIterator->second.animation.has_value() &&
+        stateIterator->second.animation->groupId == groupId) {
+      stateIterator->second.animation->exposedToInactivity = false;
+      stateIterator->second.animation->needsForegroundReconciliation = false;
+    }
+  }
+}
 
 Presentation unavailablePresentation() {
   // Non-finite geometry makes the JS side fall back to its current value
@@ -647,6 +767,7 @@ void tryStartGroup(int32_t groupId) {
     if (stateIterator == registry().end() ||
         !stateIterator->second.animation.has_value() ||
         stateIterator->second.animation->groupId != groupId ||
+        stateIterator->second.animation->started ||
         !driverReady(stateIterator->second)) {
       return;
     }
@@ -689,19 +810,14 @@ bool applicationIsActive() {
 void applicationWillResignActive() {
   NSCAssert(NSThread.isMainThread, @"SmoothClip registry is main-thread only");
   if (!applicationActiveState()) return;
+  const CFTimeInterval mediaTime = CACurrentMediaTime();
   applicationActiveState() = false;
-  std::vector<int32_t> groupIds;
-  groupIds.reserve(groupRegistry().size());
-  for (const auto &[groupId, group] : groupRegistry()) {
-    (void)group;
-    groupIds.push_back(groupId);
-  }
-  for (const int32_t groupId : groupIds) {
-    finishGroupForHostLoss(groupId);
-  }
+  applicationInactiveSince() = mediaTime;
   for (auto &[driverId, state] : registry()) {
-    if (!state.animation.has_value() || state.animation->groupId == 0) {
-      finishStandaloneAtTarget(driverId, state);
+    (void)driverId;
+    if (state.animation.has_value() && state.animation->started) {
+      state.animation->exposedToInactivity = true;
+      pauseSpringForInactivity(state, mediaTime);
     }
   }
 }
@@ -709,6 +825,14 @@ void applicationWillResignActive() {
 void applicationDidBecomeActive() {
   NSCAssert(NSThread.isMainThread, @"SmoothClip registry is main-thread only");
   if (applicationActiveState()) return;
+  const CFTimeInterval mediaTime = CACurrentMediaTime();
+  const CFTimeInterval inactiveDuration = applicationInactiveSince().has_value()
+      ? std::max((CFTimeInterval)0,
+                 mediaTime - *applicationInactiveSince())
+      : 0;
+  const CFTimeInterval springCatchUp =
+      std::min((CFTimeInterval)0.064, inactiveDuration);
+  applicationInactiveSince().reset();
   applicationActiveState() = true;
   std::vector<int32_t> groupIds;
   groupIds.reserve(groupRegistry().size());
@@ -717,13 +841,35 @@ void applicationDidBecomeActive() {
     groupIds.push_back(groupId);
   }
   for (const int32_t groupId : groupIds) {
-    tryStartGroup(groupId);
+    bool needsReconciliation = groupNeedsForegroundReconciliation(groupId);
+    if (!needsReconciliation) {
+      needsReconciliation = !resumeGroupSpringsAfterInactivity(
+          groupId, mediaTime, springCatchUp);
+    }
+    if (needsReconciliation) {
+      cancelGroupInternal(groupId, GroupCancelBehavior::Finish, true);
+    } else {
+      clearGroupInactivityExposure(groupId);
+      tryStartGroup(groupId);
+    }
   }
   for (auto &[driverId, state] : registry()) {
-    (void)driverId;
-    if (state.animation.has_value() && !state.animation->started &&
-        state.animation->groupId == 0 && anyDisplayableView(state)) {
-      startPendingAnimation(state);
+    if (!state.animation.has_value() || state.animation->groupId != 0) {
+      continue;
+    }
+    bool needsReconciliation = animationNeedsForegroundReconciliation(state);
+    if (!needsReconciliation) {
+      needsReconciliation = !resumeSpringAfterInactivity(
+          state, mediaTime, springCatchUp);
+    }
+    if (needsReconciliation) {
+      finishStandaloneAtTarget(driverId, state);
+    } else {
+      state.animation->exposedToInactivity = false;
+      state.animation->needsForegroundReconciliation = false;
+      if (!state.animation->started && anyDisplayableView(state)) {
+        startPendingAnimation(state);
+      }
     }
   }
 }
@@ -818,6 +964,9 @@ void viewDisplayabilityChanged(uint64_t driverId, SmoothClipView *view) {
     return;
   }
   if (![view smoothClipCanDisplay]) {
+    if (!applicationActiveState()) {
+      return;
+    }
     if (state.animation->groupId != 0 && state.animation->started) {
       finishGroupForHostLoss(state.animation->groupId);
     } else if (state.animation->started) {
@@ -841,7 +990,10 @@ void unregisterView(uint64_t driverId, SmoothClipView *view) {
   DriverState &state = iterator->second;
   const ViewKey key = keyForView(view);
   if (state.animation.has_value()) {
-    if (state.animation->groupId != 0 && state.animation->started) {
+    if (!applicationActiveState() && state.animation->started) {
+      state.animation->participants.erase(key);
+      state.animation->needsForegroundReconciliation = true;
+    } else if (state.animation->groupId != 0 && state.animation->started) {
       finishGroupForHostLoss(state.animation->groupId);
     } else if (state.animation->groupId == 0 && state.animation->started) {
       finishStandaloneAtTarget(driverId, state);
@@ -1611,6 +1763,10 @@ void viewAnimationDidStop(
 
   const ViewKey key = keyForView(view);
   if (state.animation->participants.erase(key) == 0) return;
+  if (!applicationActiveState() || state.animation->exposedToInactivity) {
+    state.animation->needsForegroundReconciliation = true;
+    return;
+  }
   state.animation->finished = state.animation->finished && finished;
   finishIfNoInstalledParticipants(driverId, state);
 }

package/ios/SmoothClipTurboModule.cpp

@@ -10,7 +10,7 @@
 namespace facebook::react {
 namespace {
 
-constexpr size_t kPresentationStride = 21;
+constexpr size_t kPresentationStride = 23;
 constexpr size_t kSnapshotStride = kPresentationStride + 1;
 constexpr size_t kMotionEntryStride = kPresentationStride * 2 + 2;
 
@@ -65,7 +65,9 @@ smoothclip::Presentation makePresentation(
     double shadowOffsetX = 0,
     double shadowOffsetY = 0,
     double shadowBlurRadius = 0,
-    double shadowSpreadDistance = 0) {
+    double shadowSpreadDistance = 0,
+    double rotation = 0,
+    double opacity = 1) {
   const bool uniform = topLeftRadius == topRightRadius &&
       topLeftRadius == bottomRightRadius &&
       topLeftRadius == bottomLeftRadius;
@@ -82,7 +84,8 @@ smoothclip::Presentation makePresentation(
       contentTranslateY,
       contentScale,
       {shadowEnabled, shadowRed, shadowGreen, shadowBlue, shadowAlpha,
-       shadowOffsetX, shadowOffsetY, shadowBlurRadius, shadowSpreadDistance}};
+       shadowOffsetX, shadowOffsetY, shadowBlurRadius, shadowSpreadDistance},
+      rotation, opacity};
 }
 
 bool finitePresentation(const smoothclip::Presentation &presentation) {
@@ -97,6 +100,7 @@ bool finitePresentation(const smoothclip::Presentation &presentation) {
       std::isfinite(presentation.contentTranslateY) &&
       std::isfinite(presentation.contentScale) &&
       presentation.contentScale > 0 &&
+      std::isfinite(presentation.rotation) && std::isfinite(presentation.opacity) &&
       std::isfinite(presentation.shadow.red) &&
       std::isfinite(presentation.shadow.green) &&
       std::isfinite(presentation.shadow.blue) &&
@@ -141,7 +145,7 @@ bool presentationAt(
       values[11],
       values[12] == 1,
       values[13], values[14], values[15], values[16],
-      values[17], values[18], values[19], values[20]);
+      values[17], values[18], values[19], values[20], values[21], values[22]);
   return finitePresentation(result);
 }
 
@@ -181,6 +185,8 @@ void writePresentation(
   result.setValueAtIndex(runtime, offset + 18, presentation.shadow.offsetY);
   result.setValueAtIndex(runtime, offset + 19, presentation.shadow.blurRadius);
   result.setValueAtIndex(runtime, offset + 20, presentation.shadow.spreadDistance);
+  result.setValueAtIndex(runtime, offset + 21, presentation.rotation);
+  result.setValueAtIndex(runtime, offset + 22, presentation.opacity);
 }
 
 jsi::Array snapshotArray(
@@ -226,6 +232,8 @@ std::vector<double> snapshotValues(
     result.push_back(presentation.shadow.offsetY);
     result.push_back(presentation.shadow.blurRadius);
     result.push_back(presentation.shadow.spreadDistance);
+    result.push_back(presentation.rotation);
+    result.push_back(presentation.opacity);
   }
   return result;
 }
@@ -504,13 +512,16 @@ void SmoothClipTurboModule::setClipFrameScalars(
     double shadowOffsetX,
     double shadowOffsetY,
     double shadowBlurRadius,
-    double shadowSpreadDistance) {
+    double shadowSpreadDistance,
+    double rotation,
+    double opacity) {
   const smoothclip::Presentation presentation = makePresentation(
       x, y, width, height, topLeftRadius, topRightRadius,
       bottomRightRadius, bottomLeftRadius, curveCode,
       contentTranslateX, contentTranslateY, contentScale,
       shadowEnabled, shadowRed, shadowGreen, shadowBlue, shadowAlpha,
-      shadowOffsetX, shadowOffsetY, shadowBlurRadius, shadowSpreadDistance);
+      shadowOffsetX, shadowOffsetY, shadowBlurRadius, shadowSpreadDistance,
+      rotation, opacity);
   if (!validDriverId(driverId) || !finitePresentation(presentation)) return;
   smoothclip::setPresentation(
       static_cast<uint64_t>(driverId), presentation, true, false, true);

package/ios/SmoothClipTurboModule.h

@@ -160,7 +160,9 @@ class SmoothClipTurboModule final
       double shadowOffsetX,
       double shadowOffsetY,
       double shadowBlurRadius,
-      double shadowSpreadDistance);
+      double shadowSpreadDistance,
+      double rotation,
+      double opacity);
   jsi::Array beginInteraction(jsi::Runtime &runtime, double driverId);
   jsi::Array snapshotCurrent(jsi::Runtime &runtime, double driverId);