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

package/android/src/main/java/dev/apexnative/navigation/options/TopBarOptions.kt

@@ -34,12 +34,14 @@ class TopBarOptions {
     @JvmField var rightButtonDisabledColor: ThemeColour = NullThemeColour()
     @JvmField var centerButtonColor: ThemeColour = NullThemeColour()
     @JvmField var centerButtonDisabledColor: ThemeColour = NullThemeColour()
+    @JvmField var menuBackgroundColor: ThemeColour = NullThemeColour()
+    @JvmField var menuTextColor: ThemeColour = NullThemeColour()
     @JvmField var drawBehind: Bool = NullBool()
     @JvmField var testID: Text = NullText()
     @JvmField var title = TitleOptions()
     @JvmField var subtitle = SubtitleOptions()
     /** `backButton`, `leftButtons`, `rightButtons`, `centerButtons`. */
-    @JvmField var buttons = TopBarButtons()
+    @ReadFromParent @JvmField var buttons = TopBarButtons()
     @JvmField var customizationId: Text = NullText()
     /** Shared between copies, as its module wants. */
     @JvmField var overflowMenu: ButtonMenuOptions? = null
@@ -63,7 +65,8 @@ class TopBarOptions {
         hideOnTap.hasValue() || hideOnKeyboard.hasValue() || leftButtonColor.hasValue() ||
         rightButtonColor.hasValue() || leftButtonBackgroundColor.hasValue() || rightButtonBackgroundColor.hasValue() ||
         leftButtonDisabledColor.hasValue() || rightButtonDisabledColor.hasValue() || centerButtonColor.hasValue() ||
-        centerButtonDisabledColor.hasValue() || drawBehind.hasValue() || testID.hasValue() || title.hasValue() ||
+        centerButtonDisabledColor.hasValue() || menuBackgroundColor.hasValue() || menuTextColor.hasValue() ||
+        drawBehind.hasValue() || testID.hasValue() || title.hasValue() ||
         subtitle.hasValue() || buttons.hasValue() || customizationId.hasValue() || overflowMenu != null ||
         verticalBarKeeps.hasValue() || background.hasValue() || scrollEdgeAppearance.hasValue() ||
         barStyle.hasValue() || style.hasValue() || noBorder.hasValue() || searchBar.hasAnyValue() ||
@@ -85,6 +88,8 @@ class TopBarOptions {
         rightButtonDisabledColor = rightButtonDisabledColor.mergeWith(other.rightButtonDisabledColor)
         centerButtonColor = centerButtonColor.mergeWith(other.centerButtonColor)
         centerButtonDisabledColor = centerButtonDisabledColor.mergeWith(other.centerButtonDisabledColor)
+        menuBackgroundColor = menuBackgroundColor.mergeWith(other.menuBackgroundColor)
+        menuTextColor = menuTextColor.mergeWith(other.menuTextColor)
         if (other.drawBehind.hasValue()) drawBehind = other.drawBehind
         if (other.testID.hasValue()) testID = other.testID
         title.mergeWith(other.title)
@@ -127,6 +132,8 @@ class TopBarOptions {
         rightButtonDisabledColor = rightButtonDisabledColor.withDefault(defaults.rightButtonDisabledColor)
         centerButtonColor = centerButtonColor.withDefault(defaults.centerButtonColor)
         centerButtonDisabledColor = centerButtonDisabledColor.withDefault(defaults.centerButtonDisabledColor)
+        menuBackgroundColor = menuBackgroundColor.withDefault(defaults.menuBackgroundColor)
+        menuTextColor = menuTextColor.withDefault(defaults.menuTextColor)
         if (!drawBehind.hasValue()) drawBehind = defaults.drawBehind
         if (!testID.hasValue()) testID = defaults.testID
         title.mergeWithDefault(defaults.title)
@@ -178,6 +185,8 @@ class TopBarOptions {
             options.rightButtonDisabledColor = ThemeColour.parse(context, map, "rightButtonDisabledColor")
             options.centerButtonColor = ThemeColour.parse(context, map, "centerButtonColor")
             options.centerButtonDisabledColor = ThemeColour.parse(context, map, "centerButtonDisabledColor")
+            options.menuBackgroundColor = ThemeColour.parse(context, map, "menuBackgroundColor")
+            options.menuTextColor = ThemeColour.parse(context, map, "menuTextColor")
             options.drawBehind = BoolParser.parse(map, "drawBehind")
             options.testID = TextParser.parse(map, "testID")
             options.title = map.group("title") { TitleOptions.parse(context, it) }
@@ -212,13 +221,13 @@ class TopBarOptions {
  * don't give it; `[]` takes the buttons of the layers below away.
  */
 class TopBarButtons {
-    @JvmField var back = BackButtonOptions()
+    @OptionKey("backButton") @JvmField var back = BackButtonOptions()
     /** `topBar.leftButtons`; null when the options don't give them. */
-    @JvmField var left: List<ButtonOptions>? = null
+    @OptionKey("leftButtons") @JvmField var left: List<ButtonOptions>? = null
     /** `topBar.rightButtons`; null when the options don't give them. */
-    @JvmField var right: List<ButtonOptions>? = null
+    @OptionKey("rightButtons") @JvmField var right: List<ButtonOptions>? = null
     /** `topBar.centerButtons`; null when the options don't give them. */
-    @JvmField var center: List<ButtonOptions>? = null
+    @OptionKey("centerButtons") @JvmField var center: List<ButtonOptions>? = null
 
     fun hasValue(): Boolean = back.hasValue() || left != null || right != null || center != null
 
@@ -263,7 +272,7 @@ class BackButtonOptions {
     @JvmField var showTitle: Bool = NullBool()
     @JvmField var color: ThemeColour = NullThemeColour()
     @JvmField var fontSize: Fraction = NullFraction()
-    @JvmField var font = FontOptions()
+    @ReadFromParent @JvmField var font = FontOptions()
     @JvmField var iconBackground = IconBackgroundOptions()
     @JvmField var testID: Text = NullText()
     @JvmField var enableMenu: Bool = NullBool()

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

@@ -0,0 +1,95 @@
+package dev.apexnative.navigation.react
+
+import android.content.Context
+import android.util.Log
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags
+import com.facebook.react.modules.i18nmanager.I18nUtil
+import com.facebook.react.runtime.ReactSurfaceImpl
+import com.facebook.soloader.SoLoader
+import dev.apexnative.navigation.utils.NavigationLog
+
+/**
+ * The height of React content laid out at a width without a height limit, as iOS measures a sheet's `'content'`
+ * detent: Fabric lays out a copy of the tree, so the shown layout stays as it is. A React root's surface measures
+ * through `SurfaceHandler::measure`; a slot's content in the slot's own layout, once asked for ([requestSlot]), which
+ * keeps the height for [slotHeight] (`ANNSlotContentHeights`, the C++ iOS shares). The native half is the library's
+ * own C++ (`android/src/main/jni`), in the codegen library of its components; when that library doesn't load, nothing
+ * is measured. Main thread.
+ */
+internal object ContentHeights {
+    private const val LIBRARY = "react_codegen_ApexNavigationSpec"
+
+    private val loaded: Boolean by lazy {
+        try {
+            SoLoader.loadLibrary(LIBRARY)
+            true
+        } catch (e: Throwable) {
+            Log.w(NavigationLog.TAG, "[ApexNavigation] $LIBRARY doesn't load: no content is measured", e)
+            false
+        }
+    }
+
+    /**
+     * The height of [surface]'s content at [width] pixels, in pixels, with the layout context the surface lays out
+     * with (`ReactSurfaceImpl.updateLayoutSpecs`); null before the surface runs or renders, or when it can't measure.
+     */
+    fun surfaceHeight(context: Context, surface: ReactSurface, width: Int): Int? {
+        if (width <= 0 || surface !is ReactSurfaceImpl || !loaded) return null
+        val density = context.resources.displayMetrics.density
+        val scalesFont = ReactNativeFeatureFlags.enableFontScaleChangesUpdatingLayout()
+        val fontScale = if (scalesFont) context.resources.configuration.fontScale else 1f
+        val height = try {
+            nativeSurfaceHeight(
+                surface,
+                width / density,
+                density,
+                fontScale,
+                I18nUtil.instance.isRTL(context),
+                I18nUtil.instance.doLeftAndRightSwapInRTL(context),
+            )
+        } catch (e: Throwable) {
+            Log.w(NavigationLog.TAG, "[ApexNavigation] the content of a surface can't be measured", e)
+            return null
+        }
+        return if (height > 0f) Math.round(height * density) else null
+    }
+
+    /** The content of the slot [slotId] is measured from its next layout on. */
+    fun requestSlot(slotId: String) {
+        if (loaded) nativeRequestSlot(slotId)
+    }
+
+    /** The content of the slot [slotId] is measured. */
+    fun isSlotRequested(slotId: String): Boolean = loaded && nativeIsSlotRequested(slotId)
+
+    /** The height of the content of the slot [slotId] at its last layout, in dp; null before it. */
+    fun slotHeight(slotId: String): Float? = if (loaded) nativeSlotHeight(slotId).takeIf { it >= 0f } else null
+
+    /** The screen of the slot [slotId] went: nothing more is measured for it. */
+    fun forgetSlot(slotId: String) {
+        if (loaded) nativeForgetSlot(slotId)
+    }
+
+    @JvmStatic
+    private external fun nativeRequestSlot(slotId: String)
+
+    @JvmStatic
+    private external fun nativeIsSlotRequested(slotId: String): Boolean
+
+    @JvmStatic
+    private external fun nativeSlotHeight(slotId: String): Float
+
+    @JvmStatic
+    private external fun nativeForgetSlot(slotId: String)
+
+    @JvmStatic
+    private external fun nativeSurfaceHeight(
+        surface: ReactSurfaceImpl,
+        width: Float,
+        pointScale: Float,
+        fontScale: Float,
+        rtl: Boolean,
+        swapLeftAndRight: Boolean,
+    ): Float
+}

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

@@ -0,0 +1,66 @@
+package dev.apexnative.navigation.react
+
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.bridge.UIManagerListener
+import com.facebook.react.common.annotations.UnstableReactNativeAPI
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.common.UIManagerType
+import dev.apexnative.navigation.NavigationApplication
+
+/**
+ * The handlers of a screen's content that hear each mount of Fabric (`IReactView.setOnContentMounted`), by key, while
+ * [hears] holds (the content is in a window and not destroyed). Fabric tells every mount of the app, on the main
+ * thread, not those of one surface: the handlers measure and compare, so a mount elsewhere costs only that. It listens
+ * only while a handler waits. Main thread only.
+ */
+internal class ContentMounts(private val hears: () -> Boolean) {
+    private val handlers = LinkedHashMap<String, Runnable>()
+    // The UI manager that tells the mounts; none while no handler waits.
+    private var uiManager: UIManager? = null
+
+    // React Native marks the listener unstable; it is the one place that tells a mount.
+    @OptIn(UnstableReactNativeAPI::class)
+    private val listener = object : UIManagerListener {
+        override fun willDispatchViewUpdates(uiManager: UIManager) = Unit
+
+        override fun willMountItems(uiManager: UIManager) = Unit
+
+        override fun didMountItems(uiManager: UIManager) {
+            if (hears()) run()
+        }
+
+        override fun didDispatchMountItems(uiManager: UIManager) = Unit
+
+        override fun didScheduleMountItems(uiManager: UIManager) = Unit
+    }
+
+    /** [handler] runs after each mount under [key]; null removes the handler of [key]. */
+    fun set(key: String, handler: Runnable?) {
+        if (handler == null) handlers.remove(key) else handlers[key] = handler
+        if (handlers.isEmpty()) stop() else start()
+    }
+
+    /** Runs the handlers now: a mount the content tells itself. */
+    fun run() = handlers.values.toList().forEach(Runnable::run)
+
+    /** The content goes: no handler runs again. */
+    fun clear() {
+        handlers.clear()
+        stop()
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    private fun start() {
+        if (uiManager != null) return
+        val reactContext = NavigationApplication.instanceOrNull?.reactGatewayOrNull?.currentReactContext ?: return
+        uiManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)?.also {
+            it.addUIManagerEventListener(listener)
+        }
+    }
+
+    @OptIn(UnstableReactNativeAPI::class)
+    private fun stop() {
+        uiManager?.removeUIManagerEventListener(listener)
+        uiManager = null
+    }
+}

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

@@ -55,6 +55,10 @@ class NavigationTurboModule(reactContext: ReactApplicationContext) : NativeANNTu
     override fun mergeOptions(componentId: String, options: ReadableMap) =
         optionsCommands.mergeOptions(componentId, options)
 
+    // Development (Fast Refresh): the options an edit took out of a screen that shows; as mergeOptions without one.
+    override fun clearOptions(componentId: String, paths: ReadableArray) =
+        optionsCommands.clearOptions(componentId, paths)
+
     override fun push(commandId: String, componentId: String, layout: ReadableMap, promise: Promise) {
         val what = "push the screen '${LayoutReader.idOf(layout)}'"
         runner.run(
@@ -236,11 +240,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/OptionsCommands.kt

@@ -1,8 +1,11 @@
 package dev.apexnative.navigation.react
 
 import android.content.Context
+import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import dev.apexnative.navigation.options.DefaultOptions
+import dev.apexnative.navigation.options.OptionPaths
 import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.options.OptionsReader
 import dev.apexnative.navigation.system.AppDirection
@@ -10,9 +13,9 @@ import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
 /**
- * The commands of the options, `setDefaultOptions` and `mergeOptions`: both without a promise. Their options are read
- * on the module thread, in the runner's step before the main task; the main task stores and applies them. What can't be
- * read is logged (`[ApexNavigation] <method>: <text>`); the app goes on.
+ * The commands of the options, `setDefaultOptions`, `mergeOptions` and `clearOptions`: all without a promise. Their
+ * options and paths are read on the module thread, in the runner's step before the main task; the main task stores
+ * and applies them. What can't be read is logged (`[ApexNavigation] <method>: <text>`); the app goes on.
  */
 internal class OptionsCommands(
     private val runner: CommandRunner,
@@ -30,6 +33,11 @@ internal class OptionsCommands(
      * system UI follows (`Navigator.optionsMerged`, `mergeOptions` step 5). Main thread.
      */
     private val merged: (ViewController<*>, Options) -> Unit = { _, _ -> },
+    /**
+     * Repaints what shows in the current navigation activity, as [repaint] does without new default options
+     * (`Navigator.repaint`), after `clearOptions`. Main thread.
+     */
+    private val repaintCurrent: () -> Unit = {},
 ) {
     constructor(runner: CommandRunner, context: () -> Context?) : this(
         runner = runner,
@@ -40,6 +48,7 @@ internal class OptionsCommands(
             Navigators.all().forEach { it.navigator?.defaultOptionsChanged(direction) }
         },
         merged = { node, options -> Navigators.current()?.navigator?.optionsMerged(node, options) },
+        repaintCurrent = { Navigators.current()?.navigator?.repaint() },
     )
 
     /**
@@ -82,8 +91,37 @@ internal class OptionsCommands(
         merged(node, read.options)
     }
 
+    /**
+     * `clearOptions` (development: Fast Refresh, after an edit took options out of a screen that shows): the values at
+     * [paths] (`topBar.subtitle`; a group's path for the whole group) leave the own options of the node [componentId]
+     * names, through `ViewController.changeOptions` ([OptionPaths.clear]), so it resolves to what the layouts around it
+     * and the defaults give there; the user layer stays. The stack it is in writes its back arrow's visibility into
+     * them again (`StackController.ownOptionsCleared`), then what shows is repainted as after `setDefaultOptions`. No
+     * node with that id, or no path that names an option: nothing, not even a log line. Without an activity: one log
+     * line, as `mergeOptions`.
+     */
+    fun clearOptions(componentId: String, paths: ReadableArray) = runner.runVoid(
+        name = CLEAR_OPTIONS,
+        what = "clear the options of the screen '$componentId'",
+        prepare = {
+            (0 until paths.size()).filter { paths.getType(it) == ReadableType.String }.mapNotNull(paths::getString)
+        },
+    ) { read ->
+        if (!runner.hasActivity()) {
+            runner.logFailure(CLEAR_OPTIONS, ErrorTexts.nowhereToShow())
+            return@runVoid
+        }
+        val node = findNode(componentId) ?: return@runVoid
+        val known = read.filter { OptionPaths.find(node.options, it) != null }
+        if (known.isEmpty()) return@runVoid
+        node.changeOptions { own -> known.forEach { OptionPaths.clear(own, it) } }
+        node.findParentStack()?.ownOptionsCleared(node)
+        repaintCurrent()
+    }
+
     private companion object {
         const val SET_DEFAULT_OPTIONS = "setDefaultOptions"
         const val MERGE_OPTIONS = "mergeOptions"
+        const val CLEAR_OPTIONS = "clearOptions"
     }
 }

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

@@ -3,6 +3,7 @@ package dev.apexnative.navigation.react
 import android.annotation.SuppressLint
 import android.content.Context
 import android.os.Bundle
+import android.util.Size
 import android.view.MotionEvent
 import android.view.ViewGroup
 import android.widget.FrameLayout
@@ -28,7 +29,9 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListe
  * 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.
+ * Ready once, ready for good; what waits for it ([whenReady]) runs then, once. Its content measures without a height
+ * limit ([contentSize], `ContentHeights`), and the handlers of [setOnContentMounted] hear each mount of Fabric while
+ * the view is in a window.
  * 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`).
@@ -51,6 +54,7 @@ class ReactView @JvmOverloads constructor(
     private var readyTold = false
     private val readyListeners = mutableListOf<Runnable>()
     private var listening = false
+    private val mounts = ContentMounts { !destroyed && isAttachedToWindow }
 
     // What this root hears of its id: only the signals of its own surface.
     private val readiness = object : ScreenReadiness.Listener {
@@ -112,6 +116,16 @@ class ReactView @JvmOverloads constructor(
     override val touchRoot: ViewGroup?
         get() = surface?.view as? ViewGroup
 
+    override fun contentSize(maxWidth: Int): Size? {
+        val surface = surface ?: return null
+        val height = ContentHeights.surfaceHeight(context, surface, maxWidth) ?: return null
+        return Size(maxWidth, height)
+    }
+
+    override fun setOnContentMounted(key: String, handler: Runnable?) {
+        if (!destroyed) mounts.set(key, handler)
+    }
+
     override fun isReady(): Boolean {
         if (!ready && hasRendered()) ready = true
         return ready
@@ -167,6 +181,7 @@ class ReactView @JvmOverloads constructor(
         AppearanceDispatcher.didDisappear(appearance)
         destroyed = true
         readyListeners.clear()
+        mounts.clear()
         stopListening()
         if (rendersAtOnce) ScreenReadiness.setRendersAtOnce(componentId, this, false)
         val surface = surface ?: return

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

@@ -82,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)
         }
     }

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)
+    }
+}