@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

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

@@ -0,0 +1,82 @@
+package dev.apexnative.navigation.viewcontrollers.stack
+
+import android.animation.Animator
+import android.animation.AnimatorSet
+import android.animation.ObjectAnimator
+import android.view.View
+import android.view.animation.LinearInterpolator
+import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.Fade
+import dev.apexnative.navigation.viewcontrollers.stack.StackDisplay.Motion
+import dev.apexnative.navigation.views.animations.AnimationRules
+import dev.apexnative.navigation.views.animations.FadeThrough
+import dev.apexnative.navigation.views.animations.SystemTransition
+
+/**
+ * The animators of a stack's default transitions, one per screen, built as the transition starts: push and pop are the
+ * system's transition between activities (`SystemTransition`: 96 dp along the axis in 450 ms on
+ * `fast_out_extra_slow_in`, mirrored right to left), `setStackRoot` is Material's fade through (`FadeThrough`). What
+ * leaves starts from where it is; what comes in on a push is hidden explicitly until it fades in, as a delay doesn't
+ * apply an animator's first value. Main thread only.
+ */
+internal object StackTransitions {
+    /** The animator of [view] for [motion]; [fromCurrent] for a screen taken over from a transition still running. */
+    fun animator(view: View, motion: Motion, fromCurrent: Boolean): Animator {
+        val distance = SystemTransition.DISTANCE_DP * view.resources.displayMetrics.density
+        // Forward is to the end of the line: right to left, the screens move the other way. The stack's view inherits
+        // the app's direction, which `layout.direction` sets on the activity's content (`AppDirection`).
+        val forward = if (view.layoutDirection == View.LAYOUT_DIRECTION_RTL) -distance else distance
+        return when (motion) {
+            Motion.PushIn -> {
+                view.translationX = forward
+                view.alpha = 0f
+                together(
+                    slide(view, 0f),
+                    fade(view, 1f, SystemTransition.PUSH_FADE_DELAY),
+                )
+            }
+            Motion.PushCover -> slide(view, -forward)
+            Motion.PopOut -> together(
+                slide(view, forward),
+                fade(view, 0f, SystemTransition.POP_FADE_DELAY),
+            )
+            Motion.PopReveal -> {
+                if (!fromCurrent) view.translationX = -forward
+                if (view.alpha < 1f) together(slide(view, 0f), fade(view, 1f, 0L)) else slide(view, 0f)
+            }
+            Motion.FadeIn -> FadeThrough.enter(view)
+            Motion.FadeOut -> FadeThrough.exit(view)
+        }
+    }
+
+    /**
+     * The fade of a screen around elements: in from 0 to 1, out from where it is to 0, linearly in
+     * [AnimationRules.SCREEN_FADE]; none for [Fade.None].
+     */
+    fun fade(view: View, fade: Fade): Animator? {
+        val (from, to) = when (fade) {
+            Fade.None -> return null
+            Fade.In -> 0f to 1f
+            Fade.Out -> view.alpha to 0f
+        }
+        view.alpha = from
+        return ObjectAnimator.ofFloat(view, View.ALPHA, from, to).apply {
+            duration = AnimationRules.SCREEN_FADE
+            interpolator = LinearInterpolator()
+        }
+    }
+
+    private fun slide(view: View, to: Float): Animator =
+        ObjectAnimator.ofFloat(view, View.TRANSLATION_X, view.translationX, to).apply {
+            duration = SystemTransition.DURATION
+            interpolator = SystemTransition.CURVE
+        }
+
+    private fun fade(view: View, to: Float, delay: Long): Animator =
+        ObjectAnimator.ofFloat(view, View.ALPHA, view.alpha, to).apply {
+            startDelay = delay
+            duration = SystemTransition.FADE_DURATION
+            interpolator = LinearInterpolator()
+        }
+
+    private fun together(vararg animators: Animator): Animator = AnimatorSet().apply { playTogether(*animators) }
+}

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

