@apexnative/navigation 1.0.0-alpha.0 → 1.0.0-alpha.10

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,22 +28,39 @@ 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 STATE_COMMANDS) guarded("report the navigation state") { events.beforeAnswer() }
+        if (commandName in CommandContract.STATE) reportStateNow()
         promise.resolve(value)
         val commandId = commandId
-        if (commandName in COMPLETED_COMMANDS && commandId != null) {
+        if (commandName in CommandContract.COMPLETED && commandId != null) {
             guarded("send ANN.CommandCompleted") { events.commandCompleted(commandName, commandId, clock()) }
         }
     }
@@ -65,44 +83,19 @@ internal class CommandAnswer(
             log("[ApexNavigation] $commandName: ${ErrorTexts.couldNot(what, ErrorTexts.reasonOf(e))}")
         }
     }
-
-    companion object {
-        // The commands that send `ANN.CommandCompleted` (EVT-CommandCompleted).
-        val COMPLETED_COMMANDS = setOf(
-            "setRoot",
-            "push",
-            "pop",
-            "popTo",
-            "popToRoot",
-            "setStackRoot",
-            "showInColumn",
-            "showModal",
-            "dismissModal",
-            "dismissAllModals",
-            "showOverlay",
-            "dismissOverlay",
-            "dismissAllOverlays",
-        )
-
-        // The commands whose answer comes after the navigation state: those and `setColumnShown`.
-        val STATE_COMMANDS = COMPLETED_COMMANDS + "setColumnShown"
-    }
 }
 
 /** 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/CommandContract.kt

@@ -0,0 +1,59 @@
+// Made by scripts/contract.mjs from src/interfaces/contract/commands.json: change that file and run the script again.
+
+package dev.apexnative.navigation.react
+
+/**
+ * What the commands with a promise answer, the same table as iOS. What each resolves with:
+ * - `setRoot`: the id of the root, once the root and the layout's modals and overlays show.
+ * - `push`: the id of the screen that shows; of a pair, the pair's id.
+ * - `preparePush`: the frame `{ width, height, padding }` of the prepared screen, or null; always null on iOS.
+ * - `pop`: the id of the screen that went.
+ * - `popTo`: the id of the screen it went back to.
+ * - `popToRoot`: the id of the first screen of the stack.
+ * - `setStackRoot`: the id of the new top screen.
+ * - `showModal`: the id of the modal's root.
+ * - `dismissModal`: the id of the modal's root.
+ * - `dismissAllModals`: an empty string.
+ * - `showOverlay`: the id of the overlay's root.
+ * - `dismissOverlay`: the id of the overlay's root.
+ * - `dismissAllOverlays`: an empty string.
+ * - `showInColumn`: the id of the screen that shows.
+ * - `setColumnShown`: nothing once the columns stopped moving (`undefined` on iOS, `null` on Android).
+ * - `getLaunchLink`: the link that launched the app, or null.
+ */
+internal object CommandContract {
+    /** The commands whose answer comes after the navigation state: every one that may change what shows. */
+    val STATE: Set<String> = setOf(
+        "setRoot",
+        "push",
+        "pop",
+        "popTo",
+        "popToRoot",
+        "setStackRoot",
+        "showModal",
+        "dismissModal",
+        "dismissAllModals",
+        "showOverlay",
+        "dismissOverlay",
+        "dismissAllOverlays",
+        "showInColumn",
+        "setColumnShown",
+    )
+
+    /** The commands that send `ANN.CommandCompleted` after their answer: every one that shows or dismisses. */
+    val COMPLETED: Set<String> = setOf(
+        "setRoot",
+        "push",
+        "pop",
+        "popTo",
+        "popToRoot",
+        "setStackRoot",
+        "showModal",
+        "dismissModal",
+        "dismissAllModals",
+        "showOverlay",
+        "dismissOverlay",
+        "dismissAllOverlays",
+        "showInColumn",
+    )
+}

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/ErrorTexts.kt

