@lodev09/react-native-true-sheet 3.0.0-beta.8 → 3.0.0

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

@@ -2,17 +2,16 @@ package com.lodev09.truesheet
 
 import android.annotation.SuppressLint
 import android.graphics.Color
-import android.graphics.drawable.GradientDrawable
 import android.graphics.drawable.ShapeDrawable
 import android.graphics.drawable.shapes.RoundRectShape
 import android.util.TypedValue
-import android.view.Gravity
 import android.view.MotionEvent
 import android.view.View
 import android.view.WindowManager
 import android.view.accessibility.AccessibilityNodeInfo
 import android.widget.FrameLayout
 import androidx.core.view.isNotEmpty
+import androidx.core.view.isVisible
 import com.facebook.react.R
 import com.facebook.react.uimanager.JSPointerDispatcher
 import com.facebook.react.uimanager.JSTouchDispatcher
@@ -26,21 +25,26 @@ import com.facebook.react.views.view.ReactViewGroup
 import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.bottomsheet.BottomSheetDialog
 import com.lodev09.truesheet.core.RNScreensFragmentObserver
+import com.lodev09.truesheet.core.TrueSheetGrabberView
 import com.lodev09.truesheet.utils.ScreenUtils
 
 data class DetentInfo(val index: Int, val position: Float)
 
 interface TrueSheetViewControllerDelegate {
-  fun viewControllerWillPresent(index: Int, position: Float)
-  fun viewControllerDidPresent(index: Int, position: Float)
+  fun viewControllerWillPresent(index: Int, position: Float, detent: Float)
+  fun viewControllerDidPresent(index: Int, position: Float, detent: Float)
   fun viewControllerWillDismiss()
-  fun viewControllerDidDismiss()
-  fun viewControllerDidChangeDetent(index: Int, position: Float)
-  fun viewControllerDidDragBegin(index: Int, position: Float)
-  fun viewControllerDidDragChange(index: Int, position: Float)
-  fun viewControllerDidDragEnd(index: Int, position: Float)
-  fun viewControllerDidChangePosition(index: Int, position: Float, transitioning: Boolean)
+  fun viewControllerDidDismiss(hadParent: Boolean)
+  fun viewControllerDidChangeDetent(index: Int, position: Float, detent: Float)
+  fun viewControllerDidDragBegin(index: Int, position: Float, detent: Float)
+  fun viewControllerDidDragChange(index: Int, position: Float, detent: Float)
+  fun viewControllerDidDragEnd(index: Int, position: Float, detent: Float)
+  fun viewControllerDidChangePosition(index: Float, position: Float, detent: Float, realtime: Boolean)
   fun viewControllerDidChangeSize(width: Int, height: Int)
+  fun viewControllerWillFocus()
+  fun viewControllerDidFocus()
+  fun viewControllerWillBlur()
+  fun viewControllerDidBlur()
 }
 
 /**
@@ -58,10 +62,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     private const val GRABBER_TAG = "TrueSheetGrabber"
     private const val DEFAULT_MAX_WIDTH = 640 // dp
     private const val DEFAULT_CORNER_RADIUS = 16 // dp
-    private const val GRABBER_WIDTH = 32f // dp
-    private const val GRABBER_HEIGHT = 4f // dp
-    private const val GRABBER_TOP_MARGIN = 16f // dp
-    private val GRABBER_COLOR = Color.argb((0.4 * 255).toInt(), 73, 69, 79) // #49454F @ 40%
 
     /**
      * Gets the effective sheet height by subtracting headerHeight * 2.
@@ -107,15 +107,26 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   var isPresented = false
     private set
 
+  var isDialogVisible = false
+    private set
+
   var currentDetentIndex: Int = -1
     private set
 
+  // Resolved detent positions (Y coordinate when sheet rests at each detent)
+  private val resolvedDetentPositions = mutableListOf<Int>()
+
   private var isDragging = false
+  private var isReconfiguring = false
   private var windowAnimation: Int = 0
+  private var lastEmittedPositionPx: Int = -1
 
   var presentPromise: (() -> Unit)? = null
   var dismissPromise: (() -> Unit)? = null
 
+  // Reference to parent TrueSheetView (if presented from another sheet)
+  var parentSheetView: TrueSheetView? = null
+
   // ====================================================================
   // MARK: - Configuration Properties
   // ====================================================================
@@ -142,6 +153,12 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       }
     }
 
+  var draggable: Boolean = true
+    set(value) {
+      field = value
+      behavior?.isDraggable = value
+    }
+
   // ====================================================================
   // MARK: - Computed Properties
   // ====================================================================
@@ -149,6 +166,13 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   val statusBarHeight: Int
     get() = ScreenUtils.getStatusBarHeight(reactContext)
 
+  /**
+   * The bottom inset (navigation bar height) to add to sheet height.
+   * This matches iOS behavior where the system adds bottom safe area inset internally.
+   */
+  private val bottomInset: Int
+    get() = ScreenUtils.getNavigationBarHeight(reactContext)
+
   /**
    * Edge-to-edge is enabled by default on API 36+, or when explicitly configured.
    */
