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

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

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

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

@@ -139,6 +139,9 @@ class TrueSheetDimView(private val reactContext: ThemedReactContext) :
 
   override fun onTouchEvent(event: MotionEvent): Boolean {
     if (blockGestures) {
+      if (event.actionMasked == MotionEvent.ACTION_DOWN) {
+        parent?.requestDisallowInterceptTouchEvent(true)
+      }
       // When dimmed, consume touch and trigger click on ACTION_UP
       if (event.action == MotionEvent.ACTION_UP) {
         performClick()

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

@@ -0,0 +1,137 @@
+package com.lodev09.truesheet.core
+
+import android.annotation.SuppressLint
+import android.view.MotionEvent
+import android.view.View
+import android.widget.FrameLayout
+import com.facebook.react.uimanager.JSPointerDispatcher
+import com.facebook.react.uimanager.JSTouchDispatcher
+import com.facebook.react.uimanager.RootView
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.TouchTargetHelper
+import com.facebook.react.uimanager.events.EventDispatcher
+import com.lodev09.truesheet.utils.TouchEventDeduper
+
+interface TrueSheetOverlayRootViewDelegate {
+  val eventDispatcher: EventDispatcher?
+  fun overlayRootViewDidChangeSize(width: Int, height: Int)
+}
+
+/**
+ * Window-level view hosting an overlay's children, attached to the activity's
+ * content view above the sheet coordinators.
+ *
+ * Implements RootView to dispatch touches to JS. Touches that miss every child
+ * fall through to the views beneath.
+ */
+@SuppressLint("ViewConstructor")
+class TrueSheetOverlayRootView(private val reactContext: ThemedReactContext) :
+  FrameLayout(reactContext),
+  RootView {
+
+  var delegate: TrueSheetOverlayRootViewDelegate? = null
+
+  private val eventDispatcher: EventDispatcher?
+    get() = delegate?.eventDispatcher
+
+  private val jsTouchDispatcher = JSTouchDispatcher(this)
+  private val jsPointerDispatcher = JSPointerDispatcher(this)
+  private val touchDeduper = TouchEventDeduper()
+
+  // Whether the current touch stream landed on a child
+  private var isHandlingStream = false
+
+  init {
+    layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+
+    // Draws and receives touches above the sheet coordinators regardless of add order
+    translationZ = OVERLAY_Z
+  }
+
+  // Children are positioned by Fabric — a FrameLayout pass would stretch them to match_parent
+  override fun onLayout(
+    changed: Boolean,
+    left: Int,
+    top: Int,
+    right: Int,
+    bottom: Int
+  ) {
+  }
+
+  override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+    super.onSizeChanged(w, h, oldw, oldh)
+    delegate?.overlayRootViewDidChangeSize(w, h)
+  }
+
+  override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+    if (ev.actionMasked == MotionEvent.ACTION_DOWN) {
+      // The path ends with this root, so a touch that misses every child resolves to it
+      val target = TouchTargetHelper
+        .findTargetPathAndCoordinatesForTouch(ev.x, ev.y, this, FloatArray(2))
+        .firstNotNullOfOrNull { it.getView() }
+      isHandlingStream = target != null && target !== this
+    }
+    if (!isHandlingStream) return false
+    return super.dispatchTouchEvent(ev)
+  }
+
+  // ==================== RootView Implementation ====================
+
+  override fun onInterceptTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, dispatcher, true)
+    }
+    return super.onInterceptTouchEvent(event)
+  }
+
+  override fun requestDisallowInterceptTouchEvent(disallowIntercept: Boolean) {
+    // Mirrors ReactSurfaceView: keep receiving onInterceptTouchEvent so
+    // jsTouchDispatcher sees the gesture end, but forward the request up the tree.
+    parent?.requestDisallowInterceptTouchEvent(disallowIntercept)
+  }
+
+  @SuppressLint("ClickableViewAccessibility")
+  override fun onTouchEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { dispatcher ->
+      if (touchDeduper.shouldDispatch(event)) {
+        jsTouchDispatcher.handleTouchEvent(event, dispatcher, reactContext)
+      }
+      jsPointerDispatcher.handleMotionEvent(event, dispatcher, false)
+    }
+    super.onTouchEvent(event)
+    return true
+  }
+
+  override fun onInterceptHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, true) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onHoverEvent(event: MotionEvent): Boolean {
+    eventDispatcher?.let { jsPointerDispatcher.handleMotionEvent(event, it, false) }
+    return super.onHoverEvent(event)
+  }
+
+  override fun onChildStartedNativeGesture(childView: View?, ev: MotionEvent) {
+    eventDispatcher?.let { dispatcher ->
+      jsTouchDispatcher.onChildStartedNativeGesture(ev, dispatcher)
+      jsPointerDispatcher.onChildStartedNativeGesture(childView, ev, dispatcher)
+    }
+  }
+
+  override fun onChildEndedNativeGesture(childView: View, ev: MotionEvent) {
+    eventDispatcher?.let { jsTouchDispatcher.onChildEndedNativeGesture(ev, it) }
+    jsPointerDispatcher.onChildEndedNativeGesture()
+  }
+
+  override fun handleException(t: Throwable) {
+    reactContext.reactApplicationContext.handleException(RuntimeException(t))
+  }
+
+  companion object {
+    private const val OVERLAY_Z = 1000f
+  }
+}

package/android/src/main/java/com/lodev09/truesheet/events/TrueSheetLifecycleEvents.kt

@@ -93,6 +93,21 @@ class DidDismissEvent(surfaceId: Int, viewId: Int) : Event<DidDismissEvent>(surf
   }
 }
 
