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

pythonnative/native_modules/net_info.py

@@ -3,8 +3,10 @@
 [`NetInfo`][pythonnative.NetInfo] reports whether the device is online
 and over what kind of connection. ``fetch`` returns a snapshot dict;
 ``add_listener`` (and the [`use_net_info`][pythonnative.use_net_info]
-hook) deliver live updates as the native host forwards connectivity
-changes through
+hook) deliver live updates: while at least one listener is subscribed,
+a lightweight background watcher polls the platform's connectivity
+state and dispatches a fresh snapshot whenever it changes. Native
+hosts may also push changes directly through
 [`dispatch_net_info`][pythonnative.native_modules.net_info.dispatch_net_info].
 
 A snapshot looks like::
@@ -17,7 +19,8 @@ A snapshot looks like::
 
 from __future__ import annotations
 
-from typing import Callable, Dict, List
+import threading
+from typing import Callable, Dict, List, Optional
 
 from .. import diagnostics
 from ..hooks import use_effect, use_state
@@ -32,6 +35,11 @@ _last_state: NetInfoState = {
     "is_internet_reachable": True,
 }
 
+# Background watcher driving live updates while listeners exist.
+_WATCH_INTERVAL_S = 2.0
+_watcher_lock = threading.Lock()
+_watcher_stop: Optional[threading.Event] = None
+
 
 class NetInfo:
     """Network connectivity interface."""
@@ -48,18 +56,60 @@ class NetInfo:
 
     @staticmethod
     def add_listener(callback: Callable[[NetInfoState], None]) -> Callable[[], None]:
-        """Subscribe to connectivity changes; returns an unsubscribe fn."""
+        """Subscribe to connectivity changes; returns an unsubscribe fn.
+
+        The first subscription starts a background watcher that polls
+        the platform connectivity state every couple of seconds and
+        dispatches a snapshot on change; the watcher stops when the
+        last listener unsubscribes.
+        """
         _listeners.append(callback)
+        _ensure_watcher()
 
         def _unsubscribe() -> None:
             try:
                 _listeners.remove(callback)
             except ValueError:
                 pass
+            if not _listeners:
+                _stop_watcher()
 
         return _unsubscribe
 
 
+def _ensure_watcher() -> None:
+    """Start the connectivity watcher if a platform backend exists."""
+    global _watcher_stop
+    if not (IS_ANDROID or IS_IOS):
+        return
+    with _watcher_lock:
+        if _watcher_stop is not None:
+            return
+        stop = threading.Event()
+        _watcher_stop = stop
+
+    def _watch() -> None:
+        previous = dict(_last_state)
+        while not stop.wait(_WATCH_INTERVAL_S):
+            try:
+                current = _android_state() if IS_ANDROID else _ios_state()
+            except Exception:
+                continue
+            if current != previous:
+                previous = dict(current)
+                dispatch_net_info(current)
+
+    threading.Thread(target=_watch, daemon=True, name="pn-netinfo").start()
+
+
+def _stop_watcher() -> None:
+    global _watcher_stop
+    with _watcher_lock:
+        if _watcher_stop is not None:
+            _watcher_stop.set()
+            _watcher_stop = None
+
+
 def dispatch_net_info(state: NetInfoState) -> None:
     """Push a new connectivity snapshot and notify listeners."""
     global _last_state
@@ -71,6 +121,25 @@ def dispatch_net_info(state: NetInfoState) -> None:
             diagnostics.swallowed("net_info.dispatch_net_info")
 
 
+def dispatch_android_change() -> None:
+    """Re-read Android connectivity and notify listeners on change.
+
+    Called by the template's ``MainActivity`` from the
+    ``ConnectivityManager.NetworkCallback`` it registers via
+    ``registerDefaultNetworkCallback`` whenever the default network
+    appears, drops, or changes capabilities. The callback lives in
+    Kotlin because Chaquopy's ``dynamic_proxy`` implements interfaces
+    only and ``NetworkCallback`` is a class. Re-reading the snapshot
+    here keeps the transport-type mapping in one place, and identical
+    consecutive snapshots are dropped so paired ``onAvailable`` /
+    ``onCapabilitiesChanged`` callbacks don't double-notify.
+    """
+    state = _android_state()
+    if state == _last_state:
+        return
+    dispatch_net_info(state)
+
+
 def use_net_info() -> NetInfoState:
     """Subscribe a component to [`NetInfo`][pythonnative.NetInfo].
 

pythonnative/native_modules/notifications.py

@@ -5,9 +5,10 @@ cancelling local push notifications. Uses Android's
 ``NotificationManager`` or iOS's ``UNUserNotificationCenter``.
 
 On iOS you must ``await Notifications.request_permission()`` before
-scheduling. On Android 13+ the runtime permission should be requested
-through standard Android APIs (the manifest declaration is otherwise
-sufficient).
+scheduling. On Android 13+ the ``POST_NOTIFICATIONS`` runtime
+permission is requested automatically the first time you schedule a
+notification (the template manifest declares it); earlier Android
+versions don't prompt at all.
 
 For remote (server-sent) pushes, enable the ``remote_notifications``
 capability in ``pythonnative.toml`` and call
@@ -55,17 +56,18 @@ class Notifications:
     async def request_permission() -> bool:
         """Request notification permission from the user.
 
-        On Android the manifest declaration is normally sufficient for
-        legacy permission grants and this returns ``True`` without
-        prompting (the runtime POST_NOTIFICATIONS prompt for Android
-        13+ should be requested via standard Android APIs).
+        On Android 12 and below the manifest declaration is sufficient
+        and this returns ``True`` without prompting. On Android 13+
+        (API 33) the ``POST_NOTIFICATIONS`` runtime permission is
+        requested through [`Permissions`][pythonnative.Permissions],
+        which shows the system prompt if the user hasn't decided yet.
 
         Returns:
             ``True`` if granted (or no prompt is needed), ``False``
             otherwise.
         """
         if IS_ANDROID:
-            return True
+            return await _android_request_permission()
         return await _ios_request_permission()
 
     @staticmethod
@@ -92,10 +94,15 @@ class Notifications:
 
         Returns:
             ``True`` on success, ``False`` if the underlying native
-            call failed.
+            call failed or (on Android 13+) the user denied the
+            notification permission.
         """
         del options
         if IS_ANDROID:
+            # Android 13+ silently drops notifications posted without
+            # the POST_NOTIFICATIONS grant, so prompt before posting.
+            if not await _android_request_permission():
+                return False
             if delay_seconds > 0:
                 _cancel_android_delayed(identifier)
                 _android_delayed[identifier] = asyncio.ensure_future(
@@ -147,6 +154,27 @@ class Notifications:
 # ======================================================================
 
 
+async def _android_request_permission() -> bool:
+    """Request ``POST_NOTIFICATIONS`` on Android 13+; older versions skip.
+
+    Delegates to the shared
+    [`Permissions`][pythonnative.Permissions] machinery, which routes
+    through the activity's ``requestPermissions`` and resolves once
+    ``onRequestPermissionsResult`` arrives. Below API 33 there's no
+    runtime permission, so this resolves ``True`` immediately.
+    """
+    try:
+        from java import jclass
+
+        if int(jclass("android.os.Build$VERSION").SDK_INT) < 33:
+            return True
+    except Exception:
+        return True
+    from .permissions import GRANTED, Permissions
+
+    return await Permissions.request("notifications") == GRANTED
+
+
 def _cancel_android_delayed(identifier: str) -> None:
     pending = _android_delayed.pop(identifier, None)
     if pending is not None and not pending.done():