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

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

@@ -7,17 +7,13 @@ import android.app.Activity
 import android.content.Context
 import android.content.pm.ApplicationInfo
 import android.graphics.Color
-import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
-import android.view.Menu
-import android.view.MenuItem
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.view.animation.LinearInterpolator
 import android.view.animation.PathInterpolator
 import android.widget.FrameLayout
-import android.widget.ImageView
 import androidx.appcompat.content.res.AppCompatResources
 import androidx.core.graphics.drawable.DrawableCompat
 import androidx.core.view.WindowInsetsCompat
@@ -59,6 +55,7 @@ import dev.apexnative.navigation.views.stack.topbar.TitleBar
 import dev.apexnative.navigation.views.stack.topbar.TopBar
 import dev.apexnative.navigation.views.stack.topbar.TopBarDefaults
 import dev.apexnative.navigation.views.stack.topbar.titlebar.BarButtonComponentCell
+import dev.apexnative.navigation.views.stack.topbar.titlebar.BarMenu
 import dev.apexnative.navigation.views.stack.topbar.titlebar.ButtonBar
 import dev.apexnative.navigation.views.stack.topbar.titlebar.IconBackgroundDrawable
 import kotlin.math.roundToInt
@@ -132,6 +129,8 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
     // The bar goes with the screens of a transition of the stack's own, and the screen that leaves with its picture.
     private var travelling = false
     private var travelLeaving: ViewController<*>? = null
+    // The bar hides as it shows now, and the options of the screen it hides for wait until it is gone.
+    private var waitsForHide = false
 
     private enum class Part { Look, Title, Left, Right, Back, LargeTitle, Visible, TestId }
 
@@ -142,9 +141,9 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         this.layout = layout
         val bar = layout.topBar
         this.bar = bar
-        leftButtons = ButtonBar(bar.leftButtonBar, true, ::loadIcon, Buttons())
-        rightButtons = ButtonBar(bar.rightButtonBar, false, ::loadIcon, Buttons())
-        visibility = TopBarVisibility(VisibilityTarget(bar) { collapse?.reset() })
+        leftButtons = ButtonBar(bar.leftButtonBar, ::loadIcon, Buttons())
+        rightButtons = ButtonBar(bar.rightButtonBar, ::loadIcon, Buttons())
+        visibility = TopBarVisibility(VisibilityTarget(bar) { collapse?.reset() }, ::hidden)
         rowTransition = BarRowTransition(RowTarget(bar).also { rowTarget = it })
         collapse = TopBarCollapseBehavior(bar)
         bar.leftButtonBar.setNavigationOnClickListener { host.backPressed() }
@@ -185,6 +184,7 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         val bar = bar
         val leaving = shownEntry
         val lowers = bar != null && bar.isLargeTitleShown && incoming != null && leaving != null &&
+            !hidesMoving(host.resolvedOf(incoming), visibility, travel != null) &&
             lowersBar(motion, incoming, host.resolvedOf(incoming))
         rowTarget?.withLargeTitle = !lowers
         if (lowers) pictureUnderRow(bar, leaving)
@@ -193,6 +193,15 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         if (travel != null && bar != null && incoming != null) beginTravel(bar, leaving, incoming, travel, visibility)
     }
 
