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

package/android/src/main/java/com/smoothclipview/SmoothClipBindings.kt

@@ -32,6 +32,7 @@ internal object SmoothClipBindings {
         density: Double,
         widthPx: Double,
         heightPx: Double,
+        lifecycleVisible: Boolean,
     )
 
     /**
@@ -49,11 +50,14 @@ internal object SmoothClipBindings {
     external fun nativeUnregisterView(driverId: Double, view: SmoothClipView)
 
     /**
-     * Notifies the registry that a registered view attached to a window; a
-     * latched animation may only start once a view can produce a visible
-     * frame (attached and with real host geometry).
+     * Pushes both positive and negative attachment/window-visibility state.
+     * The registry combines it with real host geometry before a latch can run.
      */
-    external fun nativeViewBecameDisplayable(driverId: Double, view: SmoothClipView)
+    external fun nativeSetViewLifecycleVisibility(
+        driverId: Double,
+        view: SmoothClipView,
+        lifecycleVisible: Boolean,
+    )
 
     /**
      * Releases runtime-bound listener state during host teardown; must run

package/android/src/main/java/com/smoothclipview/SmoothClipView.kt

@@ -41,6 +41,7 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
     private var userTranslationY = 0f
     private var requestedImportantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_AUTO
     private var acceptingTouchStream = false
+    private var retainedTouchEvent: MotionEvent? = null
 
     /** Driver this view is registered with in the native registry (0 = none). */
     internal var boundDriverId: Double = 0.0
@@ -212,13 +213,13 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
         applyClipPlacement()
 
         if (isEmpty != clipIsEmpty) {
+            if (isEmpty) cancelAcceptedTouchStream()
             clipIsEmpty = isEmpty
             visibility = clipVisibility(isEmpty)
             importantForAccessibility = clipAccessibility(
                 isEmpty,
                 requestedImportantForAccessibility,
             )
-            if (isEmpty) acceptingTouchStream = false
         }
 
         // An emptiness transition necessarily changes at least one emitted
@@ -299,12 +300,24 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
+        pushLifecycleVisibility()
+    }
+
+    override fun onDetachedFromWindow() {
         if (boundDriverId != 0.0) {
-            // A latched animation may only start once this view can produce a
-            // visible frame; window attach is that signal for views that
-            // registered from a detached subtree.
-            SmoothClipBindings.nativeViewBecameDisplayable(boundDriverId, this)
+            SmoothClipBindings.nativeSetViewLifecycleVisibility(
+                boundDriverId,
+                this,
+                false,
+            )
         }
+        clearTouchState()
+        super.onDetachedFromWindow()
+    }
+
+    override fun onWindowVisibilityChanged(visibility: Int) {
+        super.onWindowVisibilityChanged(visibility)
+        pushLifecycleVisibility()
     }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
@@ -324,6 +337,18 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
 
     internal fun densityScale(): Double = PixelUtil.toPixelFromDIP(1f).toDouble()
 
