pythonnative 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

pythonnative/native_modules/file_system.py

@@ -0,0 +1,131 @@
+"""Cross-platform file system access.
+
+Provides helpers for reading and writing files within the app's
+sandboxed storage area.
+"""
+
+import os
+from typing import Any, Optional
+
+from ..utils import IS_ANDROID
+
+
+class FileSystem:
+    """App-scoped file I/O."""
+
+    @staticmethod
+    def app_dir() -> str:
+        """Return the app's writable data directory."""
+        if IS_ANDROID:
+            try:
+                from ..utils import get_android_context
+
+                return str(get_android_context().getFilesDir().getAbsolutePath())
+            except Exception:
+                pass
+        else:
+            try:
+                from rubicon.objc import ObjCClass
+
+                NSSearchPathForDirectoriesInDomains = ObjCClass(
+                    "NSFileManager"
+                ).defaultManager.URLsForDirectory_inDomains_
+                docs = NSSearchPathForDirectoriesInDomains(9, 1)  # NSDocumentDirectory, NSUserDomainMask
+                if docs and docs.count > 0:
+                    return str(docs.objectAtIndex_(0).path)
+            except Exception:
+                pass
+        return os.path.join(os.path.expanduser("~"), ".pythonnative_data")
+
+    @staticmethod
+    def read_text(path: str, encoding: str = "utf-8") -> Optional[str]:
+        """Read a text file relative to :meth:`app_dir` (or an absolute path)."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            with open(full, encoding=encoding) as f:
+                return f.read()
+        except OSError:
+            return None
+
+    @staticmethod
+    def write_text(path: str, content: str, encoding: str = "utf-8") -> bool:
+        """Write a text file. Returns ``True`` on success."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            os.makedirs(os.path.dirname(full), exist_ok=True)
+            with open(full, "w", encoding=encoding) as f:
+                f.write(content)
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def exists(path: str) -> bool:
+        """Check if a file or directory exists."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        return os.path.exists(full)
+
+    @staticmethod
+    def delete(path: str) -> bool:
+        """Delete a file. Returns ``True`` on success."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            os.remove(full)
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def list_dir(path: str = "") -> list:
+        """List entries in a directory."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            return os.listdir(full)
+        except OSError:
+            return []
+
+    @staticmethod
+    def read_bytes(path: str) -> Optional[bytes]:
+        """Read a binary file."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            with open(full, "rb") as f:
+                return f.read()
+        except OSError:
+            return None
+
+    @staticmethod
+    def write_bytes(path: str, data: bytes) -> bool:
+        """Write a binary file. Returns ``True`` on success."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            os.makedirs(os.path.dirname(full), exist_ok=True)
+            with open(full, "wb") as f:
+                f.write(data)
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def get_size(path: str) -> Optional[int]:
+        """Return file size in bytes, or ``None`` if not found."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            return os.path.getsize(full)
+        except OSError:
+            return None
+
+    @staticmethod
+    def ensure_dir(path: str) -> bool:
+        """Create a directory (and parents) if it doesn't exist."""
+        full = path if os.path.isabs(path) else os.path.join(FileSystem.app_dir(), path)
+        try:
+            os.makedirs(full, exist_ok=True)
+            return True
+        except OSError:
+            return False
+
+    @staticmethod
+    def join(*parts: Any) -> str:
+        """Join path components."""
+        return os.path.join(*[str(p) for p in parts])

pythonnative/native_modules/location.py

@@ -0,0 +1,61 @@
+"""Cross-platform location / GPS access.
+
+Provides methods for requesting the current device location.
+Uses Android's ``LocationManager`` or iOS's ``CLLocationManager``.
+"""
+
+from typing import Any, Callable, Optional, Tuple
+
+from ..utils import IS_ANDROID
+
+
+class Location:
+    """GPS / Location services interface."""
+
+    @staticmethod
+    def get_current(
+        on_result: Optional[Callable[[Optional[Tuple[float, float]]], None]] = None,
+        **options: Any,
+    ) -> None:
+        """Request the current location.
+
+        Parameters
+        ----------
+        on_result:
+            ``((lat, lon) | None) -> None`` called with coordinates or
+            ``None`` if location is unavailable.
+        """
+        if IS_ANDROID:
+            Location._android_get(on_result, **options)
+        else:
+            Location._ios_get(on_result, **options)
+
+    @staticmethod
+    def _android_get(on_result: Optional[Callable] = None, **options: Any) -> None:
+        try:
+            from java import jclass
+
+            from ..utils import get_android_context
+
+            ctx = get_android_context()
+            lm = ctx.getSystemService(jclass("android.content.Context").LOCATION_SERVICE)
+            loc = lm.getLastKnownLocation("gps")
+            if loc and on_result:
+                on_result((loc.getLatitude(), loc.getLongitude()))
+            elif on_result:
+                on_result(None)
+        except Exception:
+            if on_result:
+                on_result(None)
+
+    @staticmethod
+    def _ios_get(on_result: Optional[Callable] = None, **options: Any) -> None:
+        try:
+            from rubicon.objc import ObjCClass
+
+            lm = ObjCClass("CLLocationManager").alloc().init()
+            lm.requestWhenInUseAuthorization()
+            lm.startUpdatingLocation()
+        except Exception:
+            if on_result:
+                on_result(None)

pythonnative/native_modules/notifications.py

@@ -0,0 +1,151 @@
+"""Cross-platform local notifications.
+
+Provides methods for scheduling and cancelling local push notifications.
+Uses Android's ``NotificationManager`` or iOS's ``UNUserNotificationCenter``.
+"""
+
+from typing import Any, Callable, Optional
+
+from ..utils import IS_ANDROID
+
+
+class Notifications:
+    """Local notification interface."""
+
+    @staticmethod
+    def request_permission(on_result: Optional[Callable[[bool], None]] = None) -> None:
+        """Request notification permission from the user.
+
+        Parameters
+        ----------
+        on_result:
+            ``(granted: bool) -> None`` called with the permission result.
+        """
+        if IS_ANDROID:
+            if on_result:
+                on_result(True)
+        else:
+            Notifications._ios_request_permission(on_result)
+
+    @staticmethod
+    def schedule(
+        title: str,
+        body: str = "",
+        delay_seconds: float = 0,
+        identifier: str = "default",
+        **options: Any,
+    ) -> None:
+        """Schedule a local notification.
+
+        Parameters
+        ----------
+        title:
+            Notification title.
+        body:
+            Notification body text.
+        delay_seconds:
+            Seconds from now until delivery (0 = immediate).
+        identifier:
+            Unique ID for this notification (for cancellation).
+        """
+        if IS_ANDROID:
+            Notifications._android_schedule(title, body, delay_seconds, identifier, **options)
+        else:
+            Notifications._ios_schedule(title, body, delay_seconds, identifier, **options)
+
+    @staticmethod
+    def cancel(identifier: str = "default") -> None:
+        """Cancel a pending notification by its identifier."""
+        if IS_ANDROID:
+            Notifications._android_cancel(identifier)
+        else:
+            Notifications._ios_cancel(identifier)
+
+    # -- Android ---------------------------------------------------------
+
+    @staticmethod
+    def _android_schedule(title: str, body: str, delay_seconds: float, identifier: str, **options: Any) -> 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)
+            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())
+        except Exception:
+            pass
+
+    @staticmethod
+    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:
+            pass
+
+    # -- iOS -------------------------------------------------------------
+
+    @staticmethod
+    def _ios_request_permission(on_result: Optional[Callable[[bool], None]] = None) -> None:
+        try:
+            from rubicon.objc import ObjCClass
+
+            center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
+            center.requestAuthorizationWithOptions_completionHandler_(0x07, None)
+            if on_result:
+                on_result(True)
+        except Exception:
+            if on_result:
+                on_result(False)
+
+    @staticmethod
+    def _ios_schedule(title: str, body: str, delay_seconds: float, identifier: str, **options: Any) -> None:
+        try:
+            from rubicon.objc import ObjCClass
+
+            content = ObjCClass("UNMutableNotificationContent").alloc().init()
+            content.setTitle_(title)
+            content.setBody_(body)
+
+            if delay_seconds > 0:
+                trigger = ObjCClass("UNTimeIntervalNotificationTrigger").triggerWithTimeInterval_repeats_(
+                    delay_seconds, False
+                )
+            else:
+                trigger = ObjCClass("UNTimeIntervalNotificationTrigger").triggerWithTimeInterval_repeats_(1, False)
+
+            request = ObjCClass("UNNotificationRequest").requestWithIdentifier_content_trigger_(
+                identifier, content, trigger
+            )
+            center = ObjCClass("UNUserNotificationCenter").currentNotificationCenter()
+            center.addNotificationRequest_withCompletionHandler_(request, None)
+        except Exception:
+            pass
+
+    @staticmethod
+    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:
+            pass