pythonnative 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

pythonnative/native_views/android.py

@@ -21,12 +21,28 @@ 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.
+so gesture semantics match the desktop preview exactly. Serialized
+specs (including ``simultaneous`` / ``wait_for`` composition metadata
+and ``fling`` configs) pass through untouched; this module only
+schedules main-looper polls at the arbiter's ``next_deadline()`` so
+long-press activation and multi-tap windows fire even when no
+further touch events arrive.
 
 **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.
+ticker, whose per-frame values arrive through
+``set_animated_property`` (floats for transforms and opacity,
+interpolated "#AARRGGBB" strings for background and text colors that
+re-bake through the border-drawable machinery instead of clobbering
+it).
+
+**Interaction props**: ``pointer_events`` maps onto the template's
+``PNFrameLayout`` touch interception when available (with a
+Python-side fallback for older projects), ``hit_slop`` expands touch
+targets via a parent ``TouchDelegate`` sized after layout,
+``z_index`` maps to ``View.setZ``, and per-corner radii extend the
+``GradientDrawable`` border path.
 
 This module is only imported on Android at runtime. Desktop tests
 inject a mock registry via
@@ -40,6 +56,7 @@ from typing import Any, Callable, Dict, Optional, Tuple
 
 from java import dynamic_proxy, jclass
 
+from .. import diagnostics
 from ..events import dispatch_event, event_names
 from ..gestures import make_arbiter
 from ..utils import get_android_context
@@ -57,11 +74,20 @@ _SIDE_BORDER_COLOR_KEYS = (
     "border_right_color",
     "border_bottom_color",
 )
+# Order matches GradientDrawable.setCornerRadii: top-left, top-right,
+# bottom-right, bottom-left (each corner takes an x and a y radius).
+_CORNER_RADIUS_KEYS = (
+    "border_top_left_radius",
+    "border_top_right_radius",
+    "border_bottom_right_radius",
+    "border_bottom_left_radius",
+)
 _DRAWABLE_STYLE_KEYS = (
     "background_color",
     "border_radius",
     "border_width",
     "border_color",
+    *_CORNER_RADIUS_KEYS,
     *_SIDE_BORDER_WIDTH_KEYS,
     *_SIDE_BORDER_COLOR_KEYS,
 )
@@ -97,6 +123,38 @@ def _pn_runtime_class(class_name: str) -> Any:
     return jclass(f"{package}.{class_name}")
 
 
+# Cached lookup for the template's PNFrameLayout container class.
+# ``None`` means "not resolved yet"; ``False`` means "this generated
+# project predates the class", so creation falls back to FrameLayout
+# without retrying the (exception-throwing) lookup per view.
+_pn_container_cls: Any = None
+
+
+def _new_container() -> Any:
+    """Create a container view, preferring the template's ``PNFrameLayout``.
+
+    ``PNFrameLayout`` adds native ``pointer_events`` interception
+    (``onInterceptTouchEvent`` / ``dispatchTouchEvent``), which
+    Chaquopy can't express from Python. Older generated projects
+    without the class get a plain ``FrameLayout``; the
+    ``pointer_events`` prop then degrades to the Python-side
+    approximation in
+    [`_apply_pointer_events`][pythonnative.native_views.android._apply_pointer_events].
+    """
+    global _pn_container_cls
+    if _pn_container_cls is None:
+        try:
+            _pn_container_cls = _pn_runtime_class("PNFrameLayout")
+        except Exception:
+            _pn_container_cls = False
+    if _pn_container_cls is not False:
+        try:
+            return _pn_container_cls(_ctx())
+        except Exception:
+            diagnostics.swallowed("android._new_container")
+    return jclass("android.widget.FrameLayout")(_ctx())
+
+
 def _signed_color(value: int) -> int:
     """Clamp a Python color int into Java's signed 32-bit range."""
     value &= 0xFFFFFFFF
@@ -206,7 +264,7 @@ def _apply_side_border(view: Any, props: Dict[str, Any]) -> bool:
         try:
             view.invalidate()
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_side_border")
         return True
     except Exception:
         return False
