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

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

@@ -0,0 +1,41 @@
+package dev.apexnative.navigation.react
+
+import android.content.Context
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import dev.apexnative.navigation.react.events.EventEmitter
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * The state of each screen of a pair (`useArrangement`): which screen of the pair it is, how the pair lies, whether it
+ * lies over the other one and whether it is out of the window. Set on the main thread as the pair lays out; JavaScript
+ * reads it from its own thread for a screen's first render, and gets every change as `ANN.ArrangementChanged`. A
+ * screen outside a pair has none.
+ */
+internal object ArrangementStates {
+    data class State(val placement: String, val layout: String, val front: Boolean, val hidden: Boolean)
+
+    private val states = ConcurrentHashMap<String, State>()
+
+    /** Keeps the screen's state, and tells JavaScript when it changed and [notify] holds. Main thread only. */
+    fun set(context: Context, screenId: String, state: State, notify: Boolean) {
+        if (states.put(screenId, state) == state || !notify) return
+        val reactContext = (context.applicationContext as? ReactApplication)?.reactHost?.currentReactContext ?: return
+        EventEmitter(reactContext).emitArrangementChanged(screenId, toMap(state))
+    }
+
+    /** `{ placement, layout, front, hidden }`, empty for a screen outside a pair. Any thread. */
+    fun get(screenId: String): WritableMap = states[screenId]?.let(::toMap) ?: Arguments.createMap()
+
+    fun remove(screenId: String) {
+        states.remove(screenId)
+    }
+
+    private fun toMap(state: State): WritableMap = Arguments.createMap().apply {
+        putString("placement", state.placement)
+        putString("layout", state.layout)
+        putBoolean("front", state.front)
+        putBoolean("hidden", state.hidden)
+    }
+}

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

