reflex-capacitor 0.3.2__py3-none-any.whl

reflex_capacitor/__init__.py

@@ -0,0 +1,8 @@
+"""Package a Reflex app as a Capacitor mobile app (remote backend)."""
+
+from .bridge import api as mobile
+from .bridge import api  # noqa: F401 — re-export module for `from reflex_capacitor.bridge import api`
+from . import components
+from .plugin import CapacitorPlugin as CapacitorPlugin
+
+__all__ = ["CapacitorPlugin", "mobile", "api", "components"]

reflex_capacitor/android_signing.py

@@ -0,0 +1,166 @@
+"""Android release signing helpers for Capacitor Gradle builds."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+SIGNING_BEGIN = "// reflex-capacitor signing begin"
+SIGNING_END = "// reflex-capacitor signing end"
+
+KEYSTORE_ENV = "REFLEX_CAPACITOR_KEYSTORE_PATH"
+KEYSTORE_PASSWORD_ENV = "REFLEX_CAPACITOR_KEYSTORE_PASSWORD"
+KEY_ALIAS_ENV = "REFLEX_CAPACITOR_KEY_ALIAS"
+KEY_PASSWORD_ENV = "REFLEX_CAPACITOR_KEY_PASSWORD"
+
+
+@dataclass(frozen=True, kw_only=True)
+class AndroidSigningConfig:
+    """Release keystore settings."""
+
+    keystore_path: Path
+    keystore_password: str
+    key_alias: str
+    key_password: str
+
+    @classmethod
+    def from_env(cls) -> AndroidSigningConfig | None:
+        """Load signing config from standard environment variables."""
+        path = os.environ.get(KEYSTORE_ENV, "").strip()
+        if not path:
+            return None
+        store_password = os.environ.get(KEYSTORE_PASSWORD_ENV, "").strip()
+        key_alias = os.environ.get(KEY_ALIAS_ENV, "").strip()
+        key_password = os.environ.get(KEY_PASSWORD_ENV, "").strip()
+        if not store_password or not key_alias or not key_password:
+            msg = (
+                "reflex-capacitor: set all signing env vars when using "
+                f"{KEYSTORE_ENV}: {KEYSTORE_PASSWORD_ENV}, {KEY_ALIAS_ENV}, {KEY_PASSWORD_ENV}"
+            )
+            raise ValueError(msg)
+        keystore_path = Path(path).expanduser().resolve()
+        if not keystore_path.is_file():
+            msg = f"reflex-capacitor: keystore not found at {keystore_path}"
+            raise FileNotFoundError(msg)
+        return cls(
+            keystore_path=keystore_path,
+            keystore_password=store_password,
+            key_alias=key_alias,
+            key_password=key_password,
+        )
+
+
+def write_keystore_properties(android_root: Path, signing: AndroidSigningConfig) -> Path:
+    """Write ``android/keystore.properties`` (gitignored by Capacitor template)."""
+    store_path = signing.keystore_path
+    try:
+        rel = store_path.relative_to(android_root)
+        store_file = str(rel).replace("\\", "/")
+    except ValueError:
+        store_file = str(store_path).replace("\\", "/")
+
+    props_path = android_root / "keystore.properties"
+    props_path.write_text(
+        "\n".join(
+            [
+                f"storeFile={store_file}",
+                f"storePassword={signing.keystore_password}",
+                f"keyAlias={signing.key_alias}",
+                f"keyPassword={signing.key_password}",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    return props_path
+
+
+def _signing_snippet() -> str:
+    return f"""
+{SIGNING_BEGIN}
+def rcKeystorePropertiesFile = rootProject.file("keystore.properties")
+def rcKeystoreProperties = new Properties()
+if (rcKeystorePropertiesFile.exists()) {{
+    rcKeystoreProperties.load(new FileInputStream(rcKeystorePropertiesFile))
+}}
+{SIGNING_END}
+""".strip()
+
+
+def _signing_configs_block() -> str:
+    return """
+    signingConfigs {
+        release {
+            if (rcKeystorePropertiesFile.exists()) {
+                keyAlias rcKeystoreProperties['keyAlias']
+                keyPassword rcKeystoreProperties['keyPassword']
+                storeFile file(rcKeystoreProperties['storeFile'])
+                storePassword rcKeystoreProperties['storePassword']
+            }
+        }
+    }
+""".strip()
+
+
+def apply_release_signing(android_root: Path, signing: AndroidSigningConfig) -> None:
+    """Configure Gradle release signing via keystore.properties + build.gradle patch."""
+    write_keystore_properties(android_root, signing)
+    gradle_path = android_root / "app" / "build.gradle"
+    if not gradle_path.is_file():
+        msg = f"reflex-capacitor: missing {gradle_path} — run `reflex-capacitor init` first"
+        raise FileNotFoundError(msg)
+    patch_app_build_gradle(gradle_path)
+
+
+def patch_app_build_gradle(gradle_path: Path) -> None:
+    """Idempotently patch ``android/app/build.gradle`` for release signing."""
+    text = gradle_path.read_text(encoding="utf-8")
+    if SIGNING_BEGIN in text and "signingConfig signingConfigs.release" in text:
+        return
+
+    snippet = _signing_snippet()
+    if SIGNING_BEGIN not in text:
+        marker = "android {"
+        idx = text.find(marker)
+        if idx == -1:
+            msg = f"reflex-capacitor: could not find `android {{` in {gradle_path}"
+            raise ValueError(msg)
+        insert_at = idx + len(marker)
+        text = text[:insert_at] + "\n" + snippet + text[insert_at:]
+
+    if "signingConfigs {" not in text:
+        marker = "android {"
+        idx = text.find(marker)
+        if idx == -1:
+            msg = f"reflex-capacitor: could not find `android {{` in {gradle_path}"
+            raise ValueError(msg)
+        insert_at = idx + len(marker)
+        if SIGNING_BEGIN in text:
+            end = text.find(SIGNING_END, insert_at)
+            if end != -1:
+                insert_at = end + len(SIGNING_END)
+        text = text[:insert_at] + "\n" + _signing_configs_block() + text[insert_at:]
+
+    if "signingConfig signingConfigs.release" not in text:
+        release_marker = "release {"
+        idx = text.find(release_marker)
+        if idx == -1:
+            msg = f"reflex-capacitor: could not find release buildType in {gradle_path}"
+            raise ValueError(msg)
+        insert_at = idx + len(release_marker)
+        text = (
+            text[:insert_at]
+            + "\n            signingConfig signingConfigs.release"
+            + text[insert_at:]
+        )
+
+    gradle_path.write_text(text, encoding="utf-8")
+
+
+def release_output_paths(android_root: Path, *, aab: bool) -> list[Path]:
+    """Return expected Gradle release artifact paths."""
+    outputs = android_root / "app" / "build" / "outputs"
+    if aab:
+        return sorted((outputs / "bundle" / "release").glob("*.aab"))
+    return sorted((outputs / "apk" / "release").glob("*.apk"))

reflex_capacitor/bridge/__init__.py

@@ -0,0 +1,34 @@
+"""Reflex ↔ Capacitor native bridge (Python API + JS assets + injection)."""
+
+from reflex_capacitor.bridge import api as mobile
+
+from . import api
+from .inject import install_bridge
+from .log import log_bridge
+from .plugins import (
+    ALL_PLUGIN_IDS,
+    CAPACITOR_PLUGIN_PACKAGES,
+    CORE_PLUGIN_IDS,
+    EXTENDED_PLUGIN_IDS,
+    apply_package_json_deps,
+    copy_plugin_vendor_scripts,
+    ensure_android_notification_permission,
+    resolve_plugin_ids,
+    vendor_script_filename,
+)
+
+__all__ = [
+    "ALL_PLUGIN_IDS",
+    "CAPACITOR_PLUGIN_PACKAGES",
+    "CORE_PLUGIN_IDS",
+    "EXTENDED_PLUGIN_IDS",
+    "api",
+    "mobile",
+    "install_bridge",
+    "log_bridge",
+    "apply_package_json_deps",
+    "copy_plugin_vendor_scripts",
+    "ensure_android_notification_permission",
+    "resolve_plugin_ids",
+    "vendor_script_filename",
+]

reflex_capacitor/bridge/_script.py

@@ -0,0 +1,48 @@
+"""Helpers for generating rx.call_script snippets targeting __REFLEX_CAPACITOR__."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import reflex as rx
+
+
+def call_bridge(
+    method: str,
+    args: dict[str, Any] | None = None,
+    *,
+    callback: Any = None,
+) -> rx.event.EventSpec:
+    """Call an async method on ``window.__REFLEX_CAPACITOR__``.
+
+    Args:
+        method: Bridge method name (e.g. ``"notify"``).
+        args: JSON-serializable arguments object passed to the method.
+        callback: Optional Reflex handler for the resolved return value.
+
+    Returns:
+        A Reflex event that runs the bridge call in the webview.
+    """
+    payload = json.dumps(args or {})
+    script = (
+        "(async () => {"
+        "  const b = window.__REFLEX_CAPACITOR__;"
+        "  if (!b) {"
+        "    console.warn('reflex-capacitor: bridge not loaded');"
+        "    return { ok: false, error: 'bridge_not_loaded' };"
+        "  }"
+        "  try {"
+        f"    return await b.{method}({payload});"
+        "  } catch (e) {"
+        "    console.error('reflex-capacitor: bridge call failed', e);"
+        "    return { ok: false, error: String(e) };"
+        "  }"
+        "})()"
+    )
+    return rx.call_script(script, callback=callback)
+
+
+def call_bridge_void(method: str, args: dict[str, Any] | None = None) -> rx.event.EventSpec:
+    """Call a bridge method without using the return value."""
+    return call_bridge(method, args)

