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

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

@@ -4,23 +4,20 @@ 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,
@@ -30,38 +27,32 @@ 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
 }
 
 /**
- * V2 normalization with independent radii. Radii use the CSS overlap rule:
+ * Canonicalization 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.
+ * exceeds the requested width or height. This mirrors
+ * SmoothClipCanonicalize in the shared C++ delivery path.
  */
-internal inline fun normalizeClipGeometryV2Px(
+internal inline fun canonicalizeClipGeometryPx(
     x: Float,
     y: Float,
     width: Float,
@@ -71,40 +62,32 @@ internal inline fun normalizeClipGeometryV2Px(
     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,
+        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() || !hostWidth.isFinite() ||
-        !hostHeight.isFinite() ||
+        !bottomLeftRadius.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 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)
@@ -115,15 +98,15 @@ internal inline fun normalizeClipGeometryV2Px(
     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)
+    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)
 
     apply(
-        left,
-        top,
+        x,
+        y,
         right,
         bottom,
         topLeft * radiusScale,
@@ -136,7 +119,7 @@ internal inline fun normalizeClipGeometryV2Px(
 }
 
 /**
- * Emits one fixed-topology rounded rectangle for both V2 curve families.
+ * 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
@@ -245,153 +228,8 @@ internal fun containsPathPoint(path: Path, x: Float, y: Float): Boolean {
     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
-
-/** Rounded integer origin of an outline edge. */
-internal fun outlineOrigin(value: Float): Int = value.roundToInt()
-
-/**
- * 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.
- */
-internal fun outlineFarEdge(origin: Float, far: Float): Int =
-    outlineOrigin(origin) + (far - origin).roundToInt()
-
-/** 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
-
-/**
- * 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.
- */
-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 renderVisibility(rendersIntoHost: Boolean): Int =
+    if (rendersIntoHost) View.VISIBLE else View.INVISIBLE
 
 internal fun clipAccessibility(
     isEmpty: Boolean,
@@ -402,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

@@ -20,22 +20,6 @@ internal object SmoothClipBindings {
     external fun getBindingsInstaller(): BindingsInstallerHolder
 
     external fun nativeRegisterView(
-        driverId: Double,
-        view: SmoothClipView,
-        x: Double,
-        y: Double,
-        width: Double,
-        height: Double,
-        radius: Double,
-        contentTranslateX: Double,
-        contentTranslateY: Double,
-        density: Double,
-        widthPx: Double,
-        heightPx: Double,
-        lifecycleVisible: Boolean,
-    )
-
-    external fun nativeRegisterViewV2(
         driverId: Double,
         view: SmoothClipView,
         x: Double,
@@ -50,6 +34,15 @@ internal object SmoothClipBindings {
         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,
@@ -57,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,
@@ -70,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,