+    // Whether a screen with [options] hides the bar, shown now, by a move of [change]: a slide, or the transition's
+    // side. The bar then leaves as it shows, its large title too (`applyAll`); while it goes with the screens of a
+    // transition of the stack's own ([travels]) only a side of its own moves it.
+    private fun hidesMoving(options: Options, change: StackDisplay.BarVisibility, travels: Boolean): Boolean {
+        val exit = change.side?.exit
+        return options.topBar.visible.isFalse && !options.topBar.animate.isFalse && change.animated &&
+            !AnimationRules.isTurnedOff(exit) && (!travels || AnimationRules.barSideGiven(exit))
+    }
+
     /** The transition that brought the current child ended: the row at rest, the picture under it gone. */
     fun endRowTransition() {
         // A large title still opening is open now.
@@ -212,8 +221,8 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
      * bar as it is goes with [leaving], and the bar, which takes [incoming]'s options next, is drawn flat as [incoming]
      * moves — under [leaving] on a pop ([StackDisplay.BarTravel.Back]) (`StackLayout.barTravels`). No picture when the
      * bar doesn't show. Nothing travels when the new top hides the bar by a side of its own
-     * (`animations.*.topBar.exit`), which plays instead, or when the bar can't be drawn in software (a `HARDWARE`
-     * bitmap in it): the bar takes the options in its place.
+     * (`animations.*.topBar.exit`), which plays instead, or when the bar can't be recorded (a `HARDWARE` bitmap in it
+     * on Android 8): the bar takes the options in its place.
      */
     private fun beginTravel(
         bar: TopBar,
@@ -238,10 +247,10 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
 
     // The bar's picture where the bar is in the stack, its moves counted.
     private fun pictureOfBar(bar: TopBar): Drawable? {
-        val bitmap = bar.picture() ?: return null
+        val picture = bar.picture() ?: return null
         val left = (bar.left + bar.translationX).roundToInt()
         val top = (bar.top + bar.translationY).roundToInt()
-        return BitmapDrawable(bar.resources, bitmap).apply { setBounds(left, top, left + bitmap.width, top + bitmap.height) }
+        return picture.apply { setBounds(left, top, left + intrinsicWidth, top + intrinsicHeight) }
     }
 
     // The bar's travel ends: the picture goes, the bar is drawn in its place again with its shadow.
@@ -284,6 +293,8 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         val bar = bar ?: return
         val screen = host.optionsScreen(entry)
         if (screen !== shownScreen) return apply(entry)
+        // An open menu has the colors of before.
+        if (delta.topBar.menuBackgroundColor.hasValue() || delta.topBar.menuTextColor.hasValue()) closeMenus()
         val options = host.resolvedOf(entry)
         applyAll(bar, entry, screen, options, merge = true, delta = delta)
     }
@@ -293,6 +304,8 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
      * now.
      */
     fun repaint(entry: ViewController<*>?) {
+        // An open menu has the old colors: it closes.
+        closeMenus()
         keys.clear()
         apply(entry)
         val options = entry?.let(host::resolvedOf) ?: return
@@ -305,6 +318,7 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
      * of the bar (the search) applies again.
      */
     fun onInsets() {
+        if (waitsForHide) return
         val bar = bar ?: return
         val entry = shownEntry ?: return
         val screen = shownScreen ?: return
@@ -379,6 +393,12 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
 
     /** [screen] is destroyed: its components and its search go. */
     fun screenDestroyed(screen: ViewController<*>, entryView: View?) {
+        // The bar may still show the components of the screen that goes: it is gone at once, with the options it held
+        // back, before they go; none when they are of the screen that goes.
+        if (waitsForHide) {
+            if (screen === shownScreen) waitsForHide = false
+            visibility?.hide(animated = false)
+        }
         if (screen === shownScreen) {
             shownScreen = null
             shownEntry = null
@@ -465,6 +485,26 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         merge: Boolean,
         delta: Options? = null,
     ) {
+        // A screen that hides the bar: the bar leaves as it shows, its look, title and buttons those of the screen
+        // before, and takes this screen's options once it is gone. Taken first, they would paint the leaving bar (the
+        // default color over a bar that was transparent).
+        val waited = waitsForHide
+        waitsForHide = false
+        if (options.topBar.visible.isFalse && (!merge || waited)) {
+            applyVisibility(options, merge)
+            waitsForHide = visibility?.isHiding == true
+            if (waitsForHide) {
+                // The list of the screen before no longer moves the bar: a move of it would stop the hide.
+                collapse?.disableCollapse(reset = false)
+                return
+            }
+        }
+        // Shown again by a merge before it was gone: none of this screen's options are on the bar yet. It shows as a
+        // merge shows it, by `animate`, not by the transition's side.
+        if (merge && waited) {
+            visibilityChange = StackDisplay.BarVisibility(true, null)
+            return applyAll(bar, entry, screen, options, merge = false)
+        }
         applyLook(bar, entry, options)
         applyTitle(bar, screen, options)
         // The search first: its magnifier takes a place among the right buttons. It gets a copy of the group: it
@@ -582,16 +622,15 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
             keys[Part.Left] = leftKey
             reportWithoutId(topBar.buttons.left, "leftButtons")
             leftButtons?.set(
-                left.map { button(screen, it, roots) },
+                ButtonPlaces.line(left, left = true).map { button(screen, it, roots) },
                 emptyList(),
                 null,
                 merge && topBar.animateLeftButtons.isTrue,
             )
         }
         val overflow = topBar.overflowMenu?.takeIf { it.items.isNotEmpty() }
-        val menu = bar.rightButtonBar.menu
         search.applyMagnifier()
-        val taken = (0 until menu.size()).count { menu.getItem(it).itemId != Menu.NONE }
+        val taken = if (bar.rightButtonBar.trailingView != null) 1 else 0
         val configuration = context.resources.configuration
         val plan = ButtonPlaces.plan(
             right.map { ButtonPlaces.Button(ButtonPlaces.priorityOf(it.priority.get(null)), it.pinned.isTrue) },
@@ -612,12 +651,11 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
             keys[Part.Right] = rightKey
             reportWithoutId(topBar.buttons.right, "rightButtons")
             rightButtons?.set(
-                plan.inBar.map { button(screen, right[it], roots) },
+                ButtonPlaces.line(plan.inBar, left = false).map { button(screen, right[it], roots) },
                 plan.inOverflow.map { button(screen, right[it], roots) },
                 overflow,
                 merge && topBar.animateRightButtons.isTrue,
             )
-            search.applyMagnifier()
             rightButtons?.setOverflowColor(overflowColor)
         }
     }
@@ -639,9 +677,9 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         ).joinToString()
         if (keys[Part.Back] == key) return
         keys[Part.Back] = key
-        val toolbar = bar.leftButtonBar
+        val row = bar.leftButtonBar
         if (!shown) {
-            toolbar.navigationIcon = null
+            row.navigationIcon = null
             return
         }
         val own = back.icon.get(null)?.let(::loadIcon)?.mutate()
@@ -668,19 +706,13 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
                 dp(background.height.get(0.0)),
             )
         } ?: icon
