react-native-blur-vibe 0.1.13 → 0.1.14

package/README.md

@@ -1,9 +1,9 @@
 # React Native Blur-Vibe
 
-<img width="1500" height="500" alt="github-banner" src="https://github.com/user-attachments/assets/78b2e5ec-5b57-48c0-b984-69cb57cbcf26" />
+<a href="https://www.npmjs.com/package/react-native-blur-vibe"><img width="100%" height="35%" alt="github-banner" src="https://github.com/user-attachments/assets/78b2e5ec-5b57-48c0-b984-69cb57cbcf26" /></a>
 <br></br>
 
-A modern, actively maintained blur view for React Native. Works on **iOS** and **Android** with full New Architecture (Fabric) support.
+A modern, actively maintained blur view for React Native. Works on **iOS** and **Android** with both Old (Paper) and New (Fabric) Architecture support.
 
 > The key difference from other blur libraries: `overlayColor` works on **both iOS and Android** — letting you control blur visibility the same way CSS `backdrop-filter` + `background-color` works on the web.
 

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

@@ -7,6 +7,7 @@ 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
@@ -17,12 +18,10 @@ import android.os.Build
 import android.os.Handler
 import android.os.HandlerThread
 import android.os.Looper
-import android.renderscript.Allocation
-import android.renderscript.Element
-import android.renderscript.RenderScript
-import android.renderscript.ScriptIntrinsicBlur
 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
@@ -57,48 +56,40 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   private var noiseBitmap: Bitmap? = null
   private val noisePaint  = Paint()
 
-  // ── Double-buffer bitmap pool ─────────────────────────────────────────────
+  // ── 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 captureBitmap: Bitmap? = null
-  private var scaledBitmap:  Bitmap? = null
-  @Volatile private var readyBitmap:  Bitmap? = null
+  private var pixelCopyBitmap: Bitmap? = null
+  private var scaledBitmap:    Bitmap? = null
+  @Volatile private var readyBitmap:   Bitmap? = null
 
   private val capturePaint = Paint(Paint.FILTER_BITMAP_FLAG)
   private val bitmapPaint  = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG)
 
-  // ── Worker thread — blur runs here, main thread never blocks ──────────────
+  // ── Worker thread ─────────────────────────────────────────────────────────
 
   private val workerThread  = HandlerThread("BlurVibeWorker31-${hashCode()}")
     .also { it.start() }
   private val workerHandler = Handler(workerThread.looper)
   private val mainHandler   = Handler(Looper.getMainLooper())
 
-  // ── RenderScript (deprecated API 31 but still functional through API 35) ──
-
-  @Suppress("DEPRECATION")
-  private var rs:         RenderScript?        = null
-  @Suppress("DEPRECATION")
-  private var blurScript: ScriptIntrinsicBlur? = null
-  @Suppress("DEPRECATION")
-  private var inAlloc:    Allocation?          = null
-  @Suppress("DEPRECATION")
-  private var outAlloc:   Allocation?          = null
+  // ── Root / window ─────────────────────────────────────────────────────────
 
-  // ── Root view ─────────────────────────────────────────────────────────────
-
-  private var blurRoot: ViewGroup? = null
-  private val myLoc   = IntArray(2)
-  private val rootLoc = IntArray(2)
+  private var blurRoot:  ViewGroup? = null
+  private val myLoc    = IntArray(2)
+  private val rootLoc  = IntArray(2)
 
   // ── State ─────────────────────────────────────────────────────────────────
 
-  // isCapturing: suppresses our own draw() during root.draw() capture
-  // so we don't paint stale blur into the capture bitmap (static blur bug)
   var isCapturing    = false
     private set
   private var blurEnabled    = true
   private var autoUpdate     = true
   private var frameScheduled = false
+  private var pixelCopyInFlight = false
 
   // ── Choreographer gate ────────────────────────────────────────────────────
 
