@apexnative/navigation 1.0.0-alpha.4 → 1.0.0-alpha.6

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

@@ -3,13 +3,14 @@ package dev.apexnative.navigation.react
 import android.util.Log
 import com.facebook.react.bridge.Promise
 import dev.apexnative.navigation.react.events.EventEmitter
-import dev.apexnative.navigation.react.events.NavigationStateReporter
+import dev.apexnative.navigation.react.events.NavigationState
 import dev.apexnative.navigation.utils.NavigationLog
 
 /**
  * The one answer of a command with a promise: [resolve] or [reject], once; after that, and once the JavaScript it came
- * from went ([generation]), nothing. [CommandRunner] makes it on the main thread for each command; area code that takes
- * a [CommandListener] answers through [asListener]. Main thread only.
+ * from went ([generation]), nothing. It owns the command's one state step ([reportStateNow]). [CommandRunner] makes it
+ * on the main thread for each command; area code that takes a [CommandListener] answers through [asListener]. Main
+ * thread only.
  */
 internal class CommandAnswer(
     /** The method of the command: `push`, `setRoot`, … */
@@ -27,19 +28,36 @@ internal class CommandAnswer(
     var isAnswered = false
         private set
 
+    // The state step of this answer ran ([reportStateNow]).
+    private var stateReported = false
+
     /** Whether an answer now would reach the JavaScript the command came from. */
     val canAnswer: Boolean
         get() = !isAnswered && ReloadCoordinator.isCurrent(generation)
 
     /**
-     * Resolves the promise with [value]. For the commands that change what shows, the navigation state goes first,
-     * when it changed, so JavaScript has it when its `await` goes on; `ANN.CommandCompleted` follows the promise, for
-     * the commands that show or dismiss. A failure of either is logged; the promise goes all the same.
+     * The navigation state now, sent when it changed, once per answer: the end of the command's transition asks for it
+     * after the DidAppear it sends and before the transition's own events (`AppearanceDispatcher.endTransition`);
+     * otherwise [resolve] asks for it before the promise. A later call sends nothing, and nothing goes for a JavaScript
+     * that went. A failure of the step is logged and costs only the state.
+     */
+    fun reportStateNow() {
+        if (stateReported) return
+        stateReported = true
+        if (!ReloadCoordinator.isCurrent(generation)) return
+        guarded("report the navigation state") { events.stateNow() }
+    }
+
+    /**
+     * Resolves the promise with [value]. For the commands that change what shows (`CommandContract.STATE`), the
+     * navigation state goes first, when it changed and the command's transition didn't send it already
+     * ([reportStateNow]), so JavaScript has it when its `await` goes on; `ANN.CommandCompleted` follows the promise,
+     * for the commands that show or dismiss. A failure of either is logged; the promise goes all the same.
      */
     fun resolve(value: Any?) {
         if (!canAnswer) return
         isAnswered = true
-        if (commandName in CommandContract.STATE) guarded("report the navigation state") { events.beforeAnswer() }
+        if (commandName in CommandContract.STATE) reportStateNow()
         promise.resolve(value)
         val commandId = commandId
         if (commandName in CommandContract.COMPLETED && commandId != null) {
@@ -69,18 +87,15 @@ internal class CommandAnswer(
 
 /** What goes to JavaScript around the answer of a command. Main thread only. */
 internal interface AnswerEvents {
-    /** Right before the promise resolves: the navigation state, when it changed. */
-    fun beforeAnswer()
+    /** The answer's one state step ([CommandAnswer.reportStateNow]): the navigation state now, when it changed. */
+    fun stateNow()
 
     /** After the promise resolved: `ANN.CommandCompleted`. */
     fun commandCompleted(commandName: String, commandId: String, completionTime: Long)
 
     /** Through the sender of the JavaScript that runs now. */
     object Current : AnswerEvents {
-        override fun beforeAnswer() {
-            val emitter = EventEmitter.current()
-            if (emitter.canSend) NavigationStateReporter.updateNow(emitter)
-        }
+        override fun stateNow() = NavigationState.updateNow()
 
         override fun commandCompleted(commandName: String, commandId: String, completionTime: Long) {
             EventEmitter.current().emitCommandCompleted(commandName, commandId, completionTime)

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

@@ -9,7 +9,6 @@ import android.os.Build
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
-import com.facebook.react.ReactApplication
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.WritableMap
 import dev.apexnative.navigation.react.events.EventContract
@@ -22,7 +21,8 @@ import java.lang.ref.WeakReference
  * sensor (Android 11+), in degrees to a tenth as on iOS. Android has no public state of a closed device: closed is a
  * window without a fold, or an angle under 90° ([valueOf]). No sensor and no fold: no hinge, `{}`. It runs while
  * JavaScript has a hook mounted (`setHingeUpdates`), the sensor only while the activity is resumed too; the same value
- * is not sent twice. Main thread only, but [get].
+ * is not sent twice. The values go to the JavaScript that turned the updates on (`EventEmitter.current` then): after a
+ * reload, until the updates stop, they go nowhere. Main thread only, but [get].
  */
 internal object Hinge {
     /** A value of the hinge: its state, and its angle in degrees to a tenth; none while the state is unknown. */
@@ -33,6 +33,8 @@ internal object Hinge {
     private const val CLOSED_BELOW = 90f
 
     private var enabled = false
+    // The sender of the JavaScript that turned the updates on; none while they are off.
+    private var emitter: EventEmitter? = null
     private var activity: WeakReference<Activity>? = null
     private var folds: WindowFolds? = null
     private var sensorManager: SensorManager? = null
@@ -63,9 +65,11 @@ internal object Hinge {
     fun setEnabled(activity: Activity?, enabled: Boolean) {
         this.enabled = enabled
         if (!enabled) {
+            emitter = null
             detach()
             return
         }
+        emitter = EventEmitter.current()
         activity?.let(::attachTo)
         update()
     }
@@ -134,8 +138,7 @@ internal object Hinge {
         val value = valueOf(folds.folds.firstOrNull(), sensor != null, angle)
         if (value == last) return
         last = value
-        val reactContext = (activity?.get()?.application as? ReactApplication)?.reactHost?.currentReactContext ?: return
-        EventEmitter(reactContext).emitHingeChanged(toMap(value))
+        emitter?.emitHingeChanged(toMap(value))
     }
 
     /**

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

@@ -236,11 +236,11 @@ class NavigationTurboModule(reactContext: ReactApplicationContext) : NativeANNTu
         check = {},
     ) { _, answer -> navigator().stackCommands.setColumnShown(componentId, column, shown, answer) }
 
-    override fun getArrangementState(componentId: String): WritableMap = ArrangementStates.get(componentId)
+    override fun getArrangementState(componentId: String): WritableMap = ScreenEnvironment.getArrangementState(componentId)
 
-    override fun getScreenInsets(componentId: String): WritableMap = ScreenInsets.get(componentId)
+    override fun getScreenInsets(componentId: String): WritableMap = ScreenEnvironment.getScreenInsets(componentId)
 
-    override fun getScreenRegions(componentId: String): WritableMap = ScreenRegions.get(componentId)
+    override fun getScreenRegions(componentId: String): WritableMap = ScreenEnvironment.getScreenRegions(componentId)
 
     // With the activity the user sees, if there is one; the hinge remembers it and goes on with the next activity
     // (`Hinge.attach`).

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

@@ -23,11 +23,15 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListe
  * is made with the view, from the app's React host, and fills it; it starts once, as the view joins a window, and stops
  * once, on the main thread, as the view is destroyed.
  *
- * Ready once the safe area view of the screen told [ScreenReadiness] that the content rendered into it; a screen
- * without a safe area view (no view ever told anything of its id) once the root view of its surface has children, read
- * on this view's own layout passes. Ready once, ready for good; what waits for it ([whenReady]) runs then, once.
- * Without either, the limits of what waits decide: the view has no timer of its own. It owns the record of its
- * appearance, which the dispatcher of the appearance events holds until the content is ready (`AppearanceDispatcher`).
+ * Ready once the safe area view of the screen, in this view's own surface, told [ScreenReadiness] that the content
+ * rendered into it: the signal of another root with the same id (an old one, another live root of a bar component)
+ * never makes this one ready. A screen without a safe area view (no view ever told anything of its id) is ready once
+ * the root view of its surface has children, read on this view's own layout passes. A root that renders at once
+ * ([rendersAtOnce]: a component of a bar, a tab's cell) marks its id so from before its surface starts until it stops.
+ * Ready once, ready for good; what waits for it ([whenReady]) runs then, once.
+ * Without a signal or children, the limits of what waits decide: the view has no timer of its own. It owns the
+ * record of its appearance, which the dispatcher of the appearance events holds until the content is ready
+ * (`AppearanceDispatcher`).
  */
 @SuppressLint("ViewConstructor")
 class ReactView @JvmOverloads constructor(
@@ -36,6 +40,8 @@ class ReactView @JvmOverloads constructor(
     override val componentName: String,
     /** Props given by the native side, over `componentId`: the state of a tab's cell. */
     initialProps: Bundle? = null,
+    /** The root renders at once, without waiting for its layout: a component of a bar or a tab's cell. */
+    private val rendersAtOnce: Boolean = false,
 ) : FrameLayout(context), IReactView {
     private val scrollEventListener = ScrollEventListener()
     private var destroyed = false
@@ -44,7 +50,14 @@ class ReactView @JvmOverloads constructor(
     // What waited for the readiness was told; a question of isReady alone tells nothing, so nothing runs inside it.
     private var readyTold = false
     private val readyListeners = mutableListOf<Runnable>()
-    private var readinessListener: ScreenReadiness.Listener? = null
+    private var listening = false
+
+    // What this root hears of its id: only the signals of its own surface.
+    private val readiness = object : ScreenReadiness.Listener {
+        override fun accepts(source: Int): Boolean = ownSource()?.let { it == source } ?: true
+
+        override fun onContentRendered() = checkReadiness()
+    }
 
     // None without the app's host (the unit tests).
     private val surface: ReactSurface?
@@ -59,8 +72,17 @@ class ReactView @JvmOverloads constructor(
      */
     internal var contentChildCount: () -> Int = { (surface?.view as? ViewGroup)?.childCount ?: 0 }
 
+    /**
+     * The id of this root's React surface, which the signals of its safe area view carry: React Native gives it as
+     * the surface starts (none matches before) and never gives it again. Null without a surface: every signal of the
+     * id is its own. The unit tests give their own.
+     */
+    internal var ownSource: () -> Int? = { surface?.surfaceID }
+
     init {
         require(componentId.isNotEmpty()) { "a React root needs the id of its screen" }
+        // Before the surface exists, so its safe area view never asks before the mark is there.
+        if (rendersAtOnce) ScreenReadiness.setRendersAtOnce(componentId, this, true)
         val props = Bundle().apply {
             initialProps?.let(::putAll)
             putString(COMPONENT_ID, componentId)
@@ -103,14 +125,9 @@ class ReactView @JvmOverloads constructor(
         if (readyTold) return listener.run()
         readyListeners += listener
         if (isReady()) return checkReadiness()
-        if (readinessListener != null) return
-        val readiness = object : ScreenReadiness.Listener {
-            override fun onLaidOut() = Unit
-
-            override fun onContentRendered() = checkReadiness()
-        }
-        readinessListener = readiness
-        ScreenReadiness.setListener(componentId, readiness)
+        if (listening) return
+        listening = true
+        ScreenReadiness.addListener(componentId, this, readiness)
     }
 
     /**
@@ -126,23 +143,24 @@ class ReactView @JvmOverloads constructor(
         waiting.forEach(Runnable::run)
     }
 
-    // The safe area view said so; without one, the root view of the surface has children.
-    private fun hasRendered(): Boolean = when (ScreenReadiness.isContentRendered(componentId)) {
+    // The safe area view of this root's surface said so; without one, the root view of the surface has children.
+    private fun hasRendered(): Boolean = when (ScreenReadiness.isContentRendered(componentId, readiness)) {
         true -> true
         false -> false
         null -> contentChildCount() > 0
     }
 
     private fun stopListening() {
-        val readiness = readinessListener ?: return
-        readinessListener = null
-        ScreenReadiness.removeListener(componentId, readiness)
+        if (!listening) return
+        listening = false
+        ScreenReadiness.removeListener(componentId, this)
     }
 
     /**
      * Stops the content, once, on the main thread: its appearance ends first (DidDisappear if its WillAppear went,
      * else what is held goes with it), then the surface stops and leaves the host, so a reload doesn't start it again
-     * in the new JavaScript.
+     * in the new JavaScript. A root that renders at once takes its mark away: the last one of its id takes what was
+     * said of the id with it.
      */
     override fun destroy() {
         if (destroyed) return
@@ -150,6 +168,7 @@ class ReactView @JvmOverloads constructor(
         destroyed = true
         readyListeners.clear()
         stopListening()
+        if (rendersAtOnce) ScreenReadiness.setRendersAtOnce(componentId, this, false)
         val surface = surface ?: return
         if (started) surface.stop()
         surface.detach()

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

@@ -4,7 +4,7 @@ import com.facebook.react.bridge.ReactContext
 import dev.apexnative.navigation.NavigationActivity
 import dev.apexnative.navigation.nativescreen.NativeScreenCalls
 import dev.apexnative.navigation.react.events.EventEmitter
-import dev.apexnative.navigation.react.events.NavigationStateReporter
+import dev.apexnative.navigation.react.events.NavigationState
 import dev.apexnative.navigation.utils.UiThread
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
@@ -39,7 +39,7 @@ internal object ReloadCoordinator {
     /**
      * The JavaScript goes (a reload, or the host is destroyed). Any thread: the number grows at once; the layouts of
      * every navigation activity go on the main thread, with the "reloading" mark, and so do the listeners of the
-     * JavaScript that went (back, hinge).
+     * JavaScript that went (back, hinge) and the holds of the navigation state its `setRoot` left.
      */
     fun onJavaScriptGoes() {
         advance()
@@ -48,6 +48,7 @@ internal object ReloadCoordinator {
             launches.contextGone()
             try {
                 Navigators.all().forEach { it.onReload() }
+                NavigationState.javaScriptWent()
                 BackCallbackState.setJsListeners(false)
                 Hinge.setEnabled(Navigators.current(), false)
             } finally {
@@ -59,13 +60,15 @@ internal object ReloadCoordinator {
     /**
      * The developer tools of [activity] reload the JavaScript ("R R", the reload broadcast): the number grows first, so
      * the navigation of the activity goes without a word to the JavaScript that goes, then its layers go
-     * ([NavigationActivity.onReload]). The host's own reset follows as the reload destroys it. Main thread.
+     * ([NavigationActivity.onReload]) with the holds of the navigation state. The host's own reset follows as the
+     * reload destroys it. Main thread.
      */
     fun resetForDeveloperReload(activity: NavigationActivity) {
         advance()
         Navigator.setReloading(true)
         try {
             activity.onReload()
+            NavigationState.javaScriptWent()
         } finally {
             Navigator.setReloading(false)
         }
@@ -79,8 +82,6 @@ internal object ReloadCoordinator {
         UiThread.runOnMain {
             launches.contextReady(context)
             NativeScreenCalls.failAll { name, componentId -> ErrorTexts.nativeCallReloaded(name, componentId) }
-            // Scroll listeners that found no event dispatcher listen now.
-            ScrollEvents.dispatcherReady()
             Navigators.all().filter { it.isNavigationResumed }.forEach(::launchIfDue)
         }
     }
@@ -92,7 +93,7 @@ internal object ReloadCoordinator {
      */
     fun launchIfDue(activity: NavigationActivity) {
         val context = launches.takeDue(activity, activity.isNavigationResumed) ?: return
-        NavigationStateReporter.reset()
+        NavigationState.reset()
         EventEmitter(context).emitAppLaunched()
     }
 }

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

@@ -0,0 +1,177 @@
+package dev.apexnative.navigation.react
+
+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.events.EventEmitter
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * What JavaScript knows of each screen's place, by the screen's id, in one record: its safe area (the insets JavaScript
+ * gets and the padding of its safe area view, `useSafeAreaInsets`), its reserved regions (`useReservedRegions`) and,
+ * in a pair, its arrangement (`useArrangement`). The core measures them (`ScreenSafeArea`, [ScreenRegions], the pair's
+ * plan) on the main thread and keeps them here; JavaScript reads them from its own thread for a screen's first render
+ * and gets every change as an event. The record is immutable and replaced at once, so a reader on another thread sees
+ * one whole record. When the screen goes, [remove] clears all of it. As on iOS (`ANNScreenEnvironment`).
+ */
+internal object ScreenEnvironment {
+    /** How much covers each edge of a screen's content, in dp. */
+    data class Insets(val top: Double, val right: Double, val bottom: Double, val left: Double)
+
+    /** A reserved region, in dp from the top left of the screen's content. */
+    data class Region(val x: Double, val y: Double, val width: Double, val height: Double)
+
+    /** Where a screen divides (`division`) and where hardware covers it (`occlusion`). */
+    data class Regions(val division: List<Region>, val occlusion: List<Region>) {
+        val isEmpty: Boolean get() = division.isEmpty() && occlusion.isEmpty()
+    }
+
+    /** Which screen of its pair a screen is, how the pair lies, whether it lies over the other one and is hidden. */
+    data class Arrangement(val placement: String, val layout: String, val front: Boolean, val hidden: Boolean)
+
+    /** Where the changes JavaScript hears go: the events of the screen's JavaScript, or a test's record. */
+    interface Changes {
+        fun insetsChanged(screenId: String, insets: Insets)
+
+        fun regionsChanged(screenId: String, regions: Regions)
+
+        fun arrangementChanged(screenId: String, arrangement: Arrangement)
+    }
+
+    // One screen's record; null for a fact not known yet (not laid out, outside a pair).
+    private data class Record(
+        val insets: Insets? = null,
+        val padding: Insets? = null,
+        val regions: Regions? = null,
+        val arrangement: Arrangement? = null,
+    )
+
+    private val NO_REGIONS = Regions(emptyList(), emptyList())
+    private val records = ConcurrentHashMap<String, Record>()
+    // Main thread only.
+    private val paddingListeners = HashMap<String, MutableSet<() -> Unit>>()
+
+    /**
+     * Keeps the screen's [insets] for JavaScript (what still covers its content) and the [padding] of its safe area
+     * view. Calls the screen's padding listeners when the padding changed, then tells JavaScript when the insets did.
+     * Main thread only.
+     */
+    fun setInsets(screenId: String, insets: Insets, padding: Insets, changes: Changes) {
+        val before = update(screenId) { it.copy(insets = insets, padding = padding) }
+        if (before?.padding != padding) paddingListeners[screenId]?.toList()?.forEach { it() }
+        if (before?.insets != insets) changes.insetsChanged(screenId, insets)
+    }
+
+    /**
+     * Keeps the screen's [regions], and tells JavaScript when they changed; none at first is what JavaScript reads
+     * before the first layout, so it isn't told. Main thread only.
+     */
+    fun setRegions(screenId: String, regions: Regions, changes: Changes) {
+        val before = update(screenId) { it.copy(regions = regions) }?.regions
+        if (before == regions || (before == null && regions.isEmpty)) return
+        changes.regionsChanged(screenId, regions)
+    }
+
+    /** Keeps the screen's [arrangement], and tells JavaScript when it changed and [notify] holds. Main thread only. */
+    fun setArrangement(screenId: String, arrangement: Arrangement, notify: Boolean, changes: Changes) {
+        val before = update(screenId) { it.copy(arrangement = arrangement) }?.arrangement
+        if (before == arrangement || !notify) return
+        changes.arrangementChanged(screenId, arrangement)
+    }
+
+    /** The padding of the screen's safe area view; none before the screen was laid out. Any thread. */
+    fun padding(screenId: String): Insets? = records[screenId]?.padding
+
+    /** The insets JavaScript gets; none before the screen was laid out. Any thread. */
+    fun insets(screenId: String): Insets? = records[screenId]?.insets
+
+    /** The screen's reserved regions; none before its first layout. Any thread. */
+    fun regions(screenId: String): Regions? = records[screenId]?.regions
+
+    /** The screen's arrangement; none outside a pair. Any thread. */
+    fun arrangement(screenId: String): Arrangement? = records[screenId]?.arrangement
+
+    /**
+     * Calls `listener` when the padding of the screen changes; returns the function that stops it. Main thread only.
+     */
+    fun listenToPadding(screenId: String, listener: () -> Unit): () -> Unit {
+        paddingListeners.getOrPut(screenId) { LinkedHashSet() }.add(listener)
+        return {
+            paddingListeners[screenId]?.let {
+                it.remove(listener)
+                if (it.isEmpty()) paddingListeners.remove(screenId)
+            }
+        }
+    }
+
+    /**
+     * Forgets everything kept for the screen. Its padding listeners stay: a live safe area view keeps listening while
+     * it keeps the id, and stops itself.
+     */
+    fun remove(screenId: String) {
+        records.remove(screenId)
+    }
+
+    /** `getScreenInsets`: `{ top, right, bottom, left }`, empty before the screen was laid out. Any thread. */
+    fun getScreenInsets(screenId: String): WritableMap = insets(screenId)?.let(::toMap) ?: Arguments.createMap()
+
+    /** `getScreenRegions`: `{ division, occlusion }`, empty lists before the first layout. Any thread. */
+    fun getScreenRegions(screenId: String): WritableMap = toMap(regions(screenId) ?: NO_REGIONS)
+
+    /** `getArrangementState`: `{ placement, layout, front, hidden }`, empty outside a pair. Any thread. */
+    fun getArrangementState(screenId: String): WritableMap =
+        arrangement(screenId)?.let(::toMap) ?: Arguments.createMap()
+
+    /** The changes as events through [emitter], the one of the JavaScript the screen was made for. */
+    fun changesOf(emitter: EventEmitter): Changes = object : Changes {
+        override fun insetsChanged(screenId: String, insets: Insets) =
+            emitter.emitScreenInsetsChanged(screenId, toMap(insets))
+
+        override fun regionsChanged(screenId: String, regions: Regions) =
+            emitter.emitScreenRegionsChanged(screenId, toMap(regions))
+
+        override fun arrangementChanged(screenId: String, arrangement: Arrangement) =
+            emitter.emitArrangementChanged(screenId, toMap(arrangement))
+    }
+
+    // Replaces the screen's record at once with [change] of it; returns the record before, null for a new screen.
+    private fun update(screenId: String, change: (Record) -> Record): Record? {
+        var before: Record? = null
+        records.compute(screenId) { _, old ->
+            before = old
+            change(old ?: Record())
+        }
+        return before
+    }
+
+    private fun toMap(value: Insets): WritableMap = Arguments.createMap().apply {
+        putDouble(EventContract.ScreenInsetsChanged.TOP, value.top)
+        putDouble(EventContract.ScreenInsetsChanged.RIGHT, value.right)
+        putDouble(EventContract.ScreenInsetsChanged.BOTTOM, value.bottom)
+        putDouble(EventContract.ScreenInsetsChanged.LEFT, value.left)
+    }
+
+    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)
+            })
+        }
+    }
+
+    private fun toMap(value: Arrangement): WritableMap = Arguments.createMap().apply {
+        putString(EventContract.ArrangementChanged.PLACEMENT, value.placement)
+        putString(EventContract.ArrangementChanged.LAYOUT, value.layout)
+        putBoolean(EventContract.ArrangementChanged.FRONT, value.front)
+        putBoolean(EventContract.ArrangementChanged.HIDDEN, value.hidden)
+    }
+}

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

@@ -3,38 +3,33 @@ package dev.apexnative.navigation.react
 import android.app.Activity
 import android.graphics.Rect
 import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.ReactApplication
-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. 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, screenId: String, content: Rect, insets: WindowInsetsCompat?) {
+    fun update(
+        activity: Activity,
+        screenId: String,
+        content: Rect,
+        insets: WindowInsetsCompat?,
+        emitter: EventEmitter,
+    ) {
         val folds = WindowFolds.of(activity)?.folds.orEmpty()
         val cutouts = insets?.displayCutout?.boundingRects.orEmpty()
         val density = activity.resources.displayMetrics.density
@@ -43,18 +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
-        val reactContext = (activity.application as? ReactApplication)?.reactHost?.currentReactContext ?: return
-        EventEmitter(reactContext).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
@@ -69,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)
-            })
-        }
-    }
 }