@@ -1,3 +1,5 @@
+// Made by scripts/contract.mjs from src/interfaces/contract/errors.json: change that file and run the script again.
+
 package dev.apexnative.navigation.react
 
 /**
@@ -6,116 +8,129 @@ package dev.apexnative.navigation.react
  * <command>:`.
  */
 internal object ErrorTexts {
-    fun screenNotShown(id: String) = "the screen '$id' is not shown"
+    // Where the screen is.
+
+    fun screenNotShown(componentId: String) = "the screen '$componentId' is not shown"
 
-    fun notInStack(id: String) = "the screen '$id' is not in a stack"
+    fun notInStack(componentId: String) = "the screen '$componentId' is not in a stack"
 
-    fun firstScreenOfStack(id: String) = "the screen '$id' is the first screen of its stack"
+    fun firstScreenOfStack(componentId: String) = "the screen '$componentId' is the first screen of its stack"
 
-    fun notInThisStack(id: String) = "the screen '$id' is not in this stack"
+    fun notInThisStack(componentId: String) = "the screen '$componentId' is not in this stack"
 
-    fun notInModal(id: String) = "the screen '$id' is not in a modal"
+    fun notInModal(componentId: String) = "the screen '$componentId' is not in a modal"
 
-    fun notInOverlay(id: String) = "the screen '$id' is not in an overlay"
+    fun notInOverlay(componentId: String) = "the screen '$componentId' is not in an overlay"
 
-    fun notInSplitView(id: String) = "the screen '$id' is not in a split view"
+    fun notInSplitView(componentId: String) = "the screen '$componentId' is not in a split view"
 
-    fun neitherSplitViewNorStack(id: String) = "the screen '$id' is neither in a split view nor in a stack"
+    fun neitherSplitViewNorStack(componentId: String) =
+        "the screen '$componentId' is neither in a split view nor in a stack"
 
-    fun noSuchColumn(id: String, column: String) = "the split view of the screen '$id' has no '$column' column"
+    fun noSuchColumn(componentId: String, column: String) =
+        "the split view of the screen '$componentId' has no '$column' column"
 
-    fun columnIsStack(id: String, column: String) =
-        "the '$column' column of the split view of the screen '$id' is a stack: it takes a screen, not a stack"
+    fun columnIsStack(componentId: String, column: String) =
+        "the '$column' column of the split view of the screen '$componentId' is a stack: it takes a screen, not a stack"
 
-    fun columnNotStack(id: String, column: String) =
-        "the '$column' column of the split view of the screen '$id' is not a stack"
+    fun columnNotStack(componentId: String, column: String) =
+        "the '$column' column of the split view of the screen '$componentId' is not a stack"
 
-    fun noScreensForStack(id: String) = "there are no screens to put in the stack of the screen '$id'"
+    fun noScreensForStack(componentId: String) = "there are no screens to put in the stack of the screen '$componentId'"
 
-    fun alreadyShown(id: String) = "the screen '$id' shows already: an id goes to one screen"
+    fun alreadyShown(componentId: String) = "the screen '$componentId' shows already: an id goes to one screen"
 
-    fun setRootReplaced(id: String) =
-        "setRoot was replaced by a newer setRoot before the root '$id' finished showing"
+    // Root, modals, the app.
 
-    fun rootDestroyed(id: String) = "the root '$id' was destroyed before it showed"
+    fun setRootReplaced(rootId: String) =
+        "setRoot was replaced by a newer setRoot before the root '$rootId' finished showing"
 
-    fun modalWithoutRoot(id: String) = "the modal '$id' can't be dismissed: there is no root under it"
+    fun rootDestroyed(rootId: String) = "the root '$rootId' was destroyed before it showed"
+
+    fun modalWithoutRoot(componentId: String) = "the modal '$componentId' can't be dismissed: there is no root under it"
 
     fun nowhereToShow() = "the navigation has nowhere to show screens: the app has no activity or window"
 
+    // Native screens.
+
     fun nativeScreenNotRegistered(name: String) = "no native screen is registered as '$name'"
 
     fun nativeScreenNotCreated(name: String) =
         "the native screen '$name' could not be created: its creator returned nothing"
 
-    fun unknownNodeType(type: String) = "the layout has a node of unknown type '$type'"
+    /** The error of a call of a native screen whose JavaScript reloaded before it answered. */
+    fun nativeCallReloaded(name: String, componentId: String) =
+        "JavaScript reloaded before the call '$name' of the screen '$componentId' was answered"
 
-    fun nodeWithoutId(type: String) = "the layout has a node of type '$type' without an id"
+    /** The error of a call of a native screen while no JavaScript can answer it. */
+    fun nativeCallNotRunning(name: String, componentId: String) =
+        "the navigation is not running: the call '$name' of the screen '$componentId' can't be answered"
 
-    fun sideMenuChild(id: String, type: String) =
-        "the side menu '$id' has a child of type '$type': it takes SideMenuLeft, SideMenuCenter and SideMenuRight"
+    // The layout.
 
-    fun stackTakesScreens(id: String, type: String) = "the stack '$id' takes screens, not a '$type'"
+    fun unknownNodeType(type: String) = "the layout has a node of unknown type '$type'"
 
-    fun emptyStack(id: String) = "the stack '$id' has no screens"
+    fun nodeWithoutId(type: String) = "the layout has a node of type '$type' without an id"
 
-    fun emptyTabs(id: String) = "the tabs '$id' have no tabs"
+    fun sideMenuChild(menuId: String, type: String) =
+        "the side menu '$menuId' has a child of type '$type': it takes SideMenuLeft, SideMenuCenter and SideMenuRight"
 
-    fun tooManyTabs(id: String, count: Int) = "the tabs '$id' have $count tabs: Android shows at most 5"
+    fun stackTakesScreens(stackId: String, type: String) = "the stack '$stackId' takes screens, not a '$type'"
 
-    fun splitViewColumns(id: String) = "the split view '$id' needs its primary and its secondary column"
+    fun emptyStack(stackId: String) = "the stack '$stackId' has no screens"
 
-    fun pairUnsupported(id: String) = "the pair '$id' needs iOS 27.1 and an app built with its SDK"
+    fun emptyTabs(tabsId: String) = "the tabs '$tabsId' have no tabs"
 
-    fun pairNeedsTwoScreens(id: String) = "the pair '$id' needs two screens: its primary and its secondary"
+    /** Only Android checks it: its tab bar shows at most 5 tabs. */
+    fun tooManyTabs(tabsId: String, count: Int) = "the tabs '$tabsId' have $count tabs: Android shows at most 5"
 
-    fun unreadableOption(path: String, id: String) =
-        "the option '$path' of the screen '$id' has a value the navigation can't read"
+    fun splitViewColumns(splitViewId: String) =
+        "the split view '$splitViewId' needs its primary and its secondary column"
 
-    /** `setDefaultOptions` with a value it can't read; the default options before stay. */
-    fun unreadableDefaultOption(path: String) =
-        "the option '$path' of the default options has a value the navigation can't read"
+    /** Only iOS checks it: Android has pairs on every version. */
+    fun pairUnsupported(pairId: String) = "the pair '$pairId' needs iOS 27.1 and an app built with its SDK"
 
-    fun previewGone(id: String) = "the preview '$id' went without being opened"
+    fun pairNeedsTwoScreens(pairId: String) = "the pair '$pairId' needs two screens: its primary and its secondary"
 
-    /** Any other failure: [what] the command could not do, with its screen, and [reason]. */
-    fun couldNot(what: String, reason: String) = "could not $what: $reason"
+    fun nodeWithoutName(type: String, nodeId: String) = "the layout has a node '$nodeId' of type '$type' without a name"
 
-    fun nativeCallReloaded(name: String, id: String) =
-        "JavaScript reloaded before the call '$name' of the screen '$id' was answered"
+    fun rootMissing() = "the layout of setRoot has no root"
 
-    fun nativeCallNotRunning(name: String, id: String) =
-        "the navigation is not running: the call '$name' of the screen '$id' can't be answered"
+    fun tabsInTabs(tabsId: String) = "the tabs '$tabsId' have a tab of type 'BottomTabs': tabs don't go inside tabs"
 
-    /** `mergeOptions` without a navigation activity; written to the log, `mergeOptions` has no promise. */
-    fun mergeOptionsNoActivity() = nowhereToShow()
+    fun sideMenuSides(menuId: String) =
+        "the side menu '$menuId' takes one SideMenuCenter and at most one SideMenuLeft and one SideMenuRight"
 
-    /** A command whose area the native core doesn't do yet. */
-    fun notDoneYet(method: String) = "could not run '$method': the native core doesn't do it yet"
+    fun sideChildCount(sideId: String, menuId: String) =
+        "the side '$sideId' of the side menu '$menuId' needs exactly one child"
 
-    // The other cases of the layout checks: the same style.
+    fun sideMenuInSide(menuId: String) =
+        "the side menu '$menuId' has a side menu in a side: a side menu doesn't go inside a side menu"
 
-    fun nodeWithoutName(type: String, id: String) = "the layout has a node '$id' of type '$type' without a name"
+    fun sideOutsideMenu(nodeId: String, type: String) =
+        "the layout has a node '$nodeId' of type '$type' outside a side menu"
 
-    fun rootMissing() = "the layout of setRoot has no root"
+    fun splitViewInColumn(splitViewId: String) =
+        "the split view '$splitViewId' has a column of type 'SplitView': a split view doesn't go inside a split view"
 
-    fun tabsInTabs(id: String) = "the tabs '$id' have a tab of type 'BottomTabs': tabs don't go inside tabs"
+    fun idGivenTwice(nodeId: String) = "the layout gives the id '$nodeId' to two nodes"
 
-    fun sideMenuSides(id: String) =
-        "the side menu '$id' takes one SideMenuCenter and at most one SideMenuLeft and one SideMenuRight"
+    // Options, previews, any other failure.
 
-    fun sideChildCount(sideId: String, menuId: String) =
-        "the side '$sideId' of the side menu '$menuId' needs exactly one child"
+    fun unreadableOption(path: String, componentId: String) =
+        "the option '$path' of the screen '$componentId' has a value the navigation can't read"
 
-    fun sideMenuInSide(menuId: String) =
-        "the side menu '$menuId' has a side menu in a side: a side menu doesn't go inside a side menu"
+    /** An unreadable value of `setDefaultOptions`: the default options belong to no screen. */
+    fun unreadableDefaultOption(path: String) =
+        "the option '$path' of the default options has a value the navigation can't read"
 
-    fun sideOutsideMenu(id: String, type: String) = "the layout has a node '$id' of type '$type' outside a side menu"
+    fun previewGone(previewId: String) = "the preview '$previewId' went without being opened"
 
-    fun splitViewInColumn(id: String) =
-        "the split view '$id' has a column of type 'SplitView': a split view doesn't go inside a split view"
+    /** Any other failure: what could not be done and why, `could not <what>: <reason>`. */
+    fun couldNot(what: String, reason: String) = "could not $what: $reason"
 
-    fun idGivenTwice(id: String) = "the layout gives the id '$id' to two nodes"
+    /** A command whose part of the native core is not written yet. */
+    fun notDoneYet(method: String) = "could not run '$method': the native core doesn't do it yet"
 
     /** The reason of [couldNot] for an exception: its message, else the name of its class. */
     fun reasonOf(e: Throwable): String =

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

@@ -9,26 +9,32 @@ 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
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.WindowFolds
 import java.lang.ref.WeakReference
 
 /**
  * The device's hinge (`useHinge`): its state from the fold in the activity's window, its angle from the hinge angle
- * sensor (Android 11+). Android has no public state of a closed device: closed is a window without a fold and an
- * angle under 90°. 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].
+ * 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. 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 {
-    data class Value(val state: String, val angle: Float?)
+    /** A value of the hinge: its state, and its angle in degrees to a tenth; none while the state is unknown. */
+    data class Value(val state: String, val angle: Double?)
+
+    private const val UNKNOWN = "unknown"
 
     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
@@ -59,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()
     }
