@lodev09/react-native-true-sheet 4.0.0-beta.3 → 4.0.0-beta.30

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetCoordinatorLayout.kt

@@ -10,9 +10,11 @@ import android.view.ViewGroup
 import android.widget.EditText
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
 import com.facebook.react.uimanager.PointerEvents
 import com.facebook.react.uimanager.ReactPointerEventsView
 import com.facebook.react.uimanager.TouchTargetHelper
+import com.lodev09.truesheet.utils.KeyboardUtils
 import com.lodev09.truesheet.utils.isDescendantOf
 
 interface TrueSheetCoordinatorLayoutDelegate {
@@ -20,6 +22,15 @@ interface TrueSheetCoordinatorLayoutDelegate {
   fun coordinatorLayoutDidChangeConfiguration()
   fun findScrollView(): ViewGroup?
   fun findSheetView(): TrueSheetBottomSheetView?
+
+  /**
+   * A downward pull the sheet couldn't follow ended; `overdragPx` is the travel it
+   * didn't follow, `keyboardWasVisible` whether the keyboard was up when it began.
+   */
+  fun coordinatorLayoutDidPullDown(overdragPx: Int, keyboardWasVisible: Boolean)
+
+  // A touch that began inside the sheet ended, after the behavior handled the release
+  fun coordinatorLayoutDidEndTouch()
 }
 
 /**
@@ -57,13 +68,40 @@ class TrueSheetCoordinatorLayout(context: Context) :
   private var streamGestureClaimed = false
 
   // Whether the sheet owns vertical drags for this stream: the touch target is inside
-  // the sheet but outside the pinned scrollable (e.g. a header overlaying it), with
+  // the sheet but outside the detected scrollable (e.g. a header overlaying it), with
   // nothing vertically scrollable along its chain. Such targets consume the stream
   // natively (no nested scroll), and BottomSheetBehavior won't intercept because the
   // scrollable's bounds still contain the point (touchingScrollingChild) — intercept
   // manually.
   private var streamSheetDraggable = false
   private var streamDraggableEditText = false
+  private var streamScrollsIndependently = false
+
+  // Pull-down tracking. BottomSheetBehavior gives no callback when a downward drag
+  // is clamped by `isHideable = false` — the sheet stays put (or the scrollable
+  // overscrolls) and no state change fires. Accumulate the downward finger travel
+  // neither the sheet nor a scroller under the finger followed and report it on
+  // release so the controller can surface a blocked dismiss attempt. Like iOS, a
+  // pull that began on a scroller that could scroll up stays a scroll, even past
+  // its top.
+  private var pullTracking = false
+  private var pullStartX = 0f
+  private var pullStartY = 0f
+  private var pullLastY = 0f
+  private var pullOverdrag = 0f
+  private var pullKeyboardVisible = false
+  private var pullScrollers: List<View> = emptyList()
+  private var pullBeganScrolled = false
+
+  // A touch that began inside the sheet is still down
+  val isTouchingSheet: Boolean
+    get() = pullTracking
+
+  // Set while the sheet presents, from present() (keyboard wait included) until the
+  // present finishes or a dismiss starts. A stream that begins meanwhile is swallowed
+  // whole so nothing below takes it, like the iOS presentation transition.
+  var blocksTouches = false
+  private var streamBlocked = false
 
   init {
     layoutParams = LayoutParams(
@@ -94,6 +132,68 @@ class TrueSheetCoordinatorLayout(context: Context) :
   override val pointerEvents: PointerEvents
     get() = PointerEvents.BOX_NONE
 
+  override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.actionMasked == MotionEvent.ACTION_DOWN) streamBlocked = blocksTouches
+    if (streamBlocked) {
+      if (ev.actionMasked == MotionEvent.ACTION_UP || ev.actionMasked == MotionEvent.ACTION_CANCEL) {
+        streamBlocked = false
+      }
+      return true
+    }
+
+    when (ev.actionMasked) {
+      MotionEvent.ACTION_DOWN -> {
+        val sheet = delegate?.findSheetView()
+        pullTracking = sheet != null && isTouchInside(sheet, ev)
+        pullStartX = ev.rawX
+        pullStartY = ev.rawY
+        pullLastY = ev.rawY
+        pullOverdrag = 0f
+        pullKeyboardVisible = pullTracking && KeyboardUtils.isKeyboardVisible(this)
+      }
+
+      MotionEvent.ACTION_MOVE -> if (pullTracking) {
+        val sheet = delegate?.findSheetView()
+        val topBefore = sheet?.top
+        val handled = super.dispatchTouchEvent(ev)
+        val step = ev.rawY - pullLastY
+        pullLastY = ev.rawY
+        // Finger moved down but the sheet stayed put and nothing under the finger
+        // scrolled — the pull was clamped
+        if (!pullBeganScrolled &&
+          step > 0 &&
+          sheet != null &&
+          sheet.top == topBefore &&
+          pullScrollers.none { it.canScrollVertically(-1) }
+        ) {
+          pullOverdrag += step
+        }
+        return handled
+      }
+
+      MotionEvent.ACTION_UP -> if (pullTracking) {
+        pullTracking = false
+        val dx = kotlin.math.abs(ev.rawX - pullStartX)
+        val dy = ev.rawY - pullStartY
+        // Let the behavior settle first so the controller sees the resting position.
+        val handled = super.dispatchTouchEvent(ev)
+        if (dy > dx && pullOverdrag > PULL_DOWN_THRESHOLD_DP.dpToPx()) {
+          delegate?.coordinatorLayoutDidPullDown(pullOverdrag.toInt(), pullKeyboardVisible)
+        }
+        delegate?.coordinatorLayoutDidEndTouch()
+        return handled
+      }
+
+      MotionEvent.ACTION_CANCEL -> if (pullTracking) {
+        pullTracking = false
+        val handled = super.dispatchTouchEvent(ev)
+        delegate?.coordinatorLayoutDidEndTouch()
+        return handled
+      }
+    }
+    return super.dispatchTouchEvent(ev)
+  }
+
   /**
    * Clears stale `nestedScrollingChildRef` from BottomSheetBehavior.
    *
@@ -127,19 +227,29 @@ class TrueSheetCoordinatorLayout(context: Context) :
 
   /**
    * Resolves the stream's touch target (respecting zIndex and pointerEvents) and
-   * decides whether the sheet may drag from it — inside the sheet, outside the pinned
-   * scrollable, and nothing along the target's chain scrolls vertically.
+   * decides whether the sheet may drag from it — inside the sheet, outside the detected
+   * scrollable, and nothing along the target's chain scrolls vertically. Also collects
+   * the chain's vertical scrollers for pull-down tracking.
    */
   private fun updateStreamTargetFlags(ev: MotionEvent) {
     streamSheetDraggable = false
     streamDraggableEditText = false
+    streamScrollsIndependently = false
+    pullScrollers = emptyList()
+    pullBeganScrolled = false
 
     val sheet = delegate?.findSheetView() ?: return
     val target = TouchTargetHelper.findTargetPathAndCoordinatesForTouch(ev.x, ev.y, this, FloatArray(2))
       .firstNotNullOfOrNull { it.getView() } ?: return
     if (target !== sheet && !target.isDescendantOf(sheet)) return
 
-    // A pinned scrollable that can scroll (or hosts pull-to-refresh) owns its
+    pullScrollers = generateSequence(target) { it.parent as? View }
+      .takeWhile { it !== this }
+      .filter { it.canScrollVertically(1) || it.canScrollVertically(-1) }
+      .toList()
+    pullBeganScrolled = pullScrollers.any { it.canScrollVertically(-1) }
+
+    // A detected scrollable that can scroll (or hosts pull-to-refresh) owns its
     // touches — nested scrolling drags the sheet. When it can't scroll (e.g.
     // the sheet is fully expanded and the content fits) it eats the gesture
     // instead, so fall through and let the sheet drag from it — an EditText
@@ -152,7 +262,10 @@ class TrueSheetCoordinatorLayout(context: Context) :
 
     var view: View? = target
     while (view != null && view !== this) {
-      if (view.canScrollVertically(1) || view.canScrollVertically(-1)) return
+      if (view.canScrollVertically(1) || view.canScrollVertically(-1)) {
+        streamScrollsIndependently = !view.isNestedScrollingEnabled
+        return
+      }
       view = view.parent as? View
     }
 
@@ -160,6 +273,14 @@ class TrueSheetCoordinatorLayout(context: Context) :
     streamDraggableEditText = target is EditText
   }
 
+  private fun isTouchInside(view: View, ev: MotionEvent): Boolean {
+    val loc = IntArray(2)
+    view.getLocationOnScreen(loc)
+    val x = ev.rawX.toInt()
+    val y = ev.rawY.toInt()
+    return x >= loc[0] && x <= loc[0] + view.width && y >= loc[1] && y <= loc[1] + view.height
+  }
+
   private fun findDescendantViewAt(view: View, rawX: Int, rawY: Int, predicate: (View) -> Boolean): View? {
     val loc = IntArray(2)
     view.getLocationOnScreen(loc)
@@ -174,7 +295,7 @@ class TrueSheetCoordinatorLayout(context: Context) :
   }
 
   /**
-   * Called by descendant RootView implementations (controller, footer) when a child
+   * Called by the descendant RootView (controller) when a child
    * starts a native gesture — e.g. an RNGH handler activated or a scrollable began
    * scrolling. Yields sheet interception for the rest of the touch stream.
    */
@@ -226,6 +347,8 @@ class TrueSheetCoordinatorLayout(context: Context) :
       return false
     }
 
