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

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

@@ -1,25 +1,17 @@
 package dev.apexnative.navigation.react
 
-import android.content.Context
-import android.util.Log
-import com.facebook.react.ReactApplication
-import com.facebook.react.uimanager.UIManagerHelper
-import com.facebook.react.uimanager.events.Event
-import com.facebook.react.uimanager.events.EventDispatcherListener
-import com.facebook.react.views.scroll.ScrollEvent
+import android.view.ViewGroup
+import android.widget.HorizontalScrollView
+import com.facebook.react.views.scroll.ReactScrollViewHelper
 import com.facebook.react.views.scroll.ScrollEventType
-import dev.apexnative.navigation.utils.NavigationLog
-import dev.apexnative.navigation.utils.UiThread
-import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
-import java.lang.reflect.Field
-import java.util.Collections
-import java.util.WeakHashMap
 
 /**
- * The scroll events of React Native's lists, as the screens' scroll listeners hear them: from the event dispatcher of
- * the running React Native, every list of the app. React Native keeps the offset, the speed and the kind of a scroll
- * event in private fields: they are looked up once, with their types; if React Native renames them, one warning goes to
- * the log and the screens hear no scroll, with no error at each event.
+ * The scroll events of React Native's scroll views, as the screens' scroll listeners hear them: through React Native's
+ * public scroll listener ([ReactScrollViewHelper.addScrollListener]), which every `ReactScrollView`,
+ * `ReactHorizontalScrollView` and `ReactNestedScrollView` of the process calls on the main thread just before it
+ * dispatches the same event to JavaScript, after the same throttle. One listener serves every screen and every React
+ * context; it is added while a screen listens and removed when the last one stops. Horizontal scroll views are left
+ * out: a pager or a carousel doesn't move the bars. Main thread only.
  */
 internal object ScrollEvents {
     /** What a scroll event is. */
@@ -28,133 +20,62 @@ internal object ScrollEvents {
     /** One scroll event: the list's tag (its view's id), its kind, its vertical offset and speed, in pixels. */
     class Reading(val viewTag: Int, val kind: Kind, val offsetY: Float, val velocityY: Float)
 
-    private class Fields(val type: Field, val offsetY: Field, val velocityY: Field)
+    // One screen's listening: its own object, so that a stop takes away that listening and no other.
+    private class Listening(val handler: (Reading) -> Unit)
 
-    private var fields: Fields? = null
-    private var lookedUp = false
+    // The screens' listenings, in the order they came.
+    private val listenings = mutableListOf<Listening>()
 
-    // The screens' listeners that found no event dispatcher, held weakly until React Native has one. Main thread.
-    private val waiting: MutableSet<ScrollEventListener> = Collections.newSetFromMap(WeakHashMap())
+    // React Native holds its scroll listeners weakly: this object keeps the one it added for as long as it is added.
+    private val listener = object : ReactScrollViewHelper.ScrollListener {
+        override fun onScroll(
+            scrollView: ViewGroup?,
+            scrollEventType: ScrollEventType?,
+            xVelocity: Float,
+            yVelocity: Float,
+        ) = hear(scrollView, scrollEventType, yVelocity)
 
-    /** [listener] found no event dispatcher: it is asked to listen again once React Native has one. */
-    fun waitForDispatcher(listener: ScrollEventListener) {
-        waiting += listener
-    }
-
-    /** A React context is ready (`ReloadCoordinator`): the listeners waiting for an event dispatcher listen now. */
-    fun dispatcherReady() {
-        val listeners = waiting.toList()
-        waiting.clear()
-        listeners.forEach(ScrollEventListener::attachIfNeeded)
+        override fun onLayout(scrollView: ViewGroup?) = Unit
     }
 
     /**
-     * Calls [handler] on the main thread with each scroll event of the app's React Native, until the function returned
-     * is called. None when React Native has no event dispatcher now (around a reload, the caller asks again later) or
-     * its scroll events can't be read.
+     * Calls [handler] with each scroll event of a vertical scroll view of the app, until the function returned is
+     * called.
      */
-    fun listen(context: Context, handler: (Reading) -> Unit): (() -> Unit)? {
-        if (fields() == null) return null
-        val reactContext = (context.applicationContext as? ReactApplication)?.reactHost?.currentReactContext
-            ?: return null
-        val dispatcher = try {
-            UIManagerHelper.getEventDispatcher(reactContext)
-        } catch (e: RuntimeException) {
-            null
-        } ?: return null
-        val listener = EventDispatcherListener { event ->
-            // The event goes back to its pool after the dispatch: it is read now, on the thread that dispatches.
-            val reading = read(event) ?: return@EventDispatcherListener
-            if (UiThread.isMainThread()) handler(reading) else UiThread.post { handler(reading) }
+    fun listen(handler: (Reading) -> Unit): () -> Unit {
+        val listening = Listening(handler)
+        if (listenings.isEmpty()) ReactScrollViewHelper.addScrollListener(listener)
+        listenings += listening
+        return {
+            // By identity: the second call of a stop finds nothing to take away.
+            if (listenings.removeAll { it === listening } && listenings.isEmpty()) {
+                ReactScrollViewHelper.removeScrollListener(listener)
+            }
         }
-        dispatcher.addListener(listener)
-        return { dispatcher.removeListener(listener) }
     }
 
-    private fun read(event: Event<*>): Reading? {
-        if (event !is ScrollEvent) return null
-        val fields = fields() ?: return null
-        return try {
-            val type = fields.type.get(event) as? ScrollEventType ?: return null
-            val offsetY = readFloat(fields.offsetY, event) ?: return null
-            val velocityY = readFloat(fields.velocityY, event) ?: return null
-            Reading(event.viewTag, kindOf(type), offsetY, velocityY)
-        } catch (e: ReflectiveOperationException) {
-            null
-        } catch (e: IllegalArgumentException) {
-            null
-        }
+    /** One call of React Native's listener: the handlers listening now hear its reading, if it has one. */
+    fun hear(scrollView: ViewGroup?, type: ScrollEventType?, velocityY: Float) {
+        val reading = read(scrollView, type, velocityY) ?: return
+        listenings.toList().forEach { it.handler(reading) }
     }
 
-    private fun kindOf(type: ScrollEventType): Kind = when (type) {
+    /**
+     * The reading of one call of React Native's listener: none for a horizontal scroll view, or when React Native gives
+     * no view or no kind. The offset is the view's `scrollY` and the speed React Native's own, in pixels, as the event
+     * sent to JavaScript carries them before it converts them to dp.
+     */
+    fun read(scrollView: ViewGroup?, type: ScrollEventType?, velocityY: Float): Reading? {
+        if (scrollView == null || type == null || scrollView is HorizontalScrollView) return null
+        return Reading(scrollView.id, kindOf(type), scrollView.scrollY.toFloat(), velocityY)
+    }
+
+    /** The kind of a reading for React Native's [type]. */
+    fun kindOf(type: ScrollEventType): Kind = when (type) {
         ScrollEventType.BEGIN_DRAG -> Kind.BeginDrag
         ScrollEventType.END_DRAG -> Kind.EndDrag
         ScrollEventType.SCROLL -> Kind.Scroll
         ScrollEventType.MOMENTUM_BEGIN -> Kind.MomentumBegin
         ScrollEventType.MOMENTUM_END -> Kind.MomentumEnd
     }
-
-    @Synchronized
-    private fun fields(): Fields? {
-        if (lookedUp) return fields
-        lookedUp = true
-        fields = try {
-            val owner = ScrollEvent::class.java
-            val type = declaredField(owner, TYPE_NAMES) { ScrollEventType::class.java.isAssignableFrom(it) }
-            val offsetY = declaredField(owner, OFFSET_NAMES, ::isNumeric)
-            val velocityY = declaredField(owner, VELOCITY_NAMES, ::isNumeric)
-            if (type != null && offsetY != null && velocityY != null) Fields(type, offsetY, velocityY) else null
-        } catch (e: ReflectiveOperationException) {
-            null
-        } catch (e: SecurityException) {
-            null
-        }
-        if (fields == null) {
-            Log.w(
-                NavigationLog.TAG,
-                "[ApexNavigation] React Native's scroll events changed: hideOnScroll and the large title " +
-                    "don't follow the scroll",
-            )
-        }
-        return fields
-    }
-
-    // The names of the fields: React Native 0.87 first, then the earlier ones with the `m` prefix.
-    private val TYPE_NAMES = listOf("scrollEventType", "mScrollEventType")
-    private val OFFSET_NAMES = listOf("scrollY", "mScrollY")
-    private val VELOCITY_NAMES = listOf("yVelocity", "mYVelocity")
-
-    /**
-     * The first of the fields [names] that [owner] declares with a type [accepted] takes, made readable; none when no
-     * name fits. React Native renamed them and changed their types between versions.
-     */
-    fun declaredField(owner: Class<*>, names: List<String>, accepted: (Class<*>) -> Boolean): Field? {
-        for (name in names) {
-            val field = try {
-                owner.getDeclaredField(name)
-            } catch (e: NoSuchFieldException) {
-                continue
-            }
-            if (!accepted(field.type)) continue
-            field.isAccessible = true
-            return field
-        }
-        return null
-    }
-
-    /** A number of any kind: a primitive one (`int`, `float`, `double`, …) or a boxed one. */
-    fun isNumeric(type: Class<*>): Boolean =
-        type in PRIMITIVE_NUMBERS || Number::class.java.isAssignableFrom(type)
-
-    /** [field] of [target] as a float, whatever numeric type it has; none when it holds no number. */
-    fun readFloat(field: Field, target: Any): Float? = (field.get(target) as? Number)?.toFloat()
-
-    private val PRIMITIVE_NUMBERS = setOf<Class<*>?>(
-        Byte::class.javaPrimitiveType,
-        Short::class.javaPrimitiveType,
-        Int::class.javaPrimitiveType,
-        Long::class.javaPrimitiveType,
-        Float::class.javaPrimitiveType,
-        Double::class.javaPrimitiveType,
-    )
 }

package/android/src/main/java/dev/apexnative/navigation/safearea/SafeAreaView.kt

@@ -10,7 +10,7 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.view.ReactViewGroup
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 
 /**
@@ -20,7 +20,7 @@ import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 @SuppressLint("ViewConstructor")
 class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
     private var stopListening: (() -> Unit)? = null
-    private var applied: ScreenInsets.Insets? = null
+    private var applied: ScreenEnvironment.Insets? = null
     private var readySent = false
     private var contentSignalled = false
 
@@ -48,7 +48,7 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
             stopListening?.invoke()
             field = value
             applied = null
-            stopListening = value?.let { id -> ScreenInsets.listenToPadding(id) { applyPadding() } }
+            stopListening = value?.let { id -> ScreenEnvironment.listenToPadding(id) { applyPadding() } }
             // The screen has a safe area view: it counts as rendered once this view says so.
             value?.let(ScreenReadiness::wrapped)
             applyPadding()
@@ -56,7 +56,7 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
 
     private fun applyPadding() {
         val state = stateWrapper ?: return
-        val padding = screenId?.let(ScreenInsets::padding) ?: return
+        val padding = screenId?.let(ScreenEnvironment::padding) ?: return
         if (padding == applied) return
         applied = padding
         state.updateState(
@@ -69,9 +69,9 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
         )
     }
 
-    private fun paddingOf(data: ReadableMap): ScreenInsets.Insets? {
+    private fun paddingOf(data: ReadableMap): ScreenEnvironment.Insets? {
         if (!data.hasKey("top")) return null
-        return ScreenInsets.Insets(data.getDouble("top"), data.getDouble("right"), data.getDouble("bottom"),
+        return ScreenEnvironment.Insets(data.getDouble("top"), data.getDouble("right"), data.getDouble("bottom"),
             data.getDouble("left"))
     }
 

package/android/src/main/java/dev/apexnative/navigation/utils/ViewExtensions.kt

@@ -26,16 +26,3 @@ val View.borderRadius: Float
  */
 internal fun resolveBorderRadius(radius: LengthPercentage, width: Int, density: Float): Float =
     (radius.resolve(width / density) * density).coerceAtLeast(0f)
-
-/** The scale the parents of [view] give it, along x and along y: a view in a scaled parent shows smaller. */
-fun computeInheritedScale(view: View): Pair<Float, Float> {
-    var scaleX = 1f
-    var scaleY = 1f
-    var parent = view.parent as? View
-    while (parent != null) {
-        scaleX *= parent.scaleX
-        scaleY *= parent.scaleY
-        parent = parent.parent as? View
-    }
-    return scaleX to scaleY
-}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/ArrangementController.kt

@@ -9,7 +9,7 @@ import androidx.window.layout.WindowMetricsCalculator
 import dev.apexnative.navigation.NavigationActivity
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.react.ArrangementStates
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.SystemUiUtils
 import dev.apexnative.navigation.utils.WindowFolds
@@ -146,12 +146,14 @@ class ArrangementController internal constructor(
         val overlay = plan.layout == ArrangementPlan.Layout.OVERLAY
         val single = plan.layout == ArrangementPlan.Layout.SINGLE
         if (primary is ComponentViewController) {
-            val state = ArrangementStates.State(PRIMARY, layout, front = overlay, hidden = false)
-            ArrangementStates.set(primary.id, state, notify, EventEmitter.of(primary.jsGeneration))
+            val state = ScreenEnvironment.Arrangement(PRIMARY, layout, front = overlay, hidden = false)
+            val changes = ScreenEnvironment.changesOf(EventEmitter.of(primary.jsGeneration))
+            ScreenEnvironment.setArrangement(primary.id, state, notify, changes)
         }
         if (secondary is ComponentViewController) {
-            val state = ArrangementStates.State(SECONDARY, layout, front = false, hidden = single)
-            ArrangementStates.set(secondary.id, state, notify, EventEmitter.of(secondary.jsGeneration))
+            val state = ScreenEnvironment.Arrangement(SECONDARY, layout, front = false, hidden = single)
+            val changes = ScreenEnvironment.changesOf(EventEmitter.of(secondary.jsGeneration))
+            ScreenEnvironment.setArrangement(secondary.id, state, notify, changes)
         }
     }
 
@@ -244,9 +246,9 @@ class ArrangementController internal constructor(
         // The stack keeps the bar's title, buttons and search by the view of its screen on top: they go with the pair.
         if (!isDestroyed && peekView() != null) performOnParentController { it.onChildDestroyed(this) }
         folds?.removeListener(onFoldsChanged)
-        ArrangementStates.remove(primary.id)
-        ArrangementStates.remove(secondary.id)
         shownChildren.containerDisappeared()
+        // The screens go with the pair: each clears its own environment, its arrangement too, unless its id is
+        // another's now.
         super.destroy()
     }
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/BottomTabsCollapseBehavior.kt

@@ -2,6 +2,7 @@ package dev.apexnative.navigation.viewcontrollers.bottomtabs
 
 import android.view.View
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
+import dev.apexnative.navigation.views.bottomtabs.BottomTabsLayout
 
 /**
  * bottomTabs.hideOnScroll: the tabs hide after a drag that scrolls the screen's content down and come back after one
@@ -43,9 +44,10 @@ class BottomTabsCollapseBehavior(private val container: () -> View?) :
     override fun onHide() {
         val view = container() ?: return
         hiddenByScroll = true
-        // Out of the screen with what is under it: a compact bar floats over its bottom margin and the navigation bar.
-        val under = ((view.parent as? View)?.let { it.height - view.bottom } ?: 0).coerceAtLeast(0)
-        view.animate().translationY((view.height + under).toFloat()).setDuration(DURATION).start()
+        // Out of the screen with what is under it (a compact bar floats over its bottom margin and the navigation bar)
+        // and the custom row that rises above it.
+        val distance = (view.parent as? BottomTabsLayout)?.hideDistance ?: view.height
+        view.animate().translationY(distance.toFloat()).setDuration(DURATION).start()
     }
 
     private companion object {

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/BottomTabsController.kt

@@ -34,6 +34,7 @@ import dev.apexnative.navigation.viewcontrollers.stack.StackController
 import dev.apexnative.navigation.viewcontrollers.stack.fab.FabPlacement
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.animations.AnimationLayer
 import dev.apexnative.navigation.views.animations.FadeThrough
 import dev.apexnative.navigation.views.bottomtabs.BottomTabItem
 import dev.apexnative.navigation.views.bottomtabs.BottomTabsLayout
@@ -199,7 +200,9 @@ class BottomTabsController(
                 }
             })
             val set = AnimatorSet()
-            set.playTogether(exit, FadeThrough.enter(coming))
+            // Each tab fades whole through a hardware layer; a switch ended early ([set]'s end) gives them back too.
+            val enter = FadeThrough.enter(coming)
+            set.playTogether(AnimationLayer.during(going, exit), AnimationLayer.during(coming, enter))
             set.addListener(object : AnimatorListenerAdapter() {
                 override fun onAnimationEnd(animation: Animator) {
                     set.removeAllListeners()
@@ -350,8 +353,8 @@ class BottomTabsController(
 
     /**
      * Selects the tab at [index]: the bar shows it at once; on screen the tab it left fades through to it (Material's
-     * fade through), off screen one container becomes invisible and the other visible at once; then [switched]. The
-     * history of back follows.
+     * fade through); off screen, or when the new tab's `bottomTabs.switchAnimation` is `'none'`, one container becomes
+     * invisible and the other visible at once; then [switched]. The history of back follows.
      */
     private fun select(index: Int, how: How) {
         if (index == selectedIndex || index !in tabs.indices || isDestroyed) return
@@ -381,7 +384,7 @@ class BottomTabsController(
         // it must act in this tab, not in the one still fading out.
         if (how != How.Press) AppearanceDispatcher.reportState()
         if (views == null) return switched(index, previous, how, onScreen, hasViews = false)
-        endSwitch = views.switch(shown, left, animated = onScreen) {
+        endSwitch = views.switch(shown, left, animated = onScreen && fadesThrough(shown)) {
             endSwitch = null
             if (!isDestroyed) switched(index, previous, how, onScreen, hasViews = true)
         }
@@ -427,6 +430,11 @@ class BottomTabsController(
         if (screen == null) finish() else AppearanceDispatcher.afterDidAppear(screen, finish)
     }
 
+    // `bottomTabs.switchAnimation` of the tab that shows, its shown screen's over its own, the tabs' and the defaults:
+    // `'platform'`, the default, fades through; `'none'` switches at once.
+    private fun fadesThrough(tab: ViewController<*>): Boolean =
+        tab.resolveShownOptions(DefaultOptions.current).bottomTabs.switchAnimation.get(null) != "none"
+
     // A switch still running ends at once and a press's `ANN.BottomTabSelected` still waiting goes, before anything
     // newer on these tabs.
     private fun flushPendingSelected() {
@@ -548,9 +556,6 @@ class BottomTabsController(
         return TabsRoom.tabsTop(room(), screenOptions(screen), bottom)
     }
 
-    override fun leavesBottomEdgeFree(child: ViewController<*>, screen: ViewController<*>): Boolean =
-        TabsRoom.leavesBottomEdgeFree(screenOptions(screen)) || super.leavesBottomEdgeFree(child, screen)
-
     override fun tabsAtRestOf(child: ViewController<*>, screen: ViewController<*>): FabPlacement.Tabs? {
         if (peekView() == null) return super.tabsAtRestOf(child, screen)
         return TabsRoom.fabTabs(room(), screenOptions(screen))
@@ -631,7 +636,6 @@ class BottomTabsController(
         layout.row = row
         layout.bar.customRowOptionsListener = { applyRow(row, it) }
         layout.bar.customRowOptions = resolveShownOptions(DefaultOptions.current).bottomTabs.customRow.copy()
-        CustomTabRowPlacer.track(activity)
     }
 
     private fun applyRow(row: CustomTabRow, options: BottomTabsCustomRowOptions) {
@@ -683,7 +687,7 @@ class BottomTabsController(
 
     /**
      * Destroys the tabs once: every tab and the registry first, then the cells (each stops its root once), the row out
-     * of the window, the scroll it followed. A press's event still waiting goes with them.
+     * of the tabs' view, the scroll it followed. A press's event still waiting goes with them.
      */
     override fun destroy() {
         if (isDestroyed) return
@@ -694,7 +698,6 @@ class BottomTabsController(
         endSwitch?.invoke()
         peekView()?.let { layout ->
             layout.bar.destroyCustomItemViews()
-            layout.row?.let(CustomTabRowPlacer::forget)
             layout.row = null
         }
         cells = emptyList()

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/CustomTabRowGeometry.kt

@@ -49,6 +49,22 @@ internal object CustomTabRowGeometry {
             content = content,
         )
 
+    /**
+     * The row over the bar as the tabs' view lays it out: the bar's [barLeft], [barRight] and [barBottom] in that
+     * view, whose height is [tabsHeight] and whose bottom [navigationBar] pixels lie under the navigation bar — the
+     * row's bottom never goes over them —, with [margin], [content] and [bottomMargin] as [place] takes them.
+     */
+    fun inTabs(
+        barLeft: Int,
+        barRight: Int,
+        barBottom: Int,
+        tabsHeight: Int,
+        navigationBar: Int,
+        margin: Int,
+        content: Int,
+        bottomMargin: Int,
+    ): Place = place(barLeft, barRight, minOf(barBottom, tabsHeight - navigationBar), margin, content, bottomMargin)
+
     /**
      * The part of the row's frame at [place] below its visible part, in pixels: `bottomMargin`. The row draws and takes
      * touches only above it.
@@ -61,6 +77,12 @@ internal object CustomTabRowGeometry {
      */
     fun needsPlacing(last: Place?, next: Place): Boolean = last != next
 
+    /**
+     * The row's own lift over its [elevation] while the bar's container stands at [barZ]: as high as the container, so
+     * the row, after it in the tabs' view, draws over it and takes the touches first even under a raised bar.
+     */
+    fun lift(barZ: Float, elevation: Float): Float = (barZ - elevation).coerceAtLeast(0f)
+
     /**
      * The row's background: `customRow.backgroundColor` ([color]; `null` and `'NoColor'` are none); without it
      * `backgroundEffect: 'none'` ([effect]) is clear, any other effect or none the theme's `android:colorBackground`

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/TabsRoom.kt

@@ -58,11 +58,6 @@ internal object TabsRoom {
     fun tabsTop(bar: Bar, screen: Screen, tabsBottom: Int): Int? =
         if (screen.hidden) null else tabsBottom - bar.reach - bar.rowOvershoot
 
-    /**
-     * The safe area of the screen leaves its bottom edge free: the bar hides on scroll and shows for it.
-     */
-    fun leavesBottomEdgeFree(screen: Screen): Boolean = screen.hideOnScroll && !screen.hidden
-
     /**
      * The bar at rest under a stack's FAB: also when the screen is under it (`drawBehind`, `hideOnScroll`); none when
      * the screen hides it.

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ComponentViewController.kt

@@ -8,9 +8,8 @@ import androidx.core.view.ViewCompat
 import androidx.core.view.WindowInsetsCompat
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.react.ArrangementStates
 import dev.apexnative.navigation.react.ReactView
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.react.ScreenRegions
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
@@ -157,7 +156,7 @@ class ComponentViewController(
             shown = layout.isShown || prepared,
             layoutPending = !prepared && isLayoutPending(content),
             topOfStack = parent?.isTopOfStack(this) ?: true,
-            hasSafeArea = ScreenInsets.padding(id) != null,
+            hasSafeArea = ScreenEnvironment.padding(id) != null,
         )
         if (!measures) return
         val windowInsets = ViewCompat.getRootWindowInsets(content) ?: return
@@ -176,11 +175,13 @@ class ComponentViewController(
         val edges = ScreenSafeArea.paddedEdges(
             safeAreaEdges = resolveCurrentOptions(DefaultOptions.current).layout.safeAreaEdges,
             topFree = parent?.leavesTopEdgeFree(this) == true,
-            bottomFree = parent?.leavesBottomEdgeFree(this) == true,
+            largeTitle = parent?.showsLargeTitleOver(this) == true,
         )
         // The events of the screen go to the JavaScript it was made for, and to no other.
         val emitter = EventEmitter.of(jsGeneration)
-        ScreenInsets.update(id, insets, ScreenSafeArea.padding(insets, edges), emitter)
+        val padding = ScreenSafeArea.padding(insets, edges)
+        val uncovered = ScreenSafeArea.uncovered(insets, padding)
+        ScreenEnvironment.setInsets(id, uncovered, padding, ScreenEnvironment.changesOf(emitter))
         val area = Rect(place.left, place.top, place.right, place.bottom)
         ScreenRegions.update(activity, id, area, windowInsets, emitter)
     }
@@ -245,9 +246,7 @@ class ComponentViewController(
         }
         setParentController(null)
         if (isIdTakenByAnother) return
-        ScreenInsets.remove(id)
-        ScreenRegions.remove(id)
-        ArrangementStates.remove(id)
+        ScreenEnvironment.remove(id)
         ScreenReadiness.remove(id)
     }
 

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/component/ScreenSafeArea.kt

@@ -1,6 +1,6 @@
 package dev.apexnative.navigation.viewcontrollers.component
 
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment.Insets
 
 /**
  * The arithmetic of a screen's room, safe area and background on Android, without views: the screen nodes read the
@@ -19,6 +19,7 @@ internal object ScreenSafeArea {
     const val LEFT = "left"
 
     private val ALL_EDGES = setOf(TOP, RIGHT, BOTTOM, LEFT)
+    private val DEFAULT_EDGES = setOf(TOP, RIGHT, LEFT)
     private const val OPAQUE = 0xFF
 
     /**
@@ -57,10 +58,10 @@ internal object ScreenSafeArea {
         headerBottom: Int?,
         tabsTop: Int?,
         density: Float,
-    ): ScreenInsets.Insets {
+    ): Insets {
         val coveredAbove = maxOf(system.top, headerBottom ?: 0)
         val coveredBelow = minOf(windowHeight - system.bottom, tabsTop ?: windowHeight)
-        return ScreenInsets.Insets(
+        return Insets(
             top = dp((coveredAbove - root.top).coerceAtLeast(0), density),
             right = dp((root.right - (windowWidth - system.right)).coerceAtLeast(0), density),
             bottom = dp((root.bottom - coveredBelow).coerceAtLeast(0), density),
@@ -69,26 +70,43 @@ internal object ScreenSafeArea {
     }
 
     /**
-     * The edges the screen's safe area view keeps its content off: exactly [safeAreaEdges] when the options give them;
-     * else all four, but the top when the stack's header hides on scroll or a large title shows ([topFree]) and the
-     * bottom when the tabs hide on scroll ([bottomFree]).
+     * The edges the screen's safe area view keeps its content off: exactly [safeAreaEdges] when the options give them,
+     * but the top under a large title ([largeTitle]); else the top and the sides, but the top when the stack's header
+     * hides on scroll or a large title shows ([topFree]). The bottom is free by default: the content goes down to the
+     * bottom, and a list keeps its last rows clear of the navigation bar with `useSafeAreaInsets()`.
      */
-    fun paddedEdges(safeAreaEdges: List<String>?, topFree: Boolean, bottomFree: Boolean): Set<String> {
-        if (safeAreaEdges != null) return safeAreaEdges.filterTo(LinkedHashSet()) { it in ALL_EDGES }
-        val edges = LinkedHashSet(ALL_EDGES)
+    fun paddedEdges(safeAreaEdges: List<String>?, topFree: Boolean, largeTitle: Boolean): Set<String> {
+        if (safeAreaEdges != null) {
+            val edges = safeAreaEdges.filterTo(LinkedHashSet()) { it in ALL_EDGES }
+            // Under a large title the list keeps its first rows clear of the bar itself; a padded top would follow the
+            // header as it collapses and move the list with it.
+            if (largeTitle) edges -= TOP
+            return edges
+        }
+        val edges = LinkedHashSet(DEFAULT_EDGES)
         if (topFree) edges -= TOP
-        if (bottomFree) edges -= BOTTOM
         return edges
     }
 
     /** The padding of the safe area view: the [insets] on the [edges] it keeps, 0 on the others. */
-    fun padding(insets: ScreenInsets.Insets, edges: Set<String>): ScreenInsets.Insets = ScreenInsets.Insets(
+    fun padding(insets: Insets, edges: Set<String>): Insets = Insets(
         top = if (TOP in edges) insets.top else 0.0,
         right = if (RIGHT in edges) insets.right else 0.0,
         bottom = if (BOTTOM in edges) insets.bottom else 0.0,
         left = if (LEFT in edges) insets.left else 0.0,
     )
 
+    /**
+     * The insets JavaScript gets (`useSafeAreaInsets`): what of the [insets] still covers the content once the safe
+     * area view keeps it off its [padding], 0 on a padded edge.
+     */
+    fun uncovered(insets: Insets, padding: Insets) = Insets(
+        top = (insets.top - padding.top).coerceAtLeast(0.0),
+        right = (insets.right - padding.right).coerceAtLeast(0.0),
+        bottom = (insets.bottom - padding.bottom).coerceAtLeast(0.0),
+        left = (insets.left - padding.left).coerceAtLeast(0.0),
+    )
+
     /**
      * The inner padding of a screen's view: the side system bars ([systemBars]) at the sides; at the bottom the larger
      * of the navigation bar (none when the screen draws under it) and the keyboard ([imeBottom]; none with

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/externalcomponent/ExternalComponentViewController.kt

@@ -10,11 +10,9 @@ import dev.apexnative.navigation.layout.LayoutException
 import dev.apexnative.navigation.nativescreen.NativeScreenContext
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.react.ArrangementStates
 import dev.apexnative.navigation.react.CommandScope
 import dev.apexnative.navigation.react.ErrorTexts
-import dev.apexnative.navigation.react.ScreenInsets
-import dev.apexnative.navigation.react.ScreenRegions
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
 import dev.apexnative.navigation.react.events.ScreenAppearance
@@ -170,9 +168,7 @@ class ExternalComponentViewController internal constructor(
         peekView()?.let { (it.parent as? ViewGroup)?.removeView(it) }
         setParentController(null)
         if (isIdTakenByAnother) return
-        ScreenInsets.remove(id)
-        ScreenRegions.remove(id)
-        ArrangementStates.remove(id)
+        ScreenEnvironment.remove(id)
         ScreenReadiness.remove(id)
         if (!notMade) AppearanceDispatcher.nativeScreenReleased(this)
     }