react-native-blur-vibe 0.1.14 → 0.1.15

package/android/src/main/java/com/blurvibe/BlurVibeViewApi31.kt

@@ -7,7 +7,6 @@ import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.LinearGradient
 import android.graphics.Paint
-import android.graphics.PixelFormat
 import android.graphics.PorterDuff
 import android.graphics.PorterDuffXfermode
 import android.graphics.RadialGradient
@@ -20,8 +19,6 @@ import android.os.HandlerThread
 import android.os.Looper
 import android.util.TypedValue
 import android.view.Choreographer
-import android.view.PixelCopy
-import android.view.Surface
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewOutlineProvider
@@ -40,8 +37,8 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
 
   // ── Blur params ────────────────────────────────────────────────────────────
 
-  private var blurAmount   = 10f
-  private var overlayColor = Color.TRANSPARENT
+  private var blurAmount     = 10f
+  private var overlayColor   = Color.TRANSPARENT
   private var cornerRadiusPx = 0f
 
   // ── Progressive blur ──────────────────────────────────────────────────────
@@ -57,14 +54,11 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   private val noisePaint  = Paint()
 
   // ── Bitmap double-buffer ──────────────────────────────────────────────────
-  //
-  // pixelCopyBitmap: written by PixelCopy (on its own callback thread)
-  // scaledBitmap:    written by workerThread after downsampling
-  // readyBitmap:     @Volatile — RenderThread reads this in onDraw()
 
-  private var pixelCopyBitmap: Bitmap? = null
-  private var scaledBitmap:    Bitmap? = null
-  @Volatile private var readyBitmap:   Bitmap? = null
+  private var captureBitmap: Bitmap? = null   // full-size capture (main thread)
+  private var scaledBitmap:  Bitmap? = null   // downsampled + blurred (worker thread)
+  @Volatile
+  private var readyBitmap:   Bitmap? = null   // @Volatile pointer — RenderThread reads this
 
   private val capturePaint = Paint(Paint.FILTER_BITMAP_FLAG)
   private val bitmapPaint  = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG)
@@ -76,20 +70,20 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   private val workerHandler = Handler(workerThread.looper)
   private val mainHandler   = Handler(Looper.getMainLooper())
 
-  // ── Root / window ─────────────────────────────────────────────────────────
+  // ── Root ──────────────────────────────────────────────────────────────────
 
-  private var blurRoot:  ViewGroup? = null
+  private var blurRoot: ViewGroup? = null
   private val myLoc    = IntArray(2)
   private val rootLoc  = IntArray(2)
 
   // ── State ─────────────────────────────────────────────────────────────────
 
-  var isCapturing    = false
+  // isCapturing: public read so BlurVibeViewApi31.draw() can check it
+  var isCapturing     = false
     private set
   private var blurEnabled    = true
   private var autoUpdate     = true
   private var frameScheduled = false
-  private var pixelCopyInFlight = false
 
   // ── Choreographer gate ────────────────────────────────────────────────────
 
@@ -117,8 +111,9 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
 
   init {
     setWillNotDraw(false)
-    // outlineProvider = BACKGROUND: ReactViewBackgroundDrawable implements
-    // getOutline() correctly for all RN borderRadius variants automatically.
+    // outlineProvider = BACKGROUND uses ReactViewBackgroundDrawable.getOutline()
+    // which correctly handles all RN borderRadius variants automatically.
+    // clipToOutline is set to true only when a non-zero radius is applied.
     outlineProvider = ViewOutlineProvider.BACKGROUND
   }
 
@@ -135,13 +130,15 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   override fun onDetachedFromWindow() {
     safeRemovePreDrawListener()
     Choreographer.getInstance().removeFrameCallback(frameCallback)
-    frameScheduled     = false
-    isCapturing        = false
-    pixelCopyInFlight  = false
-    blurRoot           = null
-    readyBitmap        = null
+    frameScheduled = false
+    isCapturing    = false
+    blurRoot       = null
+    readyBitmap    = null
     noiseBitmap?.recycle(); noiseBitmap = null
-    workerHandler.post { releaseBitmapPool() }
+    workerHandler.post {
+      captureBitmap?.recycle(); captureBitmap = null
+      scaledBitmap?.recycle();  scaledBitmap  = null
+    }
     super.onDetachedFromWindow()
   }
 
