autoglm-gui 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

phone_agent/adb/device.py

@@ -1,253 +0,0 @@
-"""Device control utilities for Android automation."""
-
-import subprocess
-import time
-
-from phone_agent.config.apps import APP_PACKAGES
-from phone_agent.config.timing import TIMING_CONFIG
-
-
-def get_current_app(device_id: str | None = None) -> str:
-    """
-    Get the currently focused app name.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-
-    Returns:
-        The app name if recognized, otherwise "System Home".
-    """
-    adb_prefix = _get_adb_prefix(device_id)
-
-    result = subprocess.run(
-        adb_prefix + ["shell", "dumpsys", "window"],
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
-    output = result.stdout
-    if not output:
-        raise ValueError("No output from dumpsys window")
-
-    # Parse window focus info
-    for line in output.split("\n"):
-        if "mCurrentFocus" in line or "mFocusedApp" in line:
-            for app_name, package in APP_PACKAGES.items():
-                if package in line:
-                    return app_name
-
-    return "System Home"
-
-
-def tap(
-    x: int, y: int, device_id: str | None = None, delay: float | None = None
-) -> None:
-    """
-    Tap at the specified coordinates.
-
-    Args:
-        x: X coordinate.
-        y: Y coordinate.
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after tap. If None, uses configured default.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_tap_delay
-
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix + ["shell", "input", "tap", str(x), str(y)], capture_output=True
-    )
-    time.sleep(delay)
-
-
-def double_tap(
-    x: int, y: int, device_id: str | None = None, delay: float | None = None
-) -> None:
-    """
-    Double tap at the specified coordinates.
-
-    Args:
-        x: X coordinate.
-        y: Y coordinate.
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after double tap. If None, uses configured default.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_double_tap_delay
-
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix + ["shell", "input", "tap", str(x), str(y)], capture_output=True
-    )
-    time.sleep(TIMING_CONFIG.device.double_tap_interval)
-    subprocess.run(
-        adb_prefix + ["shell", "input", "tap", str(x), str(y)], capture_output=True
-    )
-    time.sleep(delay)
-
-
-def long_press(
-    x: int,
-    y: int,
-    duration_ms: int = 3000,
-    device_id: str | None = None,
-    delay: float | None = None,
-) -> None:
-    """
-    Long press at the specified coordinates.
-
-    Args:
-        x: X coordinate.
-        y: Y coordinate.
-        duration_ms: Duration of press in milliseconds.
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after long press. If None, uses configured default.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_long_press_delay
-
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix
-        + ["shell", "input", "swipe", str(x), str(y), str(x), str(y), str(duration_ms)],
-        capture_output=True,
-    )
-    time.sleep(delay)
-
-
-def swipe(
-    start_x: int,
-    start_y: int,
-    end_x: int,
-    end_y: int,
-    duration_ms: int | None = None,
-    device_id: str | None = None,
-    delay: float | None = None,
-) -> None:
-    """
-    Swipe from start to end coordinates.
-
-    Args:
-        start_x: Starting X coordinate.
-        start_y: Starting Y coordinate.
-        end_x: Ending X coordinate.
-        end_y: Ending Y coordinate.
-        duration_ms: Duration of swipe in milliseconds (auto-calculated if None).
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after swipe. If None, uses configured default.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_swipe_delay
-
-    adb_prefix = _get_adb_prefix(device_id)
-
-    if duration_ms is None:
-        # Calculate duration based on distance
-        dist_sq = (start_x - end_x) ** 2 + (start_y - end_y) ** 2
-        duration_ms = int(dist_sq / 1000)
-        duration_ms = max(1000, min(duration_ms, 2000))  # Clamp between 1000-2000ms
-
-    subprocess.run(
-        adb_prefix
-        + [
-            "shell",
-            "input",
-            "swipe",
-            str(start_x),
-            str(start_y),
-            str(end_x),
-            str(end_y),
-            str(duration_ms),
-        ],
-        capture_output=True,
-    )
-    time.sleep(delay)
-
-
-def back(device_id: str | None = None, delay: float | None = None) -> None:
-    """
-    Press the back button.
-
-    Args:
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after pressing back. If None, uses configured default.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_back_delay
-
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix + ["shell", "input", "keyevent", "4"], capture_output=True
-    )
-    time.sleep(delay)
-
-
-def home(device_id: str | None = None, delay: float | None = None) -> None:
-    """
-    Press the home button.
-
-    Args:
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after pressing home. If None, uses configured default.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_home_delay
-
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix + ["shell", "input", "keyevent", "KEYCODE_HOME"], capture_output=True
-    )
-    time.sleep(delay)
-
-
-def launch_app(
-    app_name: str, device_id: str | None = None, delay: float | None = None
-) -> bool:
-    """
-    Launch an app by name.
-
-    Args:
-        app_name: The app name (must be in APP_PACKAGES).
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after launching. If None, uses configured default.
-
-    Returns:
-        True if app was launched, False if app not found.
-    """
-    if delay is None:
-        delay = TIMING_CONFIG.device.default_launch_delay
-
-    if app_name not in APP_PACKAGES:
-        return False
-
-    adb_prefix = _get_adb_prefix(device_id)
-    package = APP_PACKAGES[app_name]
-
-    subprocess.run(
-        adb_prefix
-        + [
-            "shell",
-            "monkey",
-            "-p",
-            package,
-            "-c",
-            "android.intent.category.LAUNCHER",
-            "1",
-        ],
-        capture_output=True,
-    )
-    time.sleep(delay)
-    return True
-
-
-def _get_adb_prefix(device_id: str | None) -> list:
-    """Get ADB command prefix with optional device specifier."""
-    if device_id:
-        return ["adb", "-s", device_id]
-    return ["adb"]

phone_agent/adb/input.py

@@ -1,108 +0,0 @@
-"""Input utilities for Android device text input."""
-
-import base64
-import subprocess
-
-
-def type_text(text: str, device_id: str | None = None) -> None:
-    """
-    Type text into the currently focused input field using ADB Keyboard.
-
-    Args:
-        text: The text to type.
-        device_id: Optional ADB device ID for multi-device setups.
-
-    Note:
-        Requires ADB Keyboard to be installed on the device.
-        See: https://github.com/nicnocquee/AdbKeyboard
-    """
-    adb_prefix = _get_adb_prefix(device_id)
-    encoded_text = base64.b64encode(text.encode("utf-8")).decode("utf-8")
-
-    subprocess.run(
-        adb_prefix
-        + [
-            "shell",
-            "am",
-            "broadcast",
-            "-a",
-            "ADB_INPUT_B64",
-            "--es",
-            "msg",
-            encoded_text,
-        ],
-        capture_output=True,
-        text=True,
-    )
-
-
-def clear_text(device_id: str | None = None) -> None:
-    """
-    Clear text in the currently focused input field.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-    """
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix + ["shell", "am", "broadcast", "-a", "ADB_CLEAR_TEXT"],
-        capture_output=True,
-        text=True,
-    )
-
-
-def detect_and_set_adb_keyboard(device_id: str | None = None) -> str:
-    """
-    Detect current keyboard and switch to ADB Keyboard if needed.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-
-    Returns:
-        The original keyboard IME identifier for later restoration.
-    """
-    adb_prefix = _get_adb_prefix(device_id)
-
-    # Get current IME
-    result = subprocess.run(
-        adb_prefix + ["shell", "settings", "get", "secure", "default_input_method"],
-        capture_output=True,
-        text=True,
-    )
-    current_ime = (result.stdout + result.stderr).strip()
-
-    # Switch to ADB Keyboard if not already set
-    if "com.android.adbkeyboard/.AdbIME" not in current_ime:
-        subprocess.run(
-            adb_prefix + ["shell", "ime", "set", "com.android.adbkeyboard/.AdbIME"],
-            capture_output=True,
-            text=True,
-        )
-
-    # Warm up the keyboard
-    type_text("", device_id)
-
-    return current_ime
-
-
-def restore_keyboard(ime: str, device_id: str | None = None) -> None:
-    """
-    Restore the original keyboard IME.
-
-    Args:
-        ime: The IME identifier to restore.
-        device_id: Optional ADB device ID for multi-device setups.
-    """
-    adb_prefix = _get_adb_prefix(device_id)
-
-    subprocess.run(
-        adb_prefix + ["shell", "ime", "set", ime], capture_output=True, text=True
-    )
-
-
-def _get_adb_prefix(device_id: str | None) -> list:
-    """Get ADB command prefix with optional device specifier."""
-    if device_id:
-        return ["adb", "-s", device_id]
-    return ["adb"]

