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

pythonnative/native_modules/linking.py

@@ -1,19 +1,21 @@
 """Open URLs, deep links, and the system settings page.
 
 [`Linking`][pythonnative.Linking] wraps ``UIApplication.openURL`` /
-``Intent(ACTION_VIEW)`` so a Python app can hand a URL (``https:``,
-``mailto:``, ``tel:``, a custom scheme, …) to the OS.
+``Intent(ACTION_VIEW)`` (in the native ``Linking`` module) so a Python
+app can hand a URL (``https:``, ``mailto:``, ``tel:``, a custom
+scheme, ...) to the OS.
 
 Outbound methods are synchronous and return a ``bool`` describing
 whether the platform accepted the request. On desktop they return
 ``False``.
 
 Inbound deep links flow the other way: declare your schemes in
-``pythonnative.toml`` (``app.url_schemes``) and the native host calls
-[`dispatch_url`][pythonnative.native_modules.linking.dispatch_url] for
-every URL that opens the app. The URL that cold-started the app is kept
-and returned by ``get_initial_url``; later URLs reach subscribers added
-with ``add_listener``.
+``pythonnative.toml`` (``app.url_schemes``) and the native module
+pushes a ``url`` event for every URL that opens the app, which lands in
+[`dispatch_url`][pythonnative.native_modules.linking.dispatch_url]. The
+URL that cold-started the app is kept and returned by
+``get_initial_url``; later URLs reach subscribers added with
+``add_listener``.
 
 Example:
     ```python
@@ -30,43 +32,36 @@ from __future__ import annotations
 
 from typing import Any, Callable, List, Optional
 
-from ..utils import IS_ANDROID, IS_IOS
+from .registry import native_module, on_event
 
-# Populated by the native host when the app is launched from a deep
-# link; ``get_initial_url`` returns it.
 _initial_url: Optional[str] = None
 _url_listeners: List[Callable[[str], None]] = []
 
 
+def _call_bool(method: str, **args: Any) -> bool:
+    try:
+        return bool(native_module("Linking").call(method, **args))
+    except Exception:
+        return False
+
+
 class Linking:
     """System URL / deep-link interface (synchronous)."""
 
     @staticmethod
     def open_url(url: str) -> bool:
         """Hand ``url`` to the OS. Returns ``True`` if it was accepted."""
-        if IS_IOS:
-            return _ios_open(url)
-        if IS_ANDROID:
-            return _android_open(url)
-        return False
+        return _call_bool("open_url", url=url)
 
     @staticmethod
     def can_open_url(url: str) -> bool:
         """Return ``True`` when some installed app can handle ``url``."""
-        if IS_IOS:
-            return _ios_can_open(url)
-        if IS_ANDROID:
-            return _android_can_open(url)
-        return False
+        return _call_bool("can_open_url", url=url)
 
     @staticmethod
     def open_settings() -> bool:
         """Open this app's entry in the system Settings app."""
-        if IS_IOS:
-            return _ios_open_settings()
-        if IS_ANDROID:
-            return _android_open_settings()
-        return False
+        return _call_bool("open_settings")
 
     @staticmethod
     def get_initial_url() -> Optional[str]:
@@ -97,18 +92,17 @@ class Linking:
 
 
 def set_initial_url(url: Optional[str]) -> None:
-    """Record the launch URL (called by the native host on cold start)."""
+    """Record the launch URL (or clear it with ``None``)."""
     global _initial_url
     _initial_url = url
 
 
 def dispatch_url(url: str) -> None:
-    """Deliver an inbound deep link from the native host.
+    """Deliver an inbound deep link.
 
     The first URL ever dispatched is also recorded as the initial URL
     (a cold start from a deep link reaches Python only after the
-    interpreter boots, so the host can't call ``set_initial_url``
-    earlier than this).
+    interpreter boots, so native can't report it earlier than this).
 
     Args:
         url: The full URL string that opened the app.
@@ -125,111 +119,4 @@ def dispatch_url(url: str) -> None:
             diagnostics.warn(f"Linking listener raised while handling {url!r}: {exc!r}")
 
 
