pythonnative 0.40.0__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,110 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.LinearLayout
+import androidx.appcompat.widget.Toolbar
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentActivity
+import androidx.fragment.app.FragmentContainerView
+import com.pythonnative.runtime.PNBridge
+import org.json.JSONObject
+import android.widget.FrameLayout
+import com.pythonnative.runtime.layout.NativeLayout
+
+class ScreenManager : ViewManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View =
+        super.createView(context, tag, props).apply {
+            layoutParams = FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+            addOnLayoutChangeListener { _, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom ->
+                if (right - left != oldRight - oldLeft || bottom - top != oldBottom - oldTop) NativeLayout.containerDidLayout()
+            }
+        }
+    override fun setFrame(view: View, x: Double, y: Double, width: Double, height: Double) {}
+}
+
+/** A native fragment displays an existing logical screen's view. */
+class LogicalScreenFragment : Fragment() {
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, state: Bundle?): View {
+        val view = PNBridge.registry.get(requireArguments().getLong("tag"))?.view ?: View(requireContext())
+        (view.parent as? ViewGroup)?.removeView(view)
+        return view
+    }
+}
+
+/** One fragment stack whose Python providers and state remain application-owned. */
+class ScreenStackManager : ComponentManager() {
+    private inner class Stack(context: Context) : LinearLayout(context) {
+        val toolbar = Toolbar(context)
+        val container = FragmentContainerView(context).apply { id = View.generateViewId() }
+        val screens = ArrayList<Long>()
+        val fragments = HashMap<Long, LogicalScreenFragment>()
+        var scheduled = false
+        init {
+            orientation = VERTICAL
+            addView(toolbar, LayoutParams(LayoutParams.MATCH_PARENT, (56 * PNBridge.density()).toInt()))
+            addView(container, LayoutParams(LayoutParams.MATCH_PARENT, 0, 1f))
+            toolbar.setNavigationOnClickListener { fire(this, "on_native_back", 1) }
+        }
+        override fun onAttachedToWindow() { super.onAttachedToWindow(); schedule() }
+        fun schedule() {
+            if (scheduled) return
+            scheduled = true
+            post {
+                scheduled = false
+                if (!isAttachedToWindow) return@post
+                val manager = (context as? FragmentActivity)?.supportFragmentManager ?: return@post
+                if (manager.isStateSaved) return@post
+                val transaction = manager.beginTransaction().setReorderingAllowed(true)
+                for ((tag, fragment) in fragments.toMap()) if (tag !in screens) {
+                    transaction.remove(fragment)
+                    fragments.remove(tag)
+                }
+                for (tag in screens) {
+                    var fragment = fragments[tag]
+                    if (fragment == null) {
+                        fragment = LogicalScreenFragment().apply { arguments = Bundle().apply { putLong("tag", tag) } }
+                        fragments[tag] = fragment
+                        transaction.add(container.id, fragment, "pn-screen-$tag")
+                    }
+                    if (tag == screens.lastOrNull()) transaction.show(fragment) else transaction.hide(fragment)
+                }
+                transaction.commitNow()
+                val current = screens.lastOrNull()?.let { PNBridge.registry.get(it) }
+                toolbar.title = current?.props?.optString("title", "") ?: ""
+                toolbar.navigationIcon = if (screens.size > 1) context.getDrawable(android.R.drawable.ic_media_previous) else null
+            }
+        }
+    }
+    override fun createView(context: Context, tag: Long, props: JSONObject): View = Stack(context)
+    override fun insertChild(parent: View, child: View, index: Int) {
+        val stack = parent as Stack
+        val tag = PNBridge.registry.recordFor(child)?.tag ?: return
+        stack.screens.remove(tag)
+        stack.screens.add(index.coerceAtMost(stack.screens.size), tag)
+        stack.schedule()
+    }
+    override fun removeChild(parent: View, child: View) {
+        val stack = parent as Stack
+        PNBridge.registry.recordFor(child)?.let { stack.screens.remove(it.tag) }
+        stack.schedule()
+    }
+    override fun command(view: View, name: String, args: JSONObject): Any? {
+        if (name == "restore_stack") (view as Stack).schedule()
+        return null
+    }
+    override fun teardown(view: View) {
+        val stack = view as Stack
+        val manager = (view.context as? FragmentActivity)?.supportFragmentManager
+        if (manager != null && !manager.isDestroyed) {
+            val transaction = manager.beginTransaction()
+            for (fragment in stack.fragments.values) transaction.remove(fragment)
+            transaction.commitAllowingStateLoss()
+        }
+        stack.screens.clear()
+        stack.fragments.clear()
+    }
+}

pythonnative/native/android/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/native/android/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/native/android/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")
+        }
+    }
+}

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

