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

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

@@ -1,19 +1,8 @@
 package dev.apexnative.navigation.utils
 
 import android.content.Context
-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 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
 
 /** What an image loads into: [onComplete] with the image, or [onError] when it can't load. Main thread. */
 open class ImageLoadingListenerAdapter {
@@ -23,90 +12,19 @@ open class ImageLoadingListenerAdapter {
 }
 
 /**
- * Loads the images and icons of the options when they apply: synchronously on the main thread, without a cache, each
- * image its own mutable copy. 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). Not found while the app is in
- * development: the address is read as a stream, 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 never ends the app: the listener's [ImageLoadingListenerAdapter.onError], the log, and React Native's red
- * screen in development.
+ * Loads an image or an icon of the options at once, through the shared cache of [OptionImages]: each image its own
+ * mutable copy. For the places whose first frame needs the image (the top bar's buttons, the back button, menus, search
+ * suggestions); a place that can show it when ready asks through [ImageRequests]. A failure never ends the app: the
+ * listener's [ImageLoadingListenerAdapter.onError], and one warning per address.
  */
 class ImageLoader {
     /** Loads [uri] and gives it to [listener] before returning. Main thread. */
     fun loadIcon(context: Context, uri: String, listener: ImageLoadingListenerAdapter) {
-        val drawable = try {
-            load(context, uri)
-        } catch (e: Exception) {
-            val reason = if (e is LoadFailure) "" else ": ${e.message ?: e.javaClass.simpleName}"
-            DevelopmentLog.error("Could not load image $uri$reason${(e as? LoadFailure)?.why.orEmpty()}", e)
-            listener.onError(e)
+        val drawable = OptionImages.load(context, uri)
+        if (drawable == null) {
+            listener.onError(IOException("Could not load image $uri"))
             return
         }
         listener.onComplete(drawable)
     }
-
-    private fun load(context: Context, uri: String): Drawable {
-        if (uri.startsWith(FILE_SCHEME)) return decode(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 { decode(context) { URL(uri).openStream() } }
-            }
-            else -> decode(context) {
-                context.contentResolver.openInputStream(address) ?: throw FileNotFoundException(uri)
-            }
-        }
-    }
-
-    // A drawable of the app by name, its own copy; 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)?.mutate()
-        } 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: that is a load error too, never the end of the app.
-    private fun decode(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)
-    }
-
-    // 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")
-
-    // 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)
-        }
-    }
-
-    private companion object {
-        const val FILE_SCHEME = "file:"
-        const val ASSETS_PATH = "/assets/"
-    }
 }

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/MaterialTheme.kt

