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

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

pythonnative/native_modules/permissions.py

@@ -1,7 +1,8 @@
 """Runtime permission checks and requests.
 
 [`Permissions`][pythonnative.Permissions] normalizes the very different
-iOS and Android permission models behind two calls:
+iOS and Android permission models behind two calls, both served by the
+native ``Permissions`` module:
 
 - ``check(permission)``: synchronous, returns a status string without
   prompting.
@@ -18,12 +19,7 @@ Unknown names resolve to ``"undetermined"``.
 
 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
+from .registry import native_module
 
 PermissionStatus = str
 PermissionName = str
@@ -33,15 +29,15 @@ DENIED = "denied"
 BLOCKED = "blocked"
 UNDETERMINED = "undetermined"
 
-# PythonNative permission name -> Android manifest permission string.
-_ANDROID_PERMS: Dict[str, str] = {
-    "camera": "android.permission.CAMERA",
-    "microphone": "android.permission.RECORD_AUDIO",
-    "location": "android.permission.ACCESS_FINE_LOCATION",
-    "contacts": "android.permission.READ_CONTACTS",
-    "notifications": "android.permission.POST_NOTIFICATIONS",
-    "photos": "android.permission.READ_MEDIA_IMAGES",
-}
+_STATUSES = (GRANTED, DENIED, BLOCKED, UNDETERMINED)
+
+PERMISSION_NAMES = ("camera", "microphone", "location", "photos", "notifications", "contacts")
+"""Permission names understood by every platform."""
+
+
+def _coerce(value: object) -> PermissionStatus:
+    status = str(value) if value is not None else UNDETERMINED
+    return status if status in _STATUSES else UNDETERMINED
 
 
 class Permissions:
@@ -50,175 +46,15 @@ class Permissions:
     @staticmethod
     def check(permission: PermissionName) -> PermissionStatus:
         """Return the current status of ``permission`` without prompting."""
-        if IS_ANDROID:
-            return _android_check(permission)
-        if IS_IOS:
-            return _ios_check(permission)
-        return UNDETERMINED
+        try:
+            return _coerce(native_module("Permissions").call("check", permission=permission))
+        except Exception:
+            return UNDETERMINED
 
     @staticmethod
     async def request(permission: PermissionName) -> PermissionStatus:
         """Prompt for ``permission`` (if needed) and return the result."""
-        loop = asyncio.get_running_loop()
-        future: asyncio.Future[PermissionStatus] = loop.create_future()
-
-        def _done(status: PermissionStatus) -> None:
-            resolve_future(future, status)
-
-        if IS_ANDROID:
-            _android_request(permission, _done)
-        elif IS_IOS:
-            _ios_request(permission, _done)
-        else:
-            _done(UNDETERMINED)
-
-        return await future
-
-
-# ======================================================================
-# Android
-# ======================================================================
-
-_android_pending: Dict[int, Callable[[PermissionStatus], None]] = {}
-_android_next_code = 60001
-
-
-def _android_check(permission: str) -> PermissionStatus:
-    manifest = _ANDROID_PERMS.get(permission)
-    if manifest is None:
-        return UNDETERMINED
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        PackageManager = jclass("android.content.pm.PackageManager")
-        ctx = get_android_context()
-        granted = ctx.checkSelfPermission(manifest) == PackageManager.PERMISSION_GRANTED
-        return GRANTED if granted else DENIED
-    except Exception:
-        return UNDETERMINED
-
-
-def _android_request(permission: str, on_done: Callable[[PermissionStatus], None]) -> None:
-    manifest = _ANDROID_PERMS.get(permission)
-    if manifest is None:
-        on_done(UNDETERMINED)
-        return
-    if _android_check(permission) == GRANTED:
-        on_done(GRANTED)
-        return
-    try:
-        global _android_next_code
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Activity = jclass("android.app.Activity")
-        if not Activity.isInstance(ctx):
-            on_done(_android_check(permission))
-            return
-        code = _android_next_code
-        _android_next_code += 1
-        _android_pending[code] = on_done
-        ctx.requestPermissions([manifest], code)
-    except Exception:
-        on_done(_android_check(permission))
-
-
-def deliver_android_permission_result(request_code: int, permissions: Any, grant_results: Any) -> bool:
-    """Forward an ``onRequestPermissionsResult`` to the pending coroutine."""
-    cb = _android_pending.pop(request_code, None)
-    if cb is None:
-        return False
-    status = DENIED
-    try:
-        del permissions
-        if grant_results is not None and len(grant_results) > 0 and grant_results[0] == 0:
-            status = GRANTED
-    except Exception:
-        status = DENIED
-    try:
-        cb(status)
-    except Exception:
-        diagnostics.swallowed("permissions.deliver_android_permission_result")
-    return True
-
-
-# ======================================================================
-# iOS
-# ======================================================================
-
-
-def _ios_media_status(media_type: str) -> PermissionStatus:
-    from rubicon.objc import ObjCClass
-
-    AVCaptureDevice = ObjCClass("AVCaptureDevice")
-    status = AVCaptureDevice.authorizationStatusForMediaType_(media_type)
-    # 0 notDetermined, 1 restricted, 2 denied, 3 authorized
-    return {0: UNDETERMINED, 1: BLOCKED, 2: DENIED, 3: GRANTED}.get(int(status), UNDETERMINED)
-
-
-def _ios_check(permission: str) -> PermissionStatus:
-    try:
-        if permission == "camera":
-            return _ios_media_status("vide")
-        if permission == "microphone":
-            return _ios_media_status("soun")
-        if permission == "photos":
-            from rubicon.objc import ObjCClass
-
-            status = ObjCClass("PHPhotoLibrary").authorizationStatus()
-            return {0: UNDETERMINED, 1: BLOCKED, 2: DENIED, 3: GRANTED, 4: GRANTED}.get(int(status), UNDETERMINED)
-        if permission == "location":
-            from rubicon.objc import ObjCClass
-
-            status = ObjCClass("CLLocationManager").authorizationStatus()
-            return {0: UNDETERMINED, 1: BLOCKED, 2: DENIED, 3: GRANTED, 4: GRANTED}.get(int(status), UNDETERMINED)
-    except Exception:
-        return UNDETERMINED
-    return UNDETERMINED
-
-
-def _ios_request(permission: str, on_done: Callable[[PermissionStatus], None]) -> None:
-    try:
-        from rubicon.objc import Block, ObjCClass
-
-        if permission in ("camera", "microphone"):
-            media = "vide" if permission == "camera" else "soun"
-            AVCaptureDevice = ObjCClass("AVCaptureDevice")
-
-            def _granted(ok: bool) -> None:
-                on_done(GRANTED if ok else DENIED)
-
-            AVCaptureDevice.requestAccessForMediaType_completionHandler_(media, Block(_granted, None, bool))
-            return
-
-        if permission == "photos":
-            PHPhotoLibrary = ObjCClass("PHPhotoLibrary")
-
-            def _photos_done(status: int) -> None:
-                # 0 notDetermined, 1 restricted, 2 denied, 3 authorized,
-                # 4 limited (counts as granted).
-                on_done({0: UNDETERMINED, 1: BLOCKED, 2: DENIED, 3: GRANTED, 4: GRANTED}.get(int(status), UNDETERMINED))
-
-            PHPhotoLibrary.requestAuthorization_(Block(_photos_done, None, int))
-            return
-
-        if permission == "notifications":
-            center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
-
-            def _notif_done(granted: bool, _error: Any) -> None:
-                on_done(GRANTED if granted else DENIED)
-
-            # 0x07 = badge | sound | alert.
-            center.requestAuthorizationWithOptions_completionHandler_(0x07, Block(_notif_done, None, bool, object))
-            return
-    except Exception:
-        diagnostics.swallowed("permissions._ios_request")
-    # Fall back to reporting the current status for permissions whose
-    # request flow isn't wired up natively (location needs a
-    # CLLocationManager delegate; use the Location module's own
-    # request path for that).
-    on_done(_ios_check(permission))
+        try:
+            return _coerce(await native_module("Permissions").call_async("request", permission=permission))
+        except Exception:
+            return UNDETERMINED