@@ -186,8 +210,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
    */
   private var rnScreensObserver: RNScreensFragmentObserver? = null
 
-  fun hasActiveModals(): Boolean = rnScreensObserver?.hasActiveModals() ?: false
-
   // ====================================================================
   // MARK: - Initialization
   // ====================================================================
@@ -208,7 +230,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     val style = if (edgeToEdgeEnabled) {
       com.lodev09.truesheet.R.style.TrueSheetEdgeToEdgeEnabledDialog
     } else {
-      0
+      com.lodev09.truesheet.R.style.TrueSheetDialog
     }
 
     dialog = BottomSheetDialog(reactContext, style).apply {
@@ -225,6 +247,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       setCanceledOnTouchOutside(dismissible)
       setCancelable(dismissible)
       behavior.isHideable = dismissible
+      behavior.isDraggable = draggable
     }
   }
 
@@ -241,19 +264,31 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     dialog = null
     isDragging = false
     isPresented = false
+    isDialogVisible = false
+    lastEmittedPositionPx = -1
   }
 
   private fun setupDialogListeners(dialog: BottomSheetDialog) {
     dialog.setOnShowListener {
       isPresented = true
+      isDialogVisible = true
       resetAnimation()
       setupBackground()
       setupGrabber()
 
       sheetContainer?.post {
         val detentInfo = getDetentInfoForIndex(currentDetentIndex)
-        delegate?.viewControllerDidPresent(detentInfo.index, detentInfo.position)
-        delegate?.viewControllerDidChangePosition(detentInfo.index, detentInfo.position, transitioning = true)
+        val detent = getDetentValueForIndex(detentInfo.index)
+        val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
+
+        delegate?.viewControllerDidPresent(detentInfo.index, detentInfo.position, detent)
+
+        // Store resolved position for initial detent
+        storeResolvedPosition(detentInfo.index)
+        emitChangePositionDelegate(detentInfo.index, positionPx, realtime = false)
+
+        // Notify parent sheet that it has lost focus (after this sheet appeared)
+        parentSheetView?.viewControllerDidBlur()
 
         presentPromise?.invoke()
         presentPromise = null
@@ -263,13 +298,22 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
 
     dialog.setOnCancelListener {
+      // Notify parent sheet that it is about to regain focus
+      parentSheetView?.viewControllerWillFocus()
+
       delegate?.viewControllerWillDismiss()
     }
 
     dialog.setOnDismissListener {
+      val hadParent = parentSheetView != null
+
+      // Notify parent sheet that it has regained focus
+      parentSheetView?.viewControllerDidFocus()
+      parentSheetView = null
+
       dismissPromise?.invoke()
       dismissPromise = null
-      delegate?.viewControllerDidDismiss()
+      delegate?.viewControllerDidDismiss(hadParent)
       cleanupDialog()
     }
   }
@@ -279,8 +323,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       object : BottomSheetBehavior.BottomSheetCallback() {
         override fun onSlide(sheetView: View, slideOffset: Float) {
           val behavior = behavior ?: return
-          val detentInfo = getCurrentDetentInfo(sheetView)
-          delegate?.viewControllerDidChangePosition(detentInfo.index, detentInfo.position, transitioning = false)
+          val positionPx = getCurrentPositionPx(sheetView)
+          val detentIndex = getDetentIndexForPosition(positionPx)
+
+          emitChangePositionDelegate(detentIndex, positionPx, realtime = true)
 
           when (behavior.state) {
             BottomSheetBehavior.STATE_DRAGGING,
@@ -305,7 +351,38 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
             BottomSheetBehavior.STATE_EXPANDED,
             BottomSheetBehavior.STATE_COLLAPSED,
-            BottomSheetBehavior.STATE_HALF_EXPANDED -> handleDragEnd(newState)
+            BottomSheetBehavior.STATE_HALF_EXPANDED -> {
+              // Ignore state changes triggered by content size reconfiguration
+              if (isReconfiguring) return
+
+              getDetentInfoForState(newState)?.let { detentInfo ->
+                // Store resolved position when sheet settles
+                storeResolvedPosition(detentInfo.index)
+
+                if (isDragging) {
+                  // Handle drag end
+                  val detent = getDetentValueForIndex(detentInfo.index)
+                  delegate?.viewControllerDidDragEnd(detentInfo.index, detentInfo.position, detent)
+
+                  if (detentInfo.index != currentDetentIndex) {
+                    presentPromise?.invoke()
+                    presentPromise = null
+                    currentDetentIndex = detentInfo.index
+                    setupDimmedBackground(detentInfo.index)
+                    delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+                  }
+
+                  isDragging = false
+                } else {
+                  // Handle programmatic resize - emit detent change after sheet settles
+                  if (detentInfo.index != currentDetentIndex) {
+                    val detent = getDetentValueForIndex(detentInfo.index)
+                    currentDetentIndex = detentInfo.index
+                    delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
+                  }
+                }
+              }
+            }
 
             else -> {}
           }
@@ -319,12 +396,12 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       reactContext = reactContext,
       onModalPresented = {
         if (isPresented) {
-          dialog?.window?.decorView?.visibility = View.INVISIBLE
+          hideDialog()
         }
       },
       onModalDismissed = {
         if (isPresented) {
-          dialog?.window?.decorView?.visibility = View.VISIBLE
+          showDialog()
         }
       }
     )
@@ -336,6 +413,61 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     rnScreensObserver = null
   }
 
+  // ====================================================================
+  // MARK: - Dialog Visibility (for stacking)
+  // ====================================================================
+
+  /**
+   * Returns true if the sheet's top is at or above the status bar.
+   */
+  val isExpanded: Boolean
+    get() {
+      val sheetTop = bottomSheetView?.top ?: return false
+      return sheetTop <= statusBarHeight
+    }
+
+  /**
+   * Returns the current top position of the sheet (Y coordinate from screen top).
+   * Used for comparing sheet positions during stacking.
+   */
+  val currentSheetTop: Int
+    get() = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
+
+  /**
+   * Returns the expected top position of the sheet when presented at the given detent index.
+   * Used for comparing sheet positions before presentation.
+   */
+  fun getExpectedSheetTop(detentIndex: Int): Int {
+    if (detentIndex < 0 || detentIndex >= detents.size) return screenHeight
+    val detentHeight = getDetentHeight(detents[detentIndex])
+    return screenHeight - detentHeight
+  }
+
+  /**
+   * Hides the dialog without dismissing it.
+   * Used when another TrueSheet presents on top or when RN screen is presented.
+   */
+  fun hideDialog() {
+    isDialogVisible = false
+    dialog?.window?.decorView?.visibility = View.INVISIBLE
+
+    // Emit off-screen position (detent = 0 since sheet is fully hidden)
+    emitChangePositionDelegate(currentDetentIndex, screenHeight, realtime = false)
+  }
+
+  /**
+   * Shows a previously hidden dialog.
+   * Used when the sheet on top dismisses.
+   */
+  fun showDialog() {
+    isDialogVisible = true
+    dialog?.window?.decorView?.visibility = View.VISIBLE
+
+    // Emit current position
+    val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
+    emitChangePositionDelegate(currentDetentIndex, positionPx, realtime = false)
+  }
+
   // ====================================================================
   // MARK: - Presentation
   // ====================================================================
@@ -346,20 +478,25 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       return
     }
 
-    currentDetentIndex = detentIndex
     setupDimmedBackground(detentIndex)
 
     if (isPresented) {
-      val detentInfo = getDetentInfoForIndex(detentIndex)
-      delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position)
+      // Detent change will be emitted when sheet settles in onStateChanged
+      // Don't update currentDetentIndex here - it will be updated when sheet settles
       setStateForDetentIndex(detentIndex)
     } else {
+      currentDetentIndex = detentIndex
       isDragging = false
       setupSheetDetents()
       setStateForDetentIndex(detentIndex)
 
       val detentInfo = getDetentInfoForIndex(detentIndex)
-      delegate?.viewControllerWillPresent(detentInfo.index, detentInfo.position)
+      val detent = getDetentValueForIndex(detentInfo.index)
+
+      // Notify parent sheet that it is about to lose focus (before this sheet appears)
+      parentSheetView?.viewControllerWillBlur()
+
+      delegate?.viewControllerWillPresent(detentInfo.index, detentInfo.position, detent)
 
       if (!animated) {
         dialog.window?.setWindowAnimations(0)
@@ -371,8 +508,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   fun dismiss() {
     this.post {
-      val offScreenPosition = screenHeight.pxToDp()
-      delegate?.viewControllerDidChangePosition(currentDetentIndex, offScreenPosition, transitioning = true)
+      // Emit off-screen position (detent = 0 since sheet is fully hidden)
+      emitChangePositionDelegate(currentDetentIndex, screenHeight, realtime = false)
     }
     dialog?.dismiss()
   }
@@ -384,39 +521,53 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   fun setupSheetDetents() {
     val behavior = this.behavior ?: return
 
+    // Reset resolved positions if detents count changed
+    if (resolvedDetentPositions.size != detents.size) {
+      resolvedDetentPositions.clear()
+      repeat(detents.size) { resolvedDetentPositions.add(0) }
+    }
+
+    // Always update auto detent positions based on current content height
+    for (i in detents.indices) {
+      if (detents[i] == -1.0) {
+        val detentHeight = getDetentHeight(detents[i])
+        resolvedDetentPositions[i] = screenHeight - detentHeight
+      }
+    }
+
+    // Flag to prevent state change callbacks from updating detent index during reconfiguration
+    isReconfiguring = true
+
     behavior.apply {
       skipCollapsed = false
-      isFitToContents = true
+      isFitToContents = false
       maxWidth = DEFAULT_MAX_WIDTH.dpToPx().toInt()
 
       when (detents.size) {
         1 -> {
-          maxHeight = getDetentHeight(detents[0])
-          skipCollapsed = true
+          setPeekHeight(getDetentHeight(detents[0]), isPresented)
+          expandedOffset = screenHeight - peekHeight
         }
 
         2 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
-          maxHeight = getDetentHeight(detents[1])
+          expandedOffset = screenHeight - getDetentHeight(detents[1])
         }
 
         3 -> {
-          isFitToContents = false
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
-          maxHeight = getDetentHeight(detents[2])
-          expandedOffset = sheetTopInset
           halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), 1.0f)
+          expandedOffset = screenHeight - getDetentHeight(detents[2])
         }
       }
+    }
 
