@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

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

@@ -0,0 +1,90 @@
+package dev.apexnative.navigation.viewcontrollers.component
+
+import android.app.Activity
+import android.graphics.Color
+import android.graphics.drawable.ColorDrawable
+import android.graphics.drawable.Drawable
+import android.graphics.drawable.LayerDrawable
+import android.view.View
+import dev.apexnative.navigation.options.DefaultOptions
+import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.options.params.ThemeColour
+import dev.apexnative.navigation.system.SystemUiOwner
+import dev.apexnative.navigation.viewcontrollers.externalcomponent.ExternalComponentViewController
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * The presenter of a screen, React or native: its background — the screen's view takes `layout.backgroundColor`, kept
+ * out of the status bar's height where the status bar shows over it, and the React content takes
+ * `layout.componentBackgroundColor` over it —, its room for the bars, and its safe area again on `mergeOptions`
+ * (`mergeOptions` step 4). It applies as the screen appears, on `mergeOptions` of what it covers, and again with new
+ * default options or after a light/dark switch from the resolved options it is given, which it never writes. Each
+ * appearance tells the activity's system UI owner, which follows the screen on top. Main thread only.
+ */
+open class ComponentPresenter(activity: Activity) : Presenter(activity, DefaultOptions.current) {
+    override fun applyOptions(view: ViewController<*>, options: Options) {
+        frameOf(view)?.applyRoom()
+        applyBackground(view, options)
+        SystemUiOwner.of(activity)?.invalidate()
+    }
+
+    override fun mergeOptions(viewController: ViewController<*>, options: Options) {
+        val statusBar = options.statusBar.visible.hasValue() || options.statusBar.drawBehind.hasValue()
+        if (statusBar) frameOf(viewController)?.applyRoom()
+        if (statusBar || options.layout.backgroundColor.hasValue() ||
+            options.layout.componentBackgroundColor.hasValue()
+        ) {
+            applyBackground(viewController, viewController.resolveCurrentOptions(defaultOptions))
+        }
+        // The keyboard's room again, with the keyboard open too; the padding over or under the navigation bar again
+        // (`navigationBar.drawBehind`).
+        val navigationBar = options.navigationBar.let { it.drawBehind.hasValue() || it.backgroundColor.hasValue() }
+        if (options.layout.adjustResize.hasValue() || navigationBar) frameOf(viewController)?.applyInsetsAgain()
+        // The edges, the large title and the bars' hiding may have changed.
+        (viewController as? ComponentViewController)?.updateSafeArea()
+    }
+
+    override fun onConfigurationChanged(controller: ViewController<*>, options: Options) =
+        applyBackground(controller, options)
+
+    /**
+     * The colors of [screen] from its resolved [options]: `layout.backgroundColor` on the screen's view, none without
+     * it (the window shows); `layout.componentBackgroundColor` on its React content.
+     */
+    fun applyBackground(screen: ViewController<*>, options: Options) {
+        val view = screen.peekView() ?: return
+        view.background = screenBackground(screen, options)
+        contentOf(screen)?.background = colorOf(options.layout.componentBackgroundColor)?.let(::ColorDrawable)
+    }
+
+    private fun screenBackground(screen: ViewController<*>, options: Options): Drawable? {
+        val color = colorOf(options.layout.backgroundColor) ?: return null
+        val frame = frameOf(screen) ?: return ColorDrawable(color)
+        val band = ScreenSafeArea.backgroundBand(
+            statusBarHeight = frame.statusBarHeight,
+            hiddenOrDrawBehind = options.statusBar.isHiddenOrDrawBehind,
+            inSideMenu = screen.isInSideMenu,
+            inSheet = screen.isInSheet,
+            inPair = frame.isInPair,
+            topRoom = frame.topRoom(),
+        )
+        if (band <= 0) return ColorDrawable(color)
+        // A layer inset reports no padding (an InsetDrawable does, and the view would take it in place of its own:
+        // the side bars, the navigation bar and the keyboard).
+        return LayerDrawable(arrayOf<Drawable>(ColorDrawable(color))).apply { setLayerInset(0, 0, band, 0, 0) }
+    }
+
+    // A color the options give, with the activity's theme for platform colors; none without one.
+    private fun colorOf(colour: ThemeColour): Int? =
+        if (colour.hasValue()) colour.get(activity, Color.TRANSPARENT) ?: Color.TRANSPARENT else null
+
+    private fun frameOf(screen: ViewController<*>): ScreenFrame? = when (screen) {
+        is ComponentViewController -> screen.frame
+        is ExternalComponentViewController -> screen.frame
+        else -> null
+    }
+
+    // The view under the React content: the React root, or the container of a slot screen. A native screen has none.
+    private fun contentOf(screen: ViewController<*>): View? = (screen as? ComponentViewController)?.content?.asView()
+}

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

