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

package/Package.swift

@@ -0,0 +1,87 @@
+// swift-tools-version: 6.0
+import PackageDescription
+
+// Header search paths for quoted cross-directory imports (SPM has no CocoaPods header maps).
+// Keep in sync when adding new ios/ subdirectories that contain headers.
+let headerSearchPaths: [String] = [
+    "ios",
+    "ios/bridging",
+    "ios/conversion",
+    "ios/helpers/container",
+    "ios/helpers/image",
+    "ios/helpers/scroll-view",
+    "ios/legacy",
+    "ios/legacy/events",
+    "ios/legacy/integrations",
+    "ios/legacy/utils",
+    "ios/modals/form-sheet",
+    "ios/modals/utils",
+    "ios/safe-area",
+    "ios/scroll-to-top-guard",
+    "ios/scroll-view-marker",
+    "ios/scroll-view-marker/conversion",
+    "ios/split",
+    "ios/split/conversion",
+    "ios/stack",
+    "ios/stack/conversion",
+    "ios/stack/header",
+    "ios/stack/host",
+    "ios/stack/screen",
+    "ios/tabs",
+    "ios/tabs/bottom-accessory",
+    "ios/tabs/conversion",
+    "ios/tabs/extensions",
+    "ios/tabs/host",
+    "ios/tabs/screen",
+    "ios/utils",
+    "ios/utils/extensions",
+    "common/cpp",
+    "cpp/legacy",
+]
+
+let cSettings: [CSetting] = headerSearchPaths.map { .headerSearchPath($0) }
+
+let cxxSettings: [CXXSetting] = [
+    .define("DEBUG", .when(configuration: .debug)),
+    .define("NDEBUG", .when(configuration: .release)),
+] + headerSearchPaths.map { .headerSearchPath($0) }
+
+let package = Package(
+    name: "RNScreens",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(name: "RNScreens", targets: ["RNScreens"]),
+    ],
+    dependencies: [
+        // Resolved from the autolinker symlink `<app>/ios/build/generated/autolinking/libs/RNScreens`,
+        // not from node_modules: `../../../../xcframeworks` -> `<app>/ios/build/xcframeworks`,
+        // `../../../ios` -> `<app>/ios/build/generated/ios`. Same layout `npx react-native spm scaffold` emits.
+        // Making this self-contained (remote RN package URL + shipping our own codegen output) is blocked
+        // on RN publishing a remote SPM package and would require `codegenConfig.includesGeneratedCode`, see:
+        // https://github.com/react/react-native/blob/v0.87.1/packages/react-native/scripts/spm/__docs__/spm-header-paths-contract.md#hand-authored-community-library-contract
+        .package(name: "ReactNative", path: "../../../../xcframeworks"),
+        .package(name: "React-GeneratedCode", path: "../../../ios"),
+    ],
+    targets: [
+        .target(
+            name: "RNScreens",
+            dependencies: [
+                .product(name: "ReactHeaders", package: "ReactNative"),
+                .product(name: "ReactNativeHeaders", package: "ReactNative"),
+                .product(name: "ReactNativeDependenciesHeaders", package: "ReactNative"),
+                .product(name: "ReactAppHeaders", package: "React-GeneratedCode"),
+            ],
+            path: ".",
+            exclude: ["ios/RNScreens.xcodeproj"],
+            sources: ["ios", "common/cpp", "cpp"],
+            publicHeadersPath: "ios",
+            cSettings: cSettings,
+            cxxSettings: cxxSettings,
+            linkerSettings: [
+                .linkedFramework("UIKit"),
+                .linkedFramework("Foundation"),
+            ]
+        ),
+    ],
+    cxxLanguageStandard: .cxx20
+)

package/README.md