-      if (isPresented) {
-        sheetContainer?.apply {
-          val params = layoutParams
-          params.height = maxHeight
-          layoutParams = params
-        }
-      }
+    // Re-apply current state to update position after config changes
+    if (isPresented) {
+      setStateForDetentIndex(currentDetentIndex)
     }
+
+    isReconfiguring = false
   }
 
   fun setupGrabber() {
@@ -426,23 +577,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       bottomSheet.removeView(it)
     }
 
-    if (!grabber) return
+    if (!grabber || !draggable) return
 
-    val grabberView = View(reactContext).apply {
+    val grabberView = TrueSheetGrabberView(reactContext).apply {
       tag = GRABBER_TAG
-      layoutParams = FrameLayout.LayoutParams(
-        GRABBER_WIDTH.dpToPx().toInt(),
-        GRABBER_HEIGHT.dpToPx().toInt()
-      ).apply {
-        gravity = Gravity.CENTER_HORIZONTAL or Gravity.TOP
-        topMargin = GRABBER_TOP_MARGIN.dpToPx().toInt()
-      }
-      background = GradientDrawable().apply {
-        shape = GradientDrawable.RECTANGLE
-        cornerRadius = (GRABBER_HEIGHT / 2).dpToPx()
-        setColor(GRABBER_COLOR)
-      }
-      elevation = 1f
     }
 
     bottomSheet.addView(grabberView)
@@ -538,6 +676,159 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
   }
 
