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

pythonnative/native_modules/battery.py

@@ -2,16 +2,18 @@
 
 [`Battery`][pythonnative.Battery] reports the current charge fraction
 (``0.0``–``1.0``, or ``-1.0`` when unknown) and charging state, and
-lets you subscribe to changes that the native host forwards via
+lets you subscribe to changes. The native ``Battery`` module pushes a
+``change`` event with ``{"level", "state"}``; off device, tests drive
+the same path through
 [`dispatch_battery`][pythonnative.native_modules.battery.dispatch_battery].
 """
 
 from __future__ import annotations
 
-from typing import Callable, Dict, List
+from typing import Any, Callable, Dict, List
 
 from .. import diagnostics
-from ..utils import IS_ANDROID, IS_IOS
+from .registry import native_module, on_event
 
 BatteryState = str  # "unknown" | "unplugged" | "charging" | "full"
 
@@ -24,20 +26,20 @@ class Battery:
     @staticmethod
     def get_level() -> float:
         """Return the charge fraction in ``[0, 1]`` (``-1.0`` if unknown)."""
-        if IS_IOS:
-            return _ios_level()
-        if IS_ANDROID:
-            return _android_level()
-        return -1.0
+        try:
+            level = float(native_module("Battery").call("get_level"))
+        except Exception:
+            return -1.0
+        return level if 0.0 <= level <= 1.0 else -1.0
 
     @staticmethod
     def get_state() -> BatteryState:
         """Return ``"charging"`` / ``"full"`` / ``"unplugged"`` / ``"unknown"``."""
-        if IS_IOS:
-            return _ios_state()
-        if IS_ANDROID:
-            return _android_state()
-        return "unknown"
+        try:
+            state = str(native_module("Battery").call("get_state") or "unknown")
+        except Exception:
+            return "unknown"
+        return state if state in ("unknown", "unplugged", "charging", "full") else "unknown"
 
     @staticmethod
     def add_listener(callback: Callable[[Dict[str, object]], None]) -> Callable[[], None]:
@@ -57,7 +59,7 @@ class Battery:
 
 
 def dispatch_battery(level: float, state: BatteryState) -> None:
-    """Notify listeners of a battery change (called by the native host)."""
+    """Notify listeners of a battery change."""
     payload: Dict[str, object] = {"level": level, "state": state}
     for listener in list(_listeners):
         try:
@@ -66,75 +68,9 @@ def dispatch_battery(level: float, state: BatteryState) -> None:
             diagnostics.swallowed("battery.dispatch_battery")
 
 
-# ======================================================================
-# iOS: UIDevice
-# ======================================================================
-
-
-def _ios_device() -> object:
-    from rubicon.objc import ObjCClass
-
-    device = ObjCClass("UIDevice").currentDevice
-    try:
-        device.setBatteryMonitoringEnabled_(True)
-    except Exception:
-        diagnostics.swallowed("battery._ios_device")
-    return device
-
-
-def _ios_level() -> float:
-    try:
-        level = float(_ios_device().batteryLevel)
-        return level if level >= 0 else -1.0
-    except Exception:
-        return -1.0
-
-
-def _ios_state() -> BatteryState:
-    try:
-        # UIDeviceBatteryState: 0 unknown, 1 unplugged, 2 charging, 3 full
-        return {0: "unknown", 1: "unplugged", 2: "charging", 3: "full"}.get(int(_ios_device().batteryState), "unknown")
-    except Exception:
-        return "unknown"
-
-
-# ======================================================================
-# Android: BatteryManager
-# ======================================================================
-
-
-def _android_level() -> float:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Context = jclass("android.content.Context")
-        bm = ctx.getSystemService(Context.BATTERY_SERVICE)
-        BatteryManager = jclass("android.os.BatteryManager")
-        pct = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
-        return (pct / 100.0) if pct is not None and pct >= 0 else -1.0
-    except Exception:
-        return -1.0
-
-
-def _android_state() -> BatteryState:
-    try:
-        from java import jclass
+def _on_native_change(payload: Any) -> None:
+    if isinstance(payload, dict):
+        dispatch_battery(float(payload.get("level", -1.0)), str(payload.get("state", "unknown")))
 
-        from ..utils import get_android_context
 
-        ctx = get_android_context()
-        Context = jclass("android.content.Context")
-        bm = ctx.getSystemService(Context.BATTERY_SERVICE)
-        BatteryManager = jclass("android.os.BatteryManager")
-        status = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_STATUS)
-        return {
-            BatteryManager.BATTERY_STATUS_CHARGING: "charging",
-            BatteryManager.BATTERY_STATUS_FULL: "full",
-            BatteryManager.BATTERY_STATUS_DISCHARGING: "unplugged",
-            BatteryManager.BATTERY_STATUS_NOT_CHARGING: "unplugged",
-        }.get(status, "unknown")
-    except Exception:
-        return "unknown"
+on_event("Battery", "change", _on_native_change)

pythonnative/native_modules/biometrics.py

@@ -2,7 +2,8 @@
 
 [`Biometrics`][pythonnative.Biometrics] gates an action behind the
 device's biometric hardware via ``LAContext`` (iOS) and
-``BiometricPrompt`` (Android).
+``BiometricPrompt`` (Android), both implemented in the native
+``Biometrics`` module.
 
 ``is_available`` is synchronous; ``authenticate`` is a coroutine that
 presents the system prompt and resolves to ``True`` on success or
@@ -20,14 +21,7 @@ Example:
 
 from __future__ import annotations
 
-import asyncio
-from typing import Any, Callable, Dict
-
-from .. import diagnostics
-from ..runtime import resolve_future
-from ..utils import IS_ANDROID, IS_IOS
-
-_pending: Dict[int, Any] = {}
+from .registry import native_module
 
 
 class Biometrics:
@@ -36,122 +30,15 @@ class Biometrics:
     @staticmethod
     def is_available() -> bool:
         """Return ``True`` when biometric auth can be attempted."""
-        if IS_IOS:
-            return _ios_available()
-        if IS_ANDROID:
-            return _android_available()
-        return False
+        try:
+            return bool(native_module("Biometrics").call("is_available"))
+        except Exception:
+            return False
 
     @staticmethod
     async def authenticate(reason: str = "Authenticate") -> bool:
         """Present the biometric prompt; resolve ``True`` on success."""
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[bool] = loop.create_future()
-
-        def _done(ok: bool) -> None:
-            resolve_future(future, ok)
-
-        if IS_IOS:
-            _ios_authenticate(reason, _done)
-        elif IS_ANDROID:
-            _android_authenticate(reason, _done)
-        else:
-            _done(False)
-
-        return await future
-
-
-# ======================================================================
-# iOS: LAContext
-# ======================================================================
-
-
-def _ios_context() -> Any:
-    from rubicon.objc import ObjCClass
-
-    return ObjCClass("LAContext").alloc().init()
-
-
-def _ios_available() -> bool:
-    try:
-        # LAPolicyDeviceOwnerAuthenticationWithBiometrics == 1
-        return bool(_ios_context().canEvaluatePolicy_error_(1, None))
-    except Exception:
-        return False
-
-
-def _ios_authenticate(reason: str, on_done: Callable[[bool], None]) -> None:
-    try:
-        from rubicon.objc import Block, ObjCClass
-
-        context = _ios_context()
-        token = id(context)
-        _pending[token] = context
-
-        def _reply(success: bool, error: Any) -> None:
-            del error
-            _pending.pop(token, None)
-            try:
-                on_done(bool(success))
-            except Exception:
-                diagnostics.swallowed("biometrics._ios_authenticate._reply")
-
-        context.evaluatePolicy_localizedReason_reply_(1, reason, Block(_reply, None, bool, ObjCClass("NSError")))
-    except Exception:
-        on_done(False)
-
-
-# ======================================================================
-# Android: BiometricPrompt
-# ======================================================================
-
-
-def _android_available() -> bool:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        BiometricManager = jclass("androidx.biometric.BiometricManager")
-        manager = BiometricManager.from_(get_android_context())
-        Authenticators = jclass("androidx.biometric.BiometricManager$Authenticators")
-        result = manager.canAuthenticate(Authenticators.BIOMETRIC_WEAK)
-        return result == BiometricManager.BIOMETRIC_SUCCESS
-    except Exception:
-        return False
-
-
-def _android_authenticate(reason: str, on_done: Callable[[bool], None]) -> None:
-    try:
-        from java import dynamic_proxy, jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        FragmentActivity = jclass("androidx.fragment.app.FragmentActivity")
-        if not FragmentActivity.isInstance(ctx):
-            on_done(False)
-            return
-
-        BiometricPrompt = jclass("androidx.biometric.BiometricPrompt")
-        ContextCompat = jclass("androidx.core.content.ContextCompat")
-        executor = ContextCompat.getMainExecutor(ctx)
-
-        class _Callback(dynamic_proxy(BiometricPrompt.AuthenticationCallback)):  # type: ignore[misc]
-            def onAuthenticationSucceeded(self, result: Any) -> None:  # noqa: N802, ARG002
-                on_done(True)
-
-            def onAuthenticationError(self, code: int, message: Any) -> None:  # noqa: N802, ARG002
-                on_done(False)
-
-            def onAuthenticationFailed(self) -> None:  # noqa: N802
-                # Fired on a non-matching attempt; the prompt stays up,
-                # so don't resolve yet.
-                pass
-
-        prompt = BiometricPrompt(ctx, executor, _Callback())
-        Builder = jclass("androidx.biometric.BiometricPrompt$PromptInfo$Builder")
-        info = Builder().setTitle(reason).setNegativeButtonText("Cancel").build()
-        prompt.authenticate(info)
-    except Exception:
-        on_done(False)
+        try:
+            return bool(await native_module("Biometrics").call_async("authenticate", reason=reason))
+        except Exception:
+            return False

pythonnative/native_modules/camera.py

@@ -1,12 +1,11 @@
 """Cross-platform camera and gallery access.
 
 Both entry points are coroutines: ``await Camera.take_photo()`` returns
