react-native-blur-vibe 0.1.3 → 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,240 +1,230 @@
 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.qmdeve.blurview.base.BaseBlurViewGroup
-import com.qmdeve.blurview.widget.BlurViewGroup
+import com.facebook.react.views.view.ReactViewGroup
 
 /**
- * BlurVibeView — Android backdrop blur implementation
+ * BlurVibeView — CSS backdrop-filter: blur() for React Native / Android
  *
- * 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
+ * Extends ReactViewGroup so it can host React Native children correctly
+ * (Yoga layout, touch events, z-ordering all work out of the box).
  *
- * 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.
+ * 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.
  *
- * Credit: approach adapted from sbaiahmed1/react-native-blur
+ * 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) {
+class BlurVibeView(context: Context) : ReactViewGroup(context) {
 
-  private var currentBlurRadius = DEFAULT_BLUR_RADIUS
-  private var currentOverlayColor = Color.TRANSPARENT
-  private var currentCornerRadius = 0f
-  private var isBlurInitialized = false
+  // ── State ──────────────────────────────────────────────────────────────────
 
-  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 = 100f
-
-    // 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
-    }
-  }
+  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 ───────────────────────────────────────────────────────────────────
 
   init {
-    super.setBackgroundColor(currentOverlayColor)
-    clipChildren = true
+    setWillNotDraw(false)
+    super.setBackgroundColor(Color.TRANSPARENT)
     clipToOutline = true
-    blurRounds = 5
-    super.setDownsampleFactor(6.0f)
   }
 
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-    if (isBlurInitialized) return
-    swapBlurRootToOptimalAncestor()
-    initializeBlur()
+    attachToCoordinator()
   }
 
   override fun onDetachedFromWindow() {
+    coordinator?.unregister(this)
+    coordinator = null
     super.onDetachedFromWindow()
-    isBlurInitialized = false
   }
 
-  /**
-   * Uses reflection to redirect QmBlurView's internal blur capture root
-   * from the activity decor view to the nearest Screen or ReactRootView.
-   * This prevents the full-screen blur issue when BlurVibeView is used
-   * inside a ScrollView or with absolute positioning and zIndex.
-   */
-  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
+  // ── Coordinator attachment ─────────────────────────────────────────────────
 
-      val decorViewField = baseClass.getDeclaredField("mDecorView")
-      decorViewField.isAccessible = true
-      val oldDecorView = decorViewField.get(baseBlurViewGroup) as? View
+  private fun attachToCoordinator() {
+    coordinator?.unregister(this)
+    val root = findBlurRoot() ?: return
+    val coord = BlurCaptureCoordinator.forRoot(root).also {
+      it.blurRadius = blurRadius
+      coordinator   = it
+    }
+    coord.register(this)
+  }
 
-      val preDrawListenerField = baseClass.getDeclaredField("preDrawListener")
-      preDrawListenerField.isAccessible = true
-      val preDrawListener = preDrawListenerField.get(baseBlurViewGroup)
-        as? ViewTreeObserver.OnPreDrawListener
+  /** Called by coordinator on main thread when a new blurred bitmap is ready. */
+  fun onBlurReady(bitmap: Bitmap) {
+    latestBitmap = bitmap
+    invalidate()
+  }
 
-      if (oldDecorView != null && preDrawListener != null) {
-        // Remove listener from old root
-        oldDecorView.viewTreeObserver.removeOnPreDrawListener(preDrawListener)
+  // ── Drawing ────────────────────────────────────────────────────────────────
 
-        // Set new root
-        decorViewField.set(baseBlurViewGroup, newRoot)
+  override fun onDraw(canvas: Canvas) {
+    val bitmap = latestBitmap?.takeIf { !it.isRecycled } ?: return
+    val root   = findBlurRoot() ?: return
 
-        // Add listener to new root
-        newRoot.viewTreeObserver.addOnPreDrawListener(preDrawListener)
+    // 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
-  }
-
-  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
+    if (Color.alpha(overlayColor) > 0) {
+      overlayPaint.color = overlayColor
+      canvas.drawRect(dstRect, overlayPaint)
     }
   }
 
-  // MARK: - Public setters
+  // ── Public setters (ViewManager → UI thread) ──────────────────────────────
 
   fun setBlurAmount(amount: Float) {
-    currentBlurRadius = mapBlurAmountToRadius(amount)
-    try { super.setBlurRadius(currentBlurRadius) } catch (e: Exception) {}
+    blurRadius = (amount.coerceIn(0f, 100f) / 100f) * 25f
+    coordinator?.blurRadius = blurRadius
   }
 
-  fun setOverlayColor(colorString: String?) {
-    currentOverlayColor = parseHexColor(colorString ?: "transparent") ?: Color.TRANSPARENT
-    try {
-      super.setBackgroundColor(currentOverlayColor)
-      super.setOverlayColor(currentOverlayColor)
-    } catch (e: Exception) {}
+  fun applyOverlayColor(colorString: String?) {
+    overlayColor = parseHexColor(colorString ?: "transparent") ?: Color.TRANSPARENT
+    invalidate()
   }
 
-  fun setReducedTransparencyFallbackColor(colorString: String?) {
-    // Stored for future use — QmBlurView handles accessibility fallback internally
+  /**
+   * 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 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 applyBorderRadius(radiusDp: Float) {
+    cornerRadiusPx = TypedValue.applyDimension(
+      TypedValue.COMPLEX_UNIT_DIP, radiusDp, context.resources.displayMetrics
+    )
+    updateOutline()
   }
 
-  fun setBorderRadius(radius: Float) {
-    currentCornerRadius = radius
-    updateCornerRadius()
+  fun setReducedTransparencyFallbackColor(@Suppress("UNUSED_PARAMETER") color: String?) {
+    // iOS-only concept — no-op on Android
   }
 
-  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)
+  // ── 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)
+        }
       }
+      clipToOutline = true
+    } else {
+      outlineProvider = ViewOutlineProvider.BACKGROUND
+      clipToOutline   = false
     }
-    clipToOutline = true
-    try { super.setCornerRadius(radiusPx) } catch (e: Exception) {}
+    invalidate()
   }
 
-  // React Native handles layout — prevent superclass from interfering
+  // ── React Native layout passthrough ───────────────────────────────────────
+
   override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
-    // No-op: layout handled by React Native's Yoga engine
+    // 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).
   }
 
-  // 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 }
+  // ── 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
     }
-    val hex = s.removePrefix("#")
+    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("#")
     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), // AA is 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),   // 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 (e: NumberFormatException) { null }
+    } catch (_: NumberFormatException) { null }
+  }
+
+  companion object {
+    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 — BlurVibeView (which extends BlurViewGroup/FrameLayout)
- * hosts React children, so we must use ViewGroupManager, not SimpleViewManager.
+ * 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,34 +24,29 @@ 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 setBlurType(view: BlurVibeView, type: String?) {
-    // No-op on Android — blurType maps to iOS UIBlurEffectStyle 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?) {
+  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)
 
-  override fun onDropViewInstance(view: BlurVibeView) {
-    super.onDropViewInstance(view)
-  }
+  @ReactProp(name = "borderRadius", defaultFloat = 0f)
+  fun setBlurBorderRadius(view: BlurVibeView, radius: Float) =
+    view.applyBorderRadius(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.3",
+  "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",