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

AutoGLM_GUI/device_adapter.py

@@ -0,0 +1,263 @@
+"""Device Protocol Adapter for phone_agent integration.
+
+This module provides an adapter that bridges DeviceProtocol implementations
+to the interface expected by phone_agent's DeviceFactory.
+
+The adapter allows injecting any DeviceProtocol implementation (ADB, Mock, Remote)
+into phone_agent without modifying the third-party code.
+
+Example:
+    >>> from AutoGLM_GUI.device_adapter import inject_device_protocol
+    >>> from AutoGLM_GUI.devices import MockDevice, ADBDevice
+    >>>
+    >>> # For testing: inject mock device
+    >>> mock = MockDevice("mock_001", state_machine)
+    >>> inject_device_protocol(lambda _: mock)
+    >>>
+    >>> # For production: inject ADB device
+    >>> devices = {"phone_1": ADBDevice("emulator-5554")}
+    >>> inject_device_protocol(lambda device_id: devices[device_id])
+"""
+
+from typing import Callable
+
+import phone_agent.device_factory as device_factory_module
+from AutoGLM_GUI.device_protocol import DeviceProtocol, Screenshot
+
+
+class DeviceProtocolAdapter:
+    """
+    Adapter that bridges DeviceProtocol to phone_agent's DeviceFactory interface.
+
+    This adapter wraps a DeviceProtocol getter function and exposes the same
+    interface as phone_agent's DeviceFactory, allowing seamless injection.
+
+    The adapter handles:
+    - Routing device operations to the correct DeviceProtocol instance
+    - Converting between DeviceProtocol and DeviceFactory method signatures
+    - Managing device_id parameters (phone_agent passes device_id to each method)
+    """
+
+    def __init__(
+        self,
+        get_device: Callable[[str | None], DeviceProtocol],
+        default_device_id: str | None = None,
+    ):
+        """
+        Initialize the adapter.
+
+        Args:
+            get_device: Function that returns a DeviceProtocol given a device_id.
+                       If device_id is None, should return a default device.
+            default_device_id: Default device ID to use when None is passed.
+        """
+        self._get_device = get_device
+        self._default_device_id = default_device_id
+        # For compatibility with code that checks device_type
+        self.device_type = "protocol_adapter"
+
+    def _device(self, device_id: str | None) -> DeviceProtocol:
+        """Get device for the given ID."""
+        effective_id = device_id or self._default_device_id
+        return self._get_device(effective_id)
+
+    # === Screenshot ===
+    def get_screenshot(
+        self, device_id: str | None = None, timeout: int = 10
+    ) -> Screenshot:
+        """Get screenshot from device."""
+        return self._device(device_id).get_screenshot(timeout)
+
+    # === Input Operations ===
+    def tap(
+        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
+    ) -> None:
+        """Tap at coordinates."""
+        self._device(device_id).tap(x, y, delay)
+
+    def double_tap(
+        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
+    ) -> None:
+        """Double tap at coordinates."""
+        self._device(device_id).double_tap(x, y, delay)
+
+    def long_press(
+        self,
+        x: int,
+        y: int,
+        duration_ms: int = 3000,
+        device_id: str | None = None,
+        delay: float | None = None,
+    ) -> None:
+        """Long press at coordinates."""
+        self._device(device_id).long_press(x, y, duration_ms, delay)
+
+    def swipe(
+        self,
+        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."""
+        self._device(device_id).swipe(
+            start_x, start_y, end_x, end_y, duration_ms, delay
+        )
+
+    def type_text(self, text: str, device_id: str | None = None) -> None:
+        """Type text."""
+        self._device(device_id).type_text(text)
+
+    def clear_text(self, device_id: str | None = None) -> None:
+        """Clear text."""
+        self._device(device_id).clear_text()
+
+    # === Navigation ===
+    def back(self, device_id: str | None = None, delay: float | None = None) -> None:
+        """Press back button."""
+        self._device(device_id).back(delay)
+
+    def home(self, device_id: str | None = None, delay: float | None = None) -> None:
+        """Press home button."""
+        self._device(device_id).home(delay)
+
+    def launch_app(
+        self, app_name: str, device_id: str | None = None, delay: float | None = None
+    ) -> bool:
+        """Launch an app."""
+        return self._device(device_id).launch_app(app_name, delay)
+
+    # === State Query ===
+    def get_current_app(self, device_id: str | None = None) -> str:
+        """Get current app name."""
+        return self._device(device_id).get_current_app()
+
+    # === Keyboard Management ===
+    def detect_and_set_adb_keyboard(self, device_id: str | None = None) -> str:
+        """Detect and set keyboard."""
+        return self._device(device_id).detect_and_set_adb_keyboard()
+
+    def restore_keyboard(self, ime: str, device_id: str | None = None) -> None:
+        """Restore keyboard."""
+        self._device(device_id).restore_keyboard(ime)
+
+    # === Device Management ===
+    def list_devices(self) -> list[str]:
+        """
+        List connected devices.
+
+        Note: This is a simplified implementation. For full device listing,
+        use ADBDeviceManager.list_devices() directly.
+        """
+        # This is called by some parts of phone_agent
+        # Return the default device if available
+        if self._default_device_id:
+            return [self._default_device_id]
+        return []
+
+    def get_connection_class(self):
+        """Not applicable for protocol adapter."""
+        raise NotImplementedError(
+            "Protocol adapter does not support get_connection_class. "
+            "Use ADBDeviceManager for connection management."
+        )
+
+
+# Store original factory for restoration
+_original_factory = None
+
+
+def inject_device_protocol(
+    get_device: Callable[[str | None], DeviceProtocol],
+    default_device_id: str | None = None,
+) -> DeviceProtocolAdapter:
+    """
+    Inject a DeviceProtocol implementation into phone_agent.
+
+    This replaces phone_agent's global _device_factory with an adapter
+    that routes all device operations through the provided DeviceProtocol.
+
+    Args:
+        get_device: Function that returns a DeviceProtocol given a device_id.
+        default_device_id: Default device ID when None is passed.
+
+    Returns:
+        The adapter instance (for inspection or further configuration).
+
+    Example:
+        >>> # Single mock device
+        >>> mock = MockDevice("mock_001", state_machine)
+        >>> inject_device_protocol(lambda _: mock)
+        >>>
+        >>> # Multiple devices
+        >>> devices = {
+        ...     "phone_1": ADBDevice("emulator-5554"),
+        ...     "phone_2": RemoteDevice("phone_2", "http://remote:8080"),
+        ... }
+        >>> inject_device_protocol(lambda did: devices.get(did, devices["phone_1"]))
+    """
+    # TODO： 不应该依赖这种全部变量
+    global _original_factory
+
+    # Save original factory if not already saved
+    if _original_factory is None:
+        _original_factory = device_factory_module._device_factory
+
+    # Create and inject adapter
+    adapter = DeviceProtocolAdapter(get_device, default_device_id)
+    device_factory_module._device_factory = adapter
+
+    return adapter
+
+
+def restore_device_factory() -> None:
+    """
+    Restore the original device factory.
+
+    Call this after testing to restore normal operation.
+    """
+    global _original_factory
+
+    if _original_factory is not None:
+        device_factory_module._device_factory = _original_factory
+        _original_factory = None
+
+
+class DeviceProtocolContext:
+    """
+    Context manager for temporarily injecting a DeviceProtocol.
+
+    Example:
+        >>> with DeviceProtocolContext(lambda _: mock_device):
+        ...     agent.run("test instruction")
+        >>> # Original factory is automatically restored
+    """
+
+    def __init__(
+        self,
+        get_device: Callable[[str | None], DeviceProtocol],
+        default_device_id: str | None = None,
+    ):
+        """
+        Initialize context.
+
+        Args:
+            get_device: Function that returns a DeviceProtocol given a device_id.
+            default_device_id: Default device ID when None is passed.
+        """
+        self._get_device = get_device
+        self._default_device_id = default_device_id
+        self._original_factory = None
+
+    def __enter__(self) -> DeviceProtocolAdapter:
+        """Enter context and inject adapter."""
+        self._original_factory = device_factory_module._device_factory
+        return inject_device_protocol(self._get_device, self._default_device_id)
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit context and restore original factory."""
+        device_factory_module._device_factory = self._original_factory
+        return None

AutoGLM_GUI/device_manager.py

@@ -7,11 +7,30 @@ import time
 from collections import defaultdict
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Optional
-
-from phone_agent.adb.connection import ADBConnection, ConnectionType, DeviceInfo
+from typing import TYPE_CHECKING, Optional
 
+from AutoGLM_GUI.adb import ADBConnection, ConnectionType, DeviceInfo
 from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.types import DeviceConnectionType
+
+if TYPE_CHECKING:
+    from AutoGLM_GUI.device_protocol import DeviceProtocol
+
+
+def convert_connection_type(ct: ConnectionType) -> DeviceConnectionType:
+    """Convert phone_agent ConnectionType to DeviceConnectionType.
+
+    phone_agent.ConnectionType.REMOTE is actually WiFi ADB,
+    so we map it to DeviceConnectionType.WIFI.
+    """
+    if ct == ConnectionType.USB:
+        return DeviceConnectionType.USB
+    elif ct == ConnectionType.WIFI:
+        return DeviceConnectionType.WIFI
+    elif ct == ConnectionType.REMOTE:
+        return DeviceConnectionType.WIFI
+    else:
+        return DeviceConnectionType.USB
 
 
 class DeviceState(str, Enum):
@@ -28,7 +47,7 @@ class DeviceConnection:
     """Single connection method for a device (USB, WiFi, mDNS, etc.)."""
 
     device_id: str  # USB serial OR IP:port
-    connection_type: ConnectionType
+    connection_type: DeviceConnectionType
     status: str  # "device" | "offline" | "unauthorized"
     last_seen: float = field(default_factory=time.time)
 
@@ -36,14 +55,13 @@ class DeviceConnection:
         """Calculate connection priority for sorting.
 
         Priority:
-        1. Connection type (USB > WiFi/Remote > mDNS)
+        1. Connection type (USB > WiFi > Remote)
         2. Status (device > offline > unauthorized)
         """
-        # Type priority (higher is better)
         type_priority = {
-            ConnectionType.USB: 300,
-            ConnectionType.WIFI: 200,
-            ConnectionType.REMOTE: 200,
+            DeviceConnectionType.USB: 300,
+            DeviceConnectionType.WIFI: 200,
+            DeviceConnectionType.REMOTE: 100,
         }
 
         # Status priority
@@ -98,7 +116,7 @@ class ManagedDevice:
         return self.primary_connection.status
 
     @property
-    def connection_type(self) -> ConnectionType:
+    def connection_type(self) -> DeviceConnectionType:
         """Type of primary connection."""
         return self.primary_connection.connection_type
 
@@ -153,7 +171,7 @@ def _create_managed_device(
     connections = [
         DeviceConnection(
             device_id=d.device_id,
-            connection_type=d.connection_type,
+            connection_type=convert_connection_type(d.connection_type),
             status=d.status,
             last_seen=time.time(),
         )
@@ -228,6 +246,9 @@ class DeviceManager:
         self._mdns_devices: dict[str, ManagedDevice] = {}  # Key: serial
         self._enable_mdns_discovery: bool = True  # Feature toggle
 
+        self._remote_devices: dict[str, "DeviceProtocol"] = {}
+        self._remote_device_configs: dict[str, dict] = {}
+
     @classmethod
     def get_instance(cls, adb_path: str = "adb") -> DeviceManager:
         """Get singleton instance (thread-safe)."""
@@ -312,9 +333,19 @@ class DeviceManager:
             return None
 
     def force_refresh(self) -> None:
-        """Trigger immediate device list refresh (blocking)."""
+        """Trigger immediate device list refresh (blocking).
+
+        Note: This method may fail if ADB is unavailable. Exceptions are logged
+        but not propagated to support remote-only deployments.
+        """
         logger.info("Force refreshing device list...")
-        self._poll_devices()
+        try:
+            self._poll_devices()
+        except Exception as e:
+            logger.warning(
+                f"Device poll failed during force refresh: {e}. "
+                f"This is expected in remote-only deployments without local ADB."
+            )
 
     # Internal methods
 
@@ -366,16 +397,8 @@ class DeviceManager:
         device_with_serials: list[tuple[DeviceInfo, str]] = []
 
         for device_info in adb_devices:
+            # get_device_serial always returns a value (uses device_id as fallback)
             serial = get_device_serial(device_info.device_id, self._adb_path)
-
-            if not serial:
-                # CRITICAL: Log error and skip this device
-                logger.error(
-                    f"Failed to get serial for device {device_info.device_id}. "
-                    f"Skipping this device. Check ADB access."
-                )
-                continue
-
             device_with_serials.append((device_info, serial))
 
         # Step 2: Group devices by serial
@@ -414,6 +437,12 @@ class DeviceManager:
 
             added_serials = current_serials - previous_serials
             removed_serials = previous_serials - current_serials
+            removed_serials = {
+                s
+                for s in removed_serials
+                if s not in self._devices
+                or self._devices[s].connection_type != DeviceConnectionType.REMOTE
+            }
             existing_serials = current_serials & previous_serials
 
             # Add new devices
@@ -441,7 +470,7 @@ class DeviceManager:
                 new_connections = [
                     DeviceConnection(
                         device_id=d.device_id,
-                        connection_type=d.connection_type,
+                        connection_type=convert_connection_type(d.connection_type),
                         status=d.status,
                         last_seen=time.time(),
                     )
@@ -531,8 +560,8 @@ class DeviceManager:
                                 connections=[
                                     DeviceConnection(
                                         device_id=f"{mdns_dev.ip}:{mdns_dev.port}",
-                                        connection_type=ConnectionType.REMOTE,
-                                        status="available",  # Not connected yet
+                                        connection_type=DeviceConnectionType.WIFI,
+                                        status="available",
                                         last_seen=time.time(),
                                     )
                                 ],
@@ -590,7 +619,7 @@ class DeviceManager:
         Returns:
             Tuple of (success, message, wifi_device_id)
         """
-        from phone_agent.adb.connection import ADBConnection, ConnectionType
+        from AutoGLM_GUI.adb import ADBConnection, ConnectionType
 
         from AutoGLM_GUI.adb_plus import get_wifi_ip
 
@@ -637,7 +666,7 @@ class DeviceManager:
         Returns:
             Tuple of (success, message)
         """
-        from phone_agent.adb.connection import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         conn = ADBConnection(adb_path=self._adb_path)
         ok, msg = conn.disconnect(device_id)
@@ -663,7 +692,7 @@ class DeviceManager:
         """
         import re
 
-        from phone_agent.adb.connection import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         # IP format validation
         ip_pattern = r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$"
@@ -701,7 +730,7 @@ class DeviceManager:
         """
         import re
 
-        from phone_agent.adb.connection import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         from AutoGLM_GUI.adb_plus import pair_device
 
@@ -758,3 +787,193 @@ class DeviceManager:
             f"Successfully paired and connected to {connection_address}",
             connection_address,
         )
+
+    def discover_remote_devices(
+        self, base_url: str, timeout: int = 5
+    ) -> tuple[bool, str, list[dict]]:
+        """Discover devices from a remote Device Agent Server.
+
+        Args:
+            base_url: Remote Agent Server address
+            timeout: Connection timeout in seconds
+
+        Returns:
+            Tuple of (success, message, devices_list)
+        """
+        from AutoGLM_GUI.devices.remote_device import RemoteDeviceManager
+
+        base_url = base_url.strip().rstrip("/")
+        if not base_url.startswith(("http://", "https://")):
+            return (False, "base_url must start with http:// or https://", [])
+
+        try:
+            remote_manager = RemoteDeviceManager(base_url, timeout=float(timeout))
+            devices = remote_manager.list_devices()
+
+            devices_list = [
+                {
+                    "device_id": d.device_id,
+                    "model": d.model or "Unknown",
+                    "platform": d.platform,
+                    "status": d.status,
+                }
+                for d in devices
+            ]
+
+            return (True, f"Found {len(devices_list)} device(s)", devices_list)
+        except Exception as e:
+            logger.error(f"Failed to discover remote devices: {e}")
+            return (False, f"Discovery failed: {str(e)}", [])
+
+    def add_remote_device(self, base_url: str, device_id: str) -> tuple[bool, str, str]:
+        """Manually add a remote HTTP proxy device.
+
+        Args:
+            base_url: Remote Agent Server address (e.g., http://server:8001)
+            device_id: Device ID on the remote server
+
+        Returns:
+            Tuple of (success, message, synthetic_serial)
+        """
+        from AutoGLM_GUI.devices.remote_device import RemoteDevice
+
+        base_url = base_url.strip().rstrip("/")
+        if not base_url.startswith(("http://", "https://")):
+            return (False, "base_url must start with http:// or https://", "")
+
+        synthetic_serial = f"remote:{base_url}:{device_id}"
+
+        with self._devices_lock:
+            if synthetic_serial in self._devices:
+                return (False, f"Remote device {device_id} already exists", "")
+
+            try:
+                remote_device = RemoteDevice(device_id, base_url)
+                remote_device.get_screenshot(timeout=5)
+
+                managed = ManagedDevice(
+                    serial=synthetic_serial,
+                    connections=[
+                        DeviceConnection(
+                            device_id=f"{base_url}|{device_id}",
+                            connection_type=DeviceConnectionType.REMOTE,
+                            status="device",
+                            last_seen=time.time(),
+                        )
+                    ],
+                    model=device_id,
+                    state=DeviceState.ONLINE,
+                )
+
+                self._devices[synthetic_serial] = managed
+                self._remote_devices[synthetic_serial] = remote_device
+                self._remote_device_configs[synthetic_serial] = {
+                    "base_url": base_url,
+                    "device_id": device_id,
+                }
+
+                self._device_id_to_serial[managed.primary_device_id] = synthetic_serial
+
+                logger.info(f"Remote device added: {synthetic_serial}")
+                return (True, "Remote device added successfully", synthetic_serial)
+
+            except Exception as e:
+                logger.error(f"Failed to connect to remote device: {e}")
+                return (False, f"Connection failed: {str(e)}", "")
+
+    def remove_remote_device(self, serial: str) -> tuple[bool, str]:
+        """Remove a remote device.
+
+        Args:
+            serial: Synthetic serial of the remote device (remote:...)
+
+        Returns:
+            Tuple of (success, message)
+        """
+        with self._devices_lock:
+            if serial not in self._devices:
+                return (False, "Remote device not found")
+
+            managed = self._devices.get(serial)
+            if not managed or managed.connection_type != DeviceConnectionType.REMOTE:
+                return (False, "Not a remote device")
+
+            managed = self._devices.pop(serial)
+            remote_device = self._remote_devices.pop(serial, None)
+            self._remote_device_configs.pop(serial, None)
+
+            for conn in managed.connections:
+                self._device_id_to_serial.pop(conn.device_id, None)
+
+            if remote_device:
+                try:
+                    remote_device.close()  # type: ignore
+                except Exception as e:
+                    logger.warning(f"Error closing remote device: {e}")
+
+            logger.info(f"Remote device removed: {serial}")
+            return (True, "Remote device removed successfully")
+
+    def get_remote_device_instance(self, serial: str) -> "DeviceProtocol | None":
+        """Get RemoteDevice instance for device adapter injection.
+
+        Args:
+            serial: Synthetic serial of the remote device
+
+        Returns:
+            RemoteDevice instance or None if not found
+        """
+        return self._remote_devices.get(serial)
+
+    def get_serial_by_device_id(self, device_id: str) -> str | None:
+        """Get serial by device_id (reverse lookup).
+
+        Args:
+            device_id: Device ID from connections
+
+        Returns:
+            Serial (synthetic or ADB) or None if not found
+        """
+        return self._device_id_to_serial.get(device_id)
+
+    def get_device_protocol(self, device_id: str) -> "DeviceProtocol":
+        """
+        根据 device_id 获取 DeviceProtocol 实例（统一入口）.
+
+        自动识别设备类型（ADB / Remote）并返回对应的实现。
+
+        Args:
+            device_id: 设备标识符（USB serial / IP:port / remote_xxx）
+
+        Returns:
+            DeviceProtocol 实例（ADBDevice 或 RemoteDevice）
+
+        Raises:
+            ValueError: 设备未找到或不可用
+
+        Example:
+            >>> manager = DeviceManager.get_instance()
+            >>> device = manager.get_device_protocol("192.168.1.100:5555")
+            >>> screenshot = device.get_screenshot()  # 不关心是 ADB 还是 Remote
+        """
+        with self._devices_lock:
+            # 1. 查找设备元数据
+            managed = self.get_device_by_device_id(device_id)
+            if not managed:
+                raise ValueError(f"Device {device_id} not found in DeviceManager")
+
+            # 2. 根据连接类型返回对应实现
+            if managed.connection_type == DeviceConnectionType.REMOTE:
+                # Remote device: 返回 HTTP 客户端
+                remote_device = self.get_remote_device_instance(managed.serial)
+                if not remote_device:
+                    raise ValueError(
+                        f"Remote device instance not found for serial {managed.serial}"
+                    )
+                return remote_device  # type: ignore[return-value]
+
+            else:
+                # ADB device (USB / WiFi): 返回本地 ADB 包装
+                from AutoGLM_GUI.devices.adb_device import ADBDevice
+
+                return ADBDevice(managed.primary_device_id)