react-native-screens 5.0.0-alpha.1 → 5.0.0-alpha.3

package/android/src/main/java/com/swmansion/rnscreens/legacy/ScreenStackFragment.kt

@@ -85,6 +85,12 @@ class ScreenStackFragment :
 
     private var lastInsetsCompat: WindowInsetsCompat? = null
 
+    // Container reference is captured at registration, because `screen.container` is already
+    // null during teardown. Necessary for unregistering inset & layout listeners in `onDestroyView`.
+    private var containerWithSheetListeners: ScreenContainer? = null
+    private var containerOnLayoutChangeListener: View.OnLayoutChangeListener? = null
+    private var containerOnApplyWindowInsetsListener: View.OnApplyWindowInsetsListener? = null
+
     @SuppressLint("ValidFragment")
     constructor(screenView: Screen) : super(screenView)
 
@@ -337,6 +343,7 @@ class ScreenStackFragment :
         // - Screen.fragment
         lastActiveHeaderConfig?.clearActionBarIfOwned(activity as? AppCompatActivity)
         lastActiveHeaderConfig = null
+        detachInsetsAndLayoutListenersFromContainer()
         super.onDestroyView()
     }
 
@@ -522,15 +529,20 @@ class ScreenStackFragment :
     // Mark: Avoiding top inset by BottomSheet
 
     private fun attachInsetsAndLayoutListenersToBottomSheet(sheetTransitionCoordinator: BottomSheetTransitionCoordinator) {
-        screen.container?.apply {
+        screen.container?.let { container ->
+            containerWithSheetListeners = container
+
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-                setOnApplyWindowInsetsListener { _, insets ->
-                    val insetsCompat = WindowInsetsCompat.toWindowInsetsCompat(insets, this)
-                    handleInsetsUpdateAndNotifyTransition(
-                        insetsCompat,
-                    )
-                    insets
-                }
+                val insetsListener =
+                    View.OnApplyWindowInsetsListener { _, insets ->
+                        val insetsCompat = WindowInsetsCompat.toWindowInsetsCompat(insets, container)
+                        handleInsetsUpdateAndNotifyTransition(
+                            insetsCompat,
+                        )
+                        insets
+                    }
+                containerOnApplyWindowInsetsListener = insetsListener
+                container.setOnApplyWindowInsetsListener(insetsListener)
             } else {
                 val bottomSheetWindowInsetListenerChain = requireBottomSheetWindowInsetsListenerChain()
                 bottomSheetWindowInsetListenerChain.addListener { _, windowInsets ->
@@ -540,11 +552,28 @@ class ScreenStackFragment :
                     windowInsets
                 }
             }
+
+            val layoutChangeListener =
+                View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
+                    sheetTransitionCoordinator.onScreenContainerLayoutChanged(screen)
+                }
+            containerOnLayoutChangeListener = layoutChangeListener
+            container.addOnLayoutChangeListener(layoutChangeListener)
         }
+    }
 
-        screen.container?.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ ->
-            sheetTransitionCoordinator.onScreenContainerLayoutChanged(screen)
+    private fun detachInsetsAndLayoutListenersFromContainer() {
+        containerWithSheetListeners?.let { container ->
+            if (containerOnLayoutChangeListener != null) {
+                container.removeOnLayoutChangeListener(containerOnLayoutChangeListener)
+            }
+            if (containerOnApplyWindowInsetsListener != null) {
+                container.setOnApplyWindowInsetsListener(null)
+            }
         }
+        containerWithSheetListeners = null
+        containerOnLayoutChangeListener = null
+        containerOnApplyWindowInsetsListener = null
     }
 
     private fun handleInsetsUpdateAndNotifyTransition(insetsCompat: WindowInsetsCompat) {

package/android/src/main/java/com/swmansion/rnscreens/legacy/ScreenViewManager.kt

@@ -323,6 +323,11 @@ open class ScreenViewManager :
         value: Boolean,
     ) = Unit
 
