@lodev09/react-native-true-sheet 3.1.0-beta.0 → 3.1.0-beta.10

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

@@ -61,15 +61,15 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   companion object {
     const val TAG_NAME = "TrueSheet"
 
+    private const val MAX_HALF_EXPANDED_RATIO = 0.999f
+
     private const val GRABBER_TAG = "TrueSheetGrabber"
     private const val DEFAULT_MAX_WIDTH = 640 // dp
     private const val DEFAULT_CORNER_RADIUS = 16 // dp
 
-    /**
-     * Gets the effective sheet height by subtracting headerHeight * 2.
-     * This is needed because both native layout and Yoga layout account for the header separately.
-     */
-    fun getEffectiveSheetHeight(sheetHeight: Int, headerHeight: Int): Int = sheetHeight - headerHeight * 2
+    // Animation durations from res/anim/true_sheet_slide_in.xml and true_sheet_slide_out.xml
+    private const val PRESENT_ANIMATION_DURATION = 200L
+    private const val DISMISS_ANIMATION_DURATION = 150L
   }
 
   // ====================================================================
@@ -119,6 +119,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private val resolvedDetentPositions = mutableListOf<Int>()
 
   private var isDragging = false
+  private var isDismissing = false
   private var isReconfiguring = false
   private var windowAnimation: Int = 0
   private var lastEmittedPositionPx: Int = -1
@@ -169,48 +170,26 @@ 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.
-   */
+  /** Navigation bar height, added to sheet height to match iOS behavior. */
   private val bottomInset: Int
     get() = ScreenUtils.getNavigationBarHeight(reactContext)
 
-  /**
-   * Edge-to-edge is enabled by default on API 36+, or when explicitly configured.
-   */
+  /** Edge-to-edge enabled by default on API 36+, or when explicitly configured. */
   private val edgeToEdgeEnabled: Boolean
     get() {
       val defaultEnabled = android.os.Build.VERSION.SDK_INT >= 36
       return BuildConfig.EDGE_TO_EDGE_ENABLED || dialog?.edgeToEdgeEnabled == true || defaultEnabled
     }
 
-  /**
-   * The top inset to apply when edge-to-edge is enabled but not full-screen.
-   * This prevents the sheet from going under the status bar.
-   */
+  /** Top inset when edge-to-edge is enabled but not full-screen. */
   private val sheetTopInset: Int
     get() = if (edgeToEdgeEnabled && !edgeToEdgeFullScreen) statusBarHeight else 0
 
-  // ====================================================================
-  // MARK: - Touch Dispatchers
-  // ====================================================================
-
-  /**
-   * Touch dispatchers are required for RootView to properly forward touch events to React Native.
-   */
   internal var eventDispatcher: EventDispatcher? = null
   private val jSTouchDispatcher = JSTouchDispatcher(this)
   private var jSPointerDispatcher: JSPointerDispatcher? = null
 
-  // ====================================================================
-  // MARK: - Modal Observer
-  // ====================================================================
-
-  /**
-   * Observes react-native-screens modal fragments to hide/show the sheet appropriately.
-   * This prevents the sheet from rendering on top of modals.
-   */
+  /** Hides/shows the sheet when RN Screens modals are presented/dismissed. */
   private var rnScreensObserver: RNScreensFragmentObserver? = null
 
   // ====================================================================
@@ -252,7 +231,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       behavior.isHideable = dismissible
       behavior.isDraggable = draggable
 
-      // Handle back press
       onBackPressedDispatcher.addCallback(object : androidx.activity.OnBackPressedCallback(true) {
         override fun handleOnBackPressed() {
           this@TrueSheetViewController.delegate?.viewControllerDidBackPress()
@@ -276,6 +254,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     dialog = null
     isDragging = false
+    isDismissing = false
     isPresented = false
     isDialogVisible = false
     lastEmittedPositionPx = -1
@@ -290,44 +269,38 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       setupGrabber()
 
       sheetContainer?.post {
+        val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
+        storeResolvedPosition(currentDetentIndex)
+        emitChangePositionDelegate(positionPx, realtime = false)
+        positionFooter()
+      }
+
+      sheetContainer?.postDelayed({
         val detentInfo = getDetentInfoForIndex(currentDetentIndex)
         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()
+        delegate?.viewControllerDidFocus()
 
         presentPromise?.invoke()
         presentPromise = null
-
-        positionFooter()
-      }
+      }, PRESENT_ANIMATION_DURATION)
     }
 
     dialog.setOnCancelListener {
-      delegate?.viewControllerWillDismiss()
+      if (isDismissing) return@setOnCancelListener
 
-      // Notify parent sheet that it is about to regain focus
-      parentSheetView?.viewControllerWillFocus()
+      isDismissing = true
+      emitWillDismissEvents()
+      emitChangePositionDelegate(screenHeight, realtime = false)
     }
 
     dialog.setOnDismissListener {
-      val hadParent = parentSheetView != null
-
-      // Notify parent sheet that it has regained focus
-      parentSheetView?.viewControllerDidFocus()
-      parentSheetView = null
-
-      dismissPromise?.invoke()
-      dismissPromise = null
-      delegate?.viewControllerDidDismiss(hadParent)
-      cleanupDialog()
+      android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+        emitDidDismissEvents()
+        cleanupDialog()
+      }, DISMISS_ANIMATION_DURATION)
     }
   }
 