@@ -0,0 +1,131 @@
+package com.pythonnative.runtime.components
+
+import android.content.Context
+import android.content.res.ColorStateList
+import android.view.View
+import com.google.android.material.bottomnavigation.BottomNavigationView
+import com.google.android.material.navigation.NavigationBarView
+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.JSONArray
+import org.json.JSONObject
+
+/**
+ * `TabBar` element backed by Material's `BottomNavigationView`.
+ *
+ * `items` is a list of `{name, title, icon}`; `active_tab` names the
+ * selected item (an integer `active_index` is also accepted). Selecting
+ * a tab fires `on_tab_select(name)` and `on_select(index)` when wired.
+ */
+class TabBarManager : ComponentManager() {
+    override fun createView(context: Context, tag: Long, props: JSONObject): View {
+        val bnv = BottomNavigationView(context)
+        bnv.setBackgroundColor(0xFFFFFFFF.toInt())
+        bnv.labelVisibilityMode = NavigationBarView.LABEL_VISIBILITY_LABELED
+        bnv.setOnItemSelectedListener { item ->
+            if (stateOf(bnv)["suppress"] == true) return@setOnItemSelectedListener true
+            val items = propsOf(bnv).value("items") as? JSONArray
+            val index = item.itemId
+            val spec = items?.optJSONObject(index)
+            if (spec != null) {
+                fire(bnv, "on_tab_select", spec.str("name") ?: "")
+                if (hasEvent(bnv, "on_select")) fire(bnv, "on_select", index)
+            }
+            true
+        }
+        return bnv
+    }
+
+    override fun applyProps(view: View, props: JSONObject, initial: Boolean) {
+        val bnv = view as BottomNavigationView
+        val merged = propsOf(bnv)
+        if (props.has("items")) setMenu(bnv, merged.value("items") as? JSONArray)
+        if (props.has("active_tab") || props.has("active_index") || props.has("items")) {
+            setActive(bnv, merged)
+        }
+        val active = PNColor.parse(props.value("active_tint_color") ?: props.value("tint_color"))
+        val inactive = PNColor.parse(props.value("inactive_tint_color"))
+        if (active != null || inactive != null) {
+            val a = active ?: PNColor.parse(merged.value("active_tint_color")) ?: 0xFF1976D2.toInt()
+            val i = inactive ?: PNColor.parse(merged.value("inactive_tint_color")) ?: 0xFF757575.toInt()
+            val list = ColorStateList(arrayOf(intArrayOf(android.R.attr.state_checked), intArrayOf()), intArrayOf(a, i))
+            bnv.itemIconTintList = list
+            bnv.itemTextColor = list
+        }
+        PNColor.parse(props.value("background_color"))?.let { bnv.setBackgroundColor(it) }
+        if (props.has("shows_labels")) {
+            bnv.labelVisibilityMode = if (JsonUtil.truthy(props.value("shows_labels"))) {
+                NavigationBarView.LABEL_VISIBILITY_LABELED
+            } else {
+                NavigationBarView.LABEL_VISIBILITY_UNLABELED
+            }
+        }
+        ViewStyler.apply(bnv, JSONObject(props.toString()).apply { remove("background_color") })
+    }
+
+    private fun setMenu(bnv: BottomNavigationView, items: JSONArray?) {
+        val state = stateOf(bnv)
+        state["suppress"] = true
+        try {
+            val menu = bnv.menu
+            menu.clear()
+            if (items == null) return
+            for (i in 0 until items.length()) {
+                val item = items.optJSONObject(i) ?: continue
+                val title = item.str("title") ?: item.str("name") ?: ""
+                val menuItem = menu.add(0, i, i, title)
+                val icon = resolveIcon(bnv.context, item.value("icon"))
+                if (icon != 0) menuItem.setIcon(icon)
+                item.str("badge")?.let { badge ->
+                    val b = bnv.getOrCreateBadge(i)
+                    badge.toIntOrNull()?.let { b.number = it }
+                }
+            }
+        } catch (e: Exception) {
+            PNLog.swallowed("TabBarManager.setMenu", e)
+        } finally {
+            state["suppress"] = false
+        }
+    }
+
+    /** Resolve an icon spec (`"ic_menu_home"` or `{"android": ...}`) to a drawable id. */
+    private fun resolveIcon(context: Context, icon: Any?): Int {
+        val name = when (icon) {
+            is String -> icon
+            is JSONObject -> icon.str("android")
+            else -> null
+        } ?: return 0
+        return try {
+            val field = android.R.drawable::class.java.getField(name)
+            field.getInt(null)
+        } catch (e: Exception) {
+            context.resources.getIdentifier(name, "drawable", context.packageName)
+        }
+    }
+
+    private fun setActive(bnv: BottomNavigationView, merged: JSONObject) {
+        val items = merged.value("items") as? JSONArray ?: return
+        val active = merged.str("active_tab")
+        var target = -1
+        if (active != null) {
+            for (i in 0 until items.length()) {
+                if (items.optJSONObject(i)?.str("name") == active) {
+                    target = i
+                    break
+                }
+            }
+        }
+        if (target < 0) target = merged.value("active_index")?.let { JsonUtil.toInt(it, -1) } ?: -1
+        if (target < 0 || target >= items.length()) return
+        if (bnv.selectedItemId == target) return
+        val state = stateOf(bnv)
+        state["suppress"] = true
+        try {
+            bnv.selectedItemId = target
+        } finally {
+            state["suppress"] = false
+        }
+    }
+}