@apexnative/navigation 1.0.0-alpha.5 → 1.0.0-alpha.7

package/android/src/main/java/dev/apexnative/navigation/react/ScreenRegions.kt

@@ -3,36 +3,25 @@ package dev.apexnative.navigation.react
 import android.app.Activity
 import android.graphics.Rect
 import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.WritableArray
-import com.facebook.react.bridge.WritableMap
-import dev.apexnative.navigation.react.events.EventContract
+import dev.apexnative.navigation.react.ScreenEnvironment.Region
+import dev.apexnative.navigation.react.ScreenEnvironment.Regions
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.WindowFolds
-import java.util.concurrent.ConcurrentHashMap
 
 /**
- * The reserved regions of each screen (`useReservedRegions`), in dp from the top left of its content: where it divides
- * (a fold the window is divided at, `division`) and where hardware covers it (a fold that hides what is under it, the
- * camera cutout: `occlusion`). Only those on the screen, cut to it: a fold at the edge of a screen of a pair is not on
- * it. Measured on the main thread as each screen lays out, and again after a change of the window's folds (which lays
- * the window out); JavaScript reads them from its own thread for a screen's first render, and gets every change as
- * `ANN.ScreenRegionsChanged`.
+ * Measures the reserved regions of each screen (`useReservedRegions`), in dp from the top left of its content: where
+ * it divides (a fold the window is divided at, `division`) and where hardware covers it (a fold that hides what is
+ * under it, the camera cutout: `occlusion`). Only those on the screen, cut to it: a fold at the edge of a screen of a
+ * pair is not on it. Measured on the main thread as each screen lays out, and again after a change of the window's
+ * folds (which lays the window out); [ScreenEnvironment] keeps them, answers JavaScript's reads and tells it of every
+ * change as `ANN.ScreenRegionsChanged`.
  */
 internal object ScreenRegions {
-    data class Region(val x: Double, val y: Double, val width: Double, val height: Double)
-
-    data class Regions(val division: List<Region>, val occlusion: List<Region>) {
-        val isEmpty: Boolean get() = division.isEmpty() && occlusion.isEmpty()
-    }
-
-    private val NONE = Regions(emptyList(), emptyList())
-    private val regions = ConcurrentHashMap<String, Regions>()
-
     /**
      * Measures the regions of the screen whose content the layout puts at [content] in the window (pixels), with the
-     * window's [insets] (the camera cutout), and tells JavaScript when they changed, through [emitter], the one of the
-     * JavaScript the screen was made for: silent once it went. Main thread only.
+     * window's [insets] (the camera cutout), and keeps them in [ScreenEnvironment], which tells JavaScript when they
+     * changed through [emitter], the one of the JavaScript the screen was made for: silent once it went. Main thread
+     * only.
      */
     fun update(
         activity: Activity,
@@ -49,17 +38,7 @@ internal object ScreenRegions {
             occlusion = (folds.filter { it.occludes }.map { it.bounds } + cutouts)
                 .mapNotNull { onScreen(it, content, density) },
         )
-        val previous = regions.put(screenId, value)
-        // None at first is what JavaScript reads before the first layout.
-        if (previous == value || (previous == null && value.isEmpty)) return
-        emitter.emitScreenRegionsChanged(screenId, toMap(value))
-    }
-
-    /** `{ division, occlusion }`, empty lists for an unknown screen and before its first layout. Any thread. */
-    fun get(screenId: String): WritableMap = toMap(regions[screenId] ?: NONE)
-
-    fun remove(screenId: String) {
-        regions.remove(screenId)
+        ScreenEnvironment.setRegions(screenId, value, ScreenEnvironment.changesOf(emitter))
     }
 
     // The part of [bounds] (window pixels) on the screen, in dp from its top left; null off it. A fold without width
@@ -74,20 +53,4 @@ internal object ScreenRegions {
             height = part.height() / density.toDouble(),
         )
     }