@@ -126,13 +117,8 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
 
   init {
     setWillNotDraw(false)
-    // DO NOT call setBackgroundColor — it replaces ReactViewGroup's
-    // ReactViewBackgroundDrawable, killing all RN style prop handling.
-    //
     // outlineProvider = BACKGROUND: ReactViewBackgroundDrawable implements
-    // getOutline() for all RN borderRadius variants. clipToOutline=false
-    // by default — only enabled when a non-zero radius is actually set,
-    // to avoid GPU clip stack issues with overflow:hidden + Reanimated.
+    // getOutline() correctly for all RN borderRadius variants automatically.
     outlineProvider = ViewOutlineProvider.BACKGROUND
   }
 
@@ -143,22 +129,19 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     blurRoot = findBlurRoot()
     safeAddPreDrawListener()
     generateNoiseBitmap()
-    workerHandler.post { initRenderScript() }
     scheduleFrame()
   }
 
   override fun onDetachedFromWindow() {
     safeRemovePreDrawListener()
     Choreographer.getInstance().removeFrameCallback(frameCallback)
-    frameScheduled = false
-    isCapturing    = false
-    blurRoot       = null
-    readyBitmap    = null
+    frameScheduled     = false
+    isCapturing        = false
+    pixelCopyInFlight  = false
+    blurRoot           = null
+    readyBitmap        = null
     noiseBitmap?.recycle(); noiseBitmap = null
-    workerHandler.post {
-      releaseBitmapPool()
-      releaseRenderScript()
-    }
+    workerHandler.post { releaseBitmapPool() }
     super.onDetachedFromWindow()
   }
 
@@ -180,10 +163,6 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   }
 
   // ── draw() — no-op during root capture ────────────────────────────────────
-  //
-  // Prevents stale blur output from being captured into the background bitmap.
-  // When isCapturing=true, root.draw() is in progress — we skip ourselves
-  // so only the content BEHIND us is captured.
 
   override fun draw(canvas: Canvas) {
     if (isCapturing) return
@@ -198,12 +177,13 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     val h = height.toFloat(); if (h <= 0f) return
 
     val bmp = readyBitmap?.takeIf { !it.isRecycled } ?: run {
-      // No blur ready yet — draw overlay only so view isn't invisible
+      // No blur ready yet — show overlay color as placeholder
       if (Color.alpha(overlayColor) > 0) {
         overlayPaint.color = overlayColor
         canvas.drawRect(0f, 0f, w, h, overlayPaint)
       }
-      super.onDraw(canvas)
+      // Redraw border on top even when no blur ready
+      background?.draw(canvas)
       return
     }
 
@@ -212,7 +192,7 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
       canvas.saveLayer(0f, 0f, w, h, null)
     } else -1
 
-    // Step 2: draw blurred bitmap
+    // Step 2: blurred bitmap
     canvas.drawBitmap(bmp, null, RectF(0f, 0f, w, h), bitmapPaint)
 
     // Step 3: progressive alpha mask
@@ -236,108 +216,250 @@ 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: let ReactViewGroup draw borders/radius on top
-    super.onDraw(canvas)
+    background?.draw(canvas)
   }
 
-  // ── Capture + blur pipeline ───────────────────────────────────────────────
+  // ── Capture pipeline — PixelCopy (API 31+) ────────────────────────────────
 
   private fun captureAndBlur() {
-    if (isCapturing) return
-    val root = blurRoot ?: return
-    val rw   = root.width;  if (rw <= 0) return
-    val rh   = root.height; if (rh <= 0) return
-    val vw   = width;       if (vw <= 0) return
-    val vh   = height;      if (vh <= 0) return
+    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
+    )
 
     val sw = (vw / DOWNSAMPLE).toInt().coerceAtLeast(1)
     val sh = (vh / DOWNSAMPLE).toInt().coerceAtLeast(1)
 