@@ -0,0 +1,222 @@
+package dev.apexnative.navigation.viewcontrollers.stack
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
+import android.view.View
+import android.view.ViewGroup
+import androidx.core.view.WindowInsetsCompat
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import dev.apexnative.navigation.options.LayoutAnimation
+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.AnimationRules
+import dev.apexnative.navigation.views.animations.SideAnimator
+import dev.apexnative.navigation.views.element.ElementTransition
+import dev.apexnative.navigation.views.element.TargetsWait
+import dev.apexnative.navigation.views.stack.StackLayout
+
+/**
+ * What shows a stack ([StackDisplay]): the views of its screens in its [StackLayout] and their animators — the default
+ * transitions and the animations of their own with the transition's elements in a layer over the screens (one
+ * animator per screen, which owns them). A screen that waits lies under the current top, transparent and hidden from
+ * accessibility (the top keeps the touches); it moves under the bar as its transition starts, without leaving the
+ * container (no insets pass). Main thread only.
+ */
+internal class StackViews(private val stack: StackController) : StackDisplay {
+    private val animators = HashMap<ViewController<*>, Animator>()
+    // What goes back when a screen's animator ends or stops: the elements its transition carries.
+    private val cleanups = HashMap<ViewController<*>, () -> Unit>()
+
+    private val layout: StackLayout?
+        get() = stack.peekView()?.takeIf { !stack.isDestroyed }
+
+    override val hasView: Boolean
+        get() = layout != null
+
+    // A root under a full-screen modal is out of the window (the modal took its view out), so not shown; a stack in a
+    // modal or a root that waits to show is in a waiting layer.
+    override val isOnScreen: Boolean
+        get() = stack.isViewShown && !stack.isInWaitingLayer
+
+    override val canAnimate: Boolean
+        get() = isActivitySeen()
+
+    override fun isPlaced(screen: ViewController<*>): Boolean {
+        val view = screen.peekView() ?: return false
+        return layout?.holds(view) == true && view.visibility == View.VISIBLE
+    }
+
+    override fun placeWaiting(screen: ViewController<*>) {
+        val layout = layout ?: return
+        val view = screen.view
+        layout.giveInsets(view, insetsOf(screen))
+        layout.placeUnder(view, stack.currentChild?.peekView())
+        hide(view)
+    }
+
+    override fun placeLower(screen: ViewController<*>) {
+        val layout = layout ?: return
+        val view = screen.view
+        layout.giveInsets(view, insetsOf(screen))
+        layout.placeAtBottom(view)
+        hide(view)
+    }
+
+    override fun raise(screen: ViewController<*>) {
+        val layout = layout ?: return
+        val view = screen.view
+        layout.giveInsets(view, insetsOf(screen))
+        layout.placeUnderBar(view)
+        seen(view)
+    }
+
+    override fun reveal(screen: ViewController<*>, over: ViewController<*>) {
+        val layout = layout ?: return
+        val view = screen.view
+        layout.giveInsets(view, insetsOf(screen))
+        layout.placeUnder(view, over.peekView())
+        seen(view)
+    }
+
+    override fun hide(screen: ViewController<*>) {
+        screen.peekView()?.visibility = View.INVISIBLE
+    }
+
+    override fun detach(screen: ViewController<*>) {
+        stop(screen)
+        val view = screen.peekView() ?: return
+        SideAnimator.rest(view)
+        seen(view)
+        layout?.take(view)
+    }
+
+    override fun remove(screen: ViewController<*>) {
+        stop(screen)
+        val view = screen.peekView() ?: return
+        if (view.parent === layout) (view.parent as? ViewGroup)?.removeView(view)
+    }
+
+    override fun rest(screen: ViewController<*>) {
+        val view = screen.peekView() ?: return
+        SideAnimator.rest(view)
+        seen(view)
+    }
+
+    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)
+        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)
+                done()
+            }
+        })
+        animators[screen] = animator
+        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.
+    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
+        val elements = custom.elements?.let { elements ->
+            val layout = layout ?: return@let null
+            val fadeLength = custom.side?.takeIf(AnimationRules::isSingleAlpha)?.let(AnimationRules::lengthOf)
+            ElementTransition.startOrLog(
+                elements.animation, elements.from, elements.to, layout, null,
+                fadeLength ?: AnimationRules.SCREEN_FADE,
+            )
+        }
+        val parts = listOfNotNull(own, fade) + elements?.animators.orEmpty()
+        if (parts.isEmpty()) {
+            elements?.finish()
+            return done()
+        }
+        val set = AnimatorSet().apply { playTogether(parts) }
+        elements?.let { cleanups[screen] = it::finish }
+        set.addListener(object : AnimatorListenerAdapter() {
+            // Ended or cancelled by anything else than [stop]: the elements back, then the screen's part is done.
+            override fun onAnimationEnd(animation: Animator) {
+                if (animators[screen] === set) {
+                    animators.remove(screen)
+                    cleanups.remove(screen)?.invoke()
+                }
+                done()
+            }
+        })
+        animators[screen] = set
+        set.start()
+    }
+
+    override fun awaitTargets(
+        animation: LayoutAnimation,
+        from: ViewController<*>?,
+        to: ViewController<*>,
+        waiting: () -> Boolean,
+        done: () -> Unit,
+    ): () -> Unit = TargetsWait.start(animation, from, to, waiting, done)
+
+    override fun stop(screen: ViewController<*>) {
+        val animator = animators.remove(screen)
+        if (animator != null) {
+            animator.removeAllListeners()
+            animator.cancel()
+        }
+        cleanups.remove(screen)?.invoke()
+    }
+
+    override fun awaitPrepared(
+        screen: ViewController<*>,
+        waiting: () -> Boolean,
+        mounted: () -> Unit,
+        start: () -> Unit,
+    ) {
+        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.
+                screen.peekView()?.let {
+                    it.alpha = 0f
+                    it.visibility = View.VISIBLE
+                }
+                mounted()
+            },
+            start = start,
+        )
+    }
+
+    // A view that waits or renders under the others: transparent, without touches, unseen by accessibility.
+    private fun hide(view: View) {
+        view.alpha = 0f
+        view.visibility = View.VISIBLE
+        view.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+    }
+
+    private fun seen(view: View) {
+        view.visibility = View.VISIBLE
+        view.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_AUTO
+    }
+
+    // The window insets a screen got last.
+    private fun insetsOf(screen: ViewController<*>): WindowInsetsCompat? = when (screen) {
+        is ComponentViewController -> screen.frame.windowInsets
+        is ExternalComponentViewController -> screen.frame.windowInsets
+        else -> null
+    }
+
+    // The frames of an animation come only while the activity can be seen (the display on, the app in front).
+    private fun isActivitySeen(): Boolean =
+        (stack.activity as? LifecycleOwner)?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.STARTED) != false
+}

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