-        toolbar.navigationIcon = drawable
-        // Taking the icon, the navigation button gives it its own direction, which is stale while the button is new
-        // or the bar's direction has just changed; the toolbar corrects it only after the icon was drawn. So the arrow
-        // gets the bar's direction at once, on the drawable the button shows; a background passes it to the arrow.
-        val held = toolbar.navigationIcon ?: drawable
-        DrawableCompat.setLayoutDirection(held, arrowDirection)
-        if (held !== drawable) DrawableCompat.setLayoutDirection(drawable, arrowDirection)
-        toolbar.navigationContentDescription = label
-        // The toolbar uses its navigation button again from screen to screen: its id is set every time.
-        for (index in 0 until toolbar.childCount) {
-            val child = toolbar.getChildAt(index)
-            if ((child as? ImageView)?.drawable === held) TestIds.apply(child, testId)
-        }
+        row.navigationIcon = drawable
+        // Taking the icon, the back button gives it its own direction, which is stale while the button is new or the
+        // bar's direction has just changed; the button corrects it only once its direction is resolved again. So the
+        // arrow gets the bar's direction at once; a background passes it to the arrow.
+        DrawableCompat.setLayoutDirection(drawable, arrowDirection)
+        row.navigationContentDescription = label
+        row.navigationButton?.let { TestIds.apply(it, testId) }
     }
 
     // The background (`topBar.background.component`).
@@ -719,15 +751,14 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
 
     private fun pictureUnderRow(bar: TopBar, leaving: ViewController<*>) {
         val view = leaving.peekView() ?: return
-        val (bitmap, top) = bar.pictureUnderRow() ?: return
+        val (picture, top) = bar.pictureUnderRow() ?: return
         val barPlace = IntArray(2)
         val viewPlace = IntArray(2)
         bar.getLocationInWindow(barPlace)
         view.getLocationInWindow(viewPlace)
-        val picture = BitmapDrawable(bar.resources, bitmap)
         val left = barPlace[0] - viewPlace[0]
         val y = barPlace[1] + top - viewPlace[1]
-        picture.setBounds(left, y, left + bitmap.width, y + bitmap.height)
+        picture.setBounds(left, y, left + picture.intrinsicWidth, y + picture.intrinsicHeight)
         view.overlay.add(picture)
         underRow = leaving to picture
     }
@@ -802,6 +833,16 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
         opening.cancel()
     }
 