+/**
+ * Fired when the user tries to dismiss a non-dismissible sheet
+ */
+class DismissAttemptEvent(surfaceId: Int, viewId: Int) : Event<DismissAttemptEvent>(surfaceId, viewId) {
+
+  override fun getEventName(): String = EVENT_NAME
+
+  override fun getEventData(): WritableMap = Arguments.createMap()
+
+  companion object {
+    const val EVENT_NAME = "topDismissAttempt"
+    const val REGISTRATION_NAME = "onDismissAttempt"
+  }
+}
+
 /**
  * Fired when the sheet visibility changes due to screen transitions
  */

package/android/src/main/java/com/lodev09/truesheet/utils/KeyboardUtils.kt

@@ -3,6 +3,7 @@ package com.lodev09.truesheet.utils
 import android.content.Context
 import android.os.Build
 import android.view.View
+import android.view.WindowInsets
 import android.view.inputmethod.InputMethodManager
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsAnimationCompat
@@ -19,7 +20,7 @@ object KeyboardUtils {
     return isKeyboardVisible(rootView)
   }
 
-  private fun isKeyboardVisible(view: View): Boolean {
+  fun isKeyboardVisible(view: View): Boolean {
     val insets = ViewCompat.getRootWindowInsets(view) ?: return false
     return insets.isVisible(WindowInsetsCompat.Type.ime())
   }
@@ -36,10 +37,22 @@ object KeyboardUtils {
    * Dismisses the soft keyboard with an optional callback when the animation completes.
    */
   fun dismiss(view: View, onComplete: (() -> Unit)?) {
+    if (!isKeyboardVisible(view)) {
+      onComplete?.invoke()
+      return
+    }
+
     val imm = view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
     val focusedView = view.rootView.findFocus()
 
-    if (focusedView == null || !isKeyboardVisible(view)) {
+    // A keyboard can stay up with nothing focused, e.g. a blur that lands after focus was restored,
+    // so hide it through the window instead of treating it as already hidden.
+    if (focusedView == null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        view.windowInsetsController?.hide(WindowInsets.Type.ime())
+      } else {
+        imm?.hideSoftInputFromWindow(view.windowToken, 0)
+      }
       onComplete?.invoke()
       return
     }

package/android/src/main/java/com/lodev09/truesheet/utils/ScreenUtils.kt

@@ -104,18 +104,6 @@ object ScreenUtils {
    */
   fun getScreenHeight(reactContext: ReactContext): Int = reactContext.resources.displayMetrics.heightPixels
 
-  /**
-   * Get the location of a view in screen coordinates
-   *
-   * @param view The view to get screen location for
-   * @return IntArray with [x, y] coordinates in screen space
-   */
-  fun getScreenLocation(view: View): IntArray {
-    val location = IntArray(2)
-    view.getLocationOnScreen(location)
-    return location
-  }
-
   /**
    * Returns true if the device is a phone in portrait orientation.
    */

package/android/src/main/java/com/lodev09/truesheet/utils/ViewUtils.kt

@@ -2,8 +2,10 @@ package com.lodev09.truesheet.utils
 
 import android.view.View
 import android.view.ViewGroup
+import android.view.ViewParent
 import android.widget.ScrollView
 import androidx.core.widget.NestedScrollView
+import com.facebook.react.uimanager.ThemedReactContext
 
 fun View.isDescendantOf(ancestor: View): Boolean {
   if (!isAttachedToWindow) return false
@@ -15,16 +17,26 @@ fun View.isDescendantOf(ancestor: View): Boolean {
   return false
 }
 
-fun ViewGroup.smoothScrollBy(dx: Int, dy: Int) {
-  when (this) {
-    is ScrollView -> smoothScrollBy(dx, dy)
-    is NestedScrollView -> smoothScrollBy(dx, dy)
-  }
-}
-
 fun ViewGroup.smoothScrollTo(x: Int, y: Int) {
   when (this) {
     is ScrollView -> smoothScrollTo(x, y)
     is NestedScrollView -> smoothScrollTo(x, y)
   }
 }
+
+/**
+ * The content view hosting this view — the activity's, or a Modal dialog's.
+ * Window-level views (sheet coordinators, overlays) attach here.
+ */
+fun View.findRootContainerView(reactContext: ThemedReactContext): ViewGroup? {
+  var current: ViewParent? = parent
+
+  while (current != null) {
+    if (current is ViewGroup && current.id == android.R.id.content) {
+      return current
+    }
+    current = current.parent
+  }
+
+  return reactContext.currentActivity?.findViewById(android.R.id.content)
+}

package/android/src/main/jni/TrueSheetSpec.h

@@ -5,6 +5,7 @@
 #include <jsi/jsi.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetFooterViewComponentDescriptor.h>
+#include <react/renderer/components/TrueSheetSpec/TrueSheetOverlayViewComponentDescriptor.h>
 #include <react/renderer/components/TrueSheetSpec/TrueSheetViewComponentDescriptor.h>
 
 namespace facebook {

package/common/cpp/react/renderer/components/TrueSheetSpec/TrueSheetContentViewComponentDescriptor.h

@@ -11,14 +11,6 @@ namespace facebook::react {
 class TrueSheetContentViewComponentDescriptor final
     : public ConcreteComponentDescriptor<TrueSheetContentViewShadowNode> {
   using ConcreteComponentDescriptor::ConcreteComponentDescriptor;
-
-  void adopt(ShadowNode &shadowNode) const override {
-    auto &concreteShadowNode =
-        static_cast<TrueSheetContentViewShadowNode &>(shadowNode);
-    concreteShadowNode.adjustLayoutWithState();
-
-    ConcreteComponentDescriptor::adopt(shadowNode);
-  }
 };
 
-} // namespace facebook::react
+}  // namespace facebook::react