@@ -149,7 +146,10 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     super.onSizeChanged(w, h, oldw, oldh)
     if (w > 0 && h > 0) {
       readyBitmap = null
-      workerHandler.post { releaseBitmapPool() }
+      workerHandler.post {
+        captureBitmap?.recycle(); captureBitmap = null
+        scaledBitmap?.recycle();  scaledBitmap  = null
+      }
       scheduleFrame()
     }
   }
@@ -162,10 +162,10 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     }
   }
 
-  // ── draw() — no-op during root capture ────────────────────────────────────
+  // ── draw() — skip self during root capture ────────────────────────────────
 
   override fun draw(canvas: Canvas) {
-    if (isCapturing) return
+    if (isCapturing) return   // prevents capturing own blur output
     super.draw(canvas)
   }
 
@@ -176,26 +176,25 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     val w = width.toFloat();  if (w <= 0f) return
     val h = height.toFloat(); if (h <= 0f) return
 
+    // Show overlay as placeholder while first blur is loading
     val bmp = readyBitmap?.takeIf { !it.isRecycled } ?: run {
-      // No blur ready yet — show overlay color as placeholder
       if (Color.alpha(overlayColor) > 0) {
         overlayPaint.color = overlayColor
         canvas.drawRect(0f, 0f, w, h, overlayPaint)
       }
-      // Redraw border on top even when no blur ready
       background?.draw(canvas)
       return
     }
 
-    // Step 1: progressive mask layer
-    val saveCount = if (progressiveDirection != PROGRESSIVE_NONE) {
+    // Step 1: save layer for progressive mask compositing
+    val saveCount = if (progressiveDirection != PROGRESSIVE_NONE)
       canvas.saveLayer(0f, 0f, w, h, null)
-    } else -1
+    else -1
 
-    // Step 2: blurred bitmap
+    // Step 2: blurred bitmap — fills entire view
     canvas.drawBitmap(bmp, null, RectF(0f, 0f, w, h), bitmapPaint)
 
-    // Step 3: progressive alpha mask
+    // Step 3: progressive alpha mask (fades blur across view)
     if (progressiveDirection != PROGRESSIVE_NONE && saveCount >= 0) {
       buildProgressiveShader(w, h)?.let { shader ->
         maskPaint.shader = shader
@@ -216,197 +215,113 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
       noisePaint.shader = BitmapShader(noise, Shader.TileMode.REPEAT, Shader.TileMode.REPEAT)
       canvas.drawRect(0f, 0f, w, h, noisePaint)
     }
+
+    // Step 6: redraw ReactViewBackgroundDrawable ON TOP of blur.
+    // View.draw() drew the background BEFORE onDraw(), but our bitmap
+    // covered it. Redrawing here makes borders/borderColor/borderRadius
+    // appear on top of the blur — not hidden underneath it.
     background?.draw(canvas)
   }
 