@@ -0,0 +1,254 @@
+package dev.apexnative.navigation.viewcontrollers.component
+
+import android.app.Activity
+import android.graphics.Rect
+import android.view.View
+import android.view.ViewGroup
+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.ScreenRegions
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+import dev.apexnative.navigation.react.events.ComponentType
+import dev.apexnative.navigation.slots.SlotScreenView
+import dev.apexnative.navigation.system.SystemUiOwner
+import dev.apexnative.navigation.viewcontrollers.child.ChildController
+import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
+import dev.apexnative.navigation.viewcontrollers.parent.ChildOffsetFromRest
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.IReactView
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.component.ComponentLayout
+
+/**
+ * A React screen (`Component` of the layout): its content is a React root of its own, or the container of a slot screen
+ * for a name starting with `slot:` ([ScreenContentFactory]). It tells its appearance through its content, which owns
+ * the appearance record (`AppearanceDispatcher`). Its view, and with it its content, is made when the layout that holds
+ * it is made, before it appears: a root's surfaces start as its view joins the window (`setRoot` step 2).
+ *
+ * The content fills the screen's view; the view keeps the room for the bars as its margins and what the system
+ * covers as its padding ([ScreenFrame]), and its presenter (`ComponentPresenter`) paints it. While the view shows, each
+ * layout of the window measures the screen's safe area and regions into the stores the hooks of JavaScript read
+ * ([updateSafeArea]).
+ */
+class ComponentViewController(
+    activity: Activity,
+    childRegistry: ChildControllersRegistry,
+    id: String,
+    /** The name the screen was registered with in JavaScript, `slot:` included. */
+    val componentName: String,
+    presenter: Presenter,
+    initialOptions: Options,
+) : ChildController<ComponentLayout>(activity, childRegistry, id, presenter, initialOptions) {
+    /** The room of the screen's view for the bars and the system. */
+    internal val frame = ScreenFrame(this, consumesInsets = false)
+
+    init {
+        // The screen owns its id from now on, before its content exists: what an earlier screen with the id told of
+        // its readiness (a root made again with the same ids) isn't this one's.
+        ScreenReadiness.remove(id)
+    }
+
+    override val currentComponentName: String
+        get() = componentName.removePrefix(ScreenContentFactory.SLOT_PREFIX)
+
+    override fun createView(): ComponentLayout {
+        val layout = ComponentLayout(activity, ScreenContentFactory.create(activity, id, componentName))
+        frame.attach(layout)
+        frame.onInsetsApplied = ::applyBackgroundAgain
+        layout.onAttached = { frame.onAttached(layout) }
+        layout.onWindowLayout = ::updateSafeArea
+        return layout
+    }
+
+    /** What the screen shows, once its view is made: what a command waits for before the screen comes in. */
+    internal val content: IReactView?
+        get() = peekView()?.reactView
+
+    /**
+     * A command's wait for the content ended at its limit: the content counts as mounted, and the events held for it go
+     * at once.
+     */
+    internal fun markContentReady() {
+        when (val content = content) {
+            is ReactView -> content.appearance.markReady()
+            is SlotScreenView -> content.appearance.markReady()
+            else -> Unit
+        }
+    }
+
+    // The bar's buttons send ANN.NavigationButtonPressed with the screen's own id and JavaScript, whatever its content
+    // (a React root, a slot).
+    override fun sendOnNavigationButtonPressed(buttonId: String) =
+        AppearanceDispatcher.navigationButtonPressed(this, buttonId)
+
+    // The screen shows with its options, and the layout around takes its part of them (its bar, its FAB, its tabs).
+    override fun applyOptions(options: Options) {
+        presenter.applyOptions(this, options)
+        performOnParentController { it.applyChildOptions(options, this) }
+    }
+
+    override fun getTopInset(): Int = frame.topRoom()
+
+    override fun applyTopInset() = frame.applyRoom()
+
+    override fun getBottomInset(): Int = frame.bottomRoom()
+
+    override fun applyBottomInset() = frame.applyRoom()
+
+    // A screen that appears has its view: will and did appear go through it, made when needed; its options apply as
+    // it starts to appear. A screen whose view isn't made has shown nothing, so disappear makes none. A destroyed
+    // screen tells nothing.
+    override fun onViewWillAppear() {
+        if (isDestroyed) return
+        super.onViewWillAppear()
+        val layout = view
+        applyOptions(resolveCurrentOptions(DefaultOptions.current))
+        layout.reactView.sendComponentWillStart(ComponentType.Component)
+        // The components of its bar appear with it.
+        findParentStack()?.barScreenWillAppear(this)
+    }
+
+    override fun onViewDidAppear() {
+        if (isDestroyed) return
+        view.reactView.sendComponentStart(ComponentType.Component)
+        findParentStack()?.barScreenDidAppear(this)
+        super.onViewDidAppear()
+    }
+
+    // The system UI follows what is on top now (a modal or an overlay that goes).
+    override fun onViewDisappear() {
+        if (isDestroyed) return
+        peekView()?.reactView?.sendComponentStop(ComponentType.Component)
+        findParentStack()?.barScreenDisappeared(this)
+        super.onViewDisappear()
+        SystemUiOwner.of(activity)?.invalidate()
+    }
+
+    /**
+     * The screen starts to leave (`blurOnUnmount`): with `blurOnUnmount` in its resolved options, the view that has the
+     * activity's focus lets go of it, and a field of React Native hides the keyboard as it does.
+     */
+    override fun onLeaveStarted() {
+        if (isDestroyed) return
+        if (resolveCurrentOptions(DefaultOptions.current).blurOnUnmount.isTrue) ScreenFocus.blur(activity)
+    }
+
+    /**
+     * Measures the screen's safe area and its regions into the stores: what the bars and the system cover of the React
+     * content, in dp ([ScreenSafeArea.insets]), the part of it its safe area view keeps the content off
+     * ([ScreenSafeArea.paddedEdges]), and the folds and the cutout over it. Only while the screen's view shows, never
+     * while a layout is on its way: the next layout of the window measures then; a screen prepared for a push measures
+     * as its stack laid it out. A screen under another in its stack keeps what it has. Main thread.
+     */
+    internal fun updateSafeArea() {
+        if (isDestroyed) return
+        val layout = peekView() ?: return
+        val parent = parentController
+        val content = layout.reactView.asView()
+        // A screen prepared for a push measures too, though it doesn't show, as its stack laid it out.
+        val prepared = parent?.measuresThoughNotShown(this) == true
+        val measures = ScreenSafeArea.measuresNow(
+            shown = layout.isShown || prepared,
+            layoutPending = !prepared && isLayoutPending(content),
+            topOfStack = parent?.isTopOfStack(this) ?: true,
+            hasSafeArea = ScreenInsets.padding(id) != null,
+        )
+        if (!measures) return
+        val windowInsets = ViewCompat.getRootWindowInsets(content) ?: return
+        val window = content.rootView ?: return
+        val system = windowInsets.getInsets(SYSTEM_EDGES)
+        val place = ScreenSafeArea.placeInWindow(stepsToWindow(content), content.width, content.height)
+        val insets = ScreenSafeArea.insets(
+            windowWidth = window.width,
+            windowHeight = window.height,
+            system = ScreenSafeArea.Box(system.left, system.top, system.right, system.bottom),
+            root = place,
+            headerBottom = parent?.headerBottomOf(this),
+            tabsTop = parent?.tabsTopOf(this),
+            density = activity.resources.displayMetrics.density,
+        )
+        val edges = ScreenSafeArea.paddedEdges(
+            safeAreaEdges = resolveCurrentOptions(DefaultOptions.current).layout.safeAreaEdges,
+            topFree = parent?.leavesTopEdgeFree(this) == true,
+            bottomFree = parent?.leavesBottomEdgeFree(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)
+    }
+
+    // A layout asked for on the content or on a view around it: it isn't in its place yet.
+    private fun isLayoutPending(content: View): Boolean {
+        var current: View? = content
+        while (current != null) {
+            if (current.isLayoutRequested) return true
+            current = current.parent as? View
+        }
+        return false
+    }
+
+    // The views from the content up to the window, each with its place and its parent's scroll, at rest as [RestPlace]
+    // counts them, the same rule as the header's bottom and the tabs' top. A child that moves counts where it rests
+    // (`ChildOffsetFromRest`): a side menu's drawer where the open menu is, a sliding pane where it is open: the split
+    // view gives the pane's distance from its open place (`ChildOffsetFromRest`), which takes the pane's move away.
+    private fun stepsToWindow(content: View): List<ScreenSafeArea.Step> {
+        val steps = ArrayList(RestPlace.stepsToWindow(content))
+        val offset = offsetFromRest()
+        if (offset != 0) steps += ScreenSafeArea.Step(offset, 0, 0, 0)
+        return steps
+    }
+
+    // How far the layouts around move this screen from where it rests, along the width: the sum of what each layout
+    // that moves a child gives for the child on the way to this screen.
+    private fun offsetFromRest(): Int {
+        var offset = 0
+        var node: ViewController<*> = this
+        var parent = parentController
+        while (parent != null) {
+            if (parent is ChildOffsetFromRest) offset += parent.childOffsetFromRest(node)
+            node = parent
+            parent = parent.parentController
+        }
+        return offset
+    }
+
+    // New window insets: the status bar's band of the background may have changed.
+    private fun applyBackgroundAgain() {
+        (presenter as? ComponentPresenter)?.applyBackground(this, resolveCurrentOptions(DefaultOptions.current))
+    }
+
+    /**
+     * Destroys the screen once: it disappears when it showed (its `ANN.ScreenPopped`, when it left a stack, went
+     * before), leaves the registry, its content stops — a view never made isn't made for it, and the screen counts as
+     * destroyed all the same —, its view stops listening to the window and to the scroll of its lists and leaves its
+     * parent, the link to its layout breaks, and what the synchronous methods kept for it goes, unless a later screen
+     * with the same id is in the registry: that is its own then.
+     */
+    override fun destroy() {
+        if (isDestroyed) return
+        onViewDisappear()
+        super.destroy()
+        // The layout it is in lets go of what it kept for it while its view is still there: the components of its bar
+        // stop before its own surface, its search goes, its stack forgets its FAB.
+        performOnParentController { it.onChildDestroyed(this) }
+        peekView()?.let { layout ->
+            layout.destroy()
+            (layout.parent as? ViewGroup)?.removeView(layout)
+        }
+        setParentController(null)
+        if (isIdTakenByAnother) return
+        ScreenInsets.remove(id)
+        ScreenRegions.remove(id)
+        ArrangementStates.remove(id)
+        ScreenReadiness.remove(id)
+    }
+
+    private companion object {
+        // What the system covers at the edges of the window: its bars and the cutout.
+        val SYSTEM_EDGES = WindowInsetsCompat.Type.systemBars() or WindowInsetsCompat.Type.displayCutout()
+    }
+}

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

@@ -0,0 +1,65 @@
+package dev.apexnative.navigation.viewcontrollers.component
+
+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.
+ */
+internal interface Readiness {
+    /** The content of [screen] rendered; a screen without content to wait for is ready. */
+    fun isReady(screen: ViewController<*>): Boolean
+
+    /** Calls [listener] once [screen] is ready; it can't be taken back, so the waiter guards it itself. */
+    fun whenReady(screen: ViewController<*>, listener: () -> Unit)
+
+    /** The wait ended at its limit: the content of [screen] counts as mounted. */
+    fun markReady(screen: ViewController<*>)
+
+    /**
+     * Whether the readiness store knows nothing of [screen] now: no safe area view has reported its id (none mounted
+     * yet, or it has none). Such a screen that renders `null` would never be ready, so a wait without a limit counts it
+     * as ready after a while; once a safe area view reported, it reports `null` too.
+     */
+    fun isRenderUnknown(screen: ViewController<*>): Boolean = false
+
+    /**
+     * Whether the components of the bar over [screen] that a wait counts have drawn: its stack's answer
+     * (`StackController.areBarComponentsDrawn`); a screen out of a stack has none.
+     */
+    fun areBarComponentsReady(screen: ViewController<*>): Boolean = true
+
+    /** Calls [listener] once [areBarComponentsReady]; it can't be taken back, so the waiter guards it itself. */
+    fun whenBarComponentsReady(screen: ViewController<*>, listener: () -> Unit) = listener()
+}
+
+/**
+ * The readiness of the core's screens: a React screen's content is ready when it rendered (`IReactView.isReady`); a
+ * screen whose view isn't made yet, and a node without React content (a native screen), are ready at once. A wait
+ * makes the screen's view before it asks.
+ */
+internal object ContentReadiness : Readiness {
+    override fun isReady(screen: ViewController<*>): Boolean =
+        (screen as? ComponentViewController)?.content?.isReady() ?: true
+
+    override fun whenReady(screen: ViewController<*>, listener: () -> Unit) {
+        val content = (screen as? ComponentViewController)?.content ?: return listener()
+        content.whenReady { listener() }
+    }
+
+    override fun markReady(screen: ViewController<*>) {
+        (screen as? ComponentViewController)?.markContentReady()
+    }
+
+    override fun isRenderUnknown(screen: ViewController<*>): Boolean =
+        screen is ComponentViewController && ScreenReadiness.isContentRendered(screen.id) == null
+
+    override fun areBarComponentsReady(screen: ViewController<*>): Boolean =
+        screen.findParentStack()?.areBarComponentsDrawn(screen) ?: true
+
+    override fun whenBarComponentsReady(screen: ViewController<*>, listener: () -> Unit) {
+        val stack = screen.findParentStack() ?: return listener()
+        stack.whenBarComponentsDrawn(screen, listener)
+    }
+}

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

@@ -0,0 +1,231 @@
+package dev.apexnative.navigation.viewcontrollers.component
+
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+import dev.apexnative.navigation.viewcontrollers.parent.ParentController
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * The one wait for screens to render before they come in: a new root, a push or a `setStackRoot` that waits. It waits
+ * for the content of its screens, within [limitMillis] or as long as it takes, and marks the content not ready at the
+ * limit as mounted; the components of the bars over the screens drawn in advance join it as [bar] says. Then [onEnd],
+ * once. [cancel] ends it without [onEnd]; [retake] waits for other screens with the same limit, and a bar phase that
+ * runs goes on.
+ *
+ * Screens made with the layer that don't show when it shows (the unselected tabs of `together`) count too, for their
+ * content only and only within their first [UNSEEN_LIMIT_MILLIS]: a screen the user doesn't see never holds a wait
+ * 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.
+ */
+internal class RenderWait(
+    private val readiness: Readiness,
+    private val scheduler: AppearanceDispatcher.Scheduler,
+    /** At most this long for the content (and the bar's components within it); none: as long as it takes. */
+    private val limitMillis: Long?,
+    private val bar: Bar,
+    /**
+     * Without a limit, a screen the readiness store still knows nothing of after [UNKNOWN_CONTENT_MILLIS] counts as
+     * ready (`Readiness.isRenderUnknown`): it is marked and the wait ends.
+     */
+    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() },
+    /** 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,
+) {
+    /** How the components of the bars drawn in advance count. */
+    enum class Bar {
+        /** They don't. */
+        None,
+
+        /** Within the same limit as the content: the wait ends when both are ready, or at the limit. */
+        WithinLimit,
+
+        /** In a phase of their own once the content is ready, [BAR_PHASE_MILLIS] at most; its end marks nothing. */
+        AfterContent,
+    }
+
+    private var screens: List<ViewController<*>> = emptyList()
+    private var unseen: List<ViewController<*>> = emptyList()
+    // The unseen screens no longer count: their limit passed.
+    private var unseenDone = true
+    private var cancelUnseenTimer: (() -> Unit)? = null
+    private var waiting = false
+    // The signals of the screens waited for now: they can't be taken back, so a newer set (or the end) wins.
+    private var token: Any? = null
+    // The limit of the content, or the time after which content of unknown readiness counts.
+    private var cancelContentTimer: (() -> Unit)? = null
+    private var cancelBarPhase: (() -> Unit)? = null
+
+    /** The wait runs: it neither ended nor was cancelled. */
+    val isWaiting: Boolean
+        get() = waiting
+
+    /** The screens waited for now. */
+    val waitedScreens: List<ViewController<*>>
+        get() = screens
+
+    /**
+     * 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.
+     */
+    fun start(screens: List<ViewController<*>>, unseen: List<ViewController<*>> = emptyList()) {
+        this.screens = screens
+        this.unseen = unseen
+        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()
+        cancelContentTimer = when {
+            limitMillis != null -> scheduler.schedule(limitMillis) { step { atLimit() } }
+            countsUnknownContent -> scheduler.schedule(UNKNOWN_CONTENT_MILLIS) { step { atUnknownContentLimit() } }
+            else -> null
+        }
+        startUnseenLimit()
+        await()
+    }
+
+    /**
+     * The screens to wait for changed (a command changed a top of the layer that waits): the wait goes on for
+     * [screens], with the limit that runs and a bar phase that runs; with all of them ready it ends now.
+     */
+    fun retake(screens: List<ViewController<*>>, unseen: List<ViewController<*>> = this.unseen) {
+        if (!waiting) return
+        this.screens = screens
+        this.unseen = unseen
+        token = Any()
+        await()
+    }
+
+    /** Ends the wait without [onEnd]: its timers stop, and the signals still to come do nothing. */
+    fun cancel() {
+        waiting = false
+        token = null
+        cancelContentTimer?.invoke()
+        cancelContentTimer = null
+        cancelBarPhase?.invoke()
+        cancelBarPhase = null
+        cancelUnseenTimer?.invoke()
+        cancelUnseenTimer = null
+    }
+
+    // The unseen screens count within their own limit, unless the wait's limit ends it before.
+    private fun startUnseenLimit() {
+        if (unseenDone || cancelUnseenTimer != null) return
+        if (limitMillis != null && limitMillis <= UNSEEN_LIMIT_MILLIS) return
+        cancelUnseenTimer = scheduler.schedule(UNSEEN_LIMIT_MILLIS) { step { atUnseenLimit() } }
+    }
+
+    // Their time is up: what of them isn't ready counts as mounted, and the wait goes on for the screens that show.
+    private fun atUnseenLimit() {
+        cancelUnseenTimer = null
+        if (!waiting || unseenDone) return
+        unseen.filterNot(readiness::isReady).forEach(readiness::markReady)
+        unseenDone = true
+        if (contentReady() && cancelBarPhase == null) contentDone()
+    }
+
+    // The content of every screen ready: on to the bars; else the signals of those not ready.
+    private fun await() {
+        if (contentReady()) return contentDone()
+        val token = token
+        for (screen in screens + countedUnseen()) {
+            if (this.token !== token) return
+            if (readiness.isReady(screen)) continue
+            readiness.whenReady(screen) {
+                deliver {
+                    step { if (waiting && this.token === token && contentReady()) contentDone() }
+                }
+            }
+        }
+    }
+
+    // The content is ready: the wait ends, or goes on for the bars' components drawn in advance — within the limit
+    // that runs, or in a phase of their own after the content.
+    private fun contentDone() {
+        if (bar == Bar.None || barsReady()) return finish()
+        val token = Any()
+        this.token = token
+        if (bar == Bar.AfterContent && cancelBarPhase == null) {
+            cancelContentTimer?.invoke()
+            cancelContentTimer = null
+            // The bars' components not drawn in time: the screens come as they are, nothing is marked.
+            cancelBarPhase = scheduler.schedule(BAR_PHASE_MILLIS) { step { if (waiting) finish() } }
+        }
+        for (screen in screens) {
+            if (this.token !== token) return
+            if (readiness.areBarComponentsReady(screen)) continue
+            readiness.whenBarComponentsReady(screen) {
+                deliver {
+                    step { if (waiting && this.token === token && barsReady()) finish() }
+                }
+            }
+        }
+    }
+
+    // Not rendered in time: the screens come as they are, and the events held for their content go now; the bars'
+    // components are not marked (their own events stay with the dispatcher).
+    private fun atLimit() {
+        if (!waiting) return
+        (screens + countedUnseen()).filterNot(readiness::isReady).forEach(readiness::markReady)
+        finish()
+    }
+
+    // Without a limit: content the readiness store still knows nothing of counts as ready, as content that renders
+    // `null` would never report; once a safe area view reported the id, the wait has no limit.
+    private fun atUnknownContentLimit() {
+        if (!waiting || contentReady()) return
+        val notReady = screens.filterNot(readiness::isReady)
+        if (!notReady.all(readiness::isRenderUnknown)) return
+        notReady.forEach(readiness::markReady)
+        finish()
+    }
+
+    private fun finish() {
+        if (!waiting) return
+        cancel()
+        onEnd()
+    }
+
+    private fun contentReady(): Boolean = screens.all(readiness::isReady) && countedUnseen().all(readiness::isReady)
+
+    private fun countedUnseen(): List<ViewController<*>> = if (unseenDone) emptyList() else unseen
+
+    private fun barsReady(): Boolean = screens.all(readiness::areBarComponentsReady)
+
+    companion object {
+        /** How long a bar phase after the content lasts at most. */
+        const val BAR_PHASE_MILLIS = 500L
+
+        /**
+         * After how long, from the start of a wait without a limit, content whose id no safe area view reported yet
+         * counts as ready ([countsUnknownContent]).
+         */
+        const val UNKNOWN_CONTENT_MILLIS = 1000L
+
+        /** How long the content of the screens that don't show counts at most, from the start of a wait. */
+        const val UNSEEN_LIMIT_MILLIS = 500L
+
+        /**
+         * The screens that show when [node] shows, which a wait for it waits for: [node] itself, or down through the
+         * waited children of its layouts at every level (`ParentController.waitedChildren`).
+         */
+        fun waitedScreens(node: ViewController<*>): List<ViewController<*>> =
+            if (node is ParentController<*>) node.waitedChildren().flatMap(::waitedScreens) else listOf(node)
+
+        /**
+         * The screens made with [node] that don't show when it shows, which a wait for it counts within
+         * [UNSEEN_LIMIT_MILLIS] (`ParentController.waitedUnseenChildren`), at every level; their bars' components
+         * don't count (only the bar of the stack the layout shows).
+         */
+        fun unseenScreens(node: ViewController<*>): List<ViewController<*>> {
+            if (node !is ParentController<*>) return emptyList()
+            return node.waitedUnseenChildren().flatMap { waitedScreens(it) + unseenScreens(it) } +
+                node.waitedChildren().flatMap(::unseenScreens)
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+package dev.apexnative.navigation.viewcontrollers.component
+
+import android.view.View
+import dev.apexnative.navigation.viewcontrollers.modal.SheetContainer
+
+/**
+ * Where a view is in the window from layout only: the places of the views up to the window, each less its parent's
+ * scroll, without the translations of animations, and a sheet's container where the sheet rests, not where a drag took
+ * it. The one rule for the three parts of a screen's safe area: the screen's React root, the bottom of the stack's
+ * header and the top of the tabs, so they count the same place while something around them moves. Main thread only.
+ */
+internal object RestPlace {
+    /** The views from [view] up to the window, each with its place in its parent and its parent's scroll. */
+    fun stepsToWindow(view: View): List<ScreenSafeArea.Step> {
+        val steps = ArrayList<ScreenSafeArea.Step>()
+        var current: View = view
+        while (true) {
+            val parent = current.parent as? View
+            val top = if (current is SheetContainer) SheetContainer.restTop(current.top, current.shift) else current.top
+            steps += ScreenSafeArea.Step(current.left, top, parent?.scrollX ?: 0, parent?.scrollY ?: 0)
+            current = parent ?: break
+        }
+        return steps
+    }
+
+    /** [view]'s top in the window, at rest. */
+    fun topInWindow(view: View): Int = ScreenSafeArea.placeInWindow(stepsToWindow(view), view.width, view.height).top
+}