@@ -0,0 +1,47 @@
+package dev.apexnative.navigation.viewcontrollers.stack.fab
+
+import kotlin.math.max
+import kotlin.math.roundToInt
+
+/**
+ * Where the FAB of a stack sits: at the bottom, 16 dp from the edges, on the side of `fab.alignHorizontally` (`right`,
+ * the default, is the end of the line, `left` its start; mirrored right to left). From the bottom it clears what is
+ * higher: the tab bar at rest (its height with its bottom padding; a compact one also the navigation bar) or the
+ * navigation bar (the screen draws under it edge to edge, and an opaque one counts too) — plus 16 dp. At the sides it
+ * clears the side insets of the navigation bar (three buttons in landscape) and of the cutout. A menu keeps 16 dp for
+ * its shadows inside, so its margins are that much smaller and its main button sits where a FAB would. Pure arithmetic
+ * in pixels.
+ */
+internal object FabPlacement {
+    /** Insets at the four edges, in pixels. */
+    data class Edges(val left: Int = 0, val top: Int = 0, val right: Int = 0, val bottom: Int = 0)
+
+    /**
+     * The tab bar under the stack, at rest (a tab bar hidden by scroll or drawn behind still counts where it rests);
+     * none without one, or with `bottomTabs.visible: false`.
+     */
+    data class Tabs(val restingHeight: Int, val compact: Boolean)
+
+    /** The place: on the left edge or the right one, the margin from that edge and from the bottom, in pixels. */
+    data class Place(val onLeft: Boolean, val sideMargin: Int, val bottomMargin: Int)
+
+    /** The margin of the FAB from the edges and from what is under it, in dp. */
+    const val MARGIN_DP = 16f
+
+    fun place(
+        navigationBar: Edges,
+        cutout: Edges,
+        tabs: Tabs?,
+        density: Float,
+        rtl: Boolean,
+        alignStart: Boolean,
+        shadowInset: Int = 0,
+    ): Place {
+        val margin = (MARGIN_DP * density).roundToInt()
+        val onLeft = alignStart != rtl
+        val side = if (onLeft) max(navigationBar.left, cutout.left) else max(navigationBar.right, cutout.right)
+        val tabsHeight = tabs?.let { it.restingHeight + if (it.compact) navigationBar.bottom else 0 } ?: 0
+        val bottom = max(tabsHeight, navigationBar.bottom)
+        return Place(onLeft, margin + side - shadowInset, margin + bottom - shadowInset)
+    }
+}

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

