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

pythonnative/native_modules/haptics.py

@@ -1,6 +1,6 @@
 """Haptic feedback and raw vibration.
 
-Two interfaces live here:
+Two interfaces live here, both backed by the native ``Haptics`` module:
 
 - [`Haptics`][pythonnative.Haptics]: semantic, iOS-style feedback
   (impact / notification / selection) backed by
@@ -17,20 +17,20 @@ than errors.
 
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 from .. import diagnostics
-from ..utils import IS_ANDROID, IS_IOS
+from .registry import native_module
 
 ImpactStyle = str  # "light" | "medium" | "heavy" | "soft" | "rigid"
 NotificationType = str  # "success" | "warning" | "error"
 
-_IOS_IMPACT_STYLE = {"light": 0, "medium": 1, "heavy": 2, "soft": 4, "rigid": 5}
-_IOS_NOTIFICATION_TYPE = {"success": 0, "warning": 1, "error": 2}
 
-# Approximate Android fallback durations (ms) per semantic feedback.
-_ANDROID_IMPACT_MS = {"light": 10, "medium": 20, "heavy": 40, "soft": 15, "rigid": 30}
-_ANDROID_NOTIFICATION_MS = {"success": 30, "warning": 50, "error": 70}
+def _call(method: str, **args: Any) -> None:
+    try:
+        native_module("Haptics").call(method, **args)
+    except Exception:
+        diagnostics.swallowed(f"haptics.{method}")
 
 
 class Haptics:
@@ -39,26 +39,17 @@ class Haptics:
     @staticmethod
     def impact(style: ImpactStyle = "medium") -> None:
         """Play a physical "impact" tap of the given ``style``."""
-        if IS_IOS:
-            _ios_impact(style)
-        elif IS_ANDROID:
-            _android_buzz(_ANDROID_IMPACT_MS.get(style, 20))
+        _call("impact", style=style)
 
     @staticmethod
     def notification(type_: NotificationType = "success") -> None:
         """Play a success / warning / error notification pattern."""
-        if IS_IOS:
-            _ios_notification(type_)
-        elif IS_ANDROID:
-            _android_buzz(_ANDROID_NOTIFICATION_MS.get(type_, 30))
+        _call("notification", type=type_)
 
     @staticmethod
     def selection() -> None:
         """Play the light "selection changed" tick."""
-        if IS_IOS:
-            _ios_selection()
-        elif IS_ANDROID:
-            _android_buzz(8)
+        _call("selection")
 
 
 class Vibration:
@@ -66,116 +57,15 @@ class Vibration:
 
     @staticmethod
     def vibrate(duration_ms: int = 400) -> None:
-        """Vibrate for ``duration_ms`` milliseconds."""
-        if IS_ANDROID:
-            _android_buzz(int(duration_ms))
-        elif IS_IOS:
-            # iOS has no arbitrary-duration API; approximate with a
-            # heavy impact for short buzzes and the legacy AudioServices
-            # vibration for longer ones.
-            if duration_ms >= 200:
-                _ios_legacy_vibrate()
-            else:
-                _ios_impact("heavy")
+        """Vibrate for ``duration_ms`` milliseconds.
+
+        iOS has no arbitrary-duration API; the native module
+        approximates short buzzes with a heavy impact and longer ones
+        with the legacy system vibration sound.
+        """
+        _call("vibrate", duration_ms=int(duration_ms))
 
     @staticmethod
     def cancel() -> None:
         """Cancel an in-progress vibration (Android only)."""
-        if IS_ANDROID:
-            vibrator = _android_vibrator()
-            if vibrator is not None:
-                try:
-                    vibrator.cancel()
-                except Exception:
-                    diagnostics.swallowed("haptics.Vibration.cancel")
-
-
-# ======================================================================
-# iOS
-# ======================================================================
-
-
-def _ios_impact(style: str) -> None:
-    try:
-        from rubicon.objc import ObjCClass
-
-        generator = ObjCClass("UIImpactFeedbackGenerator").alloc().initWithStyle_(_IOS_IMPACT_STYLE.get(style, 1))
-        generator.prepare()
-        generator.impactOccurred()
-    except Exception:
-        diagnostics.swallowed("haptics._ios_impact")
-
-
-def _ios_notification(type_: str) -> None:
-    try:
-        from rubicon.objc import ObjCClass
-
-        generator = ObjCClass("UINotificationFeedbackGenerator").alloc().init()
-        generator.prepare()
-        generator.notificationOccurred_(_IOS_NOTIFICATION_TYPE.get(type_, 0))
-    except Exception:
-        diagnostics.swallowed("haptics._ios_notification")
-
-
-def _ios_selection() -> None:
-    try:
-        from rubicon.objc import ObjCClass
-
-        generator = ObjCClass("UISelectionFeedbackGenerator").alloc().init()
-        generator.prepare()
-        generator.selectionChanged()
-    except Exception:
-        diagnostics.swallowed("haptics._ios_selection")
-
-
-def _ios_legacy_vibrate() -> None:
-    try:
-        from ctypes import CDLL, util
-
-        audio = CDLL(util.find_library("AudioToolbox"))
-        audio.AudioServicesPlaySystemSound(4095)  # kSystemSoundID_Vibrate
-    except Exception:
-        diagnostics.swallowed("haptics._ios_legacy_vibrate")
-
-
-# ======================================================================
-# Android
-# ======================================================================
-
-
-def _android_vibrator() -> Optional[Any]:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Build = jclass("android.os.Build")
-        if Build.VERSION.SDK_INT >= 31:
-            VibratorManager = jclass("android.os.VibratorManager")
-            Context = jclass("android.content.Context")
-            manager = ctx.getSystemService(Context.VIBRATOR_MANAGER_SERVICE)
-            VibratorManager  # referenced for clarity
-            return manager.getDefaultVibrator()
-        Context = jclass("android.content.Context")
-        return ctx.getSystemService(Context.VIBRATOR_SERVICE)
-    except Exception:
-        return None
-
-
-def _android_buzz(duration_ms: int) -> None:
-    vibrator = _android_vibrator()
-    if vibrator is None:
-        return
-    try:
-        from java import jclass
-
-        Build = jclass("android.os.Build")
-        if Build.VERSION.SDK_INT >= 26:
-            VibrationEffect = jclass("android.os.VibrationEffect")
-            effect = VibrationEffect.createOneShot(int(duration_ms), VibrationEffect.DEFAULT_AMPLITUDE)
-            vibrator.vibrate(effect)
-        else:
-            vibrator.vibrate(int(duration_ms))
-    except Exception:
-        diagnostics.swallowed("haptics._android_buzz")
+        _call("cancel")

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