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

package/android/src/main/java/dev/apexnative/navigation/utils/ImageRequests.kt

@@ -0,0 +1,76 @@
+package dev.apexnative.navigation.utils
+
+import android.graphics.drawable.Drawable
+
+/** Where the images of the options come from, for one context: [OptionImages.source], or a fake in the tests. */
+internal interface ImageSource {
+    /** The key of [uri] in the context's configuration now; for a `file:` uri it reads the file's version. */
+    fun key(uri: String): ImageKey
+
+    /** A copy of the image of [key] when the cache has it, none otherwise; never loads. */
+    fun cached(key: ImageKey): Drawable?
+
+    /** A copy of the image of [key], from the cache or loaded on the caller's thread; none on a failure. */
+    fun now(key: ImageKey): Drawable?
+
+    /** Whether [uri] can load off the main thread: a file or a drawable of the app. */
+    fun loadsLater(uri: String): Boolean
+
+    /** Loads [key] off the main thread and gives a copy of it, or none on a failure, to [done] on the main thread. */
+    fun later(key: ImageKey, done: (Drawable?) -> Unit)
+}
+
+/**
+ * The images that the places of a view asked for (an item's icon, a button's icon), by place [P]: what the cache has
+ * comes at once; what it doesn't, when the place can show it later, loads off the main thread and comes when ready;
+ * everything else loads at once. The last request of a place wins: a load that arrives after the place asked again,
+ * or after [forget] or [clear], is dropped. A load that fails gives the place no image, as an option without one:
+ * the image it showed before doesn't stay. A request builds the key of its image once (a file's version is read once).
+ * Main thread only.
+ */
+internal class ImageRequests<P : Any>(private val source: ImageSource) {
+    // The open load of each place: its number, which a later request of the place replaces.
+    private val waiting = HashMap<P, Long>()
+    private var last = 0L
+
+    /** The key of [uri] now, for a caller that compares it before it asks ([request] with the key). */
+    fun key(uri: String): ImageKey = source.key(uri)
+
+    /** [request] for the image of [uri], its key built here. */
+    fun request(place: P, uri: String, mayWait: Boolean, show: (Drawable?) -> Unit) =
+        request(place, source.key(uri), mayWait, show)
+
+    /**
+     * Gives [show] the image of [key] for [place]: now when the cache has it, or when the place can't wait for it
+     * ([mayWait] false: the first frame needs it) or the uri can't load off the main thread (Metro's address, a content
+     * uri); otherwise later, unless [place] asks again first. Null when it doesn't load: the place shows none.
+     */
+    fun request(place: P, key: ImageKey, mayWait: Boolean, show: (Drawable?) -> Unit) {
+        waiting.remove(place)
+        source.cached(key)?.let {
+            show(it)
+            return
+        }
+        if (!mayWait || !source.loadsLater(key.uri)) {
+            show(source.now(key))
+            return
+        }
+        val number = ++last
+        waiting[place] = number
+        source.later(key) { image ->
+            if (waiting[place] != number) return@later
+            waiting.remove(place)
+            show(image)
+        }
+    }
+
+    /** The place shows no image of the options now: a load it asked for earlier is dropped. */
+    fun forget(place: P) {
+        waiting.remove(place)
+    }
+
+    /** The view goes: every open load is dropped. */
+    fun clear() {
+        waiting.clear()
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/utils/OptionImages.kt

@@ -0,0 +1,262 @@
+package dev.apexnative.navigation.utils
+
+import android.content.ComponentCallbacks2
+import android.content.Context
+import android.content.res.Configuration
+import android.content.res.Resources
+import android.graphics.BitmapFactory
+import android.graphics.drawable.BitmapDrawable
+import android.graphics.drawable.Drawable
+import android.net.Uri
+import android.os.StrictMode
+import android.util.LruCache
+import androidx.core.content.ContextCompat
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
+import java.io.FileInputStream
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.io.InputStream
+import java.net.URL
+import java.util.Collections
+import java.util.concurrent.ExecutorService
+import java.util.concurrent.Executors
+
+/**
+ * The images and icons of the options, every one of them (bar buttons and their menus, the back button, search
+ * suggestions, tab icons, the FAB): one cache for the app, by [ImageKey], sized by the bytes of its images and let go
+ * when the system is low on memory with the app in the background ([clearsOnTrim]), not each time the app's UI hides;
+ * each caller gets its own mutable copy. The images don't depend on the JavaScript, so a reload keeps them.
+ *
+ * A `file:` address is a file; anything else first a drawable of the app by name (as React Native's images by resource
+ * name: release builds' assets, `{ android }` icons). Those two load on the caller's thread ([load]) or on a
+ * background thread of their own ([loadLater]). Not found while the app is in development: the address is read as a
+ * stream on the main thread, Metro's asset over the network (network on the main thread allowed for that read only)
+ * or through the content resolver. A remote address that is not Metro's asset is never loaded. A failure (a missing
+ * file or drawable, data that doesn't decode, an image too large for the memory) never ends the app: no image, and one
+ * warning per address in the log (and LogBox in development).
+ *
+ * A theme attribute inside a drawable of the app is resolved against the theme of the context that loaded it first.
+ * Main thread, unless a member says otherwise.
+ */
+internal object OptionImages {
+    private val cache = object : LruCache<ImageKey, Entry>(maxBytes()) {
+        override fun sizeOf(key: ImageKey, value: Entry) = value.bytes
+    }
+
+    // The addresses already named in a warning: one each.
+    private val warned: MutableSet<String> = Collections.synchronizedSet(HashSet())
+
+    // The loads off the main thread under way, with who waits for each.
+    private val loading = HashMap<ImageKey, MutableList<Waiter>>()
+
+    private val background: ExecutorService by lazy {
+        Executors.newSingleThreadExecutor { task -> Thread(task, THREAD_NAME).apply { isDaemon = true } }
+    }
+
+    @Volatile
+    private var listening = false
+
+    /** The cache and the loads for [context]: the source of an [ImageRequests]. */
+    fun source(context: Context): ImageSource = object : ImageSource {
+        override fun key(uri: String) = ImageKey.of(context, uri)
+
+        override fun cached(key: ImageKey) = cached(context, key)
+
+        override fun now(key: ImageKey) = load(context, key)
+
+        override fun loadsLater(uri: String) = loadsLater(context, uri)
+
+        override fun later(key: ImageKey, done: (Drawable?) -> Unit) = loadLater(context, key, done)
+    }
+
+    /** A copy of the image of [key] when the cache has it. Any thread. */
+    fun cached(context: Context, key: ImageKey): Drawable? = cache.get(key)?.copy(context)
+
+    /** A copy of the image of [uri], from the cache or loaded on the caller's thread; none on a failure. */
+    fun load(context: Context, uri: String): Drawable? = load(context, ImageKey.of(context, uri))
+
+    /**
+     * A copy of the image of [key] (built in the configuration of [context]), from the cache or loaded on the caller's
+     * thread; none on a failure.
+     */
+    fun load(context: Context, key: ImageKey): Drawable? {
+        listen(context)
+        cache.get(key)?.let { return it.copy(context) }
+        val loaded = decodeOrWarn(context, key.uri) ?: return null
+        return keep(key, loaded)?.copy(context) ?: loaded
+    }
+
+    /** Whether [uri] loads off the main thread: a file, or a drawable the app has by that name. Any thread. */
+    fun loadsLater(context: Context, uri: String): Boolean =
+        uri.startsWith(FILE_SCHEME) || ResourceDrawableIdHelper.getResourceDrawableId(context, uri) > 0
+
+    /**
+     * Loads [key] (built in the configuration of [context]) on the background thread and gives [done] a copy of it, or
+     * none on a failure, on the main thread; one load for all who ask for the same image meanwhile. Only for what
+     * [loadsLater].
+     */
+    fun loadLater(context: Context, key: ImageKey, done: (Drawable?) -> Unit) {
+        listen(context)
+        val waiters = loading[key]
+        if (waiters != null) {
+            waiters.add(Waiter(context, done))
+            return
+        }
+        loading[key] = mutableListOf(Waiter(context, done))
+        background.execute {
+            val loaded = decodeOrWarn(context, key.uri)
+            val entry = loaded?.let { keep(key, it) }
+            UiThread.post { deliver(key, loaded, entry) }
+        }
+    }
+
+    /** Lets every image of the cache go. Any thread. */
+    fun clear() {
+        cache.evictAll()
+    }
+
+    /**
+     * Whether the cache lets its images go at a trim of [level]: when the system is low on memory with the app in the
+     * background (`TRIM_MEMORY_BACKGROUND` and above), not at `TRIM_MEMORY_UI_HIDDEN`, which comes each time the app
+     * goes to the background: its icons are there when it comes back.
+     */
+    fun clearsOnTrim(level: Int): Boolean = level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND
+
+    // Each waiter gets a copy of its own; an image the cache can't keep (no constant state) goes to the first only,
+    // the others load it again.
+    private fun deliver(key: ImageKey, loaded: Drawable?, entry: Entry?) {
+        val waiters = loading.remove(key) ?: return
+        waiters.forEachIndexed { index, waiter ->
+            val image = when {
+                loaded == null -> null
+                entry != null -> entry.copy(waiter.context)
+                index == 0 -> loaded
+                else -> load(waiter.context, key)
+            }
+            waiter.done(image)
+        }
+    }
+
+    // Into the cache, when the image can be copied; the entry it keeps. Any thread.
+    private fun keep(key: ImageKey, image: Drawable): Entry? {
+        val state = image.constantState ?: return null
+        return Entry(state, bytesOf(image)).also { cache.put(key, it) }
+    }
+
+    private fun bytesOf(image: Drawable): Int {
+        if (image is BitmapDrawable) image.bitmap?.let { return it.allocationByteCount }
+        // A drawable that draws itself (a vector) keeps a picture of its own size when it is drawn.
+        return image.intrinsicWidth.coerceAtLeast(1) * image.intrinsicHeight.coerceAtLeast(1) * BYTES_PER_PIXEL
+    }
+
+    // The image of [uri], or none and one warning per address. Any thread.
+    private fun decodeOrWarn(context: Context, uri: String): Drawable? = try {
+        decode(context, uri)
+    } catch (e: Exception) {
+        warnOnce(uri, (e as? LoadFailure)?.why ?: ": ${e.message ?: e.javaClass.simpleName}")
+        null
+    } catch (e: OutOfMemoryError) {
+        warnOnce(uri, ": it is too large to decode")
+        null
+    }
+
+    private fun warnOnce(uri: String, why: String) {
+        if (warned.add(uri)) DevelopmentLog.warn("Could not load image $uri$why")
+    }
+
+    private fun decode(context: Context, uri: String): Drawable {
+        if (uri.startsWith(FILE_SCHEME)) return decodeStream(context) { FileInputStream(Uri.parse(uri).path) }
+        resourceDrawable(context, uri)?.let { return it }
+        if (!DevelopmentLog.isDevelopment) throw LoadFailure("")
+        val address = Uri.parse(uri)
+        return when (address.scheme) {
+            "http", "https" -> {
+                if (!isMetroAsset(address)) throw LoadFailure(": remote images are not supported in options")
+                withNetworkOnMainThread { decodeStream(context) { URL(uri).openStream() } }
+            }
+            else -> decodeStream(context) {
+                context.contentResolver.openInputStream(address) ?: throw FileNotFoundException(uri)
+            }
+        }
+    }
+
+    // A drawable of the app by name; none when the app has none by that name.
+    private fun resourceDrawable(context: Context, name: String): Drawable? {
+        val id = ResourceDrawableIdHelper.getResourceDrawableId(context, name)
+        if (id <= 0) return null
+        return try {
+            ContextCompat.getDrawable(context, id)
+        } catch (e: Resources.NotFoundException) {
+            null
+        }
+    }
+
+    // The image of the stream [open] gives, closed after the read, also on an error; one it can't decode fails, and so
+    // does one too large for the memory.
+    private fun decodeStream(context: Context, open: () -> InputStream): Drawable {
+        val decoded = try {
+            open().use { BitmapFactory.decodeStream(it) }
+        } catch (e: OutOfMemoryError) {
+            throw LoadFailure(": it is too large to decode")
+        }
+        val bitmap = decoded ?: throw LoadFailure(": it can't be decoded")
+        return BitmapDrawable(context.resources, bitmap)
+    }
+
+    // Metro's asset: an address of the server the JavaScript bundle came from, under `/assets/`.
+    private fun isMetroAsset(address: Uri): Boolean {
+        val bundle = DevelopmentLog.bundleUrl?.let(Uri::parse) ?: return false
+        return address.host == bundle.host && address.port == bundle.port &&
+            address.path.orEmpty().startsWith(ASSETS_PATH)
+    }
+
+    // Reading from the network on the main thread for [read] only; the thread's policy comes back, also on an error.
+    private fun <T> withNetworkOnMainThread(read: () -> T): T {
+        val policy = StrictMode.getThreadPolicy()
+        StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.Builder(policy).permitNetwork().build())
+        try {
+            return read()
+        } finally {
+            StrictMode.setThreadPolicy(policy)
+        }
+    }
+
+    // The cache lets its images go when the system is low on memory ([clearsOnTrim]): they load again when asked.
+    private fun listen(context: Context) {
+        if (listening) return
+        synchronized(this) {
+            if (listening) return
+            listening = true
+        }
+        context.applicationContext.registerComponentCallbacks(object : ComponentCallbacks2 {
+            override fun onTrimMemory(level: Int) {
+                if (clearsOnTrim(level)) clear()
+            }
+
+            override fun onConfigurationChanged(newConfig: Configuration) = Unit
+
+            @Deprecated("Android 14 deprecates it; onTrimMemory comes with it")
+            override fun onLowMemory() = clear()
+        })
+    }
+
+    // A sixteenth of the app's heap, at most 16 MB: the options' icons are small.
+    private fun maxBytes(): Int = (Runtime.getRuntime().maxMemory() / HEAP_PART).coerceAtMost(MAX_BYTES).toInt()
+
+    // An image the cache keeps: what makes its copies, and its size.
+    private class Entry(val state: Drawable.ConstantState, val bytes: Int) {
+        fun copy(context: Context): Drawable = state.newDrawable(context.resources).mutate()
+    }
+
+    private class Waiter(val context: Context, val done: (Drawable?) -> Unit)
+
+    // A failure the loader names itself: `Could not load image <source>`, then [why].
+    private class LoadFailure(val why: String) : IOException("Could not load image$why")
+
+    private const val FILE_SCHEME = "file:"
+    private const val ASSETS_PATH = "/assets/"
+    private const val THREAD_NAME = "ApexNavigation images"
+    private const val BYTES_PER_PIXEL = 4
+    private const val HEAP_PART = 16L
+    private const val MAX_BYTES = 16L * 1024 * 1024
+}

package/android/src/main/java/dev/apexnative/navigation/utils/ViewController.kt

@@ -59,7 +59,9 @@ private fun ViewController<*>.hostIsShown(): Boolean {
  * Runs [mounted] as the content of this screen's slot mounts into its container, and [start] on the pre-draw of that
  * frame: after React Native applied the whole mount, before the frame is drawn. At once if the content has mounted,
  * after [DRAW_WAIT_LIMIT] if it never does; while [waiting] holds. A screen prepared for its push was rendered at its
- * size and insets before: in that frame it is whole.
+ * size and insets before, so it is whole from that frame on; its push doesn't start in that frame: [start] hands it to
+ * the stack's queue, which starts the transition on a later turn, behind the calls JavaScript made before
+ * (`PendingCalls`), so the `mergeOptions` of the mount's commit has applied.
  */
 fun ViewController<*>.whenContentMounted(waiting: () -> Boolean, mounted: () -> Unit, start: () -> Unit) {
     var done = false

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/arrangement/SecondaryScreenPresenter.kt

@@ -2,24 +2,25 @@ package dev.apexnative.navigation.viewcontrollers.arrangement
 
 import android.app.Activity
 import dev.apexnative.navigation.options.Options
+import dev.apexnative.navigation.viewcontrollers.component.ComponentPresenter
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
 
 /**
  * The presenter of the secondary screen of a pair ([ArrangementController]). The status bar, the navigation bar and
- * the orientation are the primary's, as the top bar is: the secondary applies only its background, and brought to the
- * front it gives them back to the primary.
+ * the orientation are the primary's, as the top bar is: the secondary applies only its background (the theme's
+ * without `layout.backgroundColor`, as any React screen), and brought to the front it gives them back to the primary.
  */
 internal class SecondaryScreenPresenter(activity: Activity, defaultOptions: Options) :
     Presenter(activity, defaultOptions) {
 
     override fun applyOptions(view: ViewController<*>, options: Options) =
-        applyBackgroundColor(view, options.copy().withDefaultOptions(defaultOptions))
+        applyBackground(view, options.copy().withDefaultOptions(defaultOptions))
 
     override fun mergeOptions(viewController: ViewController<*>, options: Options) {
         if (!options.layout.backgroundColor.hasValue()) return
         val merged = viewController.resolveCurrentOptions().copy().mergeWith(options)
-        applyBackgroundColor(viewController, merged.withDefaultOptions(defaultOptions))
+        applyBackground(viewController, merged.withDefaultOptions(defaultOptions))
     }
 
     override fun onViewBroughtToFront(viewController: ViewController<*>, options: Options) {
@@ -27,5 +28,12 @@ internal class SecondaryScreenPresenter(activity: Activity, defaultOptions: Opti
     }
 
     override fun onConfigurationChanged(controller: ViewController<*>, options: Options) =
-        applyBackgroundColor(controller, options.copy().withDefaultOptions(defaultOptions))
+        applyBackground(controller, options.copy().withDefaultOptions(defaultOptions))
+
+    // `layout.backgroundColor`, else the theme's background (`ComponentPresenter.themeBackgroundOf`).
+    private fun applyBackground(view: ViewController<*>, options: Options) {
+        if (options.layout.backgroundColor.hasValue()) return applyBackgroundColor(view, options)
+        val color = ComponentPresenter.themeBackgroundOf(activity) ?: return
+        view.peekView()?.setBackgroundColor(color)
+    }
 }

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/AppliedTabCalls.kt

@@ -0,0 +1,49 @@
+package dev.apexnative.navigation.viewcontrollers.bottomtabs
+
+import dev.apexnative.navigation.utils.ImageKey
+
+/**
+ * The last call of each kind for each item of the bar, by which [BottomTabsPresenter.run] skips a call equal to it: an
+ * icon isn't loaded and set again as a screen appears. The badge and the font always go (their defaults are read at
+ * each set). An icon whose load gave no image goes again ([failed]); a `file:` icon compares by its [ImageKey] (the
+ * file's modification time and size, read by [fileKey]), so a file written again at the same path shows. Main thread.
+ */
+internal class AppliedTabCalls(private val fileKey: (String) -> ImageKey) {
+    /** A call that runs: [isChange], the item had a call of its kind before; [image], the key of a `file:` icon. */
+    class Next(val isChange: Boolean, val image: ImageKey?)
+
+    private class Applied(val call: TabItems.Call, val image: ImageKey?, var failed: Boolean = false)
+
+    private val last = HashMap<Pair<Int, Class<*>>, Applied>()
+
+    /** How [call] runs, and it is the last of its kind for its item from now on; none when it is skipped. */
+    fun next(call: TabItems.Call): Next? {
+        val key = call.index to call.javaClass
+        val before = last[key]
+        val image = uriOf(call)?.takeIf { it.startsWith(FILE_SCHEME) }?.let(fileKey)
+        val always = call is TabItems.Call.Badge || call is TabItems.Call.Font
+        if (!always && before != null && before.call == call && !before.failed && before.image == image) return null
+        last[key] = Applied(call, image)
+        return Next(isChange = before != null, image = image)
+    }
+
+    /** The icon of [call] didn't load: the same call goes again. */
+    fun failed(call: TabItems.Call) {
+        last[call.index to call.javaClass]?.takeIf { it.call == call }?.failed = true
+    }
+
+    /** The bar goes: every call goes again. */
+    fun clear() {
+        last.clear()
+    }
+
+    private fun uriOf(call: TabItems.Call): String? = when (call) {
+        is TabItems.Call.Icon -> call.uri
+        is TabItems.Call.SelectedIcon -> call.uri
+        else -> null
+    }
+
+    private companion object {
+        const val FILE_SCHEME = "file:"
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/viewcontrollers/bottomtabs/BottomTabsController.kt

@@ -1,5 +1,8 @@
 package dev.apexnative.navigation.viewcontrollers.bottomtabs
 
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.AnimatorSet
 import android.app.Activity
 import android.graphics.Color
 import android.util.Log
@@ -33,6 +36,7 @@ import dev.apexnative.navigation.viewcontrollers.stack.fab.FabPlacement
 import dev.apexnative.navigation.viewcontrollers.stack.topbar.BarComponents
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.Presenter
 import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+import dev.apexnative.navigation.views.animations.FadeThrough
 import dev.apexnative.navigation.views.bottomtabs.BottomTabItem
 import dev.apexnative.navigation.views.bottomtabs.BottomTabsLayout
 import dev.apexnative.navigation.views.bottomtabs.CustomBottomTabItemView
@@ -68,6 +72,12 @@ class BottomTabsController(
     private var cells: List<CustomBottomTabItemView> = emptyList()
     // `ANN.BottomTabSelected` of a press that waits for the new tab's screen to appear.
     private var pendingSelected: (() -> Unit)? = null
+    // Ends the fade through of a switch still running, with its events.
+    private var endSwitch: (() -> Unit)? = null
+
+    // The made tabs that didn't show at the last repaint (new default options, a light/dark switch): each is repainted
+    // as it is selected, not while hidden.
+    private val staleTabs = mutableSetOf<ViewController<*>>()
     // The bar goes with a stack's transition: the options of the new top don't move it themselves.
     private var riding = false
     private var restAttached = false
@@ -150,8 +160,11 @@ class BottomTabsController(
         /** The view of [tab] joins, or is there already: [visible], or invisible but laid out. */
         fun attach(tab: ViewController<*>, visible: Boolean)
 
-        /** The view of [shown] becomes visible and that of [hidden] invisible: the switch, at once. */
-        fun switch(shown: ViewController<*>, hidden: ViewController<*>)
+        /**
+         * The view of [shown] becomes visible and that of [hidden] invisible: at once, or with Material's fade through
+         * when [animated]; then [onEnd]. The function returned ends a switch still running at once, [onEnd] included.
+         */
+        fun switch(shown: ViewController<*>, hidden: ViewController<*>, animated: Boolean, onEnd: () -> Unit): () -> Unit
     }
 
     /** The views of the tabs; none before the tabs' view is made. */
@@ -166,9 +179,43 @@ class BottomTabsController(
             tab.view.visibility = if (visible) View.VISIBLE else View.INVISIBLE
         }
 
-        override fun switch(shown: ViewController<*>, hidden: ViewController<*>) {
-            shown.view.visibility = View.VISIBLE
-            hidden.peekView()?.visibility = View.INVISIBLE
+        override fun switch(
+            shown: ViewController<*>,
+            hidden: ViewController<*>,
+            animated: Boolean,
+            onEnd: () -> Unit,
+        ): () -> Unit {
+            val coming = shown.view
+            coming.visibility = View.VISIBLE
+            val going = hidden.peekView()
+            if (!animated || going == null) {
+                going?.visibility = View.INVISIBLE
+                onEnd()
+                return {}
+            }
+            val exit = FadeThrough.exit(going)
+            // Faded out, the tab that goes takes no more touches and no accessibility focus.
+            exit.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    going.visibility = View.INVISIBLE
+                }
+            })
+            val set = AnimatorSet()
+            set.playTogether(exit, FadeThrough.enter(coming))
+            set.addListener(object : AnimatorListenerAdapter() {
+                override fun onAnimationEnd(animation: Animator) {
+                    set.removeAllListeners()
+                    // The tab that went keeps its look for its next selection; only its visibility hides it.
+                    going.visibility = View.INVISIBLE
+                    going.alpha = 1f
+                    coming.alpha = 1f
+                    coming.scaleX = 1f
+                    coming.scaleY = 1f
+                    onEnd()
+                }
+            })
+            set.start()
+            return set::end
         }
     }
 
@@ -204,7 +251,7 @@ class BottomTabsController(
     // `mergeOptions` with the tabs' id: their own options, then what they show, then the layouts around without
     // `bottomTabs`; the one-shot options act once, also while the view isn't shown.
     override fun mergeOptions(options: Options) {
-        this.options = this.options.copy().mergeWith(options)
+        mergeOwnOptions(options)
         applyMerge(options, null)
         performOnParentController { it.mergeChildOptions(withoutBottomTabs(options), this) }
     }
@@ -268,8 +315,10 @@ class BottomTabsController(
     private enum class How { Press, Code, Back }
 
     /**
-     * A tap on the tab at [index], on the bar or on its cell of the custom row: its `ANN.BottomTabPressed` first, then
-     * the selection, the repeat, or nothing, as its resolved options say.
+     * A tap on the tab at [index], on the bar or on its cell of the custom row, the one path of both: a switch still
+     * running ends first, with its `ANN.BottomTabSelected`; then this press's `ANN.BottomTabPressed`, then the
+     * selection (`ANN.BottomTabSelected` after the new screen's DidAppear), the repeat (the pop's own events), or
+     * nothing, as its resolved options say. The same order as `-[ANNBottomTabsController pressTabAtIndex:source:]`.
      */
     internal fun onTabPressed(index: Int) {
         if (isDestroyed || index !in tabs.indices) return
@@ -302,10 +351,9 @@ class BottomTabsController(
     }
 
     /**
-     * Selects the tab at [index]: what it shows appears, the tab it left disappears — at once, one container invisible
-     * and the other visible —, then for a press `ANN.BottomTabSelected` right after the new screen's DidAppear and the
-     * left tab's `popToRootOnBlur`, with the state as one update after them; from code and by back, `popToRootOnBlur`
-     * and the state at once. The history of back follows.
+     * Selects the tab at [index]: the bar shows it at once; on screen the tab it left fades through to it (Material's
+     * fade through), off screen one container becomes invisible and the other visible at once; then [switched]. The
+     * history of back follows.
      */
     private fun select(index: Int, how: How) {
         if (index == selectedIndex || index !in tabs.indices || isDestroyed) return
@@ -321,6 +369,9 @@ class BottomTabsController(
         }
         selectedIndex = index
         attach(index)
+        // A tab hidden at a repaint takes it now, before its screens appear: its bar's parts, its search's and its
+        // FAB's colors follow the theme and the defaults only through a repaint.
+        if (staleTabs.remove(shown)) Navigator.repaintLayer(shown)
         peekView()?.bar?.let {
             it.setCurrentItem(index, false)
             it.onCustomItemViewSelectionChanged(index)
@@ -328,10 +379,27 @@ class BottomTabsController(
         // A layer that waits for the tabs waits for the tab they show now.
         navigator?.shownScreensChanged(this)
         if (onScreen) AppearanceDispatcher.beginTransition(listOf(shown))
-        views?.switch(shown, left)
+        if (views == null) return switched(index, previous, how, onScreen, hasViews = false)
+        endSwitch = views.switch(shown, left, animated = onScreen) {
+            endSwitch = null
+            if (!isDestroyed) switched(index, previous, how, onScreen, hasViews = true)
+        }
+    }
+
+    /**
+     * The switch to the tab at [index] from [previous] ended: what went disappears, what came appears — unless the tabs
+     * stopped showing during the fade (a modal over them): it appears when they show again; then for a press
+     * `ANN.BottomTabSelected` right after the new screen's DidAppear and the left tab's `popToRootOnBlur`, with the state
+     * as one update after them; from code and by back, `popToRootOnBlur` and the state at once. [onScreen]: the switch
+     * started on screen.
+     */
+    private fun switched(index: Int, previous: Int, how: How, onScreen: Boolean, hasViews: Boolean) {
+        val left = tabs[previous]
+        val shown = tabs[index]
         if (onScreen) {
-            AppearanceDispatcher.endTransition(listOf(left), listOf(shown), null, null, null, reportsState = false)
-        } else if (views != null) {
+            val showing = if (isOnScreen) listOf(shown) else emptyList()
+            AppearanceDispatcher.endTransition(listOf(left), showing, null, null, null, reportsState = false)
+        } else if (hasViews) {
             // Not on screen: the bar takes the new tab's options as they are, without appearance events.
             val options = resolveShownOptions(DefaultOptions.current)
             bar.applyBar(options.bottomTabs, directionOf(options))
@@ -358,8 +426,10 @@ class BottomTabsController(
         if (screen == null) finish() else AppearanceDispatcher.afterDidAppear(screen, finish)
     }
 
-    // A press's `ANN.BottomTabSelected` still waiting goes before anything newer on these tabs.
+    // A switch still running ends at once and a press's `ANN.BottomTabSelected` still waiting goes, before anything
+    // newer on these tabs.
     private fun flushPendingSelected() {
+        endSwitch?.invoke()
         pendingSelected?.invoke()
     }
 
@@ -531,8 +601,8 @@ class BottomTabsController(
         }
     }
 
-    // The repaint: the bar, the items of every tab, the row, then the made tabs that don't show, which the pass over
-    // what shows doesn't reach.
+    // The repaint: the bar, the items of every tab, the row. Only what shows is repainted (the pass over what shows
+    // reaches the selected tab); a made tab that doesn't show is repainted when it is selected ([staleTabs]).
     internal fun repaint(options: Options) {
         if (isDestroyed) return
         ContainerBackground.apply(this, options)
@@ -542,7 +612,7 @@ class BottomTabsController(
             if (usesRow) layout.bar.customRowOptions = options.bottomTabs.customRow.copy()
         }
         cells.forEachIndexed { index, cell -> cell.update(cellState(index)) }
-        tabs.forEach { if (it !== currentChild && it.isViewCreated) Navigator.repaintLayer(it) }
+        tabs.forEach { if (it !== currentChild && it.isViewCreated) staleTabs += it }
     }
 
     // The custom row: the cells first into the bar's external host, then the row holds them; its look follows the tabs'
@@ -620,7 +690,10 @@ class BottomTabsController(
     override fun destroy() {
         if (isDestroyed) return
         pendingSelected = null
+        staleTabs.clear()
         super.destroy()
+        // A switch still running ends with its views at rest, without events: the tabs are gone.
+        endSwitch?.invoke()
         peekView()?.let { layout ->
             layout.bar.destroyCustomItemViews()
             layout.row?.let(CustomTabRowPlacer::forget)