@@ -226,7 +284,7 @@ def _apply_border(view: Any, props: Dict[str, Any]) -> None:
     """
     if _apply_side_border(view, props):
         return
-    has_border = any(k in props for k in ("border_radius", "border_width", "border_color"))
+    has_border = any(k in props for k in ("border_radius", "border_width", "border_color", *_CORNER_RADIUS_KEYS))
     has_bg = "background_color" in props and props["background_color"] is not None
     if not has_border and not has_bg:
         return
@@ -237,12 +295,26 @@ def _apply_border(view: Any, props: Dict[str, Any]) -> None:
             try:
                 drawable.setColor(parse_color_int(props["background_color"]))
             except Exception:
-                pass
-        if "border_radius" in props and props["border_radius"] is not None:
+                diagnostics.swallowed("android._apply_border")
+        if any(props.get(k) is not None for k in _CORNER_RADIUS_KEYS):
+            # Per-corner radii: unspecified corners inherit the uniform
+            # ``border_radius`` (else 0). ``setCornerRadii`` takes eight
+            # floats, an (x, y) pair per corner in _CORNER_RADIUS_KEYS
+            # order, each in pixels.
+            try:
+                base_radius = float(props.get("border_radius") or 0.0)
+                radii = []
+                for key in _CORNER_RADIUS_KEYS:
+                    r = float(_dp(float(props[key] if props.get(key) is not None else base_radius)))
+                    radii.extend([r, r])
+                drawable.setCornerRadii(radii)
+            except Exception:
+                diagnostics.swallowed("android._apply_border")
+        elif "border_radius" in props and props["border_radius"] is not None:
             try:
                 drawable.setCornerRadius(float(_dp(float(props["border_radius"]))))
             except Exception:
-                pass
+                diagnostics.swallowed("android._apply_border")
         if ("border_width" in props and props["border_width"] is not None) or (
             "border_color" in props and props["border_color"] is not None
         ):
@@ -254,18 +326,56 @@ def _apply_border(view: Any, props: Dict[str, Any]) -> None:
                     parse_color_int(color or "#000000"),
                 )
             except Exception:
-                pass
+                diagnostics.swallowed("android._apply_border")
         view.setBackground(drawable)
         try:
             drawable.invalidateSelf()
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_border")
         try:
             view.invalidate()
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_border")
     except Exception:
-        pass
+        diagnostics.swallowed("android._apply_border")
+
+
+def _set_animated_background(view: Any, value: Any) -> None:
+    """Apply one animated ``background_color`` frame without losing borders.
+
+    Interpolations hand this module raw color values ("#AARRGGBB" or
+    "#RRGGBB" strings, or ints). Views whose background is a
+    border-rendering drawable (the uniform ``GradientDrawable`` or the
+    per-side ``PNBorderDrawable``) must keep their corner radii and
+    strokes while the fill animates, so the color routes through the
+    same [`_apply_border`][pythonnative.native_views.android._apply_border]
+    machinery ``update()`` uses. When the current background already is
+    a ``GradientDrawable``, its fill is mutated in place, so no
+    drawable is allocated per animation frame. Plain views take the
+    direct ``setBackgroundColor`` path.
+    """
+    state = _state_of(view)
+    visual = state.get("visual")
+    has_border = isinstance(visual, dict) and any(
+        visual.get(k) is not None for k in _DRAWABLE_STYLE_KEYS if k != "background_color"
+    )
+    if has_border:
+        visual = dict(visual)
+        visual["background_color"] = value
+        state["visual"] = visual
+        try:
+            GradientDrawable = jclass("android.graphics.drawable.GradientDrawable")
+            bg = view.getBackground()
+            if bg is not None and isinstance(bg, GradientDrawable):
+                bg.setColor(parse_color_int(value))
+                return
+        except Exception:
+            diagnostics.swallowed("android._set_animated_background")
+        # Per-side ``PNBorderDrawable`` backgrounds (immutable fill) and
+        # first frames before any drawable exists re-bake the full set.
+        _apply_border(view, visual)
+        return
+    view.setBackgroundColor(parse_color_int(value))
 
 
 def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
@@ -291,7 +401,7 @@ def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
     try:
         view.setElevation(float(_dp(float(elevation))))
     except Exception:
-        pass
+        diagnostics.swallowed("android._apply_shadow")
     color = props.get("shadow_color")
     if color is None:
         return
@@ -308,7 +418,7 @@ def _apply_shadow(view: Any, props: Dict[str, Any]) -> None:
         view.setOutlineAmbientShadowColor(signed)
         view.setOutlineSpotShadowColor(signed)
     except Exception:
-        pass
+        diagnostics.swallowed("android._apply_shadow")
 
 
 def _apply_transform(view: Any, props: Dict[str, Any]) -> None:
@@ -324,7 +434,7 @@ def _apply_transform(view: Any, props: Dict[str, Any]) -> None:
             view.setTranslationX(0.0)
             view.setTranslationY(0.0)
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_transform")
         return
     entries = spec if isinstance(spec, list) else [spec]
     for entry in entries:
@@ -353,7 +463,7 @@ def _apply_transform(view: Any, props: Dict[str, Any]) -> None:
             if "translate_y" in entry:
                 view.setTranslationY(float(_dp(float(entry["translate_y"]))))
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_transform")
 
 
 def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
@@ -365,13 +475,13 @@ def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
                 View.IMPORTANT_FOR_ACCESSIBILITY_YES if props["accessible"] else View.IMPORTANT_FOR_ACCESSIBILITY_NO
             )
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_accessibility")
     if "accessibility_label" in props:
         try:
             label = props["accessibility_label"]
             view.setContentDescription(str(label) if label is not None else None)
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_accessibility")
     if "accessibility_live_region" in props:
         try:
             mode = {"none": 0, "polite": 1, "assertive": 2}.get(
@@ -379,14 +489,14 @@ def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
             )
             view.setAccessibilityLiveRegion(mode)
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_accessibility")
 
     state = props.get("accessibility_state")
     if isinstance(state, dict) and "selected" in state:
         try:
             view.setSelected(bool(state["selected"]))
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_accessibility")
     test_id = props.get("test_id")
     if test_id is None and not isinstance(state, dict):
         return
@@ -413,7 +523,139 @@ def _apply_accessibility(view: Any, props: Dict[str, Any]) -> None:
             delegate.setStateBusy(state.get("busy"))
             delegate.setStateExpanded(state.get("expanded"))
     except Exception:
+        diagnostics.swallowed("android._apply_accessibility")
+
+
+def _pointer_events_blocked(view: Any) -> bool:
+    """Whether ``pointer_events`` disables the view's own touch handling.
+
+    Consulted at the top of every touch-stream proxy (gesture, press)
+    so listeners installed at create time honor the prop without being
+    re-wired: ``"none"`` and ``"box_none"`` both mean the view itself
+    must not observe or consume the stream.
+    """
+    merged = _state_of(view).get("props") or {}
+    return merged.get("pointer_events") in ("none", "box_none")
+
+
+def _apply_pointer_events(view: Any, value: Any) -> None:
+    """Apply the ``pointer_events`` prop (``None`` restores ``"auto"``).
+
+    Two cooperating layers implement the modes:
+
+    - **Native interception** (preferred): containers built by
+      [`_new_container`][pythonnative.native_views.android._new_container]
+      are the template's ``PNFrameLayout``, whose
+      ``setPointerEventsMode(String)`` drives real
+      ``dispatchTouchEvent`` / ``onInterceptTouchEvent`` overrides.
+      ``"none"`` declines the whole dispatch so touches pass through
+      to views underneath, ``"box_only"`` intercepts events away from
+      children, and ``"box_none"`` never intercepts. The call is
+      guarded so older generated projects without the class (and
+      non-container views) fall back cleanly.
+    - **Python-side muting**: ``setClickable`` toggles whether the
+      view claims events, and the touch-stream proxies consult
+      [`_pointer_events_blocked`][pythonnative.native_views.android._pointer_events_blocked]
+      so gesture/press wiring goes quiet without being torn down.
+      ``"auto"`` / removal restores the original clickability
+      captured before the first override.
+
+    On a plain ``FrameLayout`` (old template) the fallback keeps the
+    previous approximation: ``"none"`` silences the view itself but
+    interactive children keep receiving touches, and ``"box_only"``
+    only claims events no interactive child consumed. ``"box_none"``
+    is exact either way, since children need no help.
+    """
+    mode = value if value is not None else "auto"
+    state = _state_of(view)
+    try:
+        view.setPointerEventsMode(str(mode))
+    except Exception:
+        # Plain FrameLayout, a leaf widget, or an older template
+        # without PNFrameLayout; the Python-side fallback still runs.
         pass
+    try:
+        if mode in ("none", "box_none"):
+            state.setdefault("pe_was_clickable", bool(view.isClickable()))
+            view.setClickable(False)
+        elif mode == "box_only":
+            state.setdefault("pe_was_clickable", bool(view.isClickable()))
+            view.setClickable(True)
+        elif "pe_was_clickable" in state:
+            view.setClickable(bool(state.pop("pe_was_clickable")))
+    except Exception:
+        diagnostics.swallowed("android._apply_pointer_events")
+
+
+def _hit_slop_insets(value: Any) -> Optional[Tuple[float, float, float, float]]:
+    """Normalize a ``hit_slop`` prop into ``(top, left, bottom, right)`` points.
+
+    Accepts a uniform number or a dict with any of ``top`` / ``left``
+    / ``bottom`` / ``right``. Returns ``None`` for absent or
+    unparseable values.
+    """
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        try:
+            return (
+                float(value.get("top") or 0.0),
+                float(value.get("left") or 0.0),
+                float(value.get("bottom") or 0.0),
+                float(value.get("right") or 0.0),
+            )
+        except Exception:
+            return None
+    try:
+        uniform = float(value)
+    except Exception:
+        return None
+    return (uniform, uniform, uniform, uniform)
+
+
+def _update_hit_slop(view: Any) -> None:
+    """Extend the view's touch target via a ``TouchDelegate`` on its parent.
+
+    The standard Android mechanism: the parent forwards touches
+    landing inside an expanded ``Rect`` (the view's frame plus the
+    slop insets, in parent-relative pixels) to the view. Parents are
+    PythonNative-managed ``FrameLayout``s, so installing the delegate
+    is safe; a parent only holds one delegate, so among siblings the
+    last ``hit_slop`` applied wins (matching the platform limitation).
+
+    Requires a known frame, so
+    [`set_frame`][pythonnative.native_views.android.AndroidViewHandler.set_frame]
+    records the frame and re-invokes this; prop-only updates before
+    the first frame defer until layout runs.
+    """
+    state = _state_of(view)
+    frame = state.get("frame")
+    if frame is None:
+        return
+    merged = state.get("props") or {}
+    insets = _hit_slop_insets(merged.get("hit_slop"))
+    try:
+        parent = view.getParent()
+        if parent is None:
+            return
+        if insets is None:
+            if state.pop("hit_slop_active", None):
+                parent.setTouchDelegate(None)
+            return
+        top, left, bottom, right = insets
+        x, y, width, height = frame
+        Rect = jclass("android.graphics.Rect")
+        TouchDelegate = jclass("android.view.TouchDelegate")
+        rect = Rect(
+            _dp(x - left),
+            _dp(y - top),
+            _dp(x + width + right),
+            _dp(y + height + bottom),
+        )
+        parent.setTouchDelegate(TouchDelegate(rect, view))
+        state["hit_slop_active"] = True
+    except Exception:
+        diagnostics.swallowed("android._update_hit_slop")
 
 
 def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
@@ -433,12 +675,24 @@ def _apply_common_visual(view: Any, props: Dict[str, Any]) -> None:
             view.setClipChildren(clip)
             view.setClipToPadding(clip)
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_common_visual")
     if "opacity" in props and props["opacity"] is not None:
         try:
             view.setAlpha(float(props["opacity"]))
         except Exception:
-            pass
+            diagnostics.swallowed("android._apply_common_visual")
+    if "z_index" in props:
+        # ``setZ`` takes pixels, so scale like other coordinates; a
+        # removal (``None``) resets the view to the default plane.
+        try:
+            z = props["z_index"]
+            view.setZ(float(_dp(float(z))) if z is not None else 0.0)
+        except Exception:
+            diagnostics.swallowed("android._apply_common_visual")
+    if "pointer_events" in props:
+        _apply_pointer_events(view, props["pointer_events"])
+    if "hit_slop" in props:
+        _update_hit_slop(view)
     _apply_shadow(view, props)
     _apply_transform(view, props)
     _apply_accessibility(view, props)
@@ -453,10 +707,14 @@ 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.
+    forwarded as ``gesture:<i>`` events for this view's tag. Specs
+    (including ``simultaneous`` / ``wait_for`` metadata and fling
+    configs) pass through to the arbiter untouched; all arbitration
+    and recognition live in ``pythonnative.gestures``. Time-based
+    deadlines (long press, multi-tap windows) are polled with a
+    main-looper ``Handler`` scheduled at the arbiter's
+    ``next_deadline()``. 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:
@@ -475,13 +733,27 @@ def _wire_gestures(view: Any, specs: Any) -> None:
 
 
 def _schedule_arbiter_poll(view: Any, state: Dict[str, Any]) -> None:
-    """Schedule a main-looper poll at the arbiter's next deadline (long-press)."""
+    """Schedule a main-looper poll at the arbiter's next deadline.
+
+    Deadlines cover every time-based recognizer decision: long-press
+    activation and the multi-tap windows that flush an Exclusive
+    double-tap/single-tap buffer. Called after every pointer event
+    (not just DOWN) because a deadline can appear on UP, when no
+    further touch events arrive to drive the arbiter forward.
+
+    A pending poll at or before the requested deadline is reused
+    rather than stacking duplicate runnables; each poll reschedules
+    itself for the following deadline until none remains.
+    """
     arbiter = state.get("arbiter")
     if arbiter is None:
         return
     deadline = arbiter.next_deadline()
     if deadline is None:
         return
