pythonnative 0.17.0__tar.gz → 0.17.1__tar.gz

{pythonnative-0.17.0/src/pythonnative.egg-info → pythonnative-0.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonnative
-Version: 0.17.0
+Version: 0.17.1
 Summary: Cross-platform native UI toolkit for Android and iOS
 Author: Owen Carey
 License: MIT License

{pythonnative-0.17.0 → pythonnative-0.17.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonnative"
-version = "0.17.0"
+version = "0.17.1"
 description = "Cross-platform native UI toolkit for Android and iOS"
 authors = [
   { name = "Owen Carey" }
@@ -69,6 +69,7 @@ Documentation = "https://docs.pythonnative.com/"
 
 
 
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/__init__.py

@@ -51,7 +51,7 @@ Example:
     ```
 """
 
-__version__ = "0.17.0"
+__version__ = "0.17.1"
 
 from . import runtime, sdk
 from .alerts import Alert

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/animated.py

@@ -62,6 +62,12 @@ from .style import StyleProp, resolve_style
 _TARGET_FPS = 60.0
 _FRAME_DT = 1.0 / _TARGET_FPS
 
+# Upper bound on how much wall-clock time the animation loop will try to
+# catch up on in a single iteration after thread starvation. At 60 fps
+# this is ~333 ms of simulated motion; further drift is dropped to keep
+# the loop responsive.
+_MAX_CATCHUP_FRAMES = 20
+
 _EASINGS: Dict[str, Callable[[float], float]] = {
     "linear": lambda t: t,
     "ease_in": lambda t: t * t,
@@ -199,6 +205,20 @@ class _AnimationManager:
 
     def _loop(self) -> None:
         last = time.monotonic()
+        # Clamping the per-tick dt is important for numerical stability:
+        # an underdamped spring with a 0.3 s step explodes immediately,
+        # and on iOS/Android the animation thread can be starved for
+        # several frames during render bursts. We integrate physics on a
+        # clamped dt (max 2 target frames) and sub-step when wall-clock
+        # has advanced more than that, so the perceived motion still
+        # tracks real time at most a couple of frames behind. After an
+        # extreme starvation (e.g. the app was backgrounded for seconds)
+        # we cap the catch-up at ``_MAX_CATCHUP_FRAMES`` worth of
+        # physics; any further wall-clock drift is dropped on the floor,
+        # which keeps the loop responsive instead of spinning forward
+        # through hundreds of substeps.
+        max_step = _FRAME_DT * 2.0
+        max_catchup = _FRAME_DT * _MAX_CATCHUP_FRAMES
         while not self._stopped:
             now = time.monotonic()
             dt = now - last
@@ -209,13 +229,19 @@ class _AnimationManager:
                 time.sleep(0.05)
                 last = time.monotonic()
                 continue
-            for anim in active:
-                try:
-                    finished = anim.advance(dt)
-                except Exception:
-                    finished = True
-                if finished:
-                    self.remove(anim)
+            remaining = min(dt, max_catchup)
+            while remaining > 0.0:
+                step = remaining if remaining <= max_step else max_step
+                remaining -= step
+                for anim in active:
+                    if getattr(anim, "_completed", False):
+                        continue
+                    try:
+                        finished = anim.advance(step)
+                    except Exception:
+                        finished = True
+                    if finished:
+                        self.remove(anim)
             time.sleep(_FRAME_DT)
 
 

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/layout.py

@@ -401,7 +401,17 @@ class LayoutNode:
         height: Computed height in points.
     """
 
-    __slots__ = ("style", "children", "measure", "user_data", "x", "y", "width", "height")
+    __slots__ = (
+        "style",
+        "children",
+        "measure",
+        "user_data",
+        "x",
+        "y",
+        "width",
+        "height",
+        "_pn_scroll_axis",
+    )
 
     def __init__(
         self,
@@ -418,6 +428,14 @@ class LayoutNode:
         self.y: float = 0.0
         self.width: float = 0.0
         self.height: float = 0.0
+        # ``"x"``/``"y"`` for scroll containers; ``None`` for everything
+        # else. Consumed by ``_measure_container`` to clamp the node's
+        # own main-axis size to the parent's available space while still
+        # measuring children unbounded on the scroll axis (which is what
+        # makes the native ``UIScrollView`` / Android ``ScrollView``
+        # actually scroll). The reconciler stamps this when building the
+        # layout tree for ``ScrollView`` elements.
+        self._pn_scroll_axis: Optional[str] = None
 
     def __repr__(self) -> str:
         return (
@@ -576,6 +594,22 @@ def _measure_container(
 
     width = explicit_w if explicit_w is not None else (used_w + pad_x)
     height = explicit_h if explicit_h is not None else (used_h + pad_y)
+
+    # Scroll containers: clamp the container's own main-axis size to the
+    # parent's available space when no explicit size was provided. The
+    # children are still measured against an unbounded main-axis (handled
+    # via the wrapper inserted in ``Reconciler._build_layout_tree``) so the
+    # overflow becomes the scrollable region. Without this clamp, the
+    # container would grow to fit its content and there would be no
+    # overflow for the native ScrollView to scroll. Skipped when the
+    # parent is itself unbounded, so nested scroll views still fall back
+    # to natural sizing (the inner scroll is unscrollable in that case,
+    # which matches the behavior in React Native).
+    scroll_axis = getattr(node, "_pn_scroll_axis", None)
+    if scroll_axis == "y" and explicit_h is None and math.isfinite(avail_h):
+        height = avail_h
+    elif scroll_axis == "x" and explicit_w is None and math.isfinite(avail_w):
+        width = avail_w
     return width, height
 
 

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/native_views/android.py

@@ -35,6 +35,7 @@ _pn_text_input_suppress_callbacks: dict = {}
 _pn_view_visual_props: dict = {}
 _DRAWABLE_STYLE_KEYS = ("background_color", "border_radius", "border_width", "border_color")
 
+
 # ======================================================================
 # Shared helpers
 # ======================================================================
@@ -509,18 +510,27 @@ class ButtonHandler(AndroidViewHandler):
 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.
+
     When a ``refresh_control`` prop is provided, wraps the scroll in
     a `SwipeRefreshLayout` and forwards the on-refresh callback.
     """
 
     def create(self, props: Dict[str, Any]) -> Any:
-        sv = jclass("android.widget.ScrollView")(_ctx())
+        try:
+            sv = jclass("androidx.core.widget.NestedScrollView")(_ctx())
+        except Exception:
+            sv = jclass("android.widget.ScrollView")(_ctx())
         _apply_common_visual(sv, props)
-        # Wrap the inner ScrollView in a SwipeRefreshLayout when
-        # ``refresh_control`` is asked for. Implementing this cleanly
-        # would require returning a different parent; for v1, we
-        # attach the listener via a wrapper that we expose to
-        # add_child callers below.
         return sv
 
     def update(self, native_view: Any, changed: Dict[str, Any]) -> None:
@@ -536,6 +546,17 @@ class ScrollViewHandler(AndroidViewHandler):
 class TextInputHandler(AndroidViewHandler):
     def create(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``.
+        try:
+            if not props.get("multiline"):
+                et.setSingleLine(True)
+        except Exception:
+            pass
         self._apply(et, props)
         return et
 
@@ -661,7 +682,73 @@ class TextInputHandler(AndroidViewHandler):
                     et.addTextChangedListener(watcher)
             else:
                 _pn_text_input_callbacks[key] = None
-        if "on_submit" in props and props["on_submit"] is not 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.
+            try:
+                EditorInfo = jclass("android.view.inputmethod.EditorInfo")
+                rkt_mapping = {
+                    "default": EditorInfo.IME_ACTION_UNSPECIFIED,
+                    "go": EditorInfo.IME_ACTION_GO,
+                    "google": EditorInfo.IME_ACTION_DONE,
+                    "join": EditorInfo.IME_ACTION_DONE,
+                    "next": EditorInfo.IME_ACTION_NEXT,
+                    "route": EditorInfo.IME_ACTION_DONE,
+                    "search": EditorInfo.IME_ACTION_SEARCH,
+                    "send": EditorInfo.IME_ACTION_SEND,
+                    "yahoo": EditorInfo.IME_ACTION_DONE,
+                    "done": EditorInfo.IME_ACTION_DONE,
+                }
+                action = rkt_mapping.get(props["return_key_type"], EditorInfo.IME_ACTION_DONE)
+                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")
+
+                class SubmitProxy(dynamic_proxy(EditorListener)):
+                    def __init__(self, callback: Optional[Callable[[str], None]]) -> None:
+                        super().__init__()
+                        self.callback = callback
+
+                    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
+                        try:
+                            view.clearFocus()
+                            ctx = view.getContext()
+                            imm = ctx.getSystemService(Context.INPUT_METHOD_SERVICE)
+                            imm.hideSoftInputFromWindow(view.getWindowToken(), 0)
+                        except Exception:
+                            pass
+                        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")

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/native_views/ios.py

@@ -54,6 +54,19 @@ NSObject = ObjCClass("NSObject")
 UIColor = ObjCClass("UIColor")
 UIFont = ObjCClass("UIFont")
 
+# Declare ``superview`` as a property on UIView so rubicon-objc returns
+# the actual UIView (or None) on attribute access, instead of an
+# ObjCBoundMethod. Without this, accessing ``view.superview`` returns a
+# method handle and the entire codepath that updates UIScrollView's
+# ``contentSize`` would raise silently. See rubicon-objc docs on
+# ``declare_property`` for why some ``@property`` declarations aren't
+# auto-detected by the runtime introspection.
+try:
+    _UIView = ObjCClass("UIView")
+    _UIView.declare_property("superview")
+except Exception:
+    pass
+
 
 def _objc_ptr(obj: Any) -> Optional[int]:
     """Return the raw Objective-C pointer for a Rubicon object."""
@@ -131,6 +144,8 @@ _SEL_UTF8STRING = _sel_reg(b"UTF8String")
 _SEL_ADD_TARGET_ACTION_EVENTS = _sel_reg(b"addTarget:action:forControlEvents:")
 _SEL_ON_EDIT = _sel_reg(b"onEdit:")
 _SEL_ON_SUBMIT = _sel_reg(b"onSubmit:")
+_SEL_RESIGN_FIRST_RESPONDER = _sel_reg(b"resignFirstResponder")
+_SEL_TEXT_FIELD_SHOULD_RETURN = _sel_reg(b"textFieldShouldReturn:")
 
 _NS_OBJECT_CLS = _get_cls(b"NSObject")
 
@@ -507,12 +522,19 @@ class IOSViewHandler(ViewHandler):
                 pass
             try:
                 parent = native_view.superview
-                set_content_size = getattr(parent, "setContentSize_", None)
-                if set_content_size is not None:
+                parent_cls = ""
+                try:
+                    parent_cls = str(parent.objc_class.name) if parent is not None else ""
+                except Exception:
+                    parent_cls = ""
+                # Expand the parent UIScrollView's contentSize whenever a
+                # child's frame extends past the visible bounds, so the
+                # scroll view can actually scroll to reveal it.
+                if "UIScrollView" in parent_cls:
                     bounds = parent.bounds
                     content_w = max(float(bounds.size.width), frame_x + frame_w)
                     content_h = max(float(bounds.size.height), frame_y + frame_h)
-                    set_content_size((content_w, content_h))
+                    parent.setContentSize_((content_w, content_h))
             except Exception:
                 pass
         except Exception:
@@ -651,6 +673,7 @@ _pn_tf_raw_target_map: dict = {}
 _PN_TEXTFIELD_TARGET_CLS: Optional[int] = None
 _textfield_edit_imp_ref: Any = None
 _textfield_submit_imp_ref: Any = None
+_textfield_should_return_imp_ref: Any = None
 
 
 def _textfield_text(sender_ptr: int) -> str:
@@ -694,8 +717,27 @@ def _textfield_on_submit_imp(self_ptr: int, _cmd: int, sender_ptr: int) -> None:
         pass
 
 
+def _textfield_should_return_imp(self_ptr: int, _cmd: int, tf_ptr: int) -> bool:
+    """``UITextFieldDelegate.textFieldShouldReturn:`` — dismiss the keyboard.
+
+    iOS doesn't dismiss the keyboard on Return by default; the standard
+    pattern is for the delegate to call ``resignFirstResponder`` and
+    return ``YES``. Matching that here brings PythonNative's
+    ``TextInput`` in line with React Native's default behavior and with
+    what users expect from a ``return_key_type="done"`` style.
+    """
+    try:
+        _objc_msgSend.restype = None
+        _objc_msgSend.argtypes = [_ct.c_void_p, _ct.c_void_p]
+        _objc_msgSend(_ct.c_void_p(int(tf_ptr or 0)), _SEL_RESIGN_FIRST_RESPONDER)
+    except Exception:
+        pass
+    return True
+
+
 def _ensure_textfield_target_class() -> Optional[int]:
-    global _PN_TEXTFIELD_TARGET_CLS, _textfield_edit_imp_ref, _textfield_submit_imp_ref
+    global _PN_TEXTFIELD_TARGET_CLS
+    global _textfield_edit_imp_ref, _textfield_submit_imp_ref, _textfield_should_return_imp_ref
     if _PN_TEXTFIELD_TARGET_CLS is not None:
         return _PN_TEXTFIELD_TARGET_CLS
     existing = _get_cls(b"PNTextFieldActionTarget")
@@ -706,10 +748,18 @@ def _ensure_textfield_target_class() -> Optional[int]:
     if not cls:
         return None
     action_type = _ct.CFUNCTYPE(None, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p)
+    bool_type = _ct.CFUNCTYPE(_ct.c_bool, _ct.c_void_p, _ct.c_void_p, _ct.c_void_p)
     _textfield_edit_imp_ref = action_type(_textfield_on_edit_imp)
     _textfield_submit_imp_ref = action_type(_textfield_on_submit_imp)
+    _textfield_should_return_imp_ref = bool_type(_textfield_should_return_imp)
     _add_method(cls, _SEL_ON_EDIT, _ct.cast(_textfield_edit_imp_ref, _ct.c_void_p), b"v@:@")
     _add_method(cls, _SEL_ON_SUBMIT, _ct.cast(_textfield_submit_imp_ref, _ct.c_void_p), b"v@:@")
+    _add_method(
+        cls,
+        _SEL_TEXT_FIELD_SHOULD_RETURN,
+        _ct.cast(_textfield_should_return_imp_ref, _ct.c_void_p),
+        b"c@:@",
+    )
     _reg_cls(cls)
     _PN_TEXTFIELD_TARGET_CLS = int(cls)
     return _PN_TEXTFIELD_TARGET_CLS
@@ -760,6 +810,16 @@ def _attach_textfield_raw_target(tf: Any, props: Dict[str, Any]) -> None:
             _SEL_ON_SUBMIT,
             1 << 6,
         )
+        # Wire the same object as the UITextFieldDelegate so its
+        # ``textFieldShouldReturn:`` runs and resigns first responder
+        # — without this iOS keeps the keyboard up after Return.
+        _objc_msgSend.restype = None
+        _objc_msgSend.argtypes = [_ct.c_void_p, _ct.c_void_p, _ct.c_void_p]
+        _objc_msgSend(
+            _ct.c_void_p(tf_ptr),
+            _SEL_SET_DELEGATE,
+            _ct.c_void_p(target_ptr),
+        )
     if "on_change" in props:
         _pn_tf_change_callback_map[int(target_ptr)] = props["on_change"]
     if "on_submit" in props:
@@ -1313,8 +1373,10 @@ class TextInputHandler(IOSViewHandler):
             except Exception:
                 pass
         self._common_apply(tf, props)
-        if "on_change" in props or "on_submit" in props:
-            _attach_textfield_raw_target(tf, props)
+        # Always wire the action target — even without ``on_change`` /
+        # ``on_submit`` we want the textfield's delegate set so Return
+        # dismisses the keyboard (textFieldShouldReturn:).
+        _attach_textfield_raw_target(tf, props)
 
     def _apply_textview(self, tv: Any, props: Dict[str, Any]) -> None:
         if "value" in props:

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/navigation.py

@@ -64,7 +64,14 @@ from .hooks import (
 # Focus context
 # ======================================================================
 
-_FocusContext = create_context(False)
+# Defaults to True: components rendered outside any declarative
+# navigator (e.g. the root component of a screen pushed via the host's
+# native nav stack) are by definition focused — the host's own
+# ``on_resume`` / ``on_pause`` lifecycle drives the focus state for
+# those. Declarative navigators override this provider on the active
+# subtree (always True today; reserved for future inactive-screen
+# rendering).
+_FocusContext = create_context(True)
 
 # ======================================================================
 # Data structures
@@ -925,6 +932,15 @@ def use_focus_effect(effect: Callable, deps: Optional[list] = None) -> None:
     one. Useful for starting subscriptions, refreshing data, or
     pausing animations on the inactive screen.
 
+    The focus state combines two sources of truth:
+
+    - The screen host's lifecycle (``on_resume`` / ``on_pause``), so
+      pushing a sibling onto the navigation stack blurs this screen and
+      popping back to it refocuses it.
+    - The in-tree ``_FocusContext`` value, which lets declarative
+      navigators (e.g. tabs, drawers) mark only the active subtree as
+      focused even when both screens are part of the same host.
+
     Args:
         effect: A zero-arg callable invoked when focused. Optionally
             returns a cleanup callable.
@@ -941,7 +957,46 @@ def use_focus_effect(effect: Callable, deps: Optional[list] = None) -> None:
             return pn.Text("Home")
         ```
     """
-    is_focused = use_context(_FocusContext)
+    context_focused = use_context(_FocusContext)
+
+    nav = use_context(_NavigationContext)
+    # Walk the navigator parent chain to find the screen host. Declarative
+    # navigators (Stack/Tab/Drawer) wrap the host's ``NavigationHandle``
+    # as ``_parent``; only the host-level handle has ``_host``.
+    host = None
+    cursor = nav
+    while cursor is not None:
+        candidate = getattr(cursor, "_host", None)
+        if candidate is not None:
+            host = candidate
+            break
+        cursor = getattr(cursor, "_parent", None)
+    initial_host_focus = bool(getattr(host, "_is_focused", True)) if host is not None else True
+    host_focused, set_host_focused = use_state(initial_host_focus)
+
+    def subscribe_to_host_focus() -> Any:
+        if host is None:
+            return None
+        subscribers = getattr(host, "_focus_subscribers", None)
+        if subscribers is None:
+            return None
+        subscribers.append(set_host_focused)
+        # The host may have changed focus state between the initial
+        # ``use_state`` call and this effect running (e.g. mid-render
+        # lifecycle event); resync once to avoid stale state.
+        set_host_focused(bool(host._is_focused))
+
+        def cleanup() -> None:
+            try:
+                subscribers.remove(set_host_focused)
+            except ValueError:
+                pass
+
+        return cleanup
+
+    use_effect(subscribe_to_host_focus, [])
+
+    is_focused = context_focused and host_focused
     all_deps = [is_focused] + (list(deps) if deps is not None else [])
 
     def wrapped_effect() -> Any:

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/reconciler.py

@@ -803,8 +803,37 @@ class Reconciler:
         # root in the screen.
         for child in layout_root.children:
             self._apply_layout(child, 0.0, 0.0)
+        # Lay out the children of every visible ``Modal`` as a fresh
+        # subtree sized to the viewport. Modals are excluded from the
+        # main layout tree (their content lives in a separately
+        # presented native container) so without this pass the
+        # children's frames never get computed and the modal renders
+        # blank.
+        self._layout_visible_modals(self._tree, viewport_w, viewport_h)
         self._log_viewport(f"_run_layout: pass#{layout_pass} done")
 
+    def _layout_visible_modals(
+        self,
+        vnode: VNode,
+        viewport_w: float,
+        viewport_h: float,
+    ) -> None:
+        element = vnode.element
+        if isinstance(element.type, str) and element.type == "Modal":
+            if element.props.get("visible") and vnode.children:
+                child_layout = self._build_layout_tree(vnode.children[0])
+                if child_layout is not None:
+                    viewport = LayoutNode(
+                        style={"width": viewport_w, "height": viewport_h},
+                        children=[child_layout],
+                    )
+                    calculate_layout(viewport, viewport_w, viewport_h)
+                    for c in viewport.children:
+                        self._apply_layout(c, 0.0, 0.0)
+            return
+        for child in vnode.children:
+            self._layout_visible_modals(child, viewport_w, viewport_h)
+
     def _build_layout_tree(self, vnode: VNode) -> Optional[LayoutNode]:
         """Walk `vnode` and build a parallel `LayoutNode` tree of native nodes.
 
@@ -829,6 +858,15 @@ class Reconciler:
 
         style = extract_layout_style(element.props)
         layout = LayoutNode(style=style, user_data=vnode)
+        if element.type == "ScrollView":
+            # Mark the scroll axis so the layout engine clamps the
+            # container's own main-axis size to its parent's available
+            # space (otherwise the container grows to fit its content
+            # and there is no overflow for the native ScrollView to
+            # actually scroll). The children are still wrapped below so
+            # they see an unbounded main axis when measured.
+            scroll_axis = element.props.get("scroll_axis", "vertical")
+            layout._pn_scroll_axis = "x" if scroll_axis == "horizontal" else "y"
         self._log_viewport(
             f"_build_layout_tree: node type={element.type!r} view={self._obj_debug(vnode.native_view)} "
             f"style={style!r} children={len(vnode.children)}"

{pythonnative-0.17.0 → pythonnative-0.17.1}/src/pythonnative/screen.py

@@ -165,6 +165,25 @@ def _init_host_common(host: Any, component_path: str, component_func: Any) -> No
     host._hot_reload_manifest_path = None
     host._hot_reload_last_version = None
     host._layout_listener = None  # retained on Android to prevent GC
+    # Focus state — drives ``use_focus_effect``. Starts focused because
+    # a host is only created when the screen is being presented; the
+    # platform lifecycle hooks (``on_resume`` / ``on_pause``) flip this
+    # when the user navigates to / from another screen.
+    host._is_focused = True
+    host._focus_subscribers = []
+
+
+def _set_host_focused(host: Any, focused: bool) -> None:
+    """Update ``host._is_focused`` and notify ``use_focus_effect`` subscribers."""
+    if getattr(host, "_is_focused", True) == focused:
+        return
+    host._is_focused = focused
+    subscribers = list(getattr(host, "_focus_subscribers", ()) or ())
+    for callback in subscribers:
+        try:
+            callback(focused)
+        except Exception:
+            pass
 
 
 def _push_viewport_size(host: Any, width: float, height: float) -> None:
@@ -232,6 +251,23 @@ def _flush_scheduled_renders(hosts: Sequence[Any]) -> None:
 def _on_create(host: Any) -> None:
     from .hooks import NavigationHandle, Provider, _NavigationContext
 
+    # ``on_create`` is idempotent across native-view recreations. On
+    # Android the FragmentManager destroys and recreates a screen's
+    # view every time the user pops back to it, and the platform
+    # template calls ``screen.on_create()`` again from
+    # ``onViewCreated`` — but the Python screen object (and therefore
+    # the reconciler, hook state, focus subscribers, etc.) persists
+    # across that. Re-running the full mount path here would reset
+    # use_state, clobber use_focus_effect subscriptions, and break
+    # navigation handles held by existing components, which is why
+    # the focus counter never advanced past ``1`` before this guard.
+    # If we're already mounted, just re-attach the existing root view
+    # to the (newly created) native container — ``on_resume`` will
+    # fire the focus subscribers separately.
+    if host._reconciler is not None and host._root_native_view is not None:
+        host._attach_root(host._root_native_view)
+        return
+
     host._nav_handle = NavigationHandle(host)
     host._reconciler = _new_reconciler(host)
 
@@ -711,7 +747,7 @@ if IS_ANDROID:
             pass
 
         def on_resume(self) -> None:
-            pass
+            _set_host_focused(self, True)
 
         def on_layout(self) -> None:
             # Android pushes viewport changes through the
@@ -721,7 +757,7 @@ if IS_ANDROID:
             pass
 
         def on_pause(self) -> None:
-            pass
+            _set_host_focused(self, False)
 
         def on_stop(self) -> None:
             pass
@@ -796,6 +832,18 @@ if IS_ANDROID:
                     container.removeAllViews()
                 except Exception:
                     pass
+                # When the user pops back to a previously mounted screen,
+                # ``native_view`` is the root from the prior mount and may
+                # still be parented under the old (destroyed) FrameLayout.
+                # ViewGroup.addView() throws if a view already has a
+                # parent, so detach it from the old one before re-attaching
+                # to the freshly created container.
+                try:
+                    old_parent = native_view.getParent()
+                    if old_parent is not None:
+                        old_parent.removeView(native_view)
+                except Exception:
+                    pass
                 LayoutParams = jclass("android.view.ViewGroup$LayoutParams")
                 lp = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
                 container.addView(native_view, lp)
@@ -1052,7 +1100,7 @@ else:
                 pass
 
             def on_pause(self) -> None:
-                pass
+                _set_host_focused(self, False)
 
             def on_stop(self) -> None:
                 pass
@@ -1267,6 +1315,7 @@ else:
                 # ``viewDidAppear`` always follows ``viewDidLayoutSubviews``,
                 # but trigger one extra sync here for safety in case a
                 # template overrides the layout call without forwarding.
+                _set_host_focused(self, True)
                 if self._root_native_view is None:
                     _log_pn("on_resume: no root_native_view yet, skipping")
                     return