@lodev09/react-native-true-sheet 4.0.0-beta.2 → 4.0.0-beta.21

package/android/src/main/java/com/lodev09/truesheet/TrueSheetViewController.kt

@@ -1,5 +1,6 @@
 package com.lodev09.truesheet
 
+import android.animation.ValueAnimator
 import android.annotation.SuppressLint
 import android.graphics.Canvas
 import android.os.Build
@@ -34,9 +35,11 @@ import com.lodev09.truesheet.core.TrueSheetDetentCalculator
 import com.lodev09.truesheet.core.TrueSheetDetentCalculatorDelegate
 import com.lodev09.truesheet.core.TrueSheetDimView
 import com.lodev09.truesheet.core.TrueSheetDimViewDelegate
+import com.lodev09.truesheet.core.TrueSheetDismissThreshold
 import com.lodev09.truesheet.core.TrueSheetKeyboardObserver
 import com.lodev09.truesheet.core.TrueSheetKeyboardObserverDelegate
 import com.lodev09.truesheet.core.TrueSheetStackManager
+import com.lodev09.truesheet.utils.Insets
 import com.lodev09.truesheet.utils.KeyboardUtils
 import com.lodev09.truesheet.utils.ScreenUtils
 import com.lodev09.truesheet.utils.TouchEventDeduper
