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

pythonnative/native_modules/notifications.py

@@ -28,11 +28,16 @@ Example:
 from __future__ import annotations
 
 import asyncio
-from typing import Any
+from typing import Any, Dict
 
 from ..runtime import resolve_future
 from ..utils import IS_ANDROID
 
+# 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]"] = {}
+
 
 class Notifications:
     """Local notification interface."""
@@ -82,7 +87,13 @@ class Notifications:
         """
         del options
         if IS_ANDROID:
-            return await asyncio.to_thread(_android_schedule, title, body, delay_seconds, identifier)
+            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)
 
     @staticmethod
@@ -94,6 +105,7 @@ class Notifications:
                 [`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)
@@ -104,8 +116,28 @@ class Notifications:
 # ======================================================================
 
 
-def _android_schedule(title: str, body: str, delay_seconds: float, identifier: str) -> bool:
-    del delay_seconds  # Android schedule is fire-and-forget for now.
+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
 

pythonnative/native_modules/permissions.py

@@ -193,8 +193,31 @@ def _ios_request(permission: str, on_done: Callable[[PermissionStatus], None]) -
 
             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:
         pass
     # Fall back to reporting the current status for permissions whose
-    # request flow isn't wired up natively.
+    # 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))

pythonnative/native_views/android.py

@@ -612,11 +612,16 @@ def _make_end_listener(anim_id: int) -> Any:
     AnimatorListener = jclass("android.animation.Animator$AnimatorListener")
 
     class _EndProxy(dynamic_proxy(AnimatorListener)):
+        # ``onAnimationStart`` / ``onAnimationEnd`` accept an optional
+        # ``isReverse``: API 26 added default two-arg overloads to
+        # ``AnimatorListener``, and ``ValueAnimator`` invokes those, so
+        # the java.lang.reflect.Proxy forwards two arguments here.
+
         def __init__(self) -> None:
             super().__init__()
             self._cancelled = False
 
-        def onAnimationStart(self, animation: Any) -> None:
+        def onAnimationStart(self, animation: Any, isReverse: bool = False) -> None:
             pass
 
         def onAnimationRepeat(self, animation: Any) -> None:
@@ -625,7 +630,7 @@ def _make_end_listener(anim_id: int) -> Any:
         def onAnimationCancel(self, animation: Any) -> None:
             self._cancelled = True
 
-        def onAnimationEnd(self, animation: Any) -> None:
+        def onAnimationEnd(self, animation: Any, isReverse: bool = False) -> None:
             entry = _native_anims.pop(anim_id, None)
             if entry is None:
                 return

pythonnative/native_views/ios.py

@@ -3251,7 +3251,18 @@ class PortalHandler(IOSViewHandler):
                 return
             current = overlay.superview
             if current is not None and _objc_ptr(current) == _objc_ptr(host):
-                host.bringSubviewToFront_(overlay)
+                # Already attached to the right host. Only reorder when
+                # the overlay is not frontmost: reordering the subview
+                # array during an active touch sequence (a re-render can
+                # flush between touch-down and touch-up) can cancel the
+                # touch and leave the portal's controls stuck
+                # highlighted with their action never fired.
+                try:
+                    front = host.subviews.lastObject()
+                    if front is None or _objc_ptr(front) != _objc_ptr(overlay):
+                        host.bringSubviewToFront_(overlay)
+                except Exception:
+                    host.bringSubviewToFront_(overlay)
                 self._sync_overlay_frame(overlay, host)
                 return
             if current is not None: