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

AutoGLM_GUI/adb/connection.py

@@ -0,0 +1,323 @@
+"""ADB connection management for local and remote devices."""
+
+import subprocess
+import time
+from dataclasses import dataclass
+from enum import Enum
+
+from AutoGLM_GUI.adb.timing import TIMING_CONFIG
+from AutoGLM_GUI.adb_plus.ip import get_wifi_ip
+
+
+class ConnectionType(Enum):
+    """Type of ADB connection."""
+
+    USB = "usb"
+    WIFI = "wifi"
+    REMOTE = "remote"
+
+
+@dataclass
+class DeviceInfo:
+    """Information about a connected device."""
+
+    device_id: str
+    status: str
+    connection_type: ConnectionType
+    model: str | None = None
+    android_version: str | None = None
+
+
+class ADBConnection:
+    """
+    Manages ADB connections to Android devices.
+
+    Supports USB, WiFi, and remote TCP/IP connections.
+
+    Example:
+        >>> conn = ADBConnection()
+        >>> # Connect to remote device
+        >>> conn.connect("192.168.1.100:5555")
+        >>> # List devices
+        >>> devices = conn.list_devices()
+        >>> # Disconnect
+        >>> conn.disconnect("192.168.1.100:5555")
+    """
+
+    def __init__(self, adb_path: str = "adb"):
+        """
+        Initialize ADB connection manager.
+
+        Args:
+            adb_path: Path to ADB executable.
+        """
+        self.adb_path = adb_path
+
+    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
+        """
+        Connect to a remote device via TCP/IP.
+
+        Args:
+            address: Device address in format "host:port" (e.g., "192.168.1.100:5555").
+            timeout: Connection timeout in seconds.
+
+        Returns:
+            Tuple of (success, message).
+
+        Note:
+            The remote device must have TCP/IP debugging enabled.
+            On the device, run: adb tcpip 5555
+        """
+        # Validate address format
+        if ":" not in address:
+            address = f"{address}:5555"  # Default ADB port
+
+        try:
+            result = subprocess.run(
+                [self.adb_path, "connect", address],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+
+            output = result.stdout + result.stderr
+
+            if "connected" in output.lower():
+                return True, f"Connected to {address}"
+            elif "already connected" in output.lower():
+                return True, f"Already connected to {address}"
+            else:
+                return False, output.strip()
+
+        except subprocess.TimeoutExpired:
+            return False, f"Connection timeout after {timeout}s"
+        except Exception as e:
+            return False, f"Connection error: {e}"
+
+    def disconnect(self, address: str | None = None) -> tuple[bool, str]:
+        """
+        Disconnect from a remote device.
+
+        Args:
+            address: Device address to disconnect. If None, disconnects all.
+
+        Returns:
+            Tuple of (success, message).
+        """
+        try:
+            cmd = [self.adb_path, "disconnect"]
+            if address:
+                cmd.append(address)
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, encoding="utf-8", timeout=5
+            )
+
+            output = result.stdout + result.stderr
+            return True, output.strip() or "Disconnected"
+
+        except Exception as e:
+            return False, f"Disconnect error: {e}"
+
+    def list_devices(self) -> list[DeviceInfo]:
+        """
+        List all connected devices.
+
+        Returns:
+            List of DeviceInfo objects.
+        """
+        try:
+            result = subprocess.run(
+                [self.adb_path, "devices", "-l"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+
+            devices = []
+            for line in result.stdout.strip().split("\n")[1:]:  # Skip header
+                if not line.strip():
+                    continue
+
+                parts = line.split()
+                if len(parts) >= 2:
+                    device_id = parts[0]
+                    status = parts[1]
+
+                    # Determine connection type
+                    if ":" in device_id:
+                        conn_type = ConnectionType.REMOTE
+                    elif "emulator" in device_id:
+                        conn_type = ConnectionType.USB  # Emulator via USB
+                    else:
+                        conn_type = ConnectionType.USB
+
+                    # Parse additional info
+                    model = None
+                    for part in parts[2:]:
+                        if part.startswith("model:"):
+                            model = part.split(":", 1)[1]
+                            break
+
+                    devices.append(
+                        DeviceInfo(
+                            device_id=device_id,
+                            status=status,
+                            connection_type=conn_type,
+                            model=model,
+                        )
+                    )
+
+            return devices
+
+        except Exception as e:
+            print(f"Error listing devices: {e}")
+            return []
+
+    def get_device_info(self, device_id: str | None = None) -> DeviceInfo | None:
+        """
+        Get detailed information about a device.
+
+        Args:
+            device_id: Device ID. If None, uses first available device.
+
+        Returns:
+            DeviceInfo or None if not found.
+        """
+        devices = self.list_devices()
+
+        if not devices:
+            return None
+
+        if device_id is None:
+            return devices[0]
+
+        for device in devices:
+            if device.device_id == device_id:
+                return device
+
+        return None
+
+    def is_connected(self, device_id: str | None = None) -> bool:
+        """
+        Check if a device is connected.
+
+        Args:
+            device_id: Device ID to check. If None, checks if any device is connected.
+
+        Returns:
+            True if connected, False otherwise.
+        """
+        devices = self.list_devices()
+
+        if not devices:
+            return False
+
+        if device_id is None:
+            return any(d.status == "device" for d in devices)
+
+        return any(d.device_id == device_id and d.status == "device" for d in devices)
+
+    def enable_tcpip(
+        self, port: int = 5555, device_id: str | None = None
+    ) -> tuple[bool, str]:
+        """
+        Enable TCP/IP debugging on a USB-connected device.
+
+        This allows subsequent wireless connections to the device.
+
+        Args:
+            port: TCP port for ADB (default: 5555).
+            device_id: Device ID. If None, uses first available device.
+
+        Returns:
+            Tuple of (success, message).
+
+        Note:
+            The device must be connected via USB first.
+            After this, you can disconnect USB and connect via WiFi.
+        """
+        try:
+            cmd = [self.adb_path]
+            if device_id:
+                cmd.extend(["-s", device_id])
+            cmd.extend(["tcpip", str(port)])
+
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, encoding="utf-8", timeout=10
+            )
+
+            output = result.stdout + result.stderr
+
+            if "restarting" in output.lower() or result.returncode == 0:
+                time.sleep(TIMING_CONFIG.connection.adb_restart_delay)
+                return True, f"TCP/IP mode enabled on port {port}"
+            else:
+                return False, output.strip()
+
+        except Exception as e:
+            return False, f"Error enabling TCP/IP: {e}"
+
+    def get_device_ip(self, device_id: str | None = None) -> str | None:
+        """
+        Get the IP address of a connected device.
+
+        Delegates to adb_plus.ip.get_wifi_ip() for better WiFi interface detection.
+
+        Args:
+            device_id: Device ID. If None, uses first available device.
+
+        Returns:
+            IP address string or None if not found.
+        """
+        return get_wifi_ip(adb_path=self.adb_path, device_id=device_id)
+
+    def restart_server(self) -> tuple[bool, str]:
+        """
+        Restart the ADB server.
+
+        Returns:
+            Tuple of (success, message).
+        """
+        try:
+            # Kill server
+            subprocess.run(
+                [self.adb_path, "kill-server"], capture_output=True, timeout=5
+            )
+
+            time.sleep(TIMING_CONFIG.connection.server_restart_delay)
+
+            # Start server
+            subprocess.run(
+                [self.adb_path, "start-server"], capture_output=True, timeout=5
+            )
+
+            return True, "ADB server restarted"
+
+        except Exception as e:
+            return False, f"Error restarting server: {e}"
+
+
+def quick_connect(address: str) -> tuple[bool, str]:
+    """
+    Quick helper to connect to a remote device.
+
+    Args:
+        address: Device address (e.g., "192.168.1.100" or "192.168.1.100:5555").
+
+    Returns:
+        Tuple of (success, message).
+    """
+    conn = ADBConnection()
+    return conn.connect(address)
+
+
+def list_devices() -> list[DeviceInfo]:
+    """
+    Quick helper to list connected devices.
+
+    Returns:
+        List of DeviceInfo objects.
+    """
+    conn = ADBConnection()
+    return conn.list_devices()

AutoGLM_GUI/adb/device.py

@@ -0,0 +1,171 @@
+"""Device control utilities for Android automation."""
+
+import subprocess
+import time
+
+from AutoGLM_GUI.adb.apps import APP_PACKAGES
+from AutoGLM_GUI.adb.timing import TIMING_CONFIG
+from AutoGLM_GUI.platform_utils import build_adb_command
+
+
+def get_current_app(device_id: str | None = None) -> str:
+    adb_prefix = build_adb_command(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")
+
+    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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_tap_delay
+
+    adb_prefix = build_adb_command(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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_double_tap_delay
+
+    adb_prefix = build_adb_command(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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_long_press_delay
+
+    adb_prefix = build_adb_command(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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_swipe_delay
+
+    adb_prefix = build_adb_command(device_id)
+
+    if duration_ms is None:
+        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))
+
+    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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_back_delay
+
+    adb_prefix = build_adb_command(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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_home_delay
+
+    adb_prefix = build_adb_command(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:
+    if delay is None:
+        delay = TIMING_CONFIG.device.default_launch_delay
+
+    if app_name not in APP_PACKAGES:
+        return False
+
+    adb_prefix = build_adb_command(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

AutoGLM_GUI/adb/input.py

@@ -0,0 +1,67 @@
+"""Input utilities for Android device text input."""
+
+import base64
+import subprocess
+
+from AutoGLM_GUI.platform_utils import build_adb_command
+
+
+def type_text(text: str, device_id: str | None = None) -> None:
+    adb_prefix = build_adb_command(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:
+    adb_prefix = build_adb_command(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:
+    adb_prefix = build_adb_command(device_id)
+
+    result = subprocess.run(
+        adb_prefix + ["shell", "settings", "get", "secure", "default_input_method"],
+        capture_output=True,
+        text=True,
+    )
+    current_ime = (result.stdout + result.stderr).strip()
+
+    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,
+        )
+
+    type_text("", device_id)
+
+    return current_ime
+
+
+def restore_keyboard(ime: str, device_id: str | None = None) -> None:
+    adb_prefix = build_adb_command(device_id)
+
+    subprocess.run(
+        adb_prefix + ["shell", "ime", "set", ime], capture_output=True, text=True
+    )

AutoGLM_GUI/adb/screenshot.py

@@ -0,0 +1,11 @@
+"""Screenshot utilities for capturing Android device screen.
+
+DEPRECATED: This module now delegates to adb_plus.screenshot for the actual implementation.
+Use adb_plus.screenshot directly for new code.
+"""
+
+from AutoGLM_GUI.adb_plus.screenshot import Screenshot, capture_screenshot
+
+
+def get_screenshot(device_id: str | None = None, timeout: int = 10) -> Screenshot:
+    return capture_screenshot(device_id=device_id, timeout=timeout)