+  // ====================================================================
+  // MARK: - Position Change Delegate
+  // ====================================================================
+
+  /**
+   * Emits position change to the delegate if the position has changed.
+   * @param index The current detent index (discrete, used as fallback)
+   * @param positionPx The current position in pixels (screen Y coordinate)
+   * @param realtime Whether the position is a real-time value (during drag or animation tracking)
+   */
+  private fun emitChangePositionDelegate(index: Int, positionPx: Int, realtime: Boolean) {
+    if (positionPx == lastEmittedPositionPx) return
+
+    lastEmittedPositionPx = positionPx
+    val position = positionPx.pxToDp()
+    val interpolatedIndex = getInterpolatedIndexForPosition(positionPx)
+    val detent = getInterpolatedDetentForPosition(positionPx)
+    delegate?.viewControllerDidChangePosition(interpolatedIndex, position, detent, realtime)
+  }
+
+  /**
+   * Stores the current Y position as the resolved position for the given detent index.
+   * This is called when the sheet settles at a detent to capture the actual position
+   * which may differ from the calculated position due to system adjustments.
+   */
+  private fun storeResolvedPosition(index: Int) {
+    if (index < 0 || index >= resolvedDetentPositions.size) return
+    val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: return
+    if (positionPx in 1..<screenHeight) {
+      resolvedDetentPositions[index] = positionPx
+    }
+  }
+
+  /**
+   * Stores the resolved position for the current detent.
+   * Called from TrueSheetView when content size changes.
+   */
+  fun storeCurrentResolvedPosition() {
+    storeResolvedPosition(currentDetentIndex)
+  }
+
+  /**
+   * Returns the estimated Y position for a detent index, using stored positions when available.
+   */
+  private fun getEstimatedPositionForIndex(index: Int): Int {
+    if (index < 0 || index >= resolvedDetentPositions.size) return screenHeight
+
+    val storedPos = resolvedDetentPositions[index]
+    if (storedPos > 0) return storedPos
+
+    // Estimate based on getDetentHeight which accounts for bottomInset and maxAllowedHeight
+    if (index < detents.size) {
+      val detentHeight = getDetentHeight(detents[index])
+      return screenHeight - detentHeight
+    }
+
+    return screenHeight
+  }
+
+  /**
+   * Finds the segment index and interpolation progress for a given position.
+   * Returns a Triple of (fromIndex, toIndex, progress) where progress is 0-1 within that segment.
+   * Returns null if position count is less than 2.
+   */
+  private fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
+    val count = resolvedDetentPositions.size
+    if (count < 2) return null
+
+    val firstPos = getEstimatedPositionForIndex(0)
+    val lastPos = getEstimatedPositionForIndex(count - 1)
+
+    // Below first detent
+    if (positionPx > firstPos) {
+      val range = screenHeight - firstPos
+      val progress = if (range > 0) (positionPx - firstPos).toFloat() / range else 0f
+      return Triple(-1, 0, progress) // Special index -1 for below first
+    }
+
+    // Above last detent
+    if (positionPx < lastPos) {
+      return Triple(count - 1, count - 1, 0f)
+    }
+
+    // Find segment (positions decrease as index increases)
+    for (i in 0 until count - 1) {
+      val pos = getEstimatedPositionForIndex(i)
+      val nextPos = getEstimatedPositionForIndex(i + 1)
+
+      if (positionPx <= pos && positionPx >= nextPos) {
+        val range = pos - nextPos
+        val progress = if (range > 0) (pos - positionPx).toFloat() / range else 0f
+        return Triple(i, i + 1, maxOf(0f, minOf(1f, progress)))
+      }
+    }
+
+    return Triple(count - 1, count - 1, 0f)
+  }
+
+  /**
+   * Calculates the interpolated index based on position.
+   * Returns a continuous value (e.g., 0.5 means halfway between detent 0 and 1).
+   */
+  private fun getInterpolatedIndexForPosition(positionPx: Int): Float {
+    val count = resolvedDetentPositions.size
+    if (count == 0) return -1f
+    if (count == 1) return 0f
+
+    val segment = findSegmentForPosition(positionPx) ?: return 0f
+    val (fromIndex, _, progress) = segment
+
+    // Below first detent
+    if (fromIndex == -1) return -progress
+
+    return fromIndex + progress
+  }
+
+  /**
+   * Calculates the interpolated detent value based on position.
+   * Returns the actual screen fraction, clamped to valid detent range.
+   */
+  private fun getInterpolatedDetentForPosition(positionPx: Int): Float {
+    val count = resolvedDetentPositions.size
+    if (count == 0) return 0f
+
+    val segment = findSegmentForPosition(positionPx) ?: return getDetentValueForIndex(0)
+    val (fromIndex, toIndex, progress) = segment
+
+    // Below first detent
+    if (fromIndex == -1) {
+      val firstDetent = getDetentValueForIndex(0)
+      return maxOf(0f, firstDetent * (1 - progress))
+    }
+
+    val fromDetent = getDetentValueForIndex(fromIndex)
+    val toDetent = getDetentValueForIndex(toIndex)
+    return fromDetent + progress * (toDetent - fromDetent)
+  }
+
+  /**
+   * Gets the detent value (fraction) for a given index.
+   * Returns the raw screen fraction without bottomInset for interpolation calculations.
+   * Note: bottomInset is only added in getDetentHeight() for actual sheet sizing.
+   */
+  private fun getDetentValueForIndex(index: Int): Float {
+    if (index < 0 || index >= detents.size) return 0f
+    val value = detents[index]
+    return if (value == -1.0) {
+      (contentHeight + headerHeight).toFloat() / screenHeight.toFloat()
+    } else {
+      value.toFloat()
+    }
+  }
+
   // ====================================================================
   // MARK: - Drag Handling
   // ====================================================================
