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

package/android/src/main/java/dev/apexnative/navigation/react/events/NavigationState.kt

@@ -0,0 +1,154 @@
+package dev.apexnative.navigation.react.events
+
+import android.os.Handler
+import android.os.Looper
+import dev.apexnative.navigation.react.ReloadCoordinator
+import dev.apexnative.navigation.viewcontrollers.bottomtabs.BottomTabsController
+import dev.apexnative.navigation.viewcontrollers.navigator.Navigators
+import dev.apexnative.navigation.viewcontrollers.parent.ParentController
+import dev.apexnative.navigation.viewcontrollers.viewcontroller.ViewController
+
+/**
+ * The one place of the navigation state JavaScript hears (`ANN.NavigationStateChanged`): the screen the user sees and
+ * the selected tab, the last state sent, the update posted for a pass of the main loop and its holds. Every change of
+ * the screen the user sees comes with a screen appearing: a push, a pop, a modal, a tab, a menu.
+ *
+ * Two ways ask for it. The dispatcher asks for one update after the events of a pass ([setNeedsUpdate], coalesced and
+ * held while a `setRoot` shows the modals and the overlays of its layout). A command's answer sends it at once
+ * ([updateNow], never held), once per answer (`CommandAnswer.reportStateNow`): at the end of its transition, else
+ * right before its promise. Each goes only when the state differs from the last one sent, through the JavaScript that
+ * runs now. Main thread only.
+ */
+internal object NavigationState : AppearanceDispatcher.StateUpdates {
+    /** What JavaScript hears: the screen the user sees (`null` for none) and the selected tab (`null` out of tabs). */
+    data class State(val screenId: String?, val screenName: String?, val tab: Int?)
+
+    private val handler by lazy { Handler(Looper.getMainLooper()) }
+
+    // The last state sent to the JavaScript that runs now; none before its first.
+    private var sent: State? = null
+
+    // The one posted update of a pass of the main loop, which checks the holds when it runs.
+    private val updates = Updates(
+        post = { task -> handler.post(task) },
+        generation = { ReloadCoordinator.generation },
+        update = ::updateNow,
+    )
+
+    override fun setNeedsUpdate() {
+        if (EventEmitter.current().canSend) updates.setNeedsUpdate()
+    }
+
+    override fun hold() = updates.hold()
+
+    override fun release() = updates.release()
+
+    /**
+     * Sends the state at once when it differs from the last one sent. A command's answer calls it once, at the end of
+     * its transition or right before its promise: the event and the resolution reach JavaScript in that order, so the
+     * state is new when the `await` of the command goes on. The update posted for the pass then finds nothing new.
+     */
+    override fun updateNow() {
+        val emitter = EventEmitter.current()
+        if (!emitter.canSend) return
+        // The navigation of the activity the commands run in (`Navigators.current`).
+        val navigator = Navigators.current()?.navigator ?: return
+        val next = stateOf(navigator.visibleLayout)
+        if (next == sent) return
+        sent = next
+        emitter.emitNavigationStateChanged(next.screenId, next.screenName, next.tab)
+    }
+
+    /** The new JavaScript has no state yet (`ANN.AppLaunched`): the next one goes to it whatever it is. */
+    fun reset() {
+        sent = null
+    }
+
+    /**
+     * The JavaScript went with its layouts: a hold its `setRoot` left, and an update wanted under it, go with it, so
+     * the new JavaScript's updates are never held by the old one's.
+     */
+    fun javaScriptWent() = updates.dropHolds()
+
+    // The top modal, or the root ([layout]), down to the screen the user sees; overlays don't count. The tab is the
+    // selected one of the nearest tabs the screen is in, the last met on the way down, in a modal too: the tabs
+    // `selectTab` acts on from it. None for a screen out of tabs.
+    internal fun stateOf(layout: ViewController<*>?): State {
+        var tab: Int? = null
+        var current = layout ?: return State(null, null, null)
+        while (current is ParentController<*>) {
+            if (current is BottomTabsController) tab = current.selectedIndex
+            current = current.currentChild ?: return State(null, null, null)
+        }
+        return State(current.id, current.currentComponentName, tab)
+    }
+
+    /**
+     * The posted update and its holds. [setNeedsUpdate] posts one update ([post]), coalesced: the asks of one pass of
+     * the main loop make one, which runs [update] in a later pass. While held, an ask, or a posted update that runs
+     * while held (asked before the hold was taken), only marks one as wanted, and the last release posts it. Released
+     * right before the answer, that update finds nothing new: the state before the answer is sent at once, never
+     * held, and an identical state is never sent twice. Every [hold] has one [release]; a release without a hold does
+     * nothing, so the count never goes below zero. An update keeps the JavaScript it was asked for ([generation]): one
+     * asked by a JavaScript that went before it runs is dropped; a newer ask of the new JavaScript still goes.
+     */
+    internal class Updates(
+        private val post: (() -> Unit) -> Unit,
+        private val generation: () -> Int = { 0 },
+        private val update: () -> Unit,
+    ) {
+        /** The holds not released yet. */
+        var count = 0
+            private set
+
+        // An update was asked while held.
+        private var wanted = false
+        // An update is posted and hasn't run yet.
+        private var scheduled = false
+        // The JavaScript the last ask was for.
+        private var askedIn = 0
+
+        /** Asks for one update in a later pass of the main loop; while held, once the last hold is released. */
+        fun setNeedsUpdate() {
+            askedIn = generation()
+            if (count > 0) wanted = true else schedule()
+        }
+
+        /** The updates asked from now on, and those posted that run from now on, wait for as many [release]s. */
+        fun hold() {
+            count++
+        }
+
+        /** One hold ends; with the last, the update asked while held is posted now. */
+        fun release() {
+            if (count == 0) return
+            count--
+            if (count > 0 || !wanted) return
+            wanted = false
+            schedule()
+        }
+
+        /**
+         * The holds and the update wanted under them go, unreleased: the JavaScript that took them went. An update
+         * already posted stays; it runs only for the JavaScript it was asked for.
+         */
+        fun dropHolds() {
+            count = 0
+            wanted = false
+        }
+
+        private fun schedule() {
+            if (scheduled) return
+            scheduled = true
+            post {
+                scheduled = false
+                // A hold taken since it was posted: the update waits for the release. The JavaScript it was asked for
+                // went: nothing goes to the new one, which hears its first state after its own changes.
+                when {
+                    count > 0 -> wanted = true
+                    askedIn == generation() -> update()
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/dev/apexnative/navigation/react/events/ScreenAppearance.kt

@@ -45,12 +45,6 @@ internal class ScreenAppearance(
     /** Cancels the hold limit running for [held]; none when nothing is held. */
     internal var cancelLimit: (() -> Unit)? = null
 
-    /**
-     * This appearance started without its WillAppear (`AppearanceDispatcher.withoutWillAppear`: a side menu's drawer
-     * that jumped open); its DidAppear is its first event. Cleared as it is hidden.
-     */
-    internal var skippedWill = false
-
     private var ready = content == null
     private var waitsForContent = false
 

package/android/src/main/java/dev/apexnative/navigation/safearea/SafeAreaView.kt

@@ -10,7 +10,7 @@ import com.facebook.react.uimanager.StateWrapper
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.views.view.ReactViewGroup
-import dev.apexnative.navigation.react.ScreenInsets
+import dev.apexnative.navigation.react.ScreenEnvironment
 import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 
 /**
@@ -20,7 +20,7 @@ import dev.apexnative.navigation.viewcontrollers.component.ScreenReadiness
 @SuppressLint("ViewConstructor")
 class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext) {
     private var stopListening: (() -> Unit)? = null
-    private var applied: ScreenInsets.Insets? = null
+    private var applied: ScreenEnvironment.Insets? = null
     private var readySent = false
     private var contentSignalled = false
 
@@ -48,7 +48,7 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
             stopListening?.invoke()
             field = value
             applied = null
-            stopListening = value?.let { id -> ScreenInsets.listenToPadding(id) { applyPadding() } }
+            stopListening = value?.let { id -> ScreenEnvironment.listenToPadding(id) { applyPadding() } }
             // The screen has a safe area view: it counts as rendered once this view says so.
             value?.let(ScreenReadiness::wrapped)
             applyPadding()
@@ -56,7 +56,7 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
 
     private fun applyPadding() {
         val state = stateWrapper ?: return
-        val padding = screenId?.let(ScreenInsets::padding) ?: return
+        val padding = screenId?.let(ScreenEnvironment::padding) ?: return
         if (padding == applied) return
         applied = padding
         state.updateState(
@@ -69,9 +69,9 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
         )
     }
 
-    private fun paddingOf(data: ReadableMap): ScreenInsets.Insets? {
+    private fun paddingOf(data: ReadableMap): ScreenEnvironment.Insets? {
         if (!data.hasKey("top")) return null
-        return ScreenInsets.Insets(data.getDouble("top"), data.getDouble("right"), data.getDouble("bottom"),
+        return ScreenEnvironment.Insets(data.getDouble("top"), data.getDouble("right"), data.getDouble("bottom"),
             data.getDouble("left"))
     }
 
@@ -95,8 +95,9 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
         val reactContext = context as? ReactContext ?: return
         val dispatcher = UIManagerHelper.getEventDispatcher(reactContext) ?: return
         readySent = true
-        dispatcher.dispatchEvent(SafeAreaReadyEvent(UIManagerHelper.getSurfaceId(this), id))
-        screenId?.let(ScreenReadiness::laidOut)
+        val surfaceId = UIManagerHelper.getSurfaceId(this)
+        dispatcher.dispatchEvent(SafeAreaReadyEvent(surfaceId, id))
+        screenId?.let { ScreenReadiness.laidOut(it, surfaceId) }
     }
 
     // The navigation tells whether this view's screen waits: a component of a bar (title, button, background, tab)
@@ -111,12 +112,13 @@ class SafeAreaView(reactContext: ThemedReactContext) : ReactViewGroup(reactConte
     }
 
     // Once, by the screen's id: the container asks the screen's view for the layout React mounts the content without.
-    // On attach too: content added before this view was attached is signalled then.
+    // On attach too: content added before this view was attached is signalled then. The signal names this view's
+    // surface: only the root that shows it takes it as its own.
     private fun signalContent() {
         if (contentSignalled) return
         val id = screenId ?: return
         contentSignalled = true
-        ScreenReadiness.contentRendered(id)
+        ScreenReadiness.contentRendered(id, UIManagerHelper.getSurfaceId(this))
     }
 
     fun drop() {

package/android/src/main/java/dev/apexnative/navigation/slots/SlotContainers.kt

@@ -9,14 +9,15 @@ interface SlotContainer {
 }
 
 /**
- * The native containers the slots of the app's React tree show their children in, by slot id. A destroyed container
- * drops out on its own.
+ * The native containers the slots of the app's React tree show their children in, by slot id, and the slot views by
+ * the same id: a change of a container goes straight to the views of its id. A destroyed container and a collected
+ * view drop out on their own.
  */
 object SlotContainers {
     private class Entry(val view: WeakReference<ViewGroup>, val passThrough: Boolean)
 
     private val containers = HashMap<String, Entry>()
-    private val slots = LinkedHashSet<SlotView>()
+    private val slots = SlotViews<SlotView>()
 
     /** `passThrough`: touches outside the slot's content go to the screens below, as in an overlay for a toast. */
     fun put(slotId: String, container: ViewGroup, passThrough: Boolean = false) {
@@ -33,12 +34,14 @@ object SlotContainers {
         changed(slotId)
     }
 
-    /** The container of a slot appeared or changed its size. */
+    /** The container of a slot appeared or changed its size: the slot views under its id, and only they, hear it. */
     fun changed(slotId: String) {
-        slots.toList().forEach { it.containerChanged(slotId) }
+        slots.views(slotId).forEach { it.containerChanged(slotId) }
     }
 
-    internal fun listen(slot: SlotView) = slots.add(slot)
+    /** The slot view goes under its slot id, and out from under the id it had. Main thread only. */
+    internal fun register(slotId: String, slot: SlotView) = slots.register(slotId, slot)
 
-    internal fun stopListening(slot: SlotView) = slots.remove(slot)
+    /** The slot view unmounted or lost its slot id: no container change reaches it. Main thread only. */
+    internal fun unregister(slot: SlotView) = slots.unregister(slot)
 }

package/android/src/main/java/dev/apexnative/navigation/slots/SlotScreenView.kt

@@ -2,9 +2,13 @@ package dev.apexnative.navigation.slots
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.util.Size
 import android.view.MotionEvent
 import android.view.ViewGroup
 import android.widget.FrameLayout
+import com.facebook.react.uimanager.PixelUtil.dpToPx
+import dev.apexnative.navigation.react.ContentHeights
+import dev.apexnative.navigation.react.ContentMounts
 import dev.apexnative.navigation.react.events.AppearanceDispatcher
 import dev.apexnative.navigation.react.events.ComponentType
 import dev.apexnative.navigation.react.events.ScreenAppearance
@@ -16,9 +20,10 @@ import dev.apexnative.navigation.viewcontrollers.viewcontroller.ScrollEventListe
  * What a slot screen (`slot:<Name>`) shows: the empty container its slot of the app's React tree moves its children
  * into, under the screen's id ([SlotContainers]), told of each change of its size. It is the screen's content for the
  * core: ready once the slot's content has mounted into it and, when the screen has a safe area view, the screen
- * rendered into that view; its mounted handlers run at each mount. Its appearance events go through its record to the
- * core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit. Destroyed while the
- * id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
+ * rendered into that view; its mounted handlers run at each mount of Fabric and as the content mounts into it. Its
+ * content measures without a height limit in the slot's own layout ([contentSize]). Its appearance events go through
+ * its record to the core's dispatcher (`AppearanceDispatcher`), which holds them until it is ready or the hold limit.
+ * Destroyed while the id is still its own, it tells JavaScript to take the slot's content away (`ANN.SlotDestroyed`).
  */
 @SuppressLint("ViewConstructor")
 class SlotScreenView(
@@ -30,8 +35,13 @@ class SlotScreenView(
     private val scrollEventListener = ScrollEventListener()
     private val whenMounted = mutableListOf<Runnable>()
     private val whenRendered = mutableListOf<Runnable>()
-    private val mountedHandlers = LinkedHashMap<String, Runnable>()
-    private var readinessListener: ScreenReadiness.Listener? = null
+    private val mounts = ContentMounts { !destroyed && isAttachedToWindow }
+    private var listening = false
+
+    // The safe area view of a slot renders in the app's one React tree: every signal of the id is the screen's.
+    private val readiness = object : ScreenReadiness.Listener {
+        override fun onContentRendered() = checkReadiness()
+    }
     private var mounted = false
     private var readyTold = false
     private var destroyed = false
@@ -79,10 +89,11 @@ class SlotScreenView(
         destroyed = true
         whenMounted.clear()
         whenRendered.clear()
-        mountedHandlers.clear()
+        mounts.clear()
         stopListening()
         // A later screen with the same id keeps the slot.
         if (SlotContainers.get(componentId) !== this) return
+        ContentHeights.forgetSlot(componentId)
         SlotContainers.remove(componentId)
         if (!isPreparedPush) AppearanceDispatcher.slotDestroyed(componentId, appearance.generation)
     }
@@ -105,14 +116,9 @@ class SlotScreenView(
         if (readyTold) return listener.run()
         whenRendered += listener
         if (isReady()) return checkReadiness()
-        if (readinessListener != null) return
-        val readiness = object : ScreenReadiness.Listener {
-            override fun onLaidOut() = Unit
-
-            override fun onContentRendered() = checkReadiness()
-        }
-        readinessListener = readiness
-        ScreenReadiness.setListener(componentId, readiness)
+        if (listening) return
+        listening = true
+        ScreenReadiness.addListener(componentId, this, readiness)
     }
 
     override fun whenSlotContentMounted(listener: Runnable) {
@@ -120,7 +126,21 @@ class SlotScreenView(
     }
 
     override fun setOnContentMounted(key: String, handler: Runnable?) {
-        if (handler == null) mountedHandlers.remove(key) else mountedHandlers[key] = handler
+        if (!destroyed) mounts.set(key, handler)
+    }
+
+    // The slot measures its content in its own layout: the first question asks for it and lays the slot out again; the
+    // height comes with that layout, before the mount the handlers hear. The width is the container's, at which the
+    // slot lays its content out.
+    override fun contentSize(maxWidth: Int): Size? {
+        if (destroyed) return null
+        if (!ContentHeights.isSlotRequested(componentId)) {
+            ContentHeights.requestSlot(componentId)
+            SlotContainers.changed(componentId)
+            return null
+        }
+        val height = ContentHeights.slotHeight(componentId)?.takeIf { it > 0f } ?: return null
+        return Size(if (width > 0) width else maxWidth, Math.round(height.dpToPx()))
     }
 
     // Only the container that holds the slot of the id: a destroyed one, or one a later screen replaced, takes no
@@ -136,7 +156,7 @@ class SlotScreenView(
         val waiting = whenMounted.toList()
         whenMounted.clear()
         waiting.forEach { it.run() }
-        mountedHandlers.values.toList().forEach { it.run() }
+        mounts.run()
         checkReadiness()
     }
 
@@ -151,8 +171,8 @@ class SlotScreenView(
     }
 
     private fun stopListening() {
-        val readiness = readinessListener ?: return
-        readinessListener = null
-        ScreenReadiness.removeListener(componentId, readiness)
+        if (!listening) return
+        listening = false
+        ScreenReadiness.removeListener(componentId, this)
     }
 }

package/android/src/main/java/dev/apexnative/navigation/slots/SlotView.kt

@@ -15,6 +15,7 @@ import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.events.EventDispatcher
 import com.facebook.react.views.view.ReactViewGroup
+import dev.apexnative.navigation.react.ContentHeights
 
 /**
  * The React children of a slot. They live outside the views of the host's surface, in the container of a screen, so
@@ -79,6 +80,8 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
         }
     private var lastWidth = -1f
     private var lastHeight = -1f
+    // The slot was laid out once more, at the same size, for the measure of its content (`ContentHeights`).
+    private var measureAsked = false
 
     private val slotId: String?
         get() = getTag(R.id.view_tag_native_id) as? String
@@ -86,7 +89,6 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
     init {
         content.visibility = INVISIBLE
         addView(content)
-        SlotContainers.listen(this)
     }
 
     override fun setId(id: Int) {
@@ -100,7 +102,9 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
     }
 
     fun attachContent() {
-        val id = slotId ?: return
+        // The view hears the changes of the container under the id it has now, and no other.
+        val id = slotId ?: return SlotContainers.unregister(this)
+        SlotContainers.register(id, this)
         val container = SlotContainers.get(id)
         val target: ViewGroup = container ?: this
         if (content.parent !== target) {
@@ -115,7 +119,14 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
         if (container != null && state != null && container.width > 0 && container.height > 0) {
             val width = container.width.toFloat().pxToDp()
             val height = container.height.toFloat().pxToDp()
-            if (width != lastWidth || height != lastHeight) {
+            // A container that measures the content gets one layout more for it, with the same size, until the height
+            // came.
+            val requested = ContentHeights.isSlotRequested(id)
+            // A request that went (its screen did) and comes again gets its layout again.
+            if (!requested) measureAsked = false
+            val measures = !measureAsked && requested && ContentHeights.slotHeight(id) == null
+            if (width != lastWidth || height != lastHeight || measures) {
+                measureAsked = measureAsked || measures
                 lastWidth = width
                 lastHeight = height
                 state.updateState(
@@ -135,7 +146,8 @@ class SlotView(reactContext: ThemedReactContext) : ReactViewGroup(reactContext)
     }
 
     fun drop() {
-        SlotContainers.stopListening(this)
+        measureAsked = false
+        SlotContainers.unregister(this)
         (content.parent as? ViewGroup)?.removeView(content)
     }
 }

package/android/src/main/java/dev/apexnative/navigation/slots/SlotViews.kt

@@ -0,0 +1,40 @@
+package dev.apexnative.navigation.slots
+
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+
+/**
+ * The slot views by their slot id, held weakly, so a change of a container reaches only the views of its id. A view is
+ * under one id at a time: registering it under a new one (its `nativeID` changed, or Fabric reused it) takes it out
+ * from under the old one. Two live views under one id both stay, in the order they came, and both hear the change, as
+ * every view with that id did when the change went to all of them. Main thread only.
+ */
+internal class SlotViews<T : Any> {
+    private val byId = HashMap<String, MutableList<WeakReference<T>>>()
+    private val idOf = WeakHashMap<T, String>()
+
+    fun register(slotId: String, view: T) {
+        if (idOf[view] == slotId) return
+        unregister(view)
+        idOf[view] = slotId
+        byId.getOrPut(slotId) { ArrayList(1) }.add(WeakReference(view))
+    }
+
+    fun unregister(view: T) {
+        val slotId = idOf.remove(view) ?: return
+        prune(slotId) { it === view }
+    }
+
+    /** The live views under [slotId], a copy: a view may register or leave while it hears the change. */
+    fun views(slotId: String): List<T> {
+        prune(slotId) { false }
+        return byId[slotId]?.mapNotNull { it.get() }.orEmpty()
+    }
+
+    // Drops the collected views under the id and the ones `drop` picks; an id with no views left goes.
+    private fun prune(slotId: String, drop: (T) -> Boolean) {
+        val views = byId[slotId] ?: return
+        views.removeAll { reference -> reference.get()?.let(drop) ?: true }
+        if (views.isEmpty()) byId.remove(slotId)
+    }
+}

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

@@ -0,0 +1,66 @@
+package dev.apexnative.navigation.utils
+
+import android.content.Context
+import android.content.res.Configuration
+import android.view.View
+import java.io.File
+import java.net.URI
+import java.net.URISyntaxException
+
+/**
+ * What an image of the options is cached by: its [uri] and what changes the decoded result for the same uri, the
+ * screen's density (a drawable of the app picks its density's file, a decoded file is scaled to it), light or dark
+ * (`drawable-night`) and the layout direction (`drawable-ldrtl`, auto-mirrored drawables). For a `file:` uri also the
+ * file's [modified] time and [size]: a file the app writes again at the same path is another image. The loader bakes
+ * no tint and no size into an image, so neither is part of it.
+ */
+internal data class ImageKey(
+    val uri: String,
+    val densityDpi: Int,
+    val night: Boolean,
+    val rightToLeft: Boolean,
+    /** When the file of a `file:` uri last changed, in milliseconds; 0 for any other uri or a file that isn't there. */
+    val modified: Long = 0,
+    /** The bytes of the file of a `file:` uri; 0 for any other uri or a file that isn't there. */
+    val size: Long = 0,
+) {
+    companion object {
+        private const val FILE_SCHEME = "file:"
+        private const val FILE_PREFIX = "file://"
+
+        /** The key of [uri] in the current configuration of [context]. Any thread. */
+        fun of(context: Context, uri: String): ImageKey {
+            val configuration = context.resources.configuration
+            return of(uri, configuration.densityDpi, configuration.uiMode, configuration.layoutDirection)
+        }
+
+        /**
+         * The key of [uri] for a configuration's density, `uiMode` (only its night bits count) and layout direction;
+         * a `file:` uri reads its file's modification time and size. Any thread.
+         */
+        fun of(uri: String, densityDpi: Int, uiMode: Int, layoutDirection: Int): ImageKey {
+            val file = filePath(uri)?.let(::File)
+            return ImageKey(
+                uri = uri,
+                densityDpi = densityDpi,
+                night = uiMode and Configuration.UI_MODE_NIGHT_MASK == Configuration.UI_MODE_NIGHT_YES,
+                rightToLeft = layoutDirection == View.LAYOUT_DIRECTION_RTL,
+                // Both 0 when the file isn't there or can't be read.
+                modified = file?.lastModified() ?: 0,
+                size = file?.length() ?: 0,
+            )
+        }
+
+        // The path of a `file:` uri, decoded as the loader's `Uri.getPath` decodes it; none for any other uri. A uri
+        // that `URI` can't parse (an unescaped space) is taken as it is after its scheme.
+        private fun filePath(uri: String): String? {
+            if (!uri.startsWith(FILE_SCHEME)) return null
+            val path = try {
+                URI(uri).path
+            } catch (e: URISyntaxException) {
+                null
+            }
+            return path ?: uri.removePrefix(FILE_PREFIX).removePrefix(FILE_SCHEME).ifEmpty { null }
+        }
+    }
+}