+    internal fun isHostLifecycleVisible(): Boolean =
+        isAttachedToWindow && windowVisibility == VISIBLE
+
+    private fun pushLifecycleVisibility() {
+        if (boundDriverId == 0.0) return
+        SmoothClipBindings.nativeSetViewLifecycleVisibility(
+            boundDriverId,
+            this,
+            isHostLifecycleVisible(),
+        )
+    }
+
     private fun containsRoundedPoint(x: Float, y: Float): Boolean {
         // The event arrives in this view's local space, which the parent has
         // already inverse-transformed by the residual translation. Adding it
@@ -345,8 +370,16 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
     override fun dispatchTouchEvent(event: MotionEvent): Boolean {
         when (event.actionMasked) {
             MotionEvent.ACTION_DOWN -> {
+                clearTouchState()
                 acceptingTouchStream = containsRoundedPoint(event.x, event.y)
                 if (!acceptingTouchStream) return false
+                val accepted = super.dispatchTouchEvent(event)
+                if (accepted) {
+                    retainTouchEvent(event)
+                } else {
+                    clearTouchState()
+                }
+                return accepted
             }
             MotionEvent.ACTION_CANCEL, MotionEvent.ACTION_UP -> {
                 val result = if (acceptingTouchStream) {
@@ -354,12 +387,46 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
                 } else {
                     false
                 }
-                acceptingTouchStream = false
+                clearTouchState()
                 return result
             }
         }
 
-        return acceptingTouchStream && super.dispatchTouchEvent(event)
+        if (!acceptingTouchStream) return false
+        val result = super.dispatchTouchEvent(event)
+        retainTouchEvent(event)
+        return result
+    }
+
+    private fun retainTouchEvent(event: MotionEvent) {
+        retainedTouchEvent?.recycle()
+        retainedTouchEvent = MotionEvent.obtain(event)
+    }
+
+    private fun clearTouchState() {
+        acceptingTouchStream = false
+        retainedTouchEvent?.recycle()
+        retainedTouchEvent = null
+    }
+
+    private fun cancelAcceptedTouchStream() {
+        val latest = retainedTouchEvent
+        if (!acceptingTouchStream || latest == null) {
+            clearTouchState()
+            return
+        }
+        val cancel = MotionEvent.obtain(latest)
+        cancel.action = MotionEvent.ACTION_CANCEL
+        // Terminal BEFORE dispatch: a child's synchronous cancel handler can
+        // re-enter geometry application, and a nested emptiness transition
+        // must observe an already-ended stream instead of synthesizing a
+        // second cancel for it.
+        clearTouchState()
+        try {
+            super.dispatchTouchEvent(cancel)
+        } finally {
+            cancel.recycle()
+        }
     }
 
     fun setRequestedImportantForAccessibility(value: Int) {
@@ -383,7 +450,7 @@ class SmoothClipView(context: ThemedReactContext) : ReactViewGroup(context) {
     }
 
     fun resetClipState() {
-        acceptingTouchStream = false
+        clearTouchState()
         commandIsAuthoritative = false
         requestedX = 0f
         requestedY = 0f

package/android/src/main/java/com/smoothclipview/SmoothClipViewManager.kt

@@ -167,6 +167,7 @@ class SmoothClipViewManager : ViewGroupManager<SmoothClipView>(),
                 view.densityScale(),
                 view.width.toDouble(),
                 view.height.toDouble(),
+                view.isHostLifecycleVisible(),
             )
         } else if (!view.commandIsAuthoritative) {
             // Command-driven mode (driverId 0): the initial props are the only

package/cpp/SmoothClipAnimationCurve.h

@@ -147,6 +147,11 @@ struct TimingRemainder {
   bool representable;
 };
 
+struct TimingContinuation {
+  Presentation start;
+  TimingAnimation animation;
+};
+
 // Exact right-hand segment of a CSS/CoreAnimation cubic Bezier after a raw
 // time cutoff. Restarting the original controls from a frozen presentation
 // resets its slope and creates a visible velocity cusp. De Casteljau splitting
@@ -321,6 +326,39 @@ inline Presentation interpolate(
       mix(from.contentTranslateY, to.contentTranslateY)};
 }
 
+// Freezes a timing animation at one already-rendered raw-time phase and
+// returns the exact right-hand Bezier segment. Keeping the presentation and
+// residual curve in one helper prevents lifecycle code from sampling one
+// timestamp for the geometry and another for the duration.
+inline TimingContinuation timingContinuation(
+    const TimingAnimation &original,
+    const Presentation &start,
+    const Presentation &target,
+    double rawProgress) {
+  const TimingRemainder remainder = timingRemainder(original, rawProgress);
+  return {
+      interpolate(start, target, remainder.easedProgress),
+      remainder.animation};
+}
+
+// Android lifecycle callbacks can arrive long after the frame whose
+// presentation was actually delivered. Keep the clock inputs at this shared
+// boundary so callers cannot accidentally trim from callback wall time while
+// calculating geometry from the last rendered frame.
+inline TimingContinuation timingContinuationAtFrame(
+    const TimingAnimation &original,
+    const Presentation &start,
+    const Presentation &target,
+    double lastRenderedS,
+    double startedAtS,
+    double durationS) {
+  return timingContinuation(
+      original,
+      start,
+      target,
+      timingFraction(lastRenderedS, startedAtS, durationS));
+}
+
 // --- Keyframe curve -------------------------------------------------------
 
 // Keyframes sampled from a smooth path, evaluated with monotone cubic Hermite
@@ -465,4 +503,58 @@ class KeyframeCurve {
   std::size_t cursor_ = 1;
 };
 
+struct KeyframeContinuation {
+  Presentation start;
+  std::vector<Keyframe> frames;
+  double durationMs;
+};
+
+// Trims keyframes at the same raw-time phase that produced `frozen`. The new
+// zero frame is the rendered presentation, not an analytically re-sampled
+// neighbor, so a pause/re-latch cannot jump at the seam. Strictly increasing
+// remapped offsets avoid duplicate/division-by-zero segments after repeated
+// trims or floating-point collisions near the cutoff.
+inline KeyframeContinuation keyframeContinuation(
+    const std::vector<Keyframe> &frames,
+    const Presentation &frozen,
+    const Presentation &target,
+    double durationMs,
+    double rawProgress) {
+  const double progress = clamp01(rawProgress);
+  KeyframeContinuation result{
+      frozen, {{0.0, frozen}}, std::max(0.0, durationMs * (1 - progress))};
+  if (progress < 1.0) {
+    for (const Keyframe &frame : frames) {
+      if (frame.offset <= progress) continue;
+      const double offset = clamp01(
+          (frame.offset - progress) / (1 - progress));
+      if (offset <= result.frames.back().offset + 1e-12) continue;
+      result.frames.push_back({offset, frame.presentation});
+    }
+  }
+  if (result.frames.size() == 1 ||
+      result.frames.back().offset < 1.0 - 1e-12) {
+    result.frames.push_back({1.0, target});
+  } else {
+    result.frames.back().offset = 1.0;
+    result.frames.back().presentation = target;
+  }
+  return result;
+}
+
+inline KeyframeContinuation keyframeContinuationAtFrame(
+    const std::vector<Keyframe> &frames,
+    const Presentation &frozen,
+    const Presentation &target,
+    double lastRenderedS,
+    double startedAtS,
+    double durationS) {
+  return keyframeContinuation(
+      frames,
+      frozen,
+      target,
+      std::max(0.0, durationS * 1000.0),
+      timingFraction(lastRenderedS, startedAtS, durationS));
+}
+
 } // namespace smoothclip

package/cpp/SmoothClipVelocityTracker.h

@@ -67,13 +67,11 @@ inline void recordVelocitySample(
   history.latestTimeS = nowS;
 }
 
-// beginInteraction on both platforms records the frozen presentation as a
-// plain sample: a grab mid-animation pairs the frozen value with the last
-// real sample, so an instant refling inherits bounded recent motion instead
-// of launching dead, and a grab at an unchanged value dedupes to a no-op
-// whose staleness keeps aging. There is deliberately no reset primitive —
-// the staleness decay below is the forgetting mechanism, and it forgets
-// gradually rather than all at once.
+// Only explicit interactive writes route through this recorder. Native
+// freeze/join/resume/static-finalization paths deliberately do not, so an
+// animation cannot manufacture a later inherited velocity. During ordinary
+// interaction, the staleness decay below is the forgetting mechanism and it
+// forgets gradually rather than all at once.
 
 inline void clearVelocitySamples(VelocitySampleHistory &history) {
   history = VelocitySampleHistory{};