pythonnative 0.20.0__py3-none-any.whl → 0.22.0__py3-none-any.whl

pythonnative/native_views/android.py

@@ -6,14 +6,27 @@ and frame application. Handlers are registered with the
 [`NativeViewRegistry`][pythonnative.native_views.NativeViewRegistry] by
 [`register_handlers`][pythonnative.native_views.android.register_handlers].
 
-Layout is owned by the pure-Python flex engine in
-[`pythonnative.layout`][pythonnative.layout]: container handlers create
-plain `FrameLayout`s, the engine computes per-child frames, and
+**Batched protocol**: the registry applies the reconciler's mutation
+ops; handlers receive callable-free props. User callbacks never reach
+this module — every interaction (clicks, text changes, scrolls,
+gestures) is forwarded through
+[`dispatch_event`][pythonnative.events.dispatch_event] keyed by the
+view's reconciler-assigned tag.
+
+**Layout** is owned by the pure-Python flex engine in
+`pythonnative.layout`: container handlers create plain `FrameLayout`s,
+the engine computes per-child frames, and
 [`set_frame`][pythonnative.native_views.android.AndroidViewHandler.set_frame]
-applies those frames via per-child `MarginLayoutParams`. Handlers
-therefore only deal with *visual* props — text, colors, callbacks — and
-ignore everything in
-[`pythonnative.layout.LAYOUT_STYLE_KEYS`][pythonnative.layout.LAYOUT_STYLE_KEYS].
+applies those frames via per-child `MarginLayoutParams`.
+
+**Gestures** feed raw ``MotionEvent`` streams into the shared
+pure-Python [`GestureArbiter`][pythonnative.gestures.GestureArbiter],
+so gesture semantics match the desktop preview exactly.
+
+**Animations**: ``timing`` animations on transform/opacity/color props
+are driven natively by ``ObjectAnimator`` (Choreographer-paced, no
+Python per-frame work); springs and decay fall back to the Python
+ticker.
 
 This module is only imported on Android at runtime. Desktop tests
 inject a mock registry via
@@ -22,20 +35,16 @@ trigger this import path.
 """
 
 import math
+import time
 from typing import Any, Callable, Dict, Optional, Tuple
 
 from java import dynamic_proxy, jclass
 
+from ..events import dispatch_event, event_names
+from ..gestures import make_arbiter
 from ..utils import get_android_context
 from .base import ViewHandler, _safe_max, parse_color_int
 
-_pn_text_input_watchers: dict = {}
-_pn_text_input_callbacks: dict = {}
-_pn_text_input_suppress_callbacks: dict = {}
-_pn_text_input_focus_listeners: dict = {}
-_pn_text_input_focus_callbacks: dict = {}
-_pn_text_input_clear_touch: dict = {}
-_pn_view_visual_props: dict = {}
 _DRAWABLE_STYLE_KEYS = ("background_color", "border_radius", "border_width", "border_color")
 
 
@@ -56,6 +65,59 @@ def _dp(value: float) -> int:
     return int(round(value * _density()))
 
 
+def _java_id(jobj: Any) -> int:
+    """Return ``System.identityHashCode(jobj)`` as a stable lookup key.
+
+    Chaquopy's ``JavaObject.__setattr__`` rejects unknown Python
+    attributes, so per-view bookkeeping can't live on the wrapper.
+    The JVM identity hash is stable for the lifetime of the Java
+    object and identical across every Python wrapper that proxies it.
+    """
+    System = jclass("java.lang.System")
+    return int(System.identityHashCode(jobj))
+
+
+# Tag table: java identity -> reconciler tag, and tag -> per-view state.
+_view_tags: Dict[int, int] = {}
+_view_state: Dict[int, Dict[str, Any]] = {}
+
+
+def _remember(view: Any, tag: int) -> None:
+    _view_tags[_java_id(view)] = tag
+    _view_state[tag] = {"props": {}}
+
+
+def _tag_of(view: Any) -> Optional[int]:
+    return _view_tags.get(_java_id(view))
+
+
+def _state_of(view: Any) -> Dict[str, Any]:
+    tag = _tag_of(view)
+    if tag is None:
+        return {}
+    return _view_state.setdefault(tag, {"props": {}})
+
+
+def _forget(view: Any) -> None:
+    tag = _view_tags.pop(_java_id(view), None)
+    if tag is not None:
+        _view_state.pop(tag, None)
+
+
+def _fire(view: Any, name: str, *args: Any) -> bool:
+    """Dispatch event ``name`` for ``view`` through the tag registry."""
+    tag = _tag_of(view)
+    if tag is None:
+        return False
+    return dispatch_event(tag, name, *args)
+
+
+def _has_event(view: Any, name: str) -> bool:
+    """Whether the element wired a callback named ``name`` this render."""
+    merged = _state_of(view).get("props") or {}
+    return name in event_names(merged)
+
+
 def _apply_border(view: Any, props: Dict[str, Any]) -> None:
     """Apply border_radius / border_width / border_color via a GradientDrawable.
 
@@ -191,11 +253,12 @@ def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
     """Apply visual properties shared across many handlers."""
     has_drawable_keys = any(k in props for k in _DRAWABLE_STYLE_KEYS)
     if has_drawable_keys:
-        visual_props = dict(_pn_view_visual_props.get(id(view), {}))
+        state = _state_of(view)
+        visual_props = dict(state.get("visual") or {})
         for key in _DRAWABLE_STYLE_KEYS:
             if key in props:
                 visual_props[key] = props[key]
-        _pn_view_visual_props[id(view)] = visual_props
+        state["visual"] = visual_props
         _apply_border(view, visual_props)
     if "overflow" in props:
         clip = props["overflow"] == "hidden"
@@ -215,19 +278,299 @@ def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
 
 
 # ======================================================================
-# Base class with shared frame/measure implementations
+# Gesture wiring (MotionEvent -> GestureArbiter -> dispatch_event)
 # ======================================================================
 
 
-class AndroidViewHandler(ViewHandler):
-    """Base class providing the shared `set_frame` / measure contract.
+def _wire_gestures(view: Any, specs: Any) -> None:
+    """Feed ``MotionEvent`` streams on ``view`` into a `GestureArbiter`.
+
+    The arbiter emits ``(gesture_index, payload)`` pairs which are
+    forwarded as ``gesture:<i>`` events for this view's tag. Long
+    presses are polled with a main-looper ``Handler``. When a pan
+    activates, the parent is asked not to intercept so an enclosing
+    ScrollView can't steal the drag.
+    """
+    state = _state_of(view)
+    if not isinstance(specs, (list, tuple)) or not specs:
+        state["arbiter"] = None
+        return
+
+    def _emit(index: int, payload: Dict[str, Any]) -> None:
+        _fire(view, f"gesture:{index}", payload)
+
+    arbiter = make_arbiter([s for s in specs if isinstance(s, dict)], _emit)
+    state["arbiter"] = arbiter
+    if state.get("gestures_bound"):
+        return
+    state["gestures_bound"] = True
+    _bind_touch_stream(view, state)
+
+
+def _schedule_arbiter_poll(view: Any, state: Dict[str, Any]) -> None:
+    """Schedule a main-looper poll at the arbiter's next deadline (long-press)."""
+    arbiter = state.get("arbiter")
+    if arbiter is None:
+        return
+    deadline = arbiter.next_deadline()
+    if deadline is None:
+        return
+    delay_ms = max(1, int((deadline - time.monotonic()) * 1000.0))
+    try:
+        Handler = jclass("android.os.Handler")
+        Looper = jclass("android.os.Looper")
+        Runnable = jclass("java.lang.Runnable")
+        handler = state.get("poll_handler")
+        if handler is None:
+            handler = Handler(Looper.getMainLooper())
+            state["poll_handler"] = handler
+
+        class _PollRunnable(dynamic_proxy(Runnable)):
+            def run(self) -> None:
+                live = state.get("arbiter")
+                if live is not None:
+                    live.poll(time.monotonic())
+                    _schedule_arbiter_poll(view, state)
+
+        handler.postDelayed(_PollRunnable(), delay_ms)
+    except Exception:
+        pass
+
+
+def _bind_touch_stream(view: Any, state: Dict[str, Any]) -> None:
+    """Install one ``OnTouchListener`` that forwards every pointer to the arbiter."""
+    try:
+        OnTouchListener = jclass("android.view.View$OnTouchListener")
+
+        class _GestureTouchProxy(dynamic_proxy(OnTouchListener)):
+            def onTouch(self, v: Any, event: Any) -> bool:
+                return bool(_feed_motion_event(v, state, event))
+
+        view.setOnTouchListener(_GestureTouchProxy())
+    except Exception:
+        pass
+
+
+def _feed_motion_event(view: Any, state: Dict[str, Any], event: Any) -> bool:
+    """Translate one ``MotionEvent`` into arbiter pointer calls.
+
+    Returns ``True`` to keep receiving the stream while any gesture
+    spec is wired.
+    """
+    arbiter = state.get("arbiter")
+    if arbiter is None:
+        return False
+    try:
+        action = int(event.getActionMasked())
+        t = time.monotonic()
+        density = _density() or 1.0
+        if action in (0, 5):  # DOWN / POINTER_DOWN
+            idx = int(event.getActionIndex())
+            pid = int(event.getPointerId(idx))
+            arbiter.pointer_down(pid, float(event.getX(idx)) / density, float(event.getY(idx)) / density, t)
+            _schedule_arbiter_poll(view, state)
+        elif action == 2:  # MOVE
+            for i in range(int(event.getPointerCount())):
+                pid = int(event.getPointerId(i))
+                arbiter.pointer_move(pid, float(event.getX(i)) / density, float(event.getY(i)) / density, t)
+            if arbiter.has_active_pan():
+                try:
+                    parent = view.getParent()
+                    if parent is not None:
+                        parent.requestDisallowInterceptTouchEvent(True)
+                except Exception:
+                    pass
+        elif action in (1, 6):  # UP / POINTER_UP
+            idx = int(event.getActionIndex())
+            pid = int(event.getPointerId(idx))
+            arbiter.pointer_up(pid, float(event.getX(idx)) / density, float(event.getY(idx)) / density, t)
+        elif action == 3:  # CANCEL
+            arbiter.cancel(t)
+        return True
+    except Exception:
+        return True
+
+
+# ======================================================================
+# Native-driven animations (ObjectAnimator)
+# ======================================================================
+
+_native_anims: Dict[int, Dict[str, Any]] = {}
+
+
+def _interpolator_for(easing: str) -> Any:
+    mapping = {
+        "linear": "android.view.animation.LinearInterpolator",
+        "ease_in": "android.view.animation.AccelerateInterpolator",
+        "ease_out": "android.view.animation.DecelerateInterpolator",
+        "ease_in_out": "android.view.animation.AccelerateDecelerateInterpolator",
+    }
+    cls = mapping.get(easing, "android.view.animation.AccelerateDecelerateInterpolator")
+    return jclass(cls)()
+
+
+_ANIMATABLE_FLOAT_PROPS = {
+    "opacity": ("alpha", 1.0),
+    "translate_x": ("translationX", None),  # dp -> px scaling
+    "translate_y": ("translationY", None),
+    "scale_x": ("scaleX", 1.0),
+    "scale_y": ("scaleY", 1.0),
+    "rotate": ("rotation", 1.0),
+}
+
 
-    All Android handlers go through `set_frame` to apply the layout
-    engine's computed frames as `MarginLayoutParams` mutations.
-    Container handlers inherit the default `add_child` /
-    `remove_child` implementations; leaves leave them as no-ops.
+def _read_animated_value(view: Any, prop_name: str) -> Any:
+    """Read the current (presentation) value of an animatable property."""
+    try:
+        density = _density() or 1.0
+        if prop_name == "opacity":
+            return float(view.getAlpha())
+        if prop_name == "translate_x":
+            return float(view.getTranslationX()) / density
+        if prop_name == "translate_y":
+            return float(view.getTranslationY()) / density
+        if prop_name in ("scale", "scale_x"):
+            return float(view.getScaleX())
+        if prop_name == "scale_y":
+            return float(view.getScaleY())
+        if prop_name == "rotate":
+            return float(view.getRotation())
+    except Exception:
+        pass
+    return None
+
+
+def _make_end_listener(anim_id: int) -> Any:
+    """Build an ``Animator.AnimatorListener`` that reports completion to Python."""
+    AnimatorListener = jclass("android.animation.Animator$AnimatorListener")
+
+    class _EndProxy(dynamic_proxy(AnimatorListener)):
+        def __init__(self) -> None:
+            super().__init__()
+            self._cancelled = False
+
+        def onAnimationStart(self, animation: Any) -> None:
+            pass
+
+        def onAnimationRepeat(self, animation: Any) -> None:
+            pass
+
+        def onAnimationCancel(self, animation: Any) -> None:
+            self._cancelled = True
+
+        def onAnimationEnd(self, animation: Any) -> None:
+            entry = _native_anims.pop(anim_id, None)
+            if entry is None:
+                return
+            try:
+                from ..animated import native_animation_completed
+
+                native_animation_completed(anim_id, not self._cancelled)
+            except Exception:
+                pass
+
+    return _EndProxy()
+
+
+def _start_native_timing(view: Any, anim_id: int, prop_name: str, spec: Dict[str, Any]) -> bool:
+    """Drive a ``timing`` spec with ``ObjectAnimator``. Returns success."""
+    try:
+        ObjectAnimator = jclass("android.animation.ObjectAnimator")
+        from_val = float(spec.get("from", 0.0))
+        to_val = float(spec.get("to", 0.0))
+        duration = max(0, int(float(spec.get("duration_ms", 300.0))))
+        density = _density() or 1.0
+
+        if prop_name == "background_color":
+            animator = ObjectAnimator.ofArgb(
+                view,
+                "backgroundColor",
+                parse_color_int(int(from_val)),
+                parse_color_int(int(to_val)),
+            )
+        elif prop_name == "scale":
+            AnimatorSet = jclass("android.animation.AnimatorSet")
+            sx = ObjectAnimator.ofFloat(view, "scaleX", from_val, to_val)
+            sy = ObjectAnimator.ofFloat(view, "scaleY", from_val, to_val)
+            group = AnimatorSet()
+            group.playTogether([sx, sy])
+            group.setDuration(duration)
+            group.setInterpolator(_interpolator_for(str(spec.get("easing", "ease_in_out"))))
+            group.addListener(_make_end_listener(anim_id))
+            _native_anims[anim_id] = {"animator": group, "view": view, "prop": prop_name}
+            group.start()
+            return True
+        else:
+            java_prop, scale = _ANIMATABLE_FLOAT_PROPS.get(prop_name, (None, None))
+            if java_prop is None:
+                return False
+            factor = density if scale is None else scale
+            animator = ObjectAnimator.ofFloat(view, java_prop, from_val * factor, to_val * factor)
+
+        animator.setDuration(duration)
+        animator.setInterpolator(_interpolator_for(str(spec.get("easing", "ease_in_out"))))
+        animator.addListener(_make_end_listener(anim_id))
+        _native_anims[anim_id] = {"animator": animator, "view": view, "prop": prop_name}
+        animator.start()
+        return True
+    except Exception:
+        _native_anims.pop(anim_id, None)
+        return False
+
+
+# ======================================================================
+# Base class with shared frame/measure/animation implementations
+# ======================================================================
+
+
+class AndroidViewHandler(ViewHandler):
+    """Base class providing the shared protocol implementation.
+
+    Subclasses implement
+    [`_build`][pythonnative.native_views.android.AndroidViewHandler._build]
+    (construct the widget) and
+    [`_apply`][pythonnative.native_views.android.AndroidViewHandler._apply]
+    (apply visual props); the base class owns tag registration,
+    gesture wiring, frame application, intrinsic measurement, and the
+    animation hooks.
     """
 