-  // ── Capture pipeline — PixelCopy (API 31+) ────────────────────────────────
+  // ── Capture + blur pipeline ────────────────────────────────────────────────
 
   private fun captureAndBlur() {
-    if (isCapturing || pixelCopyInFlight) return
-    val root  = blurRoot  ?: return
-    val vw    = width;      if (vw <= 0) return
-    val vh    = height;     if (vh <= 0) return
-
-    // Compute this view's screen rect for PixelCopy
-    getLocationInWindow(myLoc)
-    root.getLocationInWindow(rootLoc)
-
-    // Screen-space rect of the CONTENT BEHIND this view (use root location
-    // as origin since PixelCopy works in window coordinates)
-    val srcRect = Rect(
-      myLoc[0], myLoc[1],
-      myLoc[0] + vw, myLoc[1] + vh
-    )
+    if (isCapturing) return
+    val root = blurRoot ?: return
+    val vw   = width;   if (vw <= 0) return
+    val vh   = height;  if (vh <= 0) return
 
     val sw = (vw / DOWNSAMPLE).toInt().coerceAtLeast(1)
     val sh = (vh / DOWNSAMPLE).toInt().coerceAtLeast(1)
 
-    val destBitmap = reuseBitmap(pixelCopyBitmap, vw, vh)
-      .also { pixelCopyBitmap = it }
-
-    // Hide ourselves during PixelCopy so we capture ONLY content behind us
-    isCapturing       = true
-    pixelCopyInFlight = true
-
-    val window = (context as? android.app.Activity)?.window
-      ?: run {
-        // Fallback to root.draw() if window not available
-        isCapturing       = false
-        pixelCopyInFlight = false
-        captureWithRootDraw()
-        return
-      }
-
-    PixelCopy.request(
-      window,
-      srcRect,
-      destBitmap,
-      { result ->
-        isCapturing       = false
-        pixelCopyInFlight = false
-
-        if (result != PixelCopy.SUCCESS) {
-          // PixelCopy failed — fall back to root.draw()
-          mainHandler.post { captureWithRootDraw() }
-          return@request
-        }
-
-        // Blur on worker thread
-        val captureRef = destBitmap
-        workerHandler.post {
-          val scaled = reuseBitmap(scaledBitmap, sw, sh).also { scaledBitmap = it }
-
-          // Downsample
-          Canvas(scaled).drawBitmap(
-            captureRef,
-            Rect(0, 0, captureRef.width, captureRef.height),
-            Rect(0, 0, scaled.width, scaled.height),
-            capturePaint
-          )
-
-          // Multi-pass software Gaussian blur
-          val radius = blurRadiusFromAmount(blurAmount)
-          repeat(BLUR_ROUNDS) { stackBlur(scaled, radius.toInt().coerceAtLeast(1)) }
-
-          readyBitmap = scaled
-          mainHandler.post { invalidate() }
-        }
-      },
-      mainHandler
-    )
-  }
-
-  // ── Fallback: root.draw() when PixelCopy unavailable ─────────────────────
-
-  private fun captureWithRootDraw() {
-    if (isCapturing) return
-    val root = blurRoot ?: return
-    val vw   = width;  if (vw <= 0) return
-    val vh   = height; if (vh <= 0) return
-    val sw   = (vw / DOWNSAMPLE).toInt().coerceAtLeast(1)
-    val sh   = (vh / DOWNSAMPLE).toInt().coerceAtLeast(1)
-
+    // Window-relative offset (correct for split-screen, freeform, PiP)
     root.getLocationInWindow(rootLoc)
     getLocationInWindow(myLoc)
     val offsetX = (myLoc[0] - rootLoc[0]).toFloat()
     val offsetY = (myLoc[1] - rootLoc[1]).toFloat()
 
-    val capture = reuseBitmap(pixelCopyBitmap, vw, vh).also { pixelCopyBitmap = it }
-    val scaled  = reuseBitmap(scaledBitmap,    sw, sh).also { scaledBitmap    = it }
+    val capture = reuseBitmap(captureBitmap, vw, vh).also { captureBitmap = it }
+    val scaled  = reuseBitmap(scaledBitmap,  sw, sh).also { scaledBitmap  = it }
 
+    // isCapturing = true → our draw() is a no-op → root.draw() skips us
+    // → capture contains ONLY the content behind us (not our own blur output)
     isCapturing = true
     val c = Canvas(capture)
     c.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
     c.translate(-offsetX, -offsetY)
-    try { root.draw(c) } catch (_: Exception) { isCapturing = false; return }
+    try {
+      root.draw(c)
+    } catch (_: Exception) {
+      isCapturing = false
+      return
+    }
     isCapturing = false
 
+    // Blur on worker thread — never blocks main/RenderThread
     val captureRef = capture
+    val radius     = blurRadiusFromAmount(blurAmount)
+
     workerHandler.post {
+      // Downsample
       Canvas(scaled).drawBitmap(
         captureRef,
         Rect(0, 0, captureRef.width, captureRef.height),
         Rect(0, 0, scaled.width, scaled.height),
         capturePaint
       )
-      val radius = blurRadiusFromAmount(blurAmount)
+      // Multi-pass StackBlur (pure Kotlin, no deprecated APIs, all API levels)
       repeat(BLUR_ROUNDS) { stackBlur(scaled, radius.toInt().coerceAtLeast(1)) }
+
+      // Atomic @Volatile swap — RenderThread always reads a complete bitmap
       readyBitmap = scaled
       mainHandler.post { invalidate() }
     }
   }
 