+    if (streamScrollsIndependently) return false
+
     if (streamGestureClaimed) {
       if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
         streamGestureClaimed = false
@@ -299,5 +422,6 @@ class TrueSheetCoordinatorLayout(context: Context) :
   companion object {
     private const val GESTURE_HANDLER_ROOT_VIEW_CLASS = "com.swmansion.gesturehandler.react.RNGestureHandlerRootView"
     private const val GESTURE_CLAIM_SLOP_FACTOR = 3
+    private const val PULL_DOWN_THRESHOLD_DP = 24f
   }
 }

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetDetentCalculator.kt

@@ -18,11 +18,27 @@ interface TrueSheetDetentCalculatorDelegate {
   val absoluteHeader: Boolean
   val footerHeight: Int
   val absoluteFooter: Boolean
+
+  /**
+   * True while the plugged scrollable is padded by the absolute footer's
+   * height (see ScrollableOptions.footerInsetAdjustment) — the footer then
+   * counts toward the auto detent like a relative one, so the content ends
+   * above it.
+   */
+  val footerInsetAdjustment: Boolean
+  val footerAvoidsKeyboard: Boolean
   val peekContentHeight: Int
   val contentBottomInset: Int
   val maxContentHeight: Int?
   val keyboardInset: Int
   val topInset: Int
+
+  /**
+   * True while the keyboard holds the sheet up: the collapsed stop then sits at
+   * the keyboard-free first detent (the "floor") so a drag-down dismisses the
+   * keyboard before it can dismiss the sheet.
+   */
+  val hasKeyboardFloor: Boolean
 }
 
 /**
@@ -44,6 +60,15 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   private val maxContentHeight: Int? get() = delegate?.maxContentHeight
   private val keyboardInset: Int get() = delegate?.keyboardInset ?: 0
   private val topInset: Int get() = delegate?.topInset ?: 0
+  private val hasKeyboardFloor: Boolean get() = delegate?.hasKeyboardFloor == true
+
+  /**
+   * An absolute footer floats over the content and contributes no height to
+   * the auto detent — unless it pads the scrollable, then the content ends
+   * above it like a relative footer.
+   */
+  private val footerInAuto: Boolean
+    get() = delegate?.absoluteFooter == false || delegate?.footerInsetAdjustment == true
 
   /**
    * Height for auto (-1.0) detents: content + header + footer height.
@@ -52,14 +77,14 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   private val autoDetentHeight: Int
     get() = contentHeight +
       (if (delegate?.absoluteHeader == true) 0 else headerHeight) +
-      (if (delegate?.absoluteFooter == true) 0 else footerHeight)
+      (if (footerInAuto) footerHeight else 0)
 
   /**
-   * Bottom inset for auto detents. A relative footer owns the sheet's bottom
-   * edge, so it absorbs the inset instead of adding it to the auto height.
+   * Bottom inset for auto detents. A footer counted in the auto height owns
+   * the sheet's bottom edge, so it absorbs the inset instead of adding it.
    */
   private val autoDetentBottomInset: Int