+    def create(self, tag: int, props: Dict[str, Any]) -> Any:
+        view = self._build(props)
+        _remember(view, tag)
+        _state_of(view)["props"] = dict(props)
+        self._apply(view, props, initial=True)
+        if props.get("gestures"):
+            _wire_gestures(view, props.get("gestures"))
+        return view
+
+    def update(self, native_view: Any, changed_props: Dict[str, Any]) -> None:
+        state = _state_of(native_view)
+        merged = state.setdefault("props", {})
+        merged.update(changed_props)
+        self._apply(native_view, changed_props, initial=False)
+        if "gestures" in changed_props:
+            _wire_gestures(native_view, changed_props.get("gestures"))
+
+    def destroy(self, native_view: Any) -> None:
+        self._teardown(native_view)
+        try:
+            parent = native_view.getParent()
+            if parent is not None:
+                parent.removeView(native_view)
+        except Exception:
+            pass
+        _forget(native_view)
+
+    def _build(self, props: Dict[str, Any]) -> Any:
+        raise NotImplementedError
+
+    def _apply(self, view: Any, props: Dict[str, Any], initial: bool) -> None:
+        _apply_common_visual(view, props)
+
+    def _teardown(self, native_view: Any) -> None:
+        """Subclass hook for extra cleanup before the view is released."""
+
     def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
         if native_view is None:
             return
@@ -285,46 +628,11 @@ class AndroidViewHandler(ViewHandler):
         except Exception:
             return (0.0, 0.0)
 
-    def set_animated_property(
-        self,
-        native_view: Any,
-        prop_name: str,
-        value: Any,
-        duration_ms: float = 0.0,
-        easing: str = "linear",
-    ) -> None:
-        """Apply ``prop_name`` to ``native_view`` immediately or animated.
-
-        When ``duration_ms > 0``, the change is wrapped in a
-        ``ViewPropertyAnimator`` so Choreographer drives the
-        per-frame interpolation.
-        """
+    def set_animated_property(self, native_view: Any, prop_name: str, value: Any) -> None:
+        """Apply one Python-driven animation frame immediately."""
         if native_view is None:
             return
         try:
-            if duration_ms > 0:
-                animator = native_view.animate()
-                animator.setDuration(int(duration_ms))
-                if prop_name == "opacity":
-                    animator.alpha(float(value))
-                elif prop_name == "translate_x":
-                    animator.translationX(float(_dp(float(value))))
-                elif prop_name == "translate_y":
-                    animator.translationY(float(_dp(float(value))))
-                elif prop_name == "scale":
-                    animator.scaleX(float(value))
-                    animator.scaleY(float(value))
-                elif prop_name == "scale_x":
-                    animator.scaleX(float(value))
-                elif prop_name == "scale_y":
-                    animator.scaleY(float(value))
-                elif prop_name == "rotate":
-                    animator.rotation(float(value))
-                else:
-                    return
-                animator.start()
-                return
-            # Immediate path.
             if prop_name == "opacity":
                 native_view.setAlpha(float(value))
             elif prop_name == "translate_x":
@@ -345,6 +653,35 @@ class AndroidViewHandler(ViewHandler):
         except Exception:
             pass
 
+    def start_animation(
+        self,
+        native_view: Any,
+        anim_id: int,
+        prop_name: str,
+        spec: Dict[str, Any],
+    ) -> bool:
+        """Run ``timing`` specs on ``ObjectAnimator``; reject the rest.
+
+        Springs and decay need the exact physics integration the
+        Python ticker implements, so they return ``False`` and fall
+        back rather than approximating with an interpolator.
+        """
+        if native_view is None or not isinstance(spec, dict):
+            return False
+        if str(spec.get("kind", "")) != "timing":
+            return False
+        return _start_native_timing(native_view, anim_id, prop_name, spec)
+
+    def cancel_animation(self, native_view: Any, anim_id: int) -> Any:
+        entry = _native_anims.pop(anim_id, None)
+        if entry is None:
+            return None
+        try:
+            entry["animator"].cancel()
+        except Exception:
+            pass
+        return _read_animated_value(entry.get("view"), str(entry.get("prop", "")))
+
 
 # ======================================================================
 # Flex container handler (shared by Column, Row, View)
@@ -360,32 +697,43 @@ class FlexContainerHandler(AndroidViewHandler):
     The container itself is just a positioning surface.
     """
 
-    def create(self, props: Dict[str, Any]) -> Any:
-        fl = jclass("android.widget.FrameLayout")(_ctx())
-        _apply_common_visual(fl, props)
-        return fl
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        _apply_common_visual(native_view, changed)
+    def _build(self, props: Dict[str, Any]) -> Any:
+        return jclass("android.widget.FrameLayout")(_ctx())
 
-    def add_child(self, parent: Any, child: Any) -> None:
-        FrameLP = jclass("android.widget.FrameLayout$LayoutParams")
-        lp = child.getLayoutParams()
-        if lp is None:
-            lp = FrameLP(0, 0)
-            child.setLayoutParams(lp)
-        parent.addView(child)
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+        _insert_view(parent, child, index)
 
     def remove_child(self, parent: Any, child: Any) -> None:
-        parent.removeView(child)
+        try:
+            parent.removeView(child)
+        except Exception:
+            pass
 
-    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+
+def _insert_view(parent: Any, child: Any, index: int) -> None:
+    """Move-aware indexed insert into any ``ViewGroup``."""
+    try:
+        current_parent = child.getParent()
+        count = int(parent.getChildCount())
+        if current_parent is not None and _java_id(current_parent) == _java_id(parent):
+            current_index = int(parent.indexOfChild(child))
+            target = max(0, min(index, count - 1))
+            if current_index == target:
+                return
+            parent.removeView(child)
+            parent.addView(child, max(0, min(target, int(parent.getChildCount()))))
+            return
+        if current_parent is not None:
+            current_parent.removeView(child)
         FrameLP = jclass("android.widget.FrameLayout$LayoutParams")
-        lp = child.getLayoutParams()
-        if lp is None:
-            lp = FrameLP(0, 0)
-            child.setLayoutParams(lp)
-        parent.addView(child, index)
+        if child.getLayoutParams() is None:
+            child.setLayoutParams(FrameLP(0, 0))
+        parent.addView(child, max(0, min(index, int(parent.getChildCount()))))
+    except Exception:
+        try:
+            parent.addView(child)
+        except Exception:
+            pass
 
 
 # ======================================================================
@@ -411,15 +759,10 @@ def _typeface_for(weight: Any, italic: bool) -> Any:
 
 
 class TextHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
-        tv = jclass("android.widget.TextView")(_ctx())
-        self._apply(tv, props)
-        return tv
+    def _build(self, props: Dict[str, Any]) -> Any:
+        return jclass("android.widget.TextView")(_ctx())
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
-
-    def _apply(self, tv: Any, props: Dict[str, Any]) -> None:
+    def _apply(self, tv: Any, props: Dict[str, Any], initial: bool) -> None:
         if "text" in props:
             tv.setText(str(props["text"]) if props["text"] is not None else "")
         if "font_size" in props and props["font_size"] is not None:
@@ -429,9 +772,10 @@ class TextHandler(AndroidViewHandler):
         if any(k in props for k in ("font_family", "font_weight", "italic", "bold")):
             try:
                 Typeface = jclass("android.graphics.Typeface")
-                family = props.get("font_family")
-                weight = props.get("font_weight") or ("bold" if props.get("bold") else None)
-                italic = bool(props.get("italic"))
+                merged = _state_of(tv).get("props") or props
+                family = merged.get("font_family")
+                weight = merged.get("font_weight") or ("bold" if merged.get("bold") else None)
+                italic = bool(merged.get("italic"))
                 style = _typeface_for(weight, italic)
                 if family:
                     base = Typeface.create(str(family), style)
@@ -450,13 +794,15 @@ class TextHandler(AndroidViewHandler):
             try:
                 # Android expects letter_spacing as ems (a unitless ratio of font size).
                 # Convert from points by dividing by ~font_size; if no font size, use 16.
-                size = float(props.get("font_size") or 16.0)
+                merged = _state_of(tv).get("props") or props
+                size = float(merged.get("font_size") or 16.0)
                 tv.setLetterSpacing(float(props["letter_spacing"]) / max(size, 1.0))
             except Exception:
                 pass
         if "line_height" in props and props["line_height"] is not None:
             try:
-                size = float(props.get("font_size") or 16.0)
+                merged = _state_of(tv).get("props") or props
+                size = float(merged.get("font_size") or 16.0)
                 tv.setLineSpacing(0.0, float(props["line_height"]) / max(size, 1.0))
             except Exception:
                 pass
@@ -475,15 +821,17 @@ class TextHandler(AndroidViewHandler):
 
 
 class ButtonHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         btn = jclass("android.widget.Button")(_ctx())
-        self._apply(btn, props)
-        return btn
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
+        class ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
+            def onClick(self, view: Any) -> None:
+                _fire(view, "on_click")
+
+        btn.setOnClickListener(ClickProxy())
+        return btn
 
-    def _apply(self, btn: Any, props: Dict[str, Any]) -> None:
+    def _apply(self, btn: Any, props: Dict[str, Any], initial: bool) -> None:
         if "title" in props:
             btn.setText(str(props["title"]) if props["title"] is not None else "")
         if "font_size" in props and props["font_size"] is not None:
@@ -492,88 +840,72 @@ class ButtonHandler(AndroidViewHandler):
             btn.setTextColor(parse_color_int(props["color"]))
         if "enabled" in props:
             btn.setEnabled(bool(props["enabled"]))
-        if "on_click" in props:
-            cb = props["on_click"]
-            if cb is not None:
-
-                class ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
-                    def __init__(self, callback: Callable[[], None]) -> None:
-                        super().__init__()
-                        self.callback = callback
-
-                    def onClick(self, view: Any) -> None:
-                        self.callback()
-
-                btn.setOnClickListener(ClickProxy(cb))
-            else:
-                btn.setOnClickListener(None)
         _apply_common_visual(btn, props)
 
 
-_pn_scrollview_state: Dict[int, Dict[str, Any]] = {}
-
-
 class ScrollViewHandler(AndroidViewHandler):
     """Scroll container — wraps a single child whose height is unbounded.
 
-    Uses ``androidx.core.widget.NestedScrollView`` rather than the
-    framework ``android.widget.ScrollView`` because the framework
-    ScrollView always intercepts vertical gestures, even when it has
-    no overflow. That breaks the common case of nesting a small
-    fixed-height scroll view inside a screen-level scroll view (the
-    outer steals every gesture and the inner never scrolls).
-    ``NestedScrollView`` implements the standard
-    ``NestedScrollingParent2`` / ``NestedScrollingChild2`` protocol so
-    the outer cooperates with any nested scroll, only consuming
-    leftover scroll when its child reaches its limit.
+    Uses ``androidx.core.widget.NestedScrollView`` (vertical) or
+    ``android.widget.HorizontalScrollView`` so nested scroll views
+    cooperate instead of fighting over gestures.
 
     When a ``refresh_control`` prop is provided at creation, the scroll
