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

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/navigator/Navigator.kt

@@ -33,6 +33,7 @@ import dev.apexnative.navigation.viewcontrollers.externalcomponent.ExternalCompo
 import dev.apexnative.navigation.viewcontrollers.modal.ModalCoordinator
 import dev.apexnative.navigation.viewcontrollers.modal.ModalRecord
 import dev.apexnative.navigation.viewcontrollers.modal.ModalViews
+import dev.apexnative.navigation.viewcontrollers.modal.SheetBack
 import dev.apexnative.navigation.viewcontrollers.overlay.OverlayCoordinator
 import dev.apexnative.navigation.viewcontrollers.overlay.OverlayRecord
 import dev.apexnative.navigation.viewcontrollers.overlay.OverlayViews
@@ -40,7 +41,6 @@ import dev.apexnative.navigation.viewcontrollers.parent.ParentController
 import dev.apexnative.navigation.viewcontrollers.stack.PreparedPushes
 import dev.apexnative.navigation.viewcontrollers.stack.StackCommands
 import dev.apexnative.navigation.viewcontrollers.stack.StackController
-import dev.apexnative.navigation.viewcontrollers.stack.topbar.BarComponents
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 import dev.apexnative.navigation.views.animations.FadeThrough
 import dev.apexnative.navigation.views.animations.SideAnimator
