pythonnative 0.40.0__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,355 @@
+package com.pythonnative.runtime.components
+
+import android.graphics.Rect
+import android.graphics.drawable.GradientDrawable
+import android.os.Build
+import android.view.TouchDelegate
+import android.view.View
+import android.view.ViewGroup
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.ViewRecord
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.obj
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import com.pythonnative.runtime.views.PNAccessibilityDelegate
+import com.pythonnative.runtime.views.PNBorderDrawable
+import com.pythonnative.runtime.views.PNFrameLayout
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.math.roundToInt
+
+/**
+ * Applies the visual props every element supports: background and
+ * borders, opacity, overflow, display, z-order, pointer events, hit
+ * slop, shadows, transforms, and accessibility.
+ *
+ * Border-related props are baked into a single background drawable,
+ * so the styler keeps the merged "visual" subset per view and re-bakes
+ * it whenever one of those keys changes.
+ */
+object ViewStyler {
+    private val sideWidthKeys = listOf("border_left_width", "border_top_width", "border_right_width", "border_bottom_width")
+    private val sideColorKeys = listOf("border_left_color", "border_top_color", "border_right_color", "border_bottom_color")
+    // Order matches GradientDrawable.setCornerRadii: TL, TR, BR, BL.
+    private val cornerKeys = listOf(
+        "border_top_left_radius", "border_top_right_radius", "border_bottom_right_radius", "border_bottom_left_radius",
+    )
+    private val drawableKeys: List<String> =
+        listOf("background_color", "border_radius", "border_width", "border_color") + cornerKeys + sideWidthKeys + sideColorKeys
+
+    private fun density(): Float = PNBridge.density()
+    private fun px(dp: Double): Float = (dp * density()).toFloat()
+    private fun pxI(dp: Double): Int = (dp * density()).roundToInt()
+
+    private fun record(view: View): ViewRecord? = PNBridge.registry.recordFor(view)
+
+    /** Apply the common visual props present in `props` to `view`. */
+    fun apply(view: View, props: JSONObject) {
+        val record = record(view)
+        if (drawableKeys.any { props.has(it) }) {
+            val visual = visualProps(record)
+            for (key in drawableKeys) {
+                if (props.has(key)) visual.put(key, props.opt(key) ?: JSONObject.NULL)
+            }
+            applyBorder(view, visual)
+        }
+        if (props.has("overflow")) {
+            val clip = props.str("overflow") == "hidden"
+            if (view is ViewGroup) {
+                view.clipChildren = clip
+                view.clipToPadding = clip
+            }
+        }
+        if (props.has("display")) {
+            view.visibility = if (props.str("display") == "none") View.GONE else View.VISIBLE
+        }
+        props.num("opacity")?.let { view.alpha = it.toFloat() }
+        if (props.has("z_index")) {
+            val z = props.num("z_index")
+            view.z = if (z != null) px(z) else 0f
+        }
+        if (props.has("pointer_events")) applyPointerEvents(view, props.str("pointer_events"))
+        if (props.has("hit_slop")) updateHitSlop(view)
+        applyShadow(view, props)
+        applyTransform(view, props)
+        applyAccessibility(view, props)
+    }
+
+    private fun visualProps(record: ViewRecord?): JSONObject {
+        val existing = record?.state?.get("visual") as? JSONObject
+        if (existing != null) return existing
+        val fresh = JSONObject()
+        record?.state?.put("visual", fresh)
+        return fresh
+    }
+
+    // ------------------------------------------------------------------
+    // Background and borders
+    // ------------------------------------------------------------------
+
+    /** Re-bake the background drawable from the merged visual props. */
+    fun applyBorder(view: View, visual: JSONObject) {
+        if (applySideBorder(view, visual)) return
+        val hasBorder = listOf("border_radius", "border_width", "border_color").any { visual.has(it) } ||
+            cornerKeys.any { visual.has(it) }
+        val hasBg = visual.value("background_color") != null
+        if (!hasBorder && !hasBg) {
+            if (view.background is GradientDrawable || view.background is PNBorderDrawable) view.background = null
+            return
+        }
+        val drawable = GradientDrawable()
+        PNColor.parse(visual.value("background_color"))?.let { drawable.setColor(it) }
+        if (cornerKeys.any { visual.value(it) != null }) {
+            val base = visual.num("border_radius") ?: 0.0
+            val radii = FloatArray(8)
+            for ((i, key) in cornerKeys.withIndex()) {
+                val r = px(visual.num(key) ?: base)
+                radii[i * 2] = r
+                radii[i * 2 + 1] = r
+            }
+            drawable.cornerRadii = radii
+        } else {
+            visual.num("border_radius")?.let { drawable.cornerRadius = px(it) }
+        }
+        if (visual.value("border_width") != null || visual.value("border_color") != null) {
+            val width = visual.num("border_width") ?: 1.0
+            val color = PNColor.parseOr(visual.value("border_color"), 0xFF000000.toInt())
+            drawable.setStroke(pxI(width), color)
+        }
+        view.background = drawable
+        view.invalidate()
+    }
+
+    private fun applySideBorder(view: View, visual: JSONObject): Boolean {
+        if (sideWidthKeys.none { visual.value(it) != null }) return false
+        val baseWidth = visual.num("border_width") ?: 0.0
+        val baseColor = visual.value("border_color") ?: "#000000"
+        val widths = FloatArray(4) { i -> px(visual.num(sideWidthKeys[i]) ?: baseWidth) }
+        val colors = IntArray(4) { i -> PNColor.parseOr(visual.value(sideColorKeys[i]) ?: baseColor, 0xFF000000.toInt()) }
+        val bg = PNColor.parse(visual.value("background_color"))
+        val radius = px(visual.num("border_radius") ?: 0.0)
+        view.background = PNBorderDrawable(bg != null, bg ?: 0, radius, widths, colors)
+        view.invalidate()
+        return true
+    }
+
+    /**
+     * Apply one animated `background_color` frame without losing borders:
+     * mutate the existing drawable's fill in place when possible.
+     */
+    fun setAnimatedBackground(view: View, value: Any?) {
+        val color = PNColor.parse(value) ?: return
+        val record = record(view)
+        val visual = record?.state?.get("visual") as? JSONObject
+        val hasBorder = visual != null && drawableKeys.any { it != "background_color" && visual.value(it) != null }
+        if (hasBorder && visual != null) {
+            visual.put("background_color", String.format("#%08X", color))
+            when (val bg = view.background) {
+                is GradientDrawable -> bg.setColor(color)
+                is PNBorderDrawable -> bg.setFillColor(color)
+                else -> applyBorder(view, visual)
+            }
+            return
+        }
+        view.setBackgroundColor(color)
+    }
+
+    // ------------------------------------------------------------------
+    // Shadow / elevation
+    // ------------------------------------------------------------------
+
+    private fun applyShadow(view: View, props: JSONObject) {
+        var elevation = props.num("elevation")
+        if (elevation == null && props.has("shadow_radius")) elevation = props.num("shadow_radius")
+        if (elevation == null && (props.value("shadow_color") != null || props.value("shadow_opacity") != null)) {
+            // Shadow requested without an explicit size: Material card-like default.
+            elevation = 4.0
+        }
+        if (elevation == null) return
+        view.elevation = px(elevation)
+        val color = props.value("shadow_color") ?: return
+        if (Build.VERSION.SDK_INT < 28) return
+        var argb = PNColor.parse(color) ?: return
+        props.num("shadow_opacity")?.let { argb = PNColor.withAlpha(argb, it) }
+        view.outlineAmbientShadowColor = argb
+        view.outlineSpotShadowColor = argb
+    }
+
+    // ------------------------------------------------------------------
+    // Transform
+    // ------------------------------------------------------------------
+
+    private fun applyTransform(view: View, props: JSONObject) {
+        if (!props.has("transform")) return
+        val spec = props.value("transform")
+        if (spec == null) {
+            view.rotation = 0f
+            view.rotationX = 0f
+            view.rotationY = 0f
+            view.scaleX = 1f
+            view.scaleY = 1f
+            view.translationX = 0f
+            view.translationY = 0f
+            return
+        }
+        val entries: List<Any?> = when (spec) {
+            is JSONArray -> JsonUtil.toList(spec)
+            else -> listOf(spec)
+        }
+        for (entry in entries) {
+            val e = entry as? JSONObject ?: continue
+            try {
+                if (e.has("rotate")) view.rotation = angleDegrees(e.value("rotate"))
+                if (e.has("rotate_x")) view.rotationX = angleDegrees(e.value("rotate_x"))
+                if (e.has("rotate_y")) view.rotationY = angleDegrees(e.value("rotate_y"))
+                if (e.has("rotate_z")) view.rotation = angleDegrees(e.value("rotate_z"))
+                e.num("scale")?.let { view.scaleX = it.toFloat(); view.scaleY = it.toFloat() }
+                e.num("scale_x")?.let { view.scaleX = it.toFloat() }
+                e.num("scale_y")?.let { view.scaleY = it.toFloat() }
+                e.num("translate_x")?.let { view.translationX = px(it) }
+                e.num("translate_y")?.let { view.translationY = px(it) }
+                if (e.has("skew_x") || e.has("skew_y")) {
+                    // Android views have no skew transform; approximate with rotation around the axis.
+                    PNLog.once("skew", "transform skew_x/skew_y is not supported on Android and is ignored")
+                }
+            } catch (ex: Exception) {
+                PNLog.swallowed("ViewStyler.applyTransform", ex)
+            }
+        }
+    }
+
+    /** Parse `"45deg"`, `"0.5rad"`, or a bare number (degrees) into degrees. */
+    fun angleDegrees(value: Any?): Float {
+        return when (value) {
+            is Number -> value.toFloat()
+            is String -> {
+                val s = value.trim()
+                when {
+                    s.endsWith("deg") -> s.dropLast(3).toFloatOrNull() ?: 0f
+                    s.endsWith("rad") -> Math.toDegrees((s.dropLast(3).toDoubleOrNull() ?: 0.0)).toFloat()
+                    else -> s.toFloatOrNull() ?: 0f
+                }
+            }
+            else -> 0f
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Accessibility
+    // ------------------------------------------------------------------
+
+    /** Apply accessibility props (label / accessible / state / live region / role / test_id). */
+    fun applyAccessibility(view: View, props: JSONObject) {
+        if (props.has("accessible")) {
+            view.importantForAccessibility = if (JsonUtil.truthy(props.value("accessible"))) {
+                View.IMPORTANT_FOR_ACCESSIBILITY_YES
+            } else {
+                View.IMPORTANT_FOR_ACCESSIBILITY_NO
+            }
+        }
+        if (props.has("accessibility_label")) {
+            view.contentDescription = props.str("accessibility_label")
+        }
+        if (props.has("accessibility_hint") && Build.VERSION.SDK_INT >= 28) {
+            view.tooltipText = props.str("accessibility_hint")
+        }
+        if (props.has("accessibility_live_region")) {
+            view.accessibilityLiveRegion = when (props.str("accessibility_live_region")?.lowercase()) {
+                "polite" -> View.ACCESSIBILITY_LIVE_REGION_POLITE
+                "assertive" -> View.ACCESSIBILITY_LIVE_REGION_ASSERTIVE
+                else -> View.ACCESSIBILITY_LIVE_REGION_NONE
+            }
+        }
+        val state = props.obj("accessibility_state")
+        if (state != null && state.has("selected")) {
+            view.isSelected = JsonUtil.truthy(state.value("selected"))
+        }
+        val testId = props.str("test_id")
+        val role = props.str("accessibility_role")
+        if (testId == null && state == null && role == null) return
+        val record = record(view)
+        var delegate = record?.state?.get("a11y_delegate") as? PNAccessibilityDelegate
+        if (delegate == null) {
+            delegate = PNAccessibilityDelegate()
+            view.accessibilityDelegate = delegate
+            record?.state?.put("a11y_delegate", delegate)
+        }
+        if (testId != null) {
+            delegate.testId = testId
+            view.tag = testId
+        }
+        if (role != null) delegate.role = role
+        if (state != null) {
+            delegate.stateDisabled = optBool(state, "disabled")
+            delegate.stateSelected = optBool(state, "selected")
+            delegate.stateChecked = optBool(state, "checked")
+            delegate.stateBusy = optBool(state, "busy")
+            delegate.stateExpanded = optBool(state, "expanded")
+        }
+    }
+
+    private fun optBool(obj: JSONObject, key: String): Boolean? {
+        val v = obj.value(key) ?: return null
+        return JsonUtil.truthy(v)
+    }
+
+    // ------------------------------------------------------------------
+    // Pointer events and hit slop
+    // ------------------------------------------------------------------
+
+    /** Whether `pointer_events` disables the view's own touch handling. */
+    fun pointerEventsBlocked(view: View): Boolean {
+        val mode = record(view)?.props?.str("pointer_events") ?: return false
+        return mode == "none" || mode == "box_none"
+    }
+
+    private fun applyPointerEvents(view: View, value: String?) {
+        val mode = value ?: "auto"
+        val state = record(view)?.state
+        (view as? PNFrameLayout)?.setPointerEventsMode(mode)
+        when (mode) {
+            "none", "box_none" -> {
+                state?.let { if (!it.containsKey("pe_was_clickable")) it["pe_was_clickable"] = view.isClickable }
+                view.isClickable = false
+            }
+            "box_only" -> {
+                state?.let { if (!it.containsKey("pe_was_clickable")) it["pe_was_clickable"] = view.isClickable }
+                view.isClickable = true
+            }
+            else -> {
+                val was = state?.remove("pe_was_clickable") as? Boolean
+                if (was != null) view.isClickable = was
+            }
+        }
+    }
+
+    private fun hitSlopInsets(value: Any?): DoubleArray? {
+        return when (value) {
+            null, JSONObject.NULL -> null
+            is JSONObject -> doubleArrayOf(
+                value.num("top") ?: 0.0, value.num("left") ?: 0.0, value.num("bottom") ?: 0.0, value.num("right") ?: 0.0,
+            )
+            else -> JsonUtil.toDoubleOrNull(value)?.let { doubleArrayOf(it, it, it, it) }
+        }
+    }
+
+    /** Extend the view's touch target via a `TouchDelegate` on its parent (needs a frame). */
+    fun updateHitSlop(view: View) {
+        val record = record(view) ?: return
+        val frame = record.frame ?: return
+        val insets = hitSlopInsets(record.props.value("hit_slop"))
+        val parent = view.parent as? ViewGroup ?: return
+        if (insets == null) {
+            if (record.state.remove("hit_slop_active") != null) parent.touchDelegate = null
+            return
+        }
+        val (top, left, bottom, right) = insets
+        val (x, y, w, h) = frame
+        val rect = Rect(pxI(x - left), pxI(y - top), pxI(x + w + right), pxI(y + h + bottom))
+        parent.touchDelegate = TouchDelegate(rect, view)
+        record.state["hit_slop_active"] = true
+    }
+}

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

@@ -0,0 +1,159 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.LinearLayoutManager
+import androidx.recyclerview.widget.ListAdapter
+import androidx.recyclerview.widget.RecyclerView
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.ViewRecord
+import org.json.JSONObject
+import kotlin.math.roundToInt
+
+/** Keyed native recycling; Python prepares logical children asynchronously. */
+class VirtualListManager : ComponentManager() {
+    private data class Item(val key: String, val revision: Int, val estimate: Double)
+    private class Holder(val container: FrameLayout) : RecyclerView.ViewHolder(container) { var key = "" }
+    private inner class ListView(context: Context) : SwipeRefreshLayout(context) {
+        val recycler = RecyclerView(context)
+        val roots = HashMap<String, View>()
+        val heights = HashMap<String, Double>()
+        val holders = HashMap<String, Holder>()
+        var horizontal = false
+        val manager = LinearLayoutManager(context)
+        val rows = object : ListAdapter<Item, Holder>(object : DiffUtil.ItemCallback<Item>() {
+            override fun areItemsTheSame(a: Item, b: Item) = a.key == b.key
+            override fun areContentsTheSame(a: Item, b: Item) = a == b
+        }) {
+            override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): Holder = Holder(FrameLayout(context))
+            override fun onBindViewHolder(holder: Holder, position: Int) {
+                holders.remove(holder.key)
+                val item = getItem(position)
+                holder.key = item.key
+                holders[item.key] = holder
+                attach(holder, item)
+                fire(this@ListView, "on_bind_row", JSONObject().put("index", position).put("key", item.key)
+                    .put("revision", item.revision).put("width", width / PNBridge.density()))
+            }
+            override fun onViewRecycled(holder: Holder) {
+                holders.remove(holder.key)
+                holder.container.removeAllViews()
+            }
+        }
+        init {
+            addView(recycler, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+            recycler.layoutManager = manager
+            recycler.adapter = rows
+            recycler.itemAnimator = null
+            isEnabled = false
+            setOnRefreshListener { fire(this, "on_refresh") }
+            recycler.addOnScrollListener(object : RecyclerView.OnScrollListener() {
+                override fun onScrolled(view: RecyclerView, dx: Int, dy: Int) {
+                    fire(this@ListView, "on_scroll", JSONObject().put("x", recycler.computeHorizontalScrollOffset() / PNBridge.density())
+                        .put("y", recycler.computeVerticalScrollOffset() / PNBridge.density())
+                        .put("extent", (if (horizontal) width else height) / PNBridge.density())
+                        .put("range", (if (horizontal) recycler.computeHorizontalScrollRange() else recycler.computeVerticalScrollRange()) / PNBridge.density())
+                        .put("first", manager.findFirstVisibleItemPosition()).put("last", manager.findLastVisibleItemPosition()))
+                }
+            })
+        }
+        fun attach(holder: Holder, item: Item) {
+            val size = ((heights[item.key] ?: item.estimate) * PNBridge.density()).roundToInt().coerceAtLeast(1)
+            // Preserve RecyclerView.LayoutParams, which retain the holder identity.
+            val params = holder.container.layoutParams as? RecyclerView.LayoutParams
+                ?: RecyclerView.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, size)
+            params.width = if (horizontal) size else ViewGroup.LayoutParams.MATCH_PARENT
+            params.height = if (horizontal) ViewGroup.LayoutParams.MATCH_PARENT else size
+            holder.container.layoutParams = params
+            holder.container.removeAllViews()
+            roots[item.key]?.let { root ->
+                (root.parent as? ViewGroup)?.removeView(root)
+                holder.container.addView(root, FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.MATCH_PARENT))
+            }
+        }
+    }
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = ListView(context)
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        ViewStyler.apply(view, props)
+        val list = view as ListView
+        val all = PNBridge.registry.recordFor(view)?.props ?: props
+        list.horizontal = all.optBoolean("horizontal", false)
+        list.manager.orientation = if (list.horizontal) RecyclerView.HORIZONTAL else RecyclerView.VERTICAL
+        list.recycler.isVerticalScrollBarEnabled = all.optBoolean("shows_scroll_indicator", true)
+        val refresh = all.optJSONObject("refresh_control")
+        list.isEnabled = refresh != null && !list.horizontal
+        list.isRefreshing = refresh?.optBoolean("refreshing", false) == true
+        refresh?.optString("tint_color")?.takeIf { it.isNotEmpty() }?.let { color -> PNColor.parse(color)?.let { list.setColorSchemeColors(it) } }
+        if (initial || props.has("keys") || props.has("revision") || props.has("row_heights")) {
+            val keys = all.optJSONArray("keys")
+            val heights = all.optJSONArray("row_heights")
+            val items = (0 until (keys?.length() ?: 0)).map { Item(keys!!.getString(it), all.optInt("revision"), heights?.optDouble(it, 44.0) ?: 44.0) }
+            val first = list.manager.findFirstVisibleItemPosition()
+            val anchor = list.rows.currentList.getOrNull(first)?.key
+            val anchorView = list.manager.findViewByPosition(first)
+            val offset = (if (list.horizontal) anchorView?.left else anchorView?.top) ?: 0
+            list.rows.submitList(items) {
+                val position = items.indexOfFirst { it.key == anchor }
+                if (position >= 0) list.manager.scrollToPositionWithOffset(position, offset)
+            }
+            list.heights.keys.retainAll(items.map { it.key }.toSet())
+        }
+    }
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val list = parent as ListView
+        val record = PNBridge.registry.recordFor(child) ?: return
+        val key = record.props.optString("_pn_list_key")
+        list.roots[key] = child
+        rowOwners[record.tag] = { width, height ->
+            val extent = if (list.horizontal) width else height
+            if (extent > 0 && list.heights[key] != extent) {
+                list.heights[key] = extent
+                list.holders[key]?.let { holder -> list.rows.currentList.find { it.key == key }?.let { list.attach(holder, it) } }
+            }
+        }
+        list.holders[key]?.let { holder -> list.rows.currentList.find { it.key == key }?.let { list.attach(holder, it) } }
+    }
+    override fun removeChild(parent: View, child: View) {
+        val list = parent as ListView
+        PNBridge.registry.recordFor(child)?.let { record ->
+            list.roots.remove(record.props.optString("_pn_list_key"))
+            rowOwners.remove(record.tag)
+        }
+        (child.parent as? ViewGroup)?.removeView(child)
+    }
+    override fun teardown(view: View) {
+        val list = view as ListView
+        for (root in list.roots.values) PNBridge.registry.recordFor(root)?.let { rowOwners.remove(it.tag) }
+        list.recycler.adapter = null
+        list.roots.clear()
+        list.holders.clear()
+    }
+    override fun measure(view: View, maxWidth: Double, maxHeight: Double): FloatArray =
+        floatArrayOf(if (maxWidth < 1e6) maxWidth.toFloat() else 0f, if (maxHeight < 1e6) maxHeight.toFloat() else 0f)
+    override fun command(view: View, name: String, args: JSONObject): Any? {
+        val list = view as ListView
+        val animated = args.optBoolean("animated", true)
+        val index = when (name) {
+            "scroll_to_end" -> (list.rows.itemCount - 1).coerceAtLeast(0)
+            "scroll_to_index" -> args.optInt("index").coerceIn(0, (list.rows.itemCount - 1).coerceAtLeast(0))
+            else -> -1
+        }
+        if (index >= 0) { if (animated) list.recycler.smoothScrollToPosition(index) else list.manager.scrollToPositionWithOffset(index, 0) }
+        if (name == "scroll_to_offset") {
+            val delta = (args.optDouble(if (list.horizontal) "x" else "y") * PNBridge.density()).roundToInt() -
+                (if (list.horizontal) list.recycler.computeHorizontalScrollOffset() else list.recycler.computeVerticalScrollOffset())
+            val x = if (list.horizontal) delta else 0
+            val y = if (list.horizontal) 0 else delta
+            if (animated) list.recycler.smoothScrollBy(x, y) else list.recycler.scrollBy(x, y)
+        }
+        return null
+    }
+    companion object {
+        private val rowOwners = HashMap<Long, (Double, Double) -> Unit>()
+        fun measured(tag: Long, width: Double, height: Double) { rowOwners[tag]?.invoke(width, height) }
+    }
+}

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