@@ -0,0 +1,111 @@
+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.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.
+ */
+internal class CommandAnswer(
+    /** The method of the command: `push`, `setRoot`, … */
+    val commandName: String,
+    /** The command's id; none for `getLaunchLink`, the push's own for `preparePush`. */
+    val commandId: String?,
+    private val promise: Promise,
+    /** The number of the JavaScript the command came from (`ReloadCoordinator`). */
+    val generation: Int,
+    private val events: AnswerEvents = AnswerEvents.Current,
+    private val clock: () -> Long = System::currentTimeMillis,
+    private val log: (String) -> Unit = { Log.e(NavigationLog.TAG, it) },
+) {
+    /** The command has answered. */
+    var isAnswered = false
+        private set
+
+    /** 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.
+     */
+    fun resolve(value: Any?) {
+        if (!canAnswer) return
+        isAnswered = true
+        if (commandName in STATE_COMMANDS) guarded("report the navigation state") { events.beforeAnswer() }
+        promise.resolve(value)
+        val commandId = commandId
+        if (commandName in COMPLETED_COMMANDS && commandId != null) {
+            guarded("send ANN.CommandCompleted") { events.commandCompleted(commandName, commandId, clock()) }
+        }
+    }
+
+    /** Rejects the promise with [text] alone: no code of the navigation's own. */
+    fun reject(text: String) {
+        if (!canAnswer) return
+        isAnswered = true
+        promise.reject(null, text)
+    }
+
+    /** A [CommandListener] that answers this command: success resolves with the id, an error rejects. */
+    fun asListener(): CommandListener = AnswerListener(this)
+
+    // A step around the promise that must not keep the promise from going.
+    private inline fun guarded(what: String, step: () -> Unit) {
+        try {
+            step()
+        } catch (e: Throwable) {
+            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()
+
+    /** 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 commandCompleted(commandName: String, commandId: String, completionTime: Long) {
+            EventEmitter.current().emitCommandCompleted(commandName, commandId, completionTime)
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package dev.apexnative.navigation.react
+
+/**
+ * The answer of a command on the native side: [onSuccess] with the id of the screen it names, or [onError] with the
+ * reason, which rejects the command's promise. A command's answer gives one ([CommandAnswer.asListener]). Main thread.
+ */
+interface CommandListener {
+    /** The command succeeded; [childId] is the screen it names. */
+    fun onSuccess(childId: String)
+
+    /** The command failed for [message], a text of the navigation's table. */
+    fun onError(message: String)
+}
+
+/** A [CommandListener] that does nothing until a method is overridden. */
+open class CommandListenerAdapter : CommandListener {
+    override fun onSuccess(childId: String) = Unit
+
+    override fun onError(message: String) = Unit
+}
+
+/** The [CommandListener] of a command's [CommandAnswer]: [onSuccess] resolves with the id, [onError] rejects. */
+internal class AnswerListener(private val answer: CommandAnswer) : CommandListener {
+    override fun onSuccess(childId: String) = answer.resolve(childId)
+
+    override fun onError(message: String) = answer.reject(message)
+}

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

@@ -0,0 +1,131 @@
+package dev.apexnative.navigation.react
+
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import dev.apexnative.navigation.layout.LayoutException
+import dev.apexnative.navigation.utils.NavigationLog
+import dev.apexnative.navigation.utils.UiThread
+import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
+import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
+
+/**
+ * The one path of every asynchronous method of `ANNTurboModule`. On the module thread, at once: the command takes the
+ * number of its JavaScript ([ReloadCoordinator]) and its layout is read and checked whole; a failure rejects right
+ * there and nothing is queued. Then one main-thread task per command, in call order, does all its work: nothing when
+ * its JavaScript went, a rejection when the navigation has nowhere to show screens, else the command's body. A command
+ * without a promise always runs its body: one that needs the navigation finds none without an activity and does
+ * nothing, or logs it ([hasActivity]). An exception in the body rejects the command (or, without a promise, writes one
+ * line to the log); it never ends the app. After each main-thread task, done or rejected, what back does is computed
+ * again for every activity ([afterCommand]): `setDefaultOptions` and `mergeOptions` too.
+ */
+internal class CommandRunner(
+    private val post: (Runnable) -> Unit,
+    private val activityPresent: () -> Boolean,
+    private val events: AnswerEvents,
+    private val log: (String) -> Unit,
+    private val afterCommand: () -> Unit = { BackCallbackState.update() },
+) {
+    constructor() : this(
+        post = { UiThread.post(it) },
+        activityPresent = { Navigators.current() != null },
+        events = AnswerEvents.Current,
+        log = { Log.e(NavigationLog.TAG, it) },
+    )
+
+    /** Whether the app has a navigation activity for commands to run in (`Navigators.current`). Main thread. */
+    fun hasActivity(): Boolean = activityPresent()
+
+    /**
+     * Runs the command [name] with a promise. [check] reads and checks its layout on the calling (module) thread; a
+     * `LayoutException` rejects with its text, another exception with `ErrorTexts.couldNot` of [what]. [body] runs
+     * on the main thread with what [check] read and the command's [CommandAnswer]; [needsActivity] false for the
+     * commands that answer without one (`preparePush`, `getLaunchLink`).
+     */
+    fun <L> run(
+        name: String,
+        commandId: String?,
+        what: String,
+        promise: Promise,
+        needsActivity: Boolean = true,
+        check: () -> L,
+        body: (L, CommandAnswer) -> Unit,
+    ) {
+        val generation = ReloadCoordinator.generation
+        val layout = try {
+            check()
+        } catch (e: LayoutException) {
+            promise.reject(null, e.text)
+            return
+        } catch (e: Throwable) {
+            promise.reject(null, ErrorTexts.couldNot(what, ErrorTexts.reasonOf(e)))
+            return
+        }
+        post(Runnable {
+            if (!ReloadCoordinator.isCurrent(generation)) return@Runnable
+            val answer = CommandAnswer(name, commandId, promise, generation, events, log = log)
+            if (needsActivity && !hasActivity()) {
+                answer.reject(ErrorTexts.nowhereToShow())
+                afterCommand()
+                return@Runnable
+            }
+            val outer = CommandScope.isRunning
+            CommandScope.isRunning = true
+            try {
+                body(layout, answer)
+            } catch (e: LayoutException) {
+                // A layout that can't be made as the command makes it (a native screen whose creator made nothing).
+                answer.reject(e.text)
+            } catch (e: Throwable) {
+                answer.reject(ErrorTexts.couldNot(what, ErrorTexts.reasonOf(e)))
+            } finally {
+                CommandScope.isRunning = outer
+            }
+            afterCommand()
+        })
+    }
+
+    /**
+     * Runs the command [name] without a promise: one main-thread task, nothing when its JavaScript went, [body]
+     * inside the protection, with or without an activity; a failure writes
+     * `[ApexNavigation] <name>: could not <what>: <reason>` to the log.
+     */
+    fun runVoid(name: String, what: String, body: () -> Unit) = runVoid(name, what, prepare = {}) { body() }
+
+    /**
+     * As [runVoid], with a step on the calling (module) thread first: [prepare] reads what the command brings (its
+     * options) and [body] gets it on the main thread. A failure of [prepare] is logged as one of [body], and nothing
+     * is queued.
+     */
+    fun <P> runVoid(name: String, what: String, prepare: () -> P, body: (P) -> Unit) {
+        val generation = ReloadCoordinator.generation
+        val prepared = try {
+            prepare()
+        } catch (e: Throwable) {
+            logFailure(name, ErrorTexts.couldNot(what, ErrorTexts.reasonOf(e)))
+            return
+        }
+        post(Runnable {
+            if (!ReloadCoordinator.isCurrent(generation)) return@Runnable
+            try {
+                body(prepared)
+            } catch (e: Throwable) {
+                logFailure(name, ErrorTexts.couldNot(what, ErrorTexts.reasonOf(e)))
+            }
+            afterCommand()
+        })
+    }
+
+    /** The one line a command without a promise writes when it fails: [text] from `ErrorTexts`. */
+    fun logFailure(name: String, text: String) {
+        log("[ApexNavigation] $name: $text")
+    }
+}
+
+/**
+ * Whether the main-thread work of a command with a promise runs now ([CommandRunner.run]): what fails while it makes
+ * its layout rejects that command (a `LayoutException` with its text); what fails later, when no command can be
+ * answered any more, is logged instead. Main thread only.
+ */
+internal object CommandScope {
+    var isRunning = false
+}

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

@@ -0,0 +1,69 @@
+package dev.apexnative.navigation.react
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.view.KeyEvent
+import androidx.core.content.ContextCompat
+
+/**
+ * "R R" of the developer tools: two releases of R less than [windowMillis] apart, while the focus isn't in a text
+ * field, reload the JavaScript. A release in a text field is typing, and doesn't count.
+ */
+internal class DoubleTapReload(private val windowMillis: Long = WINDOW_MILLIS) {
+    private var lastRelease: Long? = null
+
+    /** A key was released at [now] (milliseconds); true when this release of R is the second one in time. */
+    fun onKeyUp(keyCode: Int, inTextField: Boolean, now: Long): Boolean {
+        if (keyCode != KeyEvent.KEYCODE_R || inTextField) return false
+        val last = lastRelease
+        val reload = last != null && now - last < windowMillis
+        lastRelease = if (reload) null else now
+        return reload
+    }
+
+    private companion object {
+        const val WINDOW_MILLIS = 1000L
+    }
+}
+
+/**
+ * The reload broadcast of the developer tools: end-to-end scripts send [ACTION] through adb. One receiver per activity,
+ * registered while it is resumed and only with the developer support on (no receiver in a release build: any app could
+ * reset the navigation), exported as Android 14 requires of a receiver of other apps' broadcasts; removed only where it
+ * was registered. Once [release]d, its action does nothing. Main thread only.
+ */
+internal class ReloadBroadcast(private val context: Context, action: () -> Unit) {
+    private var action: () -> Unit = action
+    private var registered = false
+
+    private val receiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) = this@ReloadBroadcast.action()
+    }
+
+    /** The activity resumed with the developer support on. */
+    fun register() {
+        if (registered) return
+        ContextCompat.registerReceiver(context, receiver, IntentFilter(ACTION), ContextCompat.RECEIVER_EXPORTED)
+        registered = true
+    }
+
+    /** The activity paused. */
+    fun unregister() {
+        if (!registered) return
+        registered = false
+        context.unregisterReceiver(receiver)
+    }
+
+    /** The activity is destroyed: the receiver goes, and its action becomes "do nothing", never none. */
+    fun release() {
+        unregister()
+        action = {}
+    }
+
+    companion object {
+        /** The action of the reload broadcast. */
+        const val ACTION = "dev.apexnative.navigation.broadcast.RELOAD"
+    }
+}

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

@@ -0,0 +1,123 @@
+package dev.apexnative.navigation.react
+
+/**
+ * Every text the native side rejects a command with or writes to the log for a command without a promise: one function
+ * per case, the same words as iOS. Other code takes its texts from here. JavaScript prefixes them with `[navigation]
+ * <command>:`.
+ */
+internal object ErrorTexts {
+    fun screenNotShown(id: String) = "the screen '$id' is not shown"
+
+    fun notInStack(id: String) = "the screen '$id' is not in a stack"
+
+    fun firstScreenOfStack(id: String) = "the screen '$id' is the first screen of its stack"
+
+    fun notInThisStack(id: String) = "the screen '$id' is not in this stack"
+
+    fun notInModal(id: String) = "the screen '$id' is not in a modal"
+
+    fun notInOverlay(id: String) = "the screen '$id' is not in an overlay"
+
+    fun notInSplitView(id: String) = "the screen '$id' is not in a split view"
+
+    fun neitherSplitViewNorStack(id: String) = "the screen '$id' 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 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 columnNotStack(id: String, column: String) =
+        "the '$column' column of the split view of the screen '$id' is not a stack"
+
+    fun noScreensForStack(id: String) = "there are no screens to put in the stack of the screen '$id'"
+
+    fun alreadyShown(id: String) = "the screen '$id' 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"
+
+    fun rootDestroyed(id: String) = "the root '$id' was destroyed before it showed"
+
+    fun modalWithoutRoot(id: String) = "the modal '$id' 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"
+
+    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'"
+
+    fun nodeWithoutId(type: String) = "the layout has a node of type '$type' without an id"
+
+    fun sideMenuChild(id: String, type: String) =
+        "the side menu '$id' has a child of type '$type': it takes SideMenuLeft, SideMenuCenter and SideMenuRight"
+
+    fun stackTakesScreens(id: String, type: String) = "the stack '$id' takes screens, not a '$type'"
+
+    fun emptyStack(id: String) = "the stack '$id' has no screens"
+
+    fun emptyTabs(id: String) = "the tabs '$id' have no tabs"
+
+    fun tooManyTabs(id: String, count: Int) = "the tabs '$id' have $count tabs: Android shows at most 5"
+
+    fun splitViewColumns(id: String) = "the split view '$id' needs its primary and its secondary column"
+
+    fun pairUnsupported(id: String) = "the pair '$id' needs iOS 27.1 and an app built with its SDK"
+
+    fun pairNeedsTwoScreens(id: String) = "the pair '$id' needs two screens: its primary and its secondary"
+
+    fun unreadableOption(path: String, id: String) =
+        "the option '$path' of the screen '$id' has a value the navigation can't read"
+
+    /** `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"
+
+    fun previewGone(id: String) = "the preview '$id' went without being opened"
+
+    /** 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 nativeCallReloaded(name: String, id: String) =
+        "JavaScript reloaded before the call '$name' of the screen '$id' was answered"
+
+    fun nativeCallNotRunning(name: String, id: String) =
+        "the navigation is not running: the call '$name' of the screen '$id' can't be answered"
+
+    /** `mergeOptions` without a navigation activity; written to the log, `mergeOptions` has no promise. */
+    fun mergeOptionsNoActivity() = nowhereToShow()
+
+    /** 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"
+
+    // The other cases of the layout checks: the same style.
+
+    fun nodeWithoutName(type: String, id: String) = "the layout has a node '$id' of type '$type' without a name"
+
+    fun rootMissing() = "the layout of setRoot has no root"
+
+    fun tabsInTabs(id: String) = "the tabs '$id' have a tab of type 'BottomTabs': tabs don't go inside tabs"
+
+    fun sideMenuSides(id: String) =
+        "the side menu '$id' takes one SideMenuCenter and at most one SideMenuLeft and one SideMenuRight"
+
+    fun sideChildCount(sideId: String, menuId: String) =
+        "the side '$sideId' of the side menu '$menuId' needs exactly one child"
+
+    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 sideOutsideMenu(id: String, type: String) = "the layout has a node '$id' of type '$type' outside a side menu"
+
+    fun splitViewInColumn(id: String) =
+        "the split view '$id' has a column of type 'SplitView': a split view doesn't go inside a split view"
+
+    fun idGivenTwice(id: String) = "the layout gives the id '$id' to two nodes"
+
+    /** The reason of [couldNot] for an exception: its message, else the name of its class. */
+    fun reasonOf(e: Throwable): String =
+        e.message?.takeIf { it.isNotBlank() } ?: e.javaClass.simpleName.ifEmpty { e.javaClass.name }
+}

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

@@ -0,0 +1,154 @@
+package dev.apexnative.navigation.react
+
+import android.app.Activity
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+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.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].
+ */
+internal object Hinge {
+    data class Value(val state: String, val angle: Float?)
+
+    private const val CLOSED_BELOW = 90f
+
+    private var enabled = false
+    private var activity: WeakReference<Activity>? = null
+    private var folds: WindowFolds? = null
+    private var sensorManager: SensorManager? = null
+    private var sensor: Sensor? = null
+    private var listening = false
+    private var angle: Float? = null
+    // The last value, as JavaScript has it; null without a hinge, and before the first one.
+    @Volatile
+    private var last: Value? = null
+
+    private val onFoldsChanged = Runnable { update() }
+
+    private val lifecycleObserver = object : DefaultLifecycleObserver {
+        override fun onResume(owner: LifecycleOwner) = listen(enabled)
+        override fun onPause(owner: LifecycleOwner) = listen(false)
+    }
+
+    private val sensorListener = object : SensorEventListener {
+        override fun onSensorChanged(event: SensorEvent) {
+            angle = event.values.firstOrNull() ?: return
+            update()
+        }
+
+        override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) = Unit
+    }
+
+    /** Starts or stops the updates; [activity] is the one the hinge is read for. */
+    fun setEnabled(activity: Activity?, enabled: Boolean) {
+        this.enabled = enabled
+        if (!enabled) {
+            detach()
+            return
+        }
+        activity?.let(::attachTo)
+        update()
+    }
+
+    /** A new activity: the updates that run go on with it. */
+    fun attach(activity: Activity) {
+        if (!enabled) return
+        attachTo(activity)
+        update()
+    }
+
+    /** `{ state, angle? }`, the last value; `{}` before the first one and without a hinge. Any thread. */
+    fun get(): WritableMap = toMap(last)
+
+    private fun attachTo(activity: Activity) {
+        if (this.activity?.get() === activity) return
+        detach()
+        val owner = activity as? LifecycleOwner ?: return
+        this.activity = WeakReference(activity)
+        folds = WindowFolds.of(activity)?.also { it.addListener(onFoldsChanged) }
+        val manager = activity.getSystemService(SensorManager::class.java)
+        sensorManager = manager
+        // A wake-up sensor wakes the device for each change: one that doesn't is taken when there is one.
+        sensor = if (manager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            manager.getDefaultSensor(Sensor.TYPE_HINGE_ANGLE, false) ?: manager.getDefaultSensor(Sensor.TYPE_HINGE_ANGLE)
+        } else {
+            null
+        }
+        // Added to a resumed activity, the observer hears onResume at once.
+        owner.lifecycle.addObserver(lifecycleObserver)
+    }
+
+    private fun detach() {
+        listen(false)
+        (activity?.get() as? LifecycleOwner)?.lifecycle?.removeObserver(lifecycleObserver)
+        folds?.removeListener(onFoldsChanged)
+        activity = null
+        folds = null
+        sensorManager = null
+        sensor = null
+        angle = null
+    }
+
+    private fun listen(on: Boolean) {
+        val listen = on && enabled && isResumed()
+        if (listen == listening) return
+        val manager = sensorManager
+        val sensor = sensor
+        if (manager == null || sensor == null) return
+        listening = listen
+        if (listen) {
+            manager.registerListener(sensorListener, sensor, SensorManager.SENSOR_DELAY_UI)
+        } else {
+            manager.unregisterListener(sensorListener)
+        }
+    }
+
+    private fun isResumed(): Boolean =
+        (activity?.get() as? LifecycleOwner)?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.RESUMED) == true
+
+    // The value once the window's first folds came, and the sensor's first angle while it listens.
+    private fun update() {
+        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)
+        }
+        if (value == last) return
+        last = value
+        val reactContext = (activity?.get()?.application as? ReactApplication)?.reactHost?.currentReactContext ?: return
+        EventEmitter(reactContext).emitHingeChanged(toMap(value))
+    }
+
+    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()) }
+    }
+}