@apexnative/navigation 1.0.0-alpha.1 → 1.0.0-alpha.10

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

@@ -2,6 +2,7 @@ package dev.apexnative.navigation.viewcontrollers.stack
 
 import android.app.Activity
 import android.util.Log
+import android.view.View
 import dev.apexnative.navigation.NavigationActivity
 import dev.apexnative.navigation.options.AnimationsOptions
 import dev.apexnative.navigation.options.BottomTabsEnterExitAnimationOptions
@@ -11,6 +12,7 @@ import dev.apexnative.navigation.options.Options
 import dev.apexnative.navigation.options.TopBarOptions
 import dev.apexnative.navigation.react.CommandListener
 import dev.apexnative.navigation.react.ErrorTexts
+import dev.apexnative.navigation.react.PendingCalls
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.utils.NavigationLog
 import dev.apexnative.navigation.utils.UiThread
@@ -20,8 +22,8 @@ import dev.apexnative.navigation.viewcontrollers.child.ChildControllersRegistry
 import dev.apexnative.navigation.viewcontrollers.component.ComponentViewController
 import dev.apexnative.navigation.viewcontrollers.component.ContentReadiness
 import dev.apexnative.navigation.viewcontrollers.component.Readiness
+import dev.apexnative.navigation.viewcontrollers.component.RenderWait
 import dev.apexnative.navigation.viewcontrollers.component.RestPlace
-import dev.apexnative.navigation.viewcontrollers.component.ScreenContentFactory
 import dev.apexnative.navigation.viewcontrollers.navigator.BackCallbackState
 import dev.apexnative.navigation.viewcontrollers.navigator.Navigator
 import dev.apexnative.navigation.viewcontrollers.parent.ContainerBackground
@@ -29,12 +31,14 @@ import dev.apexnative.navigation.viewcontrollers.parent.OptionsScreen
 import dev.apexnative.navigation.viewcontrollers.parent.ParentController
 import dev.apexnative.navigation.viewcontrollers.parent.ReturnsScreenFromColumn
 import dev.apexnative.navigation.viewcontrollers.parent.nodeWith
+import dev.apexnative.navigation.viewcontrollers.stack.fab.FabMotion
 import dev.apexnative.navigation.viewcontrollers.stack.fab.FabPresenter
 import dev.apexnative.navigation.viewcontrollers.stack.topbar.LargeTitleCollapse
 import dev.apexnative.navigation.viewcontrollers.stack.topbar.TopBarPresenter
 import dev.apexnative.navigation.viewcontrollers.stack.topbar.TopBarRoom
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.animations.AnimationRules
 import dev.apexnative.navigation.views.component.ComponentLayout
 import dev.apexnative.navigation.views.stack.StackLayout
 import dev.apexnative.navigation.views.stack.topbar.LargeTitleView