@@ -105,7 +105,10 @@ class Navigator(
         readiness = ContentReadiness,
         scheduler = scheduler,
         firstRoot = firstRootDraw,
-        onRootChanged = { root = it },
+        onRootChanged = {
+            root = it
+            BackCallbackState.update(this)
+        },
         onRootShown = {
             onRootShown?.invoke()
             BackCallbackState.update(this)
@@ -142,10 +145,21 @@ class Navigator(
 
     /**
      * Whether back has something to do in the navigation: the mirror of [handleBack], without acting — the top modal
-     * first, then the root. The back callback asks it before each frame (`BackCallbackState`).
+     * first, then the root. The back callback asks it whenever what back does can have changed (`BackCallbackState`).
      */
     fun canHandleBack(): Boolean = modals.canHandleBack() ?: (root?.canHandleBack() == true)
 
+    /**
+     * Whether back stays in the app also when the navigation has nothing to do: the layout back acts on — the top
+     * modal's, else the root — shows a screen with `hardwareBackButton.systemAnimation: false`. The system then doesn't
+     * play its animation of going home, and the press does the activity's own back ([handleBack] is false). The back
+     * callback asks it with [canHandleBack] (`BackCallbackState`).
+     */
+    fun keepsBackFromSystem(): Boolean {
+        val layout = modals.backTargetRoot() ?: root ?: return false
+        return layout.resolveShownOptions(DefaultOptions.current).hardwareBackButton.systemAnimation.isFalse
+    }
+
     /**
      * The navigation's step of back, after JavaScript's listeners didn't take it: the top modal first (its content,
      * else it closes or holds), else the root does the first thing it can (a stack's top leaves or holds, an open side
@@ -164,6 +178,9 @@ class Navigator(
         return if (modalRoot != null) modalRoot.stackPoppedByBack() else root?.stackPoppedByBack()
     }
 
+    /** The sheet [handleBack] would dismiss, as a drag down of the user would; none when back would do anything else. */
+    internal fun sheetDismissedByBack(): SheetBack? = modals.backTargetSheet()
+
     /**
      * [layer] may wait to show from now on ([WaitingLayer]): the nodes in it ask it through [isInWaitingLayer] and
      * [shownScreensChanged]. The root's layer is there from the start.
@@ -187,12 +204,14 @@ class Navigator(
      * A layout of [node] (a stack, the tabs, a side menu, a split view, a pair) changed the screens it shows: when it
      * is in a layer that still waits, the layer waits for the screens it shows now, and no longer for one that went
      * ([WaitingLayer.shownScreensChanged]); so does the operation of its stack that waits for [node] as its entry (a
-     * pushed pair); a modal's sheet takes the hold of the screen it shows now.
+     * pushed pair); a modal's sheet takes the hold of the screen it shows now; what back does is computed again (the
+     * tab, the pane or the menu back goes to, and the options of the screen it shows).
      */
     internal fun shownScreensChanged(node: ViewController<*>) {
         waitingLayerOf(node)?.shownScreensChanged()
         node.findParentStack()?.queue?.shownScreensChanged(node)
         modals.visibleScreenChanged(node)
+        BackCallbackState.update(this)
     }
 
     // The waiting layer [node] is in, up through the layouts around it; none.
@@ -435,7 +454,8 @@ class Navigator(
         destroyLayers(answerPending = false)
         // Nothing the old screens told of their readiness holds for the screens of the new JavaScript.
         ScreenReadiness.reset()
-        BarComponents.reset()
+        // Without layers back leaves the app until the new JavaScript sets its root.
+        BackCallbackState.update(this)
     }
 
     /**

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/navigator/RootCoordinator.kt

@@ -488,8 +488,8 @@ internal class RootCoordinator(
     }
 
     // The navigation state goes once, when the root is in place and its layers have shown, right before the answer:
-    // what the old root's destroy, the root's appearance and each layer ask for meanwhile waits (StateHold). Taken once
-    // per `setRoot`, before the old root goes.
+    // what the old root's destroy, the root's appearance and each layer ask for meanwhile waits (the hold of
+    // NavigationState). Taken once per `setRoot`, before the old root goes.
     private fun holdState(pending: Pending) {
         if (pending.holdsState) return
         pending.holdsState = true

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/parent/ParentController.kt

@@ -129,12 +129,9 @@ abstract class ParentController<V : ViewGroup>(
     open fun leavesTopEdgeFree(child: ViewController<*>): Boolean =
         parentController?.leavesTopEdgeFree(this) ?: false
 
-    /**
-     * Whether the safe area of [child] leaves its bottom edge free by default: the tabs show with
-     * `bottomTabs.hideOnScroll` of [screen], the screen that asks.
-     */
-    open fun leavesBottomEdgeFree(child: ViewController<*>, screen: ViewController<*> = child): Boolean =
-        parentController?.leavesBottomEdgeFree(this, screen) ?: false
+    /** Whether a large title shows over [child]: its stack shows the bar with one. No by default. */
+    open fun showsLargeTitleOver(child: ViewController<*>): Boolean =
+        parentController?.showsLargeTitleOver(this) ?: false
 
     /**
      * The tab bar at rest under [child]: where a stack's FAB keeps clear of it, by the options of [screen], the stack's

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/splitview/SplitViewController.kt

@@ -153,6 +153,9 @@ class SplitViewController(
 
     private fun onWidthChanged(layout: SplitViewLayout) {
         primary.getView().visibility = if (primaryHidden && layout.isWide == true) View.GONE else View.VISIBLE
+        // Compact, side by side or one over the other decides what back does from this measure on: the callback only
+        // takes its value here, nothing moves; the panes' end below computes it again.
+        BackCallbackState.update()
         // Where a later `compactTopColumn` puts the pane over the other at this switch: true open, false closed.
         val settle = if (measured && isSliding) laterTopColumn?.let { it == SECONDARY } else null
         if (!measured) {

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/PreparedFrame.kt

@@ -2,18 +2,18 @@ package dev.apexnative.navigation.viewcontrollers.stack
 
 import android.view.View
 import com.facebook.react.uimanager.PixelUtil.pxToDp
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 
 /**
  * Where a screen prepared for a push (`preparePush`) shows, in dp: the size of the container its slot fills and the
  * padding of its safe area view, as the push lays it out. JavaScript renders the screen with them before the push, and
  * the slot and the safe area view start their states with them.
  */
-internal data class PreparedFrame(val width: Float, val height: Float, val padding: ScreenInsets.Insets) {
+internal data class PreparedFrame(val width: Float, val height: Float, val padding: ScreenEnvironment.Insets) {
     companion object {
         /** The size of [container] as its slot measures it (`SlotView`), so the slot finds it equal. */
         @JvmStatic
-        fun of(container: View, padding: ScreenInsets.Insets) =
+        fun of(container: View, padding: ScreenEnvironment.Insets) =
             PreparedFrame(container.width.toFloat().pxToDp(), container.height.toFloat().pxToDp(), padding)
     }
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackCommands.kt

@@ -11,7 +11,7 @@ import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.react.CommandAnswer
 import dev.apexnative.navigation.react.CommandListener
 import dev.apexnative.navigation.react.ErrorTexts
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.slots.SlotScreenView
 import dev.apexnative.navigation.utils.NavigationLog
 import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
@@ -318,7 +318,7 @@ internal class StackCommands(
         layoutNow(stackView, screenView)
         node.updateSafeArea()
         val content = node.content?.asView()
-        val padding = ScreenInsets.padding(node.id)
+        val padding = ScreenEnvironment.padding(node.id)
         val noInsets = content == null || ViewCompat.getRootWindowInsets(content) == null
         if (noInsets || padding == null || content.width <= 0 || content.height <= 0) {
             prepared.discard(node.id)

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackController.kt

@@ -270,8 +270,8 @@ class StackController(
 
     /**
      * The default pop of the top is what back does now and it can be previewed: two entries or more, nothing running
-     * or waiting, no open search, the top doesn't hold back and pops with the default transition, the screen under it
-     * has its view, and the stack shows.
+     * or waiting, no open search, the top doesn't hold back, pops with the default transition and doesn't turn the
+     * preview off (`animations.pop.preview: false`), the screen under it has its view, and the stack shows.
      */
     override fun stackPoppedByBack(): StackController? {
         if (topBar.isSearchOpen() || !queue.isAtRest) return null
@@ -282,9 +282,8 @@ class StackController(
         if (!queue.isRendered(target) || backGesture != null) return null
         val options = resolvedOf(top)
         val pop = options.animations.pop
-        if (options.hardwareBackButton.popStackOnPress.isFalse || pop.enabled.isFalse || AnimationRules.stackIsOwn(pop)) {
-            return null
-        }
+        if (options.hardwareBackButton.popStackOnPress.isFalse || pop.enabled.isFalse) return null
+        if (pop.preview.isFalse || AnimationRules.stackIsOwn(pop)) return null
         val display = queue.display
         return this.takeIf { display.isOnScreen && display.canAnimate }
     }
@@ -595,6 +594,10 @@ class StackController(
     override fun leavesTopEdgeFree(child: ViewController<*>): Boolean =
         TopBarRoom.leavesTopEdgeFree(resolvedOf(child), largeTitleShown(child)) || super.leavesTopEdgeFree(child)
 
+    /** A large title shows over [child] in this stack's bar. */
+    override fun showsLargeTitleOver(child: ViewController<*>): Boolean =
+        largeTitleShown(child) || super.showsLargeTitleOver(child)
+
     /** A screen under another doesn't compute its safe area again; the prepared and waiting do. */
     override fun isTopOfStack(child: ViewController<*>): Boolean =
         child === queue.currentChild || child === queue.waitingScreen || isPrepared(child)
@@ -694,15 +697,20 @@ class StackController(
     private fun optionsScreen(node: ViewController<*>): ViewController<*> =
         (node as? OptionsScreen)?.optionsScreen ?: node
 
+    // What back does is computed again on each change of the queue (BackCallbackState): its entries change as an
+    // operation is accepted, the screen whose options count as its current child changes (a push that waited for its
+    // screen begins after its command), and an operation ends or rejects.
     private inner class QueueHost : StackQueue.Host {
         override fun operationAccepted() {
             backGesture?.abort()
+            BackCallbackState.update()
         }
 
         // The bar takes the options of the new top at once, also without appearance events.
         override fun currentChildChanged() {
             updateBar()
             navigator?.shownScreensChanged(this@StackController)
+            BackCallbackState.update()
         }
 
         // Before the bar takes the new top's options: the row's picture or the bar's travel, and how it shows or hides.

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/StackViews.kt

@@ -15,6 +15,7 @@ import dev.apexnative.navigation.viewcontrollers.component.ComponentViewControll
 import dev.apexnative.navigation.viewcontrollers.externalcomponent.ExternalComponentViewController
 import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.Motion
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.animations.AnimationLayer
 import dev.apexnative.navigation.views.animations.AnimationRules
 import dev.apexnative.navigation.views.animations.SideAnimator
 import dev.apexnative.navigation.views.animations.SystemTransition
@@ -157,6 +158,8 @@ internal class StackViews(private val stack: StackController) : StackDisplay {
         custom.alpha?.let { view.alpha = it }
         val own = custom.side?.let { SideAnimator.build(view, it, SideAnimator.Base(alpha = custom.alpha)) }
         val fade = if (own == null) StackTransitions.fade(view, custom.fade) else null
+        // A fade of the whole screen draws it through a hardware layer, as the default transition does ([dress]).
+        for (animator in listOfNotNull(own, fade)) AnimationLayer.during(view, animator)
         val elements = custom.elements?.let { elements ->
             val layout = layout ?: return@let null
             val fadeLength = custom.side?.takeIf(AnimationRules::isSingleAlpha)?.let(AnimationRules::lengthOf)

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/search/ScreenSearch.kt

@@ -36,6 +36,8 @@ import dev.apexnative.navigation.views.stack.topbar.search.SuggestionList
 class ScreenSearch(
     private val host: Host,
     private val screenId: String,
+    /** The sender of the JavaScript the screen was made for: silent once it went. */
+    private val emitter: EventEmitter,
     private val context: Context,
     private val loadIcon: (String) -> Drawable?,
     /** A scope the user picks goes into the screen's options, so it stays when they apply again. */
@@ -45,7 +47,6 @@ class ScreenSearch(
         /** The search changed what the bar shows (open or closed, its text): shown again if it is the shown one. */
         fun refresh(search: ScreenSearch)
         fun isShown(search: ScreenSearch): Boolean
-        fun emitter(): EventEmitter?
         fun keyboard(view: View, show: Boolean)
         /** The stack's view: a search view goes over it. */
         fun stackView(): ViewGroup?
@@ -402,7 +403,7 @@ class ScreenSearch(
 
     // A pick sends searchSuggestionPicked with the suggestion's id; the text stays.
     private fun pickSuggestion(suggestionId: String) {
-        host.emitter()?.emitSearchSuggestionPicked(screenId, suggestionId)
+        emitter.emitSearchSuggestionPicked(screenId, suggestionId)
         setSuggestions(emptyList())
     }
 
@@ -426,18 +427,15 @@ class ScreenSearch(
     private fun sendUpdate(
         focused: Boolean = isActive && (panel?.searchView?.editText ?: searchField.editText).hasFocus(),
     ) {
-        val emitter = host.emitter() ?: return
         eventTargets().forEach { emitter.emitSearchBarUpdated(it, text, focused, scope()) }
     }
 
     private fun sendCancel() {
-        val emitter = host.emitter() ?: return
         eventTargets().forEach { emitter.emitSearchBarCancelPressed(it) }
         sendUpdate()
     }
 
     private fun sendSubmit() {
-        val emitter = host.emitter() ?: return
         eventTargets().forEach { emitter.emitSearchBarSubmitted(it, text, scope()) }
     }
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/search/StackSearchPresenter.kt

@@ -12,7 +12,6 @@ import androidx.appcompat.content.res.AppCompatResources
 import androidx.coordinatorlayout.widget.CoordinatorLayout
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
-import com.facebook.react.ReactApplication
 import dev.apexnative.navigation.options.SearchBarOptions
 import dev.apexnative.navigation.options.params.ThemeColour
 import dev.apexnative.navigation.react.events.EventEmitter
@@ -137,9 +136,6 @@ class StackSearchPresenter(
         refresh()
     }
 
-    override fun emitter(): EventEmitter? =
-        (activity.application as? ReactApplication)?.reactHost?.currentReactContext?.let { EventEmitter(it) }
-
     override fun keyboard(view: View, show: Boolean) {
         val controller = WindowCompat.getInsetsController(activity.window, view)
         if (show) controller.show(WindowInsetsCompat.Type.ime()) else controller.hide(WindowInsetsCompat.Type.ime())
@@ -150,7 +146,8 @@ class StackSearchPresenter(
             // The search of a pair of screens is its primary's: its events name that screen, which keeps the scope in
             // its user layer, where a merge that sends the same options again doesn't take it away.
             val owner = (screen as? OptionsScreen)?.optionsScreen ?: screen
-            ScreenSearch(this, owner.id, styleContext(), loadIcon) { scope ->
+            // Its events go to the JavaScript the screen was made for, and to no other.
+            ScreenSearch(this, owner.id, EventEmitter.of(owner.jsGeneration), styleContext(), loadIcon) { scope ->
                 owner.changeChoices { it.pickScope(scope) }
             }
         }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/BarComponents.kt

@@ -5,7 +5,6 @@ import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.options.TitleComponentOptions
 import dev.apexnative.navigation.options.TopBarBackgroundComponentOptions
 import dev.apexnative.navigation.options.params.Text
-import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.IReactView
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
@@ -15,7 +14,8 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
  * same root, never made again; another replaces it, and the old one stops at once. A background with the same `name`
  * and `componentId` on several screens is one root, shared; it stops when no screen of the stack names it any more. The
  * roots go with their screen ([screenDestroyed]) or the stack ([destroyAll]). Each root renders at once, without
- * waiting for its layout: [makeRoot] marks its id so before its surface starts. Main thread only.
+ * waiting for its layout: [makeRoot] makes it so (`ReactView`'s `rendersAtOnce`), and each answers by its own render
+ * when several live roots show one id (`ScreenReadiness`). Main thread only.
  */
 internal class BarComponents(private val makeRoot: (componentId: String, name: String) -> IReactView) {
     /** A root of the bar: what it renders, and its content. */
@@ -151,18 +151,10 @@ internal class BarComponents(private val makeRoot: (componentId: String, name: S
         backgrounds.remove(key)?.let(::stop)
     }
 
-    // Made first, counted after: the maker asks whether another root with the id lives.
-    private fun make(key: Key): Root {
-        val root = Root(key.name, key.componentId, makeRoot(key.componentId, key.name))
-        LiveIds.add(key.componentId)
-        return root
-    }
+    private fun make(key: Key): Root = Root(key.name, key.componentId, makeRoot(key.componentId, key.name))
 
-    // Stops a root once; what the readiness store kept of its id goes unless another live root holds the id.
-    private fun stop(root: Root) {
-        root.view.destroy()
-        if (LiveIds.remove(root.componentId)) ScreenReadiness.remove(root.componentId)
-    }
+    // Stops a root once; its content takes its mark of rendering at once with it.
+    private fun stop(root: Root) = root.view.destroy()
 
     private fun keyOf(name: Text, componentId: Text, id: Text): Key? {
         val componentName = name.get(null)?.takeIf { it.isNotEmpty() } ?: return null
@@ -170,42 +162,4 @@ internal class BarComponents(private val makeRoot: (componentId: String, name: S
             ?: return null
         return Key(componentName, rootId)
     }
-
-    companion object {
-        /** Whether a bar root with [id] is alive now, in any stack. */
-        fun isLive(id: String): Boolean = LiveIds.has(id)
-
-        /**
-         * Another root that renders at once lives with [id] (a cell of the tabs' custom row): it counts as the bar's
-         * roots do, so a root that stops clears the id's readiness only when it was the last one with it.
-         */
-        internal fun rootMade(id: String) = LiveIds.add(id)
-
-        /** A root of [rootMade] stopped; true when no live root has [id] any more. */
-        internal fun rootStopped(id: String): Boolean = LiveIds.remove(id)
-
-        /** The JavaScript went (a reload): no id counts as held by a live root any more, as `ScreenReadiness.reset`. */
-        fun reset() = LiveIds.clear()
-    }
-
-    // The ids of the bar roots alive now, in every stack: a root that stops clears its id's readiness only when it was
-    // the last one with it.
-    private object LiveIds {
-        private val counts = HashMap<String, Int>()
-
-        fun has(id: String): Boolean = (counts[id] ?: 0) > 0
-
-        fun clear() = counts.clear()
-
-        fun add(id: String) {
-            counts[id] = (counts[id] ?: 0) + 1
-        }
-
-        // True when no root with the id is left.
-        fun remove(id: String): Boolean {
-            val count = (counts[id] ?: return true) - 1
-            if (count <= 0) counts.remove(id) else counts[id] = count
-            return count <= 0
-        }
-    }
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/stack/topbar/TopBarPresenter.kt

@@ -41,7 +41,6 @@ import dev.apexnative.navigation.utils.ImageLoader
 import dev.apexnative.navigation.utils.ImageLoadingListenerAdapter
 import dev.apexnative.navigation.utils.TestIds
 import dev.apexnative.navigation.utils.UiUtils
-import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay
 import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.BarMotion
@@ -936,14 +935,10 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         return resolved.component
     }
 
-    private fun makeRoot(componentId: String, name: String): IReactView {
-        // A component of the bar renders at once, without waiting for its layout, from before its surface starts.
-        ScreenReadiness.setRendersAtOnce(componentId, true)
-        // Another live root has this id (a component of the stack's options on two screens): what it rendered isn't
-        // this root's, which answers by its own render.
-        if (BarComponents.isLive(componentId)) ScreenReadiness.forgetRender(componentId)
-        return ReactView(activity, componentId, name)
-    }
+    // A component of the bar renders at once, without waiting for its layout. Another live root may show the same id
+    // (a component of the stack's options on two screens): each answers by the render of its own surface.
+    private fun makeRoot(componentId: String, name: String): IReactView =
+        ReactView(activity, componentId, name, rendersAtOnce = true)
 
     private fun loadIcon(uri: String): Drawable? {
         var loaded: Drawable? = null

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/viewcontroller/ScrollEventListener.kt

@@ -13,8 +13,8 @@ import java.lang.ref.WeakReference
  * tag) is in the screen, found once per tag —, not the horizontal ones, nor those of a modal, an overlay or another
  * screen; a slot screen's lists are in its container too. While a list is dragged, each follower gets the drag as a
  * translation to follow; when the drag ends, the way to settle; at every scroll event, the drags' and the inertia's,
- * the offset. It listens to React Native's events only while it has followers; without React Native's event dispatcher
- * (around a reload) it waits and listens once there is one. Released with the screen. Main thread only.
+ * the offset. It listens to React Native's scroll views ([ScrollEvents]) only while it has followers and its screen's
+ * view. Released with the screen. Main thread only.
  */
 class ScrollEventListener() {
     /** Follows the content while it is dragged. */
@@ -105,15 +105,12 @@ class ScrollEventListener() {
     }
 
     /**
-     * Listens to React Native's scroll events when followers wait for them and it doesn't yet: after a reload there may
-     * be no event dispatcher at first: then it is asked again once React Native has one, and as the screen joins a
-     * window.
+     * Listens to React Native's scroll views when followers wait for them and it doesn't yet, once it has the screen's
+     * view to tell its own lists by; asked again as the screen joins a window.
      */
     internal fun attachIfNeeded() {
-        if (released || stopListening != null || registrations.isEmpty()) return
-        val context = scope?.get()?.context ?: return
-        stopListening = ScrollEvents.listen(context, ::onScrollEvent)
-        if (stopListening == null) ScrollEvents.waitForDispatcher(this)
+        if (released || stopListening != null || registrations.isEmpty() || scope?.get() == null) return
+        stopListening = ScrollEvents.listen(::onScrollEvent)
     }
 
     /** The screen is destroyed: no follower hears it any more. */

package/android/src/main/java/dev/apexnative/navigation/views/animations/AnimationLayer.kt

@@ -0,0 +1,73 @@
+package dev.apexnative.navigation.views.animations
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.view.View
+
+/**
+ * A hardware layer on a view for the time of an animator that fades it. A view whose `alpha` is below 1 and whose
+ * rendering overlaps (any `ViewGroup` by default) is drawn into an offscreen buffer at every frame; through a layer it
+ * is drawn once and the GPU only composites it. The layer is taken as the animator starts and only from
+ * `LAYER_TYPE_NONE` (a layer someone else set stays theirs), and given back as it ends or is cancelled. A pure
+ * translation or scale needs none: RenderThread draws it. The stack's default transition has its own
+ * (`StackViews.dress`). Main thread only.
+ */
+internal object AnimationLayer {
+    private const val ALPHA = "alpha"
+
+    /**
+     * [view] draws through a hardware layer while [animator] plays, when [animator] changes the `alpha` of [view] and
+     * the view's rendering overlaps; [animator] itself, for chaining.
+     */
+    fun during(view: View, animator: Animator): Animator {
+        if (!changesAlpha(animator, view)) return animator
+        val hold = Hold({ view.layerType }, { view.setLayerType(it, null) })
+        animator.addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationStart(animation: Animator) {
+                hold.take(changesAlpha = true, overlapping = view.hasOverlappingRendering())
+            }
+
+            override fun onAnimationCancel(animation: Animator) = hold.release()
+
+            override fun onAnimationEnd(animation: Animator) = hold.release()
+        })
+        return animator
+    }
+
+    /** Whether an animation takes a layer: it fades, its view's rendering overlaps, and the view has no layer. */
+    fun takes(changesAlpha: Boolean, overlapping: Boolean, layerType: Int): Boolean =
+        changesAlpha && overlapping && layerType == View.LAYER_TYPE_NONE
+
+    /**
+     * The layer one animation took on one view, through [layerType] and [setLayerType]: taken at most once at a time,
+     * given back once, and only while it is still the hardware layer it set.
+     */
+    class Hold(private val layerType: () -> Int, private val setLayerType: (Int) -> Unit) {
+        /** Whether the animation holds the view's layer now. */
+        var isTaken = false
+            private set
+
+        /** The animation starts: the layer, when [takes] says so. */
+        fun take(changesAlpha: Boolean, overlapping: Boolean) {
+            if (isTaken || !takes(changesAlpha, overlapping, layerType())) return
+            setLayerType(View.LAYER_TYPE_HARDWARE)
+            isTaken = true
+        }
+
+        /** The animation ended or stopped: the layer goes, unless someone changed it meanwhile. */
+        fun release() {
+            if (!isTaken) return
+            isTaken = false
+            if (layerType() == View.LAYER_TYPE_HARDWARE) setLayerType(View.LAYER_TYPE_NONE)
+        }
+    }
+
+    // Whether [animator], or an animator in it, writes the alpha of [view].
+    private fun changesAlpha(animator: Animator, view: View): Boolean = when (animator) {
+        is AnimatorSet -> animator.childAnimations.any { changesAlpha(it, view) }
+        is ObjectAnimator -> animator.target === view && animator.values.orEmpty().any { it.propertyName == ALPHA }
+        else -> false
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/views/animations/ValueInterpolation.kt

@@ -18,6 +18,18 @@ internal object ValueInterpolation {
         else -> from + fraction * (to - from)
     }
 
+    /**
+     * An angle in degrees at [fraction] of the way along the shorter arc, as iOS turns a shared element: 0 → 270 turns
+     * back by 90, 170 → −170 turns on by 20; half a turn goes on. At the end of the time exactly [to].
+     */
+    fun angle(from: Float, to: Float, fraction: Float, time: Float = fraction): Float {
+        if (time <= 0f) return from
+        if (time >= 1f) return to
+        val forward = ((to - from) % FULL_TURN + FULL_TURN) % FULL_TURN
+        val turn = if (forward > HALF_TURN) forward - FULL_TURN else forward
+        return from + fraction * turn
+    }
+
     /**
      * A color (an sRGB color int, as React Native keeps a background; none is transparent) at [fraction] of the way
      * from [from] to [to]: L, a and b in Lab (D65), the alpha linear, the result rounded; at the end of the time
@@ -90,4 +102,6 @@ internal object ValueInterpolation {
     private const val WHITE_Z = 108.883
     private const val EPSILON = 0.008856
     private const val KAPPA = 903.3
+    private const val FULL_TURN = 360f
+    private const val HALF_TURN = 180f
 }