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

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

@@ -9,13 +9,16 @@ import androidx.core.view.WindowInsetsCompat
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.LifecycleOwner
 import dev.apexnative.navigation.options.LayoutAnimation
+import dev.apexnative.navigation.utils.UiThread
 import dev.apexnative.navigation.utils.whenContentMounted
 import dev.apexnative.navigation.viewcontrollers.component.ComponentViewController
 import dev.apexnative.navigation.viewcontrollers.externalcomponent.ExternalComponentViewController
 import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.Motion
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.animations.AnimationLayer
 import dev.apexnative.navigation.views.animations.AnimationRules
 import dev.apexnative.navigation.views.animations.SideAnimator
+import dev.apexnative.navigation.views.animations.SystemTransition
 import dev.apexnative.navigation.views.element.ElementTransition
 import dev.apexnative.navigation.views.element.TargetsWait
 import dev.apexnative.navigation.views.stack.StackLayout
@@ -29,6 +32,11 @@ import dev.apexnative.navigation.views.stack.StackLayout
  */
 internal class StackViews(private val stack: StackController) : StackDisplay {
     private val animators = HashMap<ViewController<*>, Animator>()
+    // The preview of the back gesture that runs or ends now, and its two screens.
+    private var preview: BackPreview? = null
+    private var previewScreens: Pair<ViewController<*>, ViewController<*>>? = null
+    // The ends of the two screens of a released gesture whose preview plays its end.
+    private var committing: Pair<() -> Unit, () -> Unit>? = null
     // What goes back when a screen's animator ends or stops: the elements its transition carries.
     private val cleanups = HashMap<ViewController<*>, () -> Unit>()
 
@@ -110,11 +118,16 @@ internal class StackViews(private val stack: StackController) : StackDisplay {
     override fun animate(screen: ViewController<*>, motion: Motion, fromCurrent: Boolean, done: () -> Unit) {
         stop(screen)
         val view = screen.peekView() ?: return done()
-        val animator = StackTransitions.animator(view, motion, fromCurrent)
+        val layout = layout
+        val animator = StackTransitions.animator(view, motion, fromCurrent) { layout?.edgesMoved() }
+        cleanups[screen] = dress(view, motion, layout)
         animator.addListener(object : AnimatorListenerAdapter() {
             // Ended or cancelled by anything else than [stop]: the screen's part is done.
             override fun onAnimationEnd(animation: Animator) {
-                if (animators[screen] === animator) animators.remove(screen)
+                if (animators[screen] === animator) {
+                    animators.remove(screen)
+                    cleanups.remove(screen)?.invoke()
+                }
                 done()
             }
         })
@@ -122,14 +135,32 @@ internal class StackViews(private val stack: StackController) : StackDisplay {
         animator.start()
     }
 
-    // The elements go into a layer over the screens, and back as the screen's animator ends or stops. A shared element
-    // without a duration takes the screen's fade: its own single `alpha`, else 300 ms.
+    // For the default transition [view] moves as the system's windows do: its edge extended by the distance it moves,
+    // and its fade drawn through a hardware layer, so the whole screen isn't drawn again at every frame of it. What
+    // undoes both.
+    private fun dress(view: View, motion: Motion, layout: StackLayout?): () -> Unit {
+        StackTransitions.extendsStart(motion)?.let { start ->
+            layout?.extendEdge(view, start, (SystemTransition.DISTANCE_DP * view.resources.displayMetrics.density).toInt())
+        }
+        val layered = StackTransitions.fades(motion) && view.layerType == View.LAYER_TYPE_NONE
+        if (layered) view.setLayerType(View.LAYER_TYPE_HARDWARE, null)
+        return {
+            layout?.dropEdge(view)
+            if (layered && view.layerType == View.LAYER_TYPE_HARDWARE) view.setLayerType(View.LAYER_TYPE_NONE, null)
+        }
+    }
+
+    // The elements play in their screens and the pairs' copies fly in a layer over them, all done as the screen's
+    // animator ends or stops. A shared element without a duration takes the screen's fade: its own single `alpha`,
+    // else 300 ms.
     override fun animateCustom(screen: ViewController<*>, custom: StackDisplay.Custom, done: () -> Unit) {
         stop(screen)
         val view = screen.peekView() ?: return done()
         custom.alpha?.let { view.alpha = it }
         val own = custom.side?.let { SideAnimator.build(view, it, SideAnimator.Base(alpha = custom.alpha)) }
         val fade = if (own == null) StackTransitions.fade(view, custom.fade) else null
+        // A fade of the whole screen draws it through a hardware layer, as the default transition does ([dress]).
+        for (animator in listOfNotNull(own, fade)) AnimationLayer.during(view, animator)
         val elements = custom.elements?.let { elements ->
             val layout = layout ?: return@let null
             val fadeLength = custom.side?.takeIf(AnimationRules::isSingleAlpha)?.let(AnimationRules::lengthOf)
@@ -167,7 +198,85 @@ internal class StackViews(private val stack: StackController) : StackDisplay {
         done: () -> Unit,
     ): () -> Unit = TargetsWait.start(animation, from, to, waiting, done)
 
+    /**
+     * Starts the preview of a back gesture over [top], [target] under it (`BackPreview`): none without the stack's view
+     * or a window. [onReveal] shows [target] with its bar and its FAB as the preview's picture is there.
+     */
+    fun startBackPreview(
+        top: ViewController<*>,
+        target: ViewController<*>,
+        fromLeft: Boolean,
+        touchY: Float,
+        onReveal: () -> Unit,
+    ): BackPreview? {
+        val bottomRoom = top.getBottomInset()
+        endPreview()
+        val layout = layout ?: return null
+        val window = stack.activity.window ?: return null
+        val topView = top.peekView() ?: return null
+        val targetView = target.peekView() ?: return null
+        val started = BackPreview(layout, topView, targetView, fromLeft, touchY, bottomRoom, onReveal) {
+            stack.fab.shownView
+        }
+        preview = started
+        previewScreens = top to target
+        started.start(window)
+        return started
+    }
+
+    /** The preview of the back gesture went: cancelled and put back, or never shown. */
+    fun previewEnded(ended: BackPreview) {
+        if (preview !== ended) return
+        preview = null
+        previewScreens = null
+    }
+
+    override fun hasBackPreview(top: ViewController<*>, target: ViewController<*>): Boolean =
+        preview?.isReady == true && previewScreens == top to target
+
+    override fun finishBackGesture(
+        top: ViewController<*>,
+        target: ViewController<*>,
+        topDone: () -> Unit,
+        targetDone: () -> Unit,
+    ) {
+        val running = preview?.takeIf { hasBackPreview(top, target) } ?: run {
+            topDone()
+            targetDone()
+            return
+        }
+        committing = topDone to targetDone
+        running.commit {
+            committing = null
+            previewEnded(running)
+            topDone()
+            targetDone()
+        }
+    }
+
+    private fun endPreview() {
+        val ended = preview ?: return
+        preview = null
+        previewScreens = null
+        committing = null
+        ended.endAtOnce()
+    }
+
+    // A later transition takes one screen of a released gesture's preview: the preview ends where it is, the popped
+    // screen stays out of sight until the pop takes it away, and the other screen's part ends on the next turn.
+    private fun stopPreview(screen: ViewController<*>) {
+        val (top, target) = previewScreens ?: return
+        if (screen !== top && screen !== target) return
+        val dones = committing
+        endPreview()
+        if (dones == null) return
+        top.peekView()?.alpha = 0f
+        val other = if (screen === top) dones.second else dones.first
+        UiThread.post { other() }
+    }
+
     override fun stop(screen: ViewController<*>) {
+        stopPreview(screen)
         val animator = animators.remove(screen)
         if (animator != null) {
             animator.removeAllListeners()
@@ -185,8 +294,8 @@ internal class StackViews(private val stack: StackController) : StackDisplay {
         screen.whenContentMounted(
             waiting = waiting,
             mounted = {
-                // The frame of the mount: the screen shows transparent and lays out; its transition starts on the
-                // pre-draw of that frame.
+                // The frame of the mount: the screen shows transparent and lays out. The pre-draw of that frame hands
+                // the start to the queue, whose transition begins behind the calls JavaScript made before.
                 screen.peekView()?.let {
                     it.alpha = 0f
                     it.visibility = View.VISIBLE

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

@@ -0,0 +1,142 @@
+package dev.apexnative.navigation.viewcontrollers.stack.fab
+
+import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.BarMotion
+import dev.apexnative.navigation.views.animations.FadeThrough
+import dev.apexnative.navigation.views.animations.SystemTransition
+
+/**
+ * How a stack's FAB goes with a change of its screen on top, as the values alone: the new top's FAB arrives with its
+ * screen and a copy of the old one leaves with the screen it belonged to, from the start of the transition. A FAB with
+ * the same id stays where it is. The stack plays them on its views (`FabPresenter`).
+ */
+internal object FabMotion {
+    /** How the stack's transition goes, as its queue tells it (`StackQueue.Host.fabTransition`). */
+    enum class Move {
+        /** The system's push: each FAB rides with its screen along the line, as the tab bar does. */
+        WithPush,
+
+        /** The system's pop: the same, the other way. */
+        WithPop,
+
+        /** The fade through of a `setStackRoot`: the old one fades out first, the new one fades in and grows. */
+        FadeThrough,
+
+        /**
+         * A transition of the screens' own (`content`, elements): Material's swap at its start, the old one shrinking
+         * away, the new one growing from 60 %.
+         */
+        Swap,
+
+        /** No animation: the new top's FAB is there at once. */
+        AtOnce,
+    }
+
+    /** The curve a ride's move and scale take; its alpha changes on a straight line. */
+    enum class Curve { System, FadeThrough, Material }
+
+    /**
+     * A FAB's ride: along the x axis in dp, mirrored right to left; its scale on [curve] over [duration]; its alpha after
+     * a hold of [alphaDelay] over [alphaDuration], in ms.
+     */
+    data class Ride(
+        val fromX: Float,
+        val toX: Float,
+        val fromAlpha: Float,
+        val toAlpha: Float,
+        val fromScale: Float,
+        val toScale: Float,
+        val alphaDelay: Long,
+        val alphaDuration: Long,
+        val duration: Long,
+        val curve: Curve,
+    )
+
+    /** How long Material's swap takes, as the FAB shrinks or grows. */
+    const val SWAP_MILLIS = 200L
+
+    /** Where Material's swap grows the new FAB from. */
+    const val GROW_FROM = 0.6f
+
+    private const val FADE_THROUGH_SCALE = 0.92f
+
+    /**
+     * The move of the FAB with a change of the current child: none when the change comes at once or the new top shows
+     * already ([shown]: a back gesture's preview showed it); Material's swap with an animation of the screens' own
+     * ([own]); else the default transition's [row], as the bar's row goes.
+     */
+    fun moveOf(animated: Boolean, own: Boolean, row: BarMotion, shown: Boolean): Move = when {
+        !animated || shown -> Move.AtOnce
+        own -> Move.Swap
+        row == BarMotion.Push -> Move.WithPush
+        row == BarMotion.Pop -> Move.WithPop
+        else -> Move.FadeThrough
+    }
+
+    /**
+     * The new top's FAB comes with its screen: a push brings it from +96 dp (−96 dp on a pop), transparent for the hold
+     * of the screen's fade, then fading in; the fade through fades it in after the old one went and grows it from 92 %;
+     * the swap grows it from 60 %. None at once.
+     */
+    fun arrival(move: Move, rtl: Boolean): Ride? {
+        val distance = SystemTransition.DISTANCE_DP * if (rtl) -1 else 1
+        return when (move) {
+            Move.WithPush, Move.WithPop -> Ride(
+                fromX = if (move == Move.WithPush) distance else -distance,
+                toX = 0f,
+                fromAlpha = 0f,
+                toAlpha = 1f,
+                fromScale = 1f,
+                toScale = 1f,
+                alphaDelay = fadeDelay(move),
+                alphaDuration = SystemTransition.FADE_DURATION,
+                duration = SystemTransition.DURATION,
+                curve = Curve.System,
+            )
+            Move.FadeThrough -> Ride(
+                fromX = 0f,
+                toX = 0f,
+                fromAlpha = 0f,
+                toAlpha = 1f,
+                fromScale = FADE_THROUGH_SCALE,
+                toScale = 1f,
+                alphaDelay = fadeThroughOut(),
+                alphaDuration = FadeThrough.DURATION - fadeThroughOut(),
+                duration = FadeThrough.DURATION,
+                curve = Curve.FadeThrough,
+            )
+            Move.Swap -> Ride(0f, 0f, 1f, 1f, GROW_FROM, 1f, 0L, 0L, SWAP_MILLIS, Curve.Material)
+            Move.AtOnce -> null
+        }
+    }
+
+    /**
+     * The old top's FAB leaves with its screen, from where it is: a push takes it to −96 dp with the covered screen and
+     * fades it out as the new screen fades in over it; a pop takes it to +96 dp, fading with the leaving screen; the
+     * fade through fades it out in the first 35 %; the swap shrinks it to nothing. None at once.
+     */
+    fun departure(move: Move, rtl: Boolean): Ride? {
+        val distance = SystemTransition.DISTANCE_DP * if (rtl) -1 else 1
+        return when (move) {
+            Move.WithPush, Move.WithPop -> Ride(
+                fromX = 0f,
+                toX = if (move == Move.WithPush) -distance else distance,
+                fromAlpha = 1f,
+                toAlpha = 0f,
+                fromScale = 1f,
+                toScale = 1f,
+                alphaDelay = fadeDelay(move),
+                alphaDuration = SystemTransition.FADE_DURATION,
+                duration = SystemTransition.DURATION,
+                curve = Curve.System,
+            )
+            Move.FadeThrough -> Ride(0f, 0f, 1f, 0f, 1f, 1f, 0L, fadeThroughOut(), fadeThroughOut(), Curve.FadeThrough)
+            Move.Swap -> Ride(0f, 0f, 1f, 1f, 1f, 0f, 0L, 0L, SWAP_MILLIS, Curve.Material)
+            Move.AtOnce -> null
+        }
+    }
+
+    private fun fadeDelay(move: Move): Long =
+        if (move == Move.WithPush) SystemTransition.PUSH_FADE_DELAY else SystemTransition.POP_FADE_DELAY
+
+    private fun fadeThroughOut(): Long = (FadeThrough.DURATION * FadeThrough.OUT).toLong()
+}