react-native-screens 5.0.0-alpha.2 → 5.0.0-alpha.4

package/android/src/main/java/com/swmansion/rnscreens/{modals/formsheet/native → core/modals/formsheet}/coordinator/FormSheetBehaviorController.kt

@@ -1,9 +1,9 @@
-package com.swmansion.rnscreens.modals.formsheet.native.coordinator
+package com.swmansion.rnscreens.core.modals.formsheet.coordinator
 
 import android.view.View
 import android.widget.FrameLayout
 import com.google.android.material.bottomsheet.BottomSheetBehavior
-import com.swmansion.rnscreens.modals.formsheet.native.model.FormSheetDetents
+import com.swmansion.rnscreens.core.modals.formsheet.model.FormSheetDetents
 
 internal class FormSheetBehaviorController(
     private val sheetView: FrameLayout,
@@ -69,6 +69,9 @@ internal class FormSheetBehaviorController(
     }
 
     /**
+     * Expected to be called from the measure pass, before the sheet is measured (see
+     * `FormSheetAvailableHeightProvider`), so the metrics below are consumed by the ongoing traversal.
+     *
      * @param detents - parsed detents configuration.
      * @param sheetAvailableSpace - the full window height that detent fractions are measured against.
      * Using the full height lets a BottomSheet with large detent configured to slide
@@ -77,7 +80,11 @@ internal class FormSheetBehaviorController(
      * Used exclusively when the sheet is in `fitToContents` mode.
      * @param nativeContainerPaddingBottom - the bottom system inset. In `fitToContents` mode, this is added to the
      * BottomSheet's height to extend its background behind the system bars, while the inner content remains within
-     * the safe area.
+     * the safe area. For fractional detents it is subtracted from the collapsed peek height, which Material resolves
+     * above the inset, so the lowest detent lands at its fraction of [sheetAvailableSpace] like the other ones.
+     * @param keyboardLift - the part of the keyboard inset above [nativeContainerPaddingBottom]. Every resting position
+     * is extended by it so the sheet is pushed above the keyboard as far as [sheetAvailableSpace] allows,
+     * see [FormSheetDetents].
      * @param initialDetentIndex - the index of the detent the sheet should snap to while opening.
      * @param applyInitialDetent - whether the sheet should forcefully snap to the initial detent state.
      * This should typically be `true` only when the sheet transitions from closed to open.
@@ -87,6 +94,7 @@ internal class FormSheetBehaviorController(
         sheetAvailableSpace: Int,
         contentHeightForFitToContents: Int = 0,
         nativeContainerPaddingBottom: Int = 0,
+        keyboardLift: Int = 0,
         initialDetentIndex: Int = 0,
         applyInitialDetent: Boolean = false,
     ) {
@@ -97,22 +105,39 @@ internal class FormSheetBehaviorController(
         }
 
         if (detents.isFitToContents) {
-            configureFitToContents(detents, sheetAvailableSpace, contentHeightForFitToContents, nativeContainerPaddingBottom)
+            configureFitToContents(
+                detents,
+                sheetAvailableSpace,
+                contentHeightForFitToContents,
+                nativeContainerPaddingBottom,
+                keyboardLift,
+            )
         } else {
             when (detents.count) {
-                1 -> configureSingleDetent(detents, sheetAvailableSpace)
-                2 -> configureTwoDetents(detents, sheetAvailableSpace, initialDetentIndex, applyInitialDetent)
-                3 -> configureThreeDetents(detents, sheetAvailableSpace, initialDetentIndex, applyInitialDetent)
+                1 -> configureSingleDetent(detents, sheetAvailableSpace, keyboardLift)
+                2 ->
+                    configureTwoDetents(
+                        detents,
+                        sheetAvailableSpace,
+                        nativeContainerPaddingBottom,
+                        keyboardLift,
+                        initialDetentIndex,
+                        applyInitialDetent,
+                    )
+                3 ->
+                    configureThreeDetents(
+                        detents,
+                        sheetAvailableSpace,
+                        nativeContainerPaddingBottom,
+                        keyboardLift,
+                        initialDetentIndex,
+                        applyInitialDetent,
+                    )
                 else -> throw IllegalStateException(
                     "[RNScreens] Unsupported detent count ${detents.count}.",
                 )
             }
         }
-
-        // Metrics were mutated on an already-measured sheet; force a fresh layout
-        // pass so the behavior re-settles to the new detent instead of keeping its
-        // stale height.
-        sheetView.requestLayout()
     }
 
     private fun configureFitToContents(
@@ -120,33 +145,37 @@ internal class FormSheetBehaviorController(
         sheetAvailableSpace: Int,
         contentHeight: Int,
         bottomInset: Int,
+        keyboardLift: Int,
     ) = behavior.apply {
         skipCollapsed = true
         isFitToContents = true
-        maxHeight = detents.maxAllowedHeightForFitToContents(sheetAvailableSpace, contentHeight, bottomInset)
+        maxHeight = detents.maxAllowedHeightForFitToContents(sheetAvailableSpace, contentHeight, bottomInset, keyboardLift)
         state = BottomSheetBehavior.STATE_EXPANDED
     }
 
     private fun configureSingleDetent(
         detents: FormSheetDetents,
         sheetAvailableSpace: Int,
+        keyboardLift: Int,
     ) = behavior.apply {
         skipCollapsed = true
         isFitToContents = true
-        maxHeight = detents.maxAllowedHeight(sheetAvailableSpace)
+        maxHeight = detents.maxAllowedHeight(sheetAvailableSpace, keyboardLift)
         state = BottomSheetBehavior.STATE_EXPANDED
     }
 
     private fun configureTwoDetents(
         detents: FormSheetDetents,
         sheetAvailableSpace: Int,
+        bottomInset: Int,
+        keyboardLift: Int,
         initialDetentIndex: Int,
         applyInitialDetent: Boolean,
     ) = behavior.apply {
         skipCollapsed = false
         isFitToContents = true
-        peekHeight = detents.firstHeight(sheetAvailableSpace)
-        maxHeight = detents.maxAllowedHeight(sheetAvailableSpace)
+        peekHeight = detents.peekHeight(sheetAvailableSpace, bottomInset, keyboardLift)
+        maxHeight = detents.maxAllowedHeight(sheetAvailableSpace, keyboardLift)
         if (applyInitialDetent) {
             state = resolveStateFromIndex(initialDetentIndex, detents.count)
         }
@@ -155,15 +184,17 @@ internal class FormSheetBehaviorController(
     private fun configureThreeDetents(
         detents: FormSheetDetents,
         sheetAvailableSpace: Int,
+        bottomInset: Int,
+        keyboardLift: Int,
         initialDetentIndex: Int,
         applyInitialDetent: Boolean,
     ) = behavior.apply {
         skipCollapsed = false
         isFitToContents = false
-        peekHeight = detents.firstHeight(sheetAvailableSpace)
-        halfExpandedRatio = detents.halfExpandedRatio()
-        expandedOffset = detents.expandedOffsetFromTop(sheetAvailableSpace)
-        maxHeight = detents.maxAllowedHeight(sheetAvailableSpace)
+        peekHeight = detents.peekHeight(sheetAvailableSpace, bottomInset, keyboardLift)
+        halfExpandedRatio = detents.halfExpandedRatio(sheetAvailableSpace, keyboardLift)
+        expandedOffset = detents.expandedOffsetFromTop(sheetAvailableSpace, keyboardLift = keyboardLift)
+        maxHeight = detents.maxAllowedHeight(sheetAvailableSpace, keyboardLift)
         if (applyInitialDetent) {
             state = resolveStateFromIndex(initialDetentIndex, detents.count)
         }

package/android/src/main/java/com/swmansion/rnscreens/core/modals/formsheet/coordinator/FormSheetDimensionsCoordinator.kt

@@ -0,0 +1,159 @@
+package com.swmansion.rnscreens.core.modals.formsheet.coordinator
+
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.swmansion.rnscreens.core.modals.formsheet.dialog.FormSheetAvailableHeightProvider
+import com.swmansion.rnscreens.core.modals.formsheet.dialog.FormSheetContainer
+import com.swmansion.rnscreens.core.modals.formsheet.dialog.FormSheetDialog
+import com.swmansion.rnscreens.core.modals.formsheet.interfaces.FormSheetContentSizeChangeDelegate
+import com.swmansion.rnscreens.core.modals.formsheet.model.FormSheetDetents
+
+internal class FormSheetDimensionsCoordinator(
+    private val dialog: FormSheetDialog,
+    private val container: FormSheetContainer,
+    private val behaviorController: FormSheetBehaviorController?,
+) : FormSheetContentSizeChangeDelegate,
+    FormSheetAvailableHeightProvider.OnAvailableHeightMeasuredListener {
+    private var lastTopInset = 0
+    private var lastBottomInset = 0
+    private var lastImeInset = 0
+    private var currentDetents: FormSheetDetents? = null
+    private var currentInitialDetentIndex: Int = 0
+    private var shouldApplyInitialDetent: Boolean = false
+
+    private var currentContentHeight: Int = 0
+
+    // Height the metrics were last resolved against. Any other value reported by the measure pass
+    // means the window has been resized and metrics have to be recomputed.
+    private var resolvedAvailableSpace: Int = 0
+    private var isGeometryDirty: Boolean = false
+
+    internal fun setup() {
+        dialog.availableHeightProvider.availableHeightListener = this
+        setupWindowInsetsListener()
+    }
+
+    private fun setupWindowInsetsListener() {
+        ViewCompat.setOnApplyWindowInsetsListener(container) { _, insets ->
+            val topInset = getTopInset(insets)
+            val bottomInset = getBottomInset(insets)
+            val imeInset = getImeInset(insets)
+            if (topInset != lastTopInset || bottomInset != lastBottomInset || imeInset != lastImeInset) {
+                lastTopInset = topInset
+                lastBottomInset = bottomInset
+                lastImeInset = imeInset
+                invalidateGeometry()
+            }
+            insets
+        }
+    }
+
+    override fun onContentHeightChanged(newHeight: Int) {
+        if (currentContentHeight != newHeight) {
+            currentContentHeight = newHeight
+            invalidateGeometry()
+        }
+    }
+
+    internal fun updateFormSheetDimensions(
+        detents: FormSheetDetents?,
+        initialDetentIndex: Int = 0,
+        applyInitialDetent: Boolean = false,
+    ) {
+        currentDetents = detents
+        currentInitialDetentIndex = initialDetentIndex
+        shouldApplyInitialDetent = applyInitialDetent
+        invalidateGeometry()
+    }
+
+    // Schedules a measure pass; the metrics are resolved from there. The provider is a sibling of the sheet
+    // subtree, not an ancestor, so it has to be asked for a re-measure explicitly. No-op while the dialog
+    // is not shown - the first traversal after `show()` measures everything anyway.
+    private fun invalidateGeometry() {
+        isGeometryDirty = true
+        dialog.availableHeightProvider.requestLayout()
+        container.requestLayout()
+    }
+
+    override fun onAvailableHeightMeasured(height: Int) {
+        if (!isGeometryDirty && height == resolvedAvailableSpace) {
+            return
+        }
+        isGeometryDirty = false
+        resolvedAvailableSpace = height
+        resolveGeometry(height)
+    }
+
+    /**
+     * For Yoga we require the container height to be "stable" to avoid updating content size in flight.
+     * If left as MATCH_PARENT, BottomSheetDialog dynamically applies insets as padding when sheet overflows
+     * status bar or display cutout. This causes Yoga to recalculate the layout, resulting in UI flickering
+     * during the drag gesture. By calculating and enforcing a static height that explicitly subtracts
+     * the system insets, we completely bypass these redundant layout passes.
+     *
+     * Runs inside the measure pass of `FormSheetAvailableHeightProvider`, i.e. before Material's container, the sheet and
+     * our container are measured, so the values applied here are picked up by the very same traversal.
+     */
+    private fun resolveGeometry(sheetAvailableSpace: Int) {
+        currentDetents?.let { detents ->
+            behaviorController?.updateSheetBehavior(
+                detents = detents,
+                sheetAvailableSpace = sheetAvailableSpace,
+                contentHeightForFitToContents = currentContentHeight,
+                nativeContainerPaddingBottom = lastBottomInset,
+                keyboardLift = keyboardLift,
+                initialDetentIndex = currentInitialDetentIndex,
+                applyInitialDetent = shouldApplyInitialDetent,
+            )
+            shouldApplyInitialDetent = false
+        }
+
+        val sheetContainerHeight =
+            currentDetents?.sheetContainerHeight(
+                sheetAvailableSpace,
+                lastTopInset,
+                lastBottomInset,
+                currentContentHeight,
+                keyboardLift,
+            ) ?: (sheetAvailableSpace - lastTopInset - lastBottomInset - keyboardLift).coerceAtLeast(0)
+
+        val layoutParams =
+            container.layoutParams
+                ?: FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, sheetContainerHeight)
+
+        if (layoutParams.width != ViewGroup.LayoutParams.MATCH_PARENT || layoutParams.height != sheetContainerHeight) {
+            layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT
+            layoutParams.height = sheetContainerHeight
+            container.layoutParams = layoutParams
+        }
+    }
+
+    /**
+     * The part of the keyboard inset that sticks out above the bottom system inset. Material pads the sheet by
+     * the larger of the two, so this is exactly how much the sheet has to be extended to keep its detent-sized
+     * part above the keyboard.
+     */
+    private val keyboardLift: Int
+        get() = (lastImeInset - lastBottomInset).coerceAtLeast(0)
+
+    private fun getImeInset(insetsCompat: WindowInsetsCompat): Int = insetsCompat.getInsets(WindowInsetsCompat.Type.ime()).bottom
+
+    private fun getTopInset(insetsCompat: WindowInsetsCompat): Int =
+        insetsCompat
+            .getInsets(
+                WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout(),
+            ).top
+
+    private fun getBottomInset(insetsCompat: WindowInsetsCompat): Int =
+        insetsCompat
+            .getInsets(
+                WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout(),
+            ).bottom
+
+    internal fun destroy() {
+        dialog.availableHeightProvider.availableHeightListener = null
+        ViewCompat.setOnApplyWindowInsetsListener(container, null)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/core/modals/formsheet/coordinator/FormSheetKeyboardCoordinator.kt

@@ -0,0 +1,101 @@
+package com.swmansion.rnscreens.core.modals.formsheet.coordinator
+
+import android.widget.FrameLayout
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsAnimationCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.doOnLayout
+
+internal class FormSheetKeyboardCoordinator(
+    private val bottomSheetView: FrameLayout,
+) {
+    /**
+     * Whether the sheet should track the keyboard animation. Kept `false` while an enter / exit
+     * transition owns `translationY`. Tracking the keyboard (`true`) should be allowed only when
+     * the sheet is in PRESENTED state.
+     */
+    internal var isTrackingEnabled: Boolean = false
+
+    private val insetsAnimationCallback = KeyboardInsetsAnimationCallback()
+
+    internal fun setup() {
+        // BottomSheetBehavior registers an internal `WindowInsetsAnimationCallback` on the
+        // sheet view during its first `onLayoutChild`. That callback drives `translationY` to track
+        // animated inset changes, what interferes with our slide-in custom animation.
+        //
+        // We manage insets ourselves by setting a fixed height for FormSheetContainer, so we can
+        // clear the Material's callback to remove the conflict entirely.
+        //
+        // This method must run after the first layout pass.
+        bottomSheetView.doOnLayout {
+            ViewCompat.setWindowInsetsAnimationCallback(it, insetsAnimationCallback)
+        }
+    }
+
+    internal fun destroy() {
+        ViewCompat.setWindowInsetsAnimationCallback(bottomSheetView, null)
+    }
+
+    private inner class KeyboardInsetsAnimationCallback : WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_STOP) {
+        private var startTop = 0
+        private var startTranslationY = 0f
+
+        // Decided once per keyboard animation, in `onPrepare`. Tracking can't be picked up mid-animation
+        // because of no start position to translate from.
+        private var isTracking = false
+
+        private val isActive: Boolean
+            get() = isTracking && isTrackingEnabled
+
+        override fun onPrepare(animation: WindowInsetsAnimationCompat) {
+            if (!animation.isKeyboardAnimation() || !isTrackingEnabled) {
+                return
+            }
+
+            // Saving sheet's position before applying keyboard insets.
+            startTop = bottomSheetView.top
+            isTracking = true
+        }
+
+        override fun onStart(
+            animation: WindowInsetsAnimationCompat,
+            bounds: WindowInsetsAnimationCompat.BoundsCompat,
+        ): WindowInsetsAnimationCompat.BoundsCompat {
+            if (!animation.isKeyboardAnimation() || !isActive) {
+                return bounds
+            }
+
+            // The end sheet position is known - move the sheet and let the animation progress
+            // bring it to the new position.
+            startTranslationY = (startTop - bottomSheetView.top).toFloat()
+            bottomSheetView.translationY = startTranslationY
+            return bounds
+        }
+
+        override fun onProgress(
+            insets: WindowInsetsCompat,
+            runningAnimations: List<WindowInsetsAnimationCompat>,
+        ): WindowInsetsCompat {
+            if (!isActive) {
+                return insets
+            }
+
+            val keyboardAnimation = runningAnimations.firstOrNull { it.isKeyboardAnimation() } ?: return insets
+            bottomSheetView.translationY = startTranslationY * (1f - keyboardAnimation.interpolatedFraction)
+            return insets
+        }
+
+        override fun onEnd(animation: WindowInsetsAnimationCompat) {
+            if (!animation.isKeyboardAnimation()) {
+                return
+            }
+
+            if (isActive) {
+                bottomSheetView.translationY = 0f
+            }
+            isTracking = false
+        }
+
+        private fun WindowInsetsAnimationCompat.isKeyboardAnimation(): Boolean = typeMask and WindowInsetsCompat.Type.ime() != 0
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/{modals/formsheet/native → core/modals/formsheet}/coordinator/FormSheetNativeDismissCoordinator.kt

@@ -1,13 +1,11 @@
-package com.swmansion.rnscreens.modals.formsheet.native.coordinator
+package com.swmansion.rnscreens.core.modals.formsheet.coordinator
 
 import androidx.activity.OnBackPressedCallback
-import com.swmansion.rnscreens.modals.dimmingview.DimmingViewManager
-import com.swmansion.rnscreens.modals.formsheet.native.core.FormSheetDialog
+import com.swmansion.rnscreens.core.modals.formsheet.dialog.FormSheetDialog
 
 internal class FormSheetNativeDismissCoordinator(
     private val dialog: FormSheetDialog,
     private val behaviorController: FormSheetBehaviorController?,
-    private val dimmingManager: DimmingViewManager,
     private val onDismissAllowed: () -> Unit,
     private val onDismissPrevented: () -> Unit,
 ) : FormSheetDialog.CancelRequestInterceptor {
@@ -27,15 +25,11 @@ internal class FormSheetNativeDismissCoordinator(
     internal fun setup() {
         dialog.cancelRequestInterceptor = this
         dialog.onBackPressedDispatcher.addCallback(preventNativeDismissBackPressCallback)
-        // Backdrop taps go through `cancel()` rather than dismissing directly, so that they are
-        // subject to the very same interception as the back press and the swipe down.
-        dimmingManager.setOnBackdropClickListener { dialog.cancel() }
     }
 
     internal fun destroy() {
         dialog.cancelRequestInterceptor = null
         preventNativeDismissBackPressCallback.remove()
-        dimmingManager.setOnBackdropClickListener(null)
     }
 
     override fun handleCancelRequest() {

package/android/src/main/java/com/swmansion/rnscreens/core/modals/formsheet/dialog/FormSheetAvailableHeightProvider.kt

@@ -0,0 +1,44 @@
+package com.swmansion.rnscreens.core.modals.formsheet.dialog
+
+import android.content.Context
+import android.view.View
+
+/**
+ * View installed as the first child of the window's `android.R.id.content`, as a sibling
+ * of Material's dialog `container` - nothing in Material's hierarchy is moved.
+ *
+ * Every metric we hand to `BottomSheetBehavior` and the height of [FormSheetContainer] is derived from
+ * the height the sheet is measured against. The measure pass is the only point where that height is known
+ * *before* the sheet gets measured. `FrameLayout` measures its children in index order, so the provider reports
+ * the height right before Material's `container`, the coordinator and the sheet are measured in the same
+ * traversal, keeping those values in sync with window resizes, e.g. orientation change.
+ */
+internal class FormSheetAvailableHeightProvider(
+    context: Context,
+) : View(context) {
+    internal fun interface OnAvailableHeightMeasuredListener {
+        /**
+         * Invoked at the beginning of every measure pass with the height the sheet is about
+         * to be measured against.
+         */
+        fun onAvailableHeightMeasured(height: Int)
+    }
+
+    internal var availableHeightListener: OnAvailableHeightMeasuredListener? = null
+
+    init {
+        visibility = INVISIBLE
+        importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_NO
+    }
+
+    override fun onMeasure(
+        widthMeasureSpec: Int,
+        heightMeasureSpec: Int,
+    ) {
+        val height = MeasureSpec.getSize(heightMeasureSpec)
+        if (MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.UNSPECIFIED && height > 0) {
+            availableHeightListener?.onAvailableHeightMeasured(height)
+        }
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/{modals/formsheet/native/core → core/modals/formsheet/dialog}/FormSheetContainer.kt

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.modals.formsheet.native.core
+package com.swmansion.rnscreens.core.modals.formsheet.dialog
 
 import android.annotation.SuppressLint
 import android.content.Context

package/android/src/main/java/com/swmansion/rnscreens/{modals/formsheet/native/core → core/modals/formsheet/dialog}/FormSheetDialog.kt

@@ -1,7 +1,8 @@
-package com.swmansion.rnscreens.modals.formsheet.native.core
+package com.swmansion.rnscreens.core.modals.formsheet.dialog
 
 import android.content.Context
 import android.os.Bundle
+import android.util.Log
 import android.view.View
 import android.view.ViewGroup
 import android.view.Window
@@ -14,8 +15,8 @@ import com.google.android.material.bottomsheet.BottomSheetDialog
  * A custom BottomSheetDialog override used to render the FormSheet native component.
  *
  * We enforce edge-to-edge rendering, bypassing standard Material checks.
- * This enforcement is required because our custom dimming view must span the entire screen.
- * The FormSheetContainer is sized manually against the system insets.
+ * This is required because our custom dimming logic needs the Dialog to span
+ * the entire screen. The FormSheetContainer is sized manually against the system insets.
  */
 internal class FormSheetDialog(
     context: Context,
@@ -33,6 +34,12 @@ internal class FormSheetDialog(
 
     internal var cancelRequestInterceptor: CancelRequestInterceptor? = null
 
+    /**
+     * Installed next to Material's content once the dialog is created. Reports the height the sheet
+     * is measured against so the sheet metrics can be resolved before the sheet itself is measured.
+     */
+    internal val availableHeightProvider = FormSheetAvailableHeightProvider(context)
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
 
@@ -40,6 +47,7 @@ internal class FormSheetDialog(
         disableNativeWindowAnimation(window)
 
         setupBottomSheetHeight()
+        installAvailableHeightProvider()
     }
 
     override fun onAttachedToWindow() {
@@ -63,7 +71,8 @@ internal class FormSheetDialog(
      * `enableEdgeToEdge` attribute AND the navigation bar is translucent (see
      * `BottomSheetDialog#onAttachedToWindow`).
      *
-     * We force edge-to-edge on every API level so the custom dimming view covers the whole screen.
+     * We force edge-to-edge on every API level so the window content always spans the whole
+     * screen.
      */
     private fun forceEdgeToEdge() {
         val window = window ?: return
@@ -80,4 +89,27 @@ internal class FormSheetDialog(
         val bottomSheetView = findViewById<FrameLayout>(com.google.android.material.R.id.design_bottom_sheet)
         bottomSheetView?.layoutParams?.height = ViewGroup.LayoutParams.MATCH_PARENT
     }
+
+    private fun installAvailableHeightProvider() {
+        if (availableHeightProvider.parent != null) {
+            return
+        }
+
+        val contentParent = findViewById<ViewGroup>(android.R.id.content)
+        if (contentParent == null) {
+            Log.e(TAG, "[RNScreens] Window content view not found; the sheet dimensions won't be resolved.")
+            return
+        }
+
+        // FrameLayout measures its children in order, so the provider reports the height before Material's container
+        contentParent.addView(
+            availableHeightProvider,
+            0,
+            FrameLayout.LayoutParams(0, ViewGroup.LayoutParams.MATCH_PARENT),
+        )
+    }
+
+    companion object {
+        private const val TAG = "FormSheetDialog"
+    }
 }