-
-    private fun toMap(value: Regions): WritableMap = Arguments.createMap().apply {
-        putArray(EventContract.ScreenRegionsChanged.DIVISION, toArray(value.division))
-        putArray(EventContract.ScreenRegionsChanged.OCCLUSION, toArray(value.occlusion))
-    }
-
-    private fun toArray(regions: List<Region>): WritableArray = Arguments.createArray().apply {
-        for (region in regions) {
-            pushMap(Arguments.createMap().apply {
-                putDouble(EventContract.ScreenRegionRect.X, region.x)
-                putDouble(EventContract.ScreenRegionRect.Y, region.y)
-                putDouble(EventContract.ScreenRegionRect.WIDTH, region.width)
-                putDouble(EventContract.ScreenRegionRect.HEIGHT, region.height)
-            })
-        }
-    }
 }

package/android/src/main/java/dev/apexnative/navigation/react/ScrollEvents.kt

@@ -1,25 +1,17 @@
 package dev.apexnative.navigation.react
 
-import android.content.Context
-import android.util.Log
-import com.facebook.react.ReactApplication
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.Event
-import com.facebook.react.uimanager.events.EventDispatcherListener
-import com.facebook.react.views.scroll.ScrollEvent
+import android.view.ViewGroup
+import android.widget.HorizontalScrollView
+import com.facebook.react.views.scroll.ReactScrollViewHelper
 import com.facebook.react.views.scroll.ScrollEventType
