react-native-blur-vibe 0.1.5 → 0.1.6

package/android/build.gradle

@@ -66,8 +66,10 @@ android {
 repositories {
     google()
     mavenCentral()
+    maven { url 'https://jitpack.io' }
   }
 
 dependencies {
   implementation "com.facebook.react:react-android"
+  implementation 'com.qmdeve.blurview:core:1.1.4'
 }

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

@@ -1,230 +1,256 @@
 package com.blurvibe
 
 import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Outline
-import android.graphics.Paint
-import android.graphics.Rect
-import android.graphics.RectF
 import android.util.TypedValue
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewOutlineProvider
+import android.view.ViewTreeObserver
 import androidx.core.graphics.toColorInt
-import com.facebook.react.views.view.ReactViewGroup
+import com.qmdeve.blurview.base.BaseBlurViewGroup
+import com.qmdeve.blurview.widget.BlurViewGroup
 
 /**
- * BlurVibeView — CSS backdrop-filter: blur() for React Native / Android
+ * BlurVibeView — Android backdrop blur implementation
  *
- * Extends ReactViewGroup so it can host React Native children correctly
- * (Yoga layout, touch events, z-ordering all work out of the box).
+ * Extends QmBlurView's BlurViewGroup — a high-performance blur library
+ * that correctly implements CSS backdrop-filter: blur() semantics:
+ *   - Blurs content BEHIND the view, not the view itself
+ *   - Hardware accelerated via native blur algorithms
+ *   - Handles scroll, animation, zIndex, absolute positioning correctly
+ *   - Never causes draw loops or bitmap capture on the JS thread
  *
- * Blur is produced by BlurCaptureCoordinator — a singleton per root view that
- * captures + blurs the root ONCE per vsync and shares the result to every
- * registered BlurVibeView. N blur views on screen = same cost as 1.
+ * Uses reflection to redirect the blur capture root from the activity
+ * decor view to the nearest ReactRootView or react-native-screens Screen,
+ * preventing full-screen blur and navigation transition artifacts.
  *
- * Each view clips the shared blurred bitmap to its own screen-space rect in
- * onDraw(), then draws the overlay color on top.
+ * Credit: approach adapted from sbaiahmed1/react-native-blur
  */
-class BlurVibeView(context: Context) : ReactViewGroup(context) {
+class BlurVibeView(context: Context) : BlurViewGroup(context, null) {
 
-  // ── State ──────────────────────────────────────────────────────────────────
+  private var currentBlurRadius = DEFAULT_BLUR_RADIUS
+  private var currentOverlayColor = Color.TRANSPARENT
+  private var currentCornerRadius = 0f
+  private var isBlurInitialized = false
 
-  private var blurRadius     = DEFAULT_BLUR_RADIUS
-  private var overlayColor   = Color.TRANSPARENT
-  private var cornerRadiusPx = 0f
-
-  // ── Coordinator ───────────────────────────────────────────────────────────
-
-  private var coordinator: BlurCaptureCoordinator? = null
-
-  // ── Draw state (main thread only) ─────────────────────────────────────────
-
-  @Volatile private var latestBitmap: Bitmap? = null
-  private val bitmapPaint  = Paint(Paint.FILTER_BITMAP_FLAG)
-  private val overlayPaint = Paint()
-  private val srcRect      = Rect()
-  private val dstRect      = RectF()
-
-  // ── Init ───────────────────────────────────────────────────────────────────
+  companion object {
+    private const val DEFAULT_BLUR_RADIUS = 10f
+    private const val MIN_BLUR_AMOUNT = 0f
+    private const val MAX_BLUR_AMOUNT = 100f
+    private const val MAX_BLUR_RADIUS = 25f  // QmBlurView Gaussian kernel designed for 0-25
+
+    // Maps 0–100 blurAmount to 0–25 QmBlurView radius range
+    private fun mapBlurAmountToRadius(amount: Float): Float {
+      val clamped = amount.coerceIn(MIN_BLUR_AMOUNT, MAX_BLUR_AMOUNT)
+      return (clamped / MAX_BLUR_AMOUNT) * MAX_BLUR_RADIUS
+    }
+  }
 
   init {
-    setWillNotDraw(false)
-    super.setBackgroundColor(Color.TRANSPARENT)
+    super.setBackgroundColor(currentOverlayColor)
+    clipChildren = true
     clipToOutline = true
+    blurRounds = 1          // was 5 — single pass is visually identical, 5x cheaper
+    super.setDownsampleFactor(8.0f)  // was 6 — 1/64 pixel count, blur hides the difference
   }
 
-  // ── Lifecycle ──────────────────────────────────────────────────────────────
-
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-    attachToCoordinator()
+    if (isBlurInitialized) return
+    swapBlurRootToOptimalAncestor()
+    initializeBlur()
   }
 
   override fun onDetachedFromWindow() {
-    coordinator?.unregister(this)
-    coordinator = null
     super.onDetachedFromWindow()
+    isBlurInitialized = false
   }
 
-  // ── Coordinator attachment ─────────────────────────────────────────────────
+  private var frameScheduled = false
 
-  private fun attachToCoordinator() {
-    coordinator?.unregister(this)
-    val root = findBlurRoot() ?: return
-    val coord = BlurCaptureCoordinator.forRoot(root).also {
-      it.blurRadius = blurRadius
-      coordinator   = it
-    }
-    coord.register(this)
+  private val frameCallback = android.view.Choreographer.FrameCallback {
+    frameScheduled = false
+    try { invalidate() } catch (_: Exception) {}
   }
 
-  /** Called by coordinator on main thread when a new blurred bitmap is ready. */
-  fun onBlurReady(bitmap: Bitmap) {
-    latestBitmap = bitmap
-    invalidate()
-  }
-
-  // ── Drawing ────────────────────────────────────────────────────────────────
+  /**
+   * Redirects QmBlurView's internal preDrawListener from the old root to [newRoot].
+   * Also wraps it in a Choreographer gate so blur work fires at most ONCE per vsync,
+   * even when many views invalidate simultaneously (scroll, animation, etc).
+   */
+  private fun swapBlurRootToOptimalAncestor() {
+    val newRoot = findNearestScreenAncestor() ?: findNearestReactRootView() ?: return
+
+    try {
+      val blurViewGroupClass = BlurViewGroup::class.java
+      val baseField = blurViewGroupClass.getDeclaredField("mBaseBlurViewGroup")
+      baseField.isAccessible = true
+      val baseBlurViewGroup = baseField.get(this) ?: return
+
+      val baseClass = BaseBlurViewGroup::class.java
+
+      val decorViewField = baseClass.getDeclaredField("mDecorView")
+      decorViewField.isAccessible = true
+      val oldDecorView = decorViewField.get(baseBlurViewGroup) as? View
+
+      val preDrawListenerField = baseClass.getDeclaredField("preDrawListener")
+      preDrawListenerField.isAccessible = true
+      val preDrawListener = preDrawListenerField.get(baseBlurViewGroup)
+        as? ViewTreeObserver.OnPreDrawListener
+
+      if (oldDecorView != null && preDrawListener != null) {
+        // Remove listener from old root
+        oldDecorView.viewTreeObserver.removeOnPreDrawListener(preDrawListener)
+
+        // Set new root
+        decorViewField.set(baseBlurViewGroup, newRoot)
+
+        // Wrap in Choreographer gate: fires at most once per vsync regardless of
+        // how many child invalidations happen in the same frame
+        val gatedListener = ViewTreeObserver.OnPreDrawListener {
+          if (!frameScheduled) {
+            frameScheduled = true
+            android.view.Choreographer.getInstance().postFrameCallback(frameCallback)
+          }
+          true  // never block the draw pass
+        }
 
-  override fun onDraw(canvas: Canvas) {
-    val bitmap = latestBitmap?.takeIf { !it.isRecycled } ?: return
-    val root   = findBlurRoot() ?: return
+        // Add gated listener to new root (NOT the original raw listener)
+        newRoot.viewTreeObserver.addOnPreDrawListener(gatedListener)
 
-    // compute this view's offset within the blur root
-    val myLoc   = IntArray(2);   getLocationInWindow(myLoc)
-    val rootLoc = IntArray(2);   root.getLocationInWindow(rootLoc)
+        // Update mDifferentRoot flag
+        val differentRootField = baseClass.getDeclaredField("mDifferentRoot")
+        differentRootField.isAccessible = true
+        differentRootField.setBoolean(baseBlurViewGroup, newRoot.rootView != this.rootView)
 
-    val l = myLoc[0] - rootLoc[0]
-    val t = myLoc[1] - rootLoc[1]
+        // Force redraw
+        val forceRedrawField = baseClass.getDeclaredField("mForceRedraw")
+        forceRedrawField.isAccessible = true
+        forceRedrawField.setBoolean(baseBlurViewGroup, true)
+      }
+    } catch (e: Exception) {
+      // Reflection failed — QmBlurView internals changed
+      // Fall back gracefully to default decor view blur root
+    }
+  }
 
-    // the blurred bitmap is at 1/DOWNSAMPLE_FACTOR resolution — scale coords
-    val f = BlurCaptureCoordinator.DOWNSAMPLE_FACTOR
-    srcRect.set(
-      (l / f).toInt().coerceAtLeast(0),
-      (t / f).toInt().coerceAtLeast(0),
-      ((l + width)  / f).toInt().coerceAtMost(bitmap.width),
-      ((t + height) / f).toInt().coerceAtMost(bitmap.height)
-    )
-    dstRect.set(0f, 0f, width.toFloat(), height.toFloat())
+  private fun findNearestScreenAncestor(): ViewGroup? {
+    var current = parent
+    while (current != null) {
+      if (current.javaClass.name == "com.swmansion.rnscreens.Screen") {
+        return current as? ViewGroup
+      }
+      current = current.parent
+    }
+    return null
+  }
 
-    if (!srcRect.isEmpty) canvas.drawBitmap(bitmap, srcRect, dstRect, bitmapPaint)
+  private fun findNearestReactRootView(): ViewGroup? {
+    var current = parent
+    while (current != null) {
+      if (current.javaClass.name == "com.facebook.react.ReactRootView") {
+        return current as? ViewGroup
+      }
+      current = current.parent
+    }
+    return null
+  }
 
-    if (Color.alpha(overlayColor) > 0) {
-      overlayPaint.color = overlayColor
-      canvas.drawRect(dstRect, overlayPaint)
+  private fun initializeBlur() {
+    if (isBlurInitialized) return
+    try {
+      super.setBlurRadius(currentBlurRadius)
+      super.setOverlayColor(currentOverlayColor)
+      updateCornerRadius()
+      isBlurInitialized = true
+    } catch (e: Exception) {
+      // Ignore — view may not be fully attached yet
     }
   }
 
-  // ── Public setters (ViewManager → UI thread) ──────────────────────────────
+  // MARK: - Public setters
 
   fun setBlurAmount(amount: Float) {
-    blurRadius = (amount.coerceIn(0f, 100f) / 100f) * 25f
-    coordinator?.blurRadius = blurRadius
+    currentBlurRadius = mapBlurAmountToRadius(amount)
+    try { super.setBlurRadius(currentBlurRadius) } catch (e: Exception) {}
   }
 
-  fun applyOverlayColor(colorString: String?) {
-    overlayColor = parseHexColor(colorString ?: "transparent") ?: Color.TRANSPARENT
-    invalidate()
+  fun setOverlayColor(colorString: String?) {
+    currentOverlayColor = parseHexColor(colorString ?: "transparent") ?: Color.TRANSPARENT
+    try {
+      super.setBackgroundColor(currentOverlayColor)
+      super.setOverlayColor(currentOverlayColor)
+    } catch (e: Exception) {}
   }
 
-  /**
-   * blurRadius prop: Android downsample factor (1–8).
-   * Higher = faster + softer. Sets the global factor on the coordinator.
-   */
-  fun applyBlurRadius(factor: Int) {
-    BlurCaptureCoordinator.DOWNSAMPLE_FACTOR = factor.coerceIn(2, 16).toFloat()
-    // re-attach so coordinator picks up new factor
-    attachToCoordinator()
+  fun setReducedTransparencyFallbackColor(colorString: String?) {
+    // Stored for future use — QmBlurView handles accessibility fallback internally
   }
 
-  fun applyBorderRadius(radiusDp: Float) {
-    cornerRadiusPx = TypedValue.applyDimension(
-      TypedValue.COMPLEX_UNIT_DIP, radiusDp, context.resources.displayMetrics
-    )
-    updateOutline()
+  fun setBlurRadius(radius: Int) {
+    // blurRadius is the Android downscale factor — map to QmBlurView's downsample factor
+    val downsample = radius.coerceIn(1, 8).toFloat()
+    try { super.setDownsampleFactor(downsample) } catch (e: Exception) {}
   }
 
-  fun setReducedTransparencyFallbackColor(@Suppress("UNUSED_PARAMETER") color: String?) {
-    // iOS-only concept — no-op on Android
+  fun setBorderRadius(radius: Float) {
+    currentCornerRadius = radius
+    updateCornerRadius()
   }
 
-  // ── Corner radius / outline ────────────────────────────────────────────────
-
-  private fun updateOutline() {
-    if (cornerRadiusPx > 0f) {
-      outlineProvider = object : ViewOutlineProvider() {
-        override fun getOutline(view: View, outline: Outline) {
-          outline.setRoundRect(0, 0, view.width, view.height, cornerRadiusPx)
-        }
+  private fun updateCornerRadius() {
+    val radiusPx = TypedValue.applyDimension(
+      TypedValue.COMPLEX_UNIT_DIP,
+      currentCornerRadius,
+      context.resources.displayMetrics
+    )
+    outlineProvider = object : ViewOutlineProvider() {
+      override fun getOutline(view: View, outline: Outline) {
+        outline.setRoundRect(0, 0, view.width, view.height, radiusPx)
       }
-      clipToOutline = true
-    } else {
-      outlineProvider = ViewOutlineProvider.BACKGROUND
-      clipToOutline   = false
     }
-    invalidate()
+    clipToOutline = true
+    try { super.setCornerRadius(radiusPx) } catch (e: Exception) {}
   }
 
-  // ── React Native layout passthrough ───────────────────────────────────────
-
+  // React Native handles layout — prevent superclass from interfering
   override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-    // Yoga owns layout — calling super would run ReactViewGroup's layout which is correct,
-    // but we must NOT call FrameLayout super here (ReactViewGroup handles it internally).
+    // No-op: layout handled by React Native's Yoga engine
   }
 
-  // ── Blur root finder ──────────────────────────────────────────────────────
-  //
-  // Priority: react-native-screens Screen → ReactRootView → window root
-  // The root is what gets captured — use the narrowest stable ancestor.
-
-  private fun findBlurRoot(): ViewGroup? {
-    var p = parent
-    while (p != null) {
-      if ((p as? View)?.javaClass?.name == "com.swmansion.rnscreens.Screen")
-        return p as? ViewGroup
-      p = (p as? View)?.parent
+  // MARK: - Color parser
+  // Supports: "transparent", "#RGB", "#RRGGBB", "#RRGGBBAA"
+  private fun parseHexColor(colorString: String): Int? {
+    val s = colorString.trim()
+    if (s.equals("transparent", ignoreCase = true)) return Color.TRANSPARENT
+    if (!s.startsWith("#")) {
+      return try { s.toColorInt() } catch (e: Exception) { null }
     }
-    p = parent
-    while (p != null) {
-      if ((p as? View)?.javaClass?.name == "com.facebook.react.ReactRootView")
-        return p as? ViewGroup
-      p = (p as? View)?.parent
-    }
-    return rootView as? ViewGroup
-  }
-
-  // ── Color parser ──────────────────────────────────────────────────────────
-  // Handles: "transparent", "#RGB", "#RRGGBB", "#RRGGBBAA", named colors
-
-  private fun parseHexColor(s: String): Int? {
-    val t = s.trim()
-    if (t.equals("transparent", ignoreCase = true)) return Color.TRANSPARENT
-    if (!t.startsWith("#")) return try { t.toColorInt() } catch (_: Exception) { null }
-    val hex = t.removePrefix("#")
+    val hex = s.removePrefix("#")
     return try {
       when (hex.length) {
-        3    -> Color.argb(255,
-                  hex[0].toString().repeat(2).toInt(16),
-                  hex[1].toString().repeat(2).toInt(16),
-                  hex[2].toString().repeat(2).toInt(16))
-        6    -> Color.argb(255,
-                  hex.substring(0, 2).toInt(16),
-                  hex.substring(2, 4).toInt(16),
-                  hex.substring(4, 6).toInt(16))
-        8    -> Color.argb(
-                  hex.substring(6, 8).toInt(16),   // alpha LAST in #RRGGBBAA
-                  hex.substring(0, 2).toInt(16),
-                  hex.substring(2, 4).toInt(16),
-                  hex.substring(4, 6).toInt(16))
+        3 -> Color.argb(
+          255,
+          hex[0].toString().repeat(2).toInt(16),
+          hex[1].toString().repeat(2).toInt(16),
+          hex[2].toString().repeat(2).toInt(16)
+        )
+        6 -> Color.argb(
+          255,
+          hex.substring(0, 2).toInt(16),
+          hex.substring(2, 4).toInt(16),
+          hex.substring(4, 6).toInt(16)
+        )
+        8 -> Color.argb(
+          hex.substring(6, 8).toInt(16), // AA is last in #RRGGBBAA
+          hex.substring(0, 2).toInt(16),
+          hex.substring(2, 4).toInt(16),
+          hex.substring(4, 6).toInt(16)
+        )
         else -> null
       }
-    } catch (_: NumberFormatException) { null }
-  }
-
-  companion object {
-    private const val DEFAULT_BLUR_RADIUS = 2.5f   // blurAmount=10 → 2.5
+    } catch (e: NumberFormatException) { null }
   }
 }

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

@@ -7,15 +7,8 @@ import com.facebook.react.uimanager.annotations.ReactProp
 /**
  * BlurVibeViewManager
  *
- * All @ReactProp handler names are intentionally distinct from BaseViewManager /
- * ReactViewGroup / View supertype methods to avoid "hides member" compile errors:
- *
- *   setBlurAmount              — unique, not in any supertype
- *   setBlurTypeProp            — avoids any "setBlurType" conflict
- *   setOverlayColorProp        — avoids BaseViewManager.setBackgroundColor etc.
- *   setReducedTransparencyFallbackColor — unique
- *   setBlurRadiusProp          — avoids View.setRadius / BlurView.setBlurRadius
- *   setBlurBorderRadius        — avoids BaseViewManager.setBorderRadius
+ * ViewGroupManager — BlurVibeView (which extends BlurViewGroup/FrameLayout)
+ * hosts React children, so we must use ViewGroupManager, not SimpleViewManager.
  */
 class BlurVibeViewManager : ViewGroupManager<BlurVibeView>() {
 
@@ -24,29 +17,35 @@ class BlurVibeViewManager : ViewGroupManager<BlurVibeView>() {
   override fun createViewInstance(context: ThemedReactContext) = BlurVibeView(context)
 
   @ReactProp(name = "blurAmount", defaultFloat = 10f)
-  fun setBlurAmount(view: BlurVibeView, amount: Float) =
+  fun setBlurAmount(view: BlurVibeView, amount: Float) {
     view.setBlurAmount(amount)
+  }
 
   @ReactProp(name = "blurType")
-  fun setBlurTypeProp(view: BlurVibeView, @Suppress("UNUSED_PARAMETER") type: String?) {
-    // iOS UIBlurEffectStyle — no-op on Android
+  fun setBlurType(view: BlurVibeView, type: String?) {
+    // No-op on Android — blurType maps to iOS UIBlurEffectStyle only
   }
 
   @ReactProp(name = "overlayColor")
-  fun setOverlayColorProp(view: BlurVibeView, color: String?) =
-    view.applyOverlayColor(color)
+  fun setOverlayColor(view: BlurVibeView, color: String?) {
+    view.setOverlayColor(color)
+  }
 
   @ReactProp(name = "reducedTransparencyFallbackColor")
-  fun setReducedTransparencyFallbackColor(view: BlurVibeView, color: String?) =
+  fun setReducedTransparencyFallbackColor(view: BlurVibeView, color: String?) {
     view.setReducedTransparencyFallbackColor(color)
+  }
 
   @ReactProp(name = "blurRadius", defaultInt = 4)
-  fun setBlurRadiusProp(view: BlurVibeView, radius: Int) =
-    view.applyBlurRadius(radius)
+  fun setBlurRadius(view: BlurVibeView, radius: Int) {
+    view.setBlurRadius(radius)
+  }
 
   @ReactProp(name = "borderRadius", defaultFloat = 0f)
-  fun setBlurBorderRadius(view: BlurVibeView, radius: Float) =
-    view.applyBorderRadius(radius)
+  fun setBlurBorderRadius(view: BlurVibeView, radius: Float) {
+    view.setBorderRadius(radius)
+  }
 
+  // React Native's Yoga handles child layout — return false
   override fun needsCustomLayoutForChildren(): Boolean = false
 }

package/package.json

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

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

@@ -1,230 +0,0 @@
-package com.blurvibe
-
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Color
-import android.graphics.Paint
-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.view.Choreographer
-import android.view.ViewGroup
-import android.view.ViewTreeObserver
-import java.util.concurrent.CopyOnWriteArraySet
-
-/**
- * BlurCaptureCoordinator
- *
- * Singleton per root-view. Owns ONE preDrawListener, ONE bitmap capture, ONE blur pass
- * per vsync — shared across ALL BlurVibeViews that point at the same root.
- *
- * Cost: O(1) per frame regardless of how many BlurVibeViews are mounted.
- * Compare to naive per-view: O(N) per frame.
- *
- * Thread model:
- *   rootView.draw()   → main thread (Android requires this)
- *   RenderScript blur → workerThread (non-blocking)
- *   onBlurReady()     → main thread via mainHandler.post()
- */
-internal class BlurCaptureCoordinator private constructor(
-  private val rootView: ViewGroup
-) {
-
-  // registered BlurVibeViews — thread-safe, iterated on main thread
-  private val clients = CopyOnWriteArraySet<BlurVibeView>()
-
-  // bitmap pool — allocated once, reused every frame (zero GC)
-  private var captureBitmap: Bitmap? = null
-  private var scaledBitmap:  Bitmap? = null
-
-  private val capturePaint = Paint(Paint.FILTER_BITMAP_FLAG)
-
-  // worker thread for blur (keeps main thread free)
-  private val workerThread = HandlerThread("BlurVibeWorker-${System.identityHashCode(rootView)}")
-    .also { it.start() }
-  private val workerHandler  = Handler(workerThread.looper)
-  private val mainHandler    = Handler(Looper.getMainLooper())
-
-  // RenderScript state (API < 31 only, created lazily on workerThread)
-  private var rs:          RenderScript?        = null
-  private var blurScript:  ScriptIntrinsicBlur? = null
-  private var inputAlloc:  Allocation?          = null
-  private var outputAlloc: Allocation?          = null
-
-  // blur params
-  var blurRadius: Float = 8f
-    set(value) { field = value.coerceIn(1f, 25f) }
-  var downsampleFactor: Float = DOWNSAMPLE_FACTOR
-
-  // frame gate — at most one capture queued at a time
-  private var frameScheduled = false
-  private val frameCallback = Choreographer.FrameCallback {
-    frameScheduled = false
-    captureAndBlur()
-  }
-
-  // ONE preDrawListener for the entire coordinator
-  private val preDrawListener = ViewTreeObserver.OnPreDrawListener {
-    if (!frameScheduled) {
-      frameScheduled = true
-      Choreographer.getInstance().postFrameCallback(frameCallback)
-    }
-    true  // never block the draw pass
-  }
-
-  // ── Init / destroy ────────────────────────────────────────────────────────
-
-  init {
-    rootView.viewTreeObserver.addOnPreDrawListener(preDrawListener)
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
-      workerHandler.post { initRenderScript() }
-    }
-  }
-
-  private fun destroy() {
-    rootView.viewTreeObserver.removeOnPreDrawListener(preDrawListener)
-    Choreographer.getInstance().removeFrameCallback(frameCallback)
-    cache.remove(rootView)
-    workerHandler.post {
-      inputAlloc?.destroy();  inputAlloc  = null
-      outputAlloc?.destroy(); outputAlloc = null
-      blurScript?.destroy();  blurScript  = null
-      rs?.destroy();          rs          = null
-      captureBitmap?.recycle(); captureBitmap = null
-      scaledBitmap?.recycle();  scaledBitmap  = null
-      workerThread.quitSafely()
-    }
-  }
-
-  // ── Registration ──────────────────────────────────────────────────────────
-
-  fun register(view: BlurVibeView) {
-    clients.add(view)
-    // deliver cached result immediately so view doesn't flash blank
-    scaledBitmap?.takeIf { !it.isRecycled }?.let { view.onBlurReady(it) }
-  }
-
-  fun unregister(view: BlurVibeView) {
-    clients.remove(view)
-    if (clients.isEmpty()) destroy()
-  }
-
-  // ── Capture + blur pipeline ───────────────────────────────────────────────
-
-  private fun captureAndBlur() {
-    if (clients.isEmpty()) return
-    val w = rootView.width;  if (w <= 0) return
-    val h = rootView.height; if (h <= 0) return
-
-    val factor  = downsampleFactor
-    val scaledW = (w / factor).toInt().coerceAtLeast(1)
-    val scaledH = (h / factor).toInt().coerceAtLeast(1)
-
-    // allocate / reuse bitmaps
-    val capture = reuseBitmap(captureBitmap, w, h).also      { captureBitmap = it }
-    val scaled  = reuseBitmap(scaledBitmap, scaledW, scaledH).also { scaledBitmap  = it }
-
-    // ① capture on main thread (required by Android)
-    try {
-      val c = Canvas(capture)
-      c.drawColor(Color.TRANSPARENT, android.graphics.PorterDuff.Mode.CLEAR)
-      rootView.draw(c)
-    } catch (_: Exception) { return }
-
-    val radius        = blurRadius
-    val captureRef    = capture
-    val scaledRef     = scaled
-
-    // ② blur on worker thread
-    workerHandler.post {
-      // downsample
-      Canvas(scaledRef).drawBitmap(
-        captureRef,
-        android.graphics.Rect(0, 0, captureRef.width, captureRef.height),
-        android.graphics.Rect(0, 0, scaledRef.width,  scaledRef.height),
-        capturePaint
-      )
-
-      // blur
-      val blurred = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-        blurSoftware(scaledRef, radius)   // BlurMaskFilter — fast enough at small size
-      } else {
-        blurRenderScript(scaledRef, radius) ?: blurSoftware(scaledRef, radius)
-      }
-
-      // ③ deliver to all clients on main thread
-      mainHandler.post {
-        clients.forEach { it.onBlurReady(blurred) }
-      }
-    }
-  }
-
-  // ── Blur implementations ──────────────────────────────────────────────────
-
-  private fun initRenderScript() {
-    try {
-      rs         = RenderScript.create(rootView.context)
-      blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs))
-    } catch (_: Exception) {}
-  }
-
-  private fun blurRenderScript(src: Bitmap, radius: Float): Bitmap? {
-    val r  = this.rs          ?: return null
-    val sc = this.blurScript  ?: return null
-    return try {
-      val inA  = reuseAlloc(inputAlloc,  src, r).also { inputAlloc  = it }
-      val outA = reuseAlloc(outputAlloc, src, r).also { outputAlloc = it }
-      inA.copyFrom(src)
-      sc.setRadius(radius)
-      sc.setInput(inA)
-      sc.forEach(outA)
-      val out = Bitmap.createBitmap(src.width, src.height, Bitmap.Config.ARGB_8888)
-      outA.copyTo(out)
-      out
-    } catch (_: Exception) { null }
-  }
-
-  private fun blurSoftware(src: Bitmap, radius: Float): Bitmap {
-    val out   = Bitmap.createBitmap(src.width, src.height, Bitmap.Config.ARGB_8888)
-    val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-      maskFilter = android.graphics.BlurMaskFilter(radius, android.graphics.BlurMaskFilter.Blur.NORMAL)
-    }
-    Canvas(out).drawBitmap(src, 0f, 0f, paint)
-    return out
-  }
-
-  // ── Bitmap / Allocation helpers ───────────────────────────────────────────
-
-  private fun reuseBitmap(existing: Bitmap?, w: Int, h: Int): Bitmap {
-    if (existing != null && !existing.isRecycled
-        && existing.width == w && existing.height == h) return existing
-    existing?.recycle()
-    return Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
-  }
-
-  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)
-  }
-
-  // ── Singleton cache ───────────────────────────────────────────────────────
-
-  companion object {
-    /** Global downsample factor. Higher = faster + softer. Range 2–16. */
-    var DOWNSAMPLE_FACTOR: Float = 8f
-
-    private val cache = HashMap<ViewGroup, BlurCaptureCoordinator>()
-
-    fun forRoot(rootView: ViewGroup): BlurCaptureCoordinator =
-      cache.getOrPut(rootView) { BlurCaptureCoordinator(rootView) }
-  }
-}