-    view is wrapped in an ``androidx.swiperefreshlayout.widget.SwipeRefreshLayout``
-    (the returned view is the wrapper, and child management forwards
-    into the inner scroll view) so pull-to-refresh matches the iOS
-    ``UIRefreshControl`` path. Without ``refresh_control`` the bare
-    scroll view is returned unchanged.
+    view is wrapped in a ``SwipeRefreshLayout`` (the returned view is
+    the wrapper, and child management forwards into the inner scroll
+    view) so pull-to-refresh matches the iOS ``UIRefreshControl`` path.
+
+    Scroll offsets are reported as ``on_scroll`` events with a
+    ``{"x": pts, "y": pts}`` payload. Imperative commands:
+    ``scroll_to_offset`` / ``scroll_to_end`` / ``get_scroll_offset``.
     """
 
-    def create(self, props: Dict[str, Any]) -> Any:
-        try:
-            sv = jclass("androidx.core.widget.NestedScrollView")(_ctx())
-        except Exception:
-            sv = jclass("android.widget.ScrollView")(_ctx())
-        _apply_common_visual(sv, props)
-        self._apply_scroll_props(sv, props)
-        if props.get("refresh_control"):
+    def create(self, tag: int, props: Dict[str, Any]) -> Any:
+        horizontal = props.get("scroll_axis") == "horizontal"
+        if horizontal:
+            sv = jclass("android.widget.HorizontalScrollView")(_ctx())
+        else:
+            try:
+                sv = jclass("androidx.core.widget.NestedScrollView")(_ctx())
+            except Exception:
+                sv = jclass("android.widget.ScrollView")(_ctx())
+
+        # Vertical scroll views are *always* wrapped in a (disabled)
+        # SwipeRefreshLayout. Wrapping later is impossible — the
+        # reconciler may reuse this view for a screen that adds a
+        # ``refresh_control`` prop afterwards (e.g. navigation swapping
+        # screens of the same shape), and re-parenting a mounted view
+        # mid-update is not safe. ``_apply_refresh`` simply toggles the
+        # wrapper's enabled state as the prop comes and goes.
+        outer = sv
+        if not horizontal:
             wrapper = self._wrap_in_refresh(sv)
             if wrapper is not None:
-                _pn_scrollview_state[id(wrapper)] = {
-                    "scroll": sv,
-                    "refresh": wrapper,
-                    "on_refresh": None,
-                    "listener_bound": False,
-                }
-                self._apply_refresh(wrapper, props)
-                return wrapper
-        return sv
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        state = _pn_scrollview_state.get(id(native_view))
-        scroll = state["scroll"] if state else native_view
-        _apply_common_visual(scroll, changed)
-        self._apply_scroll_props(scroll, changed)
-        if state is not None and "refresh_control" in changed:
-            self._apply_refresh(native_view, changed)
-
-    def add_child(self, parent: Any, child: Any) -> None:
-        state = _pn_scrollview_state.get(id(parent))
-        target = state["scroll"] if state else parent
-        target.addView(child)
-
-    def remove_child(self, parent: Any, child: Any) -> None:
-        state = _pn_scrollview_state.get(id(parent))
-        target = state["scroll"] if state else parent
-        target.removeView(child)
-
-    def _apply_scroll_props(self, sv: Any, props: Dict[str, Any]) -> None:
+                outer = wrapper
+
+        _remember(outer, tag)
+        state = _state_of(outer)
+        state["props"] = dict(props)
+        state["scroll"] = sv
+        state["horizontal"] = horizontal
+        if outer is not sv:
+            state["refresh"] = outer
+            self._bind_refresh_listener(outer)
+            if not props.get("refresh_control"):
+                try:
+                    outer.setEnabled(False)
+                except Exception:
+                    pass
+        self._bind_scroll_listener(outer, sv)
+        self._apply(outer, props, initial=True)
+        if props.get("gestures"):
+            _wire_gestures(outer, props.get("gestures"))
+        return outer
+
+    def _apply(self, outer: Any, props: Dict[str, Any], initial: bool) -> None:
+        state = _state_of(outer)
+        sv = state.get("scroll", outer)
+        _apply_common_visual(sv, props)
         if "shows_scroll_indicator" in props:
             # Only present when ``False`` (hide); a removal restores bars.
             show = props["shows_scroll_indicator"] is not False
@@ -591,26 +923,69 @@ class ScrollViewHandler(AndroidViewHandler):
                 sv.setOverScrollMode(mode)
             except Exception:
                 pass
-        if "on_scroll" in props:
-            self._apply_on_scroll(sv, props.get("on_scroll"))
+        if "refresh_control" in props and state.get("refresh") is not None:
+            self._apply_refresh(outer, props)
         # ``paging_enabled`` and ``keyboard_dismiss_mode`` have no clean
         # NestedScrollView analogue, so they are intentionally skipped
         # rather than approximated poorly.
 
-    def _apply_on_scroll(self, sv: Any, cb: Optional[Callable[[float, float], None]]) -> None:
-        if cb is None:
-            return
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+        sv = _state_of(parent).get("scroll", parent)
+        _insert_view(sv, child, index)
+
+    def remove_child(self, parent: Any, child: Any) -> None:
+        sv = _state_of(parent).get("scroll", parent)
+        try:
+            sv.removeView(child)
+        except Exception:
+            pass
+
+    def command(self, native_view: Any, name: str, args: Dict[str, Any]) -> Any:
+        state = _state_of(native_view)
+        sv = state.get("scroll", native_view)
+        density = _density() or 1.0
+        if name == "scroll_to_offset":
+            x_px = int(float(args.get("x", 0.0) or 0.0) * density)
+            y_px = int(float(args.get("y", 0.0) or 0.0) * density)
+            animated = args.get("animated", True) is not False
+            try:
+                if animated and hasattr(sv, "smoothScrollTo"):
+                    sv.smoothScrollTo(x_px, y_px)
+                else:
+                    sv.scrollTo(x_px, y_px)
+            except Exception:
+                pass
+            return None
+        if name == "scroll_to_end":
+            try:
+                child = sv.getChildAt(0) if int(sv.getChildCount()) > 0 else None
+                if child is None:
+                    return None
+                if state.get("horizontal"):
+                    target_x = max(0, int(child.getWidth()) - int(sv.getWidth()))
+                    sv.smoothScrollTo(target_x, 0)
+                else:
+                    target_y = max(0, int(child.getHeight()) - int(sv.getHeight()))
+                    sv.smoothScrollTo(0, target_y)
+            except Exception:
+                pass
+            return None
+        if name == "get_scroll_offset":
+            try:
+                return {
+                    "x": float(sv.getScrollX()) / density,
+                    "y": float(sv.getScrollY()) / density,
+                }
+            except Exception:
+                return {"x": 0.0, "y": 0.0}
+        return None
+
+    def _bind_scroll_listener(self, outer: Any, sv: Any) -> None:
         try:
             if jclass("android.os.Build$VERSION").SDK_INT < 23:
                 return
-            density = _density()
 
             class _ScrollChangeProxy(dynamic_proxy(jclass("android.view.View").OnScrollChangeListener)):
-                def __init__(self, callback: Callable[[float, float], None], dens: float) -> None:
-                    super().__init__()
-                    self.callback = callback
-                    self.dens = dens if dens else 1.0
-
                 def onScrollChange(
                     self,
                     v: Any,
@@ -620,11 +995,12 @@ class ScrollViewHandler(AndroidViewHandler):
                     old_y: int,
                 ) -> None:
                     try:
-                        self.callback(scroll_x / self.dens, scroll_y / self.dens)
+                        density = _density() or 1.0
+                        _fire(outer, "on_scroll", {"x": scroll_x / density, "y": scroll_y / density})
                     except Exception:
                         pass
 
-            sv.setOnScrollChangeListener(_ScrollChangeProxy(cb, density))
+            sv.setOnScrollChangeListener(_ScrollChangeProxy())
         except Exception:
             pass
 
@@ -638,11 +1014,22 @@ class ScrollViewHandler(AndroidViewHandler):
         except Exception:
             return None
 
-    def _apply_refresh(self, wrapper: Any, props: Dict[str, Any]) -> None:
-        state = _pn_scrollview_state.get(id(wrapper))
-        if state is None:
-            return
-        srl = state.get("refresh")
+    def _bind_refresh_listener(self, outer: Any) -> None:
+        try:
+            srl = _state_of(outer).get("refresh")
+
+            class _RefreshProxy(
+                dynamic_proxy(jclass("androidx.swiperefreshlayout.widget.SwipeRefreshLayout").OnRefreshListener)
+            ):
+                def onRefresh(self) -> None:
+                    _fire(outer, "on_refresh")
+
+            srl.setOnRefreshListener(_RefreshProxy())
+        except Exception:
+            pass
+
+    def _apply_refresh(self, outer: Any, props: Dict[str, Any]) -> None:
+        srl = _state_of(outer).get("refresh")
         if srl is None:
             return
         spec = props.get("refresh_control")
@@ -656,26 +1043,6 @@ class ScrollViewHandler(AndroidViewHandler):
             srl.setEnabled(True)
         except Exception:
             pass
-        state["on_refresh"] = spec.get("on_refresh")
-        if not state.get("listener_bound"):
-            owner = state
-
-            class _RefreshProxy(
-                dynamic_proxy(jclass("androidx.swiperefreshlayout.widget.SwipeRefreshLayout").OnRefreshListener)
-            ):
-                def onRefresh(self) -> None:
-                    callback = owner.get("on_refresh")
-                    if callback is not None:
-                        try:
-                            callback()
-                        except Exception:
-                            pass
-
-            try:
-                srl.setOnRefreshListener(_RefreshProxy())
-                state["listener_bound"] = True
-            except Exception:
-                pass
         if spec.get("tint_color"):
             try:
                 srl.setColorSchemeColors([parse_color_int(spec["tint_color"])])
@@ -688,28 +1055,55 @@ class ScrollViewHandler(AndroidViewHandler):
 
 
 class TextInputHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         et = jclass("android.widget.EditText")(_ctx())
         # Default to single-line so pressing Enter triggers IME_ACTION_DONE
-        # (submit / dismiss) instead of inserting a newline. The
-        # ``_apply`` path will override this if ``multiline=True`` is
-        # set in props. Without this, every TextInput without an
-        # explicit ``multiline`` value falls back to Android's
-        # multi-line default and Enter inserts ``\n``.
+        # (submit / dismiss) instead of inserting a newline. ``_apply``
+        # overrides this when ``multiline=True``.
         try:
             if not props.get("multiline"):
                 et.setSingleLine(True)
         except Exception:
             pass
-        self._apply(et, props)
+        self._bind_listeners(et, props)
         return et
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
+    def _bind_listeners(self, et: Any, props: Dict[str, Any]) -> None:
+        # Text watcher: dispatches on_change unless a programmatic
+        # setText is in flight. State lookups happen at dispatch time,
+        # after the registry has assigned the tag.
+        try:
+            TextWatcher = jclass("android.text.TextWatcher")
+
+            class ChangeProxy(dynamic_proxy(TextWatcher)):
+                def afterTextChanged(self, s: Any) -> None:
+                    st = _state_of(et)
+                    if st.get("suppress"):
+                        return
+                    _fire(et, "on_change", str(s))
+
+                def beforeTextChanged(self, s: Any, start: int, count: int, after: int) -> None:
+                    pass
+
+                def onTextChanged(self, s: Any, start: int, before: int, count: int) -> None:
+                    pass
+
+            et.addTextChangedListener(ChangeProxy())
+        except Exception:
+            pass
+        try:
+
+            class _FocusProxy(dynamic_proxy(jclass("android.view.View").OnFocusChangeListener)):
+                def onFocusChange(self, view: Any, has_focus: bool) -> None:
+                    _fire(view, "on_focus" if has_focus else "on_blur")
 
-    def _apply(self, et: Any, props: Dict[str, Any]) -> None:
+            et.setOnFocusChangeListener(_FocusProxy())
+        except Exception:
+            pass
+
+    def _apply(self, et: Any, props: Dict[str, Any], initial: bool) -> None:
+        state = _state_of(et)
         if "value" in props:
-            key = id(et)
             incoming = str(props["value"]) if props["value"] is not None else ""
             try:
                 before = str(et.getText())
@@ -723,7 +1117,7 @@ class TextInputHandler(AndroidViewHandler):
                     selection_end = et.getSelectionEnd()
                 except Exception:
                     pass
-                _pn_text_input_suppress_callbacks[key] = True
+                state["suppress"] = True
                 try:
                     et.setText(incoming)
                     try:
@@ -737,7 +1131,7 @@ class TextInputHandler(AndroidViewHandler):
                     except Exception:
                         pass
                 finally:
-                    _pn_text_input_suppress_callbacks[key] = False
+                    state["suppress"] = False
         if "placeholder" in props:
             et.setHint(str(props["placeholder"]) if props["placeholder"] is not None else "")
         if "placeholder_color" in props and props["placeholder_color"] is not None:
@@ -750,13 +1144,14 @@ class TextInputHandler(AndroidViewHandler):
         if "color" in props and props["color"] is not None:
             et.setTextColor(parse_color_int(props["color"]))
         if any(k in props for k in ("multiline", "secure", "keyboard_type", "auto_capitalize")):
+            merged = state.get("props") or props
             try:
                 InputType = jclass("android.text.InputType")
                 base = InputType.TYPE_CLASS_TEXT
-                if props.get("secure"):
+                if merged.get("secure"):
                     base = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_PASSWORD
                 else:
-                    kt = props.get("keyboard_type")
+                    kt = merged.get("keyboard_type")
                     if kt == "email_address":
                         base = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS
                     elif kt == "number_pad" or kt == "decimal_pad":
@@ -767,14 +1162,14 @@ class TextInputHandler(AndroidViewHandler):
                         base = InputType.TYPE_CLASS_PHONE
                     elif kt == "url":
                         base = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI
-                    auto_cap = props.get("auto_capitalize")
+                    auto_cap = merged.get("auto_capitalize")
                     if auto_cap == "sentences":
                         base |= InputType.TYPE_TEXT_FLAG_CAP_SENTENCES
                     elif auto_cap == "words":
                         base |= InputType.TYPE_TEXT_FLAG_CAP_WORDS
                     elif auto_cap == "characters":
                         base |= InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS
-                if props.get("multiline"):
+                if merged.get("multiline"):
                     base |= InputType.TYPE_TEXT_FLAG_MULTI_LINE
                     et.setSingleLine(False)
                 else:
@@ -815,49 +1210,12 @@ class TextInputHandler(AndroidViewHandler):
             self._apply_autofill(et, str(props["text_content_type"]))
         if "clear_button" in props:
             self._apply_clear_button(et, bool(props.get("clear_button")))
-        if "on_focus" in props or "on_blur" in props:
-            self._apply_focus_listener(et, props)
-        if "on_change" in props:
-            key = id(et)
-            cb = props["on_change"]
-            if cb is not None:
-                _pn_text_input_callbacks[key] = cb
-                if key not in _pn_text_input_watchers:
-                    TextWatcher = jclass("android.text.TextWatcher")
-
-                    class ChangeProxy(dynamic_proxy(TextWatcher)):
-                        def __init__(self, view_key: int) -> None:
-                            super().__init__()
-                            self.view_key = view_key
-
-                        def afterTextChanged(self, s: Any) -> None:
-                            text = str(s)
-                            if _pn_text_input_suppress_callbacks.get(self.view_key):
-                                return
-                            callback = _pn_text_input_callbacks.get(self.view_key)
-                            if callback is None:
-                                return
-                            callback(text)
-
-                        def beforeTextChanged(self, s: Any, start: int, count: int, after: int) -> None:
-                            pass
-
-                        def onTextChanged(self, s: Any, start: int, before: int, count: int) -> None:
-                            pass
-
-                    watcher = ChangeProxy(key)
-                    _pn_text_input_watchers[key] = watcher
-                    et.addTextChangedListener(watcher)
-            else:
-                _pn_text_input_callbacks[key] = None
         if "return_key_type" in props and props["return_key_type"] is not None:
             # Map the cross-platform ``return_key_type`` to Android's
             # ``EditorInfo.IME_ACTION_*`` so the soft keyboard renders the
-            # right action key (Done / Go / Search / Send / Next), which
-            # is what triggers the ``OnEditorActionListener`` below. iOS
-            # has a richer set (Google / Yahoo / Join / Route) with no
-            # direct AOSP equivalents — fall back to ``IME_ACTION_DONE``
-            # for those so the keyboard at least dismisses cleanly.
+            # right action key. iOS has a richer set (Google / Yahoo /
+            # Join / Route) with no direct AOSP equivalents — fall back
+            # to ``IME_ACTION_DONE`` for those.
             try:
                 EditorInfo = jclass("android.view.inputmethod.EditorInfo")
                 rkt_mapping = {
@@ -876,31 +1234,36 @@ class TextInputHandler(AndroidViewHandler):
                 et.setImeOptions(action)
             except Exception:
                 pass
-        if not props.get("multiline"):
-            # Always install an editor-action listener on single-line
-            # inputs so pressing the IME action key (Done / Go / etc.)
-            # *or* the Enter key on a single-line ``EditText`` dismisses
-            # the soft keyboard. Without this the keyboard stays up after
-            # ``inputText`` + ``pressKey: Enter`` in Maestro and on smaller
-            # screens hides the rest of the layout — and matches React
-            # Native's default Android behavior. ``on_submit`` (if any) is
-            # fired before dismissal so the callback sees the final text.
-            try:
-                on_submit_cb = props.get("on_submit")
-                EditorListener = jclass("android.widget.TextView$OnEditorActionListener")
-                Context = jclass("android.content.Context")
+        if initial or "multiline" in props:
+            self._apply_editor_action(et)
+        _apply_common_visual(et, props)
 
-                class SubmitProxy(dynamic_proxy(EditorListener)):
-                    def __init__(self, callback: Optional[Callable[[str], None]]) -> None:
-                        super().__init__()
-                        self.callback = callback
+    def _apply_editor_action(self, et: Any) -> None:
+        """Install the IME action listener for submit + keyboard dismissal.
 