@@ -54,6 +57,7 @@ interface TrueSheetViewControllerDelegate {
   fun viewControllerDidPresent(index: Int, position: Float, detent: Float)
   fun viewControllerWillDismiss()
   fun viewControllerDidDismiss(parent: TrueSheetView?)
+  fun viewControllerDidAttemptDismiss()
   fun viewControllerDidChangeDetent(index: Int, position: Float, detent: Float)
   fun viewControllerDidDragBegin(index: Int, position: Float, detent: Float)
   fun viewControllerDidDragChange(index: Int, position: Float, detent: Float)
@@ -78,17 +82,19 @@ interface TrueSheetViewControllerDelegate {
  * enabling touch pass-through to underlying views. Handles detent configuration, drag interactions,
  * keyboard avoidance, dimmed backgrounds, back button, and lifecycle events for stacked sheets.
  */
-enum class TrueSheetAnchor {
-  LEFT,
+enum class TrueSheetPlacement {
+  AUTOMATIC,
+  LEADING,
   CENTER,
-  RIGHT;
+  TRAILING;
 
   companion object {
-    fun fromString(value: String?): TrueSheetAnchor =
+    fun fromString(value: String?): TrueSheetPlacement =
       when (value) {
-        "left" -> LEFT
-        "right" -> RIGHT
-        else -> CENTER
+        "leading" -> LEADING
+        "center" -> CENTER
+        "trailing" -> TRAILING
+        else -> AUTOMATIC
       }
   }
 }
@@ -118,10 +124,14 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   companion object {
     private const val DEFAULT_MAX_WIDTH = 640 // dp
     private const val DEFAULT_CORNER_RADIUS = 16 // dp
-    private const val DEFAULT_ANCHOR_OFFSET = 16 // dp
+    private const val DEFAULT_PLACEMENT_OFFSET = 16 // dp
     private const val TRANSLATE_ANIMATION_DURATION = 200L
     private const val DISMISS_DURATION = 200L
     private const val SCREEN_FADE_DURATION = 150L
+
+    // Mirrors BottomSheetBehavior.HIDE_THRESHOLD — how far past the lowest stop,
+    // as a fraction of its height, a release hides a dismissible sheet
+    private const val HIDE_THRESHOLD = 0.5f
   }
 
   // =============================================================================
@@ -162,6 +172,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private var pendingDetentIndex: Int = -1
 
   private var interactionState: InteractionState = InteractionState.Idle
+
+  // A content/header/footer size change arrived mid-drag — reconfiguring then
+  // would reset behavior state and kill the gesture, so it's applied on settle.
+  private var hasPendingSizeChange = false
   internal var isBeingDismissed = false
     private set
   var wasHiddenByScreen = false
@@ -175,6 +189,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // Keyboard State
   private var detentIndexBeforeKeyboard: Int = -1
   private var isKeyboardDismissProgrammatic = false
+
+  // Sheet top when a keyboard-floor drag was released; -1 once the settle target is known
+  private var keyboardSettleStartTop = -1
   private var focusedViewBeforeBlur: View? = null
 
   // Promises
@@ -194,12 +211,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // Touch Dispatchers
   private val jsTouchDispatcher = JSTouchDispatcher(this)
   private val jsPointerDispatcher = JSPointerDispatcher(this)
-
-  // True when the active touch stream began inside the footer. Latched on
-  // ACTION_DOWN so subsequent MOVE events keep routing to the footer even if
-  // the finger drifts outside the footer's rect mid-gesture.
-  private var footerOwnsTouchStream = false
-
   private val touchDeduper = TouchEventDeduper()
 
   private val eventDispatcher
@@ -208,8 +219,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // Detent Configuration
   override var maxContentHeight: Int? = null
   override var maxContentWidth: Int? = null
-  override var anchor: TrueSheetAnchor = TrueSheetAnchor.CENTER
-  override var anchorOffset: Int = DEFAULT_ANCHOR_OFFSET.dpToPx().toInt()
+  override var placement: TrueSheetPlacement = TrueSheetPlacement.AUTOMATIC
+  override var placementOffset: Int = DEFAULT_PLACEMENT_OFFSET.dpToPx().toInt()
   override var detents: MutableList<Double> = mutableListOf(0.5, 1.0)
 
   // Appearance Configuration
@@ -218,7 +229,13 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   override var grabber: Boolean = true
   override var grabberOptions: GrabberOptions? = null
   override var accessibilityOptions: AccessibilityOptions? = null
+  var backgroundColor: Int? = null
+  var detentBackgrounds: List<Int?> = emptyList()
+  private var displayedBackgroundIndex = 0
+  private var backgroundAnimator: ValueAnimator? = null
+  private var targetBackgroundColor: Int? = null
   override var sheetBackgroundColor: Int? = null
+    private set
   var insetAdjustment: TrueSheetInsetAdjustment = TrueSheetInsetAdjustment.AUTOMATIC
 
   var scrollableOptions: ScrollableOptions? = null
@@ -227,6 +244,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       behavior?.scrollingExpandsSheet = value?.scrollingExpandsSheet ?: true
     }
 
+  // React tag of the user-provided scrollable within the content (see the scrollableRef prop)
+  var scrollableHandle: Int = -1
+
   override var sheetCornerRadius: Float = DEFAULT_CORNER_RADIUS.dpToPx()
     set(value) {
       field = if (value < 0) DEFAULT_CORNER_RADIUS.dpToPx() else value
@@ -252,6 +272,12 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       if (isPresented) sheetView?.setupGrabber()
     }
 
+  var dismissThreshold: TrueSheetDismissThreshold = TrueSheetDismissThreshold.HALF
+    set(value) {
+      field = value
+      behavior?.dismissThreshold = value
+    }
+
   // =============================================================================
   // MARK: - Computed Properties
   // =============================================================================
@@ -270,9 +296,29 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   val screenWidth: Int
     get() = ScreenUtils.getScreenWidth(reactContext)
 
+  // Cached per layout/configuration pass — the WindowManager and
+  // rootWindowInsets queries behind these allocate, and they're read many
+  // times per animation frame (position emission, detent interpolation,
+  // stacked sheet sync)
+  private var cachedRealScreenHeight: Int = 0
+  private var cachedInsets: Insets? = null
+
+  private fun invalidateScreenMetrics() {
+    cachedRealScreenHeight = 0
+    cachedInsets = null
+  }
+
   // Includes system bars for accurate positioning
   override val realScreenHeight: Int
-    get() = ScreenUtils.getRealScreenHeight(reactContext)
+    get() {
+      if (cachedRealScreenHeight == 0) {
+        cachedRealScreenHeight = ScreenUtils.getRealScreenHeight(reactContext)
+      }
+      return cachedRealScreenHeight
+    }
+
+  private val insets: Insets
+    get() = cachedInsets ?: ScreenUtils.getInsets(reactContext).also { cachedInsets = it }
 
   // Content Measurements
   // Cached values used during dismiss when container is unmounted
@@ -294,6 +340,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   override var absoluteFooter: Boolean = false
 
+  override val footerInsetAdjustment: Boolean
+    get() = absoluteFooter && scrollableHandle > 0 && scrollableOptions?.contentInsetAdjustment?.footer != false
+
   override val peekContentHeight: Int
     get() = containerView?.peekContentHeight ?: cachedPeekContentHeight
 
@@ -309,16 +358,30 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private val isKeyboardTransitioning: Boolean
     get() = keyboardObserver?.isTransitioning ?: false
 
+  // Keyboard is up or animating — detents are (or are about to be) keyboard-shifted
+  val isKeyboardActive: Boolean
+    get() = keyboardInset > 0 || isKeyboardTransitioning
+
+  // While the keyboard holds the sheet up, the keyboard-free first detent is the
+  // collapsed stop — landing there dismisses the keyboard, and (when dismissible)
+  // dragging more than half its height below it hides the sheet too, like iOS.
+  override val hasKeyboardFloor: Boolean
+    get() = keyboardInset > 0
+
+  // The detent JS last heard about — the keyboard expansion is never reported
+  private val knownDetentIndex: Int
+    get() = if (detentIndexBeforeKeyboard >= 0) detentIndexBeforeKeyboard else currentDetentIndex
+
   fun isFocusedViewWithinSheet(): Boolean {
     val sheet = sheetView ?: return false
     return keyboardObserver?.isFocusedViewWithinSheet(sheet) ?: false
   }
 
   val bottomInset: Int
-    get() = if (edgeToEdgeEnabled) ScreenUtils.getInsets(reactContext).bottom else 0
+    get() = if (edgeToEdgeEnabled) insets.bottom else 0
 
   override val topInset: Int
-    get() = if (edgeToEdgeEnabled) ScreenUtils.getInsets(reactContext).top else 0
+    get() = if (edgeToEdgeEnabled) insets.top else 0
 
   override val contentBottomInset: Int
     get() = if (insetAdjustment == TrueSheetInsetAdjustment.AUTOMATIC) bottomInset else 0
@@ -331,6 +394,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
   // Sheet State
+  val isSettling: Boolean
+    get() = behavior?.state == BottomSheetBehavior.STATE_SETTLING
+
   val isExpanded: Boolean
     get() {
       val sheetTop = sheetView?.top ?: return false
@@ -373,6 +439,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   private fun cleanupSheet() {
     cleanupKeyboardObserver()
+    backgroundAnimator?.cancel()
+    backgroundAnimator = null
+    targetBackgroundColor = null
     sheetView?.animate()?.cancel()
 
     // Cleanup dim views
@@ -392,6 +461,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     sheetView = null
 
     interactionState = InteractionState.Idle
+    hasPendingSizeChange = false
     isBeingDismissed = false
     isPresented = false
     isSheetVisible = false
@@ -440,13 +510,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // =============================================================================
 
   override fun coordinatorLayoutDidLayout(changed: Boolean) {
-    // Reposition footer when layout changes
+    if (changed) invalidateScreenMetrics()
+
     if (isPresented && changed) {
-      positionFooter()
+      setupSheetDetentsForSizeChange()
     }
   }
 
   override fun coordinatorLayoutDidChangeConfiguration() {
+    invalidateScreenMetrics()
     if (!isPresented) return
 
     sheetView?.updateGravity()
@@ -458,6 +530,28 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   override fun findScrollView(): ViewGroup? = containerView?.contentView?.findScrollView()
   override fun findSheetView(): TrueSheetBottomSheetView? = sheetView
 
+  override fun coordinatorLayoutDidPullDown(overdragPx: Int, keyboardWasVisible: Boolean) {
+    if (!isPresented || dismissible || !draggable) return
+    val sheet = sheetView ?: return
+
+    // Only a pull clamped at the lowest stop is a blocked drag-to-dismiss — a
+    // child that swallowed the gesture higher up isn't
+    val lowestTop = detentCalculator.getLowestSheetTop()
+    if (sheet.top < lowestTop) return
+
+    if (keyboardWasVisible) {
+      // A sheet that couldn't move at all (first detent already full height) never
+      // began a drag, so the keyboard is still up — dismiss it here
+      if (hasKeyboardFloor && !isKeyboardDismissProgrammatic) commitDetentAndDismissKeyboard(0, sheet)
+
+      // Past the floor by the distance that would hide a dismissible sheet, like iOS
+      val floorHeight = realScreenHeight - lowestTop
+      if (overdragPx < floorHeight * HIDE_THRESHOLD) return
+    }
+
+    delegate?.viewControllerDidAttemptDismiss()
+  }
+
   // =============================================================================
   // MARK: - TrueSheetDimViewDelegate
   // =============================================================================
@@ -495,24 +589,30 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   override fun bottomSheetViewDidTapGrabber() {
     val nextIndex = (currentDetentIndex + 1) % detents.size
-    if (nextIndex == 0 && detents.size == 1 && dismissible) {
-      dismiss(animated = true)
+    if (nextIndex == 0 && detents.size == 1) {
+      if (dismissible) {
+        dismiss(animated = true)
+      } else {
+        delegate?.viewControllerDidAttemptDismiss()
+      }
     } else {
-      setStateForDetentIndex(nextIndex)
+      resize(nextIndex)
     }
   }
 
   override fun bottomSheetViewDidAccessibilityIncrement() {
     if (currentDetentIndex < detents.size - 1) {
-      setStateForDetentIndex(currentDetentIndex + 1)
+      resize(currentDetentIndex + 1)
     }
   }
 
   override fun bottomSheetViewDidAccessibilityDecrement() {
     if (currentDetentIndex > 0) {
-      setStateForDetentIndex(currentDetentIndex - 1)
+      resize(currentDetentIndex - 1)
     } else if (dismissible) {
       dismiss(animated = true)
+    } else {
+      delegate?.viewControllerDidAttemptDismiss()
     }
   }
 
@@ -526,7 +626,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
     override fun onSlide(sheetView: View, slideOffset: Float) {
-      handleSlide(sheetView, slideOffset)
+      handleSlide(sheetView)
     }
   }
 
@@ -555,27 +655,44 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
   }
 
-  private fun handleSlide(sheetView: View, slideOffset: Float) {
+  private fun handleSlide(sheetView: View) {
     // Skip during dismiss animation
     if (isBeingDismissed) return
 
     val behavior = behavior ?: return
 
+    if (interactionState is InteractionState.Dragging || pendingDetentIndex >= 0) {
+      updateStateDimensionsForPosition(sheetView.top)
+    }
+
     when (behavior.state) {
-      BottomSheetBehavior.STATE_DRAGGING,
-      BottomSheetBehavior.STATE_SETTLING -> handleDragChange(sheetView)
+      BottomSheetBehavior.STATE_DRAGGING -> handleDragChange(sheetView)
+
+      BottomSheetBehavior.STATE_SETTLING -> {
+        handleDragChange(sheetView)
+        dismissKeyboardForSettleTarget(sheetView)
+      }
 
       else -> { }
     }
 
     emitChangePositionDelegate(sheetView.top)
 
+    // Drive the parent's stack translation from our actual frame position —
+    // an independently-timed animation lags behind (e.g. auto detent shrink)
+    // and reveals the parent above this sheet's top edge. Skipped while
+    // dragging so the parent stays put during drag-to-dismiss, and while the
+    // keyboard is active so growing for it doesn't move the parent (like iOS).
+    if (!isPresentAnimating && interactionState !is InteractionState.Dragging && !isKeyboardActive) {
+      syncParentTranslation(sheetView.top)
+    }
+
     // Position on every slide frame — during keyboard transitions the IME
     // animation callbacks are sparser than the sheet's settle frames, and the
     // footer rides the sheet between them, jittering against the keyboard.
     // positionFooter derives from current state, so double-driving it with
     // keyboardDidChangeHeight is harmless.
-    positionFooter(slideOffset)
+    positionFooter()
 
     if (!isKeyboardTransitioning) {
       updateDimAmount(sheetView.top)
@@ -585,11 +702,22 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private fun handleStateSettled(sheetView: View, newState: Int) {
     if (interactionState is InteractionState.Reconfiguring) return
 
+    // A release already at a stop settles without a slide frame
+    keyboardSettleStartTop = -1
+
     // Sheet has reached a stable state — any in-flight resize target is now stale,
     // whether settled at the target, interrupted by drag, or superseded.
     pendingDetentIndex = -1
 
-    val index = detentCalculator.getDetentIndexForState(newState) ?: return
+    val index = detentCalculator.getDetentIndexForState(newState) ?: run {
+      // Unmapped settle — end any drag anyway so deferred size changes aren't
+      // dropped forever (a leaked Dragging state skips every reconfigure)
+      if (interactionState is InteractionState.Dragging) {
+        interactionState = InteractionState.Idle
+      }
+      flushPendingSizeChange()
+      return
+    }
     val position = getPositionDpForView(sheetView)
     val detentInfo = DetentInfo(index, position)
 
@@ -597,21 +725,30 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     if (isPresentAnimating) {
       isPresentAnimating = false
       finishPresent()
+      flushPendingSizeChange()
       return
     }
 
+    val wasDragging = interactionState is InteractionState.Dragging
+
     when (interactionState) {
       is InteractionState.Dragging -> {
         val detent = detentCalculator.getDetentValueForIndex(detentInfo.index)
         delegate?.viewControllerDidDragEnd(detentInfo.index, detentInfo.position, detent)
 
-        // Skip detent change if keyboard inset is still active — detent mapping is unreliable.
-        // keyboardWillHide will recalculate detents and settle at the correct index.
-        if (detentInfo.index != currentDetentIndex && keyboardInset == 0) {
-          currentDetentIndex = detentInfo.index
-          setupDimmedBackground()
-          delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
-          this@TrueSheetViewController.sheetView?.updateGrabberAccessibilityValue(detentInfo.index, detents.size)
+        // Skip detent change if keyboard inset is still active — the keyboard floor
+        // landing below commits the detent instead.
+        if (keyboardInset == 0) {
+          val changed = detentInfo.index != knownDetentIndex
+          detentIndexBeforeKeyboard = -1
+          if (detentInfo.index != currentDetentIndex) {
+            currentDetentIndex = detentInfo.index
+            setupDimmedBackground()
+          }
+          if (changed) {
+            delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+            this@TrueSheetViewController.sheetView?.updateGrabberAccessibilityValue(detentInfo.index, detents.size)
+          }
         }
 
         interactionState = InteractionState.Idle
@@ -629,14 +766,28 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       }
     }
 
-    // Settled — resize the container to the settled detent (applies deferred shrinks)
-    updateStateDimensions()
+    if (hasKeyboardFloor && wasDragging && newState != BottomSheetBehavior.STATE_EXPANDED) {
+      // Dragged down onto a keyboard-free stop (the floor or the keyboard detent) —
+      // dismiss the keyboard and commit that detent. keyboardWillHide reconfigures
+      // the detents (and the container) to it.
+      commitDetentAndDismissKeyboard(index, sheetView)
+    } else {
+      updateStateDimensions()
+    }
 
     if (!isKeyboardTransitioning) {
       updateDimAmount(animated = true)
     }
 
     TrueSheetStackManager.updateBackgroundAccessibility()
+
+    flushPendingSizeChange()
+  }
+
+  private fun flushPendingSizeChange() {
+    if (!hasPendingSizeChange) return
+    hasPendingSizeChange = false
+    setupSheetDetentsForSizeChange()
   }
 
   // =============================================================================
@@ -698,6 +849,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val sheet = this.sheetView ?: return
     if (isPresented) return
 
+    invalidateScreenMetrics()
     shouldAnimatePresent = animated
     currentDetentIndex = detentIndex
     interactionState = InteractionState.Idle
@@ -711,6 +863,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     setupDimmedBackground()
     setupKeyboardObserver()
 
+    displayedBackgroundIndex = detentIndex
+    setupBackground(animated = false)
     sheet.setupBackground()
     sheet.setupElevation()
     sheet.setupGrabber()
@@ -735,13 +889,18 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   fun resize(detentIndex: Int) {
     if (!isPresented) return
 
-    // Commit the new index so keyboardWillHide restores to it instead of the stale one
+    // Commit the new index so keyboardWillHide restores to it instead of the stale
+    // one; the sheet keeps avoiding the keyboard meanwhile
     if (detentIndexBeforeKeyboard >= 0) {
       detentIndexBeforeKeyboard = detentIndex
+      if (hasKeyboardFloor) {
+        resizePromise?.invoke()
+        resizePromise = null
+        return
+      }
     }
 
     pendingDetentIndex = detentIndex
-    updateStateDimensions(deferShrink = true)
     setupDimmedBackground()
     setStateForDetentIndex(detentIndex)
     resizePromise?.invoke()
@@ -763,6 +922,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     behavior.isHideable = true
     behavior.isDraggable = draggable
     behavior.scrollingExpandsSheet = scrollableOptions?.scrollingExpandsSheet ?: true
+    behavior.dismissThreshold = dismissThreshold
+    behavior.lowestSheetTop = { detentCalculator.getLowestSheetTop() }
     behavior.state = BottomSheetBehavior.STATE_HIDDEN
     behavior.addBottomSheetCallback(sheetCallback)
 
@@ -866,11 +1027,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     val maxAvailableHeight = realScreenHeight - topInset
 
-    val peekHeight = minOf(detentCalculator.getDetentHeight(detents[0]), maxAvailableHeight)
+    // With a keyboard floor only the last detent stays keyboard-shifted; the
+    // collapsed and half stops are the keyboard-free first and second detents,
+    // so a short drag down from the keyboard-expanded sheet rests at the second
+    // and a long one at the first, like iOS
+    val peekHeight = minOf(detentCalculator.getDetentHeight(detents[0], includeKeyboard = !hasKeyboardFloor), maxAvailableHeight)
 
     val halfExpandedDetentHeight = when (detents.size) {
       1 -> peekHeight
-      else -> detentCalculator.getDetentHeight(detents[1])
+      else -> detentCalculator.getDetentHeight(detents[1], includeKeyboard = !hasKeyboardFloor)
     }
 
     val maxDetentHeight = minOf(detentCalculator.getDetentHeight(detents.last()), maxAvailableHeight)
@@ -880,8 +1045,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     val expandedOffset = realScreenHeight - maxDetentHeight
 
-    // fitToContents works better with <= 2 detents when no expanded offset
-    val fitToContents = detents.size < 3 && expandedOffset == 0
+    // fitToContents works better with <= 2 detents when no expanded offset, but
+    // it drops the half stop the keyboard floor relies on
+    val fitToContents = !hasKeyboardFloor && detents.size < 3 && expandedOffset == 0
 
     configureDetents(
       behavior = behavior,
@@ -892,13 +1058,25 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       animate = isPresented
     )
 
-    updateStateDimensions()
-
     if (isPresented && applyState) {
       // Prefer the pending target while a resize animation is in flight so a
       // layout-driven reconfigure doesn't revert to the stale currentDetentIndex.
       val targetIndex = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
+
+      // Track the settle like resize() — the container (and the footer pinned
+      // to its bottom) follows the sheet's visible height instead of jumping
+      // to the target and riding the animation
+      pendingDetentIndex = targetIndex
+      sheetView?.let { updateStateDimensionsForPosition(it.top) }
       setStateForDetentIndex(targetIndex)
+
+      // Already at the target — no slide frames will follow
+      if (!isSettling) {
+        pendingDetentIndex = -1
+        updateStateDimensions()
+      }
+    } else {
+      updateStateDimensions()
     }
 
     interactionState = InteractionState.Idle
@@ -922,10 +1100,13 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   fun setupSheetDetentsForSizeChange() {
-    // Skip while dragging — the size change is driven by the drag itself (the
-    // container tracks the sheet's visible height), and reconfiguring resets
-    // behavior state, killing the gesture.
-    if (interactionState is InteractionState.Dragging) return
+    // Reconfiguring while the container tracks the sheet can interrupt its
+    // motion. Apply content size changes once the drag or resize settles.
+    if (interactionState is InteractionState.Dragging || isSettling) {
+      hasPendingSizeChange = true
+      return
+    }
+    hasPendingSizeChange = false
 
     setupSheetDetents()
     positionFooter()
@@ -939,6 +1120,30 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // MARK: - Dimmed Background
   // =============================================================================
 
+  fun setupBackground(animated: Boolean = true) {
+    val sheet = sheetView ?: return
+    val color = detentBackgrounds.getOrNull(displayedBackgroundIndex)
+      ?: backgroundColor ?: sheet.getDefaultBackgroundColor()
+    if (animated && color == targetBackgroundColor) return
+
+    backgroundAnimator?.cancel()
+    targetBackgroundColor = color
+    val startColor = sheetBackgroundColor ?: color
+    if (!animated || !isPresented || startColor == color) {
+      sheetBackgroundColor = color
+      sheet.updateBackgroundColor(color)
+      return
+    }
+    backgroundAnimator = ValueAnimator.ofArgb(startColor, color).apply {
+      duration = 200L
+      addUpdateListener {
+        sheetBackgroundColor = it.animatedValue as Int
+        sheet.updateBackgroundColor(it.animatedValue as Int)
+      }
+      start()
+    }
+  }
+
   fun setupDimmedBackground() {
     val coordinator = this.coordinatorLayout ?: run {
       RNLog.e(reactContext, "TrueSheet: coordinatorLayout is null in setupDimmedBackground")
@@ -978,10 +1183,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   fun updateDimAmount(sheetTop: Int? = null, animated: Boolean = false) {
     if (!dimmed) return
-    if (contentHeight == 0) return
 
     // While keyboard is active or transitioning, use the target detent position for dim
-    val top = if (keyboardInset > 0 || isKeyboardTransitioning) {
+    val top = if (isKeyboardActive) {
       detentCalculator.getSheetTopForDetentIndex(currentDetentIndex)
     } else {
       val keyboardOffset = if (isBeingDismissed) 0 else currentKeyboardInset
@@ -1006,13 +1210,17 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   var footerKeyboardOffset: Int = 0
 
-  fun positionFooter(slideOffset: Float? = null) {
+  /**
+   * false keeps an absolute footer pinned to the sheet's bottom edge behind
+   * the keyboard instead of rising above it.
+   */
+  override var footerAvoidsKeyboard: Boolean = true
+
+  fun positionFooter() {
     if (!isPresented) return
     val footerView = containerView?.footerView ?: return
     val sheet = sheetView ?: return
 
-    val keyboardShift = if (currentKeyboardInset > 0) maxOf(0, currentKeyboardInset + footerKeyboardOffset) else 0
-
     // A relative footer is laid out by Yoga (pinned to the container's bottom
     // edge) and stays in the layout flow behind the keyboard — only an
     // absolute footer floats above it
@@ -1021,24 +1229,31 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       return
     }
 
+    // The footer's absorbed safe-area inset rides below the keyboard's top
+    // edge — its content stays flush with the keyboard without dropping the
+    // inset padding from the layout, which would jump at the transition edges
+    val keyboardShift = if (currentKeyboardInset > 0 && footerAvoidsKeyboard) {
+      maxOf(0, currentKeyboardInset + footerKeyboardOffset - footerView.bottomInset)
+    } else {
+      0
+    }
+
     val footerHeight = footerView.height
     val sheetHeight = sheet.height
-    val sheetTop = sheet.top
-
-    var footerY = (sheetHeight - sheetTop - footerHeight - keyboardShift).toFloat()
 
-    // Adjust during dismiss animation when slideOffset is negative. Skipped
-    // while the keyboard is open — the detents collapse to the expanded
-    // position, so any downward drag reads as a negative slideOffset and the
-    // adjustment would sink the footer behind the keyboard, snapping back up
-    // when the keyboard detents reset on release.
-    if (slideOffset != null && slideOffset < 0 && keyboardShift == 0) {
-      footerY -= (footerHeight * slideOffset)
-    }
+    // Pinned to the screen bottom (above the keyboard) while the sheet sits at
+    // or above its lowest stop; dragged past it the footer rides down with the
+    // sheet instead, like iOS. A resize settle always pins — the sheet may be
+    // animating up from below a stop that just grew
+    val anchorTop = if (pendingDetentIndex >= 0) sheet.top else minOf(sheet.top, detentCalculator.getLowestSheetTop())
+    val footerY = (sheetHeight - anchorTop - footerHeight - keyboardShift).toFloat()
 
     // Clamp to prevent footer going above safe area
     val maxAllowedY = (sheetHeight - topInset - footerHeight).toFloat()
     footerView.y = minOf(footerY, maxAllowedY)
+    if (!footerAvoidsKeyboard) {
+      containerView?.contentView?.updateContentInset()
+    }
   }
 
   // =============================================================================
@@ -1064,7 +1279,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     if (!viewToFocus.isAttachedToWindow) return
     if (viewToFocus.requestFocus()) {
       viewToFocus.postDelayed({
-        KeyboardUtils.show(viewToFocus)
+        if (viewToFocus.isFocused) KeyboardUtils.show(viewToFocus)
       }, 100)
     }
   }
@@ -1079,9 +1294,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       delegate = object : TrueSheetKeyboardObserverDelegate {
         override fun keyboardWillShow(height: Int) {
           if (!shouldHandleKeyboard()) return
-          // An absolute footer rises above the keyboard, so it drops the bottom
-          // inset padding — before detents are configured against its height
-          if (absoluteFooter) containerView?.footerView?.keyboardVisible = true
           // If a resize is in flight, restore to its target — not the stale current
           detentIndexBeforeKeyboard = if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex
           pendingDetentIndex = -1
@@ -1094,17 +1306,22 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         override fun keyboardWillHide() {
           if (!shouldHandleKeyboard(checkFocus = false)) return
-          containerView?.footerView?.keyboardVisible = false
+          // Mid-drag (the drag itself dismissed the keyboard) the release decides
+          // the detent and a reconfigure would kill the gesture — the floor stops
+          // stay put until the settle flushes the pending reconfigure
+          if (interactionState is InteractionState.Dragging) {
+            hasPendingSizeChange = true
+            return
+          }
           val restoring = !isBeingDismissed && detentIndexBeforeKeyboard >= 0
 
           // Skip reconfigure during interactive keyboard dismiss (e.g. keyboardDismissMode="on-drag")
           // to prevent the sheet from jumping. keyboardDidHide will reconfigure after.
           if (restoring || isKeyboardDismissProgrammatic) {
-            setupSheetDetents()
             if (restoring) {
               currentDetentIndex = detentIndexBeforeKeyboard
-              setStateForDetentIndex(currentDetentIndex)
             }
+            setupSheetDetents()
           }
 
           // Same-frame reposition — the reconfigure above shrinks the container
@@ -1119,9 +1336,13 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         override fun keyboardDidHide() {
           if (!shouldHandleKeyboard(checkFocus = false)) return
-          containerView?.footerView?.keyboardVisible = false
-          detentIndexBeforeKeyboard = -1
           isKeyboardDismissProgrammatic = false
+          // Keep detentIndexBeforeKeyboard for the settle's detent-change check
+          if (interactionState is InteractionState.Dragging) {
+            hasPendingSizeChange = true
+            return
+          }
+          detentIndexBeforeKeyboard = -1
           setupSheetDetents(applyState = false)
           positionFooter()
           updateDimAmount(
@@ -1141,7 +1362,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
           // Handle case where keyboard is already visible and focus moves into the sheet
           if (!shouldHandleKeyboard()) return
           if (detentIndexBeforeKeyboard < 0 && (keyboardObserver?.currentHeight ?: 0) > 0) {
-            if (absoluteFooter) containerView?.footerView?.keyboardVisible = true
             detentIndexBeforeKeyboard = currentDetentIndex
             currentDetentIndex = detents.size - 1
             setupSheetDetents()
@@ -1169,8 +1389,28 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     detentIndexBeforeKeyboard = -1
   }
 
+  private fun handleSettling(sheetView: View) {
+    // A keyboard-floor drag was released — the first settle frame reveals the target
+    keyboardSettleStartTop = if (hasKeyboardFloor && interactionState is InteractionState.Dragging) sheetView.top else -1
+  }
+
+  /**
+   * Dismisses the keyboard as soon as a released drag is known to land on a
+   * keyboard-free stop, rather than waiting for the landing. BottomSheetBehavior
+   * keeps its target private, so read it off the first settle frame: heading
+   * down means the half stop or the floor; heading up from below the half stop
+   * means the half stop; only heading up from above it means the expanded stop.
+   */
+  private fun dismissKeyboardForSettleTarget(sheetView: View) {
+    if (keyboardSettleStartTop < 0) return
+    val startTop = keyboardSettleStartTop
+    keyboardSettleStartTop = -1
+
+    val headingToKeyboardFreeStop = sheetView.top > startTop || startTop > detentCalculator.getKeyboardHalfStopTop()
+    if (headingToKeyboardFreeStop && shouldHandleKeyboard()) dismissKeyboard()
+  }
+
   private fun handleDragBegin(sheetView: View) {
-    detentIndexBeforeKeyboard = -1
     pendingDetentIndex = -1
 
     val position = getPositionDpForView(sheetView)
@@ -1179,43 +1419,25 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     interactionState = InteractionState.Dragging(startTop = sheetView.top)
   }
 
-  private fun handleSettling(sheetView: View) {
-    if (interactionState !is InteractionState.Dragging) return
-    if (keyboardInset <= 0) return
+  // Commits a non-keyboard detent and hides the keyboard; keyboardWillHide then
+  // reconfigures the detents so the sheet settles at the committed index.
+  private fun commitDetentAndDismissKeyboard(index: Int, sheetView: View) {
+    val changed = index != knownDetentIndex
+    detentIndexBeforeKeyboard = -1
+    currentDetentIndex = index
+    dismissKeyboard()
+    setupDimmedBackground()
 
-    // After drag release, check if the sheet was dragged past the midpoint between the
-    // keyboard-expanded position and a non-keyboard detent position. If so, dismiss
-    // keyboard and commit to that detent.
-    val maxAvailableHeight = realScreenHeight - topInset
-    val keyboardTop = detentCalculator.getSheetTopForDetentIndex(detents.size - 1)
-
-    for (i in detents.indices) {
-      val nonKeyboardHeight = minOf(detentCalculator.getDetentHeight(detents[i], includeKeyboard = false), maxAvailableHeight)
-      val nonKeyboardTop = realScreenHeight - nonKeyboardHeight
-      val midpoint = keyboardTop + (nonKeyboardTop - keyboardTop) / 2
-
-      if (sheetView.top >= midpoint) {
-        // Target position matches the keyboard-expanded position — keep keyboard open
-        if (nonKeyboardTop == keyboardTop) break
-
-        detentIndexBeforeKeyboard = -1
-        currentDetentIndex = i
-        dismissKeyboard()
-        setupDimmedBackground()
-
-        val position = getPositionDpForView(sheetView)
-        val detent = detentCalculator.getDetentValueForIndex(i)
-        delegate?.viewControllerDidChangeDetent(i, position, detent)
-        break
-      }
-    }
+    if (!changed) return
+    val position = getPositionDpForView(sheetView)
+    val detent = detentCalculator.getDetentValueForIndex(index)
+    delegate?.viewControllerDidChangeDetent(index, position, detent)
+    this.sheetView?.updateGrabberAccessibilityValue(index, detents.size)
   }
 
   private fun handleDragChange(sheetView: View) {
     if (interactionState !is InteractionState.Dragging) return
 
-    updateStateDimensionsForDrag(sheetView.top)
-
     val position = getPositionDpForView(sheetView)
     val detent = detentCalculator.getDetentValueForIndex(currentDetentIndex)
     delegate?.viewControllerDidDragChange(currentDetentIndex, position, detent)
@@ -1250,14 +1472,20 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   private fun emitChangePositionDelegate(currentTop: Int, realtime: Boolean = true) {
+    if (isPresented && !isPresentAnimating && !isBeingDismissed) {
+      val index = detentCalculator.getBackgroundIndex(currentTop, displayedBackgroundIndex)
+      if (index != displayedBackgroundIndex) {
+        displayedBackgroundIndex = index
+        setupBackground()
+      }
+    }
     // Dedupe emissions for same position
     if (currentTop == lastEmittedPositionPx) return
 
     lastEmittedPositionPx = currentTop
     val visibleHeight = realScreenHeight - currentTop
     val position = detentCalculator.getPositionDp(visibleHeight)
-    val interpolatedIndex = detentCalculator.getInterpolatedIndexForPosition(currentTop)
-    val detent = detentCalculator.getInterpolatedDetentForPosition(currentTop)
+    val (interpolatedIndex, detent) = detentCalculator.getInterpolatedPositionInfo(currentTop)
     delegate?.viewControllerDidChangePosition(interpolatedIndex, position, detent, realtime)
   }
 
@@ -1265,9 +1493,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
    * Updates position emission, footer, and dim amount together.
    * This pattern is commonly used during animations and state changes.
    */
-  private fun updateSheetVisuals(effectiveTop: Int, slideOffset: Float? = null) {
+  private fun updateSheetVisuals(effectiveTop: Int) {
     emitChangePositionDelegate(effectiveTop)
-    positionFooter(slideOffset)
+    positionFooter()
     updateDimAmount(effectiveTop)
   }
 
@@ -1287,13 +1515,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   /**
    * Updates the Fabric state with the current/target detent size so Yoga sizes
    * the container to the sheet's visible height.
-   *
-   * Unlike iOS, resize animations run over multiple frames (ViewDragHelper), so
-   * shrinking is deferred to settle ([deferShrink]) when a resize animation is
-   * about to run — growing applies immediately so content is laid out before
-   * the sheet reveals it.
    */
-  private fun updateStateDimensions(deferShrink: Boolean = false) {
+  private fun updateStateDimensions() {
     if (detents.isEmpty()) return
 
     val targetIndex = (if (pendingDetentIndex >= 0) pendingDetentIndex else currentDetentIndex)
@@ -1302,21 +1525,21 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val newHeight = minOf(detentCalculator.getDetentHeight(detents[targetIndex]), maxAvailableHeight)
     val newWidth = getStateWidth()
 
-    if (deferShrink && newWidth == lastStateWidth && newHeight < lastStateHeight) return
-
     setStateDimensions(newWidth, newHeight)
   }
 
   /**
-   * Tracks the sheet's visible height during drag (and the post-release settle
-   * animation) so the container resizes with the finger, like iOS. Clamped to the
+   * Tracks the sheet's visible height during drags and resize animations. Clamped to the
    * smallest detent — dragging below it slides the sheet out without resizing.
    */
-  private fun updateStateDimensionsForDrag(sheetTop: Int) {
+  private fun updateStateDimensionsForPosition(sheetTop: Int) {
     if (detents.isEmpty()) return
 
     val maxAvailableHeight = realScreenHeight - topInset
-    val minHeight = minOf(detentCalculator.getDetentHeight(detents.first()), maxAvailableHeight)
+    val minHeight = minOf(
+      detentCalculator.getDetentHeight(detents.first(), includeKeyboard = !hasKeyboardFloor),
+      maxAvailableHeight
+    )
     val newHeight = detentCalculator.getVisibleSheetHeight(sheetTop).coerceIn(minHeight, maxAvailableHeight)
 
     setStateDimensions(getStateWidth(), newHeight)
@@ -1336,9 +1559,27 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     delegate?.viewControllerDidChangeSize(width, height)
   }
 
-  fun translateSheet(translationY: Int, onEnd: (() -> Unit)? = null) {
+  /**
+   * Realtime (non-animated) counterpart of TrueSheetStackManager.updateParentTranslation,
+   * driven by onSlide so the parent tracks this sheet's actual position.
+   */
+  private fun syncParentTranslation(sheetTop: Int) {
+    val parent = parentSheetView ?: return
+    val minSheetTop = detentCalculator.getSheetTopForDetentIndex(0)
+    parent.syncTranslationForChild(sheetTop, minSheetTop)
+  }
+
+  fun translateSheet(translationY: Int, animated: Boolean = true, onEnd: (() -> Unit)? = null) {
     val sheet = sheetView ?: return
 
+    if (!animated) {
+      sheet.animate().cancel()
+      sheet.translationY = translationY.toFloat()
+      emitChangePositionDelegate(sheet.top + translationY)
+      onEnd?.invoke()
+      return
+    }
+
     sheet.animate()
       .translationY(translationY.toFloat())
       .setDuration(TRANSLATE_ANIMATION_DURATION)
@@ -1385,41 +1626,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // MARK: - RootView Touch Handling
   // =============================================================================
 
-  override fun dispatchTouchEvent(event: MotionEvent): Boolean {
-    val footer = containerView?.footerView
-    val action = event.actionMasked
-
-    if (footer != null && footer.isShown) {
-      if (action == MotionEvent.ACTION_DOWN) {
-        val loc = ScreenUtils.getScreenLocation(footer)
-        val x = event.rawX.toInt()
-        val y = event.rawY.toInt()
-        footerOwnsTouchStream = x >= loc[0] &&
-          x <= loc[0] + footer.width &&
-          y >= loc[1] &&
-          y <= loc[1] + footer.height
-      }
-
-      if (footerOwnsTouchStream) {
-        val loc = ScreenUtils.getScreenLocation(footer)
-        val localEvent = MotionEvent.obtain(event)
-        localEvent.setLocation(event.rawX - loc[0], event.rawY - loc[1])
-        val handled = footer.dispatchTouchEvent(localEvent)
-        localEvent.recycle()
-
-        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
-          footerOwnsTouchStream = false
-        }
-        if (handled) return true
-      }
-    }
-
-    if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
-      footerOwnsTouchStream = false
-    }
-    return super.dispatchTouchEvent(event)
-  }
-
   override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
     eventDispatcher?.let {
       if (touchDeduper.shouldDispatch(event)) {