@@ -127,28 +135,32 @@ internal object Hinge {
         if (!enabled) return
         val folds = folds ?: return
         if (!folds.hasInfo || (listening && angle == null)) return
-        val fold = folds.folds.firstOrNull()
-        val angle = angle
-        val value = if (fold == null && sensor == null) {
-            null
-        } else {
-            val state = when {
-                fold?.halfOpened == true -> "partiallyOpen"
-                fold != null -> "fullyOpen"
-                angle != null && angle < CLOSED_BELOW -> "closed"
-                else -> "unknown"
-            }
-            Value(state, angle)
-        }
+        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))
+    }
+
+    /**
+     * The value of the window's first [fold] and the sensor's [angle]: none without a fold and without a sensor
+     * ([hasSensor]). `closed` without a fold or under 90°, else `partiallyOpen` for a half-opened fold and `fullyOpen`
+     * for a flat one. The angle goes to a tenth, as iOS gives it: the sensor's noise doesn't make a new value, and it
+     * is left out while the state is unknown.
+     */
+    fun valueOf(fold: WindowFolds.Fold?, hasSensor: Boolean, angle: Float?): Value? {
+        if (fold == null && !hasSensor) return null
+        val state = when {
+            fold == null || (angle != null && angle < CLOSED_BELOW) -> "closed"
+            fold.halfOpened -> "partiallyOpen"
+            else -> "fullyOpen"
+        }
+        val tenths = angle?.let { Math.round(it * 10.0) / 10.0 }
+        return Value(state, tenths.takeIf { state != UNKNOWN })
     }
 
     private fun toMap(value: Value?): WritableMap = Arguments.createMap().apply {
         if (value == null) return@apply
-        putString("state", value.state)
-        value.angle?.let { putDouble("angle", it.toDouble()) }
+        putString(EventContract.HingeChanged.STATE, value.state)
+        if (value.state != UNKNOWN) value.angle?.let { putDouble(EventContract.HingeChanged.ANGLE, it) }
     }
 }