-import dev.apexnative.navigation.utils.NavigationLog
-import dev.apexnative.navigation.utils.UiThread
-import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
-import java.lang.reflect.Field
-import java.util.Collections
-import java.util.WeakHashMap
 
 /**
- * The scroll events of React Native's lists, as the screens' scroll listeners hear them: from the event dispatcher of
- * the running React Native, every list of the app. React Native keeps the offset, the speed and the kind of a scroll
- * event in private fields: they are looked up once, with their types; if React Native renames them, one warning goes to
- * the log and the screens hear no scroll, with no error at each event.
+ * The scroll events of React Native's scroll views, as the screens' scroll listeners hear them: through React Native's
+ * public scroll listener ([ReactScrollViewHelper.addScrollListener]), which every `ReactScrollView`,
+ * `ReactHorizontalScrollView` and `ReactNestedScrollView` of the process calls on the main thread just before it
+ * dispatches the same event to JavaScript, after the same throttle. One listener serves every screen and every React
+ * context; it is added while a screen listens and removed when the last one stops. Horizontal scroll views are left
+ * out: a pager or a carousel doesn't move the bars. Main thread only.
  */
 internal object ScrollEvents {
     /** What a scroll event is. */
@@ -28,133 +20,62 @@ internal object ScrollEvents {
     /** One scroll event: the list's tag (its view's id), its kind, its vertical offset and speed, in pixels. */
     class Reading(val viewTag: Int, val kind: Kind, val offsetY: Float, val velocityY: Float)
 
-    private class Fields(val type: Field, val offsetY: Field, val velocityY: Field)
+    // One screen's listening: its own object, so that a stop takes away that listening and no other.
+    private class Listening(val handler: (Reading) -> Unit)
 
-    private var fields: Fields? = null
-    private var lookedUp = false
+    // The screens' listenings, in the order they came.
+    private val listenings = mutableListOf<Listening>()
 
-    // The screens' listeners that found no event dispatcher, held weakly until React Native has one. Main thread.
-    private val waiting: MutableSet<ScrollEventListener> = Collections.newSetFromMap(WeakHashMap())
+    // React Native holds its scroll listeners weakly: this object keeps the one it added for as long as it is added.
+    private val listener = object : ReactScrollViewHelper.ScrollListener {
+        override fun onScroll(
+            scrollView: ViewGroup?,
+            scrollEventType: ScrollEventType?,
+            xVelocity: Float,
+            yVelocity: Float,
+        ) = hear(scrollView, scrollEventType, yVelocity)
 
-    /** [listener] found no event dispatcher: it is asked to listen again once React Native has one. */
-    fun waitForDispatcher(listener: ScrollEventListener) {
-        waiting += listener
-    }
-
-    /** A React context is ready (`ReloadCoordinator`): the listeners waiting for an event dispatcher listen now. */
-    fun dispatcherReady() {
-        val listeners = waiting.toList()
-        waiting.clear()
-        listeners.forEach(ScrollEventListener::attachIfNeeded)
+        override fun onLayout(scrollView: ViewGroup?) = Unit
     }
 
     /**
-     * Calls [handler] on the main thread with each scroll event of the app's React Native, until the function returned
-     * is called. None when React Native has no event dispatcher now (around a reload, the caller asks again later) or
-     * its scroll events can't be read.
+     * Calls [handler] with each scroll event of a vertical scroll view of the app, until the function returned is
+     * called.
      */
-    fun listen(context: Context, handler: (Reading) -> Unit): (() -> Unit)? {
-        if (fields() == null) return null
-        val reactContext = (context.applicationContext as? ReactApplication)?.reactHost?.currentReactContext
-            ?: return null
-        val dispatcher = try {
-            UIManagerHelper.getEventDispatcher(reactContext)
-        } catch (e: RuntimeException) {
-            null
-        } ?: return null
-        val listener = EventDispatcherListener { event ->
-            // The event goes back to its pool after the dispatch: it is read now, on the thread that dispatches.
-            val reading = read(event) ?: return@EventDispatcherListener
-            if (UiThread.isMainThread()) handler(reading) else UiThread.post { handler(reading) }
+    fun listen(handler: (Reading) -> Unit): () -> Unit {
+        val listening = Listening(handler)
+        if (listenings.isEmpty()) ReactScrollViewHelper.addScrollListener(listener)
+        listenings += listening
+        return {
+            // By identity: the second call of a stop finds nothing to take away.
+            if (listenings.removeAll { it === listening } && listenings.isEmpty()) {
+                ReactScrollViewHelper.removeScrollListener(listener)
+            }
         }
-        dispatcher.addListener(listener)
-        return { dispatcher.removeListener(listener) }
     }
 
-    private fun read(event: Event<*>): Reading? {
-        if (event !is ScrollEvent) return null
-        val fields = fields() ?: return null
-        return try {
-            val type = fields.type.get(event) as? ScrollEventType ?: return null
-            val offsetY = readFloat(fields.offsetY, event) ?: return null
-            val velocityY = readFloat(fields.velocityY, event) ?: return null
-            Reading(event.viewTag, kindOf(type), offsetY, velocityY)
-        } catch (e: ReflectiveOperationException) {
-            null
-        } catch (e: IllegalArgumentException) {
-            null
-        }
+    /** One call of React Native's listener: the handlers listening now hear its reading, if it has one. */
+    fun hear(scrollView: ViewGroup?, type: ScrollEventType?, velocityY: Float) {
+        val reading = read(scrollView, type, velocityY) ?: return
+        listenings.toList().forEach { it.handler(reading) }
     }
 
-    private fun kindOf(type: ScrollEventType): Kind = when (type) {
+    /**
+     * The reading of one call of React Native's listener: none for a horizontal scroll view, or when React Native gives
+     * no view or no kind. The offset is the view's `scrollY` and the speed React Native's own, in pixels, as the event
+     * sent to JavaScript carries them before it converts them to dp.
+     */
+    fun read(scrollView: ViewGroup?, type: ScrollEventType?, velocityY: Float): Reading? {
+        if (scrollView == null || type == null || scrollView is HorizontalScrollView) return null
+        return Reading(scrollView.id, kindOf(type), scrollView.scrollY.toFloat(), velocityY)
+    }
+
+    /** The kind of a reading for React Native's [type]. */
+    fun kindOf(type: ScrollEventType): Kind = when (type) {
         ScrollEventType.BEGIN_DRAG -> Kind.BeginDrag
         ScrollEventType.END_DRAG -> Kind.EndDrag
         ScrollEventType.SCROLL -> Kind.Scroll
         ScrollEventType.MOMENTUM_BEGIN -> Kind.MomentumBegin
         ScrollEventType.MOMENTUM_END -> Kind.MomentumEnd
     }
-
-    @Synchronized
-    private fun fields(): Fields? {
-        if (lookedUp) return fields
-        lookedUp = true
-        fields = try {
-            val owner = ScrollEvent::class.java
-            val type = declaredField(owner, TYPE_NAMES) { ScrollEventType::class.java.isAssignableFrom(it) }
-            val offsetY = declaredField(owner, OFFSET_NAMES, ::isNumeric)
-            val velocityY = declaredField(owner, VELOCITY_NAMES, ::isNumeric)
-            if (type != null && offsetY != null && velocityY != null) Fields(type, offsetY, velocityY) else null
-        } catch (e: ReflectiveOperationException) {
-            null
-        } catch (e: SecurityException) {
-            null
-        }
-        if (fields == null) {
-            Log.w(
-                NavigationLog.TAG,
-                "[ApexNavigation] React Native's scroll events changed: hideOnScroll and the large title " +
-                    "don't follow the scroll",
-            )
-        }
-        return fields
-    }
-
-    // The names of the fields: React Native 0.87 first, then the earlier ones with the `m` prefix.
-    private val TYPE_NAMES = listOf("scrollEventType", "mScrollEventType")
-    private val OFFSET_NAMES = listOf("scrollY", "mScrollY")
-    private val VELOCITY_NAMES = listOf("yVelocity", "mYVelocity")
-
-    /**
-     * The first of the fields [names] that [owner] declares with a type [accepted] takes, made readable; none when no
-     * name fits. React Native renamed them and changed their types between versions.
-     */
-    fun declaredField(owner: Class<*>, names: List<String>, accepted: (Class<*>) -> Boolean): Field? {
-        for (name in names) {
-            val field = try {
-                owner.getDeclaredField(name)
-            } catch (e: NoSuchFieldException) {
-                continue
-            }
-            if (!accepted(field.type)) continue
-            field.isAccessible = true
-            return field
-        }
-        return null
-    }
-
-    /** A number of any kind: a primitive one (`int`, `float`, `double`, …) or a boxed one. */
-    fun isNumeric(type: Class<*>): Boolean =
-        type in PRIMITIVE_NUMBERS || Number::class.java.isAssignableFrom(type)
-
-    /** [field] of [target] as a float, whatever numeric type it has; none when it holds no number. */
-    fun readFloat(field: Field, target: Any): Float? = (field.get(target) as? Number)?.toFloat()
-
-    private val PRIMITIVE_NUMBERS = setOf<Class<*>?>(
-        Byte::class.javaPrimitiveType,
-        Short::class.javaPrimitiveType,
-        Int::class.javaPrimitiveType,
-        Long::class.javaPrimitiveType,
-        Float::class.javaPrimitiveType,
-        Double::class.javaPrimitiveType,
-    )
 }

package/android/src/main/java/dev/apexnative/navigation/safearea/SafeAreaView.kt

@@ -10,7 +10,7 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.view.ReactViewGroup
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 
 /**
@@ -20,7 +20,7 @@ import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 @SuppressLint("ViewConstructor")
 class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
     private var stopListening: (() -> Unit)? = null
-    private var applied: ScreenInsets.Insets? = null
+    private var applied: ScreenEnvironment.Insets? = null
     private var readySent = false
     private var contentSignalled = false
 
@@ -48,7 +48,7 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
             stopListening?.invoke()
             field = value
             applied = null
-            stopListening = value?.let { id -> ScreenInsets.listenToPadding(id) { applyPadding() } }
+            stopListening = value?.let { id -> ScreenEnvironment.listenToPadding(id) { applyPadding() } }
             // The screen has a safe area view: it counts as rendered once this view says so.
             value?.let(ScreenReadiness::wrapped)
             applyPadding()
@@ -56,7 +56,7 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
 
     private fun applyPadding() {
         val state = stateWrapper ?: return
-        val padding = screenId?.let(ScreenInsets::padding) ?: return
+        val padding = screenId?.let(ScreenEnvironment::padding) ?: return
         if (padding == applied) return
         applied = padding
         state.updateState(
@@ -69,9 +69,9 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
         )
     }
 
-    private fun paddingOf(data: ReadableMap): ScreenInsets.Insets? {
+    private fun paddingOf(data: ReadableMap): ScreenEnvironment.Insets? {
         if (!data.hasKey("top")) return null
-        return ScreenInsets.Insets(data.getDouble("top"), data.getDouble("right"), data.getDouble("bottom"),
+        return ScreenEnvironment.Insets(data.getDouble("top"), data.getDouble("right"), data.getDouble("bottom"),
             data.getDouble("left"))
     }
 

package/android/src/main/java/dev/apexnative/navigation/slots/SlotScreenView.kt

@@ -2,9 +2,13 @@ package dev.apexnative.navigation.slots
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.util.Size
 import android.view.MotionEvent
 import android.view.ViewGroup
 import android.widget.FrameLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import dev.apexnative.navigation.react.ContentHeights
+import dev.apexnative.navigation.react.ContentMounts
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
 import dev.apexnative.navigation.react.events.ScreenAppearance
@@ -16,9 +20,10 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListe
  * What a slot screen (`slot:<Name>`) shows: the empty container its slot of the app's React tree moves its children
  * into, under the screen's id ([SlotContainers]), told of each change of its size. It is the screen's content for the
  * core: ready once the slot's content has mounted into it and, when the screen has a safe area view, the screen
- * rendered into that view; its mounted handlers run at each mount. Its appearance events go through its record to the
- * core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit. Destroyed while the
- * id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
+ * rendered into that view; its mounted handlers run at each mount of Fabric and as the content mounts into it. Its
+ * content measures without a height limit in the slot's own layout ([contentSize]). Its appearance events go through
+ * its record to the core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit.
+ * Destroyed while the id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
  */
 @SuppressLint("ViewConstructor")
 class SlotScreenView(
@@ -30,7 +35,7 @@ class SlotScreenView(
     private val scrollEventListener = ScrollEventListener()
     private val whenMounted = mutableListOf<Runnable>()
     private val whenRendered = mutableListOf<Runnable>()
-    private val mountedHandlers = LinkedHashMap<String, Runnable>()
+    private val mounts = ContentMounts { !destroyed && isAttachedToWindow }
     private var listening = false
 
     // The safe area view of a slot renders in the app's one React tree: every signal of the id is the screen's.
@@ -84,10 +89,11 @@ class SlotScreenView(
         destroyed = true
         whenMounted.clear()
         whenRendered.clear()
-        mountedHandlers.clear()
+        mounts.clear()
         stopListening()
         // A later screen with the same id keeps the slot.
         if (SlotContainers.get(componentId) !== this) return
+        ContentHeights.forgetSlot(componentId)
         SlotContainers.remove(componentId)
         if (!isPreparedPush) AppearanceDispatcher.slotDestroyed(componentId, appearance.generation)
     }
@@ -120,7 +126,21 @@ class SlotScreenView(
     }
 
     override fun setOnContentMounted(key: String, handler: Runnable?) {
-        if (handler == null) mountedHandlers.remove(key) else mountedHandlers[key] = handler
+        if (!destroyed) mounts.set(key, handler)
+    }
+
+    // The slot measures its content in its own layout: the first question asks for it and lays the slot out again; the
+    // height comes with that layout, before the mount the handlers hear. The width is the container's, at which the
+    // slot lays its content out.
+    override fun contentSize(maxWidth: Int): Size? {
+        if (destroyed) return null
+        if (!ContentHeights.isSlotRequested(componentId)) {
+            ContentHeights.requestSlot(componentId)
+            SlotContainers.changed(componentId)
+            return null
+        }
+        val height = ContentHeights.slotHeight(componentId)?.takeIf { it > 0f } ?: return null
+        return Size(if (width > 0) width else maxWidth, Math.round(height.dpToPx()))
     }
 
     // Only the container that holds the slot of the id: a destroyed one, or one a later screen replaced, takes no
@@ -136,7 +156,7 @@ class SlotScreenView(
         val waiting = whenMounted.toList()
         whenMounted.clear()
         waiting.forEach { it.run() }
-        mountedHandlers.values.toList().forEach { it.run() }
+        mounts.run()
         checkReadiness()
     }
 

package/android/src/main/java/dev/apexnative/navigation/slots/SlotView.kt

@@ -15,6 +15,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
+import dev.apexnative.navigation.react.ContentHeights
 
 /**
  * The React children of a slot. They live outside the views of the host's surface, in the container of a screen, so
@@ -79,6 +80,8 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
         }
     private var lastWidth = -1f
     private var lastHeight = -1f
+    // The slot was laid out once more, at the same size, for the measure of its content (`ContentHeights`).
+    private var measureAsked = false
 
     private val slotId: String?
         get() = getTag(R.id.view_tag_native_id) as? String
@@ -116,7 +119,14 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
         if (container != null && state != null && container.width > 0 && container.height > 0) {
             val width = container.width.toFloat().pxToDp()
             val height = container.height.toFloat().pxToDp()
-            if (width != lastWidth || height != lastHeight) {
+            // A container that measures the content gets one layout more for it, with the same size, until the height
+            // came.
+            val requested = ContentHeights.isSlotRequested(id)
+            // A request that went (its screen did) and comes again gets its layout again.
+            if (!requested) measureAsked = false
+            val measures = !measureAsked && requested && ContentHeights.slotHeight(id) == null
+            if (width != lastWidth || height != lastHeight || measures) {
+                measureAsked = measureAsked || measures
                 lastWidth = width
                 lastHeight = height
                 state.updateState(
@@ -136,6 +146,7 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
     }
 
     fun drop() {
+        measureAsked = false
         SlotContainers.unregister(this)
         (content.parent as? ViewGroup)?.removeView(content)
     }

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

@@ -28,7 +28,7 @@ internal object MaterialTheme {
     private val wrappers = WeakHashMap<Context, WeakReference<Context>>()
     // Themes of the navigation's own views, each made once over the activity's with a style of its own.
     private val followers = WeakHashMap<Context, Int>()
-    // The popup theme of the bar's toolbars per activity: the app's theme doesn't change while the activity lives.
+    // The popup theme of the bar's "⋮" per activity: the app's theme doesn't change while the activity lives.
     private val popupThemes = WeakHashMap<Activity, Int>()
 
     fun context(context: Context): Context {
@@ -38,11 +38,10 @@ internal object MaterialTheme {
     }
 
     /**
-     * The popup theme of the top bar's toolbars, for "⋮", set on them before their menu is made. None when the app's
-     * theme follows light and dark: the menu takes the bar's own theme, which [rebase] keeps in the current mode, with
-     * the app's colors. With a Material 3 theme fixed to light or to dark, a day/night overlay that gives the menu the
-     * current mode's colors where the theme shows the other mode. Android makes the menu's theme from it at the menu's
-     * first opening, in the mode of that moment, and no public API makes it again for a later switch.
+     * The popup theme of the top bar's "⋮", over the bar's theme at each opening of its popup, in the mode of that
+     * moment. None when the app's theme follows light and dark: the menu takes the bar's own theme, which [rebase]
+     * keeps in the current mode, with the app's colors. With a Material 3 theme fixed to light or to dark, a day/night
+     * overlay that gives the menu the current mode's colors where the theme shows the other mode.
      */
     fun popupTheme(context: Context): Int {
         val activity = activityOf(context) ?: return 0

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

@@ -0,0 +1,36 @@
+package dev.apexnative.navigation.utils
+
+import android.animation.ValueAnimator
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.provider.Settings
+import dev.apexnative.navigation.NavigationApplication
+
+/**
+ * Whether the system plays no animations: "Remove animations" in the accessibility settings, or the animator duration
+ * scale at 0 in the developer options. Then a transition doesn't wait for its elements' targets and images and moves no
+ * element, and the side menu opens and closes at once. Any thread.
+ */
+internal object SystemAnimations {
+    /**
+     * The animations are off now; [context] reads the scale below Android 8, else the application's. Lint can't see
+     * that the decision calls `areAnimatorsEnabled` (API 26) only from Android 8.
+     */
+    @SuppressLint("NewApi")
+    fun areOff(context: Context? = null): Boolean =
+        areOff(Build.VERSION.SDK_INT, { ValueAnimator.areAnimatorsEnabled() }) { durationScaleOf(context) }
+
+    /**
+     * The decision: from Android 8 the animator's own answer ([animatorsEnabled]), which follows both settings;
+     * below it the duration scale ([durationScale]) at 0.
+     */
+    fun areOff(sdk: Int, animatorsEnabled: () -> Boolean, durationScale: () -> Float): Boolean =
+        if (sdk >= Build.VERSION_CODES.O) !animatorsEnabled() else durationScale() == 0f
+
+    // Without a context and before the application started (the unit tests), the animations play.
+    private fun durationScaleOf(context: Context?): Float {
+        val resolver = (context ?: NavigationApplication.instanceOrNull)?.contentResolver ?: return 1f
+        return Settings.Global.getFloat(resolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f)
+    }
+}

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

@@ -26,16 +26,3 @@ val View.borderRadius: Float
  */
 internal fun resolveBorderRadius(radius: LengthPercentage, width: Int, density: Float): Float =
     (radius.resolve(width / density) * density).coerceAtLeast(0f)
-
-/** The scale the parents of [view] give it, along x and along y: a view in a scaled parent shows smaller. */
-fun computeInheritedScale(view: View): Pair<Float, Float> {
-    var scaleX = 1f
-    var scaleY = 1f
-    var parent = view.parent as? View
-    while (parent != null) {
-        scaleX *= parent.scaleX
-        scaleY *= parent.scaleY
-        parent = parent.parent as? View
-    }
-    return scaleX to scaleY
-}

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

@@ -9,7 +9,7 @@ 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.react.ScreenEnvironment
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.SystemUiUtils
 import dev.apexnative.navigation.utils.WindowFolds
@@ -146,12 +146,14 @@ class ArrangementController internal constructor(
         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(primary.id, state, notify, EventEmitter.of(primary.jsGeneration))
+            val state = ScreenEnvironment.Arrangement(PRIMARY, layout, front = overlay, hidden = false)
+            val changes = ScreenEnvironment.changesOf(EventEmitter.of(primary.jsGeneration))
+            ScreenEnvironment.setArrangement(primary.id, state, notify, changes)
         }
         if (secondary is ComponentViewController) {
-            val state = ArrangementStates.State(SECONDARY, layout, front = false, hidden = single)
-            ArrangementStates.set(secondary.id, state, notify, EventEmitter.of(secondary.jsGeneration))
+            val state = ScreenEnvironment.Arrangement(SECONDARY, layout, front = false, hidden = single)
+            val changes = ScreenEnvironment.changesOf(EventEmitter.of(secondary.jsGeneration))
+            ScreenEnvironment.setArrangement(secondary.id, state, notify, changes)
         }
     }
 
@@ -244,9 +246,9 @@ class ArrangementController internal constructor(
         // 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()
+        // The screens go with the pair: each clears its own environment, its arrangement too, unless its id is
+        // another's now.
         super.destroy()
     }
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/BottomTabsCollapseBehavior.kt

@@ -2,6 +2,7 @@ package dev.apexnative.navigation.viewcontrollers.bottomtabs
 
 import android.view.View
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
+import dev.apexnative.navigation.views.bottomtabs.BottomTabsLayout
 
 /**
  * bottomTabs.hideOnScroll: the tabs hide after a drag that scrolls the screen's content down and come back after one
@@ -43,9 +44,10 @@ class BottomTabsCollapseBehavior(private val container: () -> View?) :
     override fun onHide() {
         val view = container() ?: return
         hiddenByScroll = true
-        // Out of the screen with what is under it: a compact bar floats over its bottom margin and the navigation bar.
-        val under = ((view.parent as? View)?.let { it.height - view.bottom } ?: 0).coerceAtLeast(0)
-        view.animate().translationY((view.height + under).toFloat()).setDuration(DURATION).start()
+        // Out of the screen with what is under it (a compact bar floats over its bottom margin and the navigation bar)
+        // and the custom row that rises above it.
+        val distance = (view.parent as? BottomTabsLayout)?.hideDistance ?: view.height
+        view.animate().translationY(distance.toFloat()).setDuration(DURATION).start()
     }
 
     private companion object {