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

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

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

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

@@ -3,6 +3,7 @@ package dev.apexnative.navigation.react
 import android.annotation.SuppressLint
 import android.content.Context
 import android.os.Bundle
+import android.util.Size
 import android.view.MotionEvent
 import android.view.ViewGroup
 import android.widget.FrameLayout
@@ -28,7 +29,9 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListe
  * never makes this one ready. A screen without a safe area view (no view ever told anything of its id) is ready once
  * the root view of its surface has children, read on this view's own layout passes. A root that renders at once
  * ([rendersAtOnce]: a component of a bar, a tab's cell) marks its id so from before its surface starts until it stops.
- * Ready once, ready for good; what waits for it ([whenReady]) runs then, once.
+ * Ready once, ready for good; what waits for it ([whenReady]) runs then, once. Its content measures without a height
+ * limit ([contentSize], `ContentHeights`), and the handlers of [setOnContentMounted] hear each mount of Fabric while
+ * the view is in a window.
  * Without a signal or children, the limits of what waits decide: the view has no timer of its own. It owns the
  * record of its appearance, which the dispatcher of the appearance events holds until the content is ready
  * (`AppearanceDispatcher`).
@@ -51,6 +54,7 @@ class ReactView @JvmOverloads constructor(
     private var readyTold = false
     private val readyListeners = mutableListOf<Runnable>()
     private var listening = false
+    private val mounts = ContentMounts { !destroyed && isAttachedToWindow }
 
     // What this root hears of its id: only the signals of its own surface.
     private val readiness = object : ScreenReadiness.Listener {
@@ -112,6 +116,16 @@ class ReactView @JvmOverloads constructor(
     override val touchRoot: ViewGroup?
         get() = surface?.view as? ViewGroup
 
+    override fun contentSize(maxWidth: Int): Size? {
+        val surface = surface ?: return null
+        val height = ContentHeights.surfaceHeight(context, surface, maxWidth) ?: return null
+        return Size(maxWidth, height)
+    }
+
+    override fun setOnContentMounted(key: String, handler: Runnable?) {
+        if (!destroyed) mounts.set(key, handler)
+    }
+
     override fun isReady(): Boolean {
         if (!ready && hasRendered()) ready = true
         return ready
@@ -167,6 +181,7 @@ class ReactView @JvmOverloads constructor(
         AppearanceDispatcher.didDisappear(appearance)
         destroyed = true
         readyListeners.clear()
+        mounts.clear()
         stopListening()
         if (rendersAtOnce) ScreenReadiness.setRendersAtOnce(componentId, this, false)
         val surface = surface ?: return

package/android/src/main/java/dev/apexnative/navigation/slots/SlotScreenView.kt

@@ -2,9 +2,13 @@ package dev.apexnative.navigation.slots
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.util.Size
 import android.view.MotionEvent
 import android.view.ViewGroup
 import android.widget.FrameLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import dev.apexnative.navigation.react.ContentHeights
+import dev.apexnative.navigation.react.ContentMounts
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
 import dev.apexnative.navigation.react.events.ScreenAppearance
@@ -16,9 +20,10 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListe
  * What a slot screen (`slot:<Name>`) shows: the empty container its slot of the app's React tree moves its children
  * into, under the screen's id ([SlotContainers]), told of each change of its size. It is the screen's content for the
  * core: ready once the slot's content has mounted into it and, when the screen has a safe area view, the screen
- * rendered into that view; its mounted handlers run at each mount. Its appearance events go through its record to the
- * core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit. Destroyed while the
- * id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
+ * rendered into that view; its mounted handlers run at each mount of Fabric and as the content mounts into it. Its
+ * content measures without a height limit in the slot's own layout ([contentSize]). Its appearance events go through
+ * its record to the core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit.
+ * Destroyed while the id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
  */
 @SuppressLint("ViewConstructor")
 class SlotScreenView(
@@ -30,7 +35,7 @@ class SlotScreenView(
     private val scrollEventListener = ScrollEventListener()
     private val whenMounted = mutableListOf<Runnable>()
     private val whenRendered = mutableListOf<Runnable>()
-    private val mountedHandlers = LinkedHashMap<String, Runnable>()
+    private val mounts = ContentMounts { !destroyed && isAttachedToWindow }
     private var listening = false
 
     // The safe area view of a slot renders in the app's one React tree: every signal of the id is the screen's.
@@ -84,10 +89,11 @@ class SlotScreenView(
         destroyed = true
         whenMounted.clear()
         whenRendered.clear()
-        mountedHandlers.clear()
+        mounts.clear()
         stopListening()
         // A later screen with the same id keeps the slot.
         if (SlotContainers.get(componentId) !== this) return
+        ContentHeights.forgetSlot(componentId)
         SlotContainers.remove(componentId)
         if (!isPreparedPush) AppearanceDispatcher.slotDestroyed(componentId, appearance.generation)
     }
@@ -120,7 +126,21 @@ class SlotScreenView(
     }
 
     override fun setOnContentMounted(key: String, handler: Runnable?) {
-        if (handler == null) mountedHandlers.remove(key) else mountedHandlers[key] = handler
+        if (!destroyed) mounts.set(key, handler)
+    }
+
+    // The slot measures its content in its own layout: the first question asks for it and lays the slot out again; the
+    // height comes with that layout, before the mount the handlers hear. The width is the container's, at which the
+    // slot lays its content out.
+    override fun contentSize(maxWidth: Int): Size? {
+        if (destroyed) return null
+        if (!ContentHeights.isSlotRequested(componentId)) {
+            ContentHeights.requestSlot(componentId)
+            SlotContainers.changed(componentId)
+            return null
+        }
+        val height = ContentHeights.slotHeight(componentId)?.takeIf { it > 0f } ?: return null
+        return Size(if (width > 0) width else maxWidth, Math.round(height.dpToPx()))
     }
 
     // Only the container that holds the slot of the id: a destroyed one, or one a later screen replaced, takes no
@@ -136,7 +156,7 @@ class SlotScreenView(
         val waiting = whenMounted.toList()
         whenMounted.clear()
         waiting.forEach { it.run() }
-        mountedHandlers.values.toList().forEach { it.run() }
+        mounts.run()
         checkReadiness()
     }
 

package/android/src/main/java/dev/apexnative/navigation/slots/SlotView.kt

@@ -15,6 +15,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
+import dev.apexnative.navigation.react.ContentHeights
 
 /**
  * The React children of a slot. They live outside the views of the host's surface, in the container of a screen, so
@@ -79,6 +80,8 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
         }
     private var lastWidth = -1f
     private var lastHeight = -1f
+    // The slot was laid out once more, at the same size, for the measure of its content (`ContentHeights`).
+    private var measureAsked = false
 
     private val slotId: String?
         get() = getTag(R.id.view_tag_native_id) as? String
@@ -116,7 +119,14 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
         if (container != null && state != null && container.width > 0 && container.height > 0) {
             val width = container.width.toFloat().pxToDp()
             val height = container.height.toFloat().pxToDp()
-            if (width != lastWidth || height != lastHeight) {
+            // A container that measures the content gets one layout more for it, with the same size, until the height
+            // came.
+            val requested = ContentHeights.isSlotRequested(id)
+            // A request that went (its screen did) and comes again gets its layout again.
+            if (!requested) measureAsked = false
+            val measures = !measureAsked && requested && ContentHeights.slotHeight(id) == null
+            if (width != lastWidth || height != lastHeight || measures) {
+                measureAsked = measureAsked || measures
                 lastWidth = width
                 lastHeight = height
                 state.updateState(
@@ -136,6 +146,7 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
     }
 
     fun drop() {
+        measureAsked = false
         SlotContainers.unregister(this)
         (content.parent as? ViewGroup)?.removeView(content)
     }

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

@@ -28,7 +28,7 @@ internal object MaterialTheme {
     private val wrappers = WeakHashMap<Context, WeakReference<Context>>()
     // Themes of the navigation's own views, each made once over the activity's with a style of its own.
     private val followers = WeakHashMap<Context, Int>()
-    // The popup theme of the bar's toolbars per activity: the app's theme doesn't change while the activity lives.
+    // The popup theme of the bar's "⋮" per activity: the app's theme doesn't change while the activity lives.
     private val popupThemes = WeakHashMap<Activity, Int>()
 
     fun context(context: Context): Context {
@@ -38,11 +38,10 @@ internal object MaterialTheme {
     }
 
     /**
-     * The popup theme of the top bar's toolbars, for "⋮", set on them before their menu is made. None when the app's
-     * theme follows light and dark: the menu takes the bar's own theme, which [rebase] keeps in the current mode, with
-     * the app's colors. With a Material 3 theme fixed to light or to dark, a day/night overlay that gives the menu the
-     * current mode's colors where the theme shows the other mode. Android makes the menu's theme from it at the menu's
-     * first opening, in the mode of that moment, and no public API makes it again for a later switch.
+     * The popup theme of the top bar's "⋮", over the bar's theme at each opening of its popup, in the mode of that
+     * moment. None when the app's theme follows light and dark: the menu takes the bar's own theme, which [rebase]
+     * keeps in the current mode, with the app's colors. With a Material 3 theme fixed to light or to dark, a day/night
+     * overlay that gives the menu the current mode's colors where the theme shows the other mode.
      */
     fun popupTheme(context: Context): Int {
         val activity = activityOf(context) ?: return 0

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

@@ -0,0 +1,36 @@
+package dev.apexnative.navigation.utils
+
+import android.animation.ValueAnimator
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.provider.Settings
+import dev.apexnative.navigation.NavigationApplication
+
+/**
+ * Whether the system plays no animations: "Remove animations" in the accessibility settings, or the animator duration
+ * scale at 0 in the developer options. Then a transition doesn't wait for its elements' targets and images and moves no
+ * element, and the side menu opens and closes at once. Any thread.
+ */
+internal object SystemAnimations {
+    /**
+     * The animations are off now; [context] reads the scale below Android 8, else the application's. Lint can't see
+     * that the decision calls `areAnimatorsEnabled` (API 26) only from Android 8.
+     */
+    @SuppressLint("NewApi")
+    fun areOff(context: Context? = null): Boolean =
+        areOff(Build.VERSION.SDK_INT, { ValueAnimator.areAnimatorsEnabled() }) { durationScaleOf(context) }
+
+    /**
+     * The decision: from Android 8 the animator's own answer ([animatorsEnabled]), which follows both settings;
+     * below it the duration scale ([durationScale]) at 0.
+     */
+    fun areOff(sdk: Int, animatorsEnabled: () -> Boolean, durationScale: () -> Float): Boolean =
+        if (sdk >= Build.VERSION_CODES.O) !animatorsEnabled() else durationScale() == 0f
+
+    // Without a context and before the application started (the unit tests), the animations play.
+    private fun durationScaleOf(context: Context?): Float {
+        val resolver = (context ?: NavigationApplication.instanceOrNull)?.contentResolver ?: return 1f
+        return Settings.Global.getFloat(resolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f)
+    }
+}