@@ -0,0 +1,44 @@
+package dev.apexnative.navigation.viewcontrollers.stack.fab
+
+import dev.apexnative.navigation.options.FabOptions
+
+/**
+ * What becomes of a stack's FAB when the screen on top changes or its `fab` options merge: a FAB exists only while the
+ * options give `fab.id`; the same id updates the FAB that shows, another id replaces it, none takes it away. Non-empty
+ * `actions` make it a menu; an empty list in a merge takes the actions away, and it is a plain button again. Pure.
+ */
+internal object FabPlan {
+    enum class Step {
+        /** Nothing shows, and nothing is to show. */
+        None,
+
+        /** A FAB shows, and the options give none: it goes. */
+        Remove,
+
+        /** Nothing shows: a FAB is made and shows. */
+        Create,
+
+        /** The FAB that shows stays and takes the options again. */
+        Update,
+
+        /** The FAB that shows goes, and another is made: another id, or a menu that becomes a button or back. */
+        Replace,
+    }
+
+    /** The id the options give the FAB; none without one. */
+    fun idOf(options: FabOptions): String? = options.id.takeIf { it.hasValue() && !it.isNone }?.get()?.ifEmpty { null }
+
+    /** Whether the options make a menu: non-empty `actions`. */
+    fun isMenu(options: FabOptions): Boolean = !options.actions.isNullOrEmpty()
+
+    /** The step from the FAB that shows ([shownId], a menu or not) to the [options] resolved now. */
+    fun step(shownId: String?, shownIsMenu: Boolean, options: FabOptions): Step {
+        val id = idOf(options)
+        return when {
+            id == null -> if (shownId == null) Step.None else Step.Remove
+            shownId == null -> Step.Create
+            shownId != id || shownIsMenu != isMenu(options) -> Step.Replace
+            else -> Step.Update
+        }
+    }
+}

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

