react-native-smooth-clip-view 0.2.9 → 0.4.0

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

@@ -1,22 +1,23 @@
 package com.smoothclipview
 
+import android.graphics.Path
 import android.view.View
 import kotlin.math.max
 import kotlin.math.min
-import kotlin.math.roundToInt
+
+internal const val CLIP_CURVE_CIRCULAR = 0
+internal const val CLIP_CURVE_CONTINUOUS = 1
 
 /**
- * Normalizes clip geometry without allocating a result object. The callback is
- * inlined into the view's command path so per-frame updates stay allocation-free.
+ * Canonicalizes raw clip geometry without allocating a result object. Host
+ * bounds deliberately do not participate; SmoothClipView crops at draw time.
  */
-internal inline fun normalizeClipGeometryPx(
+internal inline fun canonicalizeClipGeometryPx(
     x: Float,
     y: Float,
     width: Float,
     height: Float,
     radius: Float,
-    hostWidth: Float,
-    hostHeight: Float,
     apply: (
         left: Float,
         top: Float,
@@ -26,107 +27,209 @@ internal inline fun normalizeClipGeometryPx(
     ) -> Unit,
 ): Boolean {
     if (!x.isFinite() || !y.isFinite() || !width.isFinite() ||
-        !height.isFinite() || !radius.isFinite() ||
-        !hostWidth.isFinite() || !hostHeight.isFinite()
+        !height.isFinite() || !radius.isFinite()
     ) {
         return false
     }
 
-    val boundedHostWidth = hostWidth.coerceAtLeast(0f)
-    val boundedHostHeight = hostHeight.coerceAtLeast(0f)
-    val requestedRight = x + width.coerceAtLeast(0f)
-    val requestedBottom = y + height.coerceAtLeast(0f)
-    val left = x.coerceIn(0f, boundedHostWidth)
-    val top = y.coerceIn(0f, boundedHostHeight)
-    val right = requestedRight.coerceIn(0f, boundedHostWidth)
-    val bottom = requestedBottom.coerceIn(0f, boundedHostHeight)
-    val visibleWidth = max(0f, right - left)
-    val visibleHeight = max(0f, bottom - top)
-    val normalizedRadius = min(
+    val canonicalWidth = max(0f, width)
+    val canonicalHeight = max(0f, height)
+    val right = x + canonicalWidth
+    val bottom = y + canonicalHeight
+    if (!right.isFinite() || !bottom.isFinite()) return false
+    val canonicalRadius = min(
         radius.coerceAtLeast(0f),
-        min(visibleWidth, visibleHeight) / 2f,
+        min(canonicalWidth, canonicalHeight) / 2f,
     )
 
-    apply(left, top, right, bottom, normalizedRadius)
+    apply(x, y, right, bottom, canonicalRadius)
     return true
 }
 
-internal fun clipVisibility(isEmpty: Boolean): Int =
-    if (isEmpty) View.INVISIBLE else View.VISIBLE
+/**
+ * Canonicalization with independent radii. Radii use the CSS overlap rule:
+ * one shared factor keeps all four corners proportional when any opposing pair
+ * exceeds the requested width or height. This mirrors
+ * SmoothClipCanonicalize in the shared C++ delivery path.
+ */
+internal inline fun canonicalizeClipGeometryPx(
+    x: Float,
+    y: Float,
+    width: Float,
+    height: Float,
+    topLeftRadius: Float,
+    topRightRadius: Float,
+    bottomRightRadius: Float,
+    bottomLeftRadius: Float,
+    curveCode: Int,
+    apply: (
+        left: Float,
+        top: Float,
+        right: Float,
+        bottom: Float,
+        canonicalTopLeftRadius: Float,
+        canonicalTopRightRadius: Float,
+        canonicalBottomRightRadius: Float,
+        canonicalBottomLeftRadius: Float,
+        canonicalCurveCode: Int,
+    ) -> Unit,
+): Boolean {
+    if (!x.isFinite() || !y.isFinite() || !width.isFinite() ||
+        !height.isFinite() || !topLeftRadius.isFinite() ||
+        !topRightRadius.isFinite() || !bottomRightRadius.isFinite() ||
+        !bottomLeftRadius.isFinite() ||
+        (curveCode != CLIP_CURVE_CIRCULAR && curveCode != CLIP_CURVE_CONTINUOUS)
+    ) {
+        return false
+    }
+
+    val canonicalWidth = max(0f, width)
+    val canonicalHeight = max(0f, height)
+    val right = x + canonicalWidth
+    val bottom = y + canonicalHeight
+    if (!right.isFinite() || !bottom.isFinite()) return false
+    val topLeft = topLeftRadius.coerceAtLeast(0f)
+    val topRight = topRightRadius.coerceAtLeast(0f)
+    val bottomRight = bottomRightRadius.coerceAtLeast(0f)
+    val bottomLeft = bottomLeftRadius.coerceAtLeast(0f)
+
+    var radiusScale = 1f
+    val topWidth = topLeft + topRight
+    val bottomWidth = bottomLeft + bottomRight
+    val leftHeight = topLeft + bottomLeft
+    val rightHeight = topRight + bottomRight
+    if (topWidth > 0f) radiusScale = min(radiusScale, canonicalWidth / topWidth)
+    if (bottomWidth > 0f) radiusScale = min(radiusScale, canonicalWidth / bottomWidth)
+    if (leftHeight > 0f) radiusScale = min(radiusScale, canonicalHeight / leftHeight)
+    if (rightHeight > 0f) radiusScale = min(radiusScale, canonicalHeight / rightHeight)
+    radiusScale = radiusScale.coerceIn(0f, 1f)
 
-/** Rounded integer origin of an outline edge. */
-internal fun outlineOrigin(value: Float): Int = value.roundToInt()
+    apply(
+        x,
+        y,
+        right,
+        bottom,
+        topLeft * radiusScale,
+        topRight * radiusScale,
+        bottomRight * radiusScale,
+        bottomLeft * radiusScale,
+        curveCode,
+    )
+    return true
+}
 
 /**
- * Rounded far edge, derived from the rounded origin plus the rounded extent.
- *
- * `Outline.setRoundRect` takes an int rect, and rounding the two edges
- * independently makes `round(far) - round(origin)` alternate between the floor
- * and the ceil of a *constant* extent as the origin's fraction sweeps: a pure
- * translation breathes the emitted size by 1 px, frame after frame, while the
- * content inside translates in floats. That oscillation is what reads as
- * shimmer on the slow tail of an animation, where the per-frame delta drops
- * below a pixel and the rounding becomes the motion.
- *
- * An int rect cannot hold origin, far edge and extent within half a pixel at
- * once (extent = far - origin, so bounding both edges at 0.5 bounds the extent
- * at 1.0); the only choice is which error oscillates. Deriving the far edge
- * makes the emitted extent a pure function of the true extent — stable, error
- * <= 0.5 px — and moves the slack onto the far edge, <= 1.0 px and static. A
- * static bias does not read as jank; an alternating one does.
- *
- * Two consequences, both benign:
- * - The far edge can overshoot the host bound by up to 1 px instead of 0.5. The
- *   view's own bounds already clip, so an over-large outline just means that
- *   edge is not clipped that frame — which independent rounding already
- *   produced whenever `round(far)` rounded up.
- * - A sub-pixel extent (0 < extent < 0.5) rounds to a degenerate rect, which
- *   `Outline.setRoundRect` collapses to `setEmpty()`. Independent rounding hit
- *   that state on some frames and a 1 px rect on others, i.e. it flickered;
- *   deriving the far edge makes it consistent. The emitted integer rect also
- *   governs visibility, accessibility and hit testing, so a view never remains
- *   logically visible while its outline clips every pixel.
+ * Emits one fixed-topology rounded rectangle for both curve families.
+ * Circular uses the standard quarter-circle cubic coefficient; continuous
+ * keeps both control points at the rectangle corner (coefficient 1), yielding
+ * zero endpoint curvature and a visibly smoother shoulder. "Continuous" is a
+ * library-defined cross-platform curve, not a claim of pixel identity with
+ * Apple's private continuous-corner implementation.
  */
-internal fun outlineFarEdge(origin: Float, far: Float): Int =
-    outlineOrigin(origin) + (far - origin).roundToInt()
+internal fun appendRoundedRectPath(
+    path: Path,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+    topLeftRadius: Float,
+    topRightRadius: Float,
+    bottomRightRadius: Float,
+    bottomLeftRadius: Float,
+    curveCode: Int,
+) {
+    val coefficient = if (curveCode == CLIP_CURVE_CONTINUOUS) {
+        1f
+    } else {
+        0.5522848f
+    }
 
-/** Exactly mirrors the non-empty requirement of Outline.setRoundRect(Int...). */
-internal fun outlineRectIsEmpty(
-    left: Int,
-    top: Int,
-    right: Int,
-    bottom: Int,
-): Boolean = right <= left || bottom <= top
+    path.moveTo(left + topLeftRadius, top)
+    path.lineTo(right - topRightRadius, top)
+    path.cubicTo(
+        right - topRightRadius + coefficient * topRightRadius,
+        top,
+        right,
+        top + topRightRadius - coefficient * topRightRadius,
+        right,
+        top + topRightRadius,
+    )
+    path.lineTo(right, bottom - bottomRightRadius)
+    path.cubicTo(
+        right,
+        bottom - bottomRightRadius + coefficient * bottomRightRadius,
+        right - bottomRightRadius + coefficient * bottomRightRadius,
+        bottom,
+        right - bottomRightRadius,
+        bottom,
+    )
+    path.lineTo(left + bottomLeftRadius, bottom)
+    path.cubicTo(
+        left + bottomLeftRadius - coefficient * bottomLeftRadius,
+        bottom,
+        left,
+        bottom - bottomLeftRadius + coefficient * bottomLeftRadius,
+        left,
+        bottom - bottomLeftRadius,
+    )
+    path.lineTo(left, top + topLeftRadius)
+    path.cubicTo(
+        left,
+        top + topLeftRadius - coefficient * topLeftRadius,
+        left + topLeftRadius - coefficient * topLeftRadius,
+        top,
+        left + topLeftRadius,
+        top,
+    )
+    path.close()
+}
 
 /**
- * Outline dedupe on the rounded integer physical-pixel edges actually emitted
- * to the outline provider. Takes the already-derived edges rather than raw
- * floats so the caller rounds once per frame and the predicate can never drift
- * from what the provider emits; the radius stays a float comparison because it
- * is emitted to the outline as a float.
- *
- * Sub-pixel motion that rounds to the cached integers must NOT invalidate the
- * outline — it is carried on the view's translation instead (see
- * SmoothClipView.applyClipPlacement), which is both cheaper and smoother than
- * restaging an identical rect.
+ * Hit-tests the actual rendered path. Path has no float `contains` API, so we
+ * flatten that same instance to sub-pixel line segments for ACTION_DOWN. This
+ * is deliberately off the render/animation hot path and avoids maintaining a
+ * second analytical curve that can drift from clipping geometry.
  */
-internal fun outlineChanged(
-    left: Int,
-    top: Int,
-    right: Int,
-    bottom: Int,
-    radius: Float,
-    cachedLeft: Int,
-    cachedTop: Int,
-    cachedRight: Int,
-    cachedBottom: Int,
-    cachedRadius: Float,
-): Boolean =
-    left != cachedLeft ||
-        top != cachedTop ||
-        right != cachedRight ||
-        bottom != cachedBottom ||
-        radius != cachedRadius
+internal fun containsPathPoint(path: Path, x: Float, y: Float): Boolean {
+    if (!x.isFinite() || !y.isFinite() || path.isEmpty) return false
+    val points = path.approximate(0.1f)
+    if (points.size < 6) return false
+
+    var inside = false
+    var previousX = points[1]
+    var previousY = points[2]
+    var index = 3
+    while (index + 2 < points.size) {
+        val currentX = points[index + 1]
+        val currentY = points[index + 2]
+        val dx = currentX - previousX
+        val dy = currentY - previousY
+        val segmentLengthSquared = dx * dx + dy * dy
+        if (segmentLengthSquared > 0f) {
+            val projection = (((x - previousX) * dx + (y - previousY) * dy) /
+                segmentLengthSquared).coerceIn(0f, 1f)
+            val projectedX = previousX + projection * dx
+            val projectedY = previousY + projection * dy
+            val distanceX = x - projectedX
+            val distanceY = y - projectedY
+            if (distanceX * distanceX + distanceY * distanceY <= 0.01f) {
+                return true
+            }
+        }
+        if ((currentY > y) != (previousY > y)) {
+            val crossingX = (previousX - currentX) * (y - currentY) /
+                (previousY - currentY) + currentX
+            if (x < crossingX) inside = !inside
+        }
+        previousX = currentX
+        previousY = currentY
+        index += 3
+    }
+    return inside
+}
+
+internal fun renderVisibility(rendersIntoHost: Boolean): Int =
+    if (rendersIntoHost) View.VISIBLE else View.INVISIBLE
 
 internal fun clipAccessibility(
     isEmpty: Boolean,
@@ -137,32 +240,3 @@ internal fun clipAccessibility(
     } else {
         requestedAccessibility
     }
-
-internal fun containsRoundedPointPx(
-    x: Float,
-    y: Float,
-    left: Float,
-    top: Float,
-    right: Float,
-    bottom: Float,
-    radius: Float,
-    isEmpty: Boolean,
-): Boolean {
-    if (isEmpty || x < left || x > right || y < top || y > bottom) {
-        return false
-    }
-
-    if (radius <= 0f) return true
-
-    val innerLeft = left + radius
-    val innerRight = right - radius
-    val innerTop = top + radius
-    val innerBottom = bottom - radius
-    if (x in innerLeft..innerRight || y in innerTop..innerBottom) return true
-
-    val centerX = if (x < innerLeft) innerLeft else innerRight
-    val centerY = if (y < innerTop) innerTop else innerBottom
-    val dx = x - centerX
-    val dy = y - centerY
-    return dx * dx + dy * dy <= radius * radius
-}

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

@@ -26,9 +26,23 @@ internal object SmoothClipBindings {
         y: Double,
         width: Double,
         height: Double,
-        radius: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Int,
         contentTranslateX: Double,
         contentTranslateY: Double,
+        contentScale: Double,
+        shadowEnabled: Boolean,
+        shadowRed: Double,
+        shadowGreen: Double,
+        shadowBlue: Double,
+        shadowAlpha: Double,
+        shadowOffsetX: Double,
+        shadowOffsetY: Double,
+        shadowBlurRadius: Double,
+        shadowSpreadDistance: Double,
         density: Double,
         widthPx: Double,
         heightPx: Double,
@@ -36,8 +50,9 @@ internal object SmoothClipBindings {
     )
 
     /**
-     * Pushes a registered view's density and pixel host size so driver
-     * deliveries are pre-normalized in C++; redelivers the visible value.
+     * Pushes a registered view's density and pixel host size. Density converts
+     * raw DIP presentations to pixels; host size controls readiness and the
+     * fixed rendering viewport, but never rewrites registry geometry.
      */
     external fun nativeSetViewHostGeometry(
         driverId: Double,
@@ -49,9 +64,12 @@ internal object SmoothClipBindings {
 
     external fun nativeUnregisterView(driverId: Double, view: SmoothClipView)
 
+    /** Destroys a controller after [SmoothClipModule] forwards teardown to main. */
+    external fun nativeDestroyDriver(driverId: Double)
+
     /**
      * Pushes both positive and negative attachment/window-visibility state.
-     * The registry combines it with real host geometry before a latch can run.
+     * The registry combines it with real host geometry before a pending run starts.
      */
     external fun nativeSetViewLifecycleVisibility(
         driverId: Double,

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

@@ -3,6 +3,7 @@ package com.smoothclipview
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.turbomodule.core.interfaces.BindingsInstallerHolder
@@ -29,92 +30,112 @@ class SmoothClipModule(context: ReactApplicationContext) :
         SmoothClipBindings.nativeInvalidate()
     }
 
+    // Static complex paths are supported, but autonomous animation remains a
+    // measured capability. Keep it disabled until the physical-device path
+    // sampling and frame-time gates are run for this release.
+    override fun supportsAutonomousComplexPathAnimation(): Boolean = false
+
+    override fun beginGroupInteraction(driverIds: ReadableArray): WritableArray =
+        Arguments.createArray()
+
+    override fun snapshotGroup(driverIds: ReadableArray): WritableArray =
+        Arguments.createArray()
+
+    override fun setClipPresentationBatch(entries: ReadableArray): Boolean = false
+
+    override fun animateTimingGroup(
+        controllerId: Double,
+        entries: ReadableArray,
+        durationMs: Double,
+        controlPoint1X: Double,
+        controlPoint1Y: Double,
+        controlPoint2X: Double,
+        controlPoint2Y: Double,
+        reduceMotion: Double,
+        completionTag: Double,
+        startTimestamp: Double,
+    ): Double = 0.0
+
+    override fun animateSpringGroup(
+        controllerId: Double,
+        entries: ReadableArray,
+        mass: Double,
+        stiffness: Double,
+        damping: Double,
+        velocity: Double,
+        energyThreshold: Double,
+        reduceMotion: Double,
+        completionTag: Double,
+        startTimestamp: Double,
+    ): Double = 0.0
+
+    override fun cancelAnimationGroup(
+        groupId: Double,
+        behavior: Double,
+    ): WritableArray = Arguments.createArray()
+
     override fun setClipPresentation(
+        driverId: Double,
+        presentation: ReadableArray,
+        takeOwnership: Boolean,
+        overridePendingAnimation: Boolean,
+    ) = Unit
+
+    override fun setClipFrameScalars(
         driverId: Double,
         x: Double,
         y: Double,
         width: Double,
         height: Double,
-        radius: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
         contentTranslateX: Double,
         contentTranslateY: Double,
-        takeOwnership: Boolean,
-        overridePendingAnimation: Boolean,
+        contentScale: Double,
+        shadowEnabled: Boolean,
+        shadowRed: Double,
+        shadowGreen: Double,
+        shadowBlue: Double,
+        shadowAlpha: Double,
+        shadowOffsetX: Double,
+        shadowOffsetY: Double,
+        shadowBlurRadius: Double,
+        shadowSpreadDistance: Double,
     ) = Unit
 
     override fun beginInteraction(driverId: Double): WritableArray =
         Arguments.createArray()
 
+    override fun snapshotCurrent(driverId: Double): WritableArray =
+        Arguments.createArray()
+
     override fun animateTiming(
         driverId: Double,
-        hasInteractiveStart: Boolean,
-        startX: Double,
-        startY: Double,
-        startWidth: Double,
-        startHeight: Double,
-        startRadius: Double,
-        startContentTranslateX: Double,
-        startContentTranslateY: Double,
-        x: Double,
-        y: Double,
-        width: Double,
-        height: Double,
-        radius: Double,
-        contentTranslateX: Double,
-        contentTranslateY: Double,
+        start: ReadableArray,
+        target: ReadableArray,
         durationMs: Double,
         controlPoint1X: Double,
         controlPoint1Y: Double,
         controlPoint2X: Double,
         controlPoint2Y: Double,
         reduceMotion: Double,
+        completionTag: Double,
     ): Double = 0.0
 
     override fun animateSpring(
         driverId: Double,
-        hasInteractiveStart: Boolean,
-        startX: Double,
-        startY: Double,
-        startWidth: Double,
-        startHeight: Double,
-        startRadius: Double,
-        startContentTranslateX: Double,
-        startContentTranslateY: Double,
-        x: Double,
-        y: Double,
-        width: Double,
-        height: Double,
-        radius: Double,
-        contentTranslateX: Double,
-        contentTranslateY: Double,
+        start: ReadableArray,
+        target: ReadableArray,
         mass: Double,
         stiffness: Double,
         damping: Double,
         initialVelocity: Double,
         inheritVelocity: Boolean,
         reduceMotion: Double,
-    ): Double = 0.0
-
-    override fun animateKeyframes(
-        driverId: Double,
-        hasInteractiveStart: Boolean,
-        startX: Double,
-        startY: Double,
-        startWidth: Double,
-        startHeight: Double,
-        startRadius: Double,
-        startContentTranslateX: Double,
-        startContentTranslateY: Double,
-        x: Double,
-        y: Double,
-        width: Double,
-        height: Double,
-        radius: Double,
-        contentTranslateX: Double,
-        contentTranslateY: Double,
-        durationMs: Double,
-        frames: ReadableArray,
-        reduceMotion: Double,
+        completionTag: Double,
     ): Double = 0.0
 
     override fun rejectAnimation(driverId: Double): Double = 0.0
@@ -125,5 +146,9 @@ class SmoothClipModule(context: ReactApplicationContext) :
         behavior: Double,
     ): WritableArray = Arguments.createArray()
 
-    override fun destroyDriver(driverId: Double) = Unit
+    override fun destroyDriver(driverId: Double) {
+        UiThreadUtil.runOnUiThread {
+            SmoothClipBindings.nativeDestroyDriver(driverId)
+        }
+    }
 }