pythonnative 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

pythonnative/native_modules/notifications.py

@@ -1,13 +1,22 @@
-"""Cross-platform local notifications.
+"""Cross-platform 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``.
 
 On iOS you must ``await Notifications.request_permission()`` before
-scheduling. On Android 13+ the runtime permission should be requested
-through standard Android APIs (the manifest declaration is otherwise
-sufficient).
+scheduling. On Android 13+ the ``POST_NOTIFICATIONS`` runtime
+permission is requested automatically the first time you schedule a
+notification (the template manifest declares it); earlier Android
+versions don't prompt at all.
+
+For remote (server-sent) pushes, enable the ``remote_notifications``
+capability in ``pythonnative.toml`` and call
+``Notifications.get_device_token()`` to register with APNs and receive
+the device token your server needs. Android remote push requires
+Firebase Cloud Messaging, which needs a per-app ``google-services.json``
+and is not wired up by the built-in module; ``get_device_token`` returns
+``None`` there.
 
 Example:
     ```python
@@ -28,10 +37,11 @@ Example:
 from __future__ import annotations
 
 import asyncio
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional
 
-from ..runtime import resolve_future
-from ..utils import IS_ANDROID
+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
@@ -46,17 +56,18 @@ class Notifications:
     async def request_permission() -> bool:
         """Request notification permission from the user.
 
-        On Android the manifest declaration is normally sufficient for
-        legacy permission grants and this returns ``True`` without
-        prompting (the runtime POST_NOTIFICATIONS prompt for Android
-        13+ should be requested via standard Android APIs).
+        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.
 
         Returns:
             ``True`` if granted (or no prompt is needed), ``False``
             otherwise.
         """
         if IS_ANDROID:
-            return True
+            return await _android_request_permission()
         return await _ios_request_permission()
 
     @staticmethod
@@ -83,10 +94,15 @@ class Notifications:
 
         Returns:
             ``True`` on success, ``False`` if the underlying native
-            call failed.
+            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(
@@ -110,12 +126,55 @@ class Notifications:
             return
         await asyncio.to_thread(_ios_cancel, identifier)
 
+    @staticmethod
+    async def get_device_token() -> Optional[str]:
+        """Register for remote notifications and return the device token.
+
+        On iOS this calls ``registerForRemoteNotifications`` and waits
+        for the APNs callback; the token is a lowercase hex string your
+        server passes to APNs. Requires the ``remote_notifications``
+        capability (which adds the ``aps-environment`` entitlement) and
+        a real device (the simulator has no APNs connection).
+
+        Returns:
+            The APNs token, or ``None`` on platforms without built-in
+            remote push support (Android and desktop).
+
+        Raises:
+            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():
@@ -171,7 +230,7 @@ def _android_cancel(identifier: str) -> None:
         nm = ctx.getSystemService(jclass("android.content.Context").NOTIFICATION_SERVICE)
         nm.cancel(abs(hash(identifier)) % (2**31))
     except Exception:
-        pass
+        diagnostics.swallowed("notifications._android_cancel")
 
 
 # ======================================================================
@@ -235,4 +294,64 @@ def _ios_cancel(identifier: str) -> None:
         arr = NSArray.arrayWithObject_(identifier)
         center.removePendingNotificationRequestsWithIdentifiers_(arr)
     except Exception:
-        pass
+        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)

pythonnative/native_modules/permissions.py

@@ -21,6 +21,7 @@ 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
 
@@ -141,7 +142,7 @@ def deliver_android_permission_result(request_code: int, permissions: Any, grant
     try:
         cb(status)
     except Exception:
-        pass
+        diagnostics.swallowed("permissions.deliver_android_permission_result")
     return True
 
 
@@ -215,7 +216,7 @@ def _ios_request(permission: str, on_done: Callable[[PermissionStatus], None]) -
             center.requestAuthorizationWithOptions_completionHandler_(0x07, Block(_notif_done, None, bool, object))
             return
     except Exception:
-        pass
+        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

pythonnative/native_modules/share.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 import asyncio
 from typing import Any, Callable, Dict, Optional
 
+from .. import diagnostics
 from ..runtime import resolve_future
 from ..utils import IS_ANDROID, IS_IOS
 
@@ -102,7 +103,7 @@ def _ios_share(
             try:
                 on_done(bool(completed))
             except Exception:
-                pass
+                diagnostics.swallowed("share._ios_share._completion")
 
         controller.setCompletionWithItemsHandler_(
             Block(_completion, None, ObjCClass("NSString"), Block, ObjCClass("NSArray"), ObjCClass("NSError"))