+    pending = state.get("poll_deadline")
+    if pending is not None and pending <= deadline + 0.001:
+        return
     delay_ms = max(1, int((deadline - time.monotonic()) * 1000.0))
     try:
         Handler = jclass("android.os.Handler")
@@ -491,9 +763,14 @@ def _schedule_arbiter_poll(view: Any, state: Dict[str, Any]) -> None:
         if handler is None:
             handler = Handler(Looper.getMainLooper())
             state["poll_handler"] = handler
+        token = state.get("poll_token", 0) + 1
+        state["poll_token"] = token
+        state["poll_deadline"] = deadline
 
         class _PollRunnable(dynamic_proxy(Runnable)):
             def run(self) -> None:
+                if state.get("poll_token") == token:
+                    state["poll_deadline"] = None
                 live = state.get("arbiter")
                 if live is not None:
                     live.poll(time.monotonic())
@@ -501,7 +778,8 @@ def _schedule_arbiter_poll(view: Any, state: Dict[str, Any]) -> None:
 
         handler.postDelayed(_PollRunnable(), delay_ms)
     except Exception:
-        pass
+        state["poll_deadline"] = None
+        diagnostics.swallowed("android._schedule_arbiter_poll")
 
 
 def _bind_touch_stream(view: Any, state: Dict[str, Any]) -> None:
@@ -511,11 +789,13 @@ def _bind_touch_stream(view: Any, state: Dict[str, Any]) -> None:
 
         class _GestureTouchProxy(dynamic_proxy(OnTouchListener)):
             def onTouch(self, v: Any, event: Any) -> bool:
+                if _pointer_events_blocked(v):
+                    return False
                 return bool(_feed_motion_event(v, state, event))
 
         view.setOnTouchListener(_GestureTouchProxy())
     except Exception:
-        pass
+        diagnostics.swallowed("android._bind_touch_stream")
 
 
 def _feed_motion_event(view: Any, state: Dict[str, Any], event: Any) -> bool:
@@ -535,7 +815,6 @@ def _feed_motion_event(view: Any, state: Dict[str, Any], event: Any) -> bool:
             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))
@@ -546,13 +825,17 @@ def _feed_motion_event(view: Any, state: Dict[str, Any], event: Any) -> bool:
                     if parent is not None:
                         parent.requestDisallowInterceptTouchEvent(True)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android._feed_motion_event")
         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)
+        # Every event can move the next time-based deadline (long-press
+        # activation, multi-tap windows opened on UP), so reschedule
+        # unconditionally; the scheduler dedups pending polls.
+        _schedule_arbiter_poll(view, state)
         return True
     except Exception:
         return True
@@ -603,7 +886,7 @@ def _read_animated_value(view: Any, prop_name: str) -> Any:
         if prop_name == "rotate":
             return float(view.getRotation())
     except Exception:
-        pass
+        diagnostics.swallowed("android._read_animated_value")
     return None
 
 
@@ -639,7 +922,7 @@ def _make_end_listener(anim_id: int) -> Any:
 
                 native_animation_completed(anim_id, not self._cancelled)
             except Exception:
-                pass
+                diagnostics.swallowed("android._make_end_listener._EndProxy.onAnimationEnd")
 
     return _EndProxy()
 
@@ -731,7 +1014,7 @@ class AndroidViewHandler(ViewHandler):
             if parent is not None:
                 parent.removeView(native_view)
         except Exception:
-            pass
+            diagnostics.swallowed("android.AndroidViewHandler.destroy")
         _forget(native_view)
 
     def _build(self, props: Dict[str, Any]) -> Any:
@@ -760,17 +1043,24 @@ class AndroidViewHandler(ViewHandler):
                     lp.width = px_w
                     lp.height = px_h
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android.AndroidViewHandler.set_frame")
             try:
                 lp.leftMargin = px_x
                 lp.topMargin = px_y
                 lp.rightMargin = 0
                 lp.bottomMargin = 0
             except Exception:
-                pass
+                diagnostics.swallowed("android.AndroidViewHandler.set_frame")
             native_view.setLayoutParams(lp)
+            # ``hit_slop`` needs the frame (and an attached parent, which
+            # exists by the time frames are applied) to size its
+            # TouchDelegate rect, so record the frame and recompute here.
+            state = _state_of(native_view)
+            state["frame"] = (x, y, width, height)
+            if (state.get("props") or {}).get("hit_slop") is not None or state.get("hit_slop_active"):
+                _update_hit_slop(native_view)
         except Exception:
-            pass
+            diagnostics.swallowed("android.AndroidViewHandler.set_frame")
 
     def measure_intrinsic(
         self,
@@ -801,7 +1091,13 @@ class AndroidViewHandler(ViewHandler):
             return (0.0, 0.0)
 
     def set_animated_property(self, native_view: Any, prop_name: str, value: Any) -> None:
-        """Apply one Python-driven animation frame immediately."""
+        """Apply one Python-driven animation frame immediately.
+
+        Handles float transform props (dp-scaled translations, scales,
+        rotation degrees, opacity) and interpolated color frames for
+        ``background_color`` / ``color`` ("#AARRGGBB" / "#RRGGBB"
+        strings or ints). Unknown props are silently ignored.
+        """
         if native_view is None:
             return
         try:
@@ -821,9 +1117,14 @@ class AndroidViewHandler(ViewHandler):
             elif prop_name == "rotate":
                 native_view.setRotation(float(value))
             elif prop_name == "background_color":
-                native_view.setBackgroundColor(parse_color_int(value))
+                _set_animated_background(native_view, value)
+            elif prop_name == "color":
+                # Interpolations emit "#AARRGGBB" strings; parse_color_int
+                # accepts strings and raw ints alike. Views without
+                # setTextColor fall into the except below and skip.
+                native_view.setTextColor(parse_color_int(value))
         except Exception:
-            pass
+            diagnostics.swallowed("android.AndroidViewHandler.set_animated_property")
 
     def start_animation(
         self,
@@ -851,7 +1152,7 @@ class AndroidViewHandler(ViewHandler):
         try:
             entry["animator"].cancel()
         except Exception:
-            pass
+            diagnostics.swallowed("android.AndroidViewHandler.cancel_animation")
         return _read_animated_value(entry.get("view"), str(entry.get("prop", "")))
 
 
@@ -866,11 +1167,13 @@ class FlexContainerHandler(AndroidViewHandler):
     All flex semantics (direction, alignment, distribution, padding)
     are computed by the layout engine and applied via
     [`set_frame`][pythonnative.native_views.android.AndroidViewHandler.set_frame].
-    The container itself is just a positioning surface.
+    The container itself is just a positioning surface (the template's
+    ``PNFrameLayout`` when available, so ``pointer_events`` gets real
+    touch interception).
     """
 
     def _build(self, props: Dict[str, Any]) -> Any:
-        return jclass("android.widget.FrameLayout")(_ctx())
+        return _new_container()
 
     def insert_child(self, parent: Any, child: Any, index: int) -> None:
         _insert_view(parent, child, index)
@@ -879,7 +1182,7 @@ class FlexContainerHandler(AndroidViewHandler):
         try:
             parent.removeView(child)
         except Exception:
-            pass
+            diagnostics.swallowed("android.FlexContainerHandler.remove_child")
 
 
 def _insert_view(parent: Any, child: Any, index: int) -> None:
@@ -905,7 +1208,7 @@ def _insert_view(parent: Any, child: Any, index: int) -> None:
         try:
             parent.addView(child)
         except Exception:
-            pass
+            diagnostics.swallowed("android._insert_view")
 
 
 # ======================================================================
@@ -993,7 +1296,7 @@ def _build_spannable(spans: Any) -> Any:
                 StrikethroughSpan = jclass("android.text.style.StrikethroughSpan")
                 _set(StrikethroughSpan())
         except Exception:
-            pass
+            diagnostics.swallowed("android._build_spannable")
     return builder
 
 
@@ -1035,7 +1338,7 @@ class TextHandler(AndroidViewHandler):
                 else:
                     tv.setTypeface(tv.getTypeface(), style)
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextHandler._apply")
         if "max_lines" in props and props["max_lines"] is not None:
             tv.setMaxLines(int(props["max_lines"]))
         if "text_align" in props:
@@ -1050,14 +1353,14 @@ class TextHandler(AndroidViewHandler):
                 size = float(merged.get("font_size") or 16.0)
                 tv.setLetterSpacing(float(props["letter_spacing"]) / max(size, 1.0))
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextHandler._apply")
         if "line_height" in props and props["line_height"] is not None:
             try:
                 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
+                diagnostics.swallowed("android.TextHandler._apply")
         if "text_decoration" in props:
             try:
                 Paint = jclass("android.graphics.Paint")
@@ -1068,7 +1371,7 @@ class TextHandler(AndroidViewHandler):
                     flags |= Paint.STRIKE_THRU_TEXT_FLAG
                 tv.setPaintFlags(flags)
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextHandler._apply")
         _apply_common_visual(tv, props)
 
 
@@ -1147,7 +1450,7 @@ class ScrollViewHandler(AndroidViewHandler):
                 try:
                     outer.setEnabled(False)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android.ScrollViewHandler.create")
         self._bind_scroll_listener(outer, sv)
         self._apply(outer, props, initial=True)
         if props.get("gestures"):
@@ -1165,7 +1468,7 @@ class ScrollViewHandler(AndroidViewHandler):
                 sv.setVerticalScrollBarEnabled(show)
                 sv.setHorizontalScrollBarEnabled(show)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ScrollViewHandler._apply")
         if "bounces" in props:
             # ``bounces`` is only present when ``False``; map it to the
             # closest analogue, the over-scroll (glow) mode.
@@ -1174,7 +1477,7 @@ class ScrollViewHandler(AndroidViewHandler):
                 mode = View.OVER_SCROLL_NEVER if props["bounces"] is False else View.OVER_SCROLL_IF_CONTENT_SCROLLS
                 sv.setOverScrollMode(mode)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ScrollViewHandler._apply")
         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
@@ -1190,7 +1493,7 @@ class ScrollViewHandler(AndroidViewHandler):
         try:
             sv.removeView(child)
         except Exception:
-            pass
+            diagnostics.swallowed("android.ScrollViewHandler.remove_child")
 
     def command(self, native_view: Any, name: str, args: Dict[str, Any]) -> Any:
         state = _state_of(native_view)
@@ -1206,7 +1509,7 @@ class ScrollViewHandler(AndroidViewHandler):
                 else:
                     sv.scrollTo(x_px, y_px)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ScrollViewHandler.command")
             return None
         if name == "scroll_to_end":
             try:
@@ -1220,7 +1523,7 @@ class ScrollViewHandler(AndroidViewHandler):
                     target_y = max(0, int(child.getHeight()) - int(sv.getHeight()))
                     sv.smoothScrollTo(0, target_y)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ScrollViewHandler.command")
             return None
         if name == "get_scroll_offset":
             try:
@@ -1250,11 +1553,13 @@ class ScrollViewHandler(AndroidViewHandler):
                         density = _density() or 1.0
                         _fire(outer, "on_scroll", {"x": scroll_x / density, "y": scroll_y / density})
                     except Exception:
-                        pass
+                        diagnostics.swallowed(
+                            "android.ScrollViewHandler._bind_scroll_listener._ScrollChangeProxy.onScrollChange"
+                        )
 
             sv.setOnScrollChangeListener(_ScrollChangeProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.ScrollViewHandler._bind_scroll_listener")
 
     def _wrap_in_refresh(self, sv: Any) -> Any:
         try:
@@ -1278,7 +1583,7 @@ class ScrollViewHandler(AndroidViewHandler):
 
             srl.setOnRefreshListener(_RefreshProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.ScrollViewHandler._bind_refresh_listener")
 
     def _apply_refresh(self, outer: Any, props: Dict[str, Any]) -> None:
         srl = _state_of(outer).get("refresh")
@@ -1289,21 +1594,21 @@ class ScrollViewHandler(AndroidViewHandler):
             try:
                 srl.setEnabled(False)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ScrollViewHandler._apply_refresh")
             return
         try:
             srl.setEnabled(True)
         except Exception:
-            pass
+            diagnostics.swallowed("android.ScrollViewHandler._apply_refresh")
         if spec.get("tint_color"):
             try:
                 srl.setColorSchemeColors([parse_color_int(spec["tint_color"])])
             except Exception:
-                pass
+                diagnostics.swallowed("android.ScrollViewHandler._apply_refresh")
         try:
             srl.setRefreshing(bool(spec.get("refreshing")))
         except Exception:
-            pass
+            diagnostics.swallowed("android.ScrollViewHandler._apply_refresh")
 
 
 class TextInputHandler(AndroidViewHandler):
@@ -1316,7 +1621,7 @@ class TextInputHandler(AndroidViewHandler):
             if not props.get("multiline"):
                 et.setSingleLine(True)
         except Exception:
-            pass
+            diagnostics.swallowed("android.TextInputHandler._build")
         self._bind_listeners(et, props)
         return et
 
@@ -1342,7 +1647,7 @@ class TextInputHandler(AndroidViewHandler):
 
             et.addTextChangedListener(ChangeProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.TextInputHandler._bind_listeners")
         try:
 
             class _FocusProxy(dynamic_proxy(jclass("android.view.View").OnFocusChangeListener)):
@@ -1351,7 +1656,7 @@ class TextInputHandler(AndroidViewHandler):
 
             et.setOnFocusChangeListener(_FocusProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.TextInputHandler._bind_listeners")
 
     def _apply(self, et: Any, props: Dict[str, Any], initial: bool) -> None:
         state = _state_of(et)
@@ -1368,7 +1673,7 @@ class TextInputHandler(AndroidViewHandler):
                     selection_start = et.getSelectionStart()
                     selection_end = et.getSelectionEnd()
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android.TextInputHandler._apply")
                 state["suppress"] = True
                 try:
                     et.setText(incoming)
@@ -1381,7 +1686,7 @@ class TextInputHandler(AndroidViewHandler):
                         else:
                             et.setSelection(start, end)
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android.TextInputHandler._apply")
                 finally:
                     state["suppress"] = False
         if "placeholder" in props:
@@ -1390,7 +1695,7 @@ class TextInputHandler(AndroidViewHandler):
             try:
                 et.setHintTextColor(parse_color_int(props["placeholder_color"]))
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if "font_size" in props and props["font_size"] is not None:
             et.setTextSize(float(props["font_size"]))
         if "color" in props and props["color"] is not None:
@@ -1428,18 +1733,18 @@ class TextInputHandler(AndroidViewHandler):
                     et.setSingleLine(True)
                 et.setInputType(base)
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if "max_length" in props and props["max_length"] is not None:
             try:
                 InputFilter = jclass("android.text.InputFilter$LengthFilter")
                 et.setFilters([InputFilter(int(props["max_length"]))])
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if "auto_focus" in props and props["auto_focus"]:
             try:
                 et.requestFocus()
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if "editable" in props:
             # ``editable`` is only present when ``False`` (read-only); a
             # removal (``None``) restores editing. We keep the field
@@ -1452,12 +1757,12 @@ class TextInputHandler(AndroidViewHandler):
                 et.setCursorVisible(editable)
                 et.setLongClickable(editable)
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if "selection_color" in props and props["selection_color"] is not None:
             try:
                 et.setHighlightColor(parse_color_int(props["selection_color"]))
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if "text_content_type" in props and props["text_content_type"] is not None:
             self._apply_autofill(et, str(props["text_content_type"]))
         if "clear_button" in props:
@@ -1485,7 +1790,7 @@ class TextInputHandler(AndroidViewHandler):
                 action = rkt_mapping.get(props["return_key_type"], EditorInfo.IME_ACTION_DONE)
                 et.setImeOptions(action)
             except Exception:
-                pass
+                diagnostics.swallowed("android.TextInputHandler._apply")
         if initial or "multiline" in props:
             self._apply_editor_action(et)
         _apply_common_visual(et, props)
@@ -1514,7 +1819,9 @@ class TextInputHandler(AndroidViewHandler):
                         try:
                             _fire(view, "on_submit", str(view.getText()))
                         except Exception:
-                            pass
+                            diagnostics.swallowed(
+                                "android.TextInputHandler._apply_editor_action.SubmitProxy.onEditorAction"
+                            )
                     if not multiline:
                         try:
                             view.clearFocus()
@@ -1522,12 +1829,14 @@ class TextInputHandler(AndroidViewHandler):
                             imm = ctx.getSystemService(Context.INPUT_METHOD_SERVICE)
                             imm.hideSoftInputFromWindow(view.getWindowToken(), 0)
                         except Exception:
-                            pass
+                            diagnostics.swallowed(
+                                "android.TextInputHandler._apply_editor_action.SubmitProxy.onEditorAction"
+                            )
                     return True
 
             et.setOnEditorActionListener(SubmitProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.TextInputHandler._apply_editor_action")
 
     @staticmethod
     def _autofill_hint(content_type: str) -> Optional[str]:
@@ -1559,7 +1868,7 @@ class TextInputHandler(AndroidViewHandler):
             if hint:
                 et.setAutofillHints([hint])
         except Exception:
-            pass
+            diagnostics.swallowed("android.TextInputHandler._apply_autofill")
 
     def _apply_clear_button(self, et: Any, enabled: bool) -> None:
         # Best-effort drawableEnd "X": shows a system clear icon and wires
@@ -1588,12 +1897,12 @@ class TextInputHandler(AndroidViewHandler):
                                     view.setText("")
                                     return True
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android.TextInputHandler._apply_clear_button._ClearTouchProxy.onTouch")
                     return False
 
             et.setOnTouchListener(_ClearTouchProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.TextInputHandler._apply_clear_button")
 
 
 class ImageHandler(AndroidViewHandler):
@@ -1606,12 +1915,12 @@ class ImageHandler(AndroidViewHandler):
                 ColorStateList = jclass("android.content.res.ColorStateList")
                 iv.setImageTintList(ColorStateList.valueOf(parse_color_int(props["tint_color"])))
             except Exception:
-                pass
+                diagnostics.swallowed("android.ImageHandler._apply")
         if "placeholder_color" in props and props["placeholder_color"] is not None:
             try:
                 iv.setBackgroundColor(parse_color_int(props["placeholder_color"]))
             except Exception:
-                pass
+                diagnostics.swallowed("android.ImageHandler._apply")
         if "source" in props and props["source"]:
             self._load_source(iv, str(props["source"]))
         if "scale_type" in props and props["scale_type"]:
@@ -1648,7 +1957,7 @@ class ImageHandler(AndroidViewHandler):
                         iv.setImageBitmap(bitmap)
                         _fire(iv, "on_load")
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android.ImageHandler._load_source._on_ready")
 
                 def _on_error(message: str) -> None:
                     if _state_of(iv).get("pending_uri") == source:
@@ -1674,7 +1983,7 @@ class ImageHandler(AndroidViewHandler):
                 else:
                     _fire(iv, "on_error", f"drawable {res_name!r} not found")
         except Exception:
-            pass
+            diagnostics.swallowed("android.ImageHandler._load_source")
 
     def _load_data_uri(self, iv: Any, source: str) -> None:
         """Decode an inline ``data:`` URI (base64 payload) into the view."""
@@ -1719,7 +2028,7 @@ class ImageHandler(AndroidViewHandler):
                 target_w = int(iv.getWidth())
                 target_h = int(iv.getHeight())
             except Exception:
-                pass
+                diagnostics.swallowed("android.ImageHandler._decode_downsampled")
             if target_w <= 0:
                 try:
                     metrics = _ctx().getResources().getDisplayMetrics()
@@ -1780,7 +2089,7 @@ class ProgressBarHandler(AndroidViewHandler):
                 ColorStateList = jclass("android.content.res.ColorStateList")
                 pb.setProgressTintList(ColorStateList.valueOf(parse_color_int(props["color"])))
             except Exception:
-                pass
+                diagnostics.swallowed("android.ProgressBarHandler._apply")
         if "track_color" in props and props["track_color"] is not None:
             try:
                 ColorStateList = jclass("android.content.res.ColorStateList")
@@ -1788,12 +2097,12 @@ class ProgressBarHandler(AndroidViewHandler):
                 pb.setProgressBackgroundTintList(track)
                 pb.setSecondaryProgressTintList(track)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ProgressBarHandler._apply")
         if "indeterminate" in props:
             try:
                 pb.setIndeterminate(bool(props["indeterminate"]))
             except Exception:
-                pass
+                diagnostics.swallowed("android.ProgressBarHandler._apply")
 
 
 class ActivityIndicatorHandler(AndroidViewHandler):
@@ -1809,7 +2118,7 @@ class ActivityIndicatorHandler(AndroidViewHandler):
                 ColorStateList = jclass("android.content.res.ColorStateList")
                 pb.setIndeterminateTintList(ColorStateList.valueOf(parse_color_int(props["color"])))
             except Exception:
-                pass
+                diagnostics.swallowed("android.ActivityIndicatorHandler._apply")
         if "size" in props and props["size"] is not None:
             # The framework ProgressBar has no runtime size switch, so
             # approximate "large" by scaling the indeterminate drawable.
@@ -1818,7 +2127,7 @@ class ActivityIndicatorHandler(AndroidViewHandler):
                 pb.setScaleX(scale)
                 pb.setScaleY(scale)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ActivityIndicatorHandler._apply")
 
 
 def _make_web_client(wv: Any) -> Any:
@@ -1854,13 +2163,13 @@ def _make_web_client(wv: Any) -> Any:
                         )
                         view.evaluateJavascript(shim, None)
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android._make_web_client._WebClientProxy.onPageFinished")
                 inject_js = (_state_of(wv).get("props") or {}).get("inject_javascript")
                 if inject_js:
                     try:
                         view.evaluateJavascript(str(inject_js), None)
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android._make_web_client._WebClientProxy.onPageFinished")
 
             def shouldOverrideUrlLoading(self, view: Any, request: Any) -> bool:
                 try:
@@ -1873,7 +2182,7 @@ def _make_web_client(wv: Any) -> Any:
 
                         _fire(wv, "on_message", unquote(url[len(scheme) :]))
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android._make_web_client._WebClientProxy.shouldOverrideUrlLoading")
                     return True
                 return False
 
@@ -1893,7 +2202,7 @@ class WebViewHandler(AndroidViewHandler):
             try:
                 wv.getSettings().setJavaScriptEnabled(True)
             except Exception:
-                pass
+                diagnostics.swallowed("android.WebViewHandler._apply")
 
         if initial:
             client = _make_web_client(wv)
@@ -1901,19 +2210,19 @@ class WebViewHandler(AndroidViewHandler):
                 try:
                     wv.setWebViewClient(client)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android.WebViewHandler._apply")
 
         # ``html`` takes precedence over ``url`` when both are present.
         if "html" in props and props["html"]:
             try:
                 wv.loadDataWithBaseURL(None, str(props["html"]), "text/html", "utf-8", None)
             except Exception:
-                pass
+                diagnostics.swallowed("android.WebViewHandler._apply")
         elif "url" in props and props["url"]:
             try:
                 wv.loadUrl(str(props["url"]))
             except Exception:
-                pass
+                diagnostics.swallowed("android.WebViewHandler._apply")
 
         if "scroll_enabled" in props:
             self._apply_scroll_enabled(wv, props["scroll_enabled"])
@@ -1930,7 +2239,7 @@ class WebViewHandler(AndroidViewHandler):
             else:
                 wv.setOnTouchListener(None)
         except Exception:
-            pass
+            diagnostics.swallowed("android.WebViewHandler._apply_scroll_enabled")
 
 
 class SpacerHandler(AndroidViewHandler):
@@ -1952,7 +2261,7 @@ class SafeAreaViewHandler(FlexContainerHandler):
     """Safe-area container using FrameLayout with ``fitsSystemWindows``."""
 
     def _build(self, props: Dict[str, Any]) -> Any:
-        fl = jclass("android.widget.FrameLayout")(_ctx())
+        fl = _new_container()
         fl.setFitsSystemWindows(True)
         return fl
 
@@ -1995,7 +2304,7 @@ class ModalHandler(AndroidViewHandler):
             try:
                 dialog.setCanceledOnTouchOutside(props["dismiss_on_backdrop"] is not False)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ModalHandler._apply")
 
     def insert_child(self, parent: Any, child: Any, index: int) -> None:
         state = _state_of(parent)
@@ -2012,7 +2321,7 @@ class ModalHandler(AndroidViewHandler):
             try:
                 content.removeView(child)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ModalHandler.remove_child")
         else:
             buf = state.get("pending")
             if buf and child in buf:
@@ -2057,18 +2366,18 @@ class ModalHandler(AndroidViewHandler):
                         WMLP = jclass("android.view.WindowManager$LayoutParams")
                         window.setLayout(WMLP.MATCH_PARENT, WMLP.MATCH_PARENT)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ModalHandler._present")
             try:
                 dialog.setCanceledOnTouchOutside(props.get("dismiss_on_backdrop") is not False)
             except Exception:
-                pass
+                diagnostics.swallowed("android.ModalHandler._present")
             state["dialog"] = dialog
             state["content_view"] = content
             for child in state.pop("pending", []):
                 try:
                     content.addView(child)
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android.ModalHandler._present")
 
             OnShowListener = jclass("android.content.DialogInterface$OnShowListener")
 
@@ -2087,7 +2396,7 @@ class ModalHandler(AndroidViewHandler):
             dialog.setOnDismissListener(_DismissProxy())
             dialog.show()
         except Exception:
-            pass
+            diagnostics.swallowed("android.ModalHandler._present")
 
     def _dismiss(self, placeholder: Any, state: Dict[str, Any]) -> None:
         dialog = state.pop("dialog", None)
@@ -2096,7 +2405,7 @@ class ModalHandler(AndroidViewHandler):
             try:
                 dialog.dismiss()
             except Exception:
-                pass
+                diagnostics.swallowed("android.ModalHandler._dismiss")
 
 
 # ======================================================================
@@ -2148,7 +2457,7 @@ class PortalHandler(AndroidViewHandler):
             lp = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
             container.addView(overlay, lp)
         except Exception:
-            pass
+            diagnostics.swallowed("android.PortalHandler._ensure_attached")
 
     def insert_child(self, parent: Any, child: Any, index: int) -> None:
         self._ensure_attached(parent)
@@ -2158,7 +2467,7 @@ class PortalHandler(AndroidViewHandler):
         try:
             parent.removeView(child)
         except Exception:
-            pass
+            diagnostics.swallowed("android.PortalHandler.remove_child")
 
     def set_frame(self, native_view: Any, x: float, y: float, width: float, height: float) -> None:
         # The overlay fills its container via MATCH_PARENT layout params;
@@ -2171,7 +2480,7 @@ class PortalHandler(AndroidViewHandler):
             if parent is not None:
                 parent.removeView(overlay)
         except Exception:
-            pass
+            diagnostics.swallowed("android.PortalHandler._teardown")
 
 
 class SliderHandler(AndroidViewHandler):
@@ -2225,7 +2534,7 @@ class TabBarHandler(AndroidViewHandler):
             try:
                 bnv.setLabelVisibilityMode(self._LABEL_VISIBILITY_LABELED)
             except Exception:
-                pass
+                diagnostics.swallowed("android.TabBarHandler._build")
             return bnv
         except Exception:
             LinearLayout = jclass("android.widget.LinearLayout")
@@ -2275,7 +2584,7 @@ class TabBarHandler(AndroidViewHandler):
 
             bnv.setOnItemSelectedListener(_TabSelectProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.TabBarHandler._bind_material_listener")
 
     def _set_menu(self, bnv: Any, items: list) -> None:
         try:
@@ -2289,9 +2598,9 @@ class TabBarHandler(AndroidViewHandler):
                     try:
                         menu_item.setIcon(res_id)
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android.TabBarHandler._set_menu")
         except Exception:
-            pass
+            diagnostics.swallowed("android.TabBarHandler._set_menu")
 
     def _resolve_icon(self, icon: Any) -> int:
         """Resolve a tab icon spec to an `android.R.drawable.*` res id.
@@ -2325,7 +2634,7 @@ class TabBarHandler(AndroidViewHandler):
                     try:
                         bnv.setSelectedItemId(i)
                     except Exception:
-                        pass
+                        diagnostics.swallowed("android.TabBarHandler._set_active")
                     break
 
     def _apply_fallback(self, ll: Any, props: Dict[str, Any]) -> None:
@@ -2374,7 +2683,7 @@ class PressableHandler(FlexContainerHandler):
     _TAP_SLOP_DP = 12.0
 
     def _build(self, props: Dict[str, Any]) -> Any:
-        fl = jclass("android.widget.FrameLayout")(_ctx())
+        fl = _new_container()
         fl.setClickable(True)
         fl.setFocusable(True)
         self._bind_press_stream(fl)
@@ -2403,6 +2712,8 @@ class PressableHandler(FlexContainerHandler):
 
             class _PressTouchProxy(dynamic_proxy(OnTouchListener)):
                 def onTouch(self, view: Any, event: Any) -> bool:
+                    if _pointer_events_blocked(view):
+                        return False
                     state = _state_of(view)
                     _feed_motion_event(view, state, event)
                     action = int(event.getActionMasked())
@@ -2425,7 +2736,9 @@ class PressableHandler(FlexContainerHandler):
                             try:
                                 view.animate().alpha(opacity).setDuration(50).start()
                             except Exception:
-                                pass
+                                diagnostics.swallowed(
+                                    "android.PressableHandler._bind_press_stream._PressTouchProxy.onTouch"
+                                )
                         if _has_event(view, "on_long_press"):
                             seq = press["seq"]
 
@@ -2456,7 +2769,9 @@ class PressableHandler(FlexContainerHandler):
                         try:
                             view.animate().alpha(1.0).setDuration(100).start()
                         except Exception:
-                            pass
+                            diagnostics.swallowed(
+                                "android.PressableHandler._bind_press_stream._PressTouchProxy.onTouch"
+                            )
                         if action == 1 and not press["moved"] and not press["long_fired"]:
                             _fire(view, "on_press")
                         return True
@@ -2464,7 +2779,7 @@ class PressableHandler(FlexContainerHandler):
 
             fl.setOnTouchListener(_PressTouchProxy())
         except Exception:
-            pass
+            diagnostics.swallowed("android.PressableHandler._bind_press_stream")
 
 
 # ======================================================================
@@ -2491,20 +2806,29 @@ class StatusBarHandler(AndroidViewHandler):
                 return
             if "background_color" in props and props["background_color"] is not None:
                 window.setStatusBarColor(parse_color_int(props["background_color"]))
+            View = jclass("android.view.View")
+            decor = window.getDecorView()
             if "bar_style" in props and props["bar_style"] is not None:
                 # API 23+: setSystemUiVisibility with SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
                 # for dark-content (light backgrounds), 0 for light-content.
-                View = jclass("android.view.View")
                 bar_style = props["bar_style"]
-                decor = window.getDecorView()
                 flags = decor.getSystemUiVisibility()
                 if bar_style in ("dark", "default"):
                     flags |= View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
                 else:
                     flags &= ~View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
                 decor.setSystemUiVisibility(flags)
-        except Exception:
-            pass
+            if "hidden" in props and props["hidden"] is not None:
+                flags = decor.getSystemUiVisibility()
+                if props["hidden"]:
+                    flags |= View.SYSTEM_UI_FLAG_FULLSCREEN
+                else:
+                    flags &= ~View.SYSTEM_UI_FLAG_FULLSCREEN
+                decor.setSystemUiVisibility(flags)
+        except Exception as exc:
+            from .. import diagnostics
+
+            diagnostics.warn_once(f"StatusBar: could not apply props on Android: {exc!r}")
 
 
 class KeyboardAvoidingViewHandler(FlexContainerHandler):
@@ -2552,7 +2876,7 @@ def _present_alert(
         try:
             on_result(index)
         except Exception:
-            pass
+            diagnostics.swallowed("android._present_alert._deliver")
 
     def _present_on_main() -> None:
         try:
@@ -2738,7 +3062,7 @@ class CheckboxHandler(AndroidViewHandler):
                 ColorStateList = jclass("android.content.res.ColorStateList")
                 cb.setButtonTintList(ColorStateList.valueOf(parse_color_int(props["color"])))
             except Exception:
-                pass
+                diagnostics.swallowed("android.CheckboxHandler._apply")
         _apply_accessibility(cb, props)
 
 
@@ -2798,7 +3122,7 @@ class SegmentedControlHandler(AndroidViewHandler):
         try:
             ll.removeAllViews()
         except Exception:
-            pass
+            diagnostics.swallowed("android.SegmentedControlHandler._rebuild")
         state["buttons"] = []
         LL_LP = jclass("android.widget.LinearLayout$LayoutParams")
         restyle = self._restyle
@@ -2808,7 +3132,7 @@ class SegmentedControlHandler(AndroidViewHandler):
             try:
                 btn.setAllCaps(False)
             except Exception:
-                pass
+                diagnostics.swallowed("android.SegmentedControlHandler._rebuild")
             # Equal-width segments: zero base width + weight 1, full height.
             btn.setLayoutParams(LL_LP(0, LL_LP.MATCH_PARENT, 1.0))
             enabled = (state.get("props") or {}).get("enabled") is not False
@@ -2856,7 +3180,7 @@ class SegmentedControlHandler(AndroidViewHandler):
             btn.setBackground(drawable)
             btn.setEnabled(enabled)
         except Exception:
-            pass
+            diagnostics.swallowed("android.SegmentedControlHandler._style_segment")
 
     def measure_intrinsic(
         self,
@@ -2911,7 +3235,7 @@ class DatePickerHandler(AndroidViewHandler):
         try:
             btn.setAllCaps(False)
         except Exception:
-            pass
+            diagnostics.swallowed("android.DatePickerHandler._build")
         open_dialog = self._open_dialog
 
         class _DateTriggerProxy(dynamic_proxy(jclass("android.view.View").OnClickListener)):
@@ -3021,7 +3345,7 @@ class DatePickerHandler(AndroidViewHandler):
             if maximum:
                 picker.setMaxDate(self._parse_to_calendar(maximum, mode).getTimeInMillis())
         except Exception:
-            pass
+            diagnostics.swallowed("android.DatePickerHandler._apply_min_max")
 
     def _parse_to_calendar(self, value: Any, mode: str) -> Any:
         Calendar = jclass("java.util.Calendar")
@@ -3033,7 +3357,7 @@ class DatePickerHandler(AndroidViewHandler):
                 fmt = SimpleDateFormat(self._PATTERNS.get(mode, self._PATTERNS["date"]), Locale.US)
                 cal.setTime(fmt.parse(str(value)))
             except Exception:
-                pass
+                diagnostics.swallowed("android.DatePickerHandler._parse_to_calendar")
         return cal
 
     def _format_calendar(self, cal: Any, mode: str) -> str:
@@ -3053,7 +3377,7 @@ class DatePickerHandler(AndroidViewHandler):
         try:
             btn.setText(iso)
         except Exception:
-            pass
+            diagnostics.swallowed("android.DatePickerHandler._commit")
         _fire(btn, "on_change", iso)
 
 
@@ -3153,7 +3477,7 @@ class VirtualListHandler(AndroidViewHandler):
                 try:
                     info["pool"].release(_java_id(container))
                 except Exception:
-                    pass
+                    diagnostics.swallowed("android.VirtualListHandler._build._Delegate.onRowRecycled")
 
             def onScrolled(self, offset_dp: float, extent_dp: float, range_dp: float) -> None:
                 view = info.get("view")
@@ -3202,12 +3526,12 @@ class VirtualListHandler(AndroidViewHandler):
             try:
                 view.setVerticalScrollBarEnabled(show)
             except Exception:
-                pass
+                diagnostics.swallowed("android.VirtualListHandler._apply")
         if data_changed and not initial:
             try:
                 view.notifyDataChanged()
             except Exception:
-                pass
+                diagnostics.swallowed("android.VirtualListHandler._apply")
 
     def _teardown(self, native_view: Any) -> None:
         info = _pn_vlist_info.pop(_java_id(native_view), None)
@@ -3238,7 +3562,7 @@ class VirtualListHandler(AndroidViewHandler):
                     args.get("animated", True) is not False,
                 )
             except Exception:
-                pass
+                diagnostics.swallowed("android.VirtualListHandler.command")
             return None
         if name == "scroll_to_index":
             try:
@@ -3247,7 +3571,7 @@ class VirtualListHandler(AndroidViewHandler):
                     args.get("animated", True) is not False,
                 )
             except Exception:
-                pass
+                diagnostics.swallowed("android.VirtualListHandler.command")
             return None
         if name == "scroll_to_end":
             info = _pn_vlist_info.get(_java_id(native_view))
@@ -3255,7 +3579,7 @@ class VirtualListHandler(AndroidViewHandler):
             try:
                 native_view.scrollToIndex(max(0, count - 1), args.get("animated", True) is not False)
             except Exception:
-                pass
+                diagnostics.swallowed("android.VirtualListHandler.command")
             return None
         if name == "get_scroll_offset":
             try: