react-native-blur-vibe 0.1.4 → 0.1.5

package/android/build.gradle

@@ -66,10 +66,8 @@ 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/BlurCaptureCoordinator.kt

@@ -0,0 +1,230 @@
+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) }
+  }
+}

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

@@ -1,293 +1,203 @@
 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.os.Handler
-import android.os.Looper
+import android.graphics.Paint
+import android.graphics.Rect
+import android.graphics.RectF
 import android.util.TypedValue
-import android.view.Choreographer
 import android.view.View
 import android.view.ViewGroup
 import android.view.ViewOutlineProvider
-import android.view.ViewTreeObserver
 import androidx.core.graphics.toColorInt
-import com.qmdeve.blurview.base.BaseBlurViewGroup
-import com.qmdeve.blurview.widget.BlurViewGroup
+import com.facebook.react.views.view.ReactViewGroup
 
 /**
- * BlurVibeView — Optimised Android backdrop-blur (QmBlurView / CSS backdrop-filter parity)
+ * BlurVibeView — CSS backdrop-filter: blur() for React Native / Android
  *
- * ─── What was killing performance (3 FPS) ────────────────────────────────────
+ * Extends ReactViewGroup so it can host React Native children correctly
+ * (Yoga layout, touch events, z-ordering all work out of the box).
  *
- *  1. blurRounds = 5
- *     The single biggest killer. Each "round" is a full downsample → Gaussian → upsample
- *     pipeline. At 60 fps that's 300 blur operations/second. One round looks identical
- *     to the human eye and costs 1/5 as much. Fixed: blurRounds = 1.
+ * 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.
  *
- *  2. Blur radius mapped 0–100 instead of 0–25
- *     mapBlurAmountToRadius() was returning up to 100.0. QmBlurView's Gaussian kernel
- *     at radius=100 iterates a ~200-wide kernel per-pixel every frame.
- *     Fixed: map blurAmount 0–100 → radius 0–25.
- *
- *  3. OnPreDrawListener fires every frame with no throttling
- *     The listener was doing full blur work synchronously inside the pre-draw callback,
- *     blocking the draw thread on every invalidation of every child in the tree.
- *     Fixed: listener only sets a dirty flag; actual blur work is deferred to a
- *     Choreographer.FrameCallback which fires at most once-per-vsync.
- *
- *  4. preDrawListener leaked on re-attach
- *     Each call to onAttachedToWindow re-added the listener without removing the old one,
- *     multiplying the per-frame cost every time a modal or navigator re-mounted the view.
- *     Fixed: detachPreDrawListener() called before every re-attach.
- *
- * ─── Performance profile after fixes ─────────────────────────────────────────
- *
- *  • blur cost reduced ~40× (5 rounds → 1, radius 100 → 25, gated to 1/vsync)
- *  • zero JS thread work (Choreographer callback runs on UI thread only)
- *  • zero GC pressure (no bitmap allocations on hot path)
- *  • works with: Modal, ScrollView, FlatList, FlashList, ImageBackground,
- *                Reanimated (both JS and UI thread), react-navigation transitions
+ * Each view clips the shared blurred bitmap to its own screen-space rect in
+ * onDraw(), then draws the overlay color on top.
  */
-class BlurVibeView(context: Context) : BlurViewGroup(context, null) {
-
-  // ── Blur state ─────────────────────────────────────────────────────────────
-
-  private var pendingBlurRadius = DEFAULT_BLUR_RADIUS
-  private var currentOverlayColor = Color.TRANSPARENT
-  private var currentCornerRadius = 0f
-  private var isSetupDone = false
+class BlurVibeView(context: Context) : ReactViewGroup(context) {
 
-  // ── Choreographer frame gate ───────────────────────────────────────────────
-  //
-  // OnPreDrawListener sets pendingFrame = true and returns immediately (never
-  // blocks). Choreographer fires frameCallback at the next vsync boundary,
-  // which calls invalidate() → QmBlurView captures + blurs + draws exactly once.
-  // pendingFrame prevents multiple queued callbacks stacking up.
+  // ── State ──────────────────────────────────────────────────────────────────
 
-  private var pendingFrame = false
+  private var blurRadius     = DEFAULT_BLUR_RADIUS
+  private var overlayColor   = Color.TRANSPARENT
+  private var cornerRadiusPx = 0f
 
-  private val frameCallback = Choreographer.FrameCallback {
-    pendingFrame = false
-    if (isAttachedToWindow) triggerBlurUpdate()
-  }
+  // ── Coordinator ───────────────────────────────────────────────────────────
 
-  // ── PreDraw listener — sets dirty flag only, does zero work ───────────────
+  private var coordinator: BlurCaptureCoordinator? = null
 
-  private var attachedRoot: View? = null
+  // ── Draw state (main thread only) ─────────────────────────────────────────
 
-  private val preDrawListener = ViewTreeObserver.OnPreDrawListener {
-    if (!pendingFrame) {
-      pendingFrame = true
-      Choreographer.getInstance().postFrameCallback(frameCallback)
-    }
-    true  // MUST return true — false would block the entire frame draw pass
-  }
+  @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 ──────────────────────────────────────────────────────────────────
+  // ── Init ───────────────────────────────────────────────────────────────────
 
   init {
+    setWillNotDraw(false)
     super.setBackgroundColor(Color.TRANSPARENT)
-    clipChildren = true
     clipToOutline = true
-
-    // THE critical fix #1: 1 round instead of 5.
-    // A single Gaussian pass on a downsampled bitmap is perceptually identical
-    // to 5 passes and costs exactly 1/5 as much GPU/CPU time.
-    blurRounds = 1
-
-    // Aggressive downsample: capture at 1/8 resolution before blurring.
-    // The blur kernel smooths away all pixel-level detail so 1/8 is sufficient.
-    // This reduces the bitmap size 64× and the blur kernel work proportionally.
-    super.setDownsampleFactor(8f)
   }
 
-  // ── Lifecycle ─────────────────────────────────────────────────────────────
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-    attachPreDrawListenerToOptimalRoot()
-    if (!isSetupDone) applyPendingBlurConfig()
+    attachToCoordinator()
   }
 
   override fun onDetachedFromWindow() {
-    detachPreDrawListener()
-    Choreographer.getInstance().removeFrameCallback(frameCallback)
-    pendingFrame = false
-    isSetupDone = false
+    coordinator?.unregister(this)
+    coordinator = null
     super.onDetachedFromWindow()
   }
 
-  // ── Root attachment ───────────────────────────────────────────────────────
+  // ── Coordinator attachment ─────────────────────────────────────────────────
 
-  private fun attachPreDrawListenerToOptimalRoot() {
-    detachPreDrawListener() // always detach first to prevent listener leaks
-
-    val root: ViewGroup = findNearestScreenAncestor()
-      ?: findNearestReactRootView()
-      ?: (rootView as? ViewGroup)
-      ?: return
-
-    attachedRoot = root
-    root.viewTreeObserver.addOnPreDrawListener(preDrawListener)
-    redirectQmBlurCaptureRoot(root)
+  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 fun detachPreDrawListener() {
-    attachedRoot?.viewTreeObserver?.removeOnPreDrawListener(preDrawListener)
-    attachedRoot = null
+  /** Called by coordinator on main thread when a new blurred bitmap is ready. */
+  fun onBlurReady(bitmap: Bitmap) {
+    latestBitmap = bitmap
+    invalidate()
   }
 
-  /**
-   * Redirects QmBlurView's internal bitmap-capture root (mDecorView) to [newRoot]
-   * via reflection. This scopes QmBlurView's capture to the chosen subtree instead
-   * of the full activity decor view — smaller captures = faster blur.
-   *
-   * We do NOT mirror QmBlurView's internal preDrawListener. We own the invalidation
-   * cycle via our own Choreographer-gated listener above.
-   */
-  private fun redirectQmBlurCaptureRoot(newRoot: ViewGroup) {
-    try {
-      val baseField = BlurViewGroup::class.java.getDeclaredField("mBaseBlurViewGroup")
-      baseField.isAccessible = true
-      val base = baseField.get(this) ?: return
-
-      val baseClass = BaseBlurViewGroup::class.java
+  // ── Drawing ────────────────────────────────────────────────────────────────
 
-      val decorField = baseClass.getDeclaredField("mDecorView")
-      decorField.isAccessible = true
-      decorField.set(base, newRoot)
+  override fun onDraw(canvas: Canvas) {
+    val bitmap = latestBitmap?.takeIf { !it.isRecycled } ?: return
+    val root   = findBlurRoot() ?: return
 
-      val diffRootField = baseClass.getDeclaredField("mDifferentRoot")
-      diffRootField.isAccessible = true
-      diffRootField.setBoolean(base, newRoot.rootView != this.rootView)
+    // compute this view's offset within the blur root
+    val myLoc   = IntArray(2);   getLocationInWindow(myLoc)
+    val rootLoc = IntArray(2);   root.getLocationInWindow(rootLoc)
 
-      val forceRedrawField = baseClass.getDeclaredField("mForceRedraw")
-      forceRedrawField.isAccessible = true
-      forceRedrawField.setBoolean(base, true)
+    val l = myLoc[0] - rootLoc[0]
+    val t = myLoc[1] - rootLoc[1]
 
-    } catch (_: Exception) {
-      // Reflection failed (library updated internals).
-      // Fall back gracefully — blur still works via the decor view.
-    }
-  }
-
-  // ── Blur update (fires via Choreographer, once per vsync at most) ─────────
+    // 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 triggerBlurUpdate() {
-    try {
-      if (!isSetupDone) applyPendingBlurConfig() else invalidate()
-    } catch (_: Exception) {}
-  }
+    if (!srcRect.isEmpty) canvas.drawBitmap(bitmap, srcRect, dstRect, bitmapPaint)
 
-  private fun applyPendingBlurConfig() {
-    try {
-      super.setBlurRadius(pendingBlurRadius)
-      super.setOverlayColor(currentOverlayColor)
-      updateCornerRadiusInternal()
-      isSetupDone = true
-    } catch (_: Exception) {
-      // Not fully attached yet — next Choreographer tick will retry
+    if (Color.alpha(overlayColor) > 0) {
+      overlayPaint.color = overlayColor
+      canvas.drawRect(dstRect, overlayPaint)
     }
   }
 
   // ── Public setters (ViewManager → UI thread) ──────────────────────────────
 
-  /**
-   * blurAmount: JS-facing 0–100.
-   * Mapped to 0–25 internally (QmBlurView Gaussian kernel's designed range).
-   * Values above 25 produce no visible increase in blur but cost more.
-   */
   fun setBlurAmount(amount: Float) {
-    pendingBlurRadius = mapBlurAmount(amount)
-    if (isSetupDone) {
-      try { super.setBlurRadius(pendingBlurRadius) } catch (_: Exception) {}
-      scheduleBlurFrame()
-    }
+    blurRadius = (amount.coerceIn(0f, 100f) / 100f) * 25f
+    coordinator?.blurRadius = blurRadius
   }
 
-  fun setOverlayColor(colorString: String?) {
-    currentOverlayColor = parseHexColor(colorString ?: "transparent") ?: Color.TRANSPARENT
-    if (isSetupDone) {
-      try {
-        super.setBackgroundColor(Color.TRANSPARENT)
-        super.setOverlayColor(currentOverlayColor)
-      } catch (_: Exception) {}
-      scheduleBlurFrame()
-    }
+  fun applyOverlayColor(colorString: String?) {
+    overlayColor = parseHexColor(colorString ?: "transparent") ?: Color.TRANSPARENT
+    invalidate()
   }
 
-  /** downsample factor override (1–8). Higher = faster + softer. */
-  fun setBlurRadius(factor: Int) {
-    try { super.setDownsampleFactor(factor.coerceIn(1, 8).toFloat()) } catch (_: Exception) {}
-    scheduleBlurFrame()
+  /**
+   * 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 applyBorderRadius(radiusDp: Float) {
-    currentCornerRadius = radiusDp
-    updateCornerRadiusInternal()
+    cornerRadiusPx = TypedValue.applyDimension(
+      TypedValue.COMPLEX_UNIT_DIP, radiusDp, context.resources.displayMetrics
+    )
+    updateOutline()
   }
 
-  fun setReducedTransparencyFallbackColor(@Suppress("UNUSED_PARAMETER") colorString: String?) {
-    // Reserved — QmBlurView handles its own reduced-transparency fallback
+  fun setReducedTransparencyFallbackColor(@Suppress("UNUSED_PARAMETER") color: String?) {
+    // iOS-only concept — no-op on Android
   }
 
-  // ── Corner radius ─────────────────────────────────────────────────────────
+  // ── Corner radius / outline ────────────────────────────────────────────────
 
-  private fun updateCornerRadiusInternal() {
-    val px = 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, px)
+  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)
+        }
       }
+      clipToOutline = true
+    } else {
+      outlineProvider = ViewOutlineProvider.BACKGROUND
+      clipToOutline   = false
     }
-    clipToOutline = currentCornerRadius > 0f
-    try { super.setCornerRadius(px) } catch (_: Exception) {}
+    invalidate()
   }
 
-  // ── Helpers ───────────────────────────────────────────────────────────────
+  // ── React Native layout passthrough ───────────────────────────────────────
 
-  private fun scheduleBlurFrame() {
-    if (!pendingFrame) {
-      pendingFrame = true
-      Choreographer.getInstance().postFrameCallback(frameCallback)
-    }
+  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).
   }
 
-  private fun mapBlurAmount(amount: Float): Float =
-    (amount.coerceIn(0f, 100f) / 100f) * 25f
-
-  // ── Ancestor finders ──────────────────────────────────────────────────────
+  // ── Blur root finder ──────────────────────────────────────────────────────
+  //
+  // Priority: react-native-screens Screen → ReactRootView → window root
+  // The root is what gets captured — use the narrowest stable ancestor.
 
-  private fun findNearestScreenAncestor(): ViewGroup? {
+  private fun findBlurRoot(): ViewGroup? {
     var p = parent
     while (p != null) {
-      if (p.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
     }
-    return null
-  }
-
-  private fun findNearestReactRootView(): ViewGroup? {
-    var p = parent
+    p = parent
     while (p != null) {
-      if (p.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 null
-  }
-
-  // ── React Native layout passthrough ───────────────────────────────────────
-
-  override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-    // Yoga handles all child layout. Calling super here would cause QmBlurView's
-    // FrameLayout logic to fight RN's layout system.
+    return rootView as? ViewGroup
   }
 
   // ── Color parser ──────────────────────────────────────────────────────────
-  // Supports: "transparent", "#RGB", "#RRGGBB", "#RRGGBBAA", named colors
+  // Handles: "transparent", "#RGB", "#RRGGBB", "#RRGGBBAA", named colors
 
   private fun parseHexColor(s: String): Int? {
     val t = s.trim()
@@ -296,28 +206,25 @@ class BlurVibeView(context: Context) : BlurViewGroup(context, null) {
     val hex = t.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 is LAST byte 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),   // alpha 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 }
   }
 
-  // ── Constants ─────────────────────────────────────────────────────────────
-
   companion object {
-    // blurAmount=10 → radius 2.5 — a gentle, performant default
-    private const val DEFAULT_BLUR_RADIUS = 2.5f
+    private const val DEFAULT_BLUR_RADIUS = 2.5f   // blurAmount=10 → 2.5
   }
 }

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

@@ -7,8 +7,15 @@ import com.facebook.react.uimanager.annotations.ReactProp
 /**
  * BlurVibeViewManager
  *
- * ViewGroupManager because BlurVibeView (→ BlurViewGroup → FrameLayout) hosts
- * React children. needsCustomLayoutForChildren() = false lets Yoga own layout.
+ * 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
  */
 class BlurVibeViewManager : ViewGroupManager<BlurVibeView>() {
 
@@ -17,30 +24,29 @@ class BlurVibeViewManager : ViewGroupManager<BlurVibeView>() {
   override fun createViewInstance(context: ThemedReactContext) = BlurVibeView(context)
 
   @ReactProp(name = "blurAmount", defaultFloat = 10f)
-  fun setBlurAmount(view: BlurVibeView, amount: Float) = view.setBlurAmount(amount)
+  fun setBlurAmount(view: BlurVibeView, amount: Float) =
+    view.setBlurAmount(amount)
 
   @ReactProp(name = "blurType")
-  fun setBlurType(view: BlurVibeView, type: String?) {
-    // No-op on Android — blurType is an iOS UIBlurEffectStyle concept only
+  fun setBlurTypeProp(view: BlurVibeView, @Suppress("UNUSED_PARAMETER") type: String?) {
+    // iOS UIBlurEffectStyle — no-op on Android
   }
 
   @ReactProp(name = "overlayColor")
-  fun setOverlayColor(view: BlurVibeView, color: String?) = view.setOverlayColor(color)
+  fun setOverlayColorProp(view: BlurVibeView, color: String?) =
+    view.applyOverlayColor(color)
 
   @ReactProp(name = "reducedTransparencyFallbackColor")
   fun setReducedTransparencyFallbackColor(view: BlurVibeView, color: String?) =
     view.setReducedTransparencyFallbackColor(color)
 
   @ReactProp(name = "blurRadius", defaultInt = 4)
-  fun setBlurRadius(view: BlurVibeView, radius: Int) = view.setBlurRadius(radius)
+  fun setBlurRadiusProp(view: BlurVibeView, radius: Int) =
+    view.applyBlurRadius(radius)
 
   @ReactProp(name = "borderRadius", defaultFloat = 0f)
-  fun setBlurBorderRadius(view: BlurVibeView, radius: Float) = view.applyBorderRadius(radius)
-
-  override fun onDropViewInstance(view: BlurVibeView) {
-    super.onDropViewInstance(view)
-  }
+  fun setBlurBorderRadius(view: BlurVibeView, radius: Float) =
+    view.applyBorderRadius(radius)
 
-  // Yoga drives all child layout — return false
   override fun needsCustomLayoutForChildren(): Boolean = false
 }

package/package.json

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