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

package/android/src/main/java/dev/apexnative/navigation/utils/WindowFolds.kt

@@ -0,0 +1,107 @@
+package dev.apexnative.navigation.utils
+
+import android.app.Activity
+import android.graphics.Rect
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.window.layout.FoldingFeature
+import androidx.window.layout.WindowInfoTracker
+import androidx.window.layout.WindowLayoutInfo
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.util.WeakHashMap
+
+/**
+ * The folds of a foldable in the activity's window (androidx.window `WindowLayoutInfo`), collected once for the
+ * activity while it is started. None on a device without a fold, and before the first value, which comes after the
+ * activity starts. On a change the listeners hear it and the window lays out again, so each screen measures its
+ * reserved regions. Main thread only.
+ */
+class WindowFolds private constructor(private val activity: Activity) : DefaultLifecycleObserver {
+    /** A fold of the window: its bounds in window pixels, and how it lies. */
+    data class Fold(
+        val bounds: Rect,
+        /** It runs from top to bottom, between a left and a right part. */
+        val vertical: Boolean,
+        /** It divides the window into two parts the user sees apart (`isSeparating`). */
+        val separating: Boolean,
+        /** The device is partly folded at it (`HALF_OPENED`); flat otherwise. */
+        val halfOpened: Boolean,
+        /** It hides what is under it (`occlusionType FULL`), as the hinge between two displays. */
+        val occludes: Boolean,
+    )
+
+    /** The folds of the window now. */
+    var folds: List<Fold> = emptyList()
+        private set
+
+    /** The first value came: [folds] tells the window as it is, also when it has none. */
+    var hasInfo = false
+        private set
+
+    private val listeners = LinkedHashSet<Runnable>()
+    private val scope = MainScope()
+    private var collecting: Job? = null
+
+    /** Calls [listener] on every change of [folds]. */
+    fun addListener(listener: Runnable) {
+        listeners += listener
+    }
+
+    fun removeListener(listener: Runnable) {
+        listeners -= listener
+    }
+
+    override fun onStart(owner: LifecycleOwner) {
+        collecting = scope.launch {
+            WindowInfoTracker.getOrCreate(activity).windowLayoutInfo(activity).collect { onInfo(it) }
+        }
+    }
+
+    override fun onStop(owner: LifecycleOwner) {
+        collecting?.cancel()
+        collecting = null
+    }
+
+    override fun onDestroy(owner: LifecycleOwner) {
+        owner.lifecycle.removeObserver(this)
+        scope.cancel()
+        instances.remove(activity)
+    }
+
+    private fun onInfo(info: WindowLayoutInfo) {
+        val next = info.displayFeatures.filterIsInstance<FoldingFeature>().map {
+            Fold(
+                bounds = Rect(it.bounds),
+                vertical = it.orientation == FoldingFeature.Orientation.VERTICAL,
+                separating = it.isSeparating,
+                halfOpened = it.state == FoldingFeature.State.HALF_OPENED,
+                occludes = it.occlusionType == FoldingFeature.OcclusionType.FULL,
+            )
+        }
+        val first = !hasInfo
+        hasInfo = true
+        if (next == folds && !first) return
+        folds = next
+        listeners.toList().forEach { it.run() }
+        // A fold that opens halfway changes no size: nothing would lay out, and the screens keep their old regions.
+        activity.window?.peekDecorView()?.requestLayout()
+    }
+
+    companion object {
+        private val instances = WeakHashMap<Activity, WindowFolds>()
+
+        /** The folds of the window of [activity], collected from now on; null for an activity without a lifecycle. */
+        @JvmStatic
+        fun of(activity: Activity?): WindowFolds? {
+            val owner = activity as? LifecycleOwner ?: return null
+            if (activity.isDestroyed) return null
+            return instances.getOrPut(activity) {
+                // An observer added to a started activity hears onStart at once: the collection starts now.
+                WindowFolds(activity).also { owner.lifecycle.addObserver(it) }
+            }
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/ArrangementController.kt

@@ -0,0 +1,258 @@
+package dev.apexnative.navigation.viewcontrollers.arrangement
+
+import android.animation.Animator
+import android.annotation.SuppressLint
+import android.app.Activity
+import android.graphics.Rect
+import android.view.ViewGroup
+import androidx.window.layout.WindowMetricsCalculator
+import dev.apexnative.navigation.NavigationActivity
+import dev.apexnative.navigation.options.DefaultOptions
+import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.react.ArrangementStates
+import dev.apexnative.navigation.utils.SystemUiUtils
+import dev.apexnative.navigation.utils.WindowFolds
+import dev.apexnative.navigation.viewcontrollers.child.ChildController
+import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
+import dev.apexnative.navigation.viewcontrollers.component.ComponentViewController
+import dev.apexnative.navigation.viewcontrollers.component.ScreenFrame
+import dev.apexnative.navigation.viewcontrollers.parent.KeepsStatusBarRoom
+import dev.apexnative.navigation.viewcontrollers.parent.OptionsScreen
+import dev.apexnative.navigation.viewcontrollers.parent.ParentController
+import dev.apexnative.navigation.viewcontrollers.parent.ScreensLeavingWithNode
+import dev.apexnative.navigation.viewcontrollers.parent.ShownChildren
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.component.ComponentLayout
+
+/**
+ * A pair of screens (`defineArrangement`, or a screen with `arrangement`), React or native: one entry of a stack, side
+ * by side or one above the other (`split`), or the primary over the secondary (`overlay`), as the size of the window,
+ * the shape of the pair and the fold of a foldable decide ([ArrangementPlanner]). The current child is the primary:
+ * the top bar, the status bar, the navigation bar and the animations of the push take its options, and the
+ * secondary's have no effect there. A React screen knows how the pair lies (`useArrangement`). Both appear and
+ * disappear with the pair; a secondary that a small window or the axes leave out of the window disappears, and
+ * appears again when the pair has room for it.
+ */
+class ArrangementController internal constructor(
+    activity: Activity,
+    childRegistry: ChildControllersRegistry,
+    id: String,
+    presenter: Presenter,
+    initialOptions: Options,
+    private val definition: ArrangementDefinition,
+    val primary: ChildController<*>,
+    val secondary: ChildController<*>,
+) : ParentController<ArrangementLayout>(activity, childRegistry, id, presenter, initialOptions),
+    OptionsScreen, ScreensLeavingWithNode, KeepsStatusBarRoom {
+    private val folds = WindowFolds.of(activity)
+    // A change of the folds lays the pair out again: a device folded halfway moves the boundary onto the fold.
+    private val onFoldsChanged = Runnable { peekView()?.requestLayout() }
+    // The screens told they appeared, until they leave the window, and the moves told in the dispatcher's order; the
+    // pair appeared (the push or the pop that shows it ended), until it disappears.
+    private val shownChildren = ShownChildren(::visibleChildren)
+    // How the pair lies in a window its size, until its first layout: which screens it will show.
+    private val initialPlan: ArrangementPlan
+    // The pair puts its secondary in the window, as the navigator was last told.
+    private var showsSecondary: Boolean
+
+    private val navigator
+        get() = (activity as? NavigationActivity)?.navigator
+
+    init {
+        primary.parentController = this
+        secondary.parentController = this
+        // Each screen renders first with the state of a pair the size of the window; the pair's layout tells a change.
+        initialPlan = firstPlan()
+        showsSecondary = initialPlan.secondary != null
+        publish(initialPlan, notify = false)
+    }
+
+    override fun getChildControllers(): Collection<ViewController<*>> = listOf(primary, secondary)
+
+    override fun getCurrentChild(): ViewController<*> = primary
+
+    /**
+     * The screens the pair shows: both, or the primary alone while a small window or the axes leave the secondary out
+     * of the window; before the pair's first layout as a pair the size of the window lies.
+     */
+    override fun visibleChildren(): List<ViewController<*>> {
+        val plan = peekView()?.plan ?: initialPlan
+        return if (plan.secondary != null) listOf(primary, secondary) else listOf(primary)
+    }
+
+    // A wait for the pair waits for the screens it puts in the window: a secondary out of it never renders.
+    override fun waitedChildren(): List<ViewController<*>> = visibleChildren()
+
+    // A pair laid out unseen (in a made tab that isn't selected, in a closed side of a side menu) asks its parent: its
+    // screens measure their safe area there too, as a stack's top does.
+    override fun measuresThoughNotShown(child: ViewController<*>): Boolean =
+        parentController?.measuresThoughNotShown(this) == true
+
+    // The capabilities the core asks for: the pair's options are the primary's, both screens leave a stack with it, and
+    // the pair keeps the room of the status bar for its screens.
+    override val optionsScreen: ViewController<*>
+        get() = primary
+
+    override val screensLeavingWithNode: List<ViewController<*>>
+        get() = listOf(primary, secondary)
+
+    override fun createView(): ArrangementLayout {
+        folds?.addListener(onFoldsChanged)
+        val primaryView = primary.getView()
+        val secondaryView = secondary.getView()
+        val folds = { folds?.folds.orEmpty() }
+        return if (primaryView is ComponentLayout) {
+            ReactArrangementLayout(
+                activity, definition, primaryView, secondaryView, folds, ::isLargeWindow, ::onArranged,
+            )
+        } else {
+            ArrangementLayout(activity, definition, primaryView, secondaryView, folds, ::isLargeWindow, ::onArranged)
+        }
+    }
+
+    // Large enough for a pair: Material's window classes, neither compact in width nor in height. A phone is compact
+    // both ways (in landscape in height), a tablet or an unfolded foldable is not. The activity's window, not the pair.
+    private fun isLargeWindow(): Boolean {
+        val window = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity)
+        return window.widthDp >= LARGE_WIDTH_DP && window.heightDp >= LARGE_HEIGHT_DP
+    }
+
+    private fun firstPlan(): ArrangementPlan {
+        val bounds = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity).bounds
+        val window = Rect(0, 0, bounds.width(), bounds.height())
+        val fold = folds?.folds.orEmpty().firstNotNullOfOrNull { it.across(window) }
+        // The direction moves the frames only, not the state.
+        return ArrangementPlanner.plan(definition, window.width(), window.height(), false, fold, isLargeWindow())
+    }
+
+    private fun onArranged(plan: ArrangementPlan) {
+        publish(plan, notify = true)
+        val withSecondary = plan.secondary != null
+        val shownChanged = withSecondary != showsSecondary
+        showsSecondary = withSecondary
+        // After the window's layout, out of its pass: the screens that came into the window or left it, then a layer
+        // or a stack that waits to show the pair waits for the screens it shows now.
+        getView().post {
+            updateAppeared()
+            if (shownChanged && !isDestroyed) navigator?.shownScreensChanged(this)
+        }
+    }
+
+    // The state of the React screens of the pair (useArrangement); a native screen has no hook to read it.
+    private fun publish(plan: ArrangementPlan, notify: Boolean) {
+        val layout = plan.layout.jsName
+        val overlay = plan.layout == ArrangementPlan.Layout.OVERLAY
+        val single = plan.layout == ArrangementPlan.Layout.SINGLE
+        if (primary is ComponentViewController) {
+            val state = ArrangementStates.State(PRIMARY, layout, front = overlay, hidden = false)
+            ArrangementStates.set(activity, primary.id, state, notify)
+        }
+        if (secondary is ComponentViewController) {
+            val state = ArrangementStates.State(SECONDARY, layout, front = false, hidden = single)
+            ArrangementStates.set(activity, secondary.id, state, notify)
+        }
+    }
+
+    // Once the pair appeared, the screens that came into the window appear and those that left it disappear: no view
+    // of the core tells a screen it left the window. The plan decides which are in it ([visibleChildren]), not the
+    // views, which show nothing while the activity is stopped or before the pair's first layout.
+    private fun updateAppeared() {
+        if (!isDestroyed) shownChildren.moved()
+    }
+
+    // The screens its appearance told they appeared ([visibleChildren]): one its first layout leaves out of the
+    // window disappears.
+    override fun onViewWillAppear() {
+        super.onViewWillAppear()
+        shownChildren.containerWillAppear()
+    }
+
+    override fun onViewDidAppear() {
+        shownChildren.containerDidAppear()
+        super.onViewDidAppear()
+        updateAppeared()
+    }
+
+    override fun onViewDisappear() {
+        shownChildren.containerDisappeared()
+        super.onViewDisappear()
+    }
+
+    override fun start() {
+        primary.start()
+        secondary.start()
+    }
+
+    override fun sendOnNavigationButtonPressed(buttonId: String) = primary.sendOnNavigationButtonPressed(buttonId)
+
+    override fun getPushAnimations(appearingOptions: Options): Animator? = primary.getPushAnimations(appearingOptions)
+
+    override fun getPopAnimations(appearingOptions: Options, disappearingOptions: Options): Animator? =
+        primary.getPopAnimations(appearingOptions, disappearingOptions)
+
+    // The pair's options are the primary's: what its stack merges into its entry (the back button, the options of a
+    // pop) and a mergeOptions with the pair's id go to the primary, which tells the layouts around as a screen does.
+    @SuppressLint("MissingSuperCall")
+    override fun mergeOptions(options: Options) = primary.mergeOptions(options)
+
+    // Only the primary's options reach the layouts around. The secondary that appears clears theirs first, as every
+    // screen does (ViewController.onViewWillAppear): they are read again only as options are applied, which the
+    // primary does.
+    override fun applyChildOptions(options: Options, child: ViewController<*>) {
+        if (child != primary) return
+        super.applyChildOptions(options, child)
+        performOnParentController { it.applyChildOptions(options, this) }
+    }
+
+    override fun mergeChildOptions(options: Options, child: ViewController<*>) {
+        if (child != primary) return
+        super.mergeChildOptions(options, child)
+        performOnParentController { it.mergeChildOptions(options, this) }
+    }
+
+    // The pair keeps clear of the bar and the tabs as one, with the margins of its own view: on each screen, the bar's
+    // room would cut the lower screen of a pair one above the other, and the tabs' room the upper one. Its screens
+    // have no margins; they apply the pair's room as theirs would apply.
+    override fun applyTopInset() {
+        setMargins(top = getTopInset())
+    }
+
+    // The screens' rule, with the options the pair shows with (its primary's).
+    override fun getTopInset(): Int {
+        val options = resolveShownOptions(DefaultOptions.current)
+        return ScreenFrame.topRoomOf(this, options, SystemUiUtils.getStatusBarHeight(activity))
+    }
+
+    override fun applyBottomInset() {
+        setMargins(bottom = getBottomInset())
+    }
+
+    private fun setMargins(top: Int? = null, bottom: Int? = null) {
+        val view = peekView() ?: return
+        val params = view.layoutParams as? ViewGroup.MarginLayoutParams ?: return
+        if ((top ?: params.topMargin) == params.topMargin && (bottom ?: params.bottomMargin) == params.bottomMargin) {
+            return
+        }
+        top?.let { params.topMargin = it }
+        bottom?.let { params.bottomMargin = it }
+        view.requestLayout()
+    }
+
+    override fun destroy() {
+        // The stack keeps the bar's title, buttons and search by the view of its screen on top: they go with the pair.
+        if (!isDestroyed && peekView() != null) performOnParentController { it.onChildDestroyed(this) }
+        folds?.removeListener(onFoldsChanged)
+        ArrangementStates.remove(primary.id)
+        ArrangementStates.remove(secondary.id)
+        shownChildren.containerDisappeared()
+        super.destroy()
+    }
+
+    private companion object {
+        const val PRIMARY = "primary"
+        const val SECONDARY = "secondary"
+        const val LARGE_WIDTH_DP = 600f
+        const val LARGE_HEIGHT_DP = 480f
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/ArrangementDefinition.kt

@@ -0,0 +1,57 @@
+package dev.apexnative.navigation.viewcontrollers.arrangement
+
+import org.json.JSONObject
+
+/**
+ * How a pair of screens lies (`defineArrangement`), from the `data` of its layout node. JavaScript sends every value
+ * with its default filled in; a value it doesn't know takes the default too.
+ */
+data class ArrangementDefinition(
+    val style: Style,
+    val axes: Axes,
+    /** `split`: the primary's share along the split, 0–1, where a fold doesn't decide. */
+    val fraction: Float,
+    /** `overlay`: the edge the primary takes when the pair goes side by side at a fold. */
+    val primaryEdge: Edge,
+    /** What a window too small for a pair shows. */
+    val compact: Compact,
+) {
+    /** `split`: side by side or one above the other; `overlay`: the primary over the secondary. */
+    enum class Style { SPLIT, OVERLAY }
+
+    /** `horizontal`: side by side only; `vertical`: one above the other only. */
+    enum class Axes { HORIZONTAL, VERTICAL, BOTH }
+
+    enum class Edge { LEADING, TRAILING, TOP, BOTTOM }
+
+    /** `primary`: the primary alone; `pair`: the pair, laid out as in a large window. */
+    enum class Compact { PRIMARY, PAIR }
+
+    /** The pair may lie side by side ([sideBySide]) or one above the other (not). */
+    fun allows(sideBySide: Boolean): Boolean = axes == Axes.BOTH || (axes == Axes.HORIZONTAL) == sideBySide
+
+    companion object {
+        private const val DEFAULT_FRACTION = 0.5
+
+        @JvmStatic
+        fun parse(data: JSONObject): ArrangementDefinition {
+            val fraction = data.optDouble("fraction", DEFAULT_FRACTION).takeUnless { it.isNaN() } ?: DEFAULT_FRACTION
+            return ArrangementDefinition(
+                style = if (data.optString("style") == "overlay") Style.OVERLAY else Style.SPLIT,
+                axes = when (data.optString("axes")) {
+                    "horizontal" -> Axes.HORIZONTAL
+                    "vertical" -> Axes.VERTICAL
+                    else -> Axes.BOTH
+                },
+                fraction = fraction.coerceIn(0.0, 1.0).toFloat(),
+                primaryEdge = when (data.optString("primaryEdge")) {
+                    "leading" -> Edge.LEADING
+                    "top" -> Edge.TOP
+                    "bottom" -> Edge.BOTTOM
+                    else -> Edge.TRAILING
+                },
+                compact = if (data.optString("compact") == "pair") Compact.PAIR else Compact.PRIMARY,
+            )
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/ArrangementLayout.kt

@@ -0,0 +1,225 @@
+package dev.apexnative.navigation.viewcontrollers.arrangement
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Point
+import android.graphics.Rect
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowInsets
+import androidx.core.graphics.Insets
+import androidx.core.view.WindowInsetsCompat
+import dev.apexnative.navigation.utils.WindowFolds
+import dev.apexnative.navigation.viewcontrollers.modal.SheetContainer
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.IReactView
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
+import dev.apexnative.navigation.views.component.ComponentLayout
+
+/**
+ * The view of a pair of screens ([ArrangementController]), React or native: lays them out as [ArrangementPlanner]
+ * decides from its size, its direction, the folds and the size of the window; keeps the secondary out of the window
+ * while only the primary shows; and gives each screen the window insets of the edges of the pair it touches.
+ */
+@SuppressLint("ViewConstructor")
+open class ArrangementLayout internal constructor(
+    context: Context,
+    private val definition: ArrangementDefinition,
+    private val primary: ViewGroup,
+    private val secondary: ViewGroup,
+    private val folds: () -> List<WindowFolds.Fold>,
+    private val largeWindow: () -> Boolean,
+    private val onArranged: (ArrangementPlan) -> Unit,
+) : ViewGroup(context) {
+    /** How the screens lie, as last laid out; null before the first layout. */
+    internal var plan: ArrangementPlan? = null
+        private set
+
+    // The plan the screens were measured and given their insets for.
+    private var measured: ArrangementPlan? = null
+    // The window insets the pair was last given, as its parent gives them (a pane of a split view keeps only its own
+    // sides); a pair given them before it is attached (a pop) has no root insets yet.
+    private var lastInsets: WindowInsets? = null
+
+    init {
+        // The primary last: drawn over the secondary, and the first to get a touch.
+        addView(secondary, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+        addView(primary, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+    }
+
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        val width = MeasureSpec.getSize(widthMeasureSpec)
+        val height = MeasureSpec.getSize(heightMeasureSpec)
+        setMeasuredDimension(width, height)
+        // Where the layout put the pair last: a fold is placed against it before the pair's own place is final.
+        prepare(planFor(width, height, left, top))
+    }
+
+    override fun onLayout(changed: Boolean, l: Int, t: Int, r: Int, b: Int) {
+        // In its final place a fold can cross the pair where the measure didn't see it: a pair laid out the first time.
+        val next = planFor(r - l, b - t, l, t)
+        if (next != measured) prepare(next)
+        placeSecondary(next.secondary != null)
+        layoutScreen(primary, next.primary)
+        next.secondary?.let { layoutScreen(secondary, it) }
+        // One over the other, the covered screen isn't read out.
+        secondary.importantForAccessibility = if (next.layout == ArrangementPlan.Layout.OVERLAY) {
+            IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+        } else {
+            IMPORTANT_FOR_ACCESSIBILITY_AUTO
+        }
+        if (next != plan) {
+            plan = next
+            onArranged(next)
+        }
+    }
+
+    override fun shouldDelayChildPressedState() = false
+
+    // The screens take the insets of the edges of the pair they touch: side by side, the bar of the left screen has no
+    // room for the navigation bar on the right; one above the other, the upper screen keeps none for the one at the
+    // bottom. Not applied to this view itself: the controller's listener leaves them as they are.
+    override fun dispatchApplyWindowInsets(insets: WindowInsets): WindowInsets {
+        lastInsets = insets
+        val plan = measured ?: return super.dispatchApplyWindowInsets(insets)
+        val all = WindowInsetsCompat.toWindowInsetsCompat(insets, this)
+        dispatchTo(primary, all, plan.primary, insets)
+        plan.secondary?.let { dispatchTo(secondary, all, it, insets) }
+        return insets
+    }
+
+    private fun dispatchTo(screen: View, all: WindowInsetsCompat, frame: Rect, insets: WindowInsets) {
+        val sides = keepSides(
+            all,
+            left = frame.left <= 0,
+            top = frame.top <= 0,
+            right = frame.right >= measuredWidth,
+            bottom = frame.bottom >= measuredHeight,
+        )
+        screen.dispatchApplyWindowInsets(sides.toWindowInsets() ?: insets)
+    }
+
+    private fun keepSides(
+        all: WindowInsetsCompat,
+        left: Boolean,
+        top: Boolean,
+        right: Boolean,
+        bottom: Boolean,
+    ): WindowInsetsCompat {
+        if (left && top && right && bottom) return all
+        val builder = WindowInsetsCompat.Builder(all)
+        for (type in SIDE_TYPES) {
+            val sides = all.getInsets(type)
+            builder.setInsets(
+                type,
+                Insets.of(
+                    if (left) sides.left else 0,
+                    if (top) sides.top else 0,
+                    if (right) sides.right else 0,
+                    if (bottom) sides.bottom else 0,
+                ),
+            )
+        }
+        return builder.build()
+    }
+
+    // The screens' insets for the plan, then their sizes in it: the insets set their padding, which the measure counts.
+    private fun prepare(next: ArrangementPlan) {
+        val sidesChanged = measured?.let { it.primary != next.primary || it.secondary != next.secondary } ?: true
+        measured = next
+        if (sidesChanged) (lastInsets ?: rootWindowInsets)?.let { dispatchApplyWindowInsets(it) }
+        measureScreen(primary, next.primary)
+        next.secondary?.let { measureScreen(secondary, it) }
+    }
+
+    private fun layoutScreen(screen: View, frame: Rect) =
+        screen.layout(frame.left, frame.top, frame.right, frame.bottom)
+
+    private fun measureScreen(screen: View, frame: Rect) = screen.measure(
+        MeasureSpec.makeMeasureSpec(frame.width(), MeasureSpec.EXACTLY),
+        MeasureSpec.makeMeasureSpec(frame.height(), MeasureSpec.EXACTLY),
+    )
+
+    // Out of the window while only the primary shows, as on iOS: the screen disappears, and comes back under the
+    // primary when the pair has room for it again.
+    private fun placeSecondary(shown: Boolean) {
+        val attached = secondary.parent === this
+        if (shown == attached) return
+        if (shown) {
+            addViewInLayout(secondary, 0, secondary.layoutParams ?: generateDefaultLayoutParams(), true)
+        } else {
+            removeViewInLayout(secondary)
+        }
+    }
+
+    private fun planFor(width: Int, height: Int, x: Int, y: Int): ArrangementPlan {
+        val origin = parentOriginInWindow().apply { offset(x, y) }
+        val inWindow = Rect(origin.x, origin.y, origin.x + width, origin.y + height)
+        val fold = folds().firstNotNullOfOrNull { it.across(inWindow) }
+        val rtl = layoutDirection == LAYOUT_DIRECTION_RTL
+        return ArrangementPlanner.plan(definition, width, height, rtl, fold, largeWindow())
+    }
+
+    // Where the layout puts the parent in the window, without the moves of animations: a pair sliding in on a push is
+    // placed against the fold where it comes to rest. A sheet counts where it rests, not where a drag moved it.
+    private fun parentOriginInWindow(): Point {
+        var x = 0
+        var y = 0
+        var current = parent as? View
+        while (current != null) {
+            x += current.left
+            y += current.top
+            if (current is SheetContainer) y -= current.shift
+            val next = current.parent as? View
+            if (next != null) {
+                x -= next.scrollX
+                y -= next.scrollY
+            }
+            current = next
+        }
+        return Point(x, y)
+    }
+
+    private companion object {
+        val SIDE_TYPES = intArrayOf(
+            WindowInsetsCompat.Type.statusBars(),
+            WindowInsetsCompat.Type.navigationBars(),
+            WindowInsetsCompat.Type.captionBar(),
+            WindowInsetsCompat.Type.displayCutout(),
+            WindowInsetsCompat.Type.ime(),
+            WindowInsetsCompat.Type.systemGestures(),
+            WindowInsetsCompat.Type.mandatorySystemGestures(),
+            WindowInsetsCompat.Type.tappableElement(),
+        )
+    }
+}
+
+/**
+ * The view of a pair whose primary is a React screen: for the stack around it stands for the primary, so the bar
+ * follows the primary's scroll (`topBar.hideOnScroll`). A native primary has no scroll for the bar to follow.
+ */
+@SuppressLint("ViewConstructor")
+internal class ReactArrangementLayout(
+    context: Context,
+    definition: ArrangementDefinition,
+    private val primary: ComponentLayout,
+    secondary: ViewGroup,
+    folds: () -> List<WindowFolds.Fold>,
+    largeWindow: () -> Boolean,
+    onArranged: (ArrangementPlan) -> Unit,
+) : ArrangementLayout(context, definition, primary, secondary, folds, largeWindow, onArranged), IReactView {
+    override fun isReady(): Boolean = primary.isReady
+
+    override fun asView(): ViewGroup = this
+
+    override fun sendOnNavigationButtonPressed(buttonId: String) = primary.sendOnNavigationButtonPressed(buttonId)
+
+    override fun getScrollEventListener(): ScrollEventListener = primary.scrollEventListener
+
+    override fun dispatchTouchEventToJs(event: MotionEvent) = primary.dispatchTouchEventToJs(event)
+
+    override fun isRendered(): Boolean = primary.isRendered
+
+    // The screens' controllers destroy their views.
+    override fun destroy() = Unit
+}