@@ -547,36 +838,40 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     return DetentInfo(currentDetentIndex, screenY.pxToDp())
   }
 
+  private fun getCurrentPositionPx(sheetView: View): Int = ScreenUtils.getScreenY(sheetView)
+
+  /**
+   * Returns the detent index for the current position.
+   * Only reports a higher index when the sheet has reached that detent's height.
+   */
+  private fun getDetentIndexForPosition(positionPx: Int): Int {
+    if (detents.isEmpty()) return 0
+
+    val sheetHeight = screenHeight - positionPx
+
+    // Find the highest detent index that the sheet has reached
+    for (i in detents.indices.reversed()) {
+      val detentHeight = getDetentHeight(detents[i])
+      if (sheetHeight >= detentHeight) {
+        return i
+      }
+    }
+
+    return 0
+  }
+
   private fun handleDragBegin(sheetView: View) {
     val detentInfo = getCurrentDetentInfo(sheetView)
-    delegate?.viewControllerDidDragBegin(detentInfo.index, detentInfo.position)
+    val detent = getDetentValueForIndex(detentInfo.index)
+    delegate?.viewControllerDidDragBegin(detentInfo.index, detentInfo.position, detent)
     isDragging = true
   }
 
   private fun handleDragChange(sheetView: View) {
     if (!isDragging) return
     val detentInfo = getCurrentDetentInfo(sheetView)
-    delegate?.viewControllerDidDragChange(detentInfo.index, detentInfo.position)
-  }
-
-  private fun handleDragEnd(state: Int) {
-    if (!isDragging) return
-
-    val detentInfo = getDetentInfoForState(state)
-    detentInfo?.let {
-      delegate?.viewControllerDidDragEnd(it.index, it.position)
-
-      if (it.index != currentDetentIndex) {
-        presentPromise?.invoke()
-        presentPromise = null
-
-        currentDetentIndex = it.index
-        setupDimmedBackground(it.index)
-        delegate?.viewControllerDidChangeDetent(it.index, it.position)
-      }
-    }
-
-    isDragging = false
+    val detent = getDetentValueForIndex(detentInfo.index)
+    delegate?.viewControllerDidDragChange(detentInfo.index, detentInfo.position, detent)
   }
 
   // ====================================================================