+    // A hide that held the options back ended: the bar, gone now, takes them.
+    private fun hidden() {
+        if (!waitsForHide) return
+        waitsForHide = false
+        val bar = bar ?: return
+        val entry = shownEntry ?: return
+        val screen = shownScreen ?: return
+        applyAll(bar, entry, screen, host.resolvedOf(entry), merge = false)
+    }
+
     // Shown or hidden: with the transition by its side, or by `animate` in a merge.
     private fun applyVisibility(options: Options, merge: Boolean) {
         val visible = !options.topBar.visible.isFalse
@@ -1037,11 +1078,16 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
             return (buttons.left.orEmpty() + buttons.right.orEmpty()).firstOrNull { it.id.get(null) == buttonId }?.menu
         }
 
-        // The search's magnifier, the one item of the bar with an id of its own: `<topBar.searchBar.testID>.button`.
-        override fun testIdOf(item: MenuItem): String? {
-            if (item.itemId == Menu.NONE) return null
-            val entry = shownEntry ?: return null
-            return host.resolvedOf(entry).topBar.searchBar.testID.get(null)?.let { "$it.button" }
+        // Read as a menu opens, so they follow light and dark mode: `menuBackgroundColor`, else the bar's color as it
+        // shows (none when it lets something through), and then `menuTextColor` or else the title's color, the pair
+        // the bar shows; with neither, the theme's.
+        override fun menuColors(): BarMenu.Colors {
+            val topBar = shownEntry?.let(host::resolvedOf)?.topBar ?: return BarMenu.Colors(null, null)
+            val context = bar?.context ?: activity
+            val text = topBar.menuTextColor.get(context, null)
+            topBar.menuBackgroundColor.get(context, null)?.let { return BarMenu.Colors(it, text) }
+            val barColor = bar?.barColor?.takeIf { Color.alpha(it) == OPAQUE } ?: return BarMenu.Colors(null, text)
+            return BarMenu.Colors(barColor, text ?: topBar.title.color.get(context, null))
         }
     }
 
@@ -1183,6 +1229,7 @@ internal class TopBarPresenter(private val activity: Activity, private val host:
 
     private companion object {
         const val DEFAULT_HEIGHT_DP = 64.0
+        const val OPAQUE = 255
         const val DEFAULT_TITLE_SP = 22.0
         const val DEFAULT_SUBTITLE_SP = 14.0
         const val CENTER = "center"

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

@@ -10,9 +10,10 @@ import dev.apexnative.navigation.views.animations.AnimationRules
  * stack its side (`animations.*.topBar`) plays instead — its `exit` hides, its `enter` shows; `enabled: false` shows or
  * hides at once. A show cancels a running hide and a hide a running show, each with its own token, so `visible: false`
  * then `true` leaves the bar shown; a motion cancelled leaves the bar at rest; a bar shown again stands in its place
- * with its row seen (the hide on scroll's shift and fade reset). Main thread only.
+ * with its row seen (the hide on scroll's shift and fade reset). [onHidden] runs once a hide has made the bar `GONE`.
+ * Main thread only.
  */
-internal class TopBarVisibility(private val target: Target) {
+internal class TopBarVisibility(private val target: Target, private val onHidden: () -> Unit = {}) {
     /** What moves: the bar's view, or the unit tests' fake. */
     interface Target {
         /** How far up the bar goes to hide: its height and the room over it, in pixels. */
@@ -45,6 +46,10 @@ internal class TopBarVisibility(private val target: Target) {
     val isHidden: Boolean
         get() = hidden
 
+    /** The bar is on its way out: a hide moves it and it still shows. */
+    val isHiding: Boolean
+        get() = hidden && sliding != null
+
     /** Shows the bar: by [side] when it plays, sliding down when [animated], else at once. */
     fun show(animated: Boolean, side: TopBarAnimationOptions? = null) {
         val wasHidden = hidden
@@ -84,6 +89,7 @@ internal class TopBarVisibility(private val target: Target) {
         if (!moves || target.isGone) {
             target.translationY = 0f
             target.isGone = true
+            onHidden()
             return
         }
         val token = Any()
@@ -93,6 +99,7 @@ internal class TopBarVisibility(private val target: Target) {
                 settle()
                 target.isGone = true
                 target.translationY = 0f
+                onHidden()
             }
         }
         val own = side?.takeIf { AnimationRules.sidePlays(it) }