-the saved image path (a ``str``) or ``None`` if the user cancels.
-Internally each call instantiates a fresh native delegate / activity
-request and bridges its completion onto the PythonNative asyncio
-runtime, so callers don't have to know whether the picker is backed by
-``UIImagePickerController`` (iOS) or
-``Intent(MediaStore.ACTION_IMAGE_CAPTURE)`` (Android).
+the saved image path (a ``str``) or ``None`` if the user cancels. The
+native ``Camera`` module presents ``UIImagePickerController`` (iOS) or
+launches ``MediaStore.ACTION_IMAGE_CAPTURE`` / ``ACTION_PICK``
+(Android) and resolves the call when the picker finishes; Python only
+awaits the promise.
 
 Example:
     ```python
@@ -22,316 +21,41 @@ Example:
 
 from __future__ import annotations
 
-import asyncio
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Optional
 
-from .. import diagnostics
-from ..runtime import resolve_future
-from ..utils import IS_ANDROID, IS_IOS
-
-# Retain pool keyed by ``id(delegate)`` so iOS UIImagePickerController
-# delegates aren't garbage-collected before the picker calls back.
-_pending_delegates: Dict[int, Any] = {}
+from .registry import native_module
 
 
 class Camera:
-    """Camera and image-picker interface.
-
-    All methods are static coroutines. They dispatch to the iOS or
-    Android implementation at call time based on the runtime
-    platform.
-    """
+    """Camera and image-picker interface (static coroutines)."""
 
     @staticmethod
     async def take_photo(**options: Any) -> Optional[str]:
         """Launch the device camera to capture a photo.
 
         Args:
-            **options: Reserved for platform-specific tuning. Currently
-                unused; future kwargs (e.g., ``quality``,
-                ``flash_mode``) will land here.
+            **options: Forwarded to the native module (``quality``,
+                ``allow_editing``, ...). Unknown keys are ignored.
 
         Returns:
             The saved image path, or ``None`` if the user cancelled or
             no camera is available.
         """
-        return await _launch("camera", **options)
+        return await _launch("take_photo", options)
 
     @staticmethod
     async def pick_from_gallery(**options: Any) -> Optional[str]:
         """Open the system gallery picker.
 
-        Args:
-            **options: Reserved for platform-specific tuning.
-
         Returns:
             The selected image path, or ``None`` if the user cancelled.
         """
-        return await _launch("gallery", **options)
-
-
-async def _launch(source: str, **options: Any) -> Optional[str]:
-    del options
-    loop = asyncio.get_running_loop()
-    future: asyncio.Future[Optional[str]] = loop.create_future()
-
-    def _on_result(path: Optional[str]) -> None:
-        resolve_future(future, path)
-
-    if IS_ANDROID:
-        _android_launch_picker(_on_result, source=source)
-    elif IS_IOS:
-        _ios_launch_picker(_on_result, source=source)
-    else:
-        resolve_future(future, None)
-
-    return await future
-
-
-# ======================================================================
-# iOS implementation: UIImagePickerControllerDelegate
-# ======================================================================
-
-
-def _ios_launch_picker(on_result: Callable[[Optional[str]], None], source: str) -> None:
-    try:
-        from rubicon.objc import SEL, ObjCClass, objc_method
-
-        UIImagePickerController = ObjCClass("UIImagePickerController")
-        NSObject = ObjCClass("NSObject")
-
-        class _PNImagePickerDelegate(NSObject):  # type: ignore[misc,valid-type]
-            _callback: Optional[Callable[[Optional[str]], None]] = None
-            _picker: Any = None
-
-            @objc_method
-            def imagePickerController_didFinishPickingMediaWithInfo_(self, picker: Any, info: Any) -> None:
-                path = _ios_extract_path(info)
-                try:
-                    picker.dismissViewControllerAnimated_completion_(True, None)
-                except Exception:
-                    diagnostics.swallowed(
-                        "camera._ios_launch_picker._PNImagePickerDelegate.imagePickerController_didFinishPickingMediaWithInfo_"
-                    )
-                cb = self._callback
-                self._callback = None
-                _pending_delegates.pop(id(self), None)
-                if cb is not None:
-                    try:
-                        cb(path)
-                    except Exception:
-                        diagnostics.swallowed(
-                            "camera._ios_launch_picker._PNImagePickerDelegate.imagePickerController_didFinishPickingMediaWithInfo_"
-                        )
-
-            @objc_method
-            def imagePickerControllerDidCancel_(self, picker: Any) -> None:
-                try:
-                    picker.dismissViewControllerAnimated_completion_(True, None)
-                except Exception:
-                    diagnostics.swallowed(
-                        "camera._ios_launch_picker._PNImagePickerDelegate.imagePickerControllerDidCancel_"
-                    )
-                cb = self._callback
-                self._callback = None
-                _pending_delegates.pop(id(self), None)
-                if cb is not None:
-                    try:
-                        cb(None)
-                    except Exception:
-                        diagnostics.swallowed(
-                            "camera._ios_launch_picker._PNImagePickerDelegate.imagePickerControllerDidCancel_"
-                        )
-
-        delegate = _PNImagePickerDelegate.new()
-        delegate._callback = on_result
-        _pending_delegates[id(delegate)] = delegate
-
-        picker = UIImagePickerController.alloc().init()
-        picker.setSourceType_(1 if source == "camera" else 0)
-        picker.setDelegate_(delegate)
-
-        UIApplication = ObjCClass("UIApplication")
-        top = UIApplication.sharedApplication.keyWindow.rootViewController
-        while top is not None and top.presentedViewController is not None:
-            top = top.presentedViewController
-        if top is not None:
-            top.presentViewController_animated_completion_(picker, True, None)
-        else:
-            _pending_delegates.pop(id(delegate), None)
-            on_result(None)
-
-        # Reference SEL/objc_method so the lint pass keeps the import;
-        # they're needed for the delegate class above.
-        _ = (SEL, objc_method)
-    except Exception:
-        on_result(None)
-
-
-def _ios_extract_path(info: Any) -> Optional[str]:
-    """Best-effort extraction of an image path from picker ``info``."""
-    try:
-        url = info.objectForKey_("UIImagePickerControllerImageURL")
-        if url is not None:
-            try:
-                return str(url.absoluteString)
-            except Exception:
-                try:
-                    return str(url.path)
-                except Exception:
-                    diagnostics.swallowed("camera._ios_extract_path")
-        image = info.objectForKey_("UIImagePickerControllerOriginalImage")
-        if image is not None:
-            return _ios_write_image_to_tmp(image)
-    except Exception:
-        return None
-    return None
-
-
-def _ios_write_image_to_tmp(image: Any) -> Optional[str]:
-    """Encode a UIImage to JPEG and write it to NSCachesDirectory."""
-    try:
-        from rubicon.objc import ObjCClass
-
-        try:
-            data = image.jpegDataWithCompressionQuality_(0.85)
-        except Exception:
-            return None
-        if data is None:
-            return None
-        NSString = ObjCClass("NSString")
-        NSFileManager = ObjCClass("NSFileManager")
-        manager = NSFileManager.defaultManager
-        urls = manager.URLsForDirectory_inDomains_(13, 1)  # NSCachesDirectory, NSUserDomainMask
-        if urls is None or urls.count == 0:
-            return None
-        cache_dir = urls.firstObject
-        import time as _time
-
-        filename = NSString.stringWithFormat_("pn-camera-%d.jpg", int(_time.time() * 1000))
-        target = cache_dir.URLByAppendingPathComponent_(filename)
-        if not data.writeToURL_atomically_(target, True):
-            return None
-        try:
-            return str(target.path)
-        except Exception:
-            return str(target.absoluteString)
-    except Exception:
-        return None
-
-
-# ======================================================================
-# Android implementation: ActivityResultLauncher / startActivityForResult
-# ======================================================================
-
-
-_android_pending_results: Dict[int, Callable[[Optional[str]], None]] = {}
-_android_next_request_code: int = 50001
-
-
-def _android_next_code() -> int:
-    global _android_next_request_code
-    code = _android_next_request_code
-    _android_next_request_code += 1
-    return code
-
-
-def _android_launch_picker(on_result: Callable[[Optional[str]], None], source: str) -> None:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
+        return await _launch("pick_from_gallery", options)
 
-        Intent = jclass("android.content.Intent")
-        MediaStore = jclass("android.provider.MediaStore")
-        ctx = get_android_context()
 
-        if source == "camera":
-            intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
-        else:
-            intent = Intent(Intent.ACTION_PICK)
-            intent.setType("image/*")
-
-        # ``startActivityForResult`` requires the host to be an
-        # Activity; in unit tests we may only have an Application
-        # context, in which case we fall back to ``startActivity`` and
-        # report ``None`` (the caller has no Activity to dispatch the
-        # result back through).
-        Activity = jclass("android.app.Activity")
-        if not Activity.isInstance(ctx):
-            ctx.startActivity(intent)
-            on_result(None)
-            return
-
-        request_code = _android_next_code()
-        _android_pending_results[request_code] = on_result
-        try:
-            ctx.startActivityForResult(intent, request_code)
-        except Exception:
-            _android_pending_results.pop(request_code, None)
-            on_result(None)
-    except Exception:
-        on_result(None)
-
-
-def deliver_android_activity_result(request_code: int, result_code: int, data: Any) -> bool:
-    """Forward an Activity result to the registered camera coroutine.
-
-    The host Activity should call this from ``onActivityResult`` so
-    the pending
-    [`take_photo`][pythonnative.native_modules.camera.Camera.take_photo]
-    /
-    [`pick_from_gallery`][pythonnative.native_modules.camera.Camera.pick_from_gallery]
-    awaitable receives a path. Returns ``True`` if a Python callback
-    was invoked (so the host can short-circuit further handlers).
-    """
-    cb = _android_pending_results.pop(request_code, None)
-    if cb is None:
-        return False
-    path: Optional[str] = None
-    try:
-        if result_code == -1 and data is not None:  # RESULT_OK
-            uri = data.getData()
-            if uri is not None:
-                path = str(uri)
-            else:
-                try:
-                    extras = data.getExtras()
-                    if extras is not None:
-                        thumb = extras.get("data")
-                        if thumb is not None:
-                            path = _android_write_bitmap_to_cache(thumb)
-                except Exception:
-                    diagnostics.swallowed("camera.deliver_android_activity_result")
-    except Exception:
-        path = None
+async def _launch(method: str, options: Any) -> Optional[str]:
     try:
-        cb(path)
-    except Exception:
-        diagnostics.swallowed("camera.deliver_android_activity_result")
-    return True
-
-
-def _android_write_bitmap_to_cache(bitmap: Any) -> Optional[str]:
-    """Persist a Bitmap to the app cache directory and return its path."""
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        cache_dir = ctx.getCacheDir()
-        File = jclass("java.io.File")
-        FileOutputStream = jclass("java.io.FileOutputStream")
-        Bitmap = jclass("android.graphics.Bitmap")
-        import time as _time
-
-        target = File(cache_dir, f"pn-camera-{int(_time.time() * 1000)}.jpg")
-        out = FileOutputStream(target)
-        try:
-            bitmap.compress(Bitmap.CompressFormat.JPEG, 85, out)
-        finally:
-            out.close()
-        return str(target.getAbsolutePath())
+        result = await native_module("Camera").call_async(method, **options)
     except Exception:
         return None
+    return str(result) if result else None