@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.11

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/modal/ModalSheet.kt

@@ -4,6 +4,7 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.Color
 import android.graphics.Outline
+import android.os.SystemClock
 import android.view.GestureDetector
 import android.view.Gravity
 import android.view.MotionEvent
@@ -15,8 +16,10 @@ import android.view.ViewOutlineProvider
 import android.view.ViewTreeObserver
 import android.widget.FrameLayout
 import android.widget.ScrollView
+import androidx.activity.BackEventCompat
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.core.graphics.Insets
+import androidx.core.view.OneShotPreDrawListener
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import com.google.android.material.bottomsheet.BottomSheetBehavior
@@ -24,22 +27,34 @@ import com.google.android.material.bottomsheet.BottomSheetDragHandleView
 import dev.apexnative.navigation.options.SheetDetent
 import dev.apexnative.navigation.options.SheetOptions
 import dev.apexnative.navigation.utils.MaterialTheme
+import dev.apexnative.navigation.utils.SystemAnimations
 import dev.apexnative.navigation.utils.TestIds
 import dev.apexnative.navigation.utils.dp
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.IReactView
 import kotlin.math.roundToInt
 
 /**
- * A modal shown as a Material bottom sheet (`modal.sheet`): the modal's view in a container with a
- * [BottomSheetBehavior], in the modals' CoordinatorLayout, over a scrim. It stops at the detents of its options —
- * `medium` at half the height, `large` at the full height under the status bar, a number at that height in dp — and the
- * user drags it between them. A drag down past the smallest one closes it, unless `swipeToDismiss` is false: then the
- * sheet stays, and the try is told. The screen under it stays in place.
+ * A modal shown as a Material bottom sheet (`pageSheet`, `formSheet`, `popover`, or `modal.sheet` without a style): the
+ * modal's view in a container with a [BottomSheetBehavior], in the modals' CoordinatorLayout, over a scrim. It stops at
+ * the detents of its options — `medium` at half the height, `large` at the full height under the status bar, a number
+ * at that height in dp, `content` at the height of the shown screen's content — and the user drags it between them; at
+ * three of them at most, the Material behavior's resting states ([SheetStops]). The content is measured without a
+ * height limit, as on iOS ([IReactView.contentSize]), again after each of its mounts, and the stops follow it. In a
+ * window wider than [MAX_WIDTH_DP] it stands in the middle at that width. While the keyboard shows, the sheet stands
+ * on it at every stop, as on iOS, unless its screen keeps its size for it. A drag down past the smallest one closes
+ * it, unless `swipeToDismiss` is false: then the sheet stays, and the try is told. The screen under it stays in place.
+ * On Android 14+ the back gesture previews its hide ([SheetBack]): the Material behavior shrinks it with the progress
+ * and slides it down at the release.
  */
 internal class ModalSheet(
     private val layout: CoordinatorLayout,
     private val content: View,
     private val events: Events,
-) {
+    /** The content of the screen the modal shows now, which the `content` detent measures; none without one. */
+    private val shownContent: () -> IReactView?,
+    /** The screen the modal shows now moves its content out of the keyboard's way (`layout.adjustResize`). */
+    private val adjustsForKeyboard: () -> Boolean,
+) : SheetBack {
     interface Events {
         /** The user dragged the sheet to another detent. */
         fun onDetentChanged(detent: SheetDetent)
@@ -60,16 +75,75 @@ internal class ModalSheet(
     private var options = SheetOptions()
     private var swipeToDismiss = true
     private var detents: List<SheetDetent> = listOf(SheetDetent.Large)
+    // The detents the sheet rests at, from the lowest (`SheetStops.stops`): the behavior's states.
+    private var stops: List<SheetDetent> = listOf(SheetDetent.Large)
+    // The heights the behavior has for the stops, in pixels: lifted by the keyboard (`SheetStops.lifted`).
+    private var stopHeights: List<Int> = emptyList()
+    // The part of the keyboard over the navigation bar, in pixels; 0 without the keyboard.
+    private var keyboard = 0
+    // The stops' heights changed while the sheet moved (a drag, a slide): it takes them once it rests, and goes to the
+    // `selectedDetent` a merge named meanwhile ([pendingArrived]).
+    private var restopPending = false
+    // The sheet showed while its `content` detent had no height yet: once it has one, the sheet goes where the show
+    // would have taken it ([showTarget]), unless the user moved it first.
+    private var awaiting = false
+    private var pendingArrived: SheetDetent? = null
     private var selected: SheetDetent? = null
     private var topGap = 0
     private var dragged = false
     private var shown: (() -> Unit)? = null
     private var closing: (() -> Unit)? = null
+    // The back gesture whose preview runs now; none.
+    private var backPreview: BackPreview? = null
+    // Released: the behavior slides the sheet down from where the preview left it, and hides it at the end.
+    private var backFinishing = false
+    // The window's observer the scrim follows the preview's frames through, from its start until the sheet is back
+    // in place or gone; none otherwise.
+    private var backFramesObserver: ViewTreeObserver? = null
+
+    // The behavior tells no slide while back's preview scales the sheet and its release slides it down (they move it by
+    // its transform, not its offset): the scrim follows what is drawn, frame by frame, until the sheet stands again.
+    private val backFrames = ViewTreeObserver.OnPreDrawListener {
+        updateScrim()
+        if (backPreview == null && !backFinishing && container.scaleY == 1f && container.translationY == 0f) {
+            stopBackFrames()
+        }
+        true
+    }
+
+    private val sheetCallback = object : BottomSheetBehavior.BottomSheetCallback() {
+        override fun onStateChanged(sheet: View, newState: Int) = onState(newState)
+        override fun onSlide(sheet: View, slideOffset: Float) = updateScrim()
+    }
 
     // A list inside the sheet scrolls with it, as the Material behavior expects: up at half height the sheet goes up
     // first, down at the top of the list the sheet comes down. The behavior follows views that scroll nested.
     private val scrollViews = ViewTreeObserver.OnGlobalLayoutListener {
-        if (behavior.dragAnywhere) enableNestedScrolling(container)
+        turnScrollViews()
+        // The bars above the content may have taken their height.
+        if (followed != null) contentChanged()
+    }
+
+    // The shown screen's content that the `content` detent follows, its height without a height limit (pixels, none
+    // before it is measured), and the height of the detent the behavior has now.
+    private var followed: IReactView? = null
+    // The shown screen's content whose mounts turn the lists in it to scroll nested ([hearContent]).
+    private var heard: IReactView? = null
+    private var contentBody: Int? = null
+    private var appliedContentHeight: Int? = null
+    // When the content was measured last after a mount, and whether a measure waits ([contentMounted]).
+    private var lastMeasure = 0L
+    private var measureWaits = false
+    private val measureLater = Runnable {
+        measureWaits = false
+        lastMeasure = SystemClock.uptimeMillis()
+        measureContent()
+        contentChanged()
+    }
+
+    // The stops stand in pixels: they follow the layout's height (a rotation, a resize).
+    private val layoutHeight = View.OnLayoutChangeListener { _, _, top, _, bottom, _, oldTop, _, oldBottom ->
+        if (bottom - top != oldBottom - oldTop) container.post { restop() }
     }
 
     /** The sheet is down, out of sight: the modal can go at once. */
@@ -88,6 +162,26 @@ internal class ModalSheet(
             }
         })
         scrim.setOnTouchListener { _, event -> taps.onTouchEvent(event) }
+        // The keyboard covers the bottom of the window: the sheet stands on it, by the keyboard's part over the
+        // navigation bar (the detents count that bar already), unless the screen in it keeps its size for the keyboard
+        // (`layout.adjustResize: false`). The scrim, under the sheet, hears the window's insets.
+        ViewCompat.setOnApplyWindowInsetsListener(scrim) { _, insets ->
+            val ime = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+            val bar = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom
+            val lift = (ime - bar).coerceAtLeast(0)
+            if (lift != keyboard) {
+                keyboard = lift
+                restop()
+            }
+            insets
+        }
+        // The sheet keeps a touch that lands on it and no view in it takes (its bar, an empty part), as Material's
+        // BottomSheetDialog does: else the touch falls to the scrim under it, and a tap there closes a dimmed sheet;
+        // past an undimmed scrim it reaches the behavior, which takes the sheet into its drag state at the touch's
+        // down, before any move. The back gesture starts with such a touch, and a sheet in the drag state has no
+        // preview. A drag that starts there still moves the sheet: the behavior takes it past the touch slop, as from
+        // the views in it.
+        container.setOnTouchListener { _, _ -> true }
         container.clipToOutline = true
         container.outlineProvider = object : ViewOutlineProvider() {
             // The bottom corners are under the screen's bottom: only the top ones round.
@@ -96,74 +190,109 @@ internal class ModalSheet(
                 outline.setRoundRect(0, 0, view.width, view.height + radius.roundToInt(), radius)
             }
         }
-        // The sheet is under the status bar: its screens leave no room for it at their top.
+        // The sheet is under the status bar: its screens leave no room for it at their top. In the middle of a wide
+        // window it reaches no side, and keeps room only for the part of a side bar that is over it.
         ViewCompat.setOnApplyWindowInsetsListener(container) { _, insets ->
             val types = WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()
             val bars = insets.getInsets(types)
-            WindowInsetsCompat.Builder(insets).setInsets(types, Insets.of(bars.left, 0, bars.right, bars.bottom)).build()
+            val laidOut = container.width > 0
+            val left = if (laidOut) (bars.left - container.left).coerceAtLeast(0) else bars.left
+            val right = if (laidOut) (bars.right - (layout.width - container.right)).coerceAtLeast(0) else bars.right
+            WindowInsetsCompat.Builder(insets).setInsets(types, Insets.of(left, 0, right, bars.bottom)).build()
+        }
+        // Its sides move with the window's width (a rotation, a resize): the room for the side bars follows.
+        container.addOnLayoutChangeListener { _, left, _, right, _, oldLeft, _, oldRight, _ ->
+            if (left != oldLeft || right != oldRight) container.post { ViewCompat.requestApplyInsets(container) }
         }
         container.addView(content, FrameLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
         container.addView(grabber, FrameLayout.LayoutParams(WRAP_CONTENT, WRAP_CONTENT, Gravity.TOP or Gravity.CENTER_HORIZONTAL))
         behavior.isHideable = true
         behavior.state = BottomSheetBehavior.STATE_HIDDEN
         behavior.halfExpandedRatio = 0.5f
-        behavior.addBottomSheetCallback(object : BottomSheetBehavior.BottomSheetCallback() {
-            override fun onStateChanged(sheet: View, newState: Int) = onState(newState)
-            override fun onSlide(sheet: View, slideOffset: Float) = updateScrim()
-        })
+        behavior.addBottomSheetCallback(sheetCallback)
         container.viewTreeObserver.addOnGlobalLayoutListener(scrollViews)
     }
 
-    /** Slides the sheet up to its selected detent; [onShown] once it is there. */
-    fun show(sheetOptions: SheetOptions, swipeToDismiss: Boolean, onShown: () -> Unit) {
+    /**
+     * Slides the sheet up to its selected detent; [onShown] once it is there. Not [animated], or with the system's
+     * animations off ([SystemAnimations]), it stands there at once.
+     */
+    fun show(sheetOptions: SheetOptions, swipeToDismiss: Boolean, animated: Boolean, onShown: () -> Unit) {
         topGap = ViewCompat.getRootWindowInsets(layout)?.getInsets(WindowInsetsCompat.Type.systemBars())?.top ?: 0
         layout.addView(scrim, CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT))
         // As tall as its largest detent (maxHeight), not moved down by a margin: the behavior counts its states from
         // where the sheet is laid out.
-        layout.addView(container, CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT).also { it.behavior = behavior })
+        // In a wide window it stands in the middle, as wide as a Material modal sheet at most.
+        behavior.maxWidth = MAX_WIDTH_DP.dp
+        val params = CoordinatorLayout.LayoutParams(MATCH_PARENT, MATCH_PARENT)
+        params.gravity = Gravity.TOP or Gravity.CENTER_HORIZONTAL
+        params.behavior = behavior
+        layout.addView(container, params)
+        layout.addOnLayoutChangeListener(layoutHeight)
         shown = onShown
-        update(sheetOptions, swipeToDismiss, move = false)
+        update(sheetOptions, swipeToDismiss, merge = null)
+        selected = sheetOptions.selectedDetent?.takeIf { it in detents }
+        awaiting = SheetDetent.Content in detents && contentHeight() == null
+        if (!animated || SystemAnimations.areOff(context)) {
+            // The behavior lays the sheet out at the state it has before its first layout, with no slide, and tells
+            // no state then: the sheet stands at its detent once laid out.
+            behavior.state = stateOf(showTarget())
+            container.post { if (closing == null) onState(behavior.state) }
+            return
+        }
         // Laid out hidden first, so it slides up from the bottom.
-        container.post { if (closing == null) behavior.state = stateOf(selected ?: detents.first()) }
+        container.post { if (closing == null) behavior.state = stateOf(showTarget()) }
     }
 