@@ -337,9 +310,8 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         override fun onSlide(sheetView: View, slideOffset: Float) {
           val behavior = behavior ?: return
           val positionPx = getCurrentPositionPx(sheetView)
-          val detentIndex = getDetentIndexForPosition(positionPx)
 
-          emitChangePositionDelegate(detentIndex, positionPx, realtime = true)
+          emitChangePositionDelegate(positionPx, realtime = true)
 
           when (behavior.state) {
             BottomSheetBehavior.STATE_DRAGGING,
@@ -353,7 +325,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
         override fun onStateChanged(sheetView: View, newState: Int) {
           if (newState == BottomSheetBehavior.STATE_HIDDEN) {
-            dismiss()
+            if (isDismissing) return
+            isDismissing = true
+            emitWillDismissEvents()
+            dialog.dismiss()
             return
           }
 
@@ -365,15 +340,12 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
             BottomSheetBehavior.STATE_EXPANDED,
             BottomSheetBehavior.STATE_COLLAPSED,
             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)
 
@@ -386,13 +358,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
                   }
 
                   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 if (detentInfo.index != currentDetentIndex) {
+                  val detent = getDetentValueForIndex(detentInfo.index)
+                  currentDetentIndex = detentInfo.index
+                  delegate?.viewControllerDidChangeDetent(detentInfo.index, detentInfo.position, detent)
                 }
               }
             }
@@ -407,14 +376,26 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   private fun setupModalObserver() {
     rnScreensObserver = RNScreensFragmentObserver(
       reactContext = reactContext,
+      onModalWillPresent = {
+        if (isPresented) {
+          delegate?.viewControllerWillBlur()
+        }
+      },
       onModalPresented = {
         if (isPresented) {
           hideDialog()
+          delegate?.viewControllerDidBlur()
+        }
+      },
+      onModalWillDismiss = {
+        if (isPresented) {
+          delegate?.viewControllerWillFocus()
         }
       },
       onModalDismissed = {
         if (isPresented) {
           showDialog()
+          delegate?.viewControllerDidFocus()
         }
       }
     )
@@ -426,59 +407,53 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     rnScreensObserver = null
   }
 
+  private fun emitWillDismissEvents() {
+    delegate?.viewControllerWillBlur()
+    delegate?.viewControllerWillDismiss()
+    parentSheetView?.viewControllerWillFocus()
+  }
+
+  private fun emitDidDismissEvents() {
+    val hadParent = parentSheetView != null
+    parentSheetView?.viewControllerDidFocus()
+    parentSheetView = null
+
+    delegate?.viewControllerDidBlur()
+    delegate?.viewControllerDidDismiss(hadParent)
+
+    dismissPromise?.invoke()
+    dismissPromise = 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.
-   */
+  /** Hides without dismissing. Used for sheet stacking and RN Screens modals. */
   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)
+    dialog?.window?.decorView?.visibility = INVISIBLE
   }
 
-  /**
-   * Shows a previously hidden dialog.
-   * Used when the sheet on top dismisses.
-   */
+  /** Shows a previously hidden dialog. */
   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)
+    dialog?.window?.decorView?.visibility = VISIBLE
   }
 
   // ====================================================================
@@ -494,8 +469,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     setupDimmedBackground(detentIndex)
 
     if (isPresented) {
-      // 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
@@ -506,10 +479,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       val detentInfo = getDetentInfoForIndex(detentIndex)
       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)
+      delegate?.viewControllerWillFocus()
 
       if (!animated) {
         dialog.window?.setWindowAnimations(0)
@@ -519,11 +491,20 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
   }
 