-# ======================================================================
-# iOS
-# ======================================================================
-
-
-def _ios_url(url: str) -> Optional[Any]:
-    try:
-        from rubicon.objc import ObjCClass
-
-        return ObjCClass("NSURL").URLWithString_(url)
-    except Exception:
-        return None
-
-
-def _ios_open(url: str) -> bool:
-    nsurl = _ios_url(url)
-    if nsurl is None:
-        return False
-    try:
-        from rubicon.objc import ObjCClass
-
-        app = ObjCClass("UIApplication").sharedApplication
-        if app.canOpenURL_(nsurl):
-            app.openURL_options_completionHandler_(nsurl, None, None)
-            return True
-        return False
-    except Exception:
-        return False
-
-
-def _ios_can_open(url: str) -> bool:
-    nsurl = _ios_url(url)
-    if nsurl is None:
-        return False
-    try:
-        from rubicon.objc import ObjCClass
-
-        return bool(ObjCClass("UIApplication").sharedApplication.canOpenURL_(nsurl))
-    except Exception:
-        return False
-
-
-def _ios_open_settings() -> bool:
-    try:
-        from rubicon.objc import ObjCClass
-
-        settings = ObjCClass("UIApplicationOpenSettingsURLString")
-        return _ios_open(str(settings))
-    except Exception:
-        try:
-            return _ios_open("app-settings:")
-        except Exception:
-            return False
-
-
-# ======================================================================
-# Android
-# ======================================================================
-
-
-def _android_open(url: str) -> bool:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        Intent = jclass("android.content.Intent")
-        Uri = jclass("android.net.Uri")
-        intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        get_android_context().startActivity(intent)
-        return True
-    except Exception:
-        return False
-
-
-def _android_can_open(url: str) -> bool:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        Intent = jclass("android.content.Intent")
-        Uri = jclass("android.net.Uri")
-        intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
-        pm = get_android_context().getPackageManager()
-        return intent.resolveActivity(pm) is not None
-    except Exception:
-        return False
-
-
-def _android_open_settings() -> bool:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        Intent = jclass("android.content.Intent")
-        Settings = jclass("android.provider.Settings")
-        Uri = jclass("android.net.Uri")
-        ctx = get_android_context()
-        intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
-        intent.setData(Uri.fromParts("package", ctx.getPackageName(), None))
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        ctx.startActivity(intent)
-        return True
-    except Exception:
-        return False
+on_event("Linking", "url", lambda payload: dispatch_url(str(payload)))

pythonnative/native_modules/location.py

@@ -3,6 +3,9 @@
 [`Location.get_current`][pythonnative.native_modules.location.Location.get_current]
 is a coroutine that resolves to a ``(latitude, longitude)`` tuple, or
 ``None`` if no recent fix is available or the user denies permission.
+The native ``Location`` module owns the ``CLLocationManager`` /
+``LocationManager`` session and resolves the call with
+``{"latitude", "longitude", "accuracy", "altitude", "timestamp"}``.
 
 Permission prompts are triggered the first time a location-using API
 is called; ensure the appropriate manifest entries
@@ -24,16 +27,9 @@ Example:
 
 from __future__ import annotations
 
-import asyncio
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Dict, Optional, Tuple
 
-from .. import diagnostics
-from ..runtime import resolve_future
-from ..utils import IS_ANDROID, IS_IOS
-
-# Retain pool keyed by ``id(delegate)`` so iOS / Android listeners
-# aren't garbage-collected before the platform calls back.
-_pending_delegates: Dict[int, Any] = {}
+from .registry import native_module
 
 Coords = Tuple[float, float]
 
@@ -46,184 +42,36 @@ class Location:
         """Request the device's current location.
 
         Args:
-            **options: Reserved for platform-specific tuning (e.g.,
-                ``accuracy``, ``timeout``).
+            **options: Forwarded to the native module (``accuracy``,
+                ``timeout``). Unknown keys are ignored.
 
         Returns:
             ``(latitude, longitude)`` if a fix was obtained, otherwise
             ``None``.
         """
-        del options
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[Optional[Coords]] = loop.create_future()
-
-        def _on_result(coords: Optional[Coords]) -> None:
-            resolve_future(future, coords)
-
-        if IS_ANDROID:
-            _android_get(_on_result)
-        elif IS_IOS:
-            _ios_get(_on_result)
-        else:
-            resolve_future(future, None)
-
-        return await future
-
-
-# ======================================================================
-# iOS implementation: CLLocationManagerDelegate
-# ======================================================================
-
-
-def _ios_get(on_result: Callable[[Optional[Coords]], None]) -> None:
-    try:
-        from rubicon.objc import ObjCClass, objc_method
-
-        CLLocationManager = ObjCClass("CLLocationManager")
-        NSObject = ObjCClass("NSObject")
+        fix = await Location.get_current_fix(**options)
+        if fix is None:
+            return None
+        return (fix["latitude"], fix["longitude"])
 
