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

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ComponentViewController.kt

@@ -8,12 +8,12 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.react.ArrangementStates
 import dev.apexnative.navigation.react.ReactView
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.react.ScreenRegions
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
+import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.slots.SlotScreenView
 import dev.apexnative.navigation.system.SystemUiOwner
 import dev.apexnative.navigation.viewcontrollers.child.ChildController
@@ -156,7 +156,7 @@ class ComponentViewController(
             shown = layout.isShown || prepared,
             layoutPending = !prepared && isLayoutPending(content),
             topOfStack = parent?.isTopOfStack(this) ?: true,
-            hasSafeArea = ScreenInsets.padding(id) != null,
+            hasSafeArea = ScreenEnvironment.padding(id) != null,
         )
         if (!measures) return
         val windowInsets = ViewCompat.getRootWindowInsets(content) ?: return
@@ -175,10 +175,15 @@ class ComponentViewController(
         val edges = ScreenSafeArea.paddedEdges(
             safeAreaEdges = resolveCurrentOptions(DefaultOptions.current).layout.safeAreaEdges,
             topFree = parent?.leavesTopEdgeFree(this) == true,
-            bottomFree = parent?.leavesBottomEdgeFree(this) == true,
+            largeTitle = parent?.showsLargeTitleOver(this) == true,
         )
-        ScreenInsets.update(activity, id, insets, ScreenSafeArea.padding(insets, edges))
-        ScreenRegions.update(activity, id, Rect(place.left, place.top, place.right, place.bottom), windowInsets)
+        // The events of the screen go to the JavaScript it was made for, and to no other.
+        val emitter = EventEmitter.of(jsGeneration)
+        val padding = ScreenSafeArea.padding(insets, edges)
+        val uncovered = ScreenSafeArea.uncovered(insets, padding)
+        ScreenEnvironment.setInsets(id, uncovered, padding, ScreenEnvironment.changesOf(emitter))
+        val area = Rect(place.left, place.top, place.right, place.bottom)
+        ScreenRegions.update(activity, id, area, windowInsets, emitter)
     }
 
     // A layout asked for on the content or on a view around it: it isn't in its place yet.
@@ -241,9 +246,7 @@ class ComponentViewController(
         }
         setParentController(null)
         if (isIdTakenByAnother) return
-        ScreenInsets.remove(id)
-        ScreenRegions.remove(id)
-        ArrangementStates.remove(id)
+        ScreenEnvironment.remove(id)
         ScreenReadiness.remove(id)
     }
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ContentReadiness.kt