@@ -0,0 +1,279 @@
+package dev.apexnative.navigation.viewcontrollers.stack.fab
+
+import android.app.Activity
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.view.WindowInsetsCompat
+import dev.apexnative.navigation.options.FabOptions
+import dev.apexnative.navigation.react.events.AppearanceDispatcher
+import dev.apexnative.navigation.utils.TestIds
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListener
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.stack.StackLayout
+import dev.apexnative.navigation.views.stack.fab.Fab
+import dev.apexnative.navigation.views.stack.fab.FabMenu
+
+/**
+ * The FAB of one stack (`fab.*`), over the module's `Fab` and `FabMenu`: one FAB or one menu at a time, from the
+ * resolved `fab` of the screen on top (its options over the stack's, its parents' and the defaults). It follows the top
+ * at the end of each transition and the merges of `fab` into it; a press sends `ANN.NavigationButtonPressed` with the
+ * screen whose options showed it, an action with its own id. Its views are children of the stack's view, over the
+ * screens and the bar. Main thread only.
+ */
+internal class FabPresenter(
+    private val activity: Activity,
+    /** The tab bar at rest under the stack, by the options of its screen on top; none out of tabs. */
+    private val tabsAtRest: () -> FabPlacement.Tabs? = { null },
+) {
+    private var fab: Fab? = null
+    private var menu: FabMenu? = null
+    private var shownId: String? = null
+    private var layout: StackLayout? = null
+    // `fab.alignHorizontally: 'left'`: at the start of the line.
+    private var alignStart = false
+
+    /** The screen whose options show the FAB now; none. */
+    var source: ViewController<*>? = null
+        private set
+
+    private val view: View?
+        get() = menu ?: fab
+
+    /**
+     * The screen on top became [source], with its resolved [options]: the same id updates the FAB that shows and grows
+     * it again, another id replaces it, none takes it away; the scroll of [scroll] hides it with `hideOnScroll`.
+     * Nothing when [source] already shows it.
+     */
+    fun showFor(layout: StackLayout, source: ViewController<*>?, options: FabOptions, scroll: ScrollEventListener?) {
+        if (source === this.source && this.layout === layout) return
+        this.layout = layout
+        disableCollapse()
+        this.source = source
+        when (FabPlan.step(shownId, menu != null, options)) {
+            FabPlan.Step.None -> Unit
+            FabPlan.Step.Remove -> remove()
+            FabPlan.Step.Create -> create(layout, options, scroll)
+            FabPlan.Step.Replace -> {
+                remove()
+                create(layout, options, scroll)
+            }
+            FabPlan.Step.Update -> {
+                apply(options, scroll)
+                // A new top whose options don't hide it shows it, even where the screen before hid it.
+                if (!options.visible.isFalse) {
+                    fab?.show()
+                    menu?.show()
+                }
+                view?.let {
+                    it.bringToFront()
+                    grow(it)
+                }
+            }
+        }
+    }
+
+    /**
+     * `mergeOptions` of `fab` into the screen on top or into the stack: [options] are the top's resolved options now.
+     * The same id updates the FAB at once, another id replaces it, none takes it away.
+     */
+    fun merge(layout: StackLayout, source: ViewController<*>?, options: FabOptions, scroll: ScrollEventListener?) {
+        this.layout = layout
+        this.source = source
+        when (FabPlan.step(shownId, menu != null, options)) {
+            FabPlan.Step.None -> Unit
+            FabPlan.Step.Remove -> remove()
+            FabPlan.Step.Create -> create(layout, options, scroll)
+            FabPlan.Step.Replace -> {
+                remove()
+                create(layout, options, scroll)
+            }
+            FabPlan.Step.Update -> apply(options, scroll)
+        }
+    }
+
+    /**
+     * Light or dark changed: the colors of the options, of the new mode, go again over those the buttons read again
+     * from their style.
+     */
+    fun repaint(options: FabOptions) {
+        fab?.let { applyColors(it, options) }
+        menu?.let { menu ->
+            applyColors(menu.main, options)
+            options.actions.orEmpty().zip(menu.actions).forEach { (action, button) -> applyColors(button, action) }
+        }
+    }
+
+    /** The window insets or the stack's bottom room changed: the FAB takes its place again. */
+    fun place() {
+        val layout = layout ?: return
+        val view = view ?: return
+        val params = view.layoutParams as? CoordinatorLayout.LayoutParams ?: return
+        val insets = layout.lastInsets
+        val navigationBar = insets?.getInsets(WindowInsetsCompat.Type.navigationBars())
+        val cutout = insets?.getInsets(WindowInsetsCompat.Type.displayCutout())
+        val place = FabPlacement.place(
+            navigationBar = navigationBar?.let { FabPlacement.Edges(it.left, it.top, it.right, it.bottom) }
+                ?: FabPlacement.Edges(),
+            cutout = cutout?.let { FabPlacement.Edges(it.left, it.top, it.right, it.bottom) } ?: FabPlacement.Edges(),
+            tabs = tabsAtRest(),
+            density = activity.resources.displayMetrics.density,
+            rtl = layout.layoutDirection == View.LAYOUT_DIRECTION_RTL,
+            alignStart = alignStart,
+            shadowInset = menu?.shadowInset ?: 0,
+        )
+        params.gravity = Gravity.BOTTOM or if (place.onLeft) Gravity.LEFT else Gravity.RIGHT
+        params.leftMargin = if (place.onLeft) place.sideMargin else 0
+        params.rightMargin = if (place.onLeft) 0 else place.sideMargin
+        params.bottomMargin = place.bottomMargin
+        view.layoutParams = params
+    }
+
+    /** [node] was destroyed: a FAB it showed sends nothing more. */
+    fun forget(node: ViewController<*>) {
+        if (source === node) source = null
+    }
+
+    /** The stack goes: the FAB and its menu go at once, the scrim first. */
+    fun destroy() {
+        disableCollapse()
+        menu?.let {
+            it.removeScrim()
+            (it.parent as? ViewGroup)?.removeView(it)
+        }
+        fab?.let { (it.parent as? ViewGroup)?.removeView(it) }
+        menu = null
+        fab = null
+        shownId = null
+        source = null
+        layout = null
+    }
+
+    private fun create(layout: StackLayout, options: FabOptions, scroll: ScrollEventListener?) {
+        val id = FabPlan.idOf(options) ?: return
+        shownId = id
+        val params = CoordinatorLayout.LayoutParams(WRAP, WRAP)
+        if (FabPlan.isMenu(options)) {
+            val menu = FabMenu(activity, id)
+            this.menu = menu
+            layout.addOverAll(menu, params)
+        } else {
+            val fab = Fab(activity, id)
+            this.fab = fab
+            layout.addOverAll(fab, params)
+        }
+        apply(options, scroll)
+        view?.let(::grow)
+    }
+
+    // Every option of the FAB that shows; the collapse before the visibility, which `disableCollapse` would undo.
+    private fun apply(options: FabOptions, scroll: ScrollEventListener?) {
+        alignStart = options.alignHorizontally.get("right") == "left"
+        val source = source
+        fab?.let { fab ->
+            applyButton(fab, options)
+            TestIds.apply(fab, options.testID.takeIf { it.hasValue() }?.get())
+            val id = shownId.orEmpty()
+            fab.setOnClickListener { press(source, id) }
+        }
+        menu?.let { menu ->
+            applyButton(menu.main, options)
+            TestIds.apply(menu.main, options.testID.takeIf { it.hasValue() }?.get())
+            menu.scrimColor = options.scrimColor.get(activity, null)
+            menu.setActions(options.actions.orEmpty().map { action ->
+                val actionId = action.id.get("")
+                Fab(activity, actionId).also { button ->
+                    applyButton(button, action)
+                    TestIds.apply(button, action.testID.takeIf { it.hasValue() }?.get())
+                    button.setOnClickListener {
+                        press(source, actionId)
+                        menu.close()
+                    }
+                }
+            })
+        }
+        if (options.hideOnScroll.isTrue && scroll != null) enableCollapse(scroll) else disableCollapse()
+        val view = view
+        if (options.visible.isFalse) {
+            fab?.hide()
+            menu?.hide()
+        } else if (view != null && options.visible.isTrue) {
+            fab?.show()
+            menu?.show()
+        }
+        place()
+    }
+
+    private fun applyButton(button: Fab, options: FabOptions) {
+        val icon = options.icon.takeIf { it.hasValue() }?.get()?.ifEmpty { null }
+        if (icon != null) button.applyIcon(icon, options.iconColor)
+        applyColors(button, options)
+        button.setMini(options.size.get("regular") == "mini")
+    }
+
+    private fun applyColors(button: Fab, options: FabOptions) {
+        // iconColor alone, without a new icon, tints the icon there is.
+        options.iconColor.get(activity, null)?.let(button::setIconColor)
+        val background = options.backgroundColor.get(activity, null)
+        val pressed = options.clickColor.get(activity, null)
+        if (background != null || pressed != null) button.setColors(background, pressed)
+        // A container of the options without iconColor: the icon keeps its own colors.
+        if (background != null && !options.iconColor.hasValue()) button.keepIconColors()
+        options.rippleColor.get(activity, null)?.let(button::applyRippleColor)
+    }
+
+    private fun enableCollapse(scroll: ScrollEventListener) {
+        fab?.enableCollapse(scroll)
+        menu?.enableCollapse(scroll)
+    }
+
+    private fun disableCollapse() {
+        fab?.disableCollapse()
+        menu?.disableCollapse()
+    }
+
+    // The FAB that shows goes: a button shrinks to 0 in 200 ms; a menu goes at once, its scrim first.
+    private fun remove() {
+        menu?.let {
+            it.removeScrim()
+            (it.parent as? ViewGroup)?.removeView(it)
+        }
+        fab?.let { fab ->
+            fab.animate().cancel()
+            if (!fab.isAttachedToWindow) {
+                (fab.parent as? ViewGroup)?.removeView(fab)
+            } else {
+                fab.animate().scaleX(0f).scaleY(0f).setDuration(ANIMATION_MILLIS)
+                    .withEndAction { (fab.parent as? ViewGroup)?.removeView(fab) }.start()
+            }
+        }
+        menu = null
+        fab = null
+        shownId = null
+    }
+
+    // It comes to the top and grows from 60 % in 200 ms.
+    private fun grow(view: View) {
+        val target = (view as? FabMenu)?.main ?: view
+        target.animate().cancel()
+        target.scaleX = GROW_FROM
+        target.scaleY = GROW_FROM
+        target.animate().scaleX(1f).scaleY(1f).setDuration(ANIMATION_MILLIS).start()
+    }
+
+    companion object {
+        private const val WRAP = ViewGroup.LayoutParams.WRAP_CONTENT
+        private const val ANIMATION_MILLIS = 200L
+        private const val GROW_FROM = 0.6f
+
+        /**
+         * A press on the FAB, or on an action of its menu, of [source] (EVT-NavigationButtonPressed): nothing once
+         * [source] is destroyed — its FAB still fades for 200 ms.
+         */
+        fun press(source: ViewController<*>?, buttonId: String) {
+            if (source == null || source.isDestroyed) return
+            AppearanceDispatcher.navigationButtonPressed(source, buttonId)
+        }
+    }
+}