-    // Compute offset — window coords, correct for split-screen/freeform/PiP
+    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)
+
     root.getLocationInWindow(rootLoc)
     getLocationInWindow(myLoc)
     val offsetX = (myLoc[0] - rootLoc[0]).toFloat()
     val offsetY = (myLoc[1] - rootLoc[1]).toFloat()
 
-    val capture = reuseBitmap(captureBitmap, vw, vh).also { captureBitmap = it }
-    val scaled  = reuseBitmap(scaledBitmap,  sw, sh).also { scaledBitmap  = it }
+    val capture = reuseBitmap(pixelCopyBitmap, vw, vh).also { pixelCopyBitmap = it }
+    val scaled  = reuseBitmap(scaledBitmap,    sw, sh).also { scaledBitmap    = it }
 
-    // Capture — isCapturing suppresses our own draw() so root.draw() skips us
     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
 
-    // Downsample + blur on worker thread (never blocks main/RenderThread)
     val captureRef = capture
-    val scaledRef  = scaled
-    val radius     = blurRadiusFromAmount(blurAmount)
-
     workerHandler.post {
-      // Downsample
-      Canvas(scaledRef).drawBitmap(
+      Canvas(scaled).drawBitmap(
         captureRef,
         Rect(0, 0, captureRef.width, captureRef.height),
-        Rect(0, 0, scaledRef.width,  scaledRef.height),
+        Rect(0, 0, scaled.width, scaled.height),
         capturePaint
       )
-      // Multi-pass blur for wide frosted-glass spread
-      repeat(BLUR_ROUNDS) { blurBitmap(scaledRef, radius) }
-
-      // Atomic swap: readyBitmap is @Volatile — RenderThread sees new value immediately
-      // We never mutate scaledRef after this point until the next capture starts
-      readyBitmap = scaledRef
-
+      val radius = blurRadiusFromAmount(blurAmount)
+      repeat(BLUR_ROUNDS) { stackBlur(scaled, radius.toInt().coerceAtLeast(1)) }
+      readyBitmap = scaled
       mainHandler.post { invalidate() }
     }
   }
 
-  // ── RenderScript blur ─────────────────────────────────────────────────────
-
-  @Suppress("DEPRECATION")
-  private fun initRenderScript() {
-    try {
-      rs = RenderScript.create(context)
-      blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs))
-    } catch (_: Exception) {}
-  }
-
-  @Suppress("DEPRECATION")
-  private fun blurBitmap(bmp: Bitmap, radius: Float) {
-    val r  = rs         ?: return softwareBlur(bmp, radius)
-    val sc = blurScript ?: return softwareBlur(bmp, radius)
-    try {
-      val iA = reuseAlloc(inAlloc,  bmp, r).also { inAlloc  = it }
-      val oA = reuseAlloc(outAlloc, bmp, r).also { outAlloc = it }
-      iA.copyFrom(bmp)
-      sc.setRadius(radius.coerceIn(1f, 25f))
-      sc.setInput(iA)
-      sc.forEach(oA)
-      oA.copyTo(bmp)
-    } catch (_: Exception) { softwareBlur(bmp, radius) }
-  }
+  // ── 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).
+
+  private fun stackBlur(bmp: Bitmap, radius: Int) {
+    val r = radius.coerceIn(1, 254)
+    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 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)
+
+    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) {
+        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
+        rStack[i + r] = pr; gStack[i + r] = pg; bStack[i + r] = pb
+        rSum += pr * (divSum - i)
+        gSum += pg * (divSum - i)
+        bSum += pb * (divSum - i)
+      }
 
-  private fun softwareBlur(bmp: Bitmap, radius: Float) {
-    val p = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-      maskFilter = android.graphics.BlurMaskFilter(radius, android.graphics.BlurMaskFilter.Blur.NORMAL)
+      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
+        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 += 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
+      }
+      yi += w
     }
-    Canvas(bmp).drawBitmap(bmp, 0f, 0f, p)
-  }
 