-                    def onEditorAction(self, view: Any, action_id: int, event: Any) -> bool:
-                        if self.callback is not None:
-                            try:
-                                self.callback(str(view.getText()))
-                            except Exception:
-                                pass
+        Single-line inputs always dismiss the keyboard on the action
+        key (matching React Native's Android default) and fire
+        ``on_submit`` first. Multi-line inputs only consume the action
+        when an ``on_submit`` handler exists — otherwise Enter inserts
+        a newline.
+        """
+        try:
+            EditorListener = jclass("android.widget.TextView$OnEditorActionListener")
+            Context = jclass("android.content.Context")
+
+            class SubmitProxy(dynamic_proxy(EditorListener)):
+                def onEditorAction(self, view: Any, action_id: int, event: Any) -> bool:
+                    merged = _state_of(view).get("props") or {}
+                    multiline = bool(merged.get("multiline"))
+                    has_submit = _has_event(view, "on_submit")
+                    if multiline and not has_submit:
+                        return False
+                    if has_submit:
+                        try:
+                            _fire(view, "on_submit", str(view.getText()))
+                        except Exception:
+                            pass
+                    if not multiline:
                         try:
                             view.clearFocus()
                             ctx = view.getContext()
@@ -908,35 +1271,11 @@ class TextInputHandler(AndroidViewHandler):
                             imm.hideSoftInputFromWindow(view.getWindowToken(), 0)
                         except Exception:
                             pass
-                        return True
+                    return True
 
-                et.setOnEditorActionListener(SubmitProxy(on_submit_cb))
-            except Exception:
-                pass
-        elif "on_submit" in props and props["on_submit"] is not None:
-            # Multi-line inputs: only install the listener when an explicit
-            # ``on_submit`` is provided. Enter inserts a newline by default
-            # on multi-line ``EditText`` and we don't want to override that.
-            try:
-                cb = props["on_submit"]
-                EditorListener = jclass("android.widget.TextView$OnEditorActionListener")
-
-                class SubmitProxy(dynamic_proxy(EditorListener)):
-                    def __init__(self, callback: Callable[[str], None]) -> None:
-                        super().__init__()
-                        self.callback = callback
-
-                    def onEditorAction(self, view: Any, action_id: int, event: Any) -> bool:
-                        try:
-                            self.callback(str(view.getText()))
-                        except Exception:
-                            pass
-                        return True
-
-                et.setOnEditorActionListener(SubmitProxy(cb))
-            except Exception:
-                pass
-        _apply_common_visual(et, props)
+            et.setOnEditorActionListener(SubmitProxy())
+        except Exception:
+            pass
 
     @staticmethod
     def _autofill_hint(content_type: str) -> Optional[str]:
@@ -974,15 +1313,16 @@ class TextInputHandler(AndroidViewHandler):
         # Best-effort drawableEnd "X": shows a system clear icon and wires
         # a touch listener that clears the field when the icon is tapped.
         try:
+            state = _state_of(et)
             if not enabled:
                 et.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0)
                 return
             icon_id = int(getattr(jclass("android.R$drawable"), "ic_menu_close_clear_cancel", 0))
             if icon_id:
                 et.setCompoundDrawablesWithIntrinsicBounds(0, 0, icon_id, 0)
-            key = id(et)
-            if key in _pn_text_input_clear_touch:
+            if state.get("clear_bound"):
                 return
+            state["clear_bound"] = True
 
             class _ClearTouchProxy(dynamic_proxy(jclass("android.view.View").OnTouchListener)):
                 def onTouch(self, view: Any, event: Any) -> bool:
@@ -999,51 +1339,16 @@ class TextInputHandler(AndroidViewHandler):
                         pass
                     return False
 
-            listener = _ClearTouchProxy()
-            _pn_text_input_clear_touch[key] = listener
-            et.setOnTouchListener(listener)
+            et.setOnTouchListener(_ClearTouchProxy())
         except Exception:
             pass
 
-    def _apply_focus_listener(self, et: Any, props: Dict[str, Any]) -> None:
-        key = id(et)
-        entry = _pn_text_input_focus_callbacks.setdefault(key, {"on_focus": None, "on_blur": None})
-        if "on_focus" in props:
-            entry["on_focus"] = props.get("on_focus")
-        if "on_blur" in props:
-            entry["on_blur"] = props.get("on_blur")
-        if key in _pn_text_input_focus_listeners:
-            return
-
-        class _FocusProxy(dynamic_proxy(jclass("android.view.View").OnFocusChangeListener)):
-            def __init__(self, view_key: int) -> None:
-                super().__init__()
-                self.view_key = view_key
-
-            def onFocusChange(self, view: Any, has_focus: bool) -> None:
-                callbacks = _pn_text_input_focus_callbacks.get(self.view_key) or {}
-                cb = callbacks.get("on_focus") if has_focus else callbacks.get("on_blur")
-                if cb is not None:
-                    try:
-                        cb()
-                    except Exception:
-                        pass
-
-        listener = _FocusProxy(key)
-        _pn_text_input_focus_listeners[key] = listener
-        et.setOnFocusChangeListener(listener)
-
 
 class ImageHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
-        iv = jclass("android.widget.ImageView")(_ctx())
-        self._apply(iv, props)
-        return iv
+    def _build(self, props: Dict[str, Any]) -> Any:
+        return jclass("android.widget.ImageView")(_ctx())
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
-
-    def _apply(self, iv: Any, props: Dict[str, Any]) -> None:
+    def _apply(self, iv: Any, props: Dict[str, Any], initial: bool) -> None:
         if "tint_color" in props and props["tint_color"] is not None:
             try:
                 ColorStateList = jclass("android.content.res.ColorStateList")
@@ -1117,44 +1422,37 @@ class ImageHandler(AndroidViewHandler):
 
 
 class SwitchHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         sw = jclass("android.widget.Switch")(_ctx())
-        self._apply(sw, props)
-        return sw
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
-
-    def _apply(self, sw: Any, props: Dict[str, Any]) -> None:
-        if "value" in props:
-            sw.setChecked(bool(props["value"]))
-        if "on_change" in props and props["on_change"] is not None:
-            cb = props["on_change"]
-
-            class CheckedProxy(dynamic_proxy(jclass("android.widget.CompoundButton").OnCheckedChangeListener)):
-                def __init__(self, callback: Callable[[bool], None]) -> None:
-                    super().__init__()
-                    self.callback = callback
+        class CheckedProxy(dynamic_proxy(jclass("android.widget.CompoundButton").OnCheckedChangeListener)):
+            def onCheckedChanged(self, button: Any, checked: bool) -> None:
+                if _state_of(button).get("suppress"):
+                    return
+                _fire(button, "on_change", bool(checked))
 
-                def onCheckedChanged(self, button: Any, checked: bool) -> None:
-                    self.callback(checked)
+        sw.setOnCheckedChangeListener(CheckedProxy())
+        return sw
 
-            sw.setOnCheckedChangeListener(CheckedProxy(cb))
+    def _apply(self, sw: Any, props: Dict[str, Any], initial: bool) -> None:
+        if "value" in props:
+            state = _state_of(sw)
+            state["suppress"] = True
+            try:
+                sw.setChecked(bool(props["value"]))
+            finally:
+                state["suppress"] = False
         _apply_accessibility(sw, props)
 
 
 class ProgressBarHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         style = jclass("android.R$attr").progressBarStyleHorizontal
         pb = jclass("android.widget.ProgressBar")(_ctx(), None, 0, style)
         pb.setMax(1000)
-        self._apply(pb, props)
         return pb
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
-
-    def _apply(self, pb: Any, props: Dict[str, Any]) -> None:
+    def _apply(self, pb: Any, props: Dict[str, Any], initial: bool) -> None:
         if "value" in props and props["value"] is not None:
             pb.setProgress(int(float(props["value"]) * 1000))
         if "color" in props and props["color"] is not None:
@@ -1179,15 +1477,10 @@ class ProgressBarHandler(AndroidViewHandler):
 
 
 class ActivityIndicatorHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
-        pb = jclass("android.widget.ProgressBar")(_ctx())
-        self._apply(pb, props)
-        return pb
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
+    def _build(self, props: Dict[str, Any]) -> Any:
+        return jclass("android.widget.ProgressBar")(_ctx())
 
-    def _apply(self, pb: Any, props: Dict[str, Any]) -> None:
+    def _apply(self, pb: Any, props: Dict[str, Any], initial: bool) -> None:
         if "animating" in props:
             View = jclass("android.view.View")
             pb.setVisibility(View.VISIBLE if props["animating"] else View.GONE)
@@ -1208,11 +1501,8 @@ class ActivityIndicatorHandler(AndroidViewHandler):
                 pass
 
 
-_pn_webview_props: Dict[int, Dict[str, Any]] = {}
-
-
-def _make_web_client(store: Dict[str, Any]) -> Any:
-    """Best-effort ``WebViewClient`` proxy driving the WebView callbacks.
+def _make_web_client(wv: Any) -> Any:
+    """Best-effort ``WebViewClient`` proxy driving the WebView events.
 
     ``android.webkit.WebViewClient`` is an abstract *class*, not an
     interface, so Chaquopy's ``dynamic_proxy`` may be unable to subclass
@@ -1220,35 +1510,22 @@ def _make_web_client(store: Dict[str, Any]) -> Any:
     which case the caller falls back to the default client and page
     loading still works.
 
-    When the proxy succeeds it drives ``on_navigation_state_change``
+    When the proxy succeeds it fires ``on_navigation_state_change``
     (``onPageStarted``), ``on_load`` (``onPageFinished``), evaluates
     ``inject_javascript`` after each load, and bridges ``on_message``
     via a ``pythonnative://`` URL scheme plus a small JS shim installed
-    as ``window.pythonnative.postMessage`` — so no ``@JavascriptInterface``
-    Java helper is required.
+    as ``window.pythonnative.postMessage``.
     """
-    on_load = store.get("on_load")
-    on_nav = store.get("on_navigation_state_change")
-    inject_js = store.get("inject_javascript")
-    on_message = store.get("on_message")
     scheme = "pythonnative://message/"
     try:
 
         class _WebClientProxy(dynamic_proxy(jclass("android.webkit.WebViewClient"))):
             def onPageStarted(self, view: Any, url: Any, favicon: Any) -> None:
-                if on_nav is not None:
-                    try:
-                        on_nav(str(url))
-                    except Exception:
-                        pass
+                _fire(wv, "on_navigation_state_change", str(url))
 
             def onPageFinished(self, view: Any, url: Any) -> None:
-                if on_load is not None:
-                    try:
-                        on_load(str(url))
-                    except Exception:
-                        pass
-                if on_message is not None:
+                _fire(wv, "on_load", str(url))
+                if _has_event(wv, "on_message"):
                     try:
                         shim = (
                             "(function(){window.pythonnative=window.pythonnative||{};"
@@ -1258,6 +1535,7 @@ def _make_web_client(store: Dict[str, Any]) -> Any:
                         view.evaluateJavascript(shim, None)
                     except Exception:
                         pass
+                inject_js = (_state_of(wv).get("props") or {}).get("inject_javascript")
                 if inject_js:
                     try:
                         view.evaluateJavascript(str(inject_js), None)
@@ -1269,11 +1547,11 @@ def _make_web_client(store: Dict[str, Any]) -> Any:
                     url = request if isinstance(request, str) else str(request.getUrl())
                 except Exception:
                     url = ""
-                if on_message is not None and url.startswith(scheme):
+                if url.startswith(scheme):
                     try:
                         from urllib.parse import unquote
 
-                        on_message(unquote(url[len(scheme) :]))
+                        _fire(wv, "on_message", unquote(url[len(scheme) :]))
                     except Exception:
                         pass
                     return True
@@ -1285,32 +1563,20 @@ def _make_web_client(store: Dict[str, Any]) -> Any:
 
 
 class WebViewHandler(AndroidViewHandler):
-    _CLIENT_KEYS = ("on_load", "on_navigation_state_change", "inject_javascript", "on_message")
-
-    def create(self, props: Dict[str, Any]) -> Any:
-        wv = jclass("android.webkit.WebView")(_ctx())
-        _pn_webview_props[id(wv)] = {}
-        self._apply(wv, props, initial=True)
-        return wv
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed, initial=False)
+    def _build(self, props: Dict[str, Any]) -> Any:
+        return jclass("android.webkit.WebView")(_ctx())
 
     def _apply(self, wv: Any, props: Dict[str, Any], initial: bool) -> None:
-        store = _pn_webview_props.setdefault(id(wv), {})
-        for key in self._CLIENT_KEYS:
-            if key in props:
-                store[key] = props[key]
-
-        # Enable JS whenever a callback / injection needs it.
-        if any(store.get(k) for k in self._CLIENT_KEYS):
+        merged = _state_of(wv).get("props") or props
+        needs_js = bool(merged.get("inject_javascript")) or bool(event_names(merged))
+        if needs_js:
             try:
                 wv.getSettings().setJavaScriptEnabled(True)
             except Exception:
                 pass
 
-        if initial or any(k in props for k in self._CLIENT_KEYS):
-            client = _make_web_client(store)
+        if initial:
+            client = _make_web_client(wv)
             if client is not None:
                 try:
                     wv.setWebViewClient(client)
@@ -1350,128 +1616,99 @@ class WebViewHandler(AndroidViewHandler):
 class SpacerHandler(AndroidViewHandler):
     """Empty layout placeholder used as a flexible gap.
 
-    All sizing semantics now live in the layout engine — ``Spacer``
+    All sizing semantics live in the layout engine — ``Spacer``
     behaves identically to a `View` with the same style props (e.g.,
     ``flex: 1`` for an expanding spacer, ``size`` for a fixed gap).
     """
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         return jclass("android.view.View")(_ctx())
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
+    def _apply(self, view: Any, props: Dict[str, Any], initial: bool) -> None:
         pass
 
 
-class SafeAreaViewHandler(AndroidViewHandler):
+class SafeAreaViewHandler(FlexContainerHandler):
     """Safe-area container using FrameLayout with ``fitsSystemWindows``."""
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         fl = jclass("android.widget.FrameLayout")(_ctx())
         fl.setFitsSystemWindows(True)
-        _apply_common_visual(fl, props)
         return fl
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        _apply_common_visual(native_view, changed)
-
-    def add_child(self, parent: Any, child: Any) -> None:
-        parent.addView(child)
-
-    def remove_child(self, parent: Any, child: Any) -> None:
-        parent.removeView(child)
-
 
 # ======================================================================
 # Modal — actually presents a Dialog with the children inside
 # ======================================================================
 
 
-_pn_modal_states: Dict[int, dict] = {}
-_pn_modal_pending: Dict[int, list] = {}
-
-
 class ModalHandler(AndroidViewHandler):
     """Real modal presentation backed by an Android `Dialog`.
 
     The on-tree placeholder is a hidden ``View`` (so the layout
     engine can ignore it). When ``visible`` flips to ``True``, a
     ``Dialog`` is created with a ``FrameLayout`` as its content view;
-    the reconciler's ``add_child`` calls are forwarded into that
+    the reconciler's ``insert_child`` calls are forwarded into that
     content view.
     """
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         placeholder = jclass("android.view.View")(_ctx())
         placeholder.setVisibility(jclass("android.view.View").GONE)
-        self._apply(placeholder, props, mounting=True)
         return placeholder
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed, mounting=False)
-
-    def add_child(self, parent: Any, child: Any) -> None:
-        state = _pn_modal_states.get(id(parent))
-        if state and state.get("content_view") is not None:
+    def _apply(self, placeholder: Any, props: Dict[str, Any], initial: bool) -> None:
+        state = _state_of(placeholder)
+        # ``update`` only delivers the *changed* props. When ``visible`` is
+        # not among them the presentation state must be left untouched: a
+        # re-render that happens while the modal is open (e.g. an
+        # ``on_show`` callback bumping some state) must NOT be read as
+        # ``visible=False`` and tear the dialog down.
+        if "visible" in props:
+            visible = bool(props["visible"])
+            if visible and state.get("dialog") is None:
+                self._present(placeholder, state)
+            elif not visible and state.get("dialog") is not None:
+                self._dismiss(placeholder, state)
+        dialog = state.get("dialog")
+        if dialog is not None and "dismiss_on_backdrop" in props:
             try:
-                state["content_view"].addView(child)
+                dialog.setCanceledOnTouchOutside(props["dismiss_on_backdrop"] is not False)
             except Exception:
                 pass
+
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
+        state = _state_of(parent)
+        content = state.get("content_view")
+        if content is not None:
+            _insert_view(content, child, index)
         else:
-            _pn_modal_pending.setdefault(id(parent), []).append(child)
+            state.setdefault("pending", []).insert(index, child)
 
     def remove_child(self, parent: Any, child: Any) -> None:
-        state = _pn_modal_states.get(id(parent))
-        if state and state.get("content_view") is not None:
+        state = _state_of(parent)
+        content = state.get("content_view")
+        if content is not None:
             try:
-                state["content_view"].removeView(child)
+                content.removeView(child)
             except Exception:
                 pass
         else:
-            buf = _pn_modal_pending.get(id(parent))
+            buf = state.get("pending")
             if buf and child in buf:
                 buf.remove(child)
 
-    def insert_child(self, parent: Any, child: Any, index: int) -> None:
-        state = _pn_modal_states.get(id(parent))
-        if state and state.get("content_view") is not None:
-            try:
-                state["content_view"].addView(child, index)
-            except Exception:
-                pass
-        else:
-            _pn_modal_pending.setdefault(id(parent), []).insert(index, child)
-
     def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
         return
 
-    def _apply(self, placeholder: Any, props: Dict[str, Any], *, mounting: bool) -> None:
-        state = _pn_modal_states.get(id(placeholder))
-        # ``update`` only delivers the *changed* props. When ``visible`` is
-        # not among them the presentation state must be left untouched: a
-        # re-render that happens while the modal is open (e.g. an
-        # ``on_show`` callback bumping some state) must NOT be read as
-        # ``visible=False`` and tear the dialog down. So only react to an
-        # explicitly supplied ``visible`` value.
-        if "visible" in props:
-            visible = bool(props["visible"])
-            if visible and state is None:
-                self._present(placeholder, props)
-            elif not visible and state is not None:
-                self._dismiss(placeholder)
-        # Forward live prop updates to an already-presented dialog.
-        state = _pn_modal_states.get(id(placeholder))
-        if state is not None:
-            if "on_dismiss" in props:
-                state["on_dismiss"] = props.get("on_dismiss")
-            dialog = state.get("dialog")
-            if dialog is not None and "dismiss_on_backdrop" in props:
-                try:
-                    dialog.setCanceledOnTouchOutside(props["dismiss_on_backdrop"] is not False)
-                except Exception:
-                    pass
+    def _teardown(self, placeholder: Any) -> None:
+        state = _state_of(placeholder)
+        if state.get("dialog") is not None:
+            self._dismiss(placeholder, state)
 
-    def _present(self, placeholder: Any, props: Dict[str, Any]) -> None:
+    def _present(self, placeholder: Any, state: Dict[str, Any]) -> None:
         try:
+            props = state.get("props") or {}
             Dialog = jclass("android.app.Dialog")
             FrameLayout = jclass("android.widget.FrameLayout")
             LayoutParams = jclass("android.view.ViewGroup$LayoutParams")
@@ -1505,57 +1742,36 @@ class ModalHandler(AndroidViewHandler):
                 dialog.setCanceledOnTouchOutside(props.get("dismiss_on_backdrop") is not False)
             except Exception:
                 pass
-            on_dismiss = props.get("on_dismiss")
-            _pn_modal_states[id(placeholder)] = {
-                "dialog": dialog,
-                "content_view": content,
-                "on_dismiss": on_dismiss,
-            }
-            for child in _pn_modal_pending.pop(id(placeholder), []):
+            state["dialog"] = dialog
+            state["content_view"] = content
+            for child in state.pop("pending", []):
                 try:
                     content.addView(child)
                 except Exception:
                     pass
-            on_show = props.get("on_show")
-            if on_show is not None:
-                OnShowListener = jclass("android.content.DialogInterface$OnShowListener")
 
-                class _ShowProxy(dynamic_proxy(OnShowListener)):
-                    def __init__(self, callback: Callable[[], None]) -> None:
-                        super().__init__()
-                        self.callback = callback
+            OnShowListener = jclass("android.content.DialogInterface$OnShowListener")
 
-                    def onShow(self, di: Any) -> None:
-                        try:
-                            self.callback()
-                        except Exception:
-                            pass
+            class _ShowProxy(dynamic_proxy(OnShowListener)):
+                def onShow(self, di: Any) -> None:
+                    _fire(placeholder, "on_show")
 
-                dialog.setOnShowListener(_ShowProxy(on_show))
-            if on_dismiss is not None:
-                OnDismissListener = jclass("android.content.DialogInterface$OnDismissListener")
+            dialog.setOnShowListener(_ShowProxy())
 
-                class _DismissProxy(dynamic_proxy(OnDismissListener)):
-                    def __init__(self, callback: Callable[[], None]) -> None:
-                        super().__init__()
-                        self.callback = callback
+            OnDismissListener = jclass("android.content.DialogInterface$OnDismissListener")
 
-                    def onDismiss(self, di: Any) -> None:
-                        try:
-                            self.callback()
-                        except Exception:
-                            pass
+            class _DismissProxy(dynamic_proxy(OnDismissListener)):
+                def onDismiss(self, di: Any) -> None:
+                    _fire(placeholder, "on_dismiss")
 
-                dialog.setOnDismissListener(_DismissProxy(on_dismiss))
+            dialog.setOnDismissListener(_DismissProxy())
             dialog.show()
         except Exception:
             pass
 
-    def _dismiss(self, placeholder: Any) -> None:
-        state = _pn_modal_states.pop(id(placeholder), None)
-        if state is None:
-            return
-        dialog = state.get("dialog")
+    def _dismiss(self, placeholder: Any, state: Dict[str, Any]) -> None:
+        dialog = state.pop("dialog", None)
+        state.pop("content_view", None)
         if dialog is not None:
             try:
                 dialog.dismiss()
@@ -1564,46 +1780,38 @@ class ModalHandler(AndroidViewHandler):
 
 
 class SliderHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         sb = jclass("android.widget.SeekBar")(_ctx())
         sb.setMax(1000)
-        self._apply(sb, props)
-        return sb
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
-
-    def _apply(self, sb: Any, props: Dict[str, Any]) -> None:
-        min_val = float(props.get("min_value", 0))
-        max_val = float(props.get("max_value", 1))
-        rng = max_val - min_val if max_val != min_val else 1
-        if "value" in props:
-            normalized = (float(props["value"]) - min_val) / rng
-            sb.setProgress(int(normalized * 1000))
-        if "on_change" in props and props["on_change"] is not None:
-            cb = props["on_change"]
-
-            class SeekProxy(dynamic_proxy(jclass("android.widget.SeekBar").OnSeekBarChangeListener)):
-                def __init__(self, callback: Callable[[float], None], mn: float, rn: float) -> None:
-                    super().__init__()
-                    self.callback = callback
-                    self.mn = mn
-                    self.rn = rn
-
-                def onProgressChanged(self, seekBar: Any, progress: int, fromUser: bool) -> None:
-                    if fromUser:
-                        self.callback(self.mn + (progress / 1000.0) * self.rn)
 
-                def onStartTrackingTouch(self, seekBar: Any) -> None:
-                    pass
+        class SeekProxy(dynamic_proxy(jclass("android.widget.SeekBar").OnSeekBarChangeListener)):
+            def onProgressChanged(self, seekBar: Any, progress: int, fromUser: bool) -> None:
+                if not fromUser:
+                    return
+                merged = _state_of(seekBar).get("props") or {}
+                mn = float(merged.get("min_value", 0))
+                mx = float(merged.get("max_value", 1))
+                rng = mx - mn if mx != mn else 1
+                _fire(seekBar, "on_change", mn + (progress / 1000.0) * rng)
 
-                def onStopTrackingTouch(self, seekBar: Any) -> None:
-                    pass
+            def onStartTrackingTouch(self, seekBar: Any) -> None:
+                pass
 