phone_agent/adb/screenshot.py

@@ -1,108 +0,0 @@
-"""Screenshot utilities for capturing Android device screen."""
-
-import base64
-import os
-import subprocess
-import tempfile
-import uuid
-from dataclasses import dataclass
-from io import BytesIO
-
-from PIL import Image
-
-
-@dataclass
-class Screenshot:
-    """Represents a captured screenshot."""
-
-    base64_data: str
-    width: int
-    height: int
-    is_sensitive: bool = False
-
-
-def get_screenshot(device_id: str | None = None, timeout: int = 10) -> Screenshot:
-    """
-    Capture a screenshot from the connected Android device.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-        timeout: Timeout in seconds for screenshot operations.
-
-    Returns:
-        Screenshot object containing base64 data and dimensions.
-
-    Note:
-        If the screenshot fails (e.g., on sensitive screens like payment pages),
-        a black fallback image is returned with is_sensitive=True.
-    """
-    temp_path = os.path.join(tempfile.gettempdir(), f"screenshot_{uuid.uuid4()}.png")
-    adb_prefix = _get_adb_prefix(device_id)
-
-    try:
-        # Execute screenshot command
-        result = subprocess.run(
-            adb_prefix + ["shell", "screencap", "-p", "/sdcard/tmp.png"],
-            capture_output=True,
-            text=True,
-            timeout=timeout,
-        )
-
-        # Check for screenshot failure (sensitive screen)
-        output = result.stdout + result.stderr
-        if "Status: -1" in output or "Failed" in output:
-            return _create_fallback_screenshot(is_sensitive=True)
-
-        # Pull screenshot to local temp path
-        subprocess.run(
-            adb_prefix + ["pull", "/sdcard/tmp.png", temp_path],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-
-        if not os.path.exists(temp_path):
-            return _create_fallback_screenshot(is_sensitive=False)
-
-        # Read and encode image
-        img = Image.open(temp_path)
-        width, height = img.size
-
-        buffered = BytesIO()
-        img.save(buffered, format="PNG")
-        base64_data = base64.b64encode(buffered.getvalue()).decode("utf-8")
-
-        # Cleanup
-        os.remove(temp_path)
-
-        return Screenshot(
-            base64_data=base64_data, width=width, height=height, is_sensitive=False
-        )
-
-    except Exception as e:
-        print(f"Screenshot error: {e}")
-        return _create_fallback_screenshot(is_sensitive=False)
-
-
-def _get_adb_prefix(device_id: str | None) -> list:
-    """Get ADB command prefix with optional device specifier."""
-    if device_id:
-        return ["adb", "-s", device_id]
-    return ["adb"]
-
-
-def _create_fallback_screenshot(is_sensitive: bool) -> Screenshot:
-    """Create a black fallback image when screenshot fails."""
-    default_width, default_height = 1080, 2400
-
-    black_img = Image.new("RGB", (default_width, default_height), color="black")
-    buffered = BytesIO()
-    black_img.save(buffered, format="PNG")
-    base64_data = base64.b64encode(buffered.getvalue()).decode("utf-8")
-
-    return Screenshot(
-        base64_data=base64_data,
-        width=default_width,
-        height=default_height,
-        is_sensitive=is_sensitive,
-    )