-    get() = if (footerHeight > 0 && delegate?.absoluteFooter == false) 0 else contentBottomInset
+    get() = if (footerHeight > 0 && footerInAuto) 0 else contentBottomInset
 
   /**
    * Bottom inset for peek detents. An absolute footer counts toward the peek
@@ -97,11 +122,37 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
       (detent * screenHeight).toInt() + contentBottomInset
     }
 
-    val height = if (includeKeyboard) baseHeight + keyboardInset else baseHeight
+    val keyboardHeight = if (includeKeyboard) keyboardInset else 0
+    val footerKeyboardOverlap = if (detent == -1.0 &&
+      delegate?.absoluteFooter == true &&
+      footerInAuto &&
+      delegate?.footerAvoidsKeyboard == false
+    ) {
+      minOf(keyboardHeight, maxOf(0, footerHeight - contentBottomInset))
+    } else {
+      0
+    }
+    val height = baseHeight + keyboardHeight - footerKeyboardOverlap
     val maxAllowedHeight = screenHeight + contentBottomInset
     return maxContentHeight?.let { minOf(height, it, maxAllowedHeight) } ?: minOf(height, maxAllowedHeight)
   }
 
+  fun getBackgroundIndex(sheetTop: Int, displayedIndex: Int): Int {
+    if (detents.isEmpty()) return -1
+
+    val height = getVisibleSheetHeight(sheetTop)
+    var nextIndex = displayedIndex.coerceIn(0, detents.size - 1)
+    var distance = kotlin.math.abs(height - getVisibleSheetHeight(getSheetTopForDetentIndex(nextIndex)))
+    for (index in detents.indices) {
+      val nextDistance = kotlin.math.abs(height - getVisibleSheetHeight(getSheetTopForDetentIndex(index)))
+      if (nextDistance < distance) {
+        nextIndex = index
+        distance = nextDistance
+      }
+    }
+    return nextIndex
+  }
+
   /**
    * Get the expected sheet top position for a detent index.
    */
@@ -110,12 +161,31 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
       RNLog.w(reactContext, "TrueSheet: Detent index ($index) is out of bounds (0..${detents.size - 1})")
       return realScreenHeight
     }
-    // Clamp to the space the sheet can actually occupy — matching
-    // setupSheetDetents. A keyboard-inflated detent height can exceed it,
-    // placing the expected top above the screen while the real sheet stops
-    // at the top inset.
+    // With a keyboard floor only the last detent stays keyboard-shifted — it's
+    // the keyboard-expanded resting position; the stops below it are keyboard-free
+    val isKeyboardFreeStop = hasKeyboardFloor && index != detents.size - 1
+    return getSheetTop(detents[index], includeKeyboard = !isKeyboardFreeStop)
+  }
+
+  /**
+   * Top of the lowest stop the sheet can rest at: the keyboard floor while it's
+   * active, else the first detent.
+   */
+  fun getLowestSheetTop(): Int = if (hasKeyboardFloor) getSheetTop(detents[0], includeKeyboard = false) else getSheetTopForDetentIndex(0)
+
+  /**
+   * Top of the half stop while the keyboard floor is active: the keyboard-free
+   * second detent, or the floor itself for a single detent.
+   */
+  fun getKeyboardHalfStopTop(): Int = getSheetTop(detents[minOf(1, detents.size - 1)], includeKeyboard = false)
+
+  // Clamp to the space the sheet can actually occupy — matching
+  // setupSheetDetents. A keyboard-inflated detent height can exceed it,
+  // placing the expected top above the screen while the real sheet stops
+  // at the top inset.
+  private fun getSheetTop(detent: Double, includeKeyboard: Boolean = true): Int {
     val maxAvailableHeight = realScreenHeight - topInset
-    return realScreenHeight - minOf(getDetentHeight(detents[index]), maxAvailableHeight)
+    return realScreenHeight - minOf(getDetentHeight(detent, includeKeyboard), maxAvailableHeight)
   }
 
   /**
@@ -152,6 +222,9 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    */
   fun getStateForDetentIndex(index: Int): Int {
     val stateMap = getDetentStateMap() ?: return BottomSheetBehavior.STATE_HIDDEN
+    // With a keyboard floor the keyboard-expanded last detent lives at the
+    // expanded stop — the half stop (which may share its index) is keyboard-free
+    if (hasKeyboardFloor && index == detents.size - 1) return BottomSheetBehavior.STATE_EXPANDED
     return stateMap.entries.find { it.value == index }?.key ?: BottomSheetBehavior.STATE_HIDDEN
   }
 