-  fun dismiss() {
+  fun dismiss(animated: Boolean = true) {
+    if (isDismissing) return
+
+    isDismissing = true
+    emitWillDismissEvents()
+
     this.post {
-      // Emit off-screen position (detent = 0 since sheet is fully hidden)
-      emitChangePositionDelegate(currentDetentIndex, screenHeight, realtime = false)
+      emitChangePositionDelegate(screenHeight, realtime = false)
     }
+
+    if (!animated) {
+      dialog?.window?.setWindowAnimations(0)
+    }
+
     dialog?.dismiss()
   }
 
@@ -534,13 +515,11 @@ 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])
@@ -548,39 +527,48 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       }
     }
 
-    // Flag to prevent state change callbacks from updating detent index during reconfiguration
     isReconfiguring = true
 
     behavior.apply {
-      skipCollapsed = false
       isFitToContents = false
       maxWidth = DEFAULT_MAX_WIDTH.dpToPx().toInt()
 
+      val oldExpandOffset = expandedOffset
+
       when (detents.size) {
         1 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
+          halfExpandedRatio = minOf(peekHeight.toFloat() / screenHeight.toFloat(), MAX_HALF_EXPANDED_RATIO)
           expandedOffset = screenHeight - peekHeight
+          isFitToContents = expandedOffset == 0
         }
 
         2 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
+          halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), MAX_HALF_EXPANDED_RATIO)
           expandedOffset = screenHeight - getDetentHeight(detents[1])
+          isFitToContents = expandedOffset == 0
         }
 
         3 -> {
           setPeekHeight(getDetentHeight(detents[0]), isPresented)
-          halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), 1.0f)
+          halfExpandedRatio = minOf(getDetentHeight(detents[1]).toFloat() / screenHeight.toFloat(), MAX_HALF_EXPANDED_RATIO)
           expandedOffset = screenHeight - getDetentHeight(detents[2])
         }
       }
-    }
 
-    // Re-apply current state to update position after config changes
-    if (isPresented) {
-      setStateForDetentIndex(currentDetentIndex)
-    }
+      if (oldExpandOffset != expandedOffset || expandedOffset == 0) {
+        val offset = if (expandedOffset == 0) statusBarHeight else 0
+        val newHeight = screenHeight - expandedOffset - offset
+        delegate?.viewControllerDidChangeSize(width, newHeight)
+      }
 
-    isReconfiguring = false
+      if (isPresented) {
+        setStateForDetentIndex(currentDetentIndex)
+      }
+
+      isReconfiguring = false
+    }
   }
 
   fun setupGrabber() {
@@ -612,10 +600,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     bottomSheet.clipToOutline = true
   }
 
-  /**
-   * Configures the dimmed background based on the current detent index.
-   * When not dimmed, touch events pass through to the activity behind the sheet.
-   */
+  /** Configures dim and touch-through behavior based on detent index. */
   fun setupDimmedBackground(detentIndex: Int) {
     val dialog = this.dialog ?: return
     dialog.window?.apply {
@@ -624,9 +609,9 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
       if (dimmed && detentIndex >= dimmedDetentIndex) {
         view.setOnTouchListener(null)
         setFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND, WindowManager.LayoutParams.FLAG_DIM_BEHIND)
+        setDimAmount(0.32f) // M3 scrim opacity
         dialog.setCanceledOnTouchOutside(dismissible)
       } else {
-        // Forward touch events to the activity when not dimmed
         view.setOnTouchListener { v, event ->
           event.setLocation(event.rawX - v.x, event.rawY - v.y)
           reactContext.currentActivity?.dispatchTouchEvent(event)
@@ -642,11 +627,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     dialog?.window?.setWindowAnimations(windowAnimation)
   }
 
-  /**
-   * Positions the footer view at the bottom of the sheet.
-   * The footer stays fixed at the bottom edge of the visible sheet area,
-   * adjusting during drag gestures via slideOffset.
-   */
+  /** Positions footer at bottom of sheet, adjusting during drag via slideOffset. */
   fun positionFooter(slideOffset: Float? = null) {
     val footerView = containerView?.footerView ?: return
     val bottomSheet = bottomSheetView ?: return
@@ -656,13 +637,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
     var footerY = (screenHeight - bottomSheetY - footerHeight).toFloat()
 
-    // Animate footer down with sheet when below peek height
     if (slideOffset != null && slideOffset < 0) {
       footerY -= (footerHeight * slideOffset)
     }
 
-    // Clamp footer position to prevent it from going off screen when positioning at the top
-    // This happens when fullScreen is enabled in edge-to-edge mode
     val maxAllowedY = (screenHeight - statusBarHeight - footerHeight).toFloat()
     footerView.y = minOf(footerY, maxAllowedY)
   }
@@ -690,16 +668,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   }
 
   // ====================================================================
-  // MARK: - Position Change Delegate
+  // MARK: - Position & Drag Handling
   // ====================================================================
 
-  /**
-   * 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) {
+  private fun emitChangePositionDelegate(positionPx: Int, realtime: Boolean) {
     if (positionPx == lastEmittedPositionPx) return
 
     lastEmittedPositionPx = positionPx
@@ -709,11 +681,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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
@@ -722,24 +689,16 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
   }
 
-  /**
-   * 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
@@ -748,11 +707,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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.
-   */
+  /** Returns (fromIndex, toIndex, progress) for interpolation, or null if < 2 detents. */
   private fun findSegmentForPosition(positionPx: Int): Triple<Int, Int, Float>? {
     val count = resolvedDetentPositions.size
     if (count < 2) return null
@@ -760,24 +715,21 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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
+      return Triple(-1, 0, progress)
     }
 
-    // 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) {
+      if (positionPx in nextPos..pos) {
         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)))