@@ -4,8 +4,8 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
 /**
  * Whether a screen's content rendered, which a command waits for before the screen comes in: a new root (`setRoot`),
- * a push with `waitForRender: true`, the new top of a `setStackRoot`. A wait never listens to the readiness store
- * itself: the content keeps the one listener of its id and tells every waiter. Main thread only.
+ * a push (unless `waitForRender: false`), the new top of a `setStackRoot`. A wait never listens to the readiness store
+ * itself: the content keeps its own listener of its id and tells every waiter. Main thread only.
  */
 internal interface Readiness {
     /** The content of [screen] rendered; a screen without content to wait for is ready. */

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/RenderWait.kt

@@ -16,8 +16,10 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
  * without a limit.
  *
  * What differs between its users are its values, never its steps: the readiness and the clock (fakes in the unit
- * tests), [countsUnknownContent], how a readiness signal is delivered ([deliver]: at once, or posted to the next turn
- * of the main loop), and [step], the guard the user runs every later step in (a timer, a signal). Main thread only.
+ * tests), [countsUnknownContent], how a readiness signal is delivered ([deliver]: at once, posted to the next turn of
+ * the main loop, or behind the calls of JavaScript), whether content ready at once is delivered too
+ * ([deliversReadyContent]), and [step], the guard the user runs every later step in (a timer, a signal). Main thread
+ * only.
  */
 internal class RenderWait(
     private val readiness: Readiness,
@@ -32,6 +34,12 @@ internal class RenderWait(
     private val countsUnknownContent: Boolean,
     /** How a readiness signal reaches the wait: at once by default; posted, when a signal may come inside a layout. */
     private val deliver: (() -> Unit) -> Unit = { it() },
+    /**
+     * Content ready when the wait starts (or retakes) still reaches its end through [deliver], within the limit that
+     * runs: what [deliver] waits behind (a push's: the calls JavaScript made in the commit of that content) comes
+     * first. Off: such content ends the wait at once.
+     */
+    private val deliversReadyContent: Boolean = false,
     /** Runs a later step of the wait (a timer, a signal): the user's guards and protection; as it is by default. */
     private val step: (() -> Unit) -> Unit = { it() },
     private val onEnd: () -> Unit,
@@ -70,7 +78,8 @@ internal class RenderWait(
 
     /**
      * Starts waiting for [screens], and for the content of [unseen] within its first [UNSEEN_LIMIT_MILLIS]; with all
-     * of them ready (and their bars' components, when they count within the limit) it ends at once, before it returns.
+     * of them ready (and their bars' components, when they count within the limit) it ends at once, before it returns,
+     * or through [deliver] with [deliversReadyContent].
      */
     fun start(screens: List<ViewController<*>>, unseen: List<ViewController<*>> = emptyList()) {
         this.screens = screens
@@ -78,15 +87,18 @@ internal class RenderWait(
         unseenDone = unseen.isEmpty()
         waiting = true
         token = Any()
-        // Content ready at once ends the wait, unless the bar's components count within a limit: it runs for them.
-        if (contentReady() && !(bar == Bar.WithinLimit && limitMillis != null)) return contentDone()
+        // Content ready at once ends the wait, unless the bar's components count within a limit (it runs for them) or
+        // the content goes through [deliver] too.
+        val ready = contentReady()
+        if (ready && !deliversReadyContent && !(bar == Bar.WithinLimit && limitMillis != null)) return contentDone()
+        // The timers first: a [deliver] that runs at once may end the wait before this returns.
         cancelContentTimer = when {
             limitMillis != null -> scheduler.schedule(limitMillis) { step { atLimit() } }
             countsUnknownContent -> scheduler.schedule(UNKNOWN_CONTENT_MILLIS) { step { atUnknownContentLimit() } }
             else -> null
         }
         startUnseenLimit()
-        await()
+        if (ready && deliversReadyContent) deliverReady() else await()
     }
 
     /**
@@ -98,7 +110,7 @@ internal class RenderWait(
         this.screens = screens
         this.unseen = unseen
         token = Any()
-        await()
+        if (deliversReadyContent && contentReady()) deliverReady() else await()
     }
 
     /** Ends the wait without [onEnd]: its timers stop, and the signals still to come do nothing. */
@@ -129,6 +141,14 @@ internal class RenderWait(
         if (contentReady() && cancelBarPhase == null) contentDone()
     }
 
+    // The content is ready already: it goes once through [deliver] as a signal would, then on as [await] says.
+    private fun deliverReady() {
+        val token = token
+        deliver {
+            step { if (waiting && this.token === token) await() }
+        }
+    }
+
     // The content of every screen ready: on to the bars; else the signals of those not ready.
     private fun await() {
         if (contentReady()) return contentDone()

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ScreenFrame.kt

@@ -143,7 +143,7 @@ internal class ScreenFrame(
             val parent = node.parentController
             val statusBar = ScreenSafeArea.statusBarRoom(
                 statusBarHeight = statusBarHeight,
-                hiddenOrDrawBehind = options.statusBar.isHiddenOrDrawBehind,
+                hiddenOrDrawBehind = options.statusBar.isHiddenOrDrawBehind(node.isInOverlay),
                 inSheet = node.isInSheet,
                 inSideMenu = node.isInSideMenu,
                 keptAround = parent?.keepsStatusBarRoomOf(node) == true,

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ScreenReadiness.kt

@@ -1,93 +1,128 @@
 package dev.apexnative.navigation.viewcontrollers.component
 
 /**
- * The readiness of each screen by its id: the safe area view of a screen (`ANNSafeAreaView`) tells it here that it is
- * laid out in its place and that the screen's content rendered into it, and asks whether the screen waits for that at
- * all. The screen's container listens by the screen's id: no view walks up or down the views to find the other. Main
- * thread only.
+ * The readiness of each screen by its id: the safe area view of a screen (`ANNSafeAreaView`) tells it here that it
+ * has one, that it is laid out in its place and that the screen's content rendered into it, and asks whether the
+ * screen waits for that at all. The content of a screen or of a component listens by the id: no view walks up or down
+ * the views to find the other. Main thread only.
+ *
+ * As on iOS (`ANNScreenReadiness`), what a safe area view said is kept: a listener that comes later hears it at once.
+ * Several listeners may wait on one id (the roots of a bar component that several screens show with one id), each
+ * under a key of its own, which removes it. Each signal carries its source, the React surface of the safe area view
+ * that gave it, and a listener hears only the sources it [accepts][Listener.accepts]: React Native never gives a
+ * surface's id twice in a process, so the late signal of another root with the same id (a root of the JavaScript that
+ * went, a destroyed screen, another live root of a bar component) never makes a new root ready.
  */
 object ScreenReadiness {
-    /** What a screen's container hears from the safe area view of its screen. */
+    /** The source of a signal that names none: a listener that accepts every source hears it. */
+    const val NO_SOURCE = -1
+
+    /** What the content of a screen or of a component hears from the safe area view of its id. */
     interface Listener {
+        /**
+         * Whether a signal of [source] (the id of the React surface of the safe area view that gave it) is this
+         * listener's: by default every one is.
+         */
+        fun accepts(source: Int): Boolean = true
+
         /** The safe area view is laid out in its place, with a size. */
-        fun onLaidOut()
+        fun onLaidOut() = Unit
 
         /** The screen rendered its content into its safe area view, also when it renders nothing (`null`). */
         fun onContentRendered()
     }
 
-    private val atOnce = HashSet<String>()
-    private val wrapped = HashSet<String>()
-    private val laidOut = HashSet<String>()
-    private val rendered = HashSet<String>()
-    private val listeners = HashMap<String, Listener>()
+    // What the safe area views of one id said: that one exists, and the sources that are laid out and rendered.
+    private class Entry {
+        var wrapped = false
+        val laidOut = HashSet<Int>()
+        val rendered = HashSet<Int>()
+    }
+
+    private val entries = HashMap<String, Entry>()
+    private val listeners = HashMap<String, LinkedHashMap<Any, Listener>>()
+    // The roots that render at once, by id: an id renders at once while one of them lives.
+    private val atOnce = HashMap<String, MutableSet<Any>>()
 
     /**
      * Whether the screen [screenId] waits for its safe area view to be laid out before its content renders: every
-     * screen does, as on iOS, unless the core marked it as one that renders at once ([setRendersAtOnce]) — a React
-     * component of a bar or a tab item, whose size comes from its content.
+     * screen does, as on iOS, unless a root of the id renders at once ([setRendersAtOnce]) — a React component of a
+     * bar or a tab item, whose size comes from its content.
      */
-    fun waitsForReadiness(screenId: String): Boolean = screenId !in atOnce
+    fun waitsForReadiness(screenId: String): Boolean = atOnce[screenId].isNullOrEmpty()
 
-    /** The core marks a React root it made as one that renders at once (a component of a bar, a tab item), or not. */
-    fun setRendersAtOnce(screenId: String, rendersAtOnce: Boolean) {
-        if (rendersAtOnce) atOnce += screenId else atOnce -= screenId
+    /**
+     * The root [key] of [screenId] renders at once (a component of a bar, a tab item), or stopped. The id renders at
+     * once while a root marks it; when the last one stops, what was said of the id goes too, so a later root with it
+     * starts anew.
+     */
+    fun setRendersAtOnce(screenId: String, key: Any, rendersAtOnce: Boolean) {
+        if (rendersAtOnce) {
+            atOnce.getOrPut(screenId, ::HashSet).add(key)
+            return
+        }
+        val keys = atOnce[screenId] ?: return
+        if (!keys.remove(key) || keys.isNotEmpty()) return
+        atOnce.remove(screenId)
+        entries.remove(screenId)
     }
 
     /** The screen [screenId] has a safe area view: it is rendered only once that view says so. */
     fun wrapped(screenId: String) {
-        wrapped += screenId
+        entryOf(screenId).wrapped = true
     }
 
-    /** The safe area view of [screenId] is laid out in its place, with a size. */
-    fun laidOut(screenId: String) {
-        if (laidOut.add(screenId)) listeners[screenId]?.onLaidOut()
+    /** The safe area view of [screenId], in the React surface [source], is laid out in its place, with a size. */
+    fun laidOut(screenId: String, source: Int = NO_SOURCE) {
+        val entry = entryOf(screenId)
+        entry.wrapped = true
+        if (entry.laidOut.add(source)) tell(screenId, source, Listener::onLaidOut)
     }
 
-    /** The screen [screenId] rendered its content into its safe area view. */
-    fun contentRendered(screenId: String) {
-        if (rendered.add(screenId)) listeners[screenId]?.onContentRendered()
+    /** The screen [screenId] rendered its content into its safe area view, in the React surface [source]. */
+    fun contentRendered(screenId: String, source: Int = NO_SOURCE) {
+        val entry = entryOf(screenId)
+        entry.wrapped = true
+        if (entry.rendered.add(source)) tell(screenId, source, Listener::onContentRendered)
     }
 
     /**
-     * Whether the screen [screenId] rendered its content into its safe area view; null when no safe area view told
-     * anything of it (a screen without one, of the old API: its container decides by its own content).
+     * Whether the screen [screenId] rendered its content into its safe area view, in a source [listener] accepts (any
+     * source without one); null when no safe area view told anything of the id (a screen without one, of the old API:
+     * its content decides by its own children).
      */
-    fun isContentRendered(screenId: String): Boolean? = when (screenId) {
-        in rendered -> true
-        in laidOut, in wrapped -> false
-        else -> null
-    }
-
-    /** [listener] hears the signals of [screenId] from now on; null stops it. */
-    fun setListener(screenId: String, listener: Listener?) {
-        if (listener == null) listeners.remove(screenId) else listeners[screenId] = listener
+    fun isContentRendered(screenId: String, listener: Listener? = null): Boolean? {
+        val entry = entries[screenId] ?: return null
+        return entry.rendered.any { listener?.accepts(it) ?: true }
     }
 
     /**
-     * [listener] stops hearing [screenId], if it is the one that listens: a later screen with the same id (a `setRoot`
-     * makes the new root before the old one goes) keeps its own.
+     * [listener] hears the signals of [screenId] under [key] (its owner) until [removeListener] with the key: a key
+     * has one listener per id, the other keys keep theirs. What the safe area views said before reaches it at once, in
+     * order, for the sources it accepts.
      */
-    fun removeListener(screenId: String, listener: Listener) {
-        if (listeners[screenId] === listener) listeners.remove(screenId)
+    fun addListener(screenId: String, key: Any, listener: Listener) {
+        listeners.getOrPut(screenId, ::LinkedHashMap)[key] = listener
+        val entry = entries[screenId] ?: return
+        if (entry.laidOut.any(listener::accepts) && isListening(screenId, key, listener)) listener.onLaidOut()
+        if (entry.rendered.any(listener::accepts) && isListening(screenId, key, listener)) listener.onContentRendered()
     }
 
-    /**
-     * A new root takes [screenId] while another with it lives (a component of a bar on two screens): what the other
-     * rendered isn't the new one's, which waits for its own render. Its mark of rendering at once stays.
-     */
-    fun forgetRender(screenId: String) {
-        laidOut -= screenId
-        rendered -= screenId
+    /** The listener of [key] stops hearing [screenId]; those of other keys (a later root with the id) keep theirs. */
+    fun removeListener(screenId: String, key: Any) {
+        val keys = listeners[screenId] ?: return
+        keys.remove(key)
+        if (keys.isEmpty()) listeners.remove(screenId)
     }
 
-    /** The screen is destroyed: what was kept of it goes, so a later screen with the same id starts anew. */
+    /**
+     * The screen [screenId] owns the id from now on (made), or went while no other node has it (destroyed): what its
+     * safe area views said and the marks of rendering at once go, so a later screen with the id starts anew. The
+     * listeners stay with their keys, which remove them.
+     */
     fun remove(screenId: String) {
-        atOnce -= screenId
-        wrapped -= screenId
-        laidOut -= screenId
-        rendered -= screenId
-        listeners -= screenId
+        entries.remove(screenId)
+        atOnce.remove(screenId)
     }
 
     /**
@@ -95,10 +130,22 @@ object ScreenReadiness {
      * "rendered" kept for a screen of the old one would make its new screen with the same id ready at once.
      */
     fun reset() {
-        atOnce.clear()
-        wrapped.clear()
-        laidOut.clear()
-        rendered.clear()
+        entries.clear()
         listeners.clear()
+        atOnce.clear()
+    }
+
+    private fun entryOf(screenId: String): Entry = entries.getOrPut(screenId, ::Entry)
+
+    private fun isListening(screenId: String, key: Any, listener: Listener): Boolean =
+        listeners[screenId]?.get(key) === listener
+
+    // Each listener of the id that accepts the source, as they are now: one that a listener before it removed hears
+    // nothing.
+    private fun tell(screenId: String, source: Int, signal: (Listener) -> Unit) {
+        val now = listeners[screenId]?.entries?.toList() ?: return
+        for ((key, listener) in now) {
+            if (isListening(screenId, key, listener) && listener.accepts(source)) signal(listener)
+        }
     }
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ScreenSafeArea.kt

@@ -1,6 +1,6 @@
 package dev.apexnative.navigation.viewcontrollers.component
 
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment.Insets
 
 /**
  * The arithmetic of a screen's room, safe area and background on Android, without views: the screen nodes read the
@@ -19,6 +19,7 @@ internal object ScreenSafeArea {
     const val LEFT = "left"
 
     private val ALL_EDGES = setOf(TOP, RIGHT, BOTTOM, LEFT)
+    private val DEFAULT_EDGES = setOf(TOP, RIGHT, LEFT)
     private const val OPAQUE = 0xFF
 
     /**
@@ -57,10 +58,10 @@ internal object ScreenSafeArea {
         headerBottom: Int?,
         tabsTop: Int?,
         density: Float,
-    ): ScreenInsets.Insets {
+    ): Insets {
         val coveredAbove = maxOf(system.top, headerBottom ?: 0)
         val coveredBelow = minOf(windowHeight - system.bottom, tabsTop ?: windowHeight)
-        return ScreenInsets.Insets(
+        return Insets(
             top = dp((coveredAbove - root.top).coerceAtLeast(0), density),
             right = dp((root.right - (windowWidth - system.right)).coerceAtLeast(0), density),
             bottom = dp((root.bottom - coveredBelow).coerceAtLeast(0), density),
@@ -69,26 +70,43 @@ internal object ScreenSafeArea {
     }
 
     /**
-     * The edges the screen's safe area view keeps its content off: exactly [safeAreaEdges] when the options give them;
-     * else all four, but the top when the stack's header hides on scroll or a large title shows ([topFree]) and the
-     * bottom when the tabs hide on scroll ([bottomFree]).
+     * The edges the screen's safe area view keeps its content off: exactly [safeAreaEdges] when the options give them,
+     * but the top under a large title ([largeTitle]); else the top and the sides, but the top when the stack's header
+     * hides on scroll or a large title shows ([topFree]). The bottom is free by default: the content goes down to the
+     * bottom, and a list keeps its last rows clear of the navigation bar with `useSafeAreaInsets()`.
      */
-    fun paddedEdges(safeAreaEdges: List<String>?, topFree: Boolean, bottomFree: Boolean): Set<String> {
-        if (safeAreaEdges != null) return safeAreaEdges.filterTo(LinkedHashSet()) { it in ALL_EDGES }
-        val edges = LinkedHashSet(ALL_EDGES)
+    fun paddedEdges(safeAreaEdges: List<String>?, topFree: Boolean, largeTitle: Boolean): Set<String> {
+        if (safeAreaEdges != null) {
+            val edges = safeAreaEdges.filterTo(LinkedHashSet()) { it in ALL_EDGES }
+            // Under a large title the list keeps its first rows clear of the bar itself; a padded top would follow the
+            // header as it collapses and move the list with it.
+            if (largeTitle) edges -= TOP
+            return edges
+        }
+        val edges = LinkedHashSet(DEFAULT_EDGES)
         if (topFree) edges -= TOP
-        if (bottomFree) edges -= BOTTOM
         return edges
     }
 
     /** The padding of the safe area view: the [insets] on the [edges] it keeps, 0 on the others. */
-    fun padding(insets: ScreenInsets.Insets, edges: Set<String>): ScreenInsets.Insets = ScreenInsets.Insets(
+    fun padding(insets: Insets, edges: Set<String>): Insets = Insets(
         top = if (TOP in edges) insets.top else 0.0,
         right = if (RIGHT in edges) insets.right else 0.0,
         bottom = if (BOTTOM in edges) insets.bottom else 0.0,
         left = if (LEFT in edges) insets.left else 0.0,
     )
 
+    /**
+     * The insets JavaScript gets (`useSafeAreaInsets`): what of the [insets] still covers the content once the safe
+     * area view keeps it off its [padding], 0 on a padded edge.
+     */
+    fun uncovered(insets: Insets, padding: Insets) = Insets(
+        top = (insets.top - padding.top).coerceAtLeast(0.0),
+        right = (insets.right - padding.right).coerceAtLeast(0.0),
+        bottom = (insets.bottom - padding.bottom).coerceAtLeast(0.0),
+        left = (insets.left - padding.left).coerceAtLeast(0.0),
+    )
+
     /**
      * The inner padding of a screen's view: the side system bars ([systemBars]) at the sides; at the bottom the larger
      * of the navigation bar (none when the screen draws under it) and the keyboard ([imeBottom]; none with

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/externalcomponent/ExternalComponentViewController.kt

@@ -10,11 +10,9 @@ import dev.apexnative.navigation.layout.LayoutException
 import dev.apexnative.navigation.nativescreen.NativeScreenContext
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.react.ArrangementStates
 import dev.apexnative.navigation.react.CommandScope
 import dev.apexnative.navigation.react.ErrorTexts
-import dev.apexnative.navigation.react.ScreenInsets
-import dev.apexnative.navigation.react.ScreenRegions
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
 import dev.apexnative.navigation.react.events.ScreenAppearance
@@ -170,9 +168,7 @@ class ExternalComponentViewController internal constructor(
         peekView()?.let { (it.parent as? ViewGroup)?.removeView(it) }
         setParentController(null)
         if (isIdTakenByAnother) return
-        ScreenInsets.remove(id)
-        ScreenRegions.remove(id)
-        ArrangementStates.remove(id)
+        ScreenEnvironment.remove(id)
         ScreenReadiness.remove(id)
         if (!notMade) AppearanceDispatcher.nativeScreenReleased(this)
     }

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

@@ -1,40 +1,38 @@
 package dev.apexnative.navigation.viewcontrollers.modal
 
-import kotlin.math.PI
-import kotlin.math.cos
+import dev.apexnative.navigation.views.animations.Curves
 
 /**
- * The default animations of a modal on Android, as values: it comes up from the bottom of the window by the window's
- * height (in a split screen or a window, the window's, not the display's) and fades in, [DURATION] with a deceleration
- * at the end; it goes down and fades out in the same time, accelerating and decelerating (the system's cosine, not the
- * option's `accelerateDecelerate`). A sheet moves only by the Material sheet's own motion. Pure arithmetic.
+ * The default animations of a modal over the whole screen on Android, as values: the system's motion of a window that
+ * opens over the one below it (`activity_translucent_open_enter` and `activity_translucent_close_exit` of the
+ * platform, which Android 16 plays for a translucent activity). The modal comes up from the bottom of the window by the
+ * window's height (in a split screen or a window, the window's, not the display's) in [SHOW_DURATION], slowing down at
+ * the end; it goes down in [DISMISS_DURATION], speeding up. It doesn't fade: the screen below is seen only around it,
+ * as under a translucent activity. A sheet moves only by the Material sheet's own motion. Pure arithmetic.
  */
 internal object ModalAnimations {
-    /** How long the default show and the default dismissal last (ms). */
-    const val DURATION = 300L
+    /** How long the default show lasts (ms): `activity_translucent_open_enter`. */
+    const val SHOW_DURATION = 300L
+
+    /** How long the default dismissal lasts (ms): `activity_translucent_close_exit`. */
+    const val DISMISS_DURATION = 250L
+
+    // `linear_out_slow_in` of the platform: the path (0, 0) (0, 0) (0.2, 1) (1, 1).
+    private val linearOutSlowIn = Curves.CubicBezier(0.0, 0.0, 0.2, 1.0)
 
     /** How far a modal comes up and goes down: the window's height ([windowHeight]), or the display's while it is 0. */
     fun distance(windowHeight: Int, displayHeight: Int): Float =
         (if (windowHeight > 0) windowHeight else displayHeight).toFloat()
 
-    /** The curve of the show: a deceleration, 1 − (1 − p)². */
-    fun decelerate(progress: Float): Float = 1f - (1f - progress) * (1f - progress)
+    /** The curve of the show: the platform's `linear_out_slow_in`, fast at first and slow at the end. */
+    fun linearOutSlowIn(progress: Float): Float = linearOutSlowIn.getInterpolation(progress)
 
-    /** The curve of the dismissal: an acceleration then a deceleration, cos((p + 1)π) / 2 + 0.5. */
-    fun accelerateDecelerate(progress: Float): Float = (cos((progress + 1) * PI) / 2 + 0.5).toFloat()
+    /** The curve of the dismissal: the platform's `accelerate_quad`, p². */
+    fun accelerate(progress: Float): Float = progress.coerceIn(0f, 1f).let { it * it }
 
-    /** Where a modal is at [progress] (0 … 1, in time) of its show over [distance]: its translation and its alpha. */
-    fun show(progress: Float, distance: Float): Frame {
-        val value = decelerate(progress)
-        return Frame(translationY = distance * (1f - value), alpha = value)
-    }
+    /** Where a modal is at [progress] (0 … 1, in time) of its show over [distance]: its translation. */
+    fun show(progress: Float, distance: Float): Float = distance * (1f - linearOutSlowIn(progress))
 
     /** Where a modal is at [progress] of its dismissal over [distance], from where it rests. */
-    fun dismiss(progress: Float, distance: Float): Frame {
-        val value = accelerateDecelerate(progress)
-        return Frame(translationY = distance * value, alpha = 1f - value)
-    }
-
-    /** A modal's place in its animation. */
-    data class Frame(val translationY: Float, val alpha: Float)
+    fun dismiss(progress: Float, distance: Float): Float = distance * accelerate(progress)
 }