@@ -79,26 +83,34 @@ class StackController(
 
     /** The one queue of the stack. */
     // The readiness of the screens reaches the queue's waits on the next turn of the main loop: a signal that comes
-    // inside a layout pass or a view's attach moves no view of the container there.
+    // inside a layout pass or a view's attach moves no view of the container there. A pushed screen's mount reaches
+    // its push behind the calls JavaScript made before it (`PendingCalls`), on a later turn too.
     internal var queue = StackQueue(
         display = StackViews(this),
         readiness = ContentReadiness,
         scheduler = { delay, task -> AppearanceDispatcher.scheduler.schedule(delay, task) },
         host = QueueHost(),
         deliver = { signal -> UiThread.post { signal() } },
+        afterCalls = PendingCalls::after,
     )
         private set
 
     /**
      * The unit tests run the stack over their own display, readiness and host (views are stubs there), before any
-     * screen joins it; the readiness signals come at once there.
+     * screen joins it; the readiness signals come at once there, and a push's behind the calls as [afterCalls] says.
      */
-    internal fun useQueueParts(display: StackDisplay, readiness: Readiness, host: StackQueue.Host?) {
+    internal fun useQueueParts(
+        display: StackDisplay,
+        readiness: Readiness,
+        host: StackQueue.Host?,
+        afterCalls: (() -> Unit) -> Unit = { it() },
+    ) {
         queue = StackQueue(
             display = display,
             readiness = readiness,
             scheduler = { delay, task -> AppearanceDispatcher.scheduler.schedule(delay, task) },
             host = host ?: QueueHost(),
+            afterCalls = afterCalls,
         )
     }
 
@@ -196,6 +208,17 @@ class StackController(
         screen.changeOptions { it.topBar.buttons.back.setVisible() }
     }
 
+    /**
+     * `clearOptions` took options out of the own options of [node], an entry of this stack or the options screen of
+     * one: the back arrow's rule ([join]) writes its part of them again, so the first screen keeps its arrow hidden
+     * and another shows it unless its options say otherwise.
+     */
+    internal fun ownOptionsCleared(node: ViewController<*>) {
+        val entries = queue.entries
+        val entry = entries.firstOrNull { it === node || optionsScreen(it) === node } ?: return
+        backRule(entry, first = entry === entries.first())
+    }
+
     /** The key of [entry]; none without one. */
     internal fun keyOf(entry: ViewController<*>): String? = keys[entry]
 
@@ -257,6 +280,153 @@ class StackController(
      */
     override fun canHandleBack(): Boolean = topBar.isSearchOpen() || queue.entries.size >= 2
 
+    /**
+     * 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, 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
+        val entries = queue.entries
+        val top = queue.currentChild ?: return null
+        val target = entries.getOrNull(entries.size - 2) ?: return null
+        if (top !== entries.last() || target !in queue.shown || target.peekView() == null) return null
+        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) return null
+        if (pop.preview.isFalse || AnimationRules.stackIsOwn(pop)) return null
+        val display = queue.display
+        return this.takeIf { display.isOnScreen && display.canAnimate }
+    }
+
+    /**
+     * Starts the preview of the pop a back gesture would make ([stackPoppedByBack] said yes): the top shrinks toward
+     * the gesture's side ([fromLeft]) and follows the finger from [touchY]; the screen under it shows with its bar.
+     * None when it can't be shown.
+     */
+    internal fun startBackGesture(fromLeft: Boolean, touchY: Float): BackGesture? {
+        val views = queue.display as? StackViews ?: return null
+        val top = queue.currentChild ?: return null
+        val target = queue.entries.getOrNull(queue.entries.size - 2) ?: return null
+        val gesture = BackGesture(views, top, target)
+        val preview = views.startBackPreview(top, target, fromLeft, touchY, gesture::reveal) ?: return null
+        gesture.preview = preview
+        backGesture = gesture
+        return gesture
+    }
+
+    // The back gesture over this stack whose preview hasn't ended yet; none.
+    private var backGesture: BackGesture? = null
+
+    // A merge of `fab` into the top waits for the end of a back gesture's preview.
+    private var fabMergeWaits = false
+
+    /**
+     * A back gesture over the top of this stack ([startBackGesture]): its progress, its cancel, and its release, which
+     * pops the top through the queue with the preview's end. A command accepted meanwhile, or the stack's destroy,
+     * ends the preview at once ([abort]).
+     */
+    internal inner class BackGesture(
+        private val views: StackViews,
+        private val top: ViewController<*>,
+        private val target: ViewController<*>,
+    ) {
+        lateinit var preview: BackPreview
+        // How the screen under the top was before the preview showed it: in the container and seen, its alpha and
+        // accessibility.
+        private var targetWasPlaced = false
+        private var targetAlpha = 1f
+        private var targetAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
+        private var revealed = false
+        private var aborted = false
+
+        /** The preview shows the screen under the top, with its bar and its FAB. */
+        val isRevealed: Boolean
+            get() = revealed && !aborted
+
+        /** The gesture moved: [progress] 0 … 1, the finger at [touchY]. */
+        fun progress(progress: Float, touchY: Float) {
+            if (!aborted) preview.progress(progress, touchY)
+        }
+
+        /** Cancelled: the preview springs back, then the screen under the top and the bar are as they were. */
+        fun cancel() {
+            if (!aborted) preview.cancel(::restore)
+        }
+
+        /**
+         * Released: the top pops, the preview playing its end; the default pop when its picture isn't there yet. False
+         * when the stack changed since the gesture started (a command ran, the stack went): back goes the usual way.
+         */
+        fun commit(): Boolean {
+            if (aborted || isDestroyed) return false
+            if (!preview.isReady) {
+                abort()
+                queue.cut(target, null, id, "go back in the stack '$id'", null)
+                return true
+            }
+            if (backGesture === this) backGesture = null
+            // The top's FAB, set aside, leaves with it; a merge into it no longer matters.
+            fab.dropAside()
+            fabMergeWaits = false
+            queue.cut(target, null, id, "go back in the stack '$id'", null, gesture = true)
+            return true
+        }
+
+        /** The stack changed or goes: the preview ends at once and the stack is as it was. */
+        fun abort() {
+            if (aborted) return
+            aborted = true
+            preview.endAtOnce()
+            restore()
+        }
+
+        // The preview's picture is there: the screen under the top shows under it, and the bar and the FAB show that
+        // screen, at once.
+        internal fun reveal() {
+            val view = target.peekView() ?: return
+            targetWasPlaced = view.parent === peekView() && view.visibility == View.VISIBLE
+            targetAlpha = view.alpha
+            targetAccessibility = view.importantForAccessibility
+            revealed = true
+            views.reveal(target, top)
+            view.alpha = 1f
+            topBar.apply(target)
+            fab.setAside()
+            showFab(FabMotion.Move.AtOnce, target)
+        }
+
+        private fun restore() {
+            views.previewEnded(preview)
+            if (backGesture === this) backGesture = null
+            if (!revealed || isDestroyed) return
+            revealed = false
+            if (target in queue.shown && target !== queue.currentChild) {
+                val view = target.peekView()
+                if (targetWasPlaced && view != null) {
+                    view.alpha = targetAlpha
+                    view.importantForAccessibility = targetAccessibility
+                } else {
+                    views.detach(target)
+                }
+            }
+            // The bar and the FAB show the top again, the bar's components appeared again.
+            val shown = queue.currentChild
+            topBar.apply(shown)
+            fab.bringBack()
+            if (fabMergeWaits) {
+                fabMergeWaits = false
+                mergeFab()
+            }
+            shown?.let {
+                topBar.screenWillAppear(optionsScreen(it))
+                topBar.screenDidAppear(optionsScreen(it))
+            }
+            BackCallbackState.update()
+        }
+    }
+
     /**
      * The back arrow of the bar was pressed: the screen the user sees holds it (`topBar.backButton.popStackOnPress:
      * false`: `ANN.NavigationButtonPressed` with `topBar.backButton.id` or `ApexNavigation.back`); on the first screen
@@ -322,7 +492,8 @@ class StackController(
         ContainerBackground.apply(this, options)
         updateBar()
         takeKeptMerge(child)?.let(::applyTopMerge)
-        if (queue.isAtRest) showFab()
+        // A back gesture's preview shows the FAB of the screen under the top.
+        if (queue.isAtRest && backGesture?.isRevealed != true) showFab()
         performOnParentController { it.applyChildOptions(withoutStackGroups(options), this) }
     }
 
@@ -338,7 +509,7 @@ class StackController(
 
     // `mergeOptions` with the stack's id: its own options, what it shows, then the layouts around.
     override fun mergeOptions(options: Options) {
-        this.options = this.options.copy().mergeWith(options)
+        mergeOwnOptions(options)
         applyOrKeep(options, null)
         performOnParentController { it.mergeChildOptions(withoutStackGroups(options), this) }
     }
@@ -454,14 +625,19 @@ 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)
 
     /**
      * The bar's bottom in the window while [child] is under it and it shows, from the stack's place in the window: for
-     * the screen on top where the bar is laid out (a move of the bar doesn't count); for another child (a prepared one)
-     * as its own options set the bar.
+     * the screen on top that the bar shows, where the bar is laid out (a move of the bar doesn't count); for another
+     * child (a prepared one) and for a top the bar hasn't shown yet (in a tab not selected yet, which measures though
+     * invisible) as its own options set the bar, so its content doesn't move as the bar takes them.
      */
     override fun headerBottomOf(child: ViewController<*>): Int? {
         if (!isUnderBar(child)) return super.headerBottomOf(child)
@@ -471,7 +647,7 @@ class StackController(
         val layout = peekView() ?: return null
         // The stack's place at rest, as the screen's own: a modal sliding in or a sheet dragged doesn't move it.
         val top = RestPlace.topInWindow(layout)
-        if (entry === queue.currentChild) return topBar.barBottomInStack()?.let { top + it }
+        if (entry === queue.currentChild && topBar.shows(entry)) return topBar.barBottomInStack()?.let { top + it }
         val bar = topBar.barOf(entry, options)
         val large = if (largeTitleShown(child)) UiUtils.dpToPx(activity, LargeTitleView.HEIGHT).toInt() else 0
         return top + bar.margin + bar.strip + bar.height + large
@@ -506,6 +682,7 @@ class StackController(
 
     override fun destroy() {
         if (isDestroyed) return
+        backGesture?.abort()
         queue.destroy()
         preparedPushes()?.discardFor(this)
         fab.destroy()
@@ -524,15 +701,20 @@ class StackController(
         topBar.apply(queue.currentChild)
     }
 
-    // The FAB follows the top at the end of a transition.
-    private fun showFab() {
+    // The FAB follows [top] (the current child) from the start of a transition by [move], with the screens; at rest, a
+    // FAB that comes by Material's swap.
+    private fun showFab(move: FabMotion.Move = FabMotion.Move.Swap, top: ViewController<*>? = queue.currentChild) {
         val layout = peekView() ?: return
-        val top = queue.currentChild
         val screen = top?.let(::optionsScreen)
-        fab.showFor(layout, screen, top?.let(::resolvedOf)?.fab ?: FabOptions(), scrollOf(screen))
+        fab.showFor(layout, screen, top?.let(::resolvedOf)?.fab ?: FabOptions(), scrollOf(screen), move)
     }
 
     private fun mergeFab() {
+        // A back gesture's preview shows the FAB of the screen under the top: the top's merge waits for a cancel.
+        if (backGesture?.isRevealed == true) {
+            fabMergeWaits = true
+            return
+        }
         val layout = peekView() ?: return
         val top = queue.currentChild ?: return
         val screen = optionsScreen(top)
@@ -551,16 +733,29 @@ 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, and how it shows or hides.
-        override fun barTransition(motion: StackDisplay.BarMotion?, visibility: StackDisplay.BarVisibility) {
-            if (peekView() != null) topBar.beginRowTransition(motion, queue.currentChild, visibility)
+        // Before the bar takes the new top's options: the row's picture or the bar's travel, and how it shows or hides.
+        override fun barTransition(
+            motion: StackDisplay.BarMotion?,
+            visibility: StackDisplay.BarVisibility,
+            travel: StackDisplay.BarTravel?,
+        ) {
+            if (peekView() != null) topBar.beginRowTransition(motion, queue.currentChild, visibility, travel)
         }
 
         // The tab bar of the tabs around goes with the transition; a takeover doesn't bring it to rest.
@@ -568,6 +763,9 @@ class StackController(
             parentController?.tabBarTransition(this@StackController, move, side)
         }
 
+        // The FAB of the new top arrives with its screen, the old one leaves with its own.
+        override fun fabTransition(move: FabMotion.Move) = showFab(move)
+
         override fun operationEnded(topSettled: Boolean) {
             BackCallbackState.update()
             if (topSettled) parentController?.tabBarSettled(this@StackController)
@@ -588,8 +786,8 @@ class StackController(
             if (peekView() != null) topBar.stage(node)
         }
 
-        override fun isOwnRootScreen(node: ViewController<*>): Boolean =
-            (node as? ComponentViewController)?.componentName?.startsWith(ScreenContentFactory.SLOT_PREFIX) == false
+        override fun hasReactContent(node: ViewController<*>): Boolean =
+            RenderWait.waitedScreens(node).any { it is ComponentViewController }
 
         override fun log(text: String) {
             Log.e(NavigationLog.TAG, text)

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

@@ -38,6 +38,12 @@ internal interface StackDisplay {
      */
     enum class BarMotion { Push, Pop, FadeThrough }
 
+    /**
+     * How the bar goes with a transition of the stack's own (`content`): with its screens. [Forward]: the screen that
+     * comes lies over the one that goes (a push, `setStackRoot`); [Back]: the one that goes lies over it (a pop).
+     */
+    enum class BarTravel { Forward, Back }
+
     /**
      * How the bar shows or hides when the new top's `topBar.visible` differs: at once (no animation, or a transition
      * with elements), or [animated] by the transition's [side] (`animations.push.topBar`, the leaving screen's
@@ -156,12 +162,31 @@ internal interface StackDisplay {
         done: () -> Unit,
     ): () -> Unit
 
+    /** The preview of a back gesture over [top], [target] under it, shows ([finishBackGesture] can end it). */
+    fun hasBackPreview(top: ViewController<*>, target: ViewController<*>): Boolean = false
+
+    /**
+     * The pop of a back gesture whose preview shows ([hasBackPreview]), released: the preview plays the end of [top]
+     * going and [target] coming. [topDone] and [targetDone] once each, as [animate]'s; [stop] of one screen ends the
+     * preview where it is and its other screen's part.
+     */
+    fun finishBackGesture(
+        top: ViewController<*>,
+        target: ViewController<*>,
+        topDone: () -> Unit,
+        targetDone: () -> Unit,
+    ) {
+        topDone()
+        targetDone()
+    }
+
     /** Stops the animator of [screen] where it is, without its end: a later transition takes the screen over. */
     fun stop(screen: ViewController<*>)
 
     /**
      * The push of a prepared slot screen: [mounted] as the slot's content mounts into the screen's container (or at the
-     * limit of 0.5 s), then [start] on the pre-draw of that frame, while [waiting] holds.
+     * limit of 0.5 s), then [start] on the pre-draw of that frame, while [waiting] holds; the queue starts the
+     * transition from there behind the calls JavaScript made before, on a later turn.
      */
     fun awaitPrepared(screen: ViewController<*>, waiting: () -> Boolean, mounted: () -> Unit, start: () -> Unit)
 }