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

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
@@ -35,6 +37,7 @@ 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 +82,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,
         )
     }
 
@@ -257,6 +268,136 @@ 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 and pops with the default transition, 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 || 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 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 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
+            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 shows that screen.
+        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)
+        }
+
+        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 shows the top again, its components appeared again.
+            val shown = queue.currentChild
+            topBar.apply(shown)
+            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
@@ -338,7 +479,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) }
     }
@@ -460,8 +601,9 @@ class StackController(
 
     /**
      * 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 +613,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 +648,7 @@ class StackController(
 
     override fun destroy() {
         if (isDestroyed) return
+        backGesture?.abort()
         queue.destroy()
         preparedPushes()?.discardFor(this)
         fab.destroy()
@@ -552,15 +695,23 @@ class StackController(
         (node as? OptionsScreen)?.optionsScreen ?: node
 
     private inner class QueueHost : StackQueue.Host {
+        override fun operationAccepted() {
+            backGesture?.abort()
+        }
+
         // The bar takes the options of the new top at once, also without appearance events.
         override fun currentChildChanged() {
             updateBar()
             navigator?.shownScreensChanged(this@StackController)
         }
 
-        // 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.
@@ -588,8 +739,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)
 }