@@ -787,10 +739,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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).
-   */
+  /** Returns continuous index (e.g., 0.5 = halfway between detent 0 and 1). */
   private fun getInterpolatedIndexForPosition(positionPx: Int): Float {
     val count = resolvedDetentPositions.size
     if (count == 0) return -1f
@@ -799,16 +748,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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.
-   */
+  /** Returns interpolated screen fraction for position. */
   private fun getInterpolatedDetentForPosition(positionPx: Int): Float {
     val count = resolvedDetentPositions.size
     if (count == 0) return 0f
@@ -816,7 +760,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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))
@@ -827,11 +770,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     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.
-   */
+  /** Returns raw screen fraction for index (without bottomInset). */
   private fun getDetentValueForIndex(index: Int): Float {
     if (index < 0 || index >= detents.size) return 0f
     val value = detents[index]
@@ -842,10 +781,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     }
   }
 
-  // ====================================================================
-  // MARK: - Drag Handling
-  // ====================================================================
-
   private fun getCurrentDetentInfo(sheetView: View): DetentInfo {
     val screenY = ScreenUtils.getScreenY(sheetView)
     return DetentInfo(currentDetentIndex, screenY.pxToDp())
@@ -853,26 +788,6 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   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)
     val detent = getDetentValueForIndex(detentInfo.index)
@@ -893,14 +808,11 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
 
   private fun getDetentHeight(detent: Double): Int {
     val height: Int = if (detent == -1.0) {
-      // 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")
       }
-      // For fractional detents, add bottomInset to match iOS behavior
       (detent * screenHeight).toInt() + bottomInset
     }
 
@@ -980,7 +892,10 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
     super.onSizeChanged(w, h, oldw, oldh)
     if (w == oldw && h == oldh) return
 
-    delegate?.viewControllerDidChangeSize(w, h)
+    // Skip continuous size changes when fullScreen + edge-to-edge
+    if (h + statusBarHeight > screenHeight && isExpanded && oldw == w) {
+      return
+    }
 
     val oldScreenHeight = screenHeight
     screenHeight = ScreenUtils.getScreenHeight(reactContext, edgeToEdgeEnabled)
@@ -991,7 +906,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
         positionFooter()
         storeResolvedPosition(currentDetentIndex)
         val positionPx = bottomSheetView?.let { ScreenUtils.getScreenY(it) } ?: screenHeight
-        emitChangePositionDelegate(currentDetentIndex, positionPx, realtime = false)
+        emitChangePositionDelegate(positionPx, realtime = false)
       }
     }
   }
@@ -1004,11 +919,7 @@ class TrueSheetViewController(private val reactContext: ThemedReactContext) :
   // MARK: - Touch Event Handling
   // ====================================================================
 
-  /**
-   * Custom touch dispatch to handle footer touch events.
-   * The footer is positioned outside the normal view hierarchy, so we need to
-   * manually check if touches fall within its bounds and forward them.
-   */
+  /** Forwards touch events to footer which is positioned outside normal hierarchy. */
   override fun dispatchTouchEvent(event: MotionEvent): Boolean {
     val footer = containerView?.footerView
     if (footer != null && footer.isVisible) {