@@ -0,0 +1,149 @@
+package com.pythonnative.runtime.components
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.graphics.Bitmap
+import android.view.MotionEvent
+import android.view.View
+import android.webkit.WebResourceError
+import android.webkit.WebResourceRequest
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONArray
+import org.json.JSONObject
+import java.net.URLDecoder
+
+/**
+ * `WebView` element. Fires `on_navigation_state_change`, `on_load`,
+ * `on_error`, and `on_message` (via a `window.pythonnative.postMessage`
+ * shim that navigates to a `pythonnative://message/` URL). Commands:
+ * `load_url`, `reload`, `go_back`, `go_forward`, `stop_loading`,
+ * `inject_javascript`, `post_message`.
+ */
+class WebViewManager : ComponentManager() {
+    private val scheme = "pythonnative://message/"
+
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val wv = WebView(context)
+        wv.webViewClient = client(wv)
+        return wv
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val wv = view as WebView
+        val merged = propsOf(wv)
+        val events = merged.value("_pn_events") as? JSONArray
+        val needsJs = merged.value("inject_javascript") != null ||
+            (events != null && events.length() > 0) ||
+            merged.value("javascript_enabled") != false
+        if (needsJs) wv.settings.javaScriptEnabled = true
+        if (props.has("javascript_enabled")) wv.settings.javaScriptEnabled = JsonUtil.truthy(props.value("javascript_enabled"))
+        if (props.has("dom_storage_enabled")) wv.settings.domStorageEnabled = JsonUtil.truthy(props.value("dom_storage_enabled"))
+        if (props.has("user_agent")) wv.settings.userAgentString = props.str("user_agent")
+
+        val html = props.str("html")
+        val url = props.str("url") ?: sourceUrl(props.value("source"))
+        // `html` takes precedence over `url` when both are present.
+        if (!html.isNullOrEmpty()) {
+            wv.loadDataWithBaseURL(props.str("base_url"), html, "text/html", "utf-8", null)
+        } else if (!url.isNullOrEmpty()) {
+            wv.loadUrl(url)
+        }
+        if (props.has("scroll_enabled")) applyScrollEnabled(wv, props.value("scroll_enabled"))
+        ViewStyler.apply(wv, props)
+    }
+
+    private fun sourceUrl(source: Any?): String? = when (source) {
+        is JSONObject -> source.str("uri") ?: source.str("url")
+        is String -> source
+        else -> null
+    }
+
+    @SuppressLint("ClickableViewAccessibility")
+    private fun applyScrollEnabled(wv: WebView, enabled: Any?) {
+        if (enabled == false) {
+            wv.setOnTouchListener { _, event -> event.action == MotionEvent.ACTION_MOVE }
+        } else {
+            wv.setOnTouchListener(null)
+        }
+    }
+
+    private fun client(wv: WebView): WebViewClient = object : WebViewClient() {
+        override fun onPageStarted(view: WebView, url: String?, favicon: Bitmap?) {
+            fire(wv, "on_navigation_state_change", url ?: "")
+            fire(wv, "on_load_start", url ?: "")
+        }
+
+        override fun onPageFinished(view: WebView, url: String?) {
+            fire(wv, "on_load", url ?: "")
+            if (hasEvent(wv, "on_message")) {
+                val shim = "(function(){window.pythonnative=window.pythonnative||{};" +
+                    "window.pythonnative.postMessage=function(m){" +
+                    "window.location.href='$scheme'+encodeURIComponent(m);};})();"
+                view.evaluateJavascript(shim, null)
+            }
+            propsOf(wv).str("inject_javascript")?.takeIf { it.isNotEmpty() }?.let { view.evaluateJavascript(it, null) }
+        }
+
+        override fun onReceivedError(view: WebView, request: WebResourceRequest, error: WebResourceError) {
+            if (request.isForMainFrame) {
+                fire(wv, "on_error", error.description?.toString() ?: "load error")
+            }
+        }
+
+        override fun shouldOverrideUrlLoading(view: WebView, request: WebResourceRequest): Boolean {
+            val url = request.url?.toString() ?: return false
+            return handleUrl(url)
+        }
+
+        @Deprecated("Deprecated in Java")
+        override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean = handleUrl(url)
+
+        private fun handleUrl(url: String): Boolean {
+            if (url.startsWith(scheme)) {
+                val message = try {
+                    URLDecoder.decode(url.substring(scheme.length), "UTF-8")
+                } catch (e: Exception) {
+                    url.substring(scheme.length)
+                }
+                fire(wv, "on_message", message)
+                return true
+            }
+            return false
+        }
+    }
+
+    override fun command(view: View, name: String, args: JSONObject): Any? {
+        val wv = view as? WebView ?: return null
+        when (name) {
+            "load_url" -> args.str("url")?.let { wv.loadUrl(it) }
+            "reload" -> wv.reload()
+            "go_back" -> if (wv.canGoBack()) wv.goBack()
+            "go_forward" -> if (wv.canGoForward()) wv.goForward()
+            "stop_loading" -> wv.stopLoading()
+            "inject_javascript", "evaluate_javascript" -> {
+                val script = args.str("script") ?: args.str("javascript") ?: return null
+                wv.evaluateJavascript(script, null)
+            }
+            "post_message" -> {
+                val message = JSONObject.quote(args.str("message") ?: "")
+                wv.evaluateJavascript("window.dispatchEvent(new MessageEvent('message',{data:$message}));", null)
+            }
+            "can_go_back" -> return wv.canGoBack()
+            "can_go_forward" -> return wv.canGoForward()
+            "get_url" -> return wv.url
+        }
+        return null
+    }
+
+    override fun teardown(view: View) {
+        (view as? WebView)?.let {
+            it.stopLoading()
+            it.destroy()
+        }
+    }
+}