@@ -585,12 +880,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   private fun getDetentHeight(detent: Double): Int {
     val height: Int = if (detent == -1.0) {
-      contentHeight + headerHeight
+      // For auto detent, add bottomInset to match iOS behavior where the system
+      // adds bottom safe area inset internally to the sheet height
+      contentHeight + headerHeight + bottomInset
     } else {
       if (detent <= 0.0 || detent > 1.0) {
         throw IllegalArgumentException("TrueSheet: detent fraction ($detent) must be between 0 and 1")
       }
-      (detent * screenHeight).toInt()
+      // For fractional detents, add bottomInset to match iOS behavior
+      (detent * screenHeight).toInt() + bottomInset
     }
 
     val maxAllowedHeight = screenHeight - sheetTopInset
@@ -669,7 +967,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     super.onSizeChanged(w, h, oldw, oldh)
     if (w == oldw && h == oldh) return
 
-    delegate?.viewControllerDidChangeSize(w, getEffectiveSheetHeight(h, headerHeight))
+    delegate?.viewControllerDidChangeSize(w, h)
 
     val oldScreenHeight = screenHeight
     screenHeight = ScreenUtils.getScreenHeight(reactContext, edgeToEdgeEnabled)
@@ -678,8 +976,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       setupSheetDetents()
       this.post {
         positionFooter()
-        val detentInfo = getDetentInfoForIndex(currentDetentIndex)
-        delegate?.viewControllerDidChangePosition(detentInfo.index, detentInfo.position, transitioning = true)
+        storeResolvedPosition(currentDetentIndex)
+        val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
+        emitChangePositionDelegate(currentDetentIndex, positionPx, realtime = false)
       }
     }
   }
@@ -699,7 +998,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
    */
   override fun dispatchTouchEvent(event: MotionEvent): Boolean {
     val footer = containerView?.footerView
-    if (footer != null && footer.visibility == View.VISIBLE) {
+    if (footer != null && footer.isVisible) {
       val footerLocation = ScreenUtils.getScreenLocation(footer)
       val touchScreenX = event.rawX.toInt()
       val touchScreenY = event.rawY.toInt()