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

@@ -0,0 +1,87 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.view.View
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.Spinner
+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
+
+/** `Picker` element: a native `Spinner` dropdown over `items` of `{label, value}`. */
+class PickerManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val spinner = Spinner(context)
+        spinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+            override fun onItemSelected(parent: AdapterView<*>, view: View?, position: Int, id: Long) {
+                if (stateOf(parent)["suppress"] == true) return
+                val items = propsOf(parent).value("items") as? JSONArray ?: return
+                if (position < 0 || position >= items.length()) return
+                fire(parent, "on_change", itemValue(items.opt(position)))
+            }
+
+            override fun onNothingSelected(parent: AdapterView<*>) {}
+        }
+        return spinner
+    }
+
+    private fun itemValue(item: Any?): Any? = when (item) {
+        is JSONObject -> item.value("value")
+        JSONObject.NULL -> null
+        else -> item
+    }
+
+    private fun itemLabel(item: Any?): String = when (item) {
+        is JSONObject -> item.str("label") ?: item.str("value") ?: ""
+        null, JSONObject.NULL -> ""
+        else -> item.toString()
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val spinner = view as Spinner
+        val state = stateOf(spinner)
+        val merged = propsOf(spinner)
+        val items = merged.value("items") as? JSONArray ?: JSONArray()
+        if (props.has("items") || initial) {
+            val labels = (0 until items.length()).map { itemLabel(items.opt(it)) }
+            val adapter = ArrayAdapter(spinner.context, android.R.layout.simple_spinner_item, labels)
+            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+            state["suppress"] = true
+            try {
+                spinner.adapter = adapter
+            } finally {
+                state["suppress"] = false
+            }
+        }
+        if (props.has("value") || props.has("selected_value") || initial) {
+            val value = merged.value("value") ?: merged.value("selected_value")
+            var target = -1
+            for (i in 0 until items.length()) {
+                if (valuesEqual(itemValue(items.opt(i)), value)) {
+                    target = i
+                    break
+                }
+            }
+            if (target >= 0 && spinner.selectedItemPosition != target) {
+                state["suppress"] = true
+                try {
+                    spinner.setSelection(target, false)
+                } finally {
+                    state["suppress"] = false
+                }
+            }
+        }
+        if (props.has("enabled")) spinner.isEnabled = JsonUtil.truthy(props.value("enabled"))
+        if (props.has("disabled")) spinner.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+        ViewStyler.apply(spinner, props)
+    }
+
+    private fun valuesEqual(a: Any?, b: Any?): Boolean {
+        if (a == b) return true
+        if (a is Number && b is Number) return a.toDouble() == b.toDouble()
+        return a != null && b != null && a.toString() == b.toString()
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/PortalManager.kt

@@ -0,0 +1,55 @@
+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.screens.ScreenRegistry
+import org.json.JSONObject
+
+/**
+ * `Portal` element: floats its children over the screen in a full-size,
+ * non-clickable overlay added directly to the screen's fragment
+ * container (the same parent as the screen root, so portal coordinates
+ * equal viewport coordinates). The overlay attaches lazily on the first
+ * child insert and re-homes itself if the container changed.
+ */
+class PortalManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val overlay = FrameLayout(context)
+        overlay.isClickable = false
+        return overlay
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        ViewStyler.apply(view, props)
+        if (!initial) ensureAttached(view)
+    }
+
+    private fun ensureAttached(overlay: View) {
+        val container = ScreenRegistry.activeContainer() ?: return
+        val parent = overlay.parent as? ViewGroup
+        if (parent === container) {
+            overlay.bringToFront()
+            return
+        }
+        parent?.removeView(overlay)
+        container.addView(
+            overlay,
+            ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT),
+        )
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {
+        ensureAttached(parent)
+        ViewChildren.insert(parent as ViewGroup, child, index)
+    }
+
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {
+        // The overlay fills its container; the engine frames only the portal's children.
+    }
+
+    override fun teardown(view: View) {
+        (view.parent as? ViewGroup)?.removeView(view)
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/PressableManager.kt

@@ -0,0 +1,122 @@
+package com.pythonnative.runtime.components
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.res.ColorStateList
+import android.graphics.drawable.RippleDrawable
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewConfiguration
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.MainThread
+import com.pythonnative.runtime.bridge.num
+import com.pythonnative.runtime.bridge.value
+import com.pythonnative.runtime.gestures.GestureCoordinator
+import com.pythonnative.runtime.views.PNFrameLayout
+import org.json.JSONObject
+import kotlin.math.hypot
+
+/**
+ * `Pressable` element: a container dispatching press events from one
+ * touch stream. `on_press_in` at finger-down (plus an opacity dip),
+ * `on_long_press` after the long-press timeout, `on_press` on a clean
+ * release, and `on_press_out` when the finger lifts or the touch
+ * cancels. The same stream feeds the gesture coordinator so press
+ * feedback and pan/pinch recognition coexist on one view.
+ */
+class PressableManager : ViewManager() {
+    private class Press(val downX: Double, val downY: Double, val seq: Int) {
+        var moved = false
+        var longFired = false
+    }
+
+    @SuppressLint("ClickableViewAccessibility")
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val view = PNFrameLayout(context)
+        view.isClickable = true
+        view.isFocusable = true
+        view.setOnTouchListener { v, event -> onTouch(v, event) }
+        return view
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        // Press handling owns the touch listener; gesture specs are fed from inside it.
+        stateOf(view)["gestures_bound"] = true
+        super.applyProps(view, props, initial)
+        if (props.has("ripple") || props.has("android_ripple")) applyRipple(view, props)
+        if (props.has("disabled")) view.isEnabled = !JsonUtil.truthy(props.value("disabled"))
+    }
+
+    private fun applyRipple(view: View, props: JSONObject) {
+        val spec = props.value("android_ripple") ?: props.value("ripple")
+        if (spec == null || spec == false) {
+            view.foreground = null
+            return
+        }
+        val color = when (spec) {
+            is JSONObject -> PNColor.parse(spec.value("color"))
+            else -> PNColor.parse(spec)
+        } ?: 0x33000000
+        val borderless = (spec as? JSONObject)?.let { JsonUtil.truthy(it.value("borderless")) } ?: false
+        val mask = if (borderless) null else android.graphics.drawable.ColorDrawable(0xFFFFFFFF.toInt())
+        view.foreground = RippleDrawable(ColorStateList.valueOf(color), null, mask)
+    }
+
+    private fun onTouch(view: View, event: MotionEvent): Boolean {
+        if (ViewStyler.pointerEventsBlocked(view)) return false
+        val record = recordOf(view) ?: return false
+        GestureCoordinator.feed(record, event)
+        if (!view.isEnabled) return true
+        val state = record.state
+        val merged = record.props
+        val density = view.resources.displayMetrics.density
+        val x = event.x / density
+        val y = event.y / density
+        when (event.actionMasked) {
+            MotionEvent.ACTION_DOWN -> {
+                val seq = ((state["press_seq"] as? Int) ?: 0) + 1
+                val press = Press(x.toDouble(), y.toDouble(), seq)
+                state["press"] = press
+                state["press_seq"] = seq
+                fire(view, "on_press_in")
+                val opacity = merged.num("pressed_opacity") ?: merged.num("active_opacity") ?: 0.6
+                if (opacity < 1.0) view.animate().alpha(opacity.toFloat()).setDuration(50).start()
+                if (hasEvent(view, "on_long_press")) {
+                    val delay = merged.num("delay_long_press")?.toLong() ?: ViewConfiguration.getLongPressTimeout().toLong().coerceAtLeast(500L)
+                    MainThread.postDelayed({
+                        val live = recordOf(view)?.state?.get("press") as? Press ?: return@postDelayed
+                        if (live.seq != seq || live.moved || live.longFired) return@postDelayed
+                        live.longFired = true
+                        fire(view, "on_long_press")
+                    }, delay)
+                }
+                view.isPressed = true
+                return true
+            }
+            MotionEvent.ACTION_MOVE -> {
+                val press = state["press"] as? Press ?: return true
+                val slop = merged.num("tap_slop") ?: TAP_SLOP_DP
+                if (hypot(x - press.downX, y - press.downY) > slop) press.moved = true
+                return true
+            }
+            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                val press = state["press"] as? Press
+                state["press"] = null
+                view.isPressed = false
+                if (press == null) return true
+                fire(view, "on_press_out")
+                view.animate().alpha(1f).setDuration(100).start()
+                if (event.actionMasked == MotionEvent.ACTION_UP && !press.moved && !press.longFired) {
+                    view.performClick()
+                    fire(view, "on_press")
+                }
+                return true
+            }
+        }
+        return true
+    }
+
+    private companion object {
+        const val TAP_SLOP_DP = 12.0
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/ScrollViewManager.kt

@@ -0,0 +1,214 @@
+package com.pythonnative.runtime.components
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.inputmethod.InputMethodManager
+import android.widget.HorizontalScrollView
+import androidx.core.widget.NestedScrollView
+import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.MainThread
+import com.pythonnative.runtime.bridge.obj
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+import kotlin.math.max
+import kotlin.math.roundToInt
+
+/**
+ * `ScrollView` element: a `NestedScrollView` (vertical, always wrapped in
+ * a `SwipeRefreshLayout` that is enabled only while `refresh_control`
+ * is set) or a `HorizontalScrollView`.
+ *
+ * `on_scroll` carries `{x, y, extent, range}` in dp. Commands:
+ * `scroll_to_offset`, `scroll_to_end`, `get_scroll_offset`,
+ * `flash_scroll_indicators`.
+ */
+class ScrollViewManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val horizontal = props.str("scroll_axis") == "horizontal" || JsonUtil.truthy(props.value("horizontal"))
+        return if (horizontal) {
+            val sv = HorizontalScrollView(context)
+            bindScrollListener(sv, sv, true)
+            bindTouch(sv, sv, true)
+            sv
+        } else {
+            val sv = NestedScrollView(context)
+            val wrapper = SwipeRefreshLayout(context)
+            wrapper.addView(sv, ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT))
+            wrapper.isEnabled = false
+            wrapper.setOnRefreshListener { fire(wrapper, "on_refresh") }
+            bindScrollListener(wrapper, sv, false)
+            bindTouch(wrapper, sv, false)
+            wrapper
+        }
+    }
+
+    private fun inner(outer: View): ViewGroup = when (outer) {
+        is SwipeRefreshLayout -> outer.getChildAt(0) as ViewGroup
+        else -> outer as ViewGroup
+    }
+
+    private fun isHorizontal(outer: View): Boolean = outer is HorizontalScrollView
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val sv = inner(view)
+        ViewStyler.apply(sv, props)
+        if (props.has("shows_scroll_indicator")) {
+            val show = props.value("shows_scroll_indicator") != false
+            sv.isVerticalScrollBarEnabled = show
+            sv.isHorizontalScrollBarEnabled = show
+        }
+        if (props.has("bounces")) {
+            sv.overScrollMode = if (props.value("bounces") == false) View.OVER_SCROLL_NEVER else View.OVER_SCROLL_IF_CONTENT_SCROLLS
+        }
+        if (props.has("scroll_enabled")) stateOf(view)["scroll_enabled"] = props.value("scroll_enabled") != false
+        if (props.has("refresh_control") && view is SwipeRefreshLayout) applyRefresh(view, props.obj("refresh_control"))
+        // paging_enabled and keyboard_dismiss_mode are read from merged props at touch time.
+    }
+
+    private fun applyRefresh(srl: SwipeRefreshLayout, spec: JSONObject?) {
+        if (spec == null) {
+            srl.isEnabled = false
+            srl.isRefreshing = false
+            return
+        }
+        srl.isEnabled = true
+        PNColor.parse(spec.value("tint_color"))?.let { srl.setColorSchemeColors(it) }
+        PNColor.parse(spec.value("background_color"))?.let { srl.setProgressBackgroundColorSchemeColor(it) }
+        srl.isRefreshing = JsonUtil.truthy(spec.value("refreshing"))
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) = ViewChildren.insert(inner(parent), child, index)
+
+    override fun removeChild(parent: View, child: View) {
+        inner(parent).removeView(child)
+    }
+
+    private fun bindScrollListener(outer: View, sv: View, horizontal: Boolean) {
+        sv.setOnScrollChangeListener { v, scrollX, scrollY, _, _ ->
+            if (!hasEvent(outer, "on_scroll")) return@setOnScrollChangeListener
+            fire(outer, "on_scroll", scrollPayload(v as ViewGroup, horizontal, scrollX, scrollY))
+        }
+    }
+
+    private fun scrollPayload(sv: ViewGroup, horizontal: Boolean, scrollX: Int, scrollY: Int): Map<String, Any?> {
+        val content = if (sv.childCount > 0) sv.getChildAt(0) else null
+        val extent = if (horizontal) sv.width else sv.height
+        val range = if (content == null) extent else if (horizontal) content.width else content.height
+        return mapOf(
+            "x" to dp(scrollX),
+            "y" to dp(scrollY),
+            "extent" to dp(extent),
+            "range" to dp(max(range, extent)),
+            "content_width" to dp(content?.width ?: sv.width),
+            "content_height" to dp(content?.height ?: sv.height),
+        )
+    }
+
+    @SuppressLint("ClickableViewAccessibility")
+    private fun bindTouch(outer: View, sv: ViewGroup, horizontal: Boolean) {
+        sv.setOnTouchListener { v, event ->
+            val merged = propsOf(outer)
+            if (stateOf(outer)["scroll_enabled"] == false) return@setOnTouchListener true
+            when (event.actionMasked) {
+                MotionEvent.ACTION_MOVE -> {
+                    val mode = merged.str("keyboard_dismiss_mode")
+                    if (mode == "on_drag" || mode == "interactive") dismissKeyboard(v)
+                }
+                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                    if (JsonUtil.truthy(merged.value("paging_enabled"))) scheduleSnap(sv, horizontal)
+                }
+            }
+            false
+        }
+    }
+
+    private fun dismissKeyboard(view: View) {
+        val focused = view.rootView.findFocus() ?: return
+        focused.clearFocus()
+        (view.context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager)
+            ?.hideSoftInputFromWindow(view.windowToken, 0)
+    }
+
+    /** Wait for the fling to settle (two identical samples), then snap to the nearest page. */
+    private fun scheduleSnap(sv: ViewGroup, horizontal: Boolean) {
+        val state = stateOf(sv.parent as? View ?: sv)
+        val token = ((state["snap_token"] as? Int) ?: 0) + 1
+        state["snap_token"] = token
+        var last = -1
+        val poll = object : Runnable {
+            override fun run() {
+                if (state["snap_token"] != token) return
+                val current = if (horizontal) sv.scrollX else sv.scrollY
+                if (current == last) {
+                    val page = if (horizontal) sv.width else sv.height
+                    if (page > 0) {
+                        val target = (current.toDouble() / page).roundToInt() * page
+                        if (target != current) {
+                            when (sv) {
+                                is NestedScrollView -> sv.smoothScrollTo(0, target)
+                                is HorizontalScrollView -> sv.smoothScrollTo(target, 0)
+                            }
+                        }
+                    }
+                    return
+                }
+                last = current
+                MainThread.postDelayed(this, 50)
+            }
+        }
+        MainThread.postDelayed(poll, 50)
+    }
+
+    override fun command(view: View, name: String, args: JSONObject): Any? {
+        val sv = inner(view)
+        val horizontal = isHorizontal(view)
+        when (name) {
+            "scroll_to_offset" -> {
+                val x = px(JsonUtil.toDouble(args.opt("x")))
+                val y = px(JsonUtil.toDouble(args.opt("y")))
+                val animated = args.value("animated") != false
+                when (sv) {
+                    is NestedScrollView -> if (animated) sv.smoothScrollTo(x, y) else sv.scrollTo(x, y)
+                    is HorizontalScrollView -> if (animated) sv.smoothScrollTo(x, y) else sv.scrollTo(x, y)
+                }
+            }
+            "scroll_to_end" -> {
+                val child = if (sv.childCount > 0) sv.getChildAt(0) else return null
+                val animated = args.value("animated") != false
+                if (horizontal) {
+                    val target = max(0, child.width - sv.width)
+                    if (animated) (sv as HorizontalScrollView).smoothScrollTo(target, 0) else sv.scrollTo(target, 0)
+                } else {
+                    val target = max(0, child.height - sv.height)
+                    if (animated) (sv as NestedScrollView).smoothScrollTo(0, target) else sv.scrollTo(0, target)
+                }
+            }
+            "get_scroll_offset" -> return mapOf("x" to dp(sv.scrollX), "y" to dp(sv.scrollY))
+            "flash_scroll_indicators" -> sv.awakenScrollBarsCompat()
+        }
+        return null
+    }
+
+    private fun View.awakenScrollBarsCompat() {
+        // awakenScrollBars is protected; toggling the fade re-shows the bars briefly.
+        isScrollbarFadingEnabled = false
+        MainThread.postDelayed({ isScrollbarFadingEnabled = true }, 600)
+    }
+
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {
+        super.setFrame(view, x, y, width, height)
+        // The inner scroll view fills its refresh wrapper.
+        if (view is SwipeRefreshLayout) {
+            val sv = view.getChildAt(0)
+            val lp = sv.layoutParams
+            lp.width = ViewGroup.LayoutParams.MATCH_PARENT
+            lp.height = ViewGroup.LayoutParams.MATCH_PARENT
+            sv.layoutParams = lp
+        }
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/SegmentedControlManager.kt

@@ -0,0 +1,113 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.graphics.drawable.GradientDrawable
+import android.view.View
+import android.widget.Button
+import android.widget.LinearLayout
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.arr
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+import kotlin.math.max
+
+/**
+ * `SegmentedControl` element: a horizontal `LinearLayout` of equal-width
+ * toggle `Button`s. The selected segment is filled with `tint_color`;
+ * the rest are outlined. The control owns its subviews, so child
+ * inserts are ignored.
+ */
+class SegmentedControlManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val ll = LinearLayout(context)
+        ll.orientation = LinearLayout.HORIZONTAL
+        return ll
+    }
+
+    override fun insertChild(parent: View, child: View, index: Int) {}
+
+    override fun removeChild(parent: View, child: View) {}
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val ll = view as LinearLayout
+        val state = stateOf(ll)
+        val merged = propsOf(ll)
+        var segmentsChanged = false
+        if (props.has("segments") || initial) {
+            val segments = JsonUtil.toList(merged.arr("segments")).map { it?.toString() ?: "" }
+            if (initial || segments != state["segments"]) {
+                state["segments"] = segments
+                segmentsChanged = true
+            }
+        }
+        props.value("selected_index")?.let { state["selected_index"] = JsonUtil.toInt(it) }
+        if (segmentsChanged) rebuild(ll) else restyle(ll)
+        ViewStyler.applyAccessibility(ll, props)
+    }
+
+    private fun rebuild(ll: LinearLayout) {
+        val state = stateOf(ll)
+        ll.removeAllViews()
+        @Suppress("UNCHECKED_CAST")
+        val segments = state["segments"] as? List<String> ?: emptyList()
+        val enabled = propsOf(ll).value("enabled") != false
+        segments.forEachIndexed { index, label ->
+            val btn = Button(ll.context)
+            btn.text = label
+            btn.isAllCaps = false
+            btn.layoutParams = LinearLayout.LayoutParams(0, LinearLayout.LayoutParams.MATCH_PARENT, 1f)
+            btn.isEnabled = enabled
+            btn.setOnClickListener {
+                if (propsOf(ll).value("enabled") == false) return@setOnClickListener
+                stateOf(ll)["selected_index"] = index
+                restyle(ll)
+                fire(ll, "on_change", index)
+            }
+            ll.addView(btn)
+        }
+        restyle(ll)
+    }
+
+    private fun restyle(ll: LinearLayout) {
+        val merged = propsOf(ll)
+        val accent = PNColor.parseOr(merged.value("tint_color"), DEFAULT_ACCENT)
+        val selected = (stateOf(ll)["selected_index"] as? Int) ?: JsonUtil.toInt(merged.value("selected_index"))
+        val enabled = merged.value("enabled") != false
+        for (i in 0 until ll.childCount) {
+            val btn = ll.getChildAt(i) as? Button ?: continue
+            val drawable = GradientDrawable()
+            drawable.cornerRadius = pxF(6.0)
+            drawable.setStroke(px(1.0), accent)
+            if (i == selected) {
+                drawable.setColor(accent)
+                btn.setTextColor(0xFFFFFFFF.toInt())
+            } else {
+                drawable.setColor(0x00FFFFFF)
+                btn.setTextColor(accent)
+            }
+            btn.background = drawable
+            btn.isEnabled = enabled
+        }
+    }
+
+    override fun measure(view: View, maxWidth: Double, maxHeight: Double): FloatArray {
+        // Weighted children measure to ~0 under an unspecified spec, so
+        // size to the sum of the segments' natural widths instead.
+        val ll = view as LinearLayout
+        if (ll.childCount == 0) return floatArrayOf(0f, 0f)
+        val spec = View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+        var totalW = 0
+        var maxH = 0
+        for (i in 0 until ll.childCount) {
+            val child = ll.getChildAt(i)
+            child.measure(spec, spec)
+            totalW += child.measuredWidth
+            maxH = max(maxH, child.measuredHeight)
+        }
+        return floatArrayOf(dp(totalW).toFloat(), dp(maxH).toFloat())
+    }
+
+    private companion object {
+        val DEFAULT_ACCENT = 0xFF007AFF.toInt()
+    }
+}

pythonnative/templates/android_template/pythonnative/src/main/java/com/pythonnative/runtime/components/StatusBarManager.kt

@@ -0,0 +1,52 @@
+package com.pythonnative.runtime.components
+
+import android.app.Activity
+import android.content.Context
+import android.view.View
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
+import androidx.core.view.WindowInsetsControllerCompat
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.JsonUtil
+import com.pythonnative.runtime.bridge.PNLog
+import com.pythonnative.runtime.bridge.str
+import com.pythonnative.runtime.bridge.value
+import org.json.JSONObject
+
+/** `StatusBar` element: applies bar color, style, and visibility to the host window. */
+class StatusBarManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val v = View(context)
+        v.visibility = View.GONE
+        return v
+    }
+
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {}
+
+    override fun measure(view: View, maxWidth: Double, maxHeight: Double): FloatArray = floatArrayOf(0f, 0f)
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val activity = PNBridge.activity() ?: (view.context as? Activity) ?: return
+        val window = activity.window ?: return
+        try {
+            PNColor.parse(props.value("background_color"))?.let { window.statusBarColor = it }
+            val controller: WindowInsetsControllerCompat = WindowCompat.getInsetsController(window, window.decorView)
+            props.str("bar_style")?.let { style ->
+                // "dark" / "default" mean dark icons (light backgrounds); "light" means light icons.
+                controller.isAppearanceLightStatusBars = style == "dark" || style == "default" || style == "dark_content"
+            }
+            if (props.has("hidden")) {
+                if (JsonUtil.truthy(props.value("hidden"))) {
+                    controller.hide(WindowInsetsCompat.Type.statusBars())
+                } else {
+                    controller.show(WindowInsetsCompat.Type.statusBars())
+                }
+            }
+            if (props.has("translucent")) {
+                WindowCompat.setDecorFitsSystemWindows(window, !JsonUtil.truthy(props.value("translucent")))
+            }
+        } catch (e: Exception) {
+            PNLog.once("statusbar", "StatusBar: could not apply props on Android: $e")
+        }
+    }
+}