reflex_capacitor/bridge/api.py

@@ -0,0 +1,359 @@
+"""Python → Capacitor bridge API for Reflex event handlers.
+
+Usage::
+
+    import reflex as rx
+    from reflex_capacitor import mobile
+
+    rx.button("Notify", on_click=mobile.notify("Hello", "From Reflex"))
+    rx.button("Share", on_click=mobile.share(text="Check this out"))
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+import reflex as rx
+
+from ._script import call_bridge, call_bridge_void
+
+ImpactStyle = Literal["HEAVY", "MEDIUM", "LIGHT"]
+NotificationStyle = Literal["SUCCESS", "WARNING", "ERROR"]
+StatusBarStyle = Literal["DARK", "LIGHT", "DEFAULT"]
+BackButtonMode = Literal["emit", "exit", "history"]
+
+
+def notify(title: str, body: str = "") -> rx.event.EventSpec:
+    """Show a local OS notification (requires Local Notifications plugin)."""
+    return call_bridge_void("notify", {"title": title, "body": body})
+
+
+def toast(text: str, *, duration: ToastDuration = "short") -> rx.event.EventSpec:
+    """Show a native toast banner."""
+    return call_bridge_void("toast", {"text": text, "duration": duration})
+
+
+def haptics_impact(*, style: ImpactStyle = "MEDIUM", callback: Any = None) -> rx.event.EventSpec:
+    """Trigger a haptic impact (very short tick — may be hard to feel on some Android phones)."""
+    return call_bridge("hapticsImpact", {"style": style}, callback=callback)
+
+
+def haptics_notification(*, type: NotificationStyle = "SUCCESS", callback: Any = None) -> rx.event.EventSpec:
+    """Trigger a haptic notification pattern (slightly longer than impact)."""
+    return call_bridge("hapticsNotification", {"type": type}, callback=callback)
+
+
+def haptics_vibrate(*, duration_ms: int = 300, callback: Any = None) -> rx.event.EventSpec:
+    """Vibrate for ``duration_ms`` — more noticeable than impact for testing."""
+    return call_bridge("hapticsVibrate", {"duration": duration_ms}, callback=callback)
+
+
+def share(
+    *,
+    title: str | None = None,
+    text: str | None = None,
+    url: str | None = None,
+    dialog_title: str | None = None,
+) -> rx.event.EventSpec:
+    """Open the system share sheet."""
+    args: dict[str, str] = {}
+    if title is not None:
+        args["title"] = title
+    if text is not None:
+        args["text"] = text
+    if url is not None:
+        args["url"] = url
+    if dialog_title is not None:
+        args["dialogTitle"] = dialog_title
+    return call_bridge_void("share", args)
+
+
+def clipboard_write(text: str) -> rx.event.EventSpec:
+    """Write text to the system clipboard."""
+    return call_bridge_void("clipboardWrite", {"text": text})
+
+
+def clipboard_read(callback: Any) -> rx.event.EventSpec:
+    """Read clipboard text and pass ``{value: str}`` to the callback handler."""
+    return call_bridge("clipboardRead", callback=callback)
+
+
+def status_bar_set_style(*, style: StatusBarStyle = "DARK") -> rx.event.EventSpec:
+    """Set the status bar icon/text style."""
+    return call_bridge_void("statusBarSetStyle", {"style": style})
+
+
+def status_bar_hide() -> rx.event.EventSpec:
+    """Hide the status bar."""
+    return call_bridge_void("statusBarHide")
+
+
+def status_bar_show() -> rx.event.EventSpec:
+    """Show the status bar."""
+    return call_bridge_void("statusBarShow")
+
+
+def splash_hide() -> rx.event.EventSpec:
+    """Hide the splash screen after the app has loaded."""
+    return call_bridge_void("splashHide")
+
+
+def device_info(callback: Any) -> rx.event.EventSpec:
+    """Fetch device info and pass the result to the callback handler."""
+    return call_bridge("deviceInfo", callback=callback)
+
+
+def network_status(callback: Any) -> rx.event.EventSpec:
+    """Fetch network status and pass the result to the callback handler."""
+    return call_bridge("networkStatus", callback=callback)
+
+
+def app_exit() -> rx.event.EventSpec:
+    """Exit the app (platform-dependent)."""
+    return call_bridge_void("appExit")
+
+
+def diagnostics(callback: Any) -> rx.event.EventSpec:
+    """Fetch bridge diagnostics (platform, loaded plugins, log count)."""
+    return call_bridge("getDiagnostics", callback=callback)
+
+
+def platform_info(callback: Any) -> rx.event.EventSpec:
+    """Return runtime platform flags from the WebView shell.
+
+    Callback receives::
+
+        {
+            "platform": "ios" | "android" | "web",
+            "isNative": bool,
+            "isAndroid": bool,
+            "isIos": bool,
+            "isWeb": bool,
+        }
+
+    Use this in Reflex State to branch UI or call different ``mobile.*`` handlers.
+    """
+    return call_bridge("platformInfo", callback=callback)
+
+
+def bridge_logs(limit: int = 50, callback: Any = None) -> rx.event.EventSpec:
+    """Fetch recent client-side bridge log entries from the WebView."""
+    return call_bridge("getLogs", {"limit": limit}, callback=callback)
+
+
+def clear_logs() -> rx.event.EventSpec:
+    """Clear the in-WebView bridge log buffer."""
+    return call_bridge_void("clearLogs")
+
+
+# --- Phase 3 P1 ---
+
+
+def pref_set(key: str, value: str, *, callback: Any = None) -> rx.event.EventSpec:
+    """Store a string in Capacitor Preferences (device-local key/value)."""
+    return call_bridge("prefSet", {"key": key, "value": value}, callback=callback)
+
+
+def pref_get(key: str, callback: Any) -> rx.event.EventSpec:
+    """Read a Preferences value; callback receives ``{key, value}``."""
+    return call_bridge("prefGet", {"key": key}, callback=callback)
+
+
+def take_photo(
+    callback: Any,
+    *,
+    quality: int = 90,
+    save_to_gallery: bool = False,
+) -> rx.event.EventSpec:
+    """Capture a photo.
+
+    Callback receives ``{dataUrl, webPath, format, saved, ...}``.
+
+    By default the image stays in memory as ``dataUrl`` (no cloud, not saved to disk).
+    Set ``save_to_gallery=True`` to also write into the system photo gallery on
+    Android/iOS (local only, no upload).
+    """
+    return call_bridge(
+        "takePhoto",
+        {"quality": quality, "saveToGallery": save_to_gallery},
+        callback=callback,
+    )
+
+
+def pick_images(callback: Any, *, limit: int = 1, quality: int = 90) -> rx.event.EventSpec:
+    """Pick images from the gallery; callback receives ``{photos: [...]}``."""
+    return call_bridge("pickImages", {"limit": limit, "quality": quality}, callback=callback)
+
+
+def get_current_position(
+    callback: Any,
+    *,
+    enable_high_accuracy: bool = False,
+    timeout_ms: int = 30000,
+) -> rx.event.EventSpec:
+    """Get GPS coordinates; callback receives lat/lon/accuracy.
+
+    Defaults to network/coarse first (faster indoors). Set ``enable_high_accuracy=True``
+    to prefer GPS (slower, needs clear sky).
+    """
+    return call_bridge(
+        "getCurrentPosition",
+        {"enableHighAccuracy": enable_high_accuracy, "timeout": timeout_ms},
+        callback=callback,
+    )
+
+
+def keyboard_show(*, callback: Any = None) -> rx.event.EventSpec:
+    """Show the soft keyboard."""
+    return call_bridge("keyboardShow", callback=callback)
+
+
+def keyboard_hide(*, callback: Any = None) -> rx.event.EventSpec:
+    """Hide the soft keyboard."""
+    return call_bridge("keyboardHide", callback=callback)
+
+
+def browser_open(url: str, *, callback: Any = None) -> rx.event.EventSpec:
+    """Open a URL in the in-app browser (SFSafariViewController / Custom Tabs)."""
+    return call_bridge("browserOpen", {"url": url}, callback=callback)
+
+
+def fs_write(
+    path: str,
+    data: str,
+    *,
+    directory: str = "DATA",
+    callback: Any = None,
+) -> rx.event.EventSpec:
+    """Write UTF-8 text to the app sandbox (Capacitor Filesystem directory)."""
+    return call_bridge("fsWrite", {"path": path, "data": data, "directory": directory}, callback=callback)
+
+
+def fs_read(path: str, callback: Any, *, directory: str = "DATA") -> rx.event.EventSpec:
+    """Read UTF-8 text from the app sandbox."""
+    return call_bridge("fsRead", {"path": path, "directory": directory}, callback=callback)
+
+
+def invoke(
+    plugin: str,
+    method: str,
+    args: dict[str, Any] | None = None,
+    *,
+    callback: Any = None,
+) -> rx.event.EventSpec:
+    """Call a Capacitor plugin method directly (extension point for custom plugins)."""
+    return call_bridge(
+        "invoke",
+        {"plugin": plugin, "method": method, "args": args or {}},
+        callback=callback,
+    )
+
+
+def editor_options(
+    *,
+    enable_crop: bool = True,
+    enable_rotate: bool = True,
+    enable_compress: bool = True,
+    enable_watermark: bool = False,
+    watermark_text: str = "",
+    max_width: int = 1920,
+    quality: int = 85,
+    aspect_ratio: float | None = None,
+    save_to_sandbox: bool = False,
+    sandbox_path: str = "edited/photo.jpg",
+    return_data_url: bool = True,
+) -> dict[str, Any]:
+    """Build editor option dict for :func:`capture_and_edit` / :func:`edit_image`."""
+    from reflex_capacitor.components.image_editor import ImageEditorOptions
+
+    return ImageEditorOptions(
+        enable_crop=enable_crop,
+        enable_rotate=enable_rotate,
+        enable_compress=enable_compress,
+        enable_watermark=enable_watermark,
+        watermark_text=watermark_text,
+        max_width=max_width,
+        quality=quality,
+        aspect_ratio=aspect_ratio,
+        save_to_sandbox=save_to_sandbox,
+        sandbox_path=sandbox_path,
+        return_data_url=return_data_url,
+    ).to_bridge()
+
+
+def capture_and_edit(
+    callback: Any,
+    *,
+    source: Literal["prompt", "camera", "gallery"] = "prompt",
+    editor: dict[str, Any] | None = None,
+) -> rx.event.EventSpec:
+    """Pick/capture an image then open the built-in editor (device-local processing)."""
+    return call_bridge(
+        "captureAndEdit",
+        {"source": source, "editor": editor or editor_options()},
+        callback=callback,
+    )
+
+
+def edit_image(
+    callback: Any,
+    *,
+    data_url: str | None = None,
+    web_path: str | None = None,
+    editor: dict[str, Any] | None = None,
+) -> rx.event.EventSpec:
+    """Open the built-in editor for an existing ``dataUrl`` or Capacitor ``webPath``."""
+    args: dict[str, Any] = {"editor": editor or editor_options()}
+    if data_url is not None:
+        args["dataUrl"] = data_url
+    if web_path is not None:
+        args["webPath"] = web_path
+    return call_bridge("editImage", args, callback=callback)
+
+
+def setup_native_listeners(
+    *,
+    back_button: BackButtonMode = "emit",
+    callback: Any = None,
+) -> rx.event.EventSpec:
+    """Register native → WebView listeners (app lifecycle, back button, keyboard).
+
+    Call once on app load. Events are retrieved via :func:`poll_native_events`.
+
+    ``back_button``:
+      - ``emit`` — queue event for Reflex (default; blocks auto-exit on Android)
+      - ``exit`` — quit the app immediately
+      - ``history`` — ``window.history.back()`` when possible
+    """
+    return call_bridge(
+        "setupNativeListeners",
+        {"backButton": back_button},
+        callback=callback,
+    )
+
+
+def poll_native_events(callback: Any) -> rx.event.EventSpec:
+    """Drain queued native events since the last poll.
+
+    Callback receives ``{events: [{ts, type, detail}, ...]}``.
+    """
+    return call_bridge("drainNativeEvents", callback=callback)
+
+
+def push_register(*, callback: Any = None) -> rx.event.EventSpec:
+    """Request push permission and register for FCM / APNs (requires push-notifications plugin).
+
+    Registration token arrives as a ``pushRegistration`` native event via
+    :func:`poll_native_events`.
+    """
+    return call_bridge("pushRegister", callback=callback)
+
+
+def push_check_permissions(*, callback: Any = None) -> rx.event.EventSpec:
+    """Check remote push notification permission status."""
+    return call_bridge("pushCheckPermissions", callback=callback)
+
+
+def push_request_permissions(*, callback: Any = None) -> rx.event.EventSpec:
+    """Request remote push notification permission from the user."""
+    return call_bridge("pushRequestPermissions", callback=callback)

reflex_capacitor/bridge/api.pyi

@@ -0,0 +1,60 @@
+"""Type stubs for reflex_capacitor.bridge.api."""
+
+from typing import Any, Literal
+
+import reflex as rx
+
+ImpactStyle = Literal["HEAVY", "MEDIUM", "LIGHT"]
+NotificationStyle = Literal["SUCCESS", "WARNING", "ERROR"]
+StatusBarStyle = Literal["DARK", "LIGHT", "DEFAULT"]
+ToastDuration = Literal["short", "long"]
+
+def notify(title: str, body: str = "") -> rx.event.EventSpec: ...
+def toast(text: str, *, duration: ToastDuration = "short") -> rx.event.EventSpec: ...
+def haptics_impact(*, style: ImpactStyle = "MEDIUM", callback: Any = None) -> rx.event.EventSpec: ...
+def haptics_notification(*, type: NotificationStyle = "SUCCESS", callback: Any = None) -> rx.event.EventSpec: ...
+def haptics_vibrate(*, duration_ms: int = 300, callback: Any = None) -> rx.event.EventSpec: ...
+def share(
+    *,
+    title: str | None = None,
+    text: str | None = None,
+    url: str | None = None,
+    dialog_title: str | None = None,
+) -> rx.event.EventSpec: ...
+def clipboard_write(text: str) -> rx.event.EventSpec: ...
+def clipboard_read(callback: Any) -> rx.event.EventSpec: ...
+def status_bar_set_style(*, style: StatusBarStyle = "DARK") -> rx.event.EventSpec: ...
+def status_bar_hide() -> rx.event.EventSpec: ...
+def status_bar_show() -> rx.event.EventSpec: ...
+def splash_hide() -> rx.event.EventSpec: ...
+def device_info(callback: Any) -> rx.event.EventSpec: ...
+def network_status(callback: Any) -> rx.event.EventSpec: ...
+def app_exit() -> rx.event.EventSpec: ...
+def diagnostics(callback: Any) -> rx.event.EventSpec: ...
+def platform_info(callback: Any) -> rx.event.EventSpec: ...
+def bridge_logs(limit: int = 50, callback: Any = None) -> rx.event.EventSpec: ...
+def clear_logs() -> rx.event.EventSpec: ...
+def pref_set(key: str, value: str, *, callback: Any = None) -> rx.event.EventSpec: ...
+def pref_get(key: str, callback: Any) -> rx.event.EventSpec: ...
+def take_photo(
+    callback: Any, *, quality: int = 90, save_to_gallery: bool = False
+) -> rx.event.EventSpec: ...
+def pick_images(callback: Any, *, limit: int = 1, quality: int = 90) -> rx.event.EventSpec: ...
+def get_current_position(callback: Any, *, enable_high_accuracy: bool = False, timeout_ms: int = 30000) -> rx.event.EventSpec: ...
+def keyboard_show(*, callback: Any = None) -> rx.event.EventSpec: ...
+def keyboard_hide(*, callback: Any = None) -> rx.event.EventSpec: ...
+def browser_open(url: str, *, callback: Any = None) -> rx.event.EventSpec: ...
+def fs_write(
+    path: str, data: str, *, directory: str = "DATA", callback: Any = None
+) -> rx.event.EventSpec: ...
+def fs_read(path: str, callback: Any, *, directory: str = "DATA") -> rx.event.EventSpec: ...
+def invoke(
+    plugin: str, method: str, args: dict[str, Any] | None = None, *, callback: Any = None
+) -> rx.event.EventSpec: ...
+def setup_native_listeners(
+    *, back_button: Literal["emit", "exit", "history"] = "emit", callback: Any = None
+) -> rx.event.EventSpec: ...
+def poll_native_events(callback: Any) -> rx.event.EventSpec: ...
+def push_register(*, callback: Any = None) -> rx.event.EventSpec: ...
+def push_check_permissions(*, callback: Any = None) -> rx.event.EventSpec: ...
+def push_request_permissions(*, callback: Any = None) -> rx.event.EventSpec: ...