自动设备没有获取信息

app/api/v1/endpoints/devices.py

@@ -18,14 +18,14 @@ router = APIRouter()
 
 @router.get("/devices", summary="获取所有设备")
 async def get_devices():
-    """获取所有设备列表"""
+    """获取所有设备列表（包括注册和自动发现的设备）"""
     try:
         devices = await device_service.get_all_devices()
         return DeviceListResponse(
             success=True,
             message=f"成功获取 {len(devices)} 个设备",
             data={
-                "devices": [device.dict() for device in devices],
+                "devices": devices,  # 直接返回字典列表，包含注册和自动发现的设备
                 "total": len(devices)
             }
         )
@@ -38,7 +38,7 @@ async def get_devices():
 
 @router.get("/devices/{device_id}", summary="获取指定设备")
 async def get_device(device_id: str):
-    """获取指定设备信息"""
+    """获取指定设备信息（包括注册和自动发现的设备）"""
     try:
         device = await device_service.get_device(device_id)
         if not device:
@@ -62,7 +62,7 @@ async def get_device(device_id: str):
 
 @router.get("/devices/{device_id}/status", summary="获取设备状态")
 async def get_device_status(device_id: str):
-    """获取指定设备状态"""
+    """获取指定设备状态（包括注册和自动发现的设备）"""
     try:
         status_info = await device_service.get_device_status(device_id)
         return {

app/services/device_service.py

@@ -25,54 +25,94 @@ class DeviceService:
         # 初始化设备操作映射配置
         self.operation_mapping = DeviceOperationMapping(self.auto_discovery_adb_service)
     
-    async def get_all_devices(self) -> List[Device]:
-        """获取所有设备"""
+    async def get_all_devices(self) -> List[Dict[str, Any]]:
+        """获取所有设备（包括注册和自动发现的）"""
         try:
-            devices = await self.device_manager.get_all_devices()
-            return devices  # 直接返回Device对象列表，不需要转换
+            devices = await self.device_manager.get_all_devices_unified()
+            return devices
         except Exception as e:
             logger.error(f"获取所有设备失败: {e}")
             raise
     
-    async def get_device(self, device_id: str) -> Optional[Device]:
-        """获取指定设备"""
+    async def get_device(self, device_id: str) -> Optional[Dict[str, Any]]:
+        """获取指定设备（优先获取自动发现的设备，然后获取注册的设备）"""
         try:
+            # 优先检查自动发现设备
+            device_source = await self.device_manager.get_device_source(device_id)
+            if device_source == DeviceSource.AUTO_DISCOVERED:
+                # 获取自动发现设备信息
+                auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+                for device in auto_discovered_devices:
+                    if device["device_id"] == device_id:
+                        return device
+            
+            # 然后检查注册设备
             device_info = await self.device_manager.get_device(device_id)
             if device_info:
-                return device_info  # 直接返回Device对象，不需要转换
+                # 转换为统一格式
+                return {
+                    "device_id": device_info.device_id,
+                    "name": device_info.name,
+                    "protocol_type": device_info.protocol_type,
+                    "status": device_info.status,
+                    "source": DeviceSource.REGISTERED.value,
+                    "created_at": device_info.created_at,
+                    "updated_at": device_info.updated_at,
+                    "connection_info": device_info.connection_info
+                }
+            
             return None
         except Exception as e:
             logger.error(f"获取设备 {device_id} 失败: {e}")
             raise
     
     async def get_device_status(self, device_id: str) -> DeviceStatusResponse:
-        """获取设备状态"""
+        """获取设备状态（包括注册和自动发现的设备）"""
         try:
-            device = await self.device_manager.get_device(device_id)
-            if not device:
-                raise ValueError(f"设备 {device_id} 不存在")
+            # 获取设备来源
+            device_source = await self.device_manager.get_device_source(device_id)
             
-            return DeviceStatusResponse(
-                device_id=device_id,
-                status=device.status,
-                timestamp=device.updated_at
-            )
+            if device_source == DeviceSource.REGISTERED:
+                # 注册设备
+                device = await self.device_manager.get_device(device_id)
+                if not device:
+                    raise ValueError(f"设备 {device_id} 不存在")
+                
+                return DeviceStatusResponse(
+                    device_id=device_id,
+                    status=device.status,
+                    timestamp=device.updated_at
+                )
+            else:
+                # 自动发现设备
+                auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+                for device in auto_discovered_devices:
+                    if device["device_id"] == device_id:
+                        return DeviceStatusResponse(
+                            device_id=device_id,
+                            status=device["status"],
+                            timestamp=device.get("last_seen", None)
+                        )
+                
+                raise ValueError(f"设备 {device_id} 不存在")
+                
         except Exception as e:
             logger.error(f"获取设备 {device_id} 状态失败: {e}")
             raise
     
     async def execute_operation(self, device_id: str, operation: str, **kwargs) -> Dict[str, Any]:
-        """执行设备操作"""
+        """执行设备操作（包括注册和自动发现的设备）"""
         try:
-            device = await self.device_manager.get_device(device_id)
-            if not device:
-                raise ValueError(f"设备 {device_id} 不存在")
-            
             # 获取设备来源
             device_source = await self.device_manager.get_device_source(device_id)
             
             if device_source == DeviceSource.REGISTERED:
-                # 注册设备：通过设备分发器执行
+                # 注册设备：检查设备是否存在
+                device = await self.device_manager.get_device(device_id)
+                if not device:
+                    raise ValueError(f"设备 {device_id} 不存在")
+                
+                # 通过设备分发器执行
                 return await self.device_dispatcher.execute_operation(
                     device_id=device_id,
                     protocol_type=device.protocol_type,
@@ -80,7 +120,13 @@ class DeviceService:
                     **kwargs
                 )
             else:
-                # 自动发现设备：直接调用ADB服务
+                # 自动发现设备：检查设备是否存在
+                auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+                device_exists = any(device["device_id"] == device_id for device in auto_discovered_devices)
+                if not device_exists:
+                    raise ValueError(f"设备 {device_id} 不存在")
+                
+                # 直接调用ADB服务
                 return await self._execute_auto_discovered_device_operation(
                     device_id, operation, **kwargs
                 )

docs/modify.md

@@ -1,5 +1,183 @@
 # 修改记录
 
+## 2025-08-18 修改DeviceService.get_device方法优先级
+
+**修改内容：**
+修改 `app/services/device_service.py` 中的 `get_device` 方法，让它优先获取自动发现的设备，然后再获取注册的设备。
+
+**修改详情：**
+
+### 修改前
+```python
+async def get_device(self, device_id: str) -> Optional[Dict[str, Any]]:
+    """获取指定设备（包括注册和自动发现的设备）"""
+    try:
+        # 先检查注册设备
+        device_info = await self.device_manager.get_device(device_id)
+        if device_info:
+            # 转换为统一格式
+            return {...}
+        
+        # 检查自动发现设备
+        device_source = await self.device_manager.get_device_source(device_id)
+        if device_source == DeviceSource.AUTO_DISCOVERED:
+            # 获取自动发现设备信息
+            auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+            for device in auto_discovered_devices:
+                if device["device_id"] == device_id:
+                    return device
+        
+        return None
+```
+
+### 修改后
+```python
+async def get_device(self, device_id: str) -> Optional[Dict[str, Any]]:
+    """获取指定设备（优先获取自动发现的设备，然后获取注册的设备）"""
+    try:
+        # 优先检查自动发现设备
+        device_source = await self.device_manager.get_device_source(device_id)
+        if device_source == DeviceSource.AUTO_DISCOVERED:
+            # 获取自动发现设备信息
+            auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+            for device in auto_discovered_devices:
+                if device["device_id"] == device_id:
+                    return device
+        
+        # 然后检查注册设备
+        device_info = await self.device_manager.get_device(device_id)
+        if device_info:
+            # 转换为统一格式
+            return {...}
+        
+        return None
+```
+
+**优化效果：**
+- ✅ 优先获取自动发现的设备信息
+- ✅ 然后获取注册的设备信息
+- ✅ 保持原有的错误处理和日志记录
+- ✅ 不影响其他方法的调用
+
+## 2025-08-18 修复DeviceService重大Bug：支持自动发现设备
+
+**修改内容：**
+修复 `app/services/device_service.py` 中的重大Bug，确保所有方法都能正确处理自动发现设备，而不仅仅是注册设备。
+
+**修改详情：**
+
+### 1. 修复get_all_devices方法
+```python
+# 修改前：只返回注册的设备
+async def get_all_devices(self) -> List[Device]:
+    devices = await self.device_manager.get_all_devices()
+    return devices
+
+# 修改后：返回包括注册和自动发现设备的统一列表
+async def get_all_devices(self) -> List[Dict[str, Any]]:
+    devices = await self.device_manager.get_all_devices_unified()
+    return devices
+```
+
+### 2. 修复get_device方法（重大Bug修复）
+```python
+# 修改前：只检查注册设备，自动发现设备会被误判为不存在
+async def get_device(self, device_id: str) -> Optional[Device]:
+    device_info = await self.device_manager.get_device(device_id)
+    return device_info
+
+# 修改后：同时检查注册和自动发现设备
+async def get_device(self, device_id: str) -> Optional[Dict[str, Any]]:
+    # 先检查注册设备
+    device_info = await self.device_manager.get_device(device_id)
+    if device_info:
+        return {转换为统一格式}
+    
+    # 检查自动发现设备
+    device_source = await self.device_manager.get_device_source(device_id)
+    if device_source == DeviceSource.AUTO_DISCOVERED:
+        return {获取自动发现设备信息}
+    
+    return None
+```
+
+### 3. 修复get_device_status方法（重大Bug修复）
+```python
+# 修改前：只检查注册设备，自动发现设备状态无法获取
+async def get_device_status(self, device_id: str) -> DeviceStatusResponse:
+    device = await self.device_manager.get_device(device_id)
+    if not device:
+        raise ValueError(f"设备 {device_id} 不存在")  # 自动发现设备会被误判
+
+# 修改后：同时支持注册和自动发现设备状态
+async def get_device_status(self, device_id: str) -> DeviceStatusResponse:
+    device_source = await self.device_manager.get_device_source(device_id)
+    
+    if device_source == DeviceSource.REGISTERED:
+        # 处理注册设备
+        device = await self.device_manager.get_device(device_id)
+        return DeviceStatusResponse(...)
+    else:
+        # 处理自动发现设备
+        auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+        for device in auto_discovered_devices:
+            if device["device_id"] == device_id:
+                return DeviceStatusResponse(...)
+```
+
+### 4. 修复execute_operation方法（重大Bug修复）
+```python
+# 修改前：只检查注册设备，自动发现设备操作会失败
+async def execute_operation(self, device_id: str, operation: str, **kwargs):
+    device = await self.device_manager.get_device(device_id)
+    if not device:
+        raise ValueError(f"设备 {device_id} 不存在")  # 自动发现设备会被误判
+
+# 修改后：正确处理注册和自动发现设备操作
+async def execute_operation(self, device_id: str, operation: str, **kwargs):
+    device_source = await self.device_manager.get_device_source(device_id)
+    
+    if device_source == DeviceSource.REGISTERED:
+        # 检查注册设备是否存在
+        device = await self.device_manager.get_device(device_id)
+        if not device:
+            raise ValueError(f"设备 {device_id} 不存在")
+        # 执行注册设备操作
+    else:
+        # 检查自动发现设备是否存在
+        auto_discovered_devices = await self.device_manager.get_auto_discovered_devices()
+        device_exists = any(device["device_id"] == device_id for device in auto_discovered_devices)
+        if not device_exists:
+            raise ValueError(f"设备 {device_id} 不存在")
+        # 执行自动发现设备操作
+```
+
+### 5. 更新API端点
+```python
+# 更新API端点注释，明确支持自动发现设备
+@router.get("/devices/{device_id}", summary="获取指定设备")
+async def get_device(device_id: str):
+    """获取指定设备信息（包括注册和自动发现的设备）"""
+
+@router.get("/devices/{device_id}/status", summary="获取设备状态")
+async def get_device_status(device_id: str):
+    """获取指定设备状态（包括注册和自动发现的设备）"""
+```
+
+### 6. 修复效果
+- ✅ **完整设备支持**：所有方法现在都能正确处理注册和自动发现设备
+- ✅ **设备查询修复**：`get_device` 方法不再误判自动发现设备为不存在
+- ✅ **状态查询修复**：`get_device_status` 方法能正确获取自动发现设备状态
+- ✅ **操作执行修复**：`execute_operation` 方法能正确执行自动发现设备操作
+- ✅ **统一数据格式**：所有设备都以统一的字典格式返回
+- ✅ **设备来源标识**：每个设备都包含 `source` 字段标识设备来源
+
+### 7. 技术说明
+- **设备来源检查**：使用 `get_device_source` 方法正确识别设备类型
+- **自动发现设备处理**：通过 `get_auto_discovered_devices` 方法获取自动发现设备信息
+- **错误处理完善**：确保设备不存在时抛出正确的错误信息
+- **数据格式统一**：注册和自动发现设备都转换为统一的字典格式
+
 ## 2025-08-18 请求和响应模型架构重构
 
 **修改内容：**