-  // ── Stack blur (pure Kotlin, no deprecated APIs) ──────────────────────────
-  //
-  // Mario Klingemann's StackBlur — O(w×h) regardless of radius.
-  // Fast, no RenderScript, works on all API levels, zero deprecation warnings.
-  // Used by many production apps including Facebook's Fresco library.
-  // radius clamped 1–254 (algorithm limit).
+  // ── StackBlur ─────────────────────────────────────────────────────────────
+  // Mario Klingemann's algorithm — O(w×h) regardless of radius.
+  // No RenderScript, no deprecated APIs. Works on all Android versions.
 
   private fun stackBlur(bmp: Bitmap, radius: Int) {
     val r = radius.coerceIn(1, 254)
-    val w = bmp.width
-    val h = bmp.height
+    val w = bmp.width; val h = bmp.height
     val pixels = IntArray(w * h)
     bmp.getPixels(pixels, 0, w, 0, 0, w, h)
-
     val div = r + r + 1
-    val wm = w - 1
-    val hm = h - 1
-    val wh = w * h
-    val divSum = (div + 1) shr 1
-    val divSumSq = divSum * divSum
+    val wm = w - 1; val hm = h - 1
+    val divSumSq = ((div + 1) shr 1).let { it * it }
     val dv = IntArray(256 * divSumSq) { it / divSumSq }
-
-    var yi = 0
     val vmin = IntArray(maxOf(w, h))
-    val vmax = IntArray(maxOf(w, h))
-
-    val rStack = IntArray(div)
-    val gStack = IntArray(div)
-    val bStack = IntArray(div)
-
+    val rStack = IntArray(div); val gStack = IntArray(div); val bStack = IntArray(div)
+    var yi = 0
     for (y in 0 until h) {
       var rSum = 0; var gSum = 0; var bSum = 0
       var rOut = 0; var gOut = 0; var bOut = 0
-
       var p = pixels[yi]
-      var pr = (p shr 16) and 0xFF
-      var pg = (p shr 8)  and 0xFF
-      var pb = p and 0xFF
-
-      for (i in 0 until divSum) {
+      var pr = (p shr 16) and 0xFF; var pg = (p shr 8) and 0xFF; var pb = p and 0xFF
+      val ds = (div + 1) shr 1
+      for (i in 0 until ds) {
         rStack[i] = pr; gStack[i] = pg; bStack[i] = pb
         rSum += pr * (i + 1); gSum += pg * (i + 1); bSum += pb * (i + 1)
         rOut += pr; gOut += pg; bOut += pb
       }
-      for (i in 1 until divSum) {
-        val ii = if (i <= wm) i else wm
-        p  = pixels[yi + ii]
-        pr = (p shr 16) and 0xFF; pg = (p shr 8) and 0xFF; pb = p and 0xFF
+      for (i in 1 until ds) {
+        val xi = if (i <= wm) i else wm
+        p = pixels[yi + xi]; pr = (p shr 16) and 0xFF; pg = (p shr 8) and 0xFF; pb = p and 0xFF
         rStack[i + r] = pr; gStack[i + r] = pg; bStack[i + r] = pb
-        rSum += pr * (divSum - i)
-        gSum += pg * (divSum - i)
-        bSum += pb * (divSum - i)
+        rSum += pr * (ds - i); gSum += pg * (ds - i); bSum += pb * (ds - i)
       }
-
       var si = r
       for (x in 0 until w) {
         pixels[yi + x] = (-0x1000000 or (dv[rSum] shl 16) or (dv[gSum] shl 8) or dv[bSum])
         rSum -= rOut; gSum -= gOut; bSum -= bOut
         rOut -= rStack[si]; gOut -= gStack[si]; bOut -= bStack[si]
-        var sip = si + divSum
-        if (sip >= div) sip -= div
+        var sip = si + ds; if (sip >= div) sip -= div
         pr = rStack[sip]; pg = gStack[sip]; pb = bStack[sip]
-        rOut += pr; gOut += pg; bOut += pb
-        rSum += rOut; gSum += gOut; bSum += bOut
-        if (x < r) vmin[x] = x + r + 1 else if (x + r < wm) vmin[x] = x + r + 1 else vmin[x] = wm
-        if (x > r) vmax[x] = x - r else vmax[x] = 0
-        val sp = pixels[yi + vmin[x]]
-        val vp = pixels[yi + vmax[x]]
-        rStack[sip] = (sp shr 16) and 0xFF
-        gStack[sip] = (sp shr 8)  and 0xFF
-        bStack[sip] = sp and 0xFF
+        rOut += pr; gOut += pg; bOut += pb; rSum += rOut; gSum += gOut; bSum += bOut
+        vmin[x] = if (x + r < wm) x + r + 1 else wm
+        val sp = pixels[yi + vmin[x]]; val vp = pixels[yi + (if (x > r) x - r else 0)]
+        rStack[sip] = (sp shr 16) and 0xFF; gStack[sip] = (sp shr 8) and 0xFF; bStack[sip] = sp and 0xFF
         rOut += rStack[sip] - ((vp shr 16) and 0xFF)
         gOut += gStack[sip] - ((vp shr 8) and 0xFF)
         bOut += bStack[sip] - (vp and 0xFF)
@@ -414,50 +329,38 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
       }
       yi += w
     }
-
-    var xi = 0
     for (x in 0 until w) {
       var rSum = 0; var gSum = 0; var bSum = 0
       var rOut = 0; var gOut = 0; var bOut = 0
-      var yp = -r * w
-      var p  = pixels[xi]
-      var pr = (p shr 16) and 0xFF
-      var pg = (p shr 8)  and 0xFF
-      var pb = p and 0xFF
-      for (i in 0 until divSum) {
+      val ds = (div + 1) shr 1
+      var p = pixels[x]; var pr = (p shr 16) and 0xFF; var pg = (p shr 8) and 0xFF; var pb = p and 0xFF
+      for (i in 0 until ds) {
         rStack[i] = pr; gStack[i] = pg; bStack[i] = pb
         rSum += pr * (i + 1); gSum += pg * (i + 1); bSum += pb * (i + 1)
         rOut += pr; gOut += pg; bOut += pb
       }
-      for (i in 1..r) {
-        if (i <= hm) yp += w
-        p  = pixels[xi + yp]
-        pr = (p shr 16) and 0xFF; pg = (p shr 8) and 0xFF; pb = p and 0xFF
+      for (i in 1 until ds) {
+        val yi2 = if (i <= hm) i * w else hm * w
+        p = pixels[x + yi2]; pr = (p shr 16) and 0xFF; pg = (p shr 8) and 0xFF; pb = p and 0xFF
         rStack[i + r] = pr; gStack[i + r] = pg; bStack[i + r] = pb
-        rSum += pr * (divSum - i); gSum += pg * (divSum - i); bSum += pb * (divSum - i)
+        rSum += pr * (ds - i); gSum += pg * (ds - i); bSum += pb * (ds - i)
       }
       var si = r
       for (y in 0 until h) {
-        pixels[xi + y * w] = (-0x1000000 or (dv[rSum] shl 16) or (dv[gSum] shl 8) or dv[bSum])
+        pixels[x + y * w] = (-0x1000000 or (dv[rSum] shl 16) or (dv[gSum] shl 8) or dv[bSum])
         rSum -= rOut; gSum -= gOut; bSum -= bOut
         rOut -= rStack[si]; gOut -= gStack[si]; bOut -= bStack[si]
-        var sip = si + divSum; if (sip >= div) sip -= div
+        var sip = si + ds; if (sip >= div) sip -= div
         pr = rStack[sip]; pg = gStack[sip]; pb = bStack[sip]
-        rOut += pr; gOut += pg; bOut += pb
-        rSum += rOut; gSum += gOut; bSum += bOut
+        rOut += pr; gOut += pg; bOut += pb; rSum += rOut; gSum += gOut; bSum += bOut
         vmin[y] = if (y + r < hm) (y + r + 1) * w else hm * w
-        vmax[y] = if (y > r) (y - r) * w else 0
-        val sp = pixels[xi + vmin[y]]
-        val vp = pixels[xi + vmax[y]]
-        rStack[sip] = (sp shr 16) and 0xFF
-        gStack[sip] = (sp shr 8)  and 0xFF
-        bStack[sip] = sp and 0xFF
+        val sp = pixels[x + vmin[y]]; val vp = pixels[x + (if (y > r) (y - r) * w else 0)]
+        rStack[sip] = (sp shr 16) and 0xFF; gStack[sip] = (sp shr 8) and 0xFF; bStack[sip] = sp and 0xFF
         rOut += rStack[sip] - ((vp shr 16) and 0xFF)
         gOut += gStack[sip] - ((vp shr 8) and 0xFF)
         bOut += bStack[sip] - (vp and 0xFF)
         if (++si >= div) si = 0
       }
-      xi++
     }
     bmp.setPixels(pixels, 0, w, 0, 0, w, h)
   }
@@ -472,7 +375,7 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
       PROGRESSIVE_BOTTOM_TO_TOP -> LinearGradient(0f,h,0f,0f,sc,ec,Shader.TileMode.CLAMP)
       PROGRESSIVE_LEFT_TO_RIGHT -> LinearGradient(0f,0f,w,0f,sc,ec,Shader.TileMode.CLAMP)
       PROGRESSIVE_RIGHT_TO_LEFT -> LinearGradient(w,0f,0f,0f,sc,ec,Shader.TileMode.CLAMP)
-      PROGRESSIVE_RADIAL        -> RadialGradient(w/2f,h/2f,min(w,h)/2f,sc,ec,Shader.TileMode.CLAMP)
+      PROGRESSIVE_RADIAL -> RadialGradient(w/2f,h/2f,min(w,h)/2f,sc,ec,Shader.TileMode.CLAMP)
       else -> null
     }
   }
@@ -564,22 +467,19 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   private fun findBlurRoot(): ViewGroup? {
     var p = parent
     while (p != null) {
-      if ((p as? View)?.javaClass?.name == "com.swmansion.rnscreens.Screen") return p as? ViewGroup
+      if ((p as? View)?.javaClass?.name == "com.swmansion.rnscreens.Screen")
+        return p as? ViewGroup
       p = (p as? View)?.parent
     }
     p = parent
     while (p != null) {
-      if ((p as? View)?.javaClass?.name == "com.facebook.react.ReactRootView") return p as? ViewGroup
+      if ((p as? View)?.javaClass?.name == "com.facebook.react.ReactRootView")
+        return p as? ViewGroup
       p = (p as? View)?.parent
     }
     return rootView as? ViewGroup
   }
 
-  private fun releaseBitmapPool() {
-    pixelCopyBitmap?.recycle(); pixelCopyBitmap = null
-    scaledBitmap?.recycle();    scaledBitmap    = null
-  }
-
   private fun reuseBitmap(existing: Bitmap?, w: Int, h: Int): Bitmap {
     if (existing != null && !existing.isRecycled
         && existing.width == w && existing.height == h) return existing
@@ -589,7 +489,7 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
 
   private fun blurRadiusFromAmount(amount: Float): Float {
     val t = amount.coerceIn(0f, 100f) / 100f
-    return (2f + t * 22f)   // 2–24, StackBlur works well in this range per pass
+    return 2f + t * 22f   // 2–24, with BLUR_ROUNDS=4 effective spread ≈ 4–48px
   }
 
   private fun parseHexColor(s: String): Int? {
@@ -617,8 +517,8 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}
 
   companion object {
-    private const val DOWNSAMPLE  = 2f
-    private const val BLUR_ROUNDS = 3
+    private const val DOWNSAMPLE  = 2f   // 1/4 pixels — higher quality than legacy
+    private const val BLUR_ROUNDS = 4    // 4 passes — wider spread than legacy's 3
     const val PROGRESSIVE_NONE          = 0
     const val PROGRESSIVE_TOP_TO_BOTTOM = 1
     const val PROGRESSIVE_BOTTOM_TO_TOP = 2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-blur-vibe",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "React Native package implementing Blur View in iOS and Android",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",