mobile-mcp-ai 2.1.2__py3-none-any.whl → 2.5.8__py3-none-any.whl

core/smart_app_launcher.py

@@ -1,334 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-智能App启动器 - 处理广告、弹窗、加载等待
-"""
-import asyncio
-import sys
-from typing import Dict, Optional
-
-
-class SmartAppLauncher:
-    """
-    智能App启动器
-    
-    功能：
-    1. 启动App后智能等待主页加载
-    2. 自动检测并关闭广告/弹窗
-    3. 等待网络加载完成
-    4. 智能判断是否进入主页
-    """
-    
-    def __init__(self, mobile_client):
-        """
-        初始化智能启动器
-        
-        Args:
-            mobile_client: MobileClient实例
-        """
-        self.client = mobile_client
-        
-        # 常见的广告/弹窗关闭按钮特征
-        self.ad_close_keywords = [
-            '跳过', '关闭', '×', 'X', 'x', '✕',
-            'skip', 'close', '稍后', '取消',
-            '我知道了', '不再提示', '下次再说',
-            '暂不', '以后再说', '返回'
-        ]
-        
-        # 常见的弹窗容器特征
-        self.popup_keywords = [
-            'dialog', 'popup', 'alert', 'modal',
-            '弹窗', '对话框', '提示'
-        ]
-    
-    async def launch_with_smart_wait(
-        self, 
-        package_name: str, 
-        max_wait: int = 5,  # 优化：从10秒减少到5秒
-        auto_close_ads: bool = True
-    ) -> Dict:
-        """
-        智能启动App并等待主页加载
-        
-        Args:
-            package_name: App包名
-            max_wait: 最大等待时间（秒，默认5秒）
-            auto_close_ads: 是否自动关闭广告/弹窗
-            
-        Returns:
-            启动结果
-        """
-        print(f"\n🚀 智能启动App: {package_name}", file=sys.stderr)
-        
-        try:
-            # 🎯 启动前：强制恢复竖屏（防止上次横屏残留）
-            print(f"  🔄 检查屏幕方向...", file=sys.stderr)
-            self.client.force_portrait()
-            
-            # 1. 启动App
-            print(f"  📱 正在启动...", file=sys.stderr)
-            self.client.u2.app_start(package_name)
-            await asyncio.sleep(1)  # 等待App进程启动
-            
-            # 🎯 启动后：再次强制竖屏（防止App启动时强制横屏）
-            self.client.force_portrait()
-            
-            # 2. 验证App是否启动
-            current_package = await self._get_current_package()
-            if current_package != package_name:
-                return {
-                    "success": False,
-                    "reason": f"App启动失败，当前: {current_package}，期望: {package_name}"
-                }
-            
-            print(f"  ✅ App进程已启动", file=sys.stderr)
-            
-            # 3. 智能等待主页加载（检测广告、弹窗、加载状态）
-            result = await self._wait_for_home_page(
-                package_name, 
-                max_wait=max_wait,
-                auto_close_ads=auto_close_ads
-            )
-            
-            if result['loaded']:
-                print(f"  ✅ 主页加载完成！", file=sys.stderr)
-                return {
-                    "success": True,
-                    "package": package_name,
-                    "wait_time": result['wait_time'],
-                    "ads_closed": result['ads_closed'],
-                    "popups_closed": result['popups_closed']
-                }
-            else:
-                print(f"  ⚠️  等待超时，但App已启动", file=sys.stderr)
-                return {
-                    "success": True,
-                    "package": package_name,
-                    "warning": "主页加载超时，但App已启动",
-                    "wait_time": result['wait_time'],
-                    "ads_closed": result['ads_closed'],
-                    "popups_closed": result['popups_closed']
-                }
-            
-        except Exception as e:
-            print(f"  ❌ 智能启动失败: {e}", file=sys.stderr)
-            return {
-                "success": False,
-                "reason": str(e)
-            }
-    
-    async def _wait_for_home_page(
-        self, 
-        package_name: str, 
-        max_wait: int = 5,  # 优化：从10秒减少到5秒
-        auto_close_ads: bool = True
-    ) -> Dict:
-        """
-        等待主页加载完成
-        
-        策略：
-        1. 每0.5秒检查一次页面状态
-        2. 检测广告/弹窗并自动关闭
-        3. 检测页面是否稳定（元素不再变化）
-        4. 超时后返回当前状态
-        
-        Returns:
-            {
-                "loaded": bool,  # 是否加载完成
-                "wait_time": float,  # 等待时间
-                "ads_closed": int,  # 关闭的广告数
-                "popups_closed": int  # 关闭的弹窗数
-            }
-        """
-        import time
-        start_time = time.time()
-        
-        ads_closed = 0
-        popups_closed = 0
-        last_snapshot = None
-        stable_count = 0  # 页面稳定计数（连续2次快照相同认为稳定）
-        
-        print(f"  ⏳ 等待主页加载（最多{max_wait}秒）...", file=sys.stderr)
-        
-        check_interval = 0.3  # 优化：每0.3秒检查一次（更快响应）
-        max_checks = int(max_wait / check_interval)
-        
-        for i in range(max_checks):
-            await asyncio.sleep(check_interval)
-            elapsed = time.time() - start_time
-            
-            # 检查当前包名（防止跳转到其他App）
-            current_package = await self._get_current_package()
-            if current_package != package_name:
-                print(f"  ⚠️  检测到包名变化: {package_name} -> {current_package}", file=sys.stderr)
-                # 可能跳转到其他页面（如授权页），继续等待
-                await asyncio.sleep(1)
-                continue
-            
-            # 获取页面快照
-            try:
-                snapshot = self.client.u2.dump_hierarchy()
-                
-                # 1. 检测并关闭广告/弹窗
-                if auto_close_ads:
-                    closed = await self._try_close_ads_and_popups(snapshot)
-                    if closed:
-                        ads_closed += closed
-                        print(f"  🎯 已关闭 {closed} 个广告/弹窗", file=sys.stderr)
-                        await asyncio.sleep(0.5)  # 等待关闭动画
-                        continue  # 重新检查
-                
-                # 2. 检测页面是否稳定
-                if last_snapshot and snapshot == last_snapshot:
-                    stable_count += 1
-                    if stable_count >= 2:
-                        # 页面已稳定（连续2次快照相同）
-                        print(f"  ✅ 页面稳定，加载完成（耗时{elapsed:.1f}秒）", file=sys.stderr)
-                        return {
-                            "loaded": True,
-                            "wait_time": elapsed,
-                            "ads_closed": ads_closed,
-                            "popups_closed": popups_closed
-                        }
-                else:
-                    stable_count = 0
-                
-                last_snapshot = snapshot
-                
-                # 优化：每1.5秒打印一次等待进度（从2秒减少）
-                if i % 5 == 0 and i > 0:  # 5 * 0.3秒 = 1.5秒
-                    print(f"  ⏳ 等待中... ({elapsed:.1f}秒)", file=sys.stderr)
-            
-            except Exception as e:
-                print(f"  ⚠️  检查页面状态失败: {e}", file=sys.stderr)
-                continue
-        
-        # 超时
-        elapsed = time.time() - start_time
-        print(f"  ⏰ 等待超时（{elapsed:.1f}秒），但App已启动", file=sys.stderr)
-        return {
-            "loaded": False,
-            "wait_time": elapsed,
-            "ads_closed": ads_closed,
-            "popups_closed": popups_closed
-        }
-    
-    async def _try_close_ads_and_popups(self, snapshot: str) -> int:
-        """
-        尝试关闭广告和弹窗（更谨慎的检测逻辑）
-        
-        Args:
-            snapshot: 页面XML快照
-            
-        Returns:
-            关闭的数量
-        """
-        closed_count = 0
-        
-        try:
-            # 解析XML查找关闭按钮
-            elements = self.client.xml_parser.parse(snapshot)
-            
-            # 🎯 改进：先检测是否有弹窗容器（避免误点击正常UI）
-            has_popup = False
-            for elem in elements:
-                class_name = elem.get('class', '').lower()
-                resource_id = elem.get('resource_id', '').lower()
-                # 检查是否是弹窗容器
-                if any(keyword in class_name or keyword in resource_id 
-                       for keyword in ['dialog', 'popup', 'alert', 'modal']):
-                    has_popup = True
-                    break
-            
-            # 如果没有检测到弹窗容器，不执行关闭操作（避免误点击）
-            if not has_popup:
-                return 0
-            
-            # 查找可能的关闭按钮
-            close_buttons = []
-            
-            for elem in elements:
-                if not elem.get('clickable', False):
-                    continue
-                
-                text = elem.get('text', '').lower()
-                content_desc = elem.get('content_desc', '').lower()
-                resource_id = elem.get('resource_id', '').lower()
-                bounds = elem.get('bounds', '')
-                
-                # 检查是否是关闭按钮
-                is_close_button = False
-                for keyword in self.ad_close_keywords:
-                    keyword_lower = keyword.lower()
-                    if (keyword_lower in text or 
-                        keyword_lower in content_desc or
-                        keyword_lower in resource_id or
-                        ('close' in resource_id and 'btn' in resource_id) or
-                        ('skip' in resource_id)):
-                        is_close_button = True
-                        break
-                
-                # 🎯 改进：优先选择右上角的关闭按钮（更可能是真正的关闭按钮）
-                if is_close_button and bounds:
-                    import re
-                    match = re.search(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
-                    if match:
-                        x1, y1, x2, y2 = map(int, match.groups())
-                        # 计算元素位置（右上角区域优先级更高）
-                        elem['_priority'] = 0
-                        if x1 > 800:  # 右侧
-                            elem['_priority'] += 2
-                        if y1 < 500:  # 上部
-                            elem['_priority'] += 2
-                        close_buttons.append(elem)
-
-            
-            # 🎯 改进：按优先级排序（右上角的关闭按钮优先）
-            close_buttons.sort(key=lambda x: x.get('_priority', 0), reverse=True)
-            
-            # 尝试点击关闭按钮（最多尝试1个，避免误点击）
-            for button in close_buttons[:1]:  # 🎯 改进：只点击优先级最高的1个
-                try:
-                    # 优先使用bounds点击（更可靠）
-                    bounds = button.get('bounds', '')
-                    if bounds:
-                        # 解析bounds并点击中心点
-                        import re
-                        match = re.search(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
-                        if match:
-                            x1, y1, x2, y2 = map(int, match.groups())
-                            center_x = (x1 + x2) // 2
-                            center_y = (y1 + y2) // 2
-                            
-                            button_desc = button.get('text') or button.get('content_desc') or '未知'
-                            print(f"  🎯 检测到弹窗，准备点击关闭按钮: {button_desc} (位置: {center_x}, {center_y})", file=sys.stderr)
-                            
-                            # 🎯 改进：延迟1秒再点击（给用户时间看清楚）
-                            await asyncio.sleep(1.0)
-                            
-                            self.client.u2.click(center_x, center_y)
-                            closed_count += 1
-                            
-                            print(f"  ✅ 已关闭弹窗: {button_desc}", file=sys.stderr)
-                            
-                            await asyncio.sleep(0.5)  # 等待关闭动画
-                
-                except Exception as e:
-                    print(f"  ⚠️  点击关闭按钮失败: {e}", file=sys.stderr)
-                    continue
-            
-            return closed_count
-            
-        except Exception as e:
-            print(f"  ⚠️  关闭广告/弹窗失败: {e}", file=sys.stderr)
-            return 0
-    
-    async def _get_current_package(self) -> Optional[str]:
-        """获取当前包名"""
-        try:
-            info = self.client.u2.app_current()
-            return info.get('package')
-        except:
-            return None
-

core/smart_tools.py

@@ -1,311 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-智能 MCP 工具 - 需要 AI 密钥（可选功能）
-
-提供智能定位和分析功能：
-- 自然语言元素定位
-- 智能元素识别
-- 复杂场景分析
-
-⚠️ 这些功能需要配置 AI 密钥才能使用
-"""
-
-from typing import Dict, Optional
-import os
-
-
-class SmartMobileTools:
-    """智能移动端工具（需要 AI 密钥）"""
-    
-    def __init__(self, mobile_client):
-        """
-        初始化智能工具
-        
-        Args:
-            mobile_client: MobileClient 实例
-        """
-        self.client = mobile_client
-        self.ai_available = self._check_ai_available()
-        
-        if self.ai_available:
-            # 延迟导入，避免没有配置 AI 时报错
-            from .locator.mobile_smart_locator import MobileSmartLocator
-            self.smart_locator = MobileSmartLocator(mobile_client)
-        else:
-            self.smart_locator = None
-    
-    def _check_ai_available(self) -> bool:
-        """检查 AI 是否可用（是否配置了 AI 密钥）"""
-        try:
-            from dotenv import load_dotenv
-            load_dotenv()
-            
-            ai_provider = os.getenv('AI_PROVIDER', '')
-            
-            # 检查是否配置了任何 AI 提供商
-            if ai_provider in ['qwen', 'openai', 'claude', 'ollama']:
-                # 检查对应的 API Key
-                if ai_provider == 'qwen' and os.getenv('QWEN_API_KEY'):
-                    return True
-                elif ai_provider == 'openai' and os.getenv('OPENAI_API_KEY'):
-                    return True
-                elif ai_provider == 'claude' and os.getenv('ANTHROPIC_API_KEY'):
-                    return True
-                elif ai_provider == 'ollama':
-                    return True  # Ollama 不需要 API Key
-            
-            return False
-        except:
-            return False
-    
-    def _ensure_ai_available(self):
-        """确保 AI 可用，否则抛出友好的错误提示"""
-        if not self.ai_available:
-            raise ValueError(
-                "❌ 智能定位功能需要配置 AI 密钥！\n\n"
-                "请选择以下方案之一：\n\n"
-                "方案1：使用基础工具（推荐，不需要 AI）\n"
-                "  - mobile_list_elements() - 列出所有元素\n"
-                "  - mobile_click_by_id(resource_id) - 通过 ID 点击\n"
-                "  - mobile_click_at_coords(x, y) - 通过坐标点击\n\n"
-                "方案2：配置 AI 密钥（启用智能功能）\n"
-                "  创建 .env 文件：\n"
-                "  AI_PROVIDER=qwen\n"
-                "  QWEN_API_KEY=your-api-key\n\n"
-                "详见: backend/mobile_mcp/AI_SETUP.md"
-            )
-    
-    async def smart_click(self, description: str) -> Dict:
-        """
-        智能定位并点击元素（需要 AI 密钥）
-        
-        Args:
-            description: 元素的自然语言描述（如 "顶部搜索框"、"登录按钮"）
-        
-        Returns:
-            {"success": true/false, "message": "...", "method": "..."}
-        
-        示例：
-            # 需要先配置 AI 密钥
-            result = await tools.smart_click("右上角的设置按钮")
-        
-        ⚠️ 如果没有配置 AI 密钥，请使用基础工具：
-            elements = mobile_list_elements()
-            mobile_click_by_id("com.app:id/settings")
-        """
-        self._ensure_ai_available()
-        
-        try:
-            # 使用智能定位器
-            result = await self.smart_locator.locate(description)
-            
-            if result and result.get('ref'):
-                # 执行点击
-                ref = result['ref']
-                method = result.get('method', 'unknown')
-                
-                # 根据不同的 ref 类型执行点击
-                if ref.startswith('[') and ']' in ref:
-                    # bounds 坐标
-                    import re
-                    coords = re.findall(r'\[(\d+),(\d+)\]', ref)
-                    if coords:
-                        x1, y1 = int(coords[0][0]), int(coords[0][1])
-                        x2, y2 = int(coords[1][0]), int(coords[1][1])
-                        x, y = (x1 + x2) // 2, (y1 + y2) // 2
-                        self.client.u2.click(x, y)
-                        return {
-                            "success": True,
-                            "message": f"智能定位成功: {description}",
-                            "method": method,
-                            "ref": ref
-                        }
-                elif ':id/' in ref:
-                    # resource-id
-                    self.client.u2(resourceId=ref).click()
-                    return {
-                        "success": True,
-                        "message": f"智能定位成功: {description}",
-                        "method": method,
-                        "ref": ref
-                    }
-                else:
-                    # text
-                    self.client.u2(text=ref).click()
-                    return {
-                        "success": True,
-                        "message": f"智能定位成功: {description}",
-                        "method": method,
-                        "ref": ref
-                    }
-            else:
-                return {
-                    "success": False,
-                    "message": f"智能定位失败: {description}",
-                    "suggestion": "请使用 mobile_list_elements() 查看页面元素，然后使用 mobile_click_by_id()"
-                }
-        except Exception as e:
-            return {
-                "success": False,
-                "message": f"智能点击失败: {str(e)}",
-                "suggestion": "建议使用基础工具: mobile_list_elements() + mobile_click_by_id()"
-            }
-    
-    async def smart_input(self, description: str, text: str) -> Dict:
-        """
-        智能定位输入框并输入文本（需要 AI 密钥）
-        
-        Args:
-            description: 输入框的自然语言描述（如 "用户名输入框"）
-            text: 要输入的文本
-        
-        Returns:
-            {"success": true/false, "message": "..."}
-        
-        示例：
-            result = await tools.smart_input("邮箱输入框", "test@example.com")
-        
-        ⚠️ 如果没有配置 AI 密钥，请使用基础工具：
-            mobile_input_text_by_id("com.app:id/email_input", "test@example.com")
-        """
-        self._ensure_ai_available()
-        
-        try:
-            # 使用智能定位器
-            result = await self.smart_locator.locate(description)
-            
-            if result and result.get('ref'):
-                ref = result['ref']
-                
-                # 根据不同的 ref 类型执行输入
-                if ':id/' in ref:
-                    # resource-id
-                    element = self.client.u2(resourceId=ref)
-                    element.set_text(text)
-                    return {
-                        "success": True,
-                        "message": f"智能输入成功: {description} = {text}",
-                        "ref": ref
-                    }
-                else:
-                    return {
-                        "success": False,
-                        "message": f"定位成功但无法输入: {ref}",
-                        "suggestion": "请使用 mobile_find_elements_by_class('android.widget.EditText') 查找输入框"
-                    }
-            else:
-                return {
-                    "success": False,
-                    "message": f"智能定位失败: {description}",
-                    "suggestion": "请使用 mobile_list_elements() 查找输入框，然后使用 mobile_input_text_by_id()"
-                }
-        except Exception as e:
-            return {
-                "success": False,
-                "message": f"智能输入失败: {str(e)}",
-                "suggestion": "建议使用基础工具: mobile_input_text_by_id()"
-            }
-    
-    async def analyze_screenshot_with_ai(self, screenshot_path: str, description: str) -> Dict:
-        """
-        使用 AI 分析截图并返回坐标（需要 AI 密钥）
-        
-        Args:
-            screenshot_path: 截图文件路径
-            description: 要查找的元素描述
-        
-        Returns:
-            {
-                "success": true/false,
-                "x": 坐标X（如果成功）,
-                "y": 坐标Y（如果成功）,
-                "confidence": 置信度,
-                "message": "..."
-            }
-        
-        示例：
-            # 先截图
-            screenshot = mobile_take_screenshot("登录页面")
-            
-            # 然后用 AI 分析
-            result = await tools.analyze_screenshot_with_ai(
-                screenshot['screenshot_path'],
-                "登录按钮"
-            )
-            
-            # 根据返回的坐标点击
-            if result['success']:
-                mobile_click_at_coords(result['x'], result['y'])
-        
-        ⚠️ 需要配置支持视觉识别的 AI（如 GPT-4V、Claude 3、Qwen-VL）
-        """
-        self._ensure_ai_available()
-        
-        try:
-            # 尝试使用视觉识别
-            try:
-                from ..vision.vision_locator import MobileVisionLocator
-                
-                vision_locator = MobileVisionLocator(self.client)
-                result = await vision_locator.locate_element_by_vision(
-                    description,
-                    screenshot_path=screenshot_path
-                )
-                
-                if result and result.get('found'):
-                    x, y = result['x'], result['y']
-                    confidence = result['confidence']
-                    
-                    return {
-                        "success": True,
-                        "x": x,
-                        "y": y,
-                        "confidence": confidence,
-                        "message": f"✅ AI 视觉识别成功: ({x}, {y}), 置信度 {confidence}%"
-                    }
-                else:
-                    reason = result.get('reason', '未知原因') if result else '未知原因'
-                    return {
-                        "success": False,
-                        "message": f"❌ AI 视觉识别未找到元素: {reason}",
-                        "suggestion": "请检查截图和元素描述是否准确"
-                    }
-            except ImportError:
-                return {
-                    "success": False,
-                    "message": "❌ 视觉识别模块未安装",
-                    "suggestion": "安装：pip install dashscope pillow"
-                }
-        except Exception as e:
-            return {
-                "success": False,
-                "message": f"❌ 视觉识别失败: {str(e)}",
-                "suggestion": "请使用基础工具或检查 AI 配置"
-            }
-    
-    def get_ai_status(self) -> Dict:
-        """
-        获取 AI 功能状态
-        
-        Returns:
-            {
-                "available": true/false,
-                "provider": "qwen/openai/...",
-                "message": "..."
-            }
-        """
-        if self.ai_available:
-            provider = os.getenv('AI_PROVIDER', 'unknown')
-            return {
-                "available": True,
-                "provider": provider,
-                "message": f"✅ AI 功能已启用 (Provider: {provider})"
-            }
-        else:
-            return {
-                "available": False,
-                "provider": None,
-                "message": "⚠️ AI 功能未配置，当前仅支持基础工具。如需启用智能定位，请配置 AI 密钥。"
-            }
-

mcp/__init__.py

@@ -1,8 +0,0 @@
-"""
-Mobile MCP Server Package
-"""
-from .mcp_server import MobileMCPServer
-
-__all__ = ['MobileMCPServer']
-
-