pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/templates/android_template/pythonnative/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/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/VirtualListManager.kt

@@ -0,0 +1,179 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import android.view.ViewGroup
+import android.widget.FrameLayout
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.arr
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.value
+import com.pythonnative.runtime.views.PNVirtualListView
+import org.json.JSONArray
+import org.json.JSONObject
+import kotlin.math.max
+
+/**
+ * `VirtualList` element: a `RecyclerView` (via [PNVirtualListView])
+ * whose rows are rendered lazily by Python.
+ *
+ * Binding a row is a synchronous round trip: `on_bind_row` is sent with
+ * `{container, index, width, height}` (the container key is its
+ * identity hash) and Python answers `{"root": tag}`; the tag's view is
+ * detached from any previous parent and added to the row container.
+ * Recycling emits `on_unbind_row` with the same key.
+ */
+class VirtualListManager : ComponentManager() {
+    private class Info {
+        var count = 0
+        var rowHeight = 44.0
+        var rowHeights: JSONArray? = null
+        var list: PNVirtualListView? = null
+        val mounted = HashMap<Int, View>()
+    }
+
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val info = Info()
+        info.count = JsonUtil.toInt(props.value("count"))
+        info.rowHeight = props.num("row_height") ?: 44.0
+        info.rowHeights = props.arr("row_heights")
+        val delegate = object : PNVirtualListView.Delegate {
+            override fun getCount(): Int = info.count
+
+            override fun getRowHeightDp(position: Int): Float {
+                val heights = info.rowHeights
+                if (heights != null && position in 0 until heights.length()) {
+                    return JsonUtil.toDouble(heights.opt(position), info.rowHeight).toFloat()
+                }
+                return info.rowHeight.toFloat()
+            }
+
+            override fun bindRow(position: Int, container: FrameLayout, widthDp: Float, heightDp: Float) {
+                val list = info.list ?: return
+                val key = System.identityHashCode(container)
+                val payload = JSONObject()
+                    .put("container", key)
+                    .put("index", position)
+                    .put("width", widthDp.toDouble())
+                    .put("height", heightDp.toDouble())
+                val reply = fireForResult(list, "on_bind_row", payload) ?: return
+                val rootTag = try {
+                    JSONObject(reply).optLong("root", -1L)
+                } catch (e: Exception) {
+                    PNLog.rateLimited("vlist-bind", "on_bind_row returned invalid JSON: $reply", e)
+                    return
+                }
+                if (rootTag < 0) return
+                val root = PNBridge.registry.get(rootTag)?.view ?: run {
+                    PNLog.rateLimited("vlist-root", "on_bind_row root tag $rootTag is unknown")
+                    return
+                }
+                (root.parent as? ViewGroup)?.let { if (it !== container) it.removeView(root) }
+                if (root.parent !== container) {
+                    container.addView(root, 0)
+                }
+                // The layout engine frames only the descendants of a subtree
+                // root, so the root itself must fill the cell.
+                root.layoutParams = FrameLayout.LayoutParams(
+                    FrameLayout.LayoutParams.MATCH_PARENT,
+                    FrameLayout.LayoutParams.MATCH_PARENT,
+                )
+                info.mounted[key] = root
+            }
+
+            override fun onRowPress(position: Int) {
+                info.list?.let { fire(it, "on_row_press", position) }
+            }
+
+            override fun onRowRecycled(container: FrameLayout) {
+                val list = info.list ?: return
+                val key = System.identityHashCode(container)
+                info.mounted.remove(key)
+                fire(list, "on_unbind_row", JSONObject().put("container", key))
+            }
+
+            override fun onScrolled(offsetDp: Float, extentDp: Float, rangeDp: Float) {
+                val list = info.list ?: return
+                if (!hasEvent(list, "on_scroll")) return
+                fire(
+                    list,
+                    "on_scroll",
+                    mapOf(
+                        "x" to 0.0,
+                        "y" to offsetDp.toDouble(),
+                        "extent" to extentDp.toDouble(),
+                        "range" to rangeDp.toDouble(),
+                    ),
+                )
+            }
+        }
+        val list = PNVirtualListView(context, delegate)
+        info.list = list
+        infos[list] = info
+        return list
+    }
+
+    private val infos = java.util.IdentityHashMap<View, Info>()
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        ViewStyler.apply(view, props)
+        val list = view as PNVirtualListView
+        val info = infos[list] ?: return
+        var dataChanged = false
+        if (props.has("count")) {
+            info.count = JsonUtil.toInt(props.value("count"))
+            dataChanged = true
+        }
+        props.num("row_height")?.let {
+            info.rowHeight = it
+            dataChanged = true
+        }
+        if (props.has("row_heights")) {
+            info.rowHeights = props.arr("row_heights")
+            dataChanged = true
+        }
+        if (props.has("shows_scroll_indicator")) {
+            list.isVerticalScrollBarEnabled = props.value("shows_scroll_indicator") != false
+        }
+        if (dataChanged && !initial) list.notifyDataChanged()
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        // Row roots are attached through the bind protocol, not the tree ops.
+    }
+
+    override fun removeChild(parent: View, child: View) {
+        (child.parent as? ViewGroup)?.removeView(child)
+    }
+
+    override fun teardown(view: View) {
+        val info = infos.remove(view) ?: return
+        info.mounted.clear()
+        info.list = null
+    }
+
+    override fun measure(view: View, maxWidth: Double, maxHeight: Double): FloatArray {
+        // Fill the available space; collapse to 0 on an unbounded axis
+        // (nested inside another scroll view), like React Native.
+        val w = if (maxWidth.isFinite() && maxWidth < 1e6) maxWidth else 0.0
+        val h = if (maxHeight.isFinite() && maxHeight < 1e6) maxHeight else 0.0
+        return floatArrayOf(max(0.0, w).toFloat(), max(0.0, h).toFloat())
+    }
+
+    override fun command(view: View, name: String, args: JSONObject): Any? {
+        val list = view as PNVirtualListView
+        val animated = args.value("animated") != false
+        when (name) {
+            "scroll_to_offset" -> list.scrollToOffsetDp(JsonUtil.toDouble(args.opt("y")).toFloat(), animated)
+            "scroll_to_index" -> list.scrollToIndex(JsonUtil.toInt(args.opt("index")), animated)
+            "scroll_to_end" -> {
+                val count = infos[list]?.count ?: 0
+                list.scrollToIndex(max(0, count - 1), animated)
+            }
+            "get_scroll_offset" -> return mapOf("x" to 0.0, "y" to dp(list.computeVerticalScrollOffset()))
+        }
+        return null
+    }
+}

pythonnative/templates/android_template/pythonnative/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()
+        }
+    }
+}