@@ -28,7 +28,7 @@ internal object MaterialTheme {
     private val wrappers = WeakHashMap<Context, WeakReference<Context>>()
     // Themes of the navigation's own views, each made once over the activity's with a style of its own.
     private val followers = WeakHashMap<Context, Int>()
-    // The popup theme of the bar's toolbars per activity: the app's theme doesn't change while the activity lives.
+    // The popup theme of the bar's "⋮" per activity: the app's theme doesn't change while the activity lives.
     private val popupThemes = WeakHashMap<Activity, Int>()
 
     fun context(context: Context): Context {
@@ -38,11 +38,10 @@ internal object MaterialTheme {
     }
 
     /**
-     * The popup theme of the top bar's toolbars, for "⋮", set on them before their menu is made. None when the app's
-     * theme follows light and dark: the menu takes the bar's own theme, which [rebase] keeps in the current mode, with
-     * the app's colors. With a Material 3 theme fixed to light or to dark, a day/night overlay that gives the menu the
-     * current mode's colors where the theme shows the other mode. Android makes the menu's theme from it at the menu's
-     * first opening, in the mode of that moment, and no public API makes it again for a later switch.
+     * The popup theme of the top bar's "⋮", over the bar's theme at each opening of its popup, in the mode of that
+     * moment. None when the app's theme follows light and dark: the menu takes the bar's own theme, which [rebase]
+     * keeps in the current mode, with the app's colors. With a Material 3 theme fixed to light or to dark, a day/night
+     * overlay that gives the menu the current mode's colors where the theme shows the other mode.
      */
     fun popupTheme(context: Context): Int {
         val activity = activityOf(context) ?: return 0

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/SystemAnimations.kt

@@ -0,0 +1,36 @@
+package dev.apexnative.navigation.utils
+
+import android.animation.ValueAnimator
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Build
+import android.provider.Settings
+import dev.apexnative.navigation.NavigationApplication
+
+/**
+ * Whether the system plays no animations: "Remove animations" in the accessibility settings, or the animator duration
+ * scale at 0 in the developer options. Then a transition doesn't wait for its elements' targets and images and moves no
+ * element, and the side menu opens and closes at once. Any thread.
+ */
+internal object SystemAnimations {
+    /**
+     * The animations are off now; [context] reads the scale below Android 8, else the application's. Lint can't see
+     * that the decision calls `areAnimatorsEnabled` (API 26) only from Android 8.
+     */
+    @SuppressLint("NewApi")
+    fun areOff(context: Context? = null): Boolean =
+        areOff(Build.VERSION.SDK_INT, { ValueAnimator.areAnimatorsEnabled() }) { durationScaleOf(context) }
+
+    /**
+     * The decision: from Android 8 the animator's own answer ([animatorsEnabled]), which follows both settings;
+     * below it the duration scale ([durationScale]) at 0.
+     */
+    fun areOff(sdk: Int, animatorsEnabled: () -> Boolean, durationScale: () -> Float): Boolean =
+        if (sdk >= Build.VERSION_CODES.O) !animatorsEnabled() else durationScale() == 0f
+
+    // Without a context and before the application started (the unit tests), the animations play.
+    private fun durationScaleOf(context: Context?): Float {
+        val resolver = (context ?: NavigationApplication.instanceOrNull)?.contentResolver ?: return 1f
+        return Settings.Global.getFloat(resolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1f)
+    }
+}

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

@@ -22,8 +22,8 @@ object UiUtils {
     fun pxToDp(context: Context, px: Float): Float = px / context.resources.displayMetrics.density
 
     /**
-     * A size of the options in dp, in whole pixels of the screen of [context]: times `densityDpi / 160`, the fraction
-     * of a pixel dropped; a size of 0 or less is not converted.
+     * A size of the options in dp, in whole pixels of the screen of [context]: times `densityDpi / 160`, rounded to the
+     * nearest pixel only here, as iOS places a size in points on whole pixels; a size of 0 or less is not converted.
      */
     @JvmStatic
     fun dpToPixels(context: Context, dp: Double): Int = dpToPixels(dp, context.resources.displayMetrics.densityDpi)
@@ -31,7 +31,7 @@ object UiUtils {
     /** [dp] in whole pixels at [densityDpi], as [dpToPixels] converts it. */
     @JvmStatic
     fun dpToPixels(dp: Double, densityDpi: Int): Int =
-        if (dp <= 0) dp.toInt() else (dp * densityDpi / BASE_DENSITY_DPI).toInt()
+        if (dp <= 0) dp.toInt() else (dp * densityDpi / BASE_DENSITY_DPI).roundToInt()
 
     /**
      * A font size of the options in sp, in pixels of the screen of [context]: it follows the system's text scale,

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/utils/ViewExtensions.kt

@@ -26,16 +26,3 @@ val View.borderRadius: Float
  */
 internal fun resolveBorderRadius(radius: LengthPercentage, width: Int, density: Float): Float =
     (radius.resolve(width / density) * density).coerceAtLeast(0f)
-
-/** The scale the parents of [view] give it, along x and along y: a view in a scaled parent shows smaller. */
-fun computeInheritedScale(view: View): Pair<Float, Float> {
-    var scaleX = 1f
-    var scaleY = 1f
-    var parent = view.parent as? View
-    while (parent != null) {
-        scaleX *= parent.scaleX
-        scaleY *= parent.scaleY
-        parent = parent.parent as? View
-    }
-    return scaleX to scaleY
-}

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

@@ -9,7 +9,8 @@ import androidx.window.layout.WindowMetricsCalculator
 import dev.apexnative.navigation.NavigationActivity
 import dev.apexnative.navigation.options.DefaultOptions
 import dev.apexnative.navigation.options.Options
-import dev.apexnative.navigation.react.ArrangementStates
+import dev.apexnative.navigation.react.ScreenEnvironment
+import dev.apexnative.navigation.react.events.EventEmitter
 import dev.apexnative.navigation.utils.SystemUiUtils
 import dev.apexnative.navigation.utils.WindowFolds
 import dev.apexnative.navigation.viewcontrollers.child.ChildController
@@ -145,12 +146,14 @@ class ArrangementController internal constructor(
         val overlay = plan.layout == ArrangementPlan.Layout.OVERLAY
         val single = plan.layout == ArrangementPlan.Layout.SINGLE
         if (primary is ComponentViewController) {
-            val state = ArrangementStates.State(PRIMARY, layout, front = overlay, hidden = false)
-            ArrangementStates.set(activity, primary.id, state, notify)
+            val state = ScreenEnvironment.Arrangement(PRIMARY, layout, front = overlay, hidden = false)
+            val changes = ScreenEnvironment.changesOf(EventEmitter.of(primary.jsGeneration))
+            ScreenEnvironment.setArrangement(primary.id, state, notify, changes)
         }
         if (secondary is ComponentViewController) {
-            val state = ArrangementStates.State(SECONDARY, layout, front = false, hidden = single)
-            ArrangementStates.set(activity, secondary.id, state, notify)
+            val state = ScreenEnvironment.Arrangement(SECONDARY, layout, front = false, hidden = single)
+            val changes = ScreenEnvironment.changesOf(EventEmitter.of(secondary.jsGeneration))
+            ScreenEnvironment.setArrangement(secondary.id, state, notify, changes)
         }
     }
 
@@ -243,9 +246,9 @@ class ArrangementController internal constructor(
         // The stack keeps the bar's title, buttons and search by the view of its screen on top: they go with the pair.
         if (!isDestroyed && peekView() != null) performOnParentController { it.onChildDestroyed(this) }
         folds?.removeListener(onFoldsChanged)
-        ArrangementStates.remove(primary.id)
-        ArrangementStates.remove(secondary.id)
         shownChildren.containerDisappeared()
+        // The screens go with the pair: each clears its own environment, its arrangement too, unless its id is
+        // another's now.
         super.destroy()
     }
 

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)
+    }
 }