-    /** New options from mergeOptions: the detents, the look, and the selected detent, which the sheet moves to. */
-    fun update(sheetOptions: SheetOptions, swipeToDismiss: Boolean, move: Boolean = true) {
-        val previous = selected
+    // The stop the show goes to: the selected one when it is a stop already, else the lowest.
+    private fun showTarget(): SheetDetent = selected?.takeIf { it in stops } ?: stops.first()
+
+    /**
+     * New resolved options: the detents and the look. The sheet moves only as [SheetStops] says, after a `mergeOptions`
+     * of [merge]; without one (the shown screen changed, the show) it stays where it is.
+     */
+    fun update(sheetOptions: SheetOptions, swipeToDismiss: Boolean, merge: SheetOptions?) {
+        // The stop it rests at, by the stops it has now: the new ones may give its state another detent.
+        val settled = detentOf(behavior.state)
         options = sheetOptions
         this.swipeToDismiss = swipeToDismiss
-        detents = sheetOptions.detents?.takeIf { it.isNotEmpty() }?.sortedBy { heightOf(it) } ?: listOf(SheetDetent.Large)
-        selected = sheetOptions.selectedDetent?.takeIf { it in detents }
+        detents = sheetOptions.detents?.takeIf { it.isNotEmpty() } ?: listOf(SheetDetent.Large)
         grabber.visibility = if (sheetOptions.grabber.isTrue) View.VISIBLE else View.GONE
         behavior.dragAnywhere = sheetOptions.expandsOnScroll.get(true)
         container.invalidateOutline()
-        configure()
-        if (!move || closing != null) return
-        val settled = detentOf(behavior.state)
-        if (settled != null) behavior.isHideable = swipeToDismiss && settled == detents.first()
-        val target = when {
-            selected != null && selected != previous -> selected
-            settled != null && settled !in detents -> selected ?: detents.first()
-            else -> null
-        }
-        if (target != null) behavior.state = stateOf(target)
-        updateScrim()
+        hearContent()
+        followContent()
+        restop(settled, merge?.selectedDetent)
     }
 
-    /** Slides the sheet down; [onClosed] once it is out of sight. */
-    fun close(onClosed: () -> Unit) {
+    /** Slides the sheet down; [onClosed] once it is out of sight. Not [animated], or with animations off, at once. */
+    fun close(animated: Boolean, onClosed: () -> Unit) {
         closing = onClosed
-        if (isClosed) {
+        if (isClosed || !animated || SystemAnimations.areOff(context)) {
+            stopBackPreview()
             finishClosing()
             return
         }
+        // Released by back, it goes down already: it is closed at the end of that slide.
+        if (backFinishing) return
+        stopBackPreview()
         behavior.isHideable = true
         behavior.state = BottomSheetBehavior.STATE_HIDDEN
     }
 
     /** Takes the sheet's views away; the modal's view is the caller's. */
     fun remove() {
+        // A slide down of back's release that ends after this tells nothing: the modal went already.
+        behavior.removeBottomSheetCallback(sheetCallback)
+        stopBackPreview()
+        stopBackFrames()
         container.viewTreeObserver.removeOnGlobalLayoutListener(scrollViews)
+        layout.removeOnLayoutChangeListener(layoutHeight)
+        followed?.setOnContentMounted(CONTENT_KEY, null)
+        followed = null
+        container.removeCallbacks(measureLater)
+        heard?.setOnContentMounted(SCROLL_KEY, null)
+        heard = null
         container.removeView(content)
         layout.removeView(container)
         layout.removeView(scrim)
@@ -176,58 +305,278 @@ internal class ModalSheet(
         TestIds.apply(scrim, testId?.let { "$it.scrim" })
     }
 
+    override val hidesOnBack: Boolean
+        get() = closing == null && !backFinishing && behavior.isHideable && container.isLaidOut &&
+            detentOf(behavior.state) != null
+
+    override fun startBackPreview(event: BackEventCompat): SheetBack.Gesture? {
+        if (!hidesOnBack || backPreview != null) return null
+        val preview = BackPreview()
+        backPreview = preview
+        startBackFrames()
+        behavior.startBackProgress(event)
+        return preview
+    }
+
+    // A command closed or moved the sheet, or it goes, while back's preview runs: the sheet grows back where it stands
+    // (the behavior's cancel), and the gesture's release does the usual back.
+    private fun stopBackPreview() {
+        if (backPreview == null) return
+        backPreview = null
+        behavior.cancelBackProgress()
+    }
+
+    private fun startBackFrames() {
+        if (backFramesObserver != null) return
+        backFramesObserver = container.viewTreeObserver.also { it.addOnPreDrawListener(backFrames) }
+    }
+
+    // The listener leaves the observer it joined: a container out of the window has another one.
+    private fun stopBackFrames() {
+        val observer = backFramesObserver ?: return
+        backFramesObserver = null
+        if (observer.isAlive) observer.removeOnPreDrawListener(backFrames)
+    }
+
+    /** The back gesture over this sheet: the Material behavior previews its hide (`MaterialBackHandler`). */
+    private inner class BackPreview : SheetBack.Gesture {
+        override val sheet: SheetBack
+            get() = this@ModalSheet
+
+        override fun progress(event: BackEventCompat) {
+            if (backPreview !== this) return
+            behavior.updateBackProgress(event)
+            updateScrim()
+        }
+
+        override fun cancel() {
+            if (backPreview === this) stopBackPreview()
+        }
+
+        // The behavior slides the sheet down from the preview and sets its hidden state at the end: `onState` closes
+        // it there as a drag down does (`onClosedByUser`), so the modal goes through the user's path once.
+        override fun commit(): Boolean {
+            if (backPreview !== this) return false
+            backPreview = null
+            if (!hidesOnBack) {
+                behavior.cancelBackProgress()
+                return false
+            }
+            backFinishing = true
+            behavior.handleBackInvoked()
+            return true
+        }
+    }
+
     private fun closeByUser() {
         if (!swipeToDismiss) {
             events.onCloseAttempted()
             return
         }
+        // With animations off the modal goes at once, and its close takes the sheet away with no slide.
+        if (SystemAnimations.areOff(context)) {
+            if (closing != null) return
+            closing = {}
+            return events.onClosedByUser()
+        }
         behavior.isHideable = true
         behavior.state = BottomSheetBehavior.STATE_HIDDEN
     }
 
-    // How the Material behavior stops at the detents: with half and full height both, at its three states (the
-    // smallest at the collapsed one); otherwise at the collapsed state (the smaller detent) and the expanded one, which
-    // is only as tall as the largest detent.
-    private fun configure() {
-        val height = detents.filterIsInstance<SheetDetent.Height>().firstOrNull()
-        val halfAndFull = SheetDetent.Medium in detents && SheetDetent.Large in detents
-        behavior.isFitToContents = !halfAndFull
-        behavior.expandedOffset = topGap
-        behavior.maxHeight = heightOf(detents.last())
-        val collapsed = if (halfAndFull) height else detents.takeIf { it.size > 1 }?.first()
-        behavior.skipCollapsed = collapsed == null
-        // Without a detent of its own the collapsed state is the smallest detent: a sheet that isn't hideable settles
-        // there, not at Material's peek height.
-        behavior.peekHeight = heightOf(collapsed ?: detents.first())
+    // The stops of the detents and how the Material behavior rests at them (`SheetStops.material`): at one or two it
+    // fits the sheet to its highest stop, at three it stops half expanded between them. The detent the options select
+    // stays the middle one when there are more.
+    // A new height of the sheet (`maxHeight`), of its collapsed state, or a change of the mode is laid out: the
+    // behavior measures the sheet and counts a fitted sheet's top in its layout. It says whether a layout comes.
+    private fun configure(): Boolean {
+        appliedContentHeight = contentHeight()
+        // A `content` detent not measured yet has no height: it stays out of the stops until it has one, or it would
+        // count as the full height and take the place of `large`.
+        val measured = detents.filter { it != SheetDetent.Content || contentHeight() != null }.ifEmpty { detents }
+        stops = SheetStops.stops(measured, ::heightOf, options.selectedDetent)
+        val lift = if (adjustsForKeyboard()) keyboard else 0
+        stopHeights = SheetStops.lifted(stops.map(::heightOf), lift, fullHeight())
+        val material = SheetStops.material(stopHeights, parentHeight())
+        val relayout = behavior.maxHeight != material.maxHeight || behavior.peekHeight != material.peekHeight ||
+            behavior.isFitToContents != material.fitToContents
+        behavior.isFitToContents = material.fitToContents
+        material.halfExpandedRatio?.takeIf { it > 0f && it < 1f }?.let { behavior.halfExpandedRatio = it }
+        behavior.expandedOffset = material.expandedOffset
+        behavior.maxHeight = material.maxHeight
+        behavior.skipCollapsed = material.skipCollapsed
+        behavior.peekHeight = material.peekHeight
+        if (relayout) container.requestLayout()
+        return relayout
     }
 
-    private fun stateOf(detent: SheetDetent): Int = when {
-        detent == detents.last() -> BottomSheetBehavior.STATE_EXPANDED
-        detent == SheetDetent.Medium && !behavior.isFitToContents -> BottomSheetBehavior.STATE_HALF_EXPANDED
-        else -> BottomSheetBehavior.STATE_COLLAPSED
+    /**
+     * The stops or their heights changed (the options, the layout, the content, the keyboard): the behavior takes them,
+     * and a sheet at rest goes to [arrived] (a `selectedDetent` a merge names) when it is a stop, else stays at the
+     * stop it rested at ([settled], by the stops before the change) where it stands now, else goes to the selected one
+     * or the lowest (`SheetStops.target`). A sheet on the move takes them once it rests.
+     */
+    private fun restop(settled: SheetDetent? = detentOf(behavior.state), arrived: SheetDetent? = null) {
+        if (container.parent == null) return
+        val relayout = configure()
+        updateScrim()
+        if (closing != null || backFinishing) return
+        if (isMoving()) {
+            restopPending = true
+            if (arrived != null) pendingArrived = arrived
+            return
+        }
+        // Not shown yet: the show slides it to the stop a merge names.
+        if (settled == null) {
+            if (arrived != null && arrived in stops) selected = arrived
+            return
+        }
+        val shows = awaiting && contentHeight() != null
+        if (shows) awaiting = false
+        val wanted = arrived ?: if (shows) showTarget() else null
+        val target = SheetStops.target(settled, stops, wanted, options.selectedDetent) ?: settled
+        behavior.isHideable = swipeToDismiss && target == stops.first()
+        // A move, or a sheet that can no longer go down, ends a preview of back on it.
+        if (target != settled || !behavior.isHideable) stopBackPreview()
+        if (backPreview != null) return
+        if (target != settled) selected = target
+        if (!relayout) {
+            behavior.state = stateOf(target)
+            return
+        }
+        // The new height comes with the sheet's next layout, where the behavior puts a sheet at rest at its state's
+        // offset at once; a move to another stop follows it.
+        afterNextLayout {
+            val gone = closing != null || backFinishing || container.parent == null
+            if (gone || backPreview != null) return@afterNextLayout
+            if (isMoving()) {
+                restopPending = true
+                if (target != settled) pendingArrived = target
+                return@afterNextLayout
+            }
+            behavior.state = stateOf(target)
+        }
+    }
+
+    private fun isMoving(): Boolean =
+        behavior.state == BottomSheetBehavior.STATE_DRAGGING || behavior.state == BottomSheetBehavior.STATE_SETTLING
+
+    // Runs [step] on the pre-draw of the frame of the sheet's next layout: the behavior has placed it by then.
+    private fun afterNextLayout(step: () -> Unit) {
+        container.addOnLayoutChangeListener(object : View.OnLayoutChangeListener {
+            override fun onLayoutChange(
+                view: View, left: Int, top: Int, right: Int, bottom: Int,
+                oldLeft: Int, oldTop: Int, oldRight: Int, oldBottom: Int,
+            ) {
+                view.removeOnLayoutChangeListener(this)
+                OneShotPreDrawListener.add(view, step)
+            }
+        })
+    }
+
+    private fun stateOf(detent: SheetDetent): Int = when (detent) {
+        stops.last() -> BottomSheetBehavior.STATE_EXPANDED
+        stops.first() -> BottomSheetBehavior.STATE_COLLAPSED
+        else -> BottomSheetBehavior.STATE_HALF_EXPANDED
     }
 
     private fun detentOf(state: Int): SheetDetent? = when (state) {
-        BottomSheetBehavior.STATE_EXPANDED -> detents.last()
-        BottomSheetBehavior.STATE_HALF_EXPANDED -> SheetDetent.Medium
-        BottomSheetBehavior.STATE_COLLAPSED -> detents.first()
+        BottomSheetBehavior.STATE_EXPANDED -> stops.last()
+        BottomSheetBehavior.STATE_HALF_EXPANDED -> stops.getOrNull(1)?.takeIf { stops.size == SheetStops.MAX_STOPS }
+        BottomSheetBehavior.STATE_COLLAPSED -> stops.first()
         else -> null
     }
 
+    private fun parentHeight(): Int = if (layout.height > 0) layout.height else layout.rootView.height
+
+    // The tallest a sheet is: the layout under the status bar.
+    private fun fullHeight(): Int = parentHeight() - topGap
+
     /** The height of the sheet at the detent, in px. */
     private fun heightOf(detent: SheetDetent): Int {
-        val full = (if (layout.height > 0) layout.height else layout.rootView.height) - topGap
+        val full = fullHeight()
         return when (detent) {
             SheetDetent.Large -> full
             SheetDetent.Medium -> (full + topGap) / 2
+            SheetDetent.Content -> contentHeight()?.coerceAtMost(full) ?: full
             is SheetDetent.Height -> detent.dp.toFloat().dp.coerceAtMost(full)
         }
     }
 
+    // The `content` detent follows the content of the screen shown now, and measures it after each of its mounts; a
+    // sheet without the detent follows nothing.
+    private fun followContent() {
+        val content = if (SheetDetent.Content in detents) shownContent() else null
+        if (content !== followed) {
+            followed?.setOnContentMounted(CONTENT_KEY, null)
+            followed = content
+            // The last height stays until the new content has one: a push in the sheet doesn't jump it to the top.
+            content?.setOnContentMounted(CONTENT_KEY) { contentMounted() }
+        }
+        measureContent()
+    }
+
+    // Fabric tells every mount of the app: the content is measured at most once per [MEASURE_INTERVAL_MS], the last
+    // mount of a burst included, so a screen that renders each frame elsewhere doesn't lay the sheet's tree out each
+    // frame too.
+    private fun contentMounted() {
+        val wait = lastMeasure + MEASURE_INTERVAL_MS - SystemClock.uptimeMillis()
+        if (wait > 0) {
+            if (!measureWaits) {
+                measureWaits = true
+                container.postDelayed(measureLater, wait)
+            }
+            return
+        }
+        measureLater.run()
+    }
+
+    // The content's own height at the width it has (the sheet's, before it is laid out); kept until a measure gives
+    // one again.
+    private fun measureContent() {
+        val content = followed ?: return
+        val width = content.asView().width.takeIf { it > 0 } ?: container.width.takeIf { it > 0 } ?: sheetWidth()
+        content.contentSize(width)?.let { contentBody = it.height }
+    }
+
+    // The height of the `content` detent: the content's own, the bars above it in the sheet (a stack's top bar), and
+    // the navigation bar below it, which a detent leaves room for as UIKit adds the bottom safe area; none before the
+    // content is measured.
+    private fun contentHeight(): Int? {
+        val body = contentBody ?: return null
+        val insets = ViewCompat.getRootWindowInsets(layout)
+        val bottom = insets?.getInsets(WindowInsetsCompat.Type.navigationBars())?.bottom ?: 0
+        return offsetAbove() + body + bottom
+    }
+
+    // How far below the sheet's top the content stands, by layout: the views between them, without their transforms.
+    private fun offsetAbove(): Int {
+        var view: View = followed?.asView() ?: return 0
+        var top = 0
+        while (view !== container) {
+            top += view.top
+            view = view.parent as? View ?: return 0
+        }
+        return top
+    }
+
+    // The content may have changed its height: the stops follow it.
+    private fun contentChanged() {
+        if (contentHeight() != appliedContentHeight) restop()
+    }
+
+    private fun sheetWidth(): Int {
+        val width = if (layout.width > 0) layout.width else layout.rootView.width
+        return width.coerceAtMost(MAX_WIDTH_DP.dp)
+    }
+
     private fun onState(state: Int) {
         when (state) {
-            BottomSheetBehavior.STATE_DRAGGING -> dragged = true
+            BottomSheetBehavior.STATE_DRAGGING -> {
+                dragged = true
+                awaiting = false
+            }
             BottomSheetBehavior.STATE_HIDDEN -> {
+                backFinishing = false
                 when {
                     closing != null -> finishClosing()
                     else -> {
@@ -241,7 +590,7 @@ internal class ModalSheet(
                 if (closing != null) return
                 val detent = detentOf(state)
                 // A drag down closes the sheet from its smallest detent only; from a larger one it stops at the next.
-                behavior.isHideable = swipeToDismiss && detent == detents.first()
+                behavior.isHideable = swipeToDismiss && detent == stops.first()
                 shown?.let {
                     shown = null
                     it()
@@ -251,6 +600,12 @@ internal class ModalSheet(
                     events.onDetentChanged(detent)
                 }
                 dragged = false
+                if (restopPending) {
+                    val arrived = pendingArrived
+                    restopPending = false
+                    pendingArrived = null
+                    container.post { restop(arrived = arrived) }
+                }
             }
         }
         updateScrim()
@@ -265,13 +620,23 @@ internal class ModalSheet(
     // The screen under the sheet dims as the sheet goes up past `largestUndimmedDetent` (from the bottom without
     // one), to the dim of a Material modal sheet at the next detent; while it isn't dimmed, it takes touches.
     private fun updateScrim() {
-        val height = layout.height - container.top
-        val undimmed = options.largestUndimmedDetent?.takeIf { it in detents }
-        val from = undimmed?.let { heightOf(it) } ?: 0
-        val to = detents.firstOrNull { heightOf(it) > from }?.let { heightOf(it) } ?: return run { setDim(0f) }
+        // Hidden at the end of back's slide, it still stands at its detent until the next layout.
+        if (behavior.state == BottomSheetBehavior.STATE_HIDDEN) return setDim(0f)
+        val height = layout.height - sheetTop()
+        val undimmed = stops.indexOf(options.largestUndimmedDetent).takeIf { it >= 0 }
+        val from = undimmed?.let { stopHeights.getOrNull(it) } ?: 0
+        val to = stopHeights.firstOrNull { it > from } ?: return run { setDim(0f) }
         setDim(((height - from).toFloat() / (to - from)).coerceIn(0f, 1f))
     }
 
+    // The top of the sheet as drawn: its offset, and while back's preview moves it, its slide and its scale toward
+    // the bottom (the behavior's pivot).
+    private fun sheetTop(): Int {
+        if (backFramesObserver == null) return container.top
+        val scaled = container.pivotY * (1f - container.scaleY)
+        return (container.top + container.translationY + scaled).roundToInt()
+    }
+
     private fun setDim(fraction: Float) {
         scrim.alpha = fraction * SCRIM_ALPHA
     }
@@ -280,9 +645,35 @@ internal class ModalSheet(
 
     private fun cornerRadius(): Int = if (options.cornerRadius.hasValue()) options.cornerRadius.get().toFloat().dp else 28.dp
 
-    private fun enableNestedScrolling(view: View) {
-        if (view is ScrollView && !view.isNestedScrollingEnabled) view.isNestedScrollingEnabled = true
-        if (view is ViewGroup) for (i in 0 until view.childCount) enableNestedScrolling(view.getChildAt(i))
+    // React Native mounts the lists of the shown screen after the sheet's layout, and its views take no layout of their
+    // own: the sheet hears each mount of the content and turns a new list to scroll nested there.
+    private fun hearContent() {
+        val content = if (behavior.dragAnywhere) shownContent() else null
+        if (content !== heard) {
+            heard?.setOnContentMounted(SCROLL_KEY, null)
+            heard = content
+            content?.setOnContentMounted(SCROLL_KEY) { turnScrollViews() }
+        }
+        turnScrollViews()
+    }
+
+    // The behavior finds the lists that scroll nested only in its layout of the sheet: a list turned so gets the sheet
+    // one more, else the behavior knows no list and takes a drag down on a scrolled one for a drag of the sheet.
+    private fun turnScrollViews() {
+        if (behavior.dragAnywhere && enableNestedScrolling(container)) container.requestLayout()
+    }
+
+    // Whether a list was turned to scroll nested now.
+    private fun enableNestedScrolling(view: View): Boolean {
+        var turned = false
+        if (view is ScrollView && !view.isNestedScrollingEnabled) {
+            view.isNestedScrollingEnabled = true
+            turned = true
+        }
+        if (view is ViewGroup) {
+            for (i in 0 until view.childCount) turned = enableNestedScrolling(view.getChildAt(i)) || turned
+        }
+        return turned
     }
 
     /** With `expandsOnScroll: false` only the top of the sheet, around the grabber, drags it; the rest scrolls. */
@@ -298,7 +689,7 @@ internal class ModalSheet(
             when (event.actionMasked) {
                 MotionEvent.ACTION_DOWN -> {
                     downY = event.rawY
-                    downAtSmallest = detentOf(state) == detents.first()
+                    downAtSmallest = detentOf(state) == stops.first()
                 }
                 MotionEvent.ACTION_UP -> {
                     if (!swipeToDismiss && closing == null && downAtSmallest && event.rawY - downY > ATTEMPT_DISTANCE_DP.dp) {
@@ -333,10 +724,22 @@ internal class ModalSheet(
         }
     }
 
-    private companion object {
+    companion object {
+        /** The widest a sheet is, in dp: the Material modal bottom sheet's `maxWidth`. */
+        const val MAX_WIDTH_DP = 640
+
         /** The dim of a Material modal bottom sheet's scrim. */
-        const val SCRIM_ALPHA = 0.32f
-        const val GRAB_AREA_DP = 48
-        const val ATTEMPT_DISTANCE_DP = 48
+        private const val SCRIM_ALPHA = 0.32f
+        private const val GRAB_AREA_DP = 48
+        private const val ATTEMPT_DISTANCE_DP = 48
+
+        // The key of the sheet's handler of its content's mounts.
+        private const val CONTENT_KEY = "sheet.content"
+
+        // The least time between two measures of the content after its mounts.
+        private const val MEASURE_INTERVAL_MS = 100L
+
+        // The key of the sheet's handler that turns its content's lists to scroll nested.
+        private const val SCROLL_KEY = "sheet.scroll"
     }
 }