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

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

pythonnative/native_modules/clipboard.py

@@ -1,13 +1,11 @@
 """Cross-platform clipboard access.
 
 [`Clipboard`][pythonnative.Clipboard] reads and writes the system
-pasteboard. All methods are synchronous: ``UIPasteboard`` (iOS) and
-``ClipboardManager`` (Android) both answer immediately, so there's no
-need for a coroutine.
+pasteboard through the native ``Clipboard`` module (``UIPasteboard``
+on iOS, ``ClipboardManager`` on Android). All methods are synchronous.
 
-On a desktop machine (neither Android nor iOS) the module falls back to
-a process-local string buffer. That keeps it usable in the desktop
-mock target and unit tests instead of raising.
+Off device the module is a process-local string buffer, which keeps it
+usable in ``pn preview`` and unit tests.
 
 Example:
     ```python
@@ -20,13 +18,8 @@ Example:
 
 from __future__ import annotations
 
-from typing import Optional
-
 from .. import diagnostics
-from ..utils import IS_ANDROID, IS_IOS
-
-# Desktop fallback buffer so the API is usable off-device.
-_desktop_buffer: str = ""
+from .registry import native_module
 
 
 class Clipboard:
@@ -35,109 +28,21 @@ class Clipboard:
     @staticmethod
     def set_string(text: str) -> None:
         """Copy ``text`` onto the system clipboard."""
-        global _desktop_buffer
-        value = "" if text is None else str(text)
-        if IS_ANDROID:
-            _android_set(value)
-        elif IS_IOS:
-            _ios_set(value)
-        else:
-            _desktop_buffer = value
+        try:
+            native_module("Clipboard").call("set_string", text="" if text is None else str(text))
+        except Exception:
+            diagnostics.swallowed("clipboard.set_string")
 
     @staticmethod
     def get_string() -> str:
         """Return the current clipboard string (``""`` when empty)."""
-        if IS_ANDROID:
-            return _android_get()
-        if IS_IOS:
-            return _ios_get()
-        return _desktop_buffer
+        try:
+            value = native_module("Clipboard").call("get_string")
+        except Exception:
+            return ""
+        return "" if value is None else str(value)
 
     @staticmethod
     def has_string() -> bool:
         """Return ``True`` when the clipboard holds non-empty text."""
         return bool(Clipboard.get_string())
-
-
-# ======================================================================
-# iOS: UIPasteboard
-# ======================================================================
-
-
-def _ios_pasteboard() -> Optional[object]:
-    try:
-        from rubicon.objc import ObjCClass
-
-        return ObjCClass("UIPasteboard").generalPasteboard
-    except Exception:
-        return None
-
-
-def _ios_set(text: str) -> None:
-    pb = _ios_pasteboard()
-    if pb is None:
-        return
-    try:
-        pb.string = text
-    except Exception:
-        diagnostics.swallowed("clipboard._ios_set")
-
-
-def _ios_get() -> str:
-    pb = _ios_pasteboard()
-    if pb is None:
-        return ""
-    try:
-        value = pb.string
-        return str(value) if value is not None else ""
-    except Exception:
-        return ""
-
-
-# ======================================================================
-# Android: ClipboardManager
-# ======================================================================
-
-
-def _android_manager() -> Optional[object]:
-    try:
-        from java import jclass
-
-        from ..utils import get_android_context
-
-        ctx = get_android_context()
-        Context = jclass("android.content.Context")
-        return ctx.getSystemService(Context.CLIPBOARD_SERVICE)
-    except Exception:
-        return None
-
-
-def _android_set(text: str) -> None:
-    manager = _android_manager()
-    if manager is None:
-        return
-    try:
-        from java import jclass
-
-        ClipData = jclass("android.content.ClipData")
-        clip = ClipData.newPlainText("pythonnative", text)
-        manager.setPrimaryClip(clip)
-    except Exception:
-        diagnostics.swallowed("clipboard._android_set")
-
-
-def _android_get() -> str:
-    manager = _android_manager()
-    if manager is None:
-        return ""
-    try:
-        if not manager.hasPrimaryClip():
-            return ""
-        clip = manager.getPrimaryClip()
-        if clip is None or clip.getItemCount() == 0:
-            return ""
-        item = clip.getItemAt(0)
-        text = item.getText()
-        return str(text) if text is not None else ""
-    except Exception:
-        return ""