pythonnative 0.35.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

pythonnative/native_modules/net_info.py

@@ -3,10 +3,9 @@
 [`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: 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
+hook) deliver live updates pushed by the native ``NetInfo`` module
+(``NWPathMonitor`` on iOS, ``ConnectivityManager.NetworkCallback`` on
+Android) as ``change`` events. Off device, tests push snapshots through
 [`dispatch_net_info`][pythonnative.native_modules.net_info.dispatch_net_info].
 
 A snapshot looks like::
@@ -19,12 +18,11 @@ A snapshot looks like::
 
 from __future__ import annotations
 
-import threading
-from typing import Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List
 
 from .. import diagnostics
 from ..hooks import use_effect, use_state
-from ..utils import IS_ANDROID, IS_IOS
+from .registry import native_module, on_event
 
 NetInfoState = Dict[str, object]
 
@@ -35,11 +33,6 @@ _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,66 +41,34 @@ class NetInfo:
     def fetch() -> NetInfoState:
         """Return a fresh snapshot of connectivity state."""
         global _last_state
-        if IS_ANDROID:
-            _last_state = _android_state()
-        elif IS_IOS:
-            _last_state = _ios_state()
+        try:
+            snapshot = native_module("NetInfo").call("fetch")
+        except Exception:
+            snapshot = None
+        if isinstance(snapshot, dict):
+            _last_state = _normalize(snapshot)
         return dict(_last_state)
 
     @staticmethod
     def add_listener(callback: Callable[[NetInfoState], None]) -> Callable[[], None]:
-        """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.
-        """
+        """Subscribe to connectivity changes; returns an unsubscribe fn."""
         _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 _normalize(snapshot: Dict[str, Any]) -> NetInfoState:
+    return {
+        "is_connected": bool(snapshot.get("is_connected", False)),
+        "type": str(snapshot.get("type", "unknown")),
+        "is_internet_reachable": bool(snapshot.get("is_internet_reachable", False)),
+    }
 
 
 def dispatch_net_info(state: NetInfoState) -> None:
@@ -121,25 +82,18 @@ 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()
+def _on_native_change(payload: Any) -> None:
+    if not isinstance(payload, dict):
+        return
+    state = _normalize(payload)
     if state == _last_state:
         return
     dispatch_net_info(state)
 
 
+on_event("NetInfo", "change", _on_native_change)
+
+
 def use_net_info() -> NetInfoState:
     """Subscribe a component to [`NetInfo`][pythonnative.NetInfo].
 
@@ -159,67 +113,3 @@ def use_net_info() -> NetInfoState:
 
     use_effect(_subscribe, [])
     return state
-
-
-# ======================================================================
-# iOS: SCNetworkReachability
-# ======================================================================
-
-
-def _ios_state() -> NetInfoState:
-    try:
-        from ctypes import CDLL, byref, c_uint32, c_void_p, util
-
-        sc = CDLL(util.find_library("SystemConfiguration"))
-        sc.SCNetworkReachabilityCreateWithName.restype = c_void_p
-        ref = sc.SCNetworkReachabilityCreateWithName(None, b"8.8.8.8")
-        if not ref:
-            return dict(_last_state)
-        flags = c_uint32(0)
-        ok = sc.SCNetworkReachabilityGetFlags(c_void_p(ref), byref(flags))
-        if not ok:
-            return {"is_connected": False, "type": "none", "is_internet_reachable": False}
-        reachable = bool(flags.value & 0x2)  # kSCNetworkReachabilityFlagsReachable
-        is_wwan = bool(flags.value & (1 << 18))  # kSCNetworkReachabilityFlagsIsWWAN
-        return {
-            "is_connected": reachable,
-            "type": ("cellular" if is_wwan else "wifi") if reachable else "none",
-            "is_internet_reachable": reachable,
-        }
-    except Exception:
-        return dict(_last_state)
-
-
-# ======================================================================
-# Android: ConnectivityManager
-# ======================================================================
-
-
-def _android_state() -> NetInfoState:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Context = jclass("android.content.Context")
-        manager = ctx.getSystemService(Context.CONNECTIVITY_SERVICE)
-        network = manager.getActiveNetwork()
-        if network is None:
-            return {"is_connected": False, "type": "none", "is_internet_reachable": False}
-        caps = manager.getNetworkCapabilities(network)
-        if caps is None:
-            return {"is_connected": False, "type": "none", "is_internet_reachable": False}
-        NetworkCapabilities = jclass("android.net.NetworkCapabilities")
-        if caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI):
-            kind = "wifi"
-        elif caps.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR):
-            kind = "cellular"
-        elif caps.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET):
-            kind = "ethernet"
-        else:
-            kind = "unknown"
-        reachable = bool(caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
-        return {"is_connected": True, "type": kind, "is_internet_reachable": reachable}
-    except Exception:
-        return dict(_last_state)

pythonnative/native_modules/notifications.py

@@ -1,8 +1,9 @@
-"""Cross-platform local notifications and remote push registration.
+"""Local notifications and remote push registration.
 
-Provides coroutines for requesting permission and scheduling /
-cancelling local push notifications. Uses Android's
-``NotificationManager`` or iOS's ``UNUserNotificationCenter``.
+Coroutines for requesting permission and scheduling / cancelling local
+notifications, backed by the native ``Notifications`` module
+(``UNUserNotificationCenter`` on iOS, ``NotificationManager`` on
+Android).
 
 On iOS you must ``await Notifications.request_permission()`` before
 scheduling. On Android 13+ the ``POST_NOTIFICATIONS`` runtime
@@ -36,17 +37,9 @@ Example:
 
 from __future__ import annotations
 
-import asyncio
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
-from .. import diagnostics
-from ..runtime import reject_future, resolve_future
-from ..utils import IS_ANDROID, IS_IOS
-
-# Delayed Android deliveries in flight, keyed by identifier, so
-# ``cancel`` can abort a notification that hasn't posted yet. (iOS
-# delivers delays natively through UNTimeIntervalNotificationTrigger.)
-_android_delayed: Dict[str, "asyncio.Task[Any]"] = {}
+from .registry import NativeModuleError, native_module
 
 
 class Notifications:
@@ -58,17 +51,17 @@ class Notifications:
 
         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.
+        (API 33) the ``POST_NOTIFICATIONS`` runtime permission prompt
+        is shown if the user hasn't decided yet.
 
         Returns:
             ``True`` if granted (or no prompt is needed), ``False``
             otherwise.
         """
-        if IS_ANDROID:
-            return await _android_request_permission()
-        return await _ios_request_permission()
+        try:
+            return bool(await native_module("Notifications").call_async("request_permission"))
+        except Exception:
+            return False
 
     @staticmethod
     async def schedule(
@@ -89,42 +82,34 @@ class Notifications:
             identifier: Stable ID used by
                 [`cancel`][pythonnative.native_modules.notifications.Notifications.cancel]
                 to target this notification.
-            **options: Reserved for future tuning (e.g., ``sound``,
-                ``badge``, ``category``).
+            **options: Forwarded to the native module (``sound``,
+                ``badge``, ...). Unknown keys are ignored.
 
         Returns:
             ``True`` on success, ``False`` if the underlying native
             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(
-                    _android_schedule_later(title, body, delay_seconds, identifier)
-                )
-                return True
-            return await asyncio.to_thread(_android_schedule, title, body, identifier)
-        return await asyncio.to_thread(_ios_schedule, title, body, delay_seconds, identifier)
+        try:
+            result = await native_module("Notifications").call_async(
+                "schedule",
+                title=title,
+                body=body,
+                delay_seconds=float(delay_seconds),
+                identifier=identifier,
+                **options,
+            )
+        except Exception:
+            return False
+        return bool(result)
 
     @staticmethod
     async def cancel(identifier: str = "default") -> None:
-        """Cancel a pending notification by its identifier.
-
-        Args:
-            identifier: The same string passed to
-                [`schedule`][pythonnative.native_modules.notifications.Notifications.schedule].
-        """
-        if IS_ANDROID:
-            _cancel_android_delayed(identifier)
-            await asyncio.to_thread(_android_cancel, identifier)
-            return
-        await asyncio.to_thread(_ios_cancel, identifier)
+        """Cancel a pending notification by its identifier."""
+        try:
+            await native_module("Notifications").call_async("cancel", identifier=identifier)
+        except Exception:
+            pass
 
     @staticmethod
     async def get_device_token() -> Optional[str]:
@@ -144,214 +129,8 @@ class Notifications:
             RuntimeError: If APNs registration fails, with the native
                 error description.
         """
-        if not IS_IOS:
-            return None
-        return await _ios_get_device_token()
-
-
-# ======================================================================
-# Android implementation
-# ======================================================================
-
-
-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():
-        pending.cancel()
-
-
-async def _android_schedule_later(title: str, body: str, delay_seconds: float, identifier: str) -> None:
-    """Post an Android notification after ``delay_seconds`` on the framework loop.
-
-    The delay lives in the app process (matching the semantics of
-    ``UNTimeIntervalNotificationTrigger`` closely enough for in-app
-    reminders); notifications whose delay outlives the process need
-    ``AlarmManager``, which is out of scope for the built-in module.
-    """
-    try:
-        await asyncio.sleep(delay_seconds)
-        await asyncio.to_thread(_android_schedule, title, body, identifier)
-    finally:
-        _android_delayed.pop(identifier, None)
-
-
-def _android_schedule(title: str, body: str, identifier: str) -> bool:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        nm = ctx.getSystemService(jclass("android.content.Context").NOTIFICATION_SERVICE)
-        channel_id = "pn_default"
-        NotificationChannel = jclass("android.app.NotificationChannel")
-        channel = NotificationChannel(channel_id, "PythonNative", 3)  # IMPORTANCE_DEFAULT
-        nm.createNotificationChannel(channel)
-
-        Builder = jclass("android.app.Notification$Builder")
-        builder = Builder(ctx, channel_id)
-        builder.setContentTitle(title)
-        builder.setContentText(body)
-        builder.setSmallIcon(jclass("android.R$drawable").ic_dialog_info)
-        nm.notify(abs(hash(identifier)) % (2**31), builder.build())
-        return True
-    except Exception:
-        return False
-
-
-def _android_cancel(identifier: str) -> None:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        nm = ctx.getSystemService(jclass("android.content.Context").NOTIFICATION_SERVICE)
-        nm.cancel(abs(hash(identifier)) % (2**31))
-    except Exception:
-        diagnostics.swallowed("notifications._android_cancel")
-
-
-# ======================================================================
-# iOS implementation
-# ======================================================================
-
-
-async def _ios_request_permission() -> bool:
-    loop = asyncio.get_running_loop()
-    future: asyncio.Future[bool] = loop.create_future()
-    try:
-        from rubicon.objc import Block, ObjCClass
-
-        center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
-
-        # Build a block that mirrors the UNNotificationCenter signature
-        # ``void(^)(BOOL granted, NSError* error)``.
-        def _completion(granted: bool, _error: Any) -> None:
-            resolve_future(future, bool(granted))
-
         try:
-            block = Block(_completion, None, bool, object)
-        except Exception:
-            # If Block ctor signature changed across rubicon versions,
-            # fall back to optimistic "granted" without polling.
-            resolve_future(future, True)
-            return await future
-
-        center.requestAuthorizationWithOptions_completionHandler_(0x07, block)
-    except Exception:
-        resolve_future(future, False)
-    return await future
-
-
-def _ios_schedule(title: str, body: str, delay_seconds: float, identifier: str) -> bool:
-    try:
-        from rubicon.objc import ObjCClass
-
-        content = ObjCClass("UNMutableNotificationContent").alloc().init()
-        content.setTitle_(title)
-        content.setBody_(body)
-
-        interval = float(delay_seconds) if delay_seconds > 0 else 1.0
-        trigger = ObjCClass("UNTimeIntervalNotificationTrigger").triggerWithTimeInterval_repeats_(interval, False)
-        request = ObjCClass("UNNotificationRequest").requestWithIdentifier_content_trigger_(
-            identifier, content, trigger
-        )
-        center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
-        center.addNotificationRequest_withCompletionHandler_(request, None)
-        return True
-    except Exception:
-        return False
-
-
-def _ios_cancel(identifier: str) -> None:
-    try:
-        from rubicon.objc import ObjCClass
-
-        center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
-        NSArray = ObjCClass("NSArray")
-        arr = NSArray.arrayWithObject_(identifier)
-        center.removePendingNotificationRequestsWithIdentifiers_(arr)
-    except Exception:
-        diagnostics.swallowed("notifications._ios_cancel")
-
-
-# ----------------------------------------------------------------------
-# Remote notifications (APNs)
-# ----------------------------------------------------------------------
-#
-# The registration result arrives through UIApplicationDelegate
-# callbacks in the native template, which forward here via
-# dispatch_device_token / dispatch_device_token_error. The token is
-# cached so later get_device_token() calls resolve immediately.
-
-_device_token: Optional[str] = None
-_device_token_error: Optional[str] = None
-_token_waiters: List["asyncio.Future[str]"] = []
-
-
-async def _ios_get_device_token() -> str:
-    if _device_token is not None:
-        return _device_token
-    if _device_token_error is not None:
-        raise RuntimeError(f"APNs registration failed: {_device_token_error}")
-
-    loop = asyncio.get_running_loop()
-    future: asyncio.Future[str] = loop.create_future()
-    _token_waiters.append(future)
-
-    def _register() -> None:
-        from rubicon.objc import ObjCClass
-
-        ObjCClass("UIApplication").sharedApplication.registerForRemoteNotifications()
-
-    try:
-        # registerForRemoteNotifications must run on the main thread.
-        from ..runtime import call_on_main_thread
-
-        call_on_main_thread(_register)
-    except Exception as exc:
-        _token_waiters.remove(future)
-        raise RuntimeError(f"Could not start APNs registration: {exc}") from exc
-    return await future
-
-
-def dispatch_device_token(token: str) -> None:
-    """Deliver the APNs device token from the native host."""
-    global _device_token, _device_token_error
-    _device_token = token
-    _device_token_error = None
-    waiters, _token_waiters[:] = list(_token_waiters), []
-    for future in waiters:
-        resolve_future(future, token)
-
-
-def dispatch_device_token_error(message: str) -> None:
-    """Deliver an APNs registration failure from the native host."""
-    global _device_token_error
-    _device_token_error = message
-    waiters, _token_waiters[:] = list(_token_waiters), []
-    error = RuntimeError(f"APNs registration failed: {message}")
-    for future in waiters:
-        reject_future(future, error)
+            token = await native_module("Notifications").call_async("get_device_token")
+        except NativeModuleError as exc:
+            raise RuntimeError(f"APNs registration failed: {exc.message}") from exc
+        return str(token) if token else None