@@ -169,8 +242,12 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    */
   private fun getDetentStateMap(): Map<Int, Int>? =
     when (detents.size) {
+      // With one detent halfExpandedRatio matches the peek height, so the
+      // behavior can settle HALF_EXPANDED at the same position (e.g. an upward
+      // drag release) — map it too, or the settle is unmappable
       1 -> mapOf(
         BottomSheetBehavior.STATE_COLLAPSED to 0,
+        BottomSheetBehavior.STATE_HALF_EXPANDED to 0,
         BottomSheetBehavior.STATE_EXPANDED to 0
       )
 
@@ -197,16 +274,18 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
    * Find which segment the position falls into for interpolation.
    * @return Triple(fromIndex, toIndex, progress) where progress is 0-1, or null if no detents
    */
-  fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
+  private fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
     val count = detents.size
     if (count == 0) return null
 
-    val firstPos = getSheetTopForDetentIndex(0)
+    // A single keyboard-shifted detent can rest down at its keyboard floor —
+    // that range is still index 0, not a dismissal
+    val floorPos = getLowestSheetTop()
 
-    // Position is below first detent (sheet is being dragged down to dismiss)
-    if (positionPx > firstPos) {
-      val range = realScreenHeight - firstPos
-      val progress = if (range > 0) (positionPx - firstPos).toFloat() / range else 0f
+    // Position is below the lowest stop (sheet is being dragged down to dismiss)
+    if (positionPx > floorPos) {
+      val range = realScreenHeight - floorPos
+      val progress = if (range > 0) (positionPx - floorPos).toFloat() / range else 0f
       return Triple(-1, 0, progress)
     }
 
@@ -238,37 +317,23 @@ class TrueSheetDetentCalculator(private val reactContext: ThemedReactContext) {
   }
 
   /**
-   * Returns continuous index (e.g., 0.5 = halfway between detent 0 and 1).
+   * Returns interpolated continuous index (e.g., 0.5 = halfway between detent
+   * 0 and 1) and screen fraction for a position, sharing a single segment
+   * lookup — this runs on every position frame.
    */
-  fun getInterpolatedIndexForPosition(positionPx: Int): Float {
-    val count = detents.size
-    if (count == 0) return -1f
-
-    val segment = findSegmentForPosition(positionPx) ?: return 0f
-    val (fromIndex, _, progress) = segment
-
-    if (fromIndex == -1) return -progress
-    return fromIndex + progress
-  }
-
-  /**
-   * Returns interpolated screen fraction for position.
-   */
-  fun getInterpolatedDetentForPosition(positionPx: Int): Float {
-    val count = detents.size
-    if (count == 0) return 0f
+  fun getInterpolatedPositionInfo(positionPx: Int): Pair<Float, Float> {
+    if (detents.isEmpty()) return Pair(-1f, 0f)
 
-    val segment = findSegmentForPosition(positionPx) ?: return getDetentValueForIndex(0)
-    val (fromIndex, toIndex, progress) = segment
+    val (fromIndex, toIndex, progress) = findSegmentForPosition(positionPx)
+      ?: return Pair(0f, getDetentValueForIndex(0))
 
     if (fromIndex == -1) {
-      val firstDetent = getDetentValueForIndex(0)
-      return maxOf(0f, firstDetent * (1 - progress))
+      return Pair(-progress, maxOf(0f, getDetentValueForIndex(0) * (1 - progress)))
     }
 
     val fromDetent = getDetentValueForIndex(fromIndex)
     val toDetent = getDetentValueForIndex(toIndex)
-    return fromDetent + progress * (toDetent - fromDetent)
+    return Pair(fromIndex + progress, fromDetent + progress * (toDetent - fromDetent))
   }
 
   companion object {

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetDimView.kt

@@ -34,10 +34,6 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
   View(reactContext),
   ReactPointerEventsView {
 
-  companion object {
-    private const val MAX_ALPHA = 0.5f
-  }
-
   var delegate: TrueSheetDimViewDelegate? = null
 
   private var targetView: ViewGroup? = null
@@ -48,6 +44,10 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
   private val blockGestures: Boolean
     get() = alpha > 0f
 
+  fun setDimColor(color: Int) {
+    setBackgroundColor(color)
+  }
+
   init {
     layoutParams = ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
@@ -109,36 +109,33 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
   }
 
   // =============================================================================
-  // MARK: - Alpha Calculation
+  // MARK: - Progress Calculation
   // =============================================================================
 
-  fun calculateAlpha(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int): Float {
+  /**
+   * How far the sheet is into its dimmed range, from 0 (undimmed) to 1 (fully dimmed).
+   */
+  fun calculateProgress(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int): Float {
     val realHeight = ScreenUtils.getRealScreenHeight(reactContext)
     val dimmedDetentTop = getSheetTopForDetentIndex(dimmedDetentIndex)
     val belowDimmedTop = if (dimmedDetentIndex > 0) getSheetTopForDetentIndex(dimmedDetentIndex - 1) else realHeight
 
     return when {
-      sheetTop <= dimmedDetentTop -> MAX_ALPHA
-
+      sheetTop <= dimmedDetentTop -> 1f
       sheetTop >= belowDimmedTop -> 0f
-
-      else -> {
-        val progress = 1f - (sheetTop - dimmedDetentTop).toFloat() / (belowDimmedTop - dimmedDetentTop)
-        (progress * MAX_ALPHA).coerceIn(0f, MAX_ALPHA)
-      }
+      else -> (1f - (sheetTop - dimmedDetentTop).toFloat() / (belowDimmedTop - dimmedDetentTop)).coerceIn(0f, 1f)
     }
   }
 
-  fun interpolateAlpha(sheetTop: Int, dimmedDetentIndex: Int, getSheetTopForDetentIndex: (Int) -> Int) {
-    alpha = calculateAlpha(sheetTop, dimmedDetentIndex, getSheetTopForDetentIndex)
-  }
-
   // =============================================================================
   // MARK: - Touch Handling
   // =============================================================================
 
   override fun onTouchEvent(event: MotionEvent): Boolean {
     if (blockGestures) {
+      if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+        parent?.requestDisallowInterceptTouchEvent(true)
+      }
       // When dimmed, consume touch and trigger click on ACTION_UP
       if (event.action == MotionEvent.ACTION_UP) {
         performClick()

package/android/src/main/java/com/lodev09/truesheet/core/TrueSheetGrabberView.kt

@@ -2,7 +2,6 @@ package com.lodev09.truesheet.core
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.content.res.Configuration
 import android.graphics.Color
 import android.graphics.drawable.GradientDrawable
 import android.os.Bundle
@@ -13,6 +12,7 @@ import android.widget.FrameLayout
 import androidx.core.graphics.ColorUtils
 import androidx.core.view.ViewCompat
 import com.facebook.react.uimanager.PixelUtil.dpToPx
+import com.lodev09.truesheet.utils.isDarkMode
 
 /**
  * Options for customizing the grabber appearance.
@@ -165,9 +165,7 @@ class TrueSheetGrabberView(
   }
 
   private fun getAdaptiveColor(baseColor: Int? = null): Int {
-    val nightMode = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
-    val isDarkMode = nightMode == Configuration.UI_MODE_NIGHT_YES
-    val modeColor = if (isDarkMode) Color.WHITE else Color.BLACK
+    val modeColor = if (context.isDarkMode) Color.WHITE else Color.BLACK
 
     return if (baseColor != null) {
       // Blend user color with mode color for adaptive effect