-  @Suppress("DEPRECATION")
-  private fun releaseRenderScript() {
-    inAlloc?.destroy();    inAlloc    = null
-    outAlloc?.destroy();   outAlloc   = null
-    blurScript?.destroy(); blurScript = null
-    rs?.destroy();         rs         = null
+    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) {
+        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
+        rStack[i + r] = pr; gStack[i + r] = pg; bStack[i + r] = pb
+        rSum += pr * (divSum - i); gSum += pg * (divSum - i); bSum += pb * (divSum - 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])
+        rSum -= rOut; gSum -= gOut; bSum -= bOut
+        rOut -= rStack[si]; gOut -= gStack[si]; bOut -= bStack[si]
+        var sip = si + divSum; 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
+        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
+        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)
   }
 
   // ── Progressive shader ────────────────────────────────────────────────────
@@ -383,9 +505,6 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     cornerRadiusPx = TypedValue.applyDimension(
       TypedValue.COMPLEX_UNIT_DIP, radiusDp, context.resources.displayMetrics
     )
-    // Only enable clipToOutline when radius > 0.
-    // Keeping it false when not needed avoids GPU clip stack issues
-    // when overflow:hidden is set on parent + Reanimated is animating.
     clipToOutline = cornerRadiusPx > 0f
     invalidate()
   }
@@ -413,9 +532,7 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     else {
       safeRemovePreDrawListener()
       Choreographer.getInstance().removeFrameCallback(frameCallback)
-      frameScheduled = false
-      readyBitmap = null
-      invalidate()
+      frameScheduled = false; readyBitmap = null; invalidate()
     }
   }
 
@@ -459,11 +576,10 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
   }
 
   private fun releaseBitmapPool() {
-    captureBitmap?.recycle(); captureBitmap = null
-    scaledBitmap?.recycle();  scaledBitmap  = null
+    pixelCopyBitmap?.recycle(); pixelCopyBitmap = null
+    scaledBitmap?.recycle();    scaledBitmap    = null
   }
 
-  @Suppress("DEPRECATION")
   private fun reuseBitmap(existing: Bitmap?, w: Int, h: Int): Bitmap {
     if (existing != null && !existing.isRecycled
         && existing.width == w && existing.height == h) return existing
@@ -471,13 +587,9 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     return Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
   }
 
-  @Suppress("DEPRECATION")
-  private fun reuseAlloc(existing: Allocation?, src: Bitmap, rs: RenderScript): Allocation {
-    if (existing != null && existing.type.x == src.width && existing.type.y == src.height)
-      return existing
-    existing?.destroy()
-    return Allocation.createFromBitmap(rs, src,
-      Allocation.MipmapControl.MIPMAP_NONE, Allocation.USAGE_SCRIPT)
+  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
   }
 
   private fun parseHexColor(s: String): Int? {
@@ -502,19 +614,11 @@ class BlurVibeViewApi31(context: Context) : ReactViewGroup(context) {
     } catch (_: NumberFormatException) { null }
   }
 
-  private fun blurRadiusFromAmount(amount: Float): Float {
-    // Linear 0→100 maps to 1→25 (RenderScript kernel max is 25).
-    // With BLUR_ROUNDS=4 passes the effective spread is radius × √4 = radius × 2,
-    // so blurAmount=100 gives effective spread of ~50px — properly frosted glass.
-    val t = amount.coerceIn(0f, 100f) / 100f
-    return (1f + t * 24f)
-  }
-
   override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {}
 
   companion object {
-    private const val DOWNSAMPLE  = 2f   // 1/4 pixels — higher quality than legacy
-    private const val BLUR_ROUNDS = 4    // 4 passes — wider Gaussian spread for API 31+
+    private const val DOWNSAMPLE  = 2f
+    private const val BLUR_ROUNDS = 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.13",
+  "version": "0.1.14",
   "description": "React Native package implementing Blur View in iOS and Android",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",