pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/ContainerManagers.kt

@@ -0,0 +1,69 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.modules.ModuleEvents
+import com.pythonnative.runtime.views.PNFrameLayout
+import org.json.JSONObject
+import kotlin.math.max
+
+/**
+ * Flex container (shared by `View`, `Column`, and `Row`): a bare
+ * [PNFrameLayout]. All flex semantics are computed by the Python layout
+ * engine and applied through `setFrame`; the container is just a
+ * positioning surface with `pointer_events` interception.
+ */
+open class ViewManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = PNFrameLayout(context)
+}
+
+/** Empty layout placeholder used as a flexible gap. */
+class SpacerManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = View(context)
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        // Spacers carry no visual props of their own.
+    }
+}
+
+/** Safe-area container: a flex container with `fitsSystemWindows`. */
+class SafeAreaViewManager : ViewManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val view = PNFrameLayout(context)
+        view.fitsSystemWindows = true
+        return view
+    }
+}
+
+/**
+ * Vanilla container that publishes the keyboard height (from window
+ * insets) as a `Host` module `keyboard` event so the Python-side
+ * component can compute its offset.
+ */
+class KeyboardAvoidingViewManager : ViewManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val view = PNFrameLayout(context)
+        ViewCompat.setOnApplyWindowInsetsListener(view) { v, insets ->
+            publishKeyboard(v, insets)
+            insets
+        }
+        view.addOnLayoutChangeListener { v, _, _, _, _, _, _, _, _ ->
+            ViewCompat.getRootWindowInsets(v)?.let { publishKeyboard(v, it) }
+        }
+        return view
+    }
+
+    private fun publishKeyboard(view: View, insets: WindowInsetsCompat) {
+        val density = PNBridge.density()
+        val ime = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom
+        val bars = insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom
+        val height = max(0, ime - bars) / density
+        val last = stateOf(view)["keyboard_height"] as? Double
+        if (last != null && last == height.toDouble()) return
+        stateOf(view)["keyboard_height"] = height.toDouble()
+        ModuleEvents.emit("Host", "keyboard", JSONObject().put("height", height.toDouble()))
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/ControlManagers.kt

@@ -0,0 +1,186 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.view.View
+import android.widget.CheckBox
+import android.widget.CompoundButton
+import android.widget.ProgressBar
+import android.widget.SeekBar
+import android.widget.Switch
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/** Base for `CompoundButton` widgets: `on_change` wiring with a suppress guard. */
+abstract class CheckedManager : ComponentManager() {
+    protected fun bindChecked(button: CompoundButton) {
+        button.setOnCheckedChangeListener { b, checked ->
+            if (stateOf(b)["suppress"] == true) return@setOnCheckedChangeListener
+            fire(b, "on_change", checked)
+        }
+    }
+}
+
+/** `Switch` element. */
+class SwitchManager : CheckedManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val sw = Switch(context)
+        bindChecked(sw)
+        return sw
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val sw = view as Switch
+        if (props.has("value")) {
+            val state = stateOf(sw)
+            state["suppress"] = true
+            try {
+                sw.isChecked = JsonUtil.truthy(props.value("value"))
+            } finally {
+                state["suppress"] = false
+            }
+        }
+        if (props.has("disabled")) sw.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+        if (props.has("enabled")) sw.isEnabled = JsonUtil.truthy(props.value("enabled"))
+        PNColor.parse(props.value("on_tint_color") ?: props.value("tint_color"))?.let {
+            sw.thumbTintList = ColorStateList(
+                arrayOf(intArrayOf(android.R.attr.state_checked), intArrayOf()),
+                intArrayOf(it, 0xFFFAFAFA.toInt()),
+            )
+            sw.trackTintList = ColorStateList(
+                arrayOf(intArrayOf(android.R.attr.state_checked), intArrayOf()),
+                intArrayOf(PNColor.withAlpha(it, 0.5), 0x61000000),
+            )
+        }
+        PNColor.parse(props.value("thumb_color"))?.let { sw.thumbTintList = ColorStateList.valueOf(it) }
+        ViewStyler.applyAccessibility(sw, props)
+    }
+}
+
+/** `Checkbox` element with an optional inline label. */
+class CheckboxManager : CheckedManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val cb = CheckBox(context)
+        bindChecked(cb)
+        return cb
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val cb = view as CheckBox
+        if (props.has("label")) cb.text = props.str("label") ?: ""
+        if (props.has("value")) {
+            val state = stateOf(cb)
+            state["suppress"] = true
+            try {
+                cb.isChecked = JsonUtil.truthy(props.value("value"))
+            } finally {
+                state["suppress"] = false
+            }
+        }
+        if (props.has("disabled")) cb.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+        PNColor.parse(props.value("color"))?.let { cb.buttonTintList = ColorStateList.valueOf(it) }
+        ViewStyler.applyAccessibility(cb, props)
+    }
+}
+
+/** `ProgressBar` element: a horizontal determinate bar with a 0..1 `value`. */
+class ProgressBarManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val pb = ProgressBar(context, null, android.R.attr.progressBarStyleHorizontal)
+        pb.max = 1000
+        return pb
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val pb = view as ProgressBar
+        props.num("value")?.let { pb.progress = (it.coerceIn(0.0, 1.0) * 1000).toInt() }
+        PNColor.parse(props.value("color"))?.let { pb.progressTintList = ColorStateList.valueOf(it) }
+        PNColor.parse(props.value("track_color"))?.let {
+            val track = ColorStateList.valueOf(it)
+            pb.progressBackgroundTintList = track
+            pb.secondaryProgressTintList = track
+        }
+        if (props.has("indeterminate")) pb.isIndeterminate = JsonUtil.truthy(props.value("indeterminate"))
+        ViewStyler.apply(pb, props)
+    }
+}
+
+/** `ActivityIndicator` element: an indeterminate spinner. */
+class ActivityIndicatorManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = ProgressBar(context)
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val pb = view as ProgressBar
+        if (props.has("animating")) {
+            pb.visibility = if (JsonUtil.truthy(props.value("animating"))) View.VISIBLE else View.GONE
+        }
+        if (props.has("hides_when_stopped") && !JsonUtil.truthy(props.value("hides_when_stopped"))) {
+            pb.visibility = View.VISIBLE
+        }
+        PNColor.parse(props.value("color"))?.let { pb.indeterminateTintList = ColorStateList.valueOf(it) }
+        props.str("size")?.let {
+            // The framework ProgressBar has no runtime size switch; scale "large".
+            val scale = if (it == "large") 1.5f else 1f
+            pb.scaleX = scale
+            pb.scaleY = scale
+        }
+        ViewStyler.apply(pb, props)
+    }
+}
+
+/** `Slider` element: a `SeekBar` mapped onto `min_value..max_value`. */
+class SliderManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val sb = SeekBar(context)
+        sb.max = 1000
+        sb.setOnSeekBarChangeListener(object : SeekBar.OnSeekBarChangeListener {
+            override fun onProgressChanged(seekBar: SeekBar, progress: Int, fromUser: Boolean) {
+                if (!fromUser) return
+                fire(seekBar, "on_change", valueFor(seekBar, progress))
+            }
+
+            override fun onStartTrackingTouch(seekBar: SeekBar) {
+                fire(seekBar, "on_sliding_start", valueFor(seekBar, seekBar.progress))
+            }
+
+            override fun onStopTrackingTouch(seekBar: SeekBar) {
+                fire(seekBar, "on_sliding_complete", valueFor(seekBar, seekBar.progress))
+            }
+        })
+        return sb
+    }
+
+    private fun range(view: View): Pair<Double, Double> {
+        val merged = propsOf(view)
+        val mn = merged.num("min_value") ?: merged.num("minimum_value") ?: 0.0
+        val mx = merged.num("max_value") ?: merged.num("maximum_value") ?: 1.0
+        return Pair(mn, mx)
+    }
+
+    private fun valueFor(view: View, progress: Int): Double {
+        val (mn, mx) = range(view)
+        val span = if (mx != mn) mx - mn else 1.0
+        var value = mn + (progress / 1000.0) * span
+        propsOf(view).num("step")?.takeIf { it > 0 }?.let { step ->
+            value = mn + Math.round((value - mn) / step) * step
+        }
+        return value
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val sb = view as SeekBar
+        val (mn, mx) = range(sb)
+        val span = if (mx != mn) mx - mn else 1.0
+        props.num("value")?.let { sb.progress = (((it - mn) / span) * 1000).toInt().coerceIn(0, 1000) }
+        if (props.has("disabled")) sb.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+        PNColor.parse(props.value("minimum_track_tint_color") ?: props.value("tint_color"))?.let {
+            sb.progressTintList = ColorStateList.valueOf(it)
+        }
+        PNColor.parse(props.value("maximum_track_tint_color"))?.let { sb.progressBackgroundTintList = ColorStateList.valueOf(it) }
+        PNColor.parse(props.value("thumb_tint_color"))?.let { sb.thumbTintList = ColorStateList.valueOf(it) }
+        ViewStyler.applyAccessibility(sb, props)
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/DatePickerManager.kt

@@ -0,0 +1,123 @@
+package com.pythonnative.runtime.components
+
+import android.app.DatePickerDialog
+import android.app.TimePickerDialog
+import android.content.Context
+import android.view.View
+import android.widget.Button
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Calendar
+import java.util.Locale
+
+/**
+ * `DatePicker` element: a trigger `Button` opening the native
+ * `DatePickerDialog` (`mode` `"date"`), `TimePickerDialog` (`"time"`),
+ * or a chained date-then-time flow (`"datetime"`). Values are ISO
+ * strings; the confirmed value is reported through `on_change`.
+ */
+class DatePickerManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val btn = Button(context)
+        btn.isAllCaps = false
+        btn.setOnClickListener { v ->
+            if (propsOf(v).value("disabled") == true) return@setOnClickListener
+            openDialog(v as Button)
+        }
+        return btn
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val btn = view as Button
+        if (props.has("disabled")) btn.isEnabled = props.value("disabled") != true
+        if (props.has("value") || props.has("mode") || initial) refreshLabel(btn)
+        ViewStyler.applyAccessibility(btn, props)
+    }
+
+    private fun mode(btn: Button): String = propsOf(btn).str("mode") ?: "date"
+
+    private fun refreshLabel(btn: Button) {
+        val value = propsOf(btn).str("value")
+        btn.text = if (!value.isNullOrEmpty()) value else PLACEHOLDERS[mode(btn)] ?: "Select"
+    }
+
+    private fun openDialog(btn: Button) {
+        val mode = mode(btn)
+        val cal = parse(propsOf(btn).str("value"), mode)
+        when (mode) {
+            "time" -> openTime(btn, cal)
+            "datetime" -> openDate(btn, cal, thenTime = true)
+            else -> openDate(btn, cal, thenTime = false)
+        }
+    }
+
+    private fun openDate(btn: Button, cal: Calendar, thenTime: Boolean) {
+        val dialog = DatePickerDialog(
+            btn.context,
+            { _, year, month, day ->
+                cal.set(Calendar.YEAR, year)
+                cal.set(Calendar.MONTH, month)
+                cal.set(Calendar.DAY_OF_MONTH, day)
+                if (thenTime) openTime(btn, cal) else commit(btn, cal)
+            },
+            cal.get(Calendar.YEAR),
+            cal.get(Calendar.MONTH),
+            cal.get(Calendar.DAY_OF_MONTH),
+        )
+        try {
+            val merged = propsOf(btn)
+            merged.str("minimum")?.takeIf { it.isNotEmpty() }?.let { dialog.datePicker.minDate = parse(it, mode(btn)).timeInMillis }
+            merged.str("maximum")?.takeIf { it.isNotEmpty() }?.let { dialog.datePicker.maxDate = parse(it, mode(btn)).timeInMillis }
+        } catch (e: Exception) {
+            PNLog.swallowed("DatePickerManager.minMax", e)
+        }
+        dialog.show()
+    }
+
+    private fun openTime(btn: Button, cal: Calendar) {
+        TimePickerDialog(
+            btn.context,
+            { _, hour, minute ->
+                cal.set(Calendar.HOUR_OF_DAY, hour)
+                cal.set(Calendar.MINUTE, minute)
+                commit(btn, cal)
+            },
+            cal.get(Calendar.HOUR_OF_DAY),
+            cal.get(Calendar.MINUTE),
+            true,
+        ).show()
+    }
+
+    private fun format(mode: String): SimpleDateFormat = SimpleDateFormat(PATTERNS[mode] ?: PATTERNS["date"]!!, Locale.US)
+
+    private fun parse(value: String?, mode: String): Calendar {
+        val cal = Calendar.getInstance()
+        if (!value.isNullOrEmpty()) {
+            try {
+                format(mode).parse(value)?.let { cal.time = it }
+            } catch (e: Exception) {
+                PNLog.swallowed("DatePickerManager.parse", e)
+            }
+        }
+        return cal
+    }
+
+    private fun commit(btn: Button, cal: Calendar) {
+        val iso = try {
+            format(mode(btn)).format(cal.time)
+        } catch (e: Exception) {
+            return
+        }
+        propsOf(btn).put("value", iso)
+        btn.text = iso
+        fire(btn, "on_change", iso)
+    }
+
+    private companion object {
+        val PATTERNS = mapOf("date" to "yyyy-MM-dd", "time" to "HH:mm", "datetime" to "yyyy-MM-dd'T'HH:mm")
+        val PLACEHOLDERS = mapOf("date" to "Select date", "time" to "Select time", "datetime" to "Select date & time")
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/ImageLoader.kt

@@ -0,0 +1,141 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.LruCache
+import com.pythonnative.runtime.bridge.MainThread
+import java.io.File
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+import java.util.concurrent.Executors
+import kotlin.math.max
+
+/**
+ * Image fetching and decoding for the `Image` manager.
+ *
+ * Remote images are downloaded on a small background pool into a disk
+ * cache under `cacheDir/pn_images` (keyed by the SHA-256 of the URL),
+ * decoded with `inSampleSize` downsampling to the target size, and kept
+ * in a memory `LruCache`. Callbacks run on the main thread.
+ */
+object ImageLoader {
+    private val executor = Executors.newFixedThreadPool(3) { runnable ->
+        Thread(runnable, "pn-image").apply { isDaemon = true }
+    }
+
+    private val memory: LruCache<String, Bitmap> by lazy {
+        val maxKb = (Runtime.getRuntime().maxMemory() / 1024L).toInt()
+        object : LruCache<String, Bitmap>(max(4 * 1024, maxKb / 8)) {
+            override fun sizeOf(key: String, value: Bitmap): Int = max(1, value.byteCount / 1024)
+        }
+    }
+
+    /** Result callback: exactly one of `bitmap` or `error` is non-null. */
+    fun interface Callback {
+        fun onResult(bitmap: Bitmap?, error: String?)
+    }
+
+    /** Load `url` (http/https) into a bitmap sized for `targetW` x `targetH` pixels. */
+    fun loadRemote(context: Context, url: String, targetW: Int, targetH: Int, callback: Callback) {
+        val key = "$url@$targetW"
+        memory.get(key)?.let {
+            callback.onResult(it, null)
+            return
+        }
+        val cacheDir = File(context.cacheDir, "pn_images")
+        executor.execute {
+            try {
+                val file = cachedFile(cacheDir, url)
+                if (!file.exists() || file.length() == 0L) download(url, file)
+                val bitmap = decodeDownsampled(file.absolutePath, targetW, targetH)
+                if (bitmap == null) {
+                    file.delete()
+                    deliver(callback, null, "decode failed")
+                } else {
+                    memory.put(key, bitmap)
+                    deliver(callback, bitmap, null)
+                }
+            } catch (e: Exception) {
+                deliver(callback, null, e.message ?: e.javaClass.simpleName)
+            }
+        }
+    }
+
+    /** Decode a local file on a background thread. */
+    fun loadFile(path: String, targetW: Int, targetH: Int, callback: Callback) {
+        executor.execute {
+            val bitmap = try {
+                decodeDownsampled(path, targetW, targetH)
+            } catch (e: Exception) {
+                null
+            }
+            deliver(callback, bitmap, if (bitmap == null) "decode failed" else null)
+        }
+    }
+
+    /** Decode `path` with `inSampleSize` chosen so the result still covers the target. */
+    fun decodeDownsampled(path: String, targetW: Int, targetH: Int): Bitmap? {
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeFile(path, bounds)
+        val srcW = bounds.outWidth
+        val srcH = bounds.outHeight
+        if (srcW <= 0 || srcH <= 0) return null
+        var tw = if (targetW > 0) targetW else srcW
+        var th = if (targetH > 0) targetH else tw
+        if (tw <= 0) tw = srcW
+        if (th <= 0) th = srcH
+        var sample = 1
+        while (srcW / (sample * 2) >= tw && srcH / (sample * 2) >= th) sample *= 2
+        val opts = BitmapFactory.Options().apply { inSampleSize = sample }
+        return BitmapFactory.decodeFile(path, opts)
+    }
+
+    private fun cachedFile(dir: File, url: String): File {
+        if (!dir.exists()) dir.mkdirs()
+        val digest = MessageDigest.getInstance("SHA-256").digest(url.toByteArray(Charsets.UTF_8))
+        val hex = digest.joinToString("") { String.format("%02x", it) }
+        val path = url.substringBefore('?').substringBefore('#')
+        val ext = path.substringAfterLast('.', "").takeIf { it.length in 1..5 && it.all { c -> c.isLetterOrDigit() } }
+        return File(dir, if (ext != null) "$hex.$ext" else hex)
+    }
+
+    private fun download(url: String, target: File) {
+        var current = url
+        var redirects = 0
+        while (true) {
+            val connection = URL(current).openConnection() as HttpURLConnection
+            connection.connectTimeout = 15_000
+            connection.readTimeout = 30_000
+            connection.instanceFollowRedirects = true
+            connection.setRequestProperty("User-Agent", "PythonNative/Android")
+            try {
+                val code = connection.responseCode
+                if (code in 300..399 && redirects < 5) {
+                    val location = connection.getHeaderField("Location") ?: throw IllegalStateException("redirect without Location")
+                    current = URL(URL(current), location).toString()
+                    redirects++
+                    continue
+                }
+                if (code !in 200..299) throw IllegalStateException("HTTP $code")
+                val tmp = File(target.parentFile, target.name + ".part")
+                connection.inputStream.use { input ->
+                    FileOutputStream(tmp).use { output -> input.copyTo(output) }
+                }
+                if (!tmp.renameTo(target)) {
+                    tmp.copyTo(target, overwrite = true)
+                    tmp.delete()
+                }
+                return
+            } finally {
+                connection.disconnect()
+            }
+        }
+    }
+
+    private fun deliver(callback: Callback, bitmap: Bitmap?, error: String?) {
+        MainThread.post { callback.onResult(bitmap, error) }
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/components/ImageManager.kt

@@ -0,0 +1,162 @@
+package com.pythonnative.runtime.components
+
+import com.pythonnative.runtime.PNBridge
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.BitmapFactory
+import android.util.Base64
+import android.view.View
+import android.widget.ImageView
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/**
+ * `Image` element. Sources: `http(s)` URLs (downloaded and cached by
+ * [ImageLoader]), absolute file paths, drawable resource names, and
+ * base64 `data:` URIs. Fires `on_load` / `on_error`.
+ */
+class ImageManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = ImageView(context)
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val iv = view as ImageView
+        PNColor.parse(props.value("tint_color"))?.let { iv.imageTintList = ColorStateList.valueOf(it) }
+        if (props.has("tint_color") && props.value("tint_color") == null) iv.imageTintList = null
+        PNColor.parse(props.value("placeholder_color"))?.let { iv.setBackgroundColor(it) }
+        if (props.has("source")) {
+            val source = sourceString(props.value("source"))
+            if (source != null) loadSource(iv, source) else iv.setImageDrawable(null)
+        }
+        val mode = props.str("resize_mode") ?: props.str("scale_type")
+        if (mode != null) {
+            iv.scaleType = when (mode) {
+                "cover" -> ImageView.ScaleType.CENTER_CROP
+                "contain" -> ImageView.ScaleType.FIT_CENTER
+                "stretch" -> ImageView.ScaleType.FIT_XY
+                "center", "repeat" -> ImageView.ScaleType.CENTER
+                else -> iv.scaleType
+            }
+        }
+        ViewStyler.apply(iv, props)
+    }
+
+    private fun sourceString(value: Any?): String? {
+        return when (value) {
+            null -> null
+            is JSONObject -> value.str("uri") ?: value.str("url") ?: value.str("path")
+            else -> value.toString().takeIf { it.isNotEmpty() }
+        }
+    }
+
+    private fun loadSource(iv: ImageView, source: String) {
+        val state = stateOf(iv)
+        state["pending_uri"] = source
+        try {
+            when {
+                source.startsWith("data:") -> loadDataUri(iv, source)
+                source.startsWith("http://") || source.startsWith("https://") -> {
+                    val (tw, th) = targetSize(iv)
+                    ImageLoader.loadRemote(iv.context, source, tw, th) { bitmap, error ->
+                        if (stateOf(iv)["pending_uri"] != source) return@loadRemote
+                        if (bitmap != null) {
+                            iv.setImageBitmap(bitmap)
+                            fire(iv, "on_load")
+                            PNBridge.registry.tagOf(iv)?.let { com.pythonnative.runtime.layout.NativeLayout.invalidate(it) }
+                        } else {
+                            fire(iv, "on_error", error ?: "load failed")
+                        }
+                    }
+                }
+                source.startsWith("/") || source.startsWith("file://") -> {
+                    val path = source.removePrefix("file://")
+                    val (tw, th) = targetSize(iv)
+                    ImageLoader.loadFile(path, tw, th) { bitmap, error ->
+                        if (stateOf(iv)["pending_uri"] != source) return@loadFile
+                        if (bitmap != null) {
+                            iv.setImageBitmap(bitmap)
+                            fire(iv, "on_load")
+                            PNBridge.registry.tagOf(iv)?.let { com.pythonnative.runtime.layout.NativeLayout.invalidate(it) }
+                        } else {
+                            fire(iv, "on_error", error ?: "decode failed")
+                        }
+                    }
+                }
+                else -> {
+                    val ctx = iv.context
+                    val name = source.substringBeforeLast('.', source)
+                    val resId = ctx.resources.getIdentifier(name, "drawable", ctx.packageName)
+                        .takeIf { it != 0 }
+                        ?: ctx.resources.getIdentifier(name, "mipmap", ctx.packageName)
+                    if (resId != 0) {
+                        iv.setImageResource(resId)
+                        fire(iv, "on_load")
+                            PNBridge.registry.tagOf(iv)?.let { com.pythonnative.runtime.layout.NativeLayout.invalidate(it) }
+                    } else {
+                        fire(iv, "on_error", "drawable '$name' not found")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            PNLog.swallowed("ImageManager.loadSource", e)
+            fire(iv, "on_error", e.message ?: "load failed")
+        }
+    }
+
+    private fun loadDataUri(iv: ImageView, source: String) {
+        try {
+            val payload = source.substringAfter(',', "")
+            val raw = Base64.decode(payload, Base64.DEFAULT)
+            val bitmap = BitmapFactory.decodeByteArray(raw, 0, raw.size)
+            if (bitmap != null) {
+                iv.setImageBitmap(bitmap)
+                fire(iv, "on_load")
+                            PNBridge.registry.tagOf(iv)?.let { com.pythonnative.runtime.layout.NativeLayout.invalidate(it) }
+            } else {
+                fire(iv, "on_error", "data URI decode failed")
+            }
+        } catch (e: Exception) {
+            fire(iv, "on_error", "data URI decode failed")
+        }
+    }
+
+    private fun targetSize(iv: ImageView): Pair<Int, Int> {
+        var w = iv.width
+        var h = iv.height
+        val frame = recordOf(iv)?.frame
+        if (w <= 0 && frame != null) {
+            w = px(frame[2])
+            h = px(frame[3])
+        }
+        if (w <= 0) {
+            val metrics = iv.context.resources.displayMetrics
+            w = metrics.widthPixels
+            h = metrics.heightPixels
+        }
+        if (h <= 0) h = w
+        return Pair(w, h)
+    }
+
+    override fun measure(view: View, maxWidth: Double, maxHeight: Double): FloatArray {
+        val iv = view as ImageView
+        val drawable = iv.drawable ?: return floatArrayOf(0f, 0f)
+        val density = view.context.resources.displayMetrics.density
+        // Bitmaps decode at device density, so their pixel size is already a dp-ish measure.
+        var w = drawable.intrinsicWidth / density
+        var h = drawable.intrinsicHeight / density
+        if (w <= 0f || h <= 0f) return floatArrayOf(0f, 0f)
+        val maxW = if (maxWidth.isFinite() && maxWidth < 1e6) maxWidth.toFloat() else Float.MAX_VALUE
+        val maxH = if (maxHeight.isFinite() && maxHeight < 1e6) maxHeight.toFloat() else Float.MAX_VALUE
+        if (w > maxW) {
+            h *= maxW / w
+            w = maxW
+        }
+        if (h > maxH) {
+            w *= maxH / h
+            h = maxH
+        }
+        return floatArrayOf(w, h)
+    }
+}