@@ -254,13 +254,6 @@ There are many ways to contribute to this project. See [CONTRIBUTING](https://gi
 
 React native screens library is licensed under [The MIT License](LICENSE).
 
-## Credits
-
-This project has been built and is maintained thanks to the support from [Expo.io](https://expo.io) and [Software Mansion](https://swmansion.com).
-
-[![expo](https://avatars2.githubusercontent.com/u/12504344?v=3&s=100 'Expo.io')](https://expo.io)
-[![swm](https://logo.swmansion.com/logo?color=white&variant=desktop&width=150&tag=react-native-reanimated-github 'Software Mansion')](https://swmansion.com)
-
 ## React Native Screens is created by Software Mansion
 
 Since 2012 [Software Mansion](https://swmansion.com) is a software agency with experience in building web and mobile apps. We are Core React Native Contributors and experts in dealing with all kinds of React Native issues. We can help you build your next dream product – [Hire us](https://swmansion.com/contact/projects?utm_source=screens&utm_medium=readme).

package/android/src/main/cpp/NativeProxy.cpp

@@ -2,6 +2,7 @@
 #include <react/fabric/Binding.h>
 #include <react/renderer/scheduler/Scheduler.h>
 
+#include <memory>
 #include <string>
 
 #include "NativeProxy.h"
@@ -11,6 +12,19 @@ using namespace react;
 
 namespace rnscreens {
 
+namespace {
+// Keep this listener process-lifetime to avoid races during initialization,
+// when nativeAddMutationsListener() can be called concurrently from different
+// threads. A function-local static initializes thread-safely, and an immortal
+// instance suits core's delegate list, which is append-only. For more details:
+// https://github.com/software-mansion/react-native-screens/pull/4413
+const std::shared_ptr<RNSScreenRemovalListener> &removalListener() {
+  static const std::shared_ptr<RNSScreenRemovalListener> instance =
+      std::make_shared<RNSScreenRemovalListener>();
+  return instance;
+}
+} // namespace
+
 NativeProxy::NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis)
     : javaPart_(jni::make_global(jThis)) {}
 
@@ -32,13 +46,18 @@ void NativeProxy::nativeAddMutationsListener(
   auto uiManager =
       fabricUIManager->getBinding()->getScheduler()->getUIManager();
 
-  if (!screenRemovalListener_) {
-    screenRemovalListener_ =
-        std::make_shared<RNSScreenRemovalListener>([this](int tag) {
+  {
+    // Capture a copy of the global ref, never `this`: the listener outlives
+    // this NativeProxy, and the old live read of javaPart_ at call time raced
+    // invalidateNative(). installMutex_ keeps the copy from racing the
+    // invalidation write and keeps the stored token matching the last install.
+    std::lock_guard<std::mutex> lock(installMutex_);
+    removalListenerToken_ =
+        removalListener()->setListener([javaPart = javaPart_](int tag) {
           static const auto method =
-              javaPart_->getClass()->getMethod<void(jint)>(
+              javaPart->getClass()->getMethod<void(jint)>(
                   "notifyScreenRemoved");
-          method(javaPart_, tag);
+          method(javaPart, tag);
         });
   }
 
@@ -79,7 +98,7 @@ void NativeProxy::addMountingCoordinatorIfNeeded(
       });
 
   if (!wasRegistered) {
-    coordinator->setMountingOverrideDelegate(screenRemovalListener_);
+    coordinator->setMountingOverrideDelegate(removalListener());
     coordinatorsWithMountingOverrides_.push_back(coordinator);
   }
 }
@@ -90,6 +109,11 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
 }
 
 void NativeProxy::invalidateNative() {
+  // Disarm before the hybrid is collected; also releases the captured global
+  // ref so the Java NativeProxy stays collectable. Serialized with the install
+  // path so the token is never stale and javaPart_ is not nulled mid-capture.
+  std::lock_guard<std::mutex> lock(installMutex_);
+  removalListener()->clearListener(removalListenerToken_);
   javaPart_ = nullptr;
 }
 

package/android/src/main/cpp/NativeProxy.h

@@ -4,6 +4,7 @@
 #include <react/fabric/JFabricUIManager.h>
 #include "RNSScreenRemovalListener.h"
 
+#include <cstdint>
 #include <mutex>
 #include <string>
 
@@ -13,7 +14,6 @@ using namespace facebook::jni;
 
 class NativeProxy : public jni::HybridClass<NativeProxy> {
  public:
-  std::shared_ptr<RNSScreenRemovalListener> screenRemovalListener_;
   std::vector<std::weak_ptr<const facebook::react::MountingCoordinator>>
       coordinatorsWithMountingOverrides_;
   static auto constexpr kJavaDescriptor =
@@ -28,6 +28,12 @@ class NativeProxy : public jni::HybridClass<NativeProxy> {
 
   std::mutex coordinatorsMutex_;
 
+  // Serializes callback install (nativeAddMutationsListener) with
+  // invalidateNative: the install-time copy of javaPart_ must not race the
+  // invalidation write, and the stored token must match the last install.
+  std::mutex installMutex_;
+  uint64_t removalListenerToken_{0};
+
   explicit NativeProxy(jni::alias_ref<NativeProxy::javaobject> jThis);
 
   void nativeAddMutationsListener(

package/android/src/main/java/com/swmansion/rnscreens/common/container/Container.kt

@@ -9,4 +9,12 @@ interface Container {
      * (if any).
      */
     fun resolveCurrentContentScrollView(): ViewGroup?
+
+    /**
+     * Asked when this container's whole subtree is about to be natively dismissed,
+     * e.g. the screen hosting this container is popped. Returns the item that
+     * vetoes the dismissal via `preventNativeDismiss`, or null when nothing
+     * in the subtree does.
+     */
+    fun wantsToPreventStackNativeDismiss(): ContainerItem?
 }

package/android/src/main/java/com/swmansion/rnscreens/common/container/ContainerItem.kt

@@ -2,7 +2,7 @@ package com.swmansion.rnscreens.common.container
 
 import android.view.ViewGroup
 
-internal interface ContainerItem {
+interface ContainerItem {
     // region Nested Container handling
 
     /**
@@ -27,4 +27,16 @@ internal interface ContainerItem {
     fun findContentScrollView(): ViewGroup?
 
     // endregion
+
+    // region Native dismissal
+
+    /**
+     * Asked when this item (screen) is about to be natively dismissed together
+     * with its subtree. The nested container (if any) is consulted first; its
+     * non-null answer wins, otherwise the item answers for itself, returning
+     * itself when it vetoes the dismissal or null otherwise.
+     */
+    fun wantsToPreventStackNativeDismiss(): ContainerItem?
+
+    // endregion
 }

package/android/src/main/java/com/swmansion/rnscreens/common/text/ReactTextAppearance.kt

@@ -0,0 +1,62 @@
+package com.swmansion.rnscreens.common.text
+
+import android.content.res.AssetManager
+import android.graphics.Typeface
+import android.os.Build
+import com.facebook.react.common.ReactConstants
+import com.facebook.react.common.assets.ReactFontManager.TypefaceStyle
+import com.facebook.react.views.text.ReactTypefaceUtils
+import kotlin.properties.Delegates
+import kotlin.properties.ReadWriteProperty
+
+/**
+ * [TextAppearance] driven by React props. Font family, weight and style are kept as the raw
+ * React values and turned into a [Typeface]. [onChanged] is invoked whenever a property
+ * actually changes value.
+ */
+internal class ReactTextAppearance(
+    private val assets: AssetManager,
+    onChanged: () -> Unit,
+) : TextAppearance {
+    override var color: Int? by changeNotifying(onChanged)
+    override var fontSize: Float? by changeNotifying(onChanged)
+    internal var fontFamily: String? by changeNotifying(onChanged)
+    internal var fontWeight: String? by changeNotifying(onChanged)
+    internal var fontStyle: String? by changeNotifying(onChanged)
+
+    override fun resolveTypeface(base: Typeface): Typeface {
+        val weight = ReactTypefaceUtils.parseFontWeight(fontWeight)
+        val style = ReactTypefaceUtils.parseFontStyle(fontStyle)
+
+        if (fontFamily == null && weight == ReactConstants.UNSET && style == ReactConstants.UNSET) {
+            return base
+        }
+
+        // ReactFontManager.TypefaceStyle turns an unset weight into 400 and an unset style into
+        // "not italic" rather than deriving them from the base. This would drop default styling
+        // from base typeface. Resolve both up front so it never receives UNSET style or weight.
+        return ReactTypefaceUtils.applyStyles(
+            base,
+            if (style != ReactConstants.UNSET) style else base.resolveStyle(),
+            if (weight != ReactConstants.UNSET) weight else base.resolveWeight(),
+            fontFamily,
+            assets,
+        )
+    }
+}
+
+private fun <T> changeNotifying(onChanged: () -> Unit): ReadWriteProperty<Any?, T?> =
+    Delegates.observable(null) { _, old, new -> if (old != new) onChanged() }
+
+/**
+ * Numeric weight of this typeface. [Typeface.getWeight] requires API 28; below it only bold
+ * can be told apart from regular.
+ */
+private fun Typeface.resolveWeight(): Int =
+    when {
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.P -> weight
+        isBold -> TypefaceStyle.BOLD
+        else -> TypefaceStyle.NORMAL
+    }
+
+private fun Typeface.resolveStyle(): Int = if (isItalic) Typeface.ITALIC else Typeface.NORMAL

package/android/src/main/java/com/swmansion/rnscreens/common/text/TextAppearance.kt

@@ -0,0 +1,20 @@
+package com.swmansion.rnscreens.common.text
+
+import android.graphics.Typeface
+
+/**
+ * Provides text styling for some given part of the interface. Interface is React-agnostic. A `null`
+ * value means "keep the default".
+ */
+internal interface TextAppearance {
+    val color: Int?
+
+    /** Font size in SP. */
+    val fontSize: Float?
+
+    /**
+     * Returns the modified typeface based on [base] typeface. Properties that are not overridden
+     * are inherited from [base], which is returned unchanged when there are no overrides at all.
+     */
+    fun resolveTypeface(base: Typeface): Typeface
+}

package/android/src/main/java/com/swmansion/rnscreens/common/text/TextAppearanceDefaults.kt

@@ -0,0 +1,65 @@
+package com.swmansion.rnscreens.common.text
+
+import android.content.Context
+import android.graphics.Typeface
+import androidx.annotation.AttrRes
+import com.swmansion.rnscreens.utils.resolveColorAttr
+import com.swmansion.rnscreens.utils.resolveStyleResAttr
+
+/**
+ * Default text styling of a single title/subtitle slot, resolved from the M3 type-scale
+ * style behind [textAppearanceAttr] and the color behind [textColorAttr].
+ *
+ * Resolved from the style rather than read back from the widget: Material resolves a slot's
+ * default typeface asynchronously, so until that lands the widget reports [Typeface.DEFAULT].
+ */
+internal class TextAppearanceDefaults(
+    val color: Int,
+    val textSizePx: Float,
+    val typeface: Typeface,
+) {
+    companion object {
+        fun resolve(
+            context: Context,
+            @AttrRes textAppearanceAttr: Int,
+            @AttrRes textColorAttr: Int,
+        ): TextAppearanceDefaults {
+            val appearanceRes = resolveStyleResAttr(context, textAppearanceAttr)
+            val attrs = context.obtainStyledAttributes(appearanceRes, APPEARANCE_ATTRS)
+            try {
+                val textSizePx = attrs.getDimension(IDX_TEXT_SIZE, 0f)
+                require(textSizePx > 0f) { "[RNScreens] Text appearance defines no text size." }
+
+                // android:fontFamily is either a font resource (@font/…, resolvable only
+                // asynchronously) or a family name. The M3 type scale always declares a family
+                // name (@string/m3_ref_typeface_* — "sans-serif" / "sans-serif-medium"),
+                // so we can unconditionally take the synchronous path (Material's own fallback and
+                // AppCompatTextHelper do the same).
+                val textStyle = attrs.getInt(IDX_TEXT_STYLE, Typeface.NORMAL)
+                val typeface =
+                    attrs.getString(IDX_FONT_FAMILY)?.let { Typeface.create(it, textStyle) }
+                        ?: Typeface.defaultFromStyle(textStyle)
+
+                return TextAppearanceDefaults(
+                    resolveColorAttr(context, textColorAttr),
+                    textSizePx,
+                    typeface,
+                )
+            } finally {
+                attrs.recycle()
+            }
+        }
+
+        // Framework attr ids are compile-time constants; the array must stay sorted
+        // ascending (obtainStyledAttributes requirement).
+        private val APPEARANCE_ATTRS =
+            intArrayOf(
+                android.R.attr.textSize,
+                android.R.attr.textStyle,
+                android.R.attr.fontFamily,
+            )
+        private const val IDX_TEXT_SIZE = 0
+        private const val IDX_TEXT_STYLE = 1
+        private const val IDX_FONT_FAMILY = 2
+    }
+}

package/android/src/main/java/com/swmansion/rnscreens/helpers/PropIconResolver.kt

@@ -1,6 +1,5 @@
 package com.swmansion.rnscreens.helpers
 
-import android.content.Context
 import android.graphics.drawable.Drawable
 
 /**
@@ -21,27 +20,28 @@ internal sealed interface IconResolution {
 
 /**
  * Stateful, latest-wins icon resolver for a single declaratively-driven icon slot — a `toolbarMenu`
- * prop menu item, or the back button — that is re-evaluated on every prop transaction. It
- * deduplicates unchanged sources ([IconResolution.Unchanged]) to avoid needless reloads/flicker,
- * and drops stale async results so a slow load cannot clobber a newer source.
+ * prop menu item, or the back button — that is re-evaluated on every source change. It deduplicates
+ * unchanged sources ([IconResolution.Unchanged]) to avoid needless reloads/flicker, and drops stale
+ * async results so a slow load cannot clobber a newer source.
+ *
+ * [load] must invoke its completion callback exactly once — synchronously or asynchronously,
+ * always on the main thread — with the loaded drawable, or `null` when the source resolves to
+ * no icon or fails to load (see e.g. [resolveImage]).
  */
-internal class PropIconResolver {
+internal class PropIconResolver(
+    private val load: (drawableIconResourceName: String?, imageIconUri: String?, onComplete: (Drawable?) -> Unit) -> Unit,
+) {
     private var lastDrawableName: String? = null
     private var lastImageUri: String? = null
     private var lastEmittedDrawableName: String? = null
     private var lastEmittedImageUri: String? = null
 
     /**
-     * Resolves an icon from a drawable resource name or an image uri.
-     *
-     * The result is delivered to [onResult] synchronously for drawable resources and empty sources,
-     * and asynchronously for image uris. For image uris, the callback is only invoked if the
-     * resolved uri is still the latest requested source (stale requests are dropped). On a failed
-     * image load the latest request still emits [IconResolution.Resolved] with a `null` drawable, so
-     * the icon is cleared rather than left stale.
+     * Resolves an icon from a drawable resource name or an image uri. The result is delivered
+     * to [onResult] only if the requested source is still the latest one (stale async results
+     * are dropped).
      */
     fun resolve(
-        context: Context,
         drawableIconResourceName: String?,
         imageIconUri: String?,
         onResult: (IconResolution) -> Unit,
@@ -56,16 +56,10 @@ internal class PropIconResolver {
         }
         lastEmittedDrawableName = drawableIconResourceName
         lastEmittedImageUri = imageIconUri
-        when {
-            drawableIconResourceName != null ->
-                onResult(IconResolution.Resolved(getSystemDrawableResource(context, drawableIconResourceName)))
-            imageIconUri != null ->
-                loadImage(context, imageIconUri) { drawable ->
-                    if (imageIconUri == lastImageUri && lastDrawableName == null) {
-                        onResult(IconResolution.Resolved(drawable))
-                    }
-                }
-            else -> onResult(IconResolution.Resolved(null))
+        load(drawableIconResourceName, imageIconUri) { drawable ->
+            if (drawableIconResourceName == lastDrawableName && imageIconUri == lastImageUri) {
+                onResult(IconResolution.Resolved(drawable))
+            }
         }
     }
 }

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

@@ -495,8 +495,10 @@ class Screen(
                     // It has a custom `getChildDrawingOrder` method which returns
                     // wrong index if we called `startViewTransition` on the views on new arch.
                     // We add a simple View to bump the number of children to make it work.
+                    // Appended, not inserted at `i`: a filler before the circle inflates the
+                    // index `onMeasure` caches for it, which then outlives the child it points at.
                     // TODO: find a better way to handle this scenario
-                    it.addView(View(context), i)
+                    it.addView(View(context))
                 } else {
                     child?.let { view -> it.startViewTransition(view) }
                 }

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

@@ -282,6 +282,8 @@ class ScreenStack(
                 screenWrappers
                     .asSequence()
                     .dropWhile { it !== visibleBottom } // ignore all screens beneath the visible bottom
+                    // dismissed screens are already removed above & preloaded ones must stay detached
+                    .filter { !dismissedWrappers.contains(it) && it.screen.activityState !== Screen.ActivityState.INACTIVE }
                     .forEach { wrapper ->
                         // TODO: It should be enough to dispatch this on commit action once.
                         transaction.add(id, wrapper.fragment).runOnCommit {

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

@@ -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)
         }