+    override fun setIosOrientationInheritanceFixEnabled(
+        view: Screen?,
+        value: Boolean,
+    ) = Unit
+
     // END mark: iOS-only
 
     override fun setAndroidResetScreenShadowStateOnOrientationChangeEnabled(

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

@@ -1,4 +1,4 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.coordinator
 
 import android.os.Build
 import android.widget.FrameLayout
@@ -6,6 +6,7 @@ import androidx.core.view.doOnNextLayout
 import com.google.android.material.shape.CornerFamily
 import com.google.android.material.shape.MaterialShapeDrawable
 import com.google.android.material.shape.ShapeAppearanceModel
+import com.swmansion.rnscreens.modals.formsheet.native.model.FormSheetConfig
 import com.swmansion.rnscreens.utils.dpToPx
 
 internal class FormSheetAppearanceCoordinator(

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

@@ -1,8 +1,9 @@
-package com.swmansion.rnscreens.modals.formsheet
+package com.swmansion.rnscreens.modals.formsheet.native.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
 
 internal class FormSheetBehaviorController(
     private val sheetView: FrameLayout,
@@ -12,6 +13,7 @@ internal class FormSheetBehaviorController(
 
     private var currentDetentsCount: Int = 1
     private var lastEmittedDetentIndex: Int = FORM_SHEET_UNKNOWN_DETENT_INDEX
+    private var lastStableState: Int = BottomSheetBehavior.STATE_COLLAPSED
 
     private val bottomSheetCallback =
         object : BottomSheetBehavior.BottomSheetCallback() {
@@ -19,6 +21,8 @@ internal class FormSheetBehaviorController(
                 bottomSheet: View,
                 newState: Int,
             ) {
+                rememberStateIfStable(newState)
+
                 val index = mapStateToDetentIndex(newState)
                 if (index != FORM_SHEET_UNKNOWN_DETENT_INDEX && index != lastEmittedDetentIndex) {
                     lastEmittedDetentIndex = index
@@ -34,6 +38,7 @@ internal class FormSheetBehaviorController(
 
     init {
         behavior.isHideable = true
+        rememberStateIfStable(behavior.state)
     }
 
     internal fun setup() {
@@ -44,7 +49,29 @@ internal class FormSheetBehaviorController(
         behavior.removeBottomSheetCallback(bottomSheetCallback)
     }
 
+    internal fun restoreLastStableState() {
+        if (behavior.state != BottomSheetBehavior.STATE_HIDDEN) {
+            return
+        }
+
+        behavior.state = lastStableState
+    }
+
+    private fun rememberStateIfStable(state: Int) {
+        val isVisibleRestingState =
+            state == BottomSheetBehavior.STATE_EXPANDED ||
+                state == BottomSheetBehavior.STATE_COLLAPSED ||
+                state == BottomSheetBehavior.STATE_HALF_EXPANDED
+
+        if (isVisibleRestingState) {
+            lastStableState = state
+        }
+    }
+
     /**
+     * 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
@@ -53,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.
@@ -63,6 +94,7 @@ internal class FormSheetBehaviorController(
         sheetAvailableSpace: Int,
         contentHeightForFitToContents: Int = 0,
         nativeContainerPaddingBottom: Int = 0,
+        keyboardLift: Int = 0,
         initialDetentIndex: Int = 0,
         applyInitialDetent: Boolean = false,
     ) {
@@ -73,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(
@@ -96,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)
         }
@@ -131,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/modals/formsheet/native/coordinator/FormSheetDimensionsCoordinator.kt

@@ -0,0 +1,159 @@
+package com.swmansion.rnscreens.modals.formsheet.native.coordinator
+
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.swmansion.rnscreens.modals.formsheet.native.core.FormSheetAvailableHeightProvider
+import com.swmansion.rnscreens.modals.formsheet.native.core.FormSheetContainer
+import com.swmansion.rnscreens.modals.formsheet.native.core.FormSheetDialog
+import com.swmansion.rnscreens.modals.formsheet.native.interfaces.FormSheetContentSizeChangeDelegate
+import com.swmansion.rnscreens.modals.formsheet.native.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/modals/formsheet/native/coordinator/FormSheetKeyboardCoordinator.kt

@@ -0,0 +1,101 @@
+package com.swmansion.rnscreens.modals.formsheet.native.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/coordinator/FormSheetNativeDismissCoordinator.kt

@@ -0,0 +1,44 @@
+package com.swmansion.rnscreens.modals.formsheet.native.coordinator
+
+import androidx.activity.OnBackPressedCallback
+import com.swmansion.rnscreens.modals.formsheet.native.core.FormSheetDialog
+
+internal class FormSheetNativeDismissCoordinator(
+    private val dialog: FormSheetDialog,
+    private val behaviorController: FormSheetBehaviorController?,
+    private val onDismissAllowed: () -> Unit,
+    private val onDismissPrevented: () -> Unit,
+) : FormSheetDialog.CancelRequestInterceptor {
+    private val preventNativeDismissBackPressCallback =
+        object : OnBackPressedCallback(false) {
+            override fun handleOnBackPressed() {
+                handleCancelRequest()
+            }
+        }
+
+    internal var shouldPreventDismiss: Boolean = false
+        set(value) {
+            field = value
+            preventNativeDismissBackPressCallback.isEnabled = value
+        }
+
+    internal fun setup() {
+        dialog.cancelRequestInterceptor = this
+        dialog.onBackPressedDispatcher.addCallback(preventNativeDismissBackPressCallback)
+    }
+
+    internal fun destroy() {
+        dialog.cancelRequestInterceptor = null
+        preventNativeDismissBackPressCallback.remove()
+    }
+
+    override fun handleCancelRequest() {
+        if (shouldPreventDismiss) {
+            onDismissPrevented()
+            behaviorController?.restoreLastStableState()
+            return
+        }
+
+        onDismissAllowed()
+    }
+}

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

@@ -0,0 +1,44 @@
+package com.swmansion.rnscreens.modals.formsheet.native.core
+
+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/{FormSheetContainer.kt → native/core/FormSheetContainer.kt}

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