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

package/android/src/main/cpp/SmoothClipTrace.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#if defined(SMOOTH_CLIP_ENABLE_ATRACE)
+
+#include <android/trace.h>
+
+namespace smoothclip::trace {
+
+class ScopedSection {
+ public:
+  explicit ScopedSection(const char *name) { ATrace_beginSection(name); }
+
+  ~ScopedSection() { ATrace_endSection(); }
+};
+
+} // namespace smoothclip::trace
+
+#define SMOOTH_CLIP_TRACE(name) \
+  ::smoothclip::trace::ScopedSection smoothClipTraceSection{name}
+
+#else
+
+#define SMOOTH_CLIP_TRACE(name)
+
+#endif

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

@@ -1,10 +1,14 @@
 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.
@@ -51,6 +55,267 @@ internal inline fun normalizeClipGeometryPx(
     return true
 }
 
+/**
+ * V2 normalization with independent radii. Radii use the CSS overlap rule:
+ * one shared factor keeps all four corners proportional when any opposing pair
+ * exceeds the visible width or height. This mirrors SmoothClipNormalizeV2 in
+ * the shared C++ delivery path.
+ */
+internal inline fun normalizeClipGeometryV2Px(
+    x: Float,
+    y: Float,
+    width: Float,
+    height: Float,
+    topLeftRadius: Float,
+    topRightRadius: Float,
+    bottomRightRadius: Float,
+    bottomLeftRadius: Float,
+    curveCode: Int,
+    hostWidth: Float,
+    hostHeight: Float,
+    apply: (
+        left: Float,
+        top: Float,
+        right: Float,
+        bottom: Float,
+        normalizedTopLeftRadius: Float,
+        normalizedTopRightRadius: Float,
+        normalizedBottomRightRadius: Float,
+        normalizedBottomLeftRadius: Float,
+        normalizedCurveCode: Int,
+    ) -> Unit,
+): Boolean {
+    if (!x.isFinite() || !y.isFinite() || !width.isFinite() ||
+        !height.isFinite() || !topLeftRadius.isFinite() ||
+        !topRightRadius.isFinite() || !bottomRightRadius.isFinite() ||
+        !bottomLeftRadius.isFinite() || !hostWidth.isFinite() ||
+        !hostHeight.isFinite() ||
+        (curveCode != CLIP_CURVE_CIRCULAR && curveCode != CLIP_CURVE_CONTINUOUS)
+    ) {
+        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 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, visibleWidth / topWidth)
+    if (bottomWidth > 0f) radiusScale = min(radiusScale, visibleWidth / bottomWidth)
+    if (leftHeight > 0f) radiusScale = min(radiusScale, visibleHeight / leftHeight)
+    if (rightHeight > 0f) radiusScale = min(radiusScale, visibleHeight / rightHeight)
+    radiusScale = radiusScale.coerceIn(0f, 1f)
+
+    apply(
+        left,
+        top,
+        right,
+        bottom,
+        topLeft * radiusScale,
+        topRight * radiusScale,
+        bottomRight * radiusScale,
+        bottomLeft * radiusScale,
+        curveCode,
+    )
+    return true
+}
+
+/**
+ * Emits one fixed-topology rounded rectangle for both V2 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 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
+    }
+
+    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()
+}
+
+/**
+ * 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 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 containsRoundedPointV2Px(
+    x: Float,
+    y: Float,
+    left: Float,
+    top: Float,
+    right: Float,
+    bottom: Float,
+    topLeftRadius: Float,
+    topRightRadius: Float,
+    bottomRightRadius: Float,
+    bottomLeftRadius: Float,
+    curveCode: Int,
+    isEmpty: Boolean,
+): Boolean {
+    if (isEmpty || x < left || x > right || y < top || y > bottom) return false
+
+    fun containsCorner(inwardX: Float, inwardY: Float): Boolean {
+        if (curveCode == CLIP_CURVE_CIRCULAR) {
+            val dx = inwardX - 1f
+            val dy = inwardY - 1f
+            return dx * dx + dy * dy <= 1f
+        }
+
+        // Invert the rendered cubic's inward-x component. This runs only for
+        // ACTION_DOWN hit testing, never on the animation/render hot path.
+        var low = 0f
+        var high = 1f
+        repeat(12) {
+            val t = (low + high) / 2f
+            val inverse = 1f - t
+            val boundaryInwardX = inverse * inverse * inverse
+            if (boundaryInwardX > inwardX) {
+                low = t
+            } else {
+                high = t
+            }
+        }
+        val t = (low + high) / 2f
+        val boundaryInwardY = t * t * t
+        return inwardY >= boundaryInwardY
+    }
+
+    if (topLeftRadius > 0f && x < left + topLeftRadius && y < top + topLeftRadius) {
+        return containsCorner(
+            (x - left) / topLeftRadius,
+            (y - top) / topLeftRadius,
+        )
+    }
+    if (topRightRadius > 0f && x > right - topRightRadius && y < top + topRightRadius) {
+        return containsCorner(
+            (right - x) / topRightRadius,
+            (y - top) / topRightRadius,
+        )
+    }
+    if (bottomRightRadius > 0f &&
+        x > right - bottomRightRadius && y > bottom - bottomRightRadius
+    ) {
+        return containsCorner(
+            (right - x) / bottomRightRadius,
+            (bottom - y) / bottomRightRadius,
+        )
+    }
+    if (bottomLeftRadius > 0f && x < left + bottomLeftRadius && y > bottom - bottomLeftRadius) {
+        return containsCorner(
+            (x - left) / bottomLeftRadius,
+            (bottom - y) / bottomLeftRadius,
+        )
+    }
+    return true
+}
+
 internal fun clipVisibility(isEmpty: Boolean): Int =
     if (isEmpty) View.INVISIBLE else View.VISIBLE
 

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

@@ -35,6 +35,27 @@ internal object SmoothClipBindings {
         lifecycleVisible: Boolean,
     )
 
+    external fun nativeRegisterViewV2(
+        driverId: Double,
+        view: SmoothClipView,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Int,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        density: Double,
+        widthPx: Double,
+        heightPx: Double,
+        lifecycleVisible: Boolean,
+    )
+
     /**
      * Pushes a registered view's density and pixel host size so driver
      * deliveries are pre-normalized in C++; redelivers the visible value.

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

@@ -29,6 +29,58 @@ class SmoothClipModule(context: ReactApplicationContext) :
         SmoothClipBindings.nativeInvalidate()
     }
 
+    override fun getPresentationProtocolVersion(): Double = 2.0
+
+    // 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 beginGroupInteractionV2(driverIds: ReadableArray): WritableArray =
+        Arguments.createArray()
+
+    override fun snapshotGroupV2(driverIds: ReadableArray): WritableArray =
+        Arguments.createArray()
+
+    override fun setClipPresentationBatchV2(entries: ReadableArray): Boolean = false
+
+    override fun animateTimingGroupV2(
+        controllerId: Double,
+        entries: ReadableArray,
+        durationMs: Double,
+        controlPoint1X: Double,
+        controlPoint1Y: Double,
+        controlPoint2X: Double,
+        controlPoint2Y: Double,
+        reduceMotion: Double,
+        suspensionPolicy: Double,
+    ): Double = 0.0
+
+    override fun animateSpringGroupV2(
+        controllerId: Double,
+        entries: ReadableArray,
+        mass: Double,
+        stiffness: Double,
+        damping: Double,
+        initialVelocity: Double,
+        inheritVelocity: Boolean,
+        reduceMotion: Double,
+        suspensionPolicy: Double,
+    ): Double = 0.0
+
+    override fun animateKeyframesGroupV2(
+        controllerId: Double,
+        entries: ReadableArray,
+        durationMs: Double,
+        reduceMotion: Double,
+        suspensionPolicy: Double,
+    ): Double = 0.0
+
+    override fun cancelAnimationGroupV2(
+        groupId: Double,
+        behavior: Double,
+    ): WritableArray = Arguments.createArray()
+
     override fun setClipPresentation(
         driverId: Double,
         x: Double,
@@ -42,9 +94,33 @@ class SmoothClipModule(context: ReactApplicationContext) :
         overridePendingAnimation: Boolean,
     ) = Unit
 
+    override fun setClipPresentationV2(
+        driverId: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        takeOwnership: Boolean,
+        overridePendingAnimation: Boolean,
+    ) = Unit
+
     override fun beginInteraction(driverId: Double): WritableArray =
         Arguments.createArray()
 
+    override fun beginInteractionV2(driverId: Double): WritableArray =
+        Arguments.createArray()
+
+    override fun snapshotCurrentV2(driverId: Double): WritableArray =
+        Arguments.createArray()
+
     override fun animateTiming(
         driverId: Double,
         hasInteractiveStart: Boolean,
@@ -70,6 +146,41 @@ class SmoothClipModule(context: ReactApplicationContext) :
         reduceMotion: Double,
     ): Double = 0.0
 
+    override fun animateTimingV2(
+        driverId: Double,
+        hasInteractiveStart: Boolean,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startTopLeftRadius: Double,
+        startTopRightRadius: Double,
+        startBottomRightRadius: Double,
+        startBottomLeftRadius: Double,
+        startCurveCode: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        startContentScale: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        durationMs: Double,
+        controlPoint1X: Double,
+        controlPoint1Y: Double,
+        controlPoint2X: Double,
+        controlPoint2Y: Double,
+        reduceMotion: Double,
+    ): Double = 0.0
+
     override fun animateSpring(
         driverId: Double,
         hasInteractiveStart: Boolean,
@@ -95,6 +206,41 @@ class SmoothClipModule(context: ReactApplicationContext) :
         reduceMotion: Double,
     ): Double = 0.0
 
+    override fun animateSpringV2(
+        driverId: Double,
+        hasInteractiveStart: Boolean,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startTopLeftRadius: Double,
+        startTopRightRadius: Double,
+        startBottomRightRadius: Double,
+        startBottomLeftRadius: Double,
+        startCurveCode: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        startContentScale: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        mass: Double,
+        stiffness: Double,
+        damping: Double,
+        initialVelocity: Double,
+        inheritVelocity: Boolean,
+        reduceMotion: Double,
+    ): Double = 0.0
+
     override fun animateKeyframes(
         driverId: Double,
         hasInteractiveStart: Boolean,
@@ -117,6 +263,137 @@ class SmoothClipModule(context: ReactApplicationContext) :
         reduceMotion: Double,
     ): Double = 0.0
 
+    override fun animateKeyframesV2(
+        driverId: Double,
+        hasInteractiveStart: Boolean,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startTopLeftRadius: Double,
+        startTopRightRadius: Double,
+        startBottomRightRadius: Double,
+        startBottomLeftRadius: Double,
+        startCurveCode: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        startContentScale: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        durationMs: Double,
+        frames: ReadableArray,
+        reduceMotion: Double,
+    ): Double = 0.0
+
+    override fun animateTimingFromV2(
+        driverId: Double,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startTopLeftRadius: Double,
+        startTopRightRadius: Double,
+        startBottomRightRadius: Double,
+        startBottomLeftRadius: Double,
+        startCurveCode: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        startContentScale: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        durationMs: Double,
+        controlPoint1X: Double,
+        controlPoint1Y: Double,
+        controlPoint2X: Double,
+        controlPoint2Y: Double,
+        reduceMotion: Double,
+    ): Double = 0.0
+
+    override fun animateSpringFromV2(
+        driverId: Double,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startTopLeftRadius: Double,
+        startTopRightRadius: Double,
+        startBottomRightRadius: Double,
+        startBottomLeftRadius: Double,
+        startCurveCode: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        startContentScale: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        mass: Double,
+        stiffness: Double,
+        damping: Double,
+        initialVelocity: Double,
+        inheritVelocity: Boolean,
+        reduceMotion: Double,
+    ): Double = 0.0
+
+    override fun animateKeyframesFromV2(
+        driverId: Double,
+        startX: Double,
+        startY: Double,
+        startWidth: Double,
+        startHeight: Double,
+        startTopLeftRadius: Double,
+        startTopRightRadius: Double,
+        startBottomRightRadius: Double,
+        startBottomLeftRadius: Double,
+        startCurveCode: Double,
+        startContentTranslateX: Double,
+        startContentTranslateY: Double,
+        startContentScale: Double,
+        x: Double,
+        y: Double,
+        width: Double,
+        height: Double,
+        topLeftRadius: Double,
+        topRightRadius: Double,
+        bottomRightRadius: Double,
+        bottomLeftRadius: Double,
+        curveCode: Double,
+        contentTranslateX: Double,
+        contentTranslateY: Double,
+        contentScale: Double,
+        durationMs: Double,
+        frames: ReadableArray,
+        reduceMotion: Double,
+    ): Double = 0.0
+
     override fun rejectAnimation(driverId: Double): Double = 0.0
 
     override fun cancelAnimation(
@@ -125,5 +402,11 @@ class SmoothClipModule(context: ReactApplicationContext) :
         behavior: Double,
     ): WritableArray = Arguments.createArray()
 
+    override fun cancelAnimationV2(
+        driverId: Double,
+        animationId: Double,
+        behavior: Double,
+    ): WritableArray = Arguments.createArray()
+
     override fun destroyDriver(driverId: Double) = Unit
 }