-        class _PNLocationDelegate(NSObject):  # type: ignore[misc,valid-type]
-            _callback: Optional[Callable[[Optional[Coords]], None]] = None
-            _manager: Any = None
-            _delivered: bool = False
-
-            def _finish(self, coords: Optional[Coords]) -> None:
-                if self._delivered:
-                    return
-                self._delivered = True
-                try:
-                    if self._manager is not None:
-                        self._manager.stopUpdatingLocation()
-                except Exception:
-                    diagnostics.swallowed("location._ios_get._PNLocationDelegate._finish")
-                cb = self._callback
-                self._callback = None
-                _pending_delegates.pop(id(self), None)
-                if cb is not None:
-                    try:
-                        cb(coords)
-                    except Exception:
-                        diagnostics.swallowed("location._ios_get._PNLocationDelegate._finish")
-
-            @objc_method
-            def locationManager_didUpdateLocations_(self, manager: Any, locations: Any) -> None:
-                del manager
-                try:
-                    last = locations.lastObject
-                    if last is None:
-                        return
-                    coord = last.coordinate
-                    self._finish((float(coord.latitude), float(coord.longitude)))
-                except Exception:
-                    self._finish(None)
-
-            @objc_method
-            def locationManager_didFailWithError_(self, manager: Any, error: Any) -> None:
-                del manager, error
-                self._finish(None)
-
-            @objc_method
-            def locationManagerDidChangeAuthorization_(self, manager: Any) -> None:
-                try:
-                    status = int(manager.authorizationStatus)
-                except Exception:
-                    status = 0
-                if status in (3, 4):  # AuthorizedAlways, AuthorizedWhenInUse
-                    try:
-                        manager.startUpdatingLocation()
-                    except Exception:
-                        diagnostics.swallowed(
-                            "location._ios_get._PNLocationDelegate.locationManagerDidChangeAuthorization_"
-                        )
-
-        delegate = _PNLocationDelegate.new()
-        delegate._callback = on_result
-        _pending_delegates[id(delegate)] = delegate
-
-        manager = CLLocationManager.alloc().init()
-        manager.setDelegate_(delegate)
-        delegate._manager = manager
-        try:
-            manager.requestWhenInUseAuthorization()
-        except Exception:
-            diagnostics.swallowed("location._ios_get")
-        try:
-            manager.startUpdatingLocation()
-        except Exception:
-            diagnostics.swallowed("location._ios_get")
-    except Exception:
-        on_result(None)
-
-
-# ======================================================================
-# Android implementation: LocationListener
-# ======================================================================
-
-
-def _android_get(on_result: Callable[[Optional[Coords]], None]) -> None:
-    try:
-        from java import dynamic_proxy, jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Context = jclass("android.content.Context")
-        lm = ctx.getSystemService(Context.LOCATION_SERVICE)
+    @staticmethod
+    async def get_current_fix(**options: Any) -> Optional[Dict[str, float]]:
+        """Like ``get_current`` but returns the full fix dict.
 
-        # Try the most recent known fix first; it's instant and avoids
-        # the GPS warm-up delay.
+        Keys: ``latitude``, ``longitude``, and when the platform reports
+        them ``accuracy`` (meters), ``altitude`` (meters), ``speed``
+        (m/s), ``heading`` (degrees), ``timestamp`` (Unix seconds).
+        """
         try:
-            for provider in ("gps", "network", "passive"):
-                loc = lm.getLastKnownLocation(provider)
-                if loc is not None:
-                    on_result((float(loc.getLatitude()), float(loc.getLongitude())))
-                    return
+            result = await native_module("Location").call_async("get_current", **options)
         except Exception:
-            diagnostics.swallowed("location._android_get")
-
-        LocationListener = jclass("android.location.LocationListener")
-        delivered = [False]
-
-        def _finish(coords: Optional[Coords], listener: Any) -> None:
-            if delivered[0]:
-                return
-            delivered[0] = True
-            try:
-                lm.removeUpdates(listener)
-            except Exception:
-                diagnostics.swallowed("location._android_get._finish")
-            _pending_delegates.pop(id(listener), None)
-            try:
-                on_result(coords)
-            except Exception:
-                diagnostics.swallowed("location._android_get._finish")
-
-        class _PNLocationListener(dynamic_proxy(LocationListener)):  # type: ignore[misc]
-            def onLocationChanged(self, loc: Any) -> None:
-                try:
-                    coords = (float(loc.getLatitude()), float(loc.getLongitude()))
-                except Exception:
-                    coords = None
-                _finish(coords, self)
-
-            def onStatusChanged(self, provider: Any, status: int, extras: Any) -> None:
-                del provider, status, extras
-
-            def onProviderEnabled(self, provider: Any) -> None:
-                del provider
-
-            def onProviderDisabled(self, provider: Any) -> None:
-                del provider
-                _finish(None, self)
-
-        listener = _PNLocationListener()
-        _pending_delegates[id(listener)] = listener
+            return None
+        if not isinstance(result, dict):
+            return None
         try:
-            lm.requestSingleUpdate("gps", listener, None)
-        except Exception:
-            try:
-                lm.requestLocationUpdates("network", 1000, 0.0, listener)
-            except Exception:
-                _finish(None, listener)
-    except Exception:
-        on_result(None)
+            fix: Dict[str, float] = {k: float(v) for k, v in result.items() if v is not None}
+            fix["latitude"]
+            fix["longitude"]
+        except (KeyError, TypeError, ValueError):
+            return None
+        return fix

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)