-            sb.setOnSeekBarChangeListener(SeekProxy(cb, min_val, rng))
+            def onStopTrackingTouch(self, seekBar: Any) -> None:
+                pass
 
+        sb.setOnSeekBarChangeListener(SeekProxy())
+        return sb
 
-_android_tabbar_state: dict = {"callback": None, "items": []}
+    def _apply(self, sb: Any, props: Dict[str, Any], initial: bool) -> None:
+        merged = _state_of(sb).get("props") or props
+        min_val = float(merged.get("min_value", 0))
+        max_val = float(merged.get("max_value", 1))
+        rng = max_val - min_val if max_val != min_val else 1
+        if "value" in props and props["value"] is not None:
+            normalized = (float(props["value"]) - min_val) / rng
+            sb.setProgress(int(normalized * 1000))
+        _apply_accessibility(sb, props)
 
 
 class TabBarHandler(AndroidViewHandler):
@@ -1614,71 +1822,67 @@ class TabBarHandler(AndroidViewHandler):
     """
 
     _LABEL_VISIBILITY_LABELED = 1
-    _is_material: bool = True
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         try:
             bnv = jclass("com.google.android.material.bottomnavigation.BottomNavigationView")(_ctx())
             bnv.setBackgroundColor(parse_color_int("#FFFFFF"))
-            self._configure_material_bar(bnv)
-            self._is_material = True
-            self._apply_full(bnv, props)
+            try:
+                bnv.setLabelVisibilityMode(self._LABEL_VISIBILITY_LABELED)
+            except Exception:
+                pass
             return bnv
         except Exception:
-            self._is_material = False
-            return self._create_fallback(props)
-
-    def _create_fallback(self, props: Dict[str, Any]) -> Any:
-        """Horizontal LinearLayout with Button children as a tab-bar fallback."""
-        LinearLayout = jclass("android.widget.LinearLayout")
-        ll = LinearLayout(_ctx())
-        ll.setOrientation(LinearLayout.HORIZONTAL)
-        ll.setBackgroundColor(parse_color_int("#F8F8F8"))
-        self._apply_fallback(ll, props)
-        return ll
-
-    def _configure_material_bar(self, bnv: Any) -> None:
-        """Keep text visible for every tab, including 4+ item bars."""
+            LinearLayout = jclass("android.widget.LinearLayout")
+            ll = LinearLayout(_ctx())
+            ll.setOrientation(LinearLayout.HORIZONTAL)
+            ll.setBackgroundColor(parse_color_int("#F8F8F8"))
+            return ll
+
+    def create(self, tag: int, props: Dict[str, Any]) -> Any:
+        view = super().create(tag, props)
+        state = _state_of(view)
+        state["is_material"] = "LinearLayout" not in str(type(view))
         try:
-            bnv.setLabelVisibilityMode(self._LABEL_VISIBILITY_LABELED)
+            state["is_material"] = bool(view.getMenu() is not None)
         except Exception:
-            pass
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        if self._is_material:
-            self._apply_partial(native_view, changed)
-        else:
-            self._apply_fallback(native_view, changed)
-
-    def _apply_full(self, bnv: Any, props: Dict[str, Any]) -> None:
-        """Initial creation — all props are present."""
-        items = props.get("items", [])
-        self._set_menu(bnv, items)
-        self._set_active(bnv, props.get("active_tab"), items)
-        cb = props.get("on_tab_select")
-        if cb is not None:
-            self._set_listener(bnv, cb, items)
-
-    def _apply_partial(self, bnv: Any, changed: Dict[str, Any]) -> None:
-        """Reconciler update — only changed props are present."""
-        prev_items = _android_tabbar_state["items"]
-
-        if "items" in changed:
-            items = changed["items"]
-            self._set_menu(bnv, items)
+            state["is_material"] = False
+        if state["is_material"]:
+            self._bind_material_listener(view)
+        # Re-run the items now that we know which flavor we hold.
+        self._apply(view, props, initial=True)
+        return view
+
+    def _apply(self, view: Any, props: Dict[str, Any], initial: bool) -> None:
+        state = _state_of(view)
+        if "is_material" not in state:
+            return  # create() re-invokes once flavor detection is done.
+        if state.get("is_material"):
+            if "items" in props:
+                self._set_menu(view, props["items"] or [])
+            if "active_tab" in props:
+                items = (state.get("props") or {}).get("items") or []
+                self._set_active(view, props["active_tab"], items)
         else:
-            items = prev_items
+            self._apply_fallback(view, props)
 
-        if "active_tab" in changed:
-            self._set_active(bnv, changed["active_tab"], items)
+    def _bind_material_listener(self, bnv: Any) -> None:
+        try:
+            listener_cls = jclass("com.google.android.material.navigation.NavigationBarView$OnItemSelectedListener")
 
-        if "on_tab_select" in changed:
-            cb = changed["on_tab_select"]
-            if cb is not None:
-                self._set_listener(bnv, cb, items)
+            class _TabSelectProxy(dynamic_proxy(listener_cls)):
+                def onNavigationItemSelected(self, menu_item: Any) -> bool:
+                    idx = menu_item.getItemId()
+                    items = (_state_of(bnv).get("props") or {}).get("items") or []
+                    if 0 <= idx < len(items):
+                        _fire(bnv, "on_tab_select", items[idx].get("name", ""))
+                    return True
+
+            bnv.setOnItemSelectedListener(_TabSelectProxy())
+        except Exception:
+            pass
 
     def _set_menu(self, bnv: Any, items: list) -> None:
-        _android_tabbar_state["items"] = items
         try:
             menu = bnv.getMenu()
             menu.clear()
@@ -1729,33 +1933,11 @@ class TabBarHandler(AndroidViewHandler):
                         pass
                     break
 
-    def _set_listener(self, bnv: Any, cb: Callable, items: list) -> None:
-        _android_tabbar_state["callback"] = cb
-        _android_tabbar_state["items"] = items
-        try:
-            listener_cls = jclass("com.google.android.material.navigation.NavigationBarView$OnItemSelectedListener")
-
-            class _TabSelectProxy(dynamic_proxy(listener_cls)):
-                def __init__(self, callback: Callable, tab_items: list) -> None:
-                    super().__init__()
-                    self.callback = callback
-                    self.tab_items = tab_items
-
-                def onNavigationItemSelected(self, menu_item: Any) -> bool:
-                    idx = menu_item.getItemId()
-                    if 0 <= idx < len(self.tab_items):
-                        self.callback(self.tab_items[idx].get("name", ""))
-                    return True
-
-            bnv.setOnItemSelectedListener(_TabSelectProxy(cb, items))
-        except Exception:
-            pass
-
     def _apply_fallback(self, ll: Any, props: Dict[str, Any]) -> None:
-        items = props.get("items", [])
-        active = props.get("active_tab")
-        cb = props.get("on_tab_select")
-        if "items" in props:
+        merged = _state_of(ll).get("props") or props
+        items = merged.get("items", []) or []
+        active = merged.get("active_tab")
+        if "items" in props or "active_tab" in props:
             ll.removeAllViews()
             for item in items:
                 name = item.get("name", "")
@@ -1763,96 +1945,131 @@ class TabBarHandler(AndroidViewHandler):
                 btn = jclass("android.widget.Button")(_ctx())
                 btn.setText(str(title))
                 btn.setEnabled(name != active)
-                if cb is not None:
-                    tab_name = name
-
-                    def _make_click(n: str) -> Callable[[], None]:
-                        return lambda: cb(n)
 
-                    class _ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
-                        def __init__(self, callback: Callable[[], None]) -> None:
-                            super().__init__()
-                            self.callback = callback
+                class _ClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
+                    def __init__(self, tab_name: str) -> None:
+                        super().__init__()
+                        self.tab_name = tab_name
 
-                        def onClick(self, view: Any) -> None:
-                            self.callback()
+                    def onClick(self, view: Any) -> None:
+                        _fire(ll, "on_tab_select", self.tab_name)
 
-                    btn.setOnClickListener(_ClickProxy(_make_click(tab_name)))
+                btn.setOnClickListener(_ClickProxy(name))
                 ll.addView(btn)
 
 
 # ======================================================================
-# Pressable — visual feedback + tap callbacks
+# Pressable — visual feedback + tap callbacks + gestures
 # ======================================================================
 
 
-class PressableHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
+class PressableHandler(FlexContainerHandler):
+    """Container that dispatches press events through one touch stream.
+
+    A single ``OnTouchListener`` drives the entire interaction:
+    ``on_press_in`` at finger-down (plus the opacity dip),
+    ``on_long_press`` on a 500 ms hold, ``on_press`` on a clean
+    release, and ``on_press_out`` when the finger lifts or the touch
+    cancels. The same stream feeds the gesture arbiter when
+    ``gestures`` are attached, so press feedback and pan/pinch
+    recognition coexist on one view.
+    """
+
+    _LONG_PRESS_MS = 500
+    _TAP_SLOP_DP = 12.0
+
+    def _build(self, props: Dict[str, Any]) -> Any:
         fl = jclass("android.widget.FrameLayout")(_ctx())
         fl.setClickable(True)
         fl.setFocusable(True)
-        self._apply(fl, props)
+        self._bind_press_stream(fl)
         return fl
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed)
+    def create(self, tag: int, props: Dict[str, Any]) -> Any:
+        view = super().create(tag, props)
+        # Press handling owns the touch listener; gesture specs are fed
+        # from inside the press stream rather than a second listener.
+        _state_of(view)["gestures_bound"] = True
+        return view
 
-    def _apply(self, fl: Any, props: Dict[str, Any]) -> None:
-        if "on_press" in props and props["on_press"] is not None:
-            cb = props["on_press"]
+    def update(self, native_view: Any, changed_props: Dict[str, Any]) -> None:
+        _state_of(native_view)["gestures_bound"] = True
+        super().update(native_view, changed_props)
 
-            class PressProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
-                def __init__(self, callback: Callable[[], None]) -> None:
-                    super().__init__()
-                    self.callback = callback
-
-                def onClick(self, view: Any) -> None:
-                    self.callback()
-
-            fl.setOnClickListener(PressProxy(cb))
-        if "on_long_press" in props and props["on_long_press"] is not None:
-            cb = props["on_long_press"]
-
-            class LongPressProxy(dynamic_proxy(jclass("android.view.View").OnLongClickListener)):
-                def __init__(self, callback: Callable[[], None]) -> None:
-                    super().__init__()
-                    self.callback = callback
-
-                def onLongClick(self, view: Any) -> bool:
-                    self.callback()
-                    return True
-
-            fl.setOnLongClickListener(LongPressProxy(cb))
-        # Press feedback via OnTouchListener that fades the alpha.
-        if "pressed_opacity" in props or "on_press" in props:
-            try:
-                pressed_opacity = float(props.get("pressed_opacity", 0.6))
-                OnTouchListener = jclass("android.view.View$OnTouchListener")
-                MotionEvent = jclass("android.view.MotionEvent")  # noqa: F841
-
-                class _TouchProxy(dynamic_proxy(OnTouchListener)):
-                    def __init__(self, opacity: float) -> None:
-                        super().__init__()
-                        self.opacity = opacity
+    def _bind_press_stream(self, fl: Any) -> None:
+        try:
+            OnTouchListener = jclass("android.view.View$OnTouchListener")
+            Handler = jclass("android.os.Handler")
+            Looper = jclass("android.os.Looper")
+            Runnable = jclass("java.lang.Runnable")
+            handler = Handler(Looper.getMainLooper())
+            slop = self._TAP_SLOP_DP
+            long_ms = self._LONG_PRESS_MS
+
+            class _PressTouchProxy(dynamic_proxy(OnTouchListener)):
+                def onTouch(self, view: Any, event: Any) -> bool:
+                    state = _state_of(view)
+                    _feed_motion_event(view, state, event)
+                    action = int(event.getActionMasked())
+                    density = _density() or 1.0
+                    x_dp = float(event.getX()) / density
+                    y_dp = float(event.getY()) / density
+                    if action == 0:  # DOWN
+                        press = {
+                            "down": (x_dp, y_dp),
+                            "moved": False,
+                            "long_fired": False,
+                            "seq": state.get("press_seq", 0) + 1,
+                        }
+                        state["press"] = press
+                        state["press_seq"] = press["seq"]
+                        _fire(view, "on_press_in")
+                        merged = state.get("props") or {}
+                        opacity = float(merged.get("pressed_opacity", 0.6))
+                        if opacity < 1.0:
+                            try:
+                                view.animate().alpha(opacity).setDuration(50).start()
+                            except Exception:
+                                pass
+                        if _has_event(view, "on_long_press"):
+                            seq = press["seq"]
 
-                    def onTouch(self, view: Any, event: Any) -> bool:
-                        action = event.getAction()
-                        if action == 0:  # ACTION_DOWN
-                            view.animate().alpha(self.opacity).setDuration(50).start()
-                        elif action in (1, 3):  # ACTION_UP / ACTION_CANCEL
+                            class _LongRunnable(dynamic_proxy(Runnable)):
+                                def run(self) -> None:
+                                    live = _state_of(view).get("press")
+                                    if live is None or live.get("seq") != seq:
+                                        return
+                                    if live.get("moved") or live.get("long_fired"):
+                                        return
+                                    live["long_fired"] = True
+                                    _fire(view, "on_long_press")
+
+                            handler.postDelayed(_LongRunnable(), long_ms)
+                        return True
+                    press = state.get("press")
+                    if press is None:
+                        return True
+                    if action == 2:  # MOVE
+                        dx = x_dp - press["down"][0]
+                        dy = y_dp - press["down"][1]
+                        if math.hypot(dx, dy) > slop:
+                            press["moved"] = True
+                        return True
+                    if action in (1, 3):  # UP / CANCEL
+                        state["press"] = None
+                        _fire(view, "on_press_out")
+                        try:
                             view.animate().alpha(1.0).setDuration(100).start()
-                        return False
-
-                fl.setOnTouchListener(_TouchProxy(pressed_opacity))
-            except Exception:
-                pass
-        _apply_common_visual(fl, props)
-
-    def add_child(self, parent: Any, child: Any) -> None:
-        parent.addView(child)
+                        except Exception:
+                            pass
+                        if action == 1 and not press["moved"] and not press["long_fired"]:
+                            _fire(view, "on_press")
+                        return True
+                    return True
 
-    def remove_child(self, parent: Any, child: Any) -> None:
-        parent.removeView(child)
+            fl.setOnTouchListener(_PressTouchProxy())
+        except Exception:
+            pass
 
 
 # ======================================================================
@@ -1863,19 +2080,15 @@ class PressableHandler(AndroidViewHandler):
 class StatusBarHandler(AndroidViewHandler):
     """Apply status-bar background color / style on the host activity."""
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         v = jclass("android.view.View")(_ctx())
         v.setVisibility(jclass("android.view.View").GONE)
-        self._apply(props)
         return v
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(changed)
-
     def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
         return
 
-    def _apply(self, props: Dict[str, Any]) -> None:
+    def _apply(self, view: Any, props: Dict[str, Any], initial: bool) -> None:
         try:
             ctx = _ctx()
             window = ctx.getWindow()
@@ -1899,174 +2112,8 @@ class StatusBarHandler(AndroidViewHandler):
             pass
 
 
-# ======================================================================
-# KeyboardAvoidingView — vanilla container; the user-land component
-# computes the offset from manifest-driven insets.
-# ======================================================================
-
-
-class KeyboardAvoidingViewHandler(AndroidViewHandler):
-    def create(self, props: Dict[str, Any]) -> Any:
-        fl = jclass("android.widget.FrameLayout")(_ctx())
-        _apply_common_visual(fl, props)
-        return fl
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        _apply_common_visual(native_view, changed)
-
-    def add_child(self, parent: Any, child: Any) -> None:
-        parent.addView(child)
-
-    def remove_child(self, parent: Any, child: Any) -> None:
-        parent.removeView(child)
-
-
-# ======================================================================
-# VirtualList — RecyclerView-backed virtualized list
-# ======================================================================
-
-
-_pn_recyclerview_state: Dict[int, Any] = {}
-
-
-def _java_id(jobj: Any) -> int:
-    """Return ``System.identityHashCode(jobj)`` as a stable lookup key.
-
-    Chaquopy's ``JavaObject.__setattr__`` rejects unknown Python attributes,
-    so we cannot stash custom IDs on the Java view wrapper. Instead, we use
-    the JVM's identity hash code, which is stable for the lifetime of the
-    Java object and the same across all Python wrappers that may proxy it.
-    """
-    System = jclass("java.lang.System")
-    return int(System.identityHashCode(jobj))
-
-
-def _make_recyclerview_delegate(props: Dict[str, Any]) -> Any:
-    Delegate = jclass("com.pythonnative.android_template.PNVirtualListView$Delegate")
-
-    class _Delegate(dynamic_proxy(Delegate)):
-        def __init__(self, initial: Dict[str, Any]) -> None:
-            super().__init__()
-            self.count = int(initial.get("count", 0))
-            self.row_height = float(initial.get("row_height", 44.0))
-            self.mount_row = initial.get("mount_row")
-            self.on_row_press = initial.get("on_row_press")
-
-        def update(self, changed: Dict[str, Any]) -> None:
-            if "count" in changed:
-                self.count = int(changed["count"])
-            if "row_height" in changed and changed["row_height"] is not None:
-                self.row_height = float(changed["row_height"])
-            if "mount_row" in changed:
-                self.mount_row = changed["mount_row"]
-            if "on_row_press" in changed:
-                self.on_row_press = changed["on_row_press"]
-
-        def getCount(self) -> int:
-            return self.count
-
-        def getRowHeightDp(self) -> float:
-            return self.row_height
-
-        def mountRow(self, position: int, container: Any, width_dp: float, height_dp: float) -> None:
-            if self.mount_row is None:
-                return
-            try:
-                self.mount_row(int(position), container, float(width_dp), float(height_dp))
-            except Exception:
-                import traceback as _tb
-
-                _tb.print_exc()
-
-        def onRowPress(self, position: int) -> None:
-            idx = int(position)
-            if idx < 0 or self.on_row_press is None:
-                return
-            try:
-                self.on_row_press(idx)
-            except Exception:
-                import traceback as _tb
-
-                _tb.print_exc()
-
-    return _Delegate(props)
-
-
-class VirtualListHandler(AndroidViewHandler):
-    """Backed by ``RecyclerView`` through a tiny Android template helper.
-
-    Chaquopy cannot proxy ``RecyclerView.Adapter`` directly because it is an
-    abstract Java class, so the Android template provides
-    ``PNVirtualListView``. Python implements that helper's small ``Delegate``
-    interface, while Java owns the adapter/view-holder lifecycle.
-    """
-
-    def create(self, props: Dict[str, Any]) -> Any:
-        try:
-            PNVirtualListView = jclass("com.pythonnative.android_template.PNVirtualListView")
-            delegate = _make_recyclerview_delegate(props)
-            rv = PNVirtualListView(_ctx(), delegate)
-            if "background_color" in props and props["background_color"] is not None:
-                rv.setBackgroundColor(parse_color_int(props["background_color"]))
-            key = _java_id(rv)
-            _pn_recyclerview_state[key] = delegate
-            return rv
-        except Exception:
-            return self._fallback(props)
-
-    def _fallback(self, props: Dict[str, Any]) -> Any:
-        """Eagerly mount all rows in a ScrollView (controller init failed).
-
-        Sets each row's LinearLayout.LayoutParams to MATCH_PARENT × row_h_px
-        so cells have a real visual size, and forwards the screen width (in
-        dp) to ``mount_row`` so the layout engine can position child
-        elements.
-        """
-        n = int(props.get("count", 0))
-        row_h_dp = float(props.get("row_height", 44.0))
-        density = _density()
-        row_h_px = max(1, int(round(row_h_dp * density)))
-
-        try:
-            screen_w_px = float(_ctx().getResources().getDisplayMetrics().widthPixels)
-            screen_w_dp = screen_w_px / density if density else screen_w_px
-        except Exception:
-            screen_w_dp = 0.0
-
-        sv = jclass("android.widget.ScrollView")(_ctx())
-        LinearLayout = jclass("android.widget.LinearLayout")
-        LL_LP = jclass("android.widget.LinearLayout$LayoutParams")
-        ll = LinearLayout(_ctx())
-        ll.setOrientation(LinearLayout.VERTICAL)
-        sv.addView(ll)
-
-        mount = props.get("mount_row")
-
-        for i in range(n):
-            try:
-                cell = jclass("android.widget.FrameLayout")(_ctx())
-                cell.setLayoutParams(LL_LP(LL_LP.MATCH_PARENT, row_h_px))
-                if mount is not None:
-                    mount(i, cell, screen_w_dp, row_h_dp)
-                ll.addView(cell)
-            except Exception:
-                continue
-        return sv
-
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        delegate = _pn_recyclerview_state.get(_java_id(native_view))
-        if delegate is None:
-            return
-        delegate.update(changed)
-        if "background_color" in changed and changed["background_color"] is not None:
-            try:
-                native_view.setBackgroundColor(parse_color_int(changed["background_color"]))
-            except Exception:
-                pass
-        try:
-            native_view.notifyDataChanged()
-        except Exception:
-            pass
+class KeyboardAvoidingViewHandler(FlexContainerHandler):
+    """Vanilla container; the user-land component computes the offset."""
 
 
 # ======================================================================
@@ -2182,31 +2229,43 @@ def _present_alert(
 # ======================================================================
 # Picker — native dropdown / select widget
 # ======================================================================
-#
-# Renders the PythonNative `Picker` element as an Android ``Spinner``,
-# which is the platform's standard dropdown widget. The selected item is
-# pushed to the user's callback via ``OnItemSelectedListener``.
 
 
 class PickerHandler(AndroidViewHandler):
     """``Picker`` element handler — native ``Spinner`` dropdown."""
 
-    def create(self, props: Dict[str, Any]) -> Any:
-        Spinner = jclass("android.widget.Spinner")
-        sp = Spinner(_ctx())
-        self._state: Dict[int, Dict[str, Any]] = getattr(self, "_state", {})
-        self._state[id(sp)] = {"items": [], "on_change": None, "suppress": False}
-        self._apply(sp, props, initial=True)
-        return sp
+    def _build(self, props: Dict[str, Any]) -> Any:
+        sp = jclass("android.widget.Spinner")(_ctx())
+
+        class _PickerListener(dynamic_proxy(jclass("android.widget.AdapterView").OnItemSelectedListener)):
+            def onItemSelected(
+                self,
+                parent: Any,
+                view: Any,  # noqa: ARG002
+                position: int,
+                id_: int,  # noqa: ARG002
+            ) -> None:
+                state = _state_of(parent)
+                if state.get("suppress"):
+                    return
+                items = (state.get("props") or {}).get("items") or []
+                if 0 <= position < len(items):
+                    item = items[position]
+                    v = item.get("value") if isinstance(item, dict) else item
+                    _fire(parent, "on_change", v)
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed, initial=False)
+            def onNothingSelected(self, parent: Any) -> None:  # noqa: ARG002
+                pass
+
+        sp.setOnItemSelectedListener(_PickerListener())
+        return sp
 
     def _apply(self, sp: Any, props: Dict[str, Any], initial: bool) -> None:
-        state = self._state.setdefault(id(sp), {"items": [], "on_change": None, "suppress": False})
+        state = _state_of(sp)
+        merged = state.get("props") or props
 
         if "items" in props or initial:
-            items = list(props.get("items") or state.get("items") or [])
+            items = list(merged.get("items") or [])
             labels = []
             for item in items:
                 if isinstance(item, dict):
@@ -2218,13 +2277,14 @@ class PickerHandler(AndroidViewHandler):
             adapter = ArrayAdapter(_ctx(), R.layout.simple_spinner_item, labels)
             adapter.setDropDownViewResource(R.layout.simple_spinner_dropdown_item)
             state["suppress"] = True
-            sp.setAdapter(adapter)
-            state["suppress"] = False
-            state["items"] = items
+            try:
+                sp.setAdapter(adapter)
+            finally:
+                state["suppress"] = False
 
         if "value" in props or initial:
-            items = state["items"]
-            value = props.get("value") if "value" in props else None
+            items = list(merged.get("items") or [])
+            value = merged.get("value")
             target_index = -1
             for i, item in enumerate(items):
                 v = item.get("value") if isinstance(item, dict) else item
@@ -2233,41 +2293,10 @@ class PickerHandler(AndroidViewHandler):
                     break
             if target_index >= 0 and sp.getSelectedItemPosition() != target_index:
                 state["suppress"] = True
-                sp.setSelection(target_index, False)
-                state["suppress"] = False
-
-        if "on_change" in props or initial:
-            state["on_change"] = props.get("on_change") if "on_change" in props else state.get("on_change")
-
-            class _PickerListener(dynamic_proxy(jclass("android.widget.AdapterView").OnItemSelectedListener)):
-                def __init__(self, owner_state: Dict[str, Any]) -> None:
-                    super().__init__()
-                    self._owner_state = owner_state
-
-                def onItemSelected(
-                    self,
-                    parent: Any,
-                    view: Any,  # noqa: ARG002
-                    position: int,
-                    id_: int,  # noqa: ARG002
-                ) -> None:
-                    if self._owner_state.get("suppress"):
-                        return
-                    items = self._owner_state.get("items") or []
-                    if 0 <= position < len(items):
-                        item = items[position]
-                        v = item.get("value") if isinstance(item, dict) else item
-                        cb = self._owner_state.get("on_change")
-                        if cb is not None:
-                            try:
-                                cb(v)
-                            except Exception:
-                                pass
-
-                def onNothingSelected(self, parent: Any) -> None:  # noqa: ARG002
-                    pass
-
-            sp.setOnItemSelectedListener(_PickerListener(state))
+                try:
+                    sp.setSelection(target_index, False)
+                finally:
+                    state["suppress"] = False
 
 
 # ======================================================================
@@ -2279,65 +2308,42 @@ class CheckboxHandler(AndroidViewHandler):
     """``Checkbox`` element handler — native ``CheckBox`` widget.
 
     Programmatic ``value`` updates are wrapped in a per-view
-    "suppress" guard (mirroring ``PickerHandler``) so pushing a new
-    state via ``setChecked`` never re-fires the user's ``on_change``.
+    "suppress" guard so pushing a new state via ``setChecked`` never
+    re-fires the user's ``on_change``.
     """
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         cb = jclass("android.widget.CheckBox")(_ctx())
-        self._state: Dict[int, Dict[str, Any]] = getattr(self, "_state", {})
-        self._state[id(cb)] = {"on_change": None, "suppress": False}
-        self._apply(cb, props, initial=True)
-        return cb
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed, initial=False)
+        class _CheckedProxy(dynamic_proxy(jclass("android.widget.CompoundButton").OnCheckedChangeListener)):
+            def onCheckedChanged(self, button: Any, is_checked: bool) -> None:
+                if _state_of(button).get("suppress"):
+                    return
+                _fire(button, "on_change", bool(is_checked))
 
-    def _apply(self, cb: Any, props: Dict[str, Any], initial: bool) -> None:
-        state = self._state.setdefault(id(cb), {"on_change": None, "suppress": False})
+        cb.setOnCheckedChangeListener(_CheckedProxy())
+        return cb
 
+    def _apply(self, cb: Any, props: Dict[str, Any], initial: bool) -> None:
+        state = _state_of(cb)
         if "label" in props:
             cb.setText(str(props["label"]) if props["label"] is not None else "")
-
         if "value" in props:
             state["suppress"] = True
             try:
                 cb.setChecked(bool(props["value"]))
             finally:
                 state["suppress"] = False
-
         if "disabled" in props:
             # ``disabled`` is only present when truthy; a removal (``None``)
             # re-enables the control.
             cb.setEnabled(not bool(props["disabled"]))
-
         if "color" in props and props["color"] is not None:
             try:
                 ColorStateList = jclass("android.content.res.ColorStateList")
                 cb.setButtonTintList(ColorStateList.valueOf(parse_color_int(props["color"])))
             except Exception:
                 pass
-
-        if "on_change" in props or initial:
-            state["on_change"] = props.get("on_change") if "on_change" in props else state.get("on_change")
-
-            class _CheckboxCheckedProxy(dynamic_proxy(jclass("android.widget.CompoundButton").OnCheckedChangeListener)):
-                def __init__(self, owner_state: Dict[str, Any]) -> None:
-                    super().__init__()
-                    self._owner_state = owner_state
-
-                def onCheckedChanged(self, button: Any, is_checked: bool) -> None:
-                    if self._owner_state.get("suppress"):
-                        return
-                    callback = self._owner_state.get("on_change")
-                    if callback is not None:
-                        try:
-                            callback(bool(is_checked))
-                        except Exception:
-                            pass
-
-            cb.setOnCheckedChangeListener(_CheckboxCheckedProxy(state))
-
         _apply_accessibility(cb, props)
 
 
@@ -2352,70 +2358,34 @@ class SegmentedControlHandler(AndroidViewHandler):
     Android has no ``UISegmentedControl`` equivalent, so the control is
     built from a horizontal ``LinearLayout`` holding one ``Button`` per
     segment. The selected segment is filled with the ``tint_color`` (or
-    a default accent); the rest are drawn outlined. Selection state and
-    the change callback live in a per-view dict, and a "suppress" guard
-    keeps programmatic ``selected_index`` updates from re-firing
-    ``on_change``. The control owns its own subviews, so
-    ``add_child`` / ``remove_child`` are intentional no-ops.
+    a default accent); the rest are drawn outlined. The control owns
+    its own subviews, so ``insert_child`` / ``remove_child`` are
+    intentional no-ops.
     """
 
     _DEFAULT_ACCENT = "#007AFF"
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         LinearLayout = jclass("android.widget.LinearLayout")
         ll = LinearLayout(_ctx())
         ll.setOrientation(LinearLayout.HORIZONTAL)
-        self._state: Dict[int, Dict[str, Any]] = getattr(self, "_state", {})
-        self._state[id(ll)] = {
-            "segments": [],
-            "selected_index": 0,
-            "on_change": None,
-            "tint_color": None,
-            "enabled": True,
-            "buttons": [],
-            "suppress": False,
-        }
-        self._apply(ll, props, initial=True)
         return ll
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed, initial=False)
-
-    def add_child(self, parent: Any, child: Any) -> None:
-        # SegmentedControl renders its own segment buttons.
+    def insert_child(self, parent: Any, child: Any, index: int) -> None:
         return
 
     def remove_child(self, parent: Any, child: Any) -> None:
         return
 
-    def _default_state(self) -> Dict[str, Any]:
-        return {
-            "segments": [],
-            "selected_index": 0,
-            "on_change": None,
-            "tint_color": None,
-            "enabled": True,
-            "buttons": [],
-            "suppress": False,
-        }
-
     def _apply(self, ll: Any, props: Dict[str, Any], initial: bool) -> None:
-        state = self._state.setdefault(id(ll), self._default_state())
-
-        if "on_change" in props:
-            state["on_change"] = props.get("on_change")
-        if "tint_color" in props:
-            state["tint_color"] = props.get("tint_color")
-        if "enabled" in props:
-            # ``enabled`` is only present when ``False``; a removal (``None``)
-            # re-enables the control.
-            state["enabled"] = props["enabled"] is not False
+        state = _state_of(ll)
+        merged = state.get("props") or props
 
         segments_changed = False
         if "segments" in props or initial:
-            raw = props.get("segments")
+            raw = merged.get("segments")
             new_segments = [str(s) for s in raw] if raw else []
-            if initial or new_segments != state["segments"]:
+            if initial or new_segments != state.get("segments"):
                 state["segments"] = new_segments
                 segments_changed = True
 
@@ -2425,7 +2395,7 @@ class SegmentedControlHandler(AndroidViewHandler):
         if segments_changed:
             self._rebuild(ll, state)
         else:
-            self._restyle(state)
+            self._restyle(ll, state)
 
         _apply_accessibility(ll, props)
 
@@ -2437,7 +2407,7 @@ class SegmentedControlHandler(AndroidViewHandler):
         state["buttons"] = []
         LL_LP = jclass("android.widget.LinearLayout$LayoutParams")
         restyle = self._restyle
-        for index, label in enumerate(state["segments"]):
+        for index, label in enumerate(state.get("segments") or []):
             btn = jclass("android.widget.Button")(_ctx())
             btn.setText(str(label))
             try:
@@ -2446,37 +2416,33 @@ class SegmentedControlHandler(AndroidViewHandler):
                 pass
             # Equal-width segments: zero base width + weight 1, full height.
             btn.setLayoutParams(LL_LP(0, LL_LP.MATCH_PARENT, 1.0))
-            btn.setEnabled(bool(state["enabled"]))
+            enabled = (state.get("props") or {}).get("enabled") is not False
+            btn.setEnabled(enabled)
 
             class _SegmentClickProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
-                def __init__(self, owner_state: Dict[str, Any], seg_index: int, container: Any) -> None:
+                def __init__(self, seg_index: int) -> None:
                     super().__init__()
-                    self._owner_state = owner_state
                     self._seg_index = seg_index
-                    self._container = container
 
                 def onClick(self, view: Any) -> None:
-                    if self._owner_state.get("suppress") or not self._owner_state.get("enabled", True):
+                    st = _state_of(ll)
+                    if (st.get("props") or {}).get("enabled") is False:
                         return
-                    self._owner_state["selected_index"] = self._seg_index
-                    restyle(self._owner_state)
-                    cb = self._owner_state.get("on_change")
-                    if cb is not None:
-                        try:
-                            cb(self._seg_index)
-                        except Exception:
-                            pass
+                    st["selected_index"] = self._seg_index
+                    restyle(ll, st)
+                    _fire(ll, "on_change", self._seg_index)
 
-            btn.setOnClickListener(_SegmentClickProxy(state, index, ll))
+            btn.setOnClickListener(_SegmentClickProxy(index))
             ll.addView(btn)
             state["buttons"].append(btn)
-        self._restyle(state)
-
-    def _restyle(self, state: Dict[str, Any]) -> None:
-        accent = state.get("tint_color") or self._DEFAULT_ACCENT
-        selected = state.get("selected_index", 0)
-        enabled = bool(state.get("enabled", True))
-        for i, btn in enumerate(state.get("buttons", [])):
+        self._restyle(ll, state)
+
+    def _restyle(self, ll: Any, state: Dict[str, Any]) -> None:
+        merged = state.get("props") or {}
+        accent = merged.get("tint_color") or self._DEFAULT_ACCENT
+        selected = state.get("selected_index", int(merged.get("selected_index", 0) or 0))
+        enabled = merged.get("enabled") is not False
+        for i, btn in enumerate(state.get("buttons") or []):
             self._style_segment(btn, i == selected, accent, enabled)
 
     def _style_segment(self, btn: Any, selected: bool, accent: Any, enabled: bool) -> None:
@@ -2539,85 +2505,50 @@ class DatePickerHandler(AndroidViewHandler):
     date→time flow (``"datetime"``). Values are parsed / formatted with
     ``java.util.Calendar`` + ``java.text.SimpleDateFormat`` using
     per-mode ISO patterns, and the confirmed value is reported through
-    ``on_change``.
+    the ``on_change`` event.
     """
 
     _PATTERNS = {"date": "yyyy-MM-dd", "time": "HH:mm", "datetime": "yyyy-MM-dd'T'HH:mm"}
     _PLACEHOLDERS = {"date": "Select date", "time": "Select time", "datetime": "Select date & time"}
 
-    def create(self, props: Dict[str, Any]) -> Any:
+    def _build(self, props: Dict[str, Any]) -> Any:
         btn = jclass("android.widget.Button")(_ctx())
         try:
             btn.setAllCaps(False)
         except Exception:
             pass
-        self._state: Dict[int, Dict[str, Any]] = getattr(self, "_state", {})
-        self._state[id(btn)] = {
-            "value": None,
-            "mode": "date",
-            "on_change": None,
-            "minimum": None,
-            "maximum": None,
-            "enabled": True,
-        }
-        self._apply(btn, props, initial=True)
-        return btn
+        open_dialog = self._open_dialog
 
-    def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
-        self._apply(native_view, changed, initial=False)
+        class _DateTriggerProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
+            def onClick(self, view: Any) -> None:
+                st = _state_of(view)
+                if (st.get("props") or {}).get("enabled") is False:
+                    return
+                open_dialog(view, st)
 
-    def _apply(self, btn: Any, props: Dict[str, Any], initial: bool) -> None:
-        state = self._state.setdefault(
-            id(btn),
-            {"value": None, "mode": "date", "on_change": None, "minimum": None, "maximum": None, "enabled": True},
-        )
+        btn.setOnClickListener(_DateTriggerProxy())
+        return btn
 
-        if "mode" in props and props["mode"]:
-            state["mode"] = str(props["mode"])
-        if "on_change" in props:
-            state["on_change"] = props.get("on_change")
-        if "minimum" in props:
-            state["minimum"] = props.get("minimum")
-        if "maximum" in props:
-            state["maximum"] = props.get("maximum")
+    def _apply(self, btn: Any, props: Dict[str, Any], initial: bool) -> None:
+        state = _state_of(btn)
         if "enabled" in props:
-            state["enabled"] = props["enabled"] is not False
-            btn.setEnabled(bool(state["enabled"]))
-        if "value" in props or initial:
-            state["value"] = props.get("value") if "value" in props else state.get("value")
-
-        self._refresh_label(btn, state)
-        if initial:
-            self._attach_trigger(btn, state)
-
+            btn.setEnabled(props["enabled"] is not False)
+        if "value" in props or "mode" in props or initial:
+            self._refresh_label(btn, state)
         _apply_accessibility(btn, props)
 
     def _refresh_label(self, btn: Any, state: Dict[str, Any]) -> None:
-        value = state.get("value")
+        merged = state.get("props") or {}
+        value = merged.get("value")
         if value:
             btn.setText(str(value))
         else:
-            btn.setText(self._PLACEHOLDERS.get(state.get("mode", "date"), "Select"))
-
-    def _attach_trigger(self, btn: Any, state: Dict[str, Any]) -> None:
-        open_dialog = self._open_dialog
-
-        class _DateTriggerProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
-            def __init__(self, owner_state: Dict[str, Any], trigger: Any) -> None:
-                super().__init__()
-                self._owner_state = owner_state
-                self._trigger = trigger
-
-            def onClick(self, view: Any) -> None:
-                if not self._owner_state.get("enabled", True):
-                    return
-                open_dialog(self._trigger, self._owner_state)
-
-        btn.setOnClickListener(_DateTriggerProxy(state, btn))
+            btn.setText(self._PLACEHOLDERS.get(str(merged.get("mode", "date")), "Select"))
 
     def _open_dialog(self, btn: Any, state: Dict[str, Any]) -> None:
-        mode = state.get("mode", "date")
-        cal = self._parse_to_calendar(state.get("value"), mode)
+        merged = state.get("props") or {}
+        mode = str(merged.get("mode", "date"))
+        cal = self._parse_to_calendar(merged.get("value"), mode)
         if mode == "time":
             self._open_time(btn, state, cal)
         elif mode == "datetime":
@@ -2685,10 +2616,11 @@ class DatePickerHandler(AndroidViewHandler):
 
     def _apply_min_max(self, dialog: Any, state: Dict[str, Any]) -> None:
         try:
-            mode = state.get("mode", "date")
+            merged = state.get("props") or {}
+            mode = str(merged.get("mode", "date"))
             picker = dialog.getDatePicker()
-            minimum = state.get("minimum")
-            maximum = state.get("maximum")
+            minimum = merged.get("minimum")
+            maximum = merged.get("maximum")
             if minimum:
                 picker.setMinDate(self._parse_to_calendar(minimum, mode).getTimeInMillis())
             if maximum:
@@ -2716,22 +2648,18 @@ class DatePickerHandler(AndroidViewHandler):
         return str(fmt.format(cal.getTime()))
 
     def _commit(self, btn: Any, state: Dict[str, Any], cal: Any) -> None:
-        mode = state.get("mode", "date")
+        merged = state.get("props") or {}
+        mode = str(merged.get("mode", "date"))
         try:
             iso = self._format_calendar(cal, mode)
         except Exception:
             return
-        state["value"] = iso
+        merged["value"] = iso
         try:
             btn.setText(iso)
         except Exception:
             pass
-        cb = state.get("on_change")
-        if cb is not None:
-            try:
-                cb(iso)
-            except Exception:
-                pass
+        _fire(btn, "on_change", iso)
 
 
 # ======================================================================
@@ -2762,7 +2690,6 @@ def register_handlers(registry: Any) -> None:
     registry.register("Pressable", PressableHandler())
     registry.register("StatusBar", StatusBarHandler())
     registry.register("KeyboardAvoidingView", KeyboardAvoidingViewHandler())
-    registry.register("VirtualList", VirtualListHandler())
     registry.register("Picker", PickerHandler())
     registry.register("Checkbox", CheckboxHandler())
     registry.register("SegmentedControl", SegmentedControlHandler())
@@ -2789,7 +2716,6 @@ __all__ = [
     "PressableHandler",
     "StatusBarHandler",
     "KeyboardAvoidingViewHandler",
-    "VirtualListHandler",
     "PickerHandler",
     "CheckboxHandler",
     "SegmentedControlHandler",