pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/android/src/main/java/com/pythonnative/runtime/gestures/GestureRecognizers.kt

@@ -0,0 +1,527 @@
+package com.pythonnative.runtime.gestures
+
+import kotlin.math.abs
+import kotlin.math.atan2
+import kotlin.math.hypot
+import kotlin.math.max
+
+/** Gesture states reported on event payloads. */
+object GestureState {
+    const val BEGAN = "began"
+    const val CHANGED = "changed"
+    const val ENDED = "ended"
+    const val CANCELLED = "cancelled"
+
+    /** Internal verdict used by recognizers to tell the arbiter they cannot succeed. */
+    const val FAILED = "__failed"
+}
+
+/** A pointer position in the view's coordinate space, in dp. */
+data class Point(val x: Double, val y: Double)
+
+/** Output channel of recognizers and the arbiter: `(gesture_index, payload)`. */
+typealias EmitFn = (Int, Map<String, Any?>) -> Unit
+
+/** Configuration for one leaf gesture, decoded from the serialized `gestures` prop. */
+data class GestureConfig(
+    val kind: String,
+    val nTaps: Int = 1,
+    val maxDistance: Double = 12.0,
+    val minDurationMs: Double = 500.0,
+    val minDistance: Double = 10.0,
+    val minPointers: Int = 1,
+    val direction: String = "any",
+    val minVelocity: Double = 300.0,
+    val nPointers: Int = 1,
+    /** Indices this gesture may be active alongside; `null` means everything. */
+    val simultaneous: Set<Int>? = null,
+    /** Indices that must fail before this gesture may activate. */
+    val waitFor: Set<Int> = emptySet(),
+)
+
+/** Estimate pointer velocity from recent samples (dp per second). */
+class VelocityEstimator {
+    private data class Sample(val x: Double, val y: Double, val t: Double)
+
+    private val samples = ArrayList<Sample>()
+
+    fun add(x: Double, y: Double, t: Double) {
+        samples.add(Sample(x, y, t))
+        val cutoff = t - WINDOW_S
+        while (samples.size > 2 && samples[0].t < cutoff) samples.removeAt(0)
+    }
+
+    fun velocity(): Point {
+        if (samples.size < 2) return Point(0.0, 0.0)
+        val first = samples.first()
+        val last = samples.last()
+        val dt = last.t - first.t
+        if (dt <= 1e-6) return Point(0.0, 0.0)
+        return Point((last.x - first.x) / dt, (last.y - first.y) / dt)
+    }
+
+    fun reset() = samples.clear()
+
+    private companion object {
+        const val WINDOW_S = 0.1
+    }
+}
+
+internal fun centroid(pointers: Map<Int, Point>): Point {
+    if (pointers.isEmpty()) return Point(0.0, 0.0)
+    var xs = 0.0
+    var ys = 0.0
+    for (p in pointers.values) {
+        xs += p.x
+        ys += p.y
+    }
+    return Point(xs / pointers.size, ys / pointers.size)
+}
+
+/** Base class for one gesture's state machine. `pointers` maps pointer id to position. */
+abstract class Recognizer(val index: Int, val config: GestureConfig, private val emitFn: EmitFn) {
+    protected fun emit(state: String, vararg fields: Pair<String, Any?>) {
+        val payload = LinkedHashMap<String, Any?>()
+        payload["kind"] = config.kind
+        payload["state"] = state
+        for ((k, v) in fields) payload[k] = v
+        emitFn(index, payload)
+    }
+
+    /** Report that this gesture can no longer succeed this interaction. */
+    protected fun fail() {
+        emitFn(index, mapOf("kind" to config.kind, "state" to GestureState.FAILED))
+    }
+
+    /** Abandon recognition without emitting anything (lost a race). */
+    open fun forceFail(t: Double) = cancel(t)
+
+    open fun down(pointers: Map<Int, Point>, t: Double) {}
+    open fun move(pointers: Map<Int, Point>, t: Double) {}
+    open fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {}
+    open fun cancel(t: Double) {}
+
+    /** Next time `poll` should run, or `null`. */
+    open fun deadline(): Double? = null
+    open fun poll(t: Double) {}
+
+    companion object {
+        /** Build the recognizer for `config.kind`, or `null` for unknown kinds. */
+        fun create(index: Int, config: GestureConfig, emit: EmitFn): Recognizer? = when (config.kind) {
+            "tap" -> TapRecognizer(index, config, emit)
+            "long_press" -> LongPressRecognizer(index, config, emit)
+            "pan" -> PanRecognizer(index, config, emit)
+            "swipe", "fling" -> SwipeRecognizer(index, config, emit)
+            "pinch" -> PinchRecognizer(index, config, emit)
+            "rotation" -> RotationRecognizer(index, config, emit)
+            else -> null
+        }
+    }
+}
+
+class TapRecognizer(index: Int, config: GestureConfig, emit: EmitFn) : Recognizer(index, config, emit) {
+    private val nTaps = max(1, config.nTaps)
+    private val slop = config.maxDistance
+    private var downPos: Point? = null
+    private var downTime = 0.0
+    private var tapCount = 0
+    private var lastTapTime = 0.0
+    private var failed = false
+    private var gapDeadline: Double? = null
+
+    override fun down(pointers: Map<Int, Point>, t: Double) {
+        if (pointers.size != 1) {
+            if (!failed) {
+                failed = true
+                fail()
+            }
+            return
+        }
+        if (tapCount > 0 && t - lastTapTime > MULTI_TAP_GAP_S) tapCount = 0
+        failed = false
+        gapDeadline = null
+        downPos = centroid(pointers)
+        downTime = t
+    }
+
+    override fun move(pointers: Map<Int, Point>, t: Double) {
+        val origin = downPos ?: return
+        if (failed) return
+        val c = centroid(pointers)
+        if (hypot(c.x - origin.x, c.y - origin.y) > slop) {
+            failed = true
+            fail()
+        }
+    }
+
+    override fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {
+        if (failed || downPos == null) {
+            reset()
+            return
+        }
+        if (t - downTime > MAX_TAP_DURATION_S) {
+            reset()
+            fail()
+            return
+        }
+        tapCount += 1
+        lastTapTime = t
+        if (tapCount >= nTaps) {
+            emit(GestureState.ENDED, "x" to x, "y" to y)
+            reset()
+        } else {
+            gapDeadline = t + MULTI_TAP_GAP_S
+        }
+        downPos = null
+    }
+
+    override fun cancel(t: Double) = reset()
+
+    override fun deadline(): Double? = gapDeadline
+
+    override fun poll(t: Double) {
+        val d = gapDeadline ?: return
+        if (t >= d) {
+            gapDeadline = null
+            tapCount = 0
+            fail()
+        }
+    }
+
+    private fun reset() {
+        downPos = null
+        if (tapCount >= nTaps) tapCount = 0
+        failed = false
+        gapDeadline = null
+    }
+
+    private companion object {
+        const val MAX_TAP_DURATION_S = 0.4
+        const val MULTI_TAP_GAP_S = 0.3
+    }
+}
+
+class LongPressRecognizer(index: Int, config: GestureConfig, emit: EmitFn) : Recognizer(index, config, emit) {
+    private val durationS = config.minDurationMs / 1000.0
+    private val slop = config.maxDistance
+    private var downPos: Point? = null
+    private var pressDeadline: Double? = null
+    private var active = false
+
+    override fun down(pointers: Map<Int, Point>, t: Double) {
+        downPos = centroid(pointers)
+        pressDeadline = t + durationS
+        active = false
+    }
+
+    override fun move(pointers: Map<Int, Point>, t: Double) {
+        val origin = downPos ?: return
+        val c = centroid(pointers)
+        if (hypot(c.x - origin.x, c.y - origin.y) > slop) {
+            if (active) emit(GestureState.CANCELLED, "x" to c.x, "y" to c.y)
+            reset()
+            fail()
+        }
+    }
+
+    override fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {
+        if (active) {
+            emit(GestureState.ENDED, "x" to x, "y" to y)
+        } else if (downPos != null) {
+            fail()
+        }
+        reset()
+    }
+
+    override fun cancel(t: Double) {
+        if (active) emit(GestureState.CANCELLED)
+        reset()
+    }
+
+    override fun deadline(): Double? = pressDeadline
+
+    override fun poll(t: Double) {
+        val d = pressDeadline ?: return
+        val origin = downPos ?: return
+        if (active) return
+        if (t >= d) {
+            active = true
+            pressDeadline = null
+            emit(GestureState.BEGAN, "x" to origin.x, "y" to origin.y)
+        }
+    }
+
+    private fun reset() {
+        downPos = null
+        pressDeadline = null
+        active = false
+    }
+}
+
+class PanRecognizer(index: Int, config: GestureConfig, emit: EmitFn) : Recognizer(index, config, emit) {
+    private val minDistance = config.minDistance
+    private val minPointers = max(1, config.minPointers)
+    private var origin: Point? = null
+    private var anchor: Point? = null
+    private val velocity = VelocityEstimator()
+    private var lastTranslation = Point(0.0, 0.0)
+
+    /** Whether the pan has activated (hosts use this to block parent interception). */
+    var active = false
+        private set
+
+    override fun down(pointers: Map<Int, Point>, t: Double) {
+        if (pointers.size < minPointers) return
+        if (origin == null) {
+            val c = centroid(pointers)
+            origin = c
+            velocity.reset()
+            velocity.add(c.x, c.y, t)
+        } else {
+            rebase(pointers)
+        }
+    }
+
+    override fun move(pointers: Map<Int, Point>, t: Double) {
+        val o = origin ?: return
+        if (pointers.size < minPointers) return
+        val c = centroid(pointers)
+        velocity.add(c.x, c.y, t)
+        if (!active) {
+            if (hypot(c.x - o.x, c.y - o.y) < minDistance) return
+            active = true
+            anchor = c
+            emit(GestureState.BEGAN, "x" to c.x, "y" to c.y, "pointer_count" to pointers.size)
+            return
+        }
+        val a = anchor ?: return
+        val v = velocity.velocity()
+        lastTranslation = Point(c.x - a.x, c.y - a.y)
+        emit(
+            GestureState.CHANGED,
+            "x" to c.x,
+            "y" to c.y,
+            "translation_x" to lastTranslation.x,
+            "translation_y" to lastTranslation.y,
+            "velocity_x" to v.x,
+            "velocity_y" to v.y,
+            "pointer_count" to pointers.size,
+        )
+    }
+
+    override fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {
+        if (active && pointers.size < minPointers) {
+            val v = velocity.velocity()
+            val a = anchor ?: Point(x, y)
+            emit(
+                GestureState.ENDED,
+                "x" to x,
+                "y" to y,
+                "translation_x" to x - a.x,
+                "translation_y" to y - a.y,
+                "velocity_x" to v.x,
+                "velocity_y" to v.y,
+                "pointer_count" to pointers.size,
+            )
+            reset()
+        } else if (pointers.isEmpty()) {
+            if (!active && origin != null) fail()
+            reset()
+        } else if (active) {
+            rebase(pointers)
+        }
+    }
+
+    override fun cancel(t: Double) {
+        if (active) emit(GestureState.CANCELLED)
+        reset()
+    }
+
+    private fun rebase(pointers: Map<Int, Point>) {
+        val a = anchor
+        if (!active || a == null) {
+            origin = centroid(pointers)
+            return
+        }
+        val c = centroid(pointers)
+        anchor = Point(c.x - lastTranslation.x, c.y - lastTranslation.y)
+    }
+
+    private fun reset() {
+        origin = null
+        anchor = null
+        active = false
+        velocity.reset()
+        lastTranslation = Point(0.0, 0.0)
+    }
+}
+
+/** Directional flick recognizer; also serves `fling` (adds a pointer-count requirement). */
+class SwipeRecognizer(index: Int, config: GestureConfig, emit: EmitFn) : Recognizer(index, config, emit) {
+    private val direction = config.direction
+    private val minVelocity = config.minVelocity
+    private val nPointers = max(1, config.nPointers)
+    private val velocity = VelocityEstimator()
+    private var tracking = false
+    private var maxPointers = 0
+
+    override fun down(pointers: Map<Int, Point>, t: Double) {
+        if (!tracking) {
+            velocity.reset()
+            tracking = true
+            maxPointers = 0
+        }
+        maxPointers = max(maxPointers, pointers.size)
+        val c = centroid(pointers)
+        velocity.add(c.x, c.y, t)
+    }
+
+    override fun move(pointers: Map<Int, Point>, t: Double) {
+        if (!tracking) return
+        maxPointers = max(maxPointers, pointers.size)
+        val c = centroid(pointers)
+        velocity.add(c.x, c.y, t)
+    }
+
+    override fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {
+        if (!tracking || pointers.isNotEmpty()) return
+        tracking = false
+        velocity.add(x, y, t)
+        val v = velocity.velocity()
+        val speed = hypot(v.x, v.y)
+        if (speed < minVelocity || maxPointers < nPointers) {
+            fail()
+            return
+        }
+        val resolved = if (abs(v.x) >= abs(v.y)) {
+            if (v.x > 0) "right" else "left"
+        } else {
+            if (v.y > 0) "down" else "up"
+        }
+        if (direction != "any" && direction != resolved) {
+            fail()
+            return
+        }
+        emit(
+            GestureState.ENDED,
+            "x" to x,
+            "y" to y,
+            "velocity_x" to v.x,
+            "velocity_y" to v.y,
+            "direction" to resolved,
+            "pointer_count" to maxPointers,
+        )
+    }
+
+    override fun cancel(t: Double) {
+        tracking = false
+        maxPointers = 0
+        velocity.reset()
+    }
+}
+
+class PinchRecognizer(index: Int, config: GestureConfig, emit: EmitFn) : Recognizer(index, config, emit) {
+    private var initial: Double? = null
+    private var active = false
+    private var scale = 1.0
+
+    private fun span(pointers: Map<Int, Point>): Double? {
+        if (pointers.size < 2) return null
+        val pts = pointers.values.take(2)
+        return hypot(pts[1].x - pts[0].x, pts[1].y - pts[0].y)
+    }
+
+    override fun down(pointers: Map<Int, Point>, t: Double) {
+        val s = span(pointers)
+        if (s != null && s > 0 && initial == null) {
+            initial = s
+            active = true
+            val c = centroid(pointers)
+            emit(GestureState.BEGAN, "x" to c.x, "y" to c.y, "scale" to 1.0, "pointer_count" to pointers.size)
+        }
+    }
+
+    override fun move(pointers: Map<Int, Point>, t: Double) {
+        val i = initial ?: return
+        if (!active) return
+        val s = span(pointers) ?: return
+        if (s <= 0) return
+        scale = s / i
+        val c = centroid(pointers)
+        emit(GestureState.CHANGED, "x" to c.x, "y" to c.y, "scale" to scale, "pointer_count" to pointers.size)
+    }
+
+    override fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {
+        if (active && pointers.size < 2) {
+            emit(GestureState.ENDED, "x" to x, "y" to y, "scale" to scale, "pointer_count" to pointers.size)
+            reset()
+        } else if (!active && pointers.isEmpty()) {
+            fail()
+        }
+    }
+
+    override fun cancel(t: Double) {
+        if (active) emit(GestureState.CANCELLED, "scale" to scale)
+        reset()
+    }
+
+    private fun reset() {
+        initial = null
+        active = false
+        scale = 1.0
+    }
+}
+
+class RotationRecognizer(index: Int, config: GestureConfig, emit: EmitFn) : Recognizer(index, config, emit) {
+    private var initial: Double? = null
+    private var active = false
+    private var rotation = 0.0
+
+    private fun angle(pointers: Map<Int, Point>): Double? {
+        if (pointers.size < 2) return null
+        val pts = pointers.values.take(2)
+        return atan2(pts[1].y - pts[0].y, pts[1].x - pts[0].x)
+    }
+
+    override fun down(pointers: Map<Int, Point>, t: Double) {
+        val a = angle(pointers)
+        if (a != null && initial == null) {
+            initial = a
+            active = true
+            val c = centroid(pointers)
+            emit(GestureState.BEGAN, "x" to c.x, "y" to c.y, "rotation" to 0.0, "pointer_count" to pointers.size)
+        }
+    }
+
+    override fun move(pointers: Map<Int, Point>, t: Double) {
+        val i = initial ?: return
+        if (!active) return
+        val a = angle(pointers) ?: return
+        var delta = a - i
+        while (delta > Math.PI) delta -= 2 * Math.PI
+        while (delta < -Math.PI) delta += 2 * Math.PI
+        rotation = delta
+        val c = centroid(pointers)
+        emit(GestureState.CHANGED, "x" to c.x, "y" to c.y, "rotation" to rotation, "pointer_count" to pointers.size)
+    }
+
+    override fun up(pointers: Map<Int, Point>, t: Double, x: Double, y: Double) {
+        if (active && pointers.size < 2) {
+            emit(GestureState.ENDED, "x" to x, "y" to y, "rotation" to rotation, "pointer_count" to pointers.size)
+            reset()
+        } else if (!active && pointers.isEmpty()) {
+            fail()
+        }
+    }
+
+    override fun cancel(t: Double) {
+        if (active) emit(GestureState.CANCELLED, "rotation" to rotation)
+        reset()
+    }
+
+    private fun reset() {
+        initial = null
+        active = false
+        rotation = 0.0
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/layout/NativeLayout.kt

@@ -0,0 +1,145 @@
+package com.pythonnative.runtime.layout
+
+import com.pythonnative.runtime.PNBridge
+import com.pythonnative.runtime.bridge.Op
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Native layout and measurement, with one result containing changed geometry. */
+object NativeLayout {
+    private class Entry(val yoga: YogaNode) {
+        val props = JSONObject()
+        val children = ArrayList<Long>()
+        var parent: Long? = null
+        var attached = false
+        var frame = floatArrayOf()
+    }
+    private val nodes = HashMap<Long, Entry>()
+    private var viewport = JSONObject()
+    private val detached = setOf("VirtualList", "Modal", "ScreenStack")
+    private val containers = detached + setOf("View", "Row", "Column", "ScrollView", "Screen", "Portal")
+    private var scheduled = false
+
+    fun containerDidLayout() {
+        if (scheduled) return
+        scheduled = true
+        android.os.Handler(android.os.Looper.getMainLooper()).post {
+            scheduled = false
+            val frames = compute(viewport)
+            if (frames.length() > 0) PNBridge.callPython("layout", 0, "", frames.toString())
+        }
+    }
+
+    fun reset() {
+        for (entry in nodes.values) if (entry.attached) entry.parent?.let { parent ->
+            nodes[parent]?.yoga?.let { it.remove(it.ptr, entry.yoga.ptr) }
+        }
+        for (entry in nodes.values) entry.yoga.close()
+        nodes.clear()
+        viewport = JSONObject()
+    }
+
+    fun parent(tag: Long): Long? = nodes[tag]?.parent
+
+    fun observe(ops: List<Op>) {
+        for (op in ops) when (op) {
+            is Op.Create -> {
+                val entry = Entry(YogaNode(op.tag))
+                nodes[op.tag] = entry
+                update(entry, op.props)
+            }
+            is Op.Update -> nodes[op.tag]?.let { update(it, op.changed) }
+            is Op.Insert -> {
+                val parent = nodes[op.parent] ?: continue
+                val child = nodes[op.child] ?: continue
+                child.parent?.let { old -> nodes[old]?.let { previous ->
+                    previous.children.remove(op.child)
+                    if (child.attached) previous.yoga.remove(previous.yoga.ptr, child.yoga.ptr)
+                } }
+                child.parent = op.parent
+                parent.children.add(op.index.coerceAtMost(parent.children.size), op.child)
+                child.attached = PNBridge.registry.get(op.parent)?.typeName !in detached
+                if (child.attached) parent.yoga.insert(parent.yoga.ptr, child.yoga.ptr, op.index)
+            }
+            is Op.Destroy -> nodes.remove(op.tag)?.let { child ->
+                child.parent?.let { old -> nodes[old]?.let { parent ->
+                    parent.children.remove(op.tag)
+                    if (child.attached) parent.yoga.remove(parent.yoga.ptr, child.yoga.ptr)
+                } }
+                child.yoga.close()
+            }
+            is Op.Frame -> Unit
+        }
+    }
+
+    private fun update(entry: Entry, changed: JSONObject) {
+        for (key in changed.keys()) {
+            if (changed.isNull(key)) entry.props.remove(key) else entry.props.put(key, changed.get(key))
+        }
+        val yoga = entry.yoga
+        yoga.resetStyle(yoga.ptr)
+        for (key in entry.props.keys()) {
+            val value = entry.props.get(key)
+            if (value is JSONObject && key in setOf("margin", "padding")) {
+                for (edge in value.keys()) yoga.style(yoga.ptr, if (edge == "all") key else "${key}_$edge", value.get(edge).toString())
+            } else yoga.style(yoga.ptr, key, value.toString())
+        }
+        val type = PNBridge.registry.get(yoga.tag)?.typeName
+        if (type in setOf("ScrollView", "VirtualList", "ScreenStack")) yoga.style(yoga.ptr, "flex_shrink", "1")
+        yoga.measureLeaf(yoga.ptr, entry.children.isEmpty() && type !in containers)
+    }
+
+    fun compute(request: JSONObject): JSONArray {
+        viewport = request
+        val width = request.optDouble("width").toFloat()
+        val height = request.optDouble("height").toFloat()
+        if (!width.isFinite() || !height.isFinite() || width <= 0 || height <= 0) return JSONArray()
+        val roots = request.optJSONArray("roots") ?: JSONArray()
+        val rootTags = (0 until roots.length()).map { roots.getLong(it) }.toSet()
+        for (tag in rootTags) nodes[tag]?.yoga?.let { it.calculate(it.ptr, width, height) }
+        // Portals have no on-screen parent. Their own Yoga node supplies the
+        // viewport for all children, including absolute insets and sibling layout.
+        for ((tag, entry) in nodes) {
+            val record = PNBridge.registry.get(tag) ?: continue
+            if (record.typeName != "Portal") continue
+            val containerWidth = record.view.width / PNBridge.density()
+            val containerHeight = record.view.height / PNBridge.density()
+            val portalWidth = if (containerWidth > 0) containerWidth else width
+            val portalHeight = if (containerHeight > 0) containerHeight else height
+            entry.yoga.style(entry.yoga.ptr, "width", portalWidth.toString())
+            entry.yoga.style(entry.yoga.ptr, "height", portalHeight.toString())
+            entry.yoga.calculate(entry.yoga.ptr, portalWidth, portalHeight)
+        }
+        for (entry in nodes.values) if (entry.parent != null && !entry.attached) {
+            val parent = PNBridge.registry.get(entry.parent!!)
+            val record = PNBridge.registry.get(entry.yoga.tag)
+            val container = if (record?.typeName == "Screen") record.view else parent?.view
+            val availableWidth = (container?.width ?: 0) / PNBridge.density()
+            val availableHeight = (container?.height ?: 0) / PNBridge.density()
+            val isList = parent?.typeName == "VirtualList"
+            val horizontal = parent?.props?.optBoolean("horizontal", false) ?: false
+            entry.yoga.calculate(entry.yoga.ptr, if (isList && horizontal) Float.NaN else if (availableWidth > 0) availableWidth else width,
+                if (isList && !horizontal) Float.NaN else if (availableHeight > 0) availableHeight else height)
+        }
+        val frames = JSONArray()
+        for ((tag, entry) in nodes) {
+            val frame = entry.yoga.frame(entry.yoga.ptr)
+            if (frame.contentEquals(entry.frame)) continue
+            entry.frame = frame
+            if (tag !in rootTags) PNBridge.registry.get(tag)?.let { record ->
+                record.frame = frame.map { it.toDouble() }.toDoubleArray()
+                record.manager.setFrame(record.view, frame[0].toDouble(), frame[1].toDouble(), frame[2].toDouble(), frame[3].toDouble())
+            }
+            com.pythonnative.runtime.components.VirtualListManager.measured(tag, frame[2].toDouble(), frame[3].toDouble())
+            frames.put(JSONArray().put(tag).put(frame[0]).put(frame[1]).put(frame[2]).put(frame[3]))
+        }
+        return frames
+    }
+
+    fun invalidate(tag: Long) {
+        val entry = nodes[tag] ?: return
+        if (entry.children.isNotEmpty()) return
+        entry.yoga.measureLeaf(entry.yoga.ptr, true)
+        PNBridge.callPython("layout", 0, "", compute(viewport).toString())
+    }
+}

pythonnative/native/android/src/main/java/com/pythonnative/runtime/layout/YogaNode.kt

@@ -0,0 +1,29 @@
+package com.pythonnative.runtime.layout
+
+import android.widget.TextView
+import com.pythonnative.runtime.PNBridge
+
+/** Explicit ownership of a node in the pinned, shared Yoga core. */
+class YogaNode(val tag: Long) : AutoCloseable {
+    companion object { init { System.loadLibrary("pn_yoga") } }
+    val ptr = create()
+    private var closed = false
+    private external fun create(): Long
+    private external fun free(ptr: Long)
+    external fun style(ptr: Long, key: String, value: String)
+    external fun resetStyle(ptr: Long)
+    external fun measureLeaf(ptr: Long, enabled: Boolean)
+    external fun insert(ptr: Long, child: Long, index: Int)
+    external fun remove(ptr: Long, child: Long)
+    external fun calculate(ptr: Long, width: Float, height: Float)
+    external fun frame(ptr: Long): FloatArray
+    fun measure(width: Float, height: Float): FloatArray {
+        val record = PNBridge.registry.get(tag) ?: return floatArrayOf(0f, 0f)
+        return record.manager.measure(record.view, width.toDouble(), height.toDouble())
+    }
+    fun baseline(height: Float): Float {
+        val view = PNBridge.registry.get(tag)?.view as? TextView ?: return height
+        return -view.paint.fontMetrics.ascent / PNBridge.density()
+    }
+    override fun close() { if (!closed) { closed = true; free(ptr) } }
+}