mobile-mcp-ai 2.6.10__py3-none-any.whl → 2.7.0__py3-none-any.whl

mobile_mcp/core/basic_tools_lite.py

@@ -8,112 +8,28 @@
 - 核心功能精简
 - 保留 pytest 脚本生成
 - 支持操作历史记录
+- Token 优化模式（省钱）
 """
 
 import asyncio
 import time
 import re
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Optional
 from datetime import datetime
 
-
-# ==================== 弹窗检测配置常量 ====================
-
-# 确认性按钮文本（最高优先级 - 优先点击这些按钮关闭弹窗）
-CONFIRM_BUTTON_TEXTS = [
-    # 中文确认类
-    '同意', '同意并继续', '同意协议', '我同意', '同意条款',
-    '确认', '确定', '好的', '好', '知道了', '我知道了', '明白了',
-    '允许', '始终允许', '仅在使用中允许', '仅本次允许',
-    '立即体验', '立即开始', '开始使用', '马上体验',
-    '去设置', '立即更新', '立即升级', '现在更新',
-    'OK', 'Ok', 'ok', 'Yes', 'YES', 'yes',
-    'Accept', 'ACCEPT', 'accept', 'Agree', 'AGREE', 'agree',
-    'Allow', 'ALLOW', 'allow', 'Confirm', 'CONFIRM', 'confirm',
-    'Got it', 'GOT IT', 'Done', 'DONE', 'Continue', 'CONTINUE',
-]
-
-# 关闭/取消按钮文本（次优先级 - 当没有确认按钮时使用）
-CLOSE_BUTTON_TEXTS = [
-    # 符号类
-    '×', 'X', 'x', '✕', '✖', '╳',
-    # 中文关闭/拒绝类
-    '关闭', '取消', '跳过', '放弃', '算了', '忽略', '不了', '拒绝', '否',
-    '稍后再说', '下次再说', '以后再说', '暂不需要', '不再提示', 
-    '不要', '残忍拒绝', '狠心离开', '我再想想', '暂不',
-    '不感兴趣', '跳过广告', '稍后更新',
-    '不同意', '仍不同意', '不同意并退出',  # 这些优先级最低
-    # 英文关闭/拒绝类
-    'close', 'Close', 'CLOSE', 'Skip', 'skip', 'SKIP',
-    'Dismiss', 'dismiss', 'Cancel', 'cancel', 'CANCEL',
-    'Not now', 'NOT NOW', 'Later', 'later', 'LATER',
-    'No thanks', 'NO THANKS', 'No', 'NO', 'no',
-    'Ignore', 'IGNORE', 'Deny', 'DENY', 'Reject', 'REJECT',
-]
-
-# 关闭按钮描述关键词（模糊匹配 content-desc / resource-id）
-# 确认类关键词（优先）
-CONFIRM_BUTTON_KEYWORDS = [
-    'confirm', 'accept', 'agree', 'allow', 'ok', 'yes', 'done',
-    '确认', '同意', '允许', '确定',
-]
-
-# 关闭类关键词（次优先）
-CLOSE_BUTTON_KEYWORDS = [
-    'close', 'dismiss', 'cancel', 'skip', 'ignore', 'deny', 'reject',
-    '关闭', '取消', '跳过', '忽略', '拒绝',
-]
-
-# 弹窗检测 - class 名称关键词（强特征）
-POPUP_CLASS_KEYWORDS = [
-    'Dialog', 'Popup', 'Alert', 'Modal', 'BottomSheet', 
-    'PopupWindow', 'DialogFragment', 'AlertDialog',
-]
-
-# 弹窗检测 - resource-id 关键词（强特征）
-POPUP_ID_KEYWORDS = [
-    'dialog', 'popup', 'alert', 'modal', 'bottom_sheet', 
-    'overlay', 'mask', 'dim', 'scrim',
-]
-
-# 广告弹窗 resource-id 关键词
-AD_POPUP_KEYWORDS = [
-    'ad_close', 'ad_button', 'full_screen', 'interstitial', 
-    'reward', 'close_icon', 'close_btn', 'ad_container',
-    'splash', 'banner', 'native_ad',
-]
-
-# 小元素排除关键词（避免误点）
-EXCLUDE_ELEMENT_KEYWORDS = [
-    # 功能按钮
-    'more', 'menu', 'setting', 'settings', 'option', 'options',
-    'share', 'favorite', 'like', 'comment', 'follow', 'download',
-    'search', 'back', 'home', 'profile', 'notification', 'message',
-    # 播放控制
-    'play', 'pause', 'next', 'previous', 'volume', 'fullscreen',
-    'mute', 'unmute', 'forward', 'rewind', 'seek',
-    # 导航
-    'tab', 'navigation', 'drawer', 'sidebar',
-    # 编辑
-    'edit', 'delete', 'copy', 'paste', 'cut', 'select',
-]
-
-# 页面内容特征关键词（非弹窗）
-PAGE_CONTENT_KEYWORDS = [
-    'video', 'player', 'recycler', 'list', 'scroll', 
-    'viewpager', 'fragment', 'webview', 'content',
-]
-
-# 弹窗检测默认置信度阈值
-DEFAULT_POPUP_CONFIDENCE_THRESHOLD = 0.6
-
-# iOS 弹窗元素类型
-IOS_POPUP_TYPES = [
-    'XCUIElementTypeAlert',
-    'XCUIElementTypeSheet',
-    'XCUIElementTypePopover',
-]
+# Token 优化配置（只精简格式，不限制数量，确保准确度）
+try:
+    from mobile_mcp.config import Config
+    TOKEN_OPTIMIZATION = Config.TOKEN_OPTIMIZATION_ENABLED
+    MAX_ELEMENTS = Config.MAX_ELEMENTS_RETURN
+    MAX_SOM_ELEMENTS = Config.MAX_SOM_ELEMENTS_RETURN
+    COMPACT_RESPONSE = Config.COMPACT_RESPONSE
+except ImportError:
+    TOKEN_OPTIMIZATION = True
+    MAX_ELEMENTS = 0  # 0 = 不限制
+    MAX_SOM_ELEMENTS = 0  # 0 = 不限制
+    COMPACT_RESPONSE = True
 
 
 class BasicMobileToolsLite:
@@ -433,7 +349,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 self.client.u2.screenshot(str(temp_path))
                 info = self.client.u2.info
@@ -484,22 +400,14 @@ class BasicMobileToolsLite:
                 
                 cropped_size = final_path.stat().st_size
                 
+                # 返回结果
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
-                    "screen_width": screen_width,
-                    "screen_height": screen_height,
                     "image_width": img.width,
                     "image_height": img.height,
                     "crop_offset_x": crop_offset_x,
-                    "crop_offset_y": crop_offset_y,
-                    "file_size": f"{cropped_size/1024:.1f}KB",
-                    "message": f"🔍 局部截图已保存: {final_path}\n"
-                              f"📐 裁剪区域: ({crop_offset_x}, {crop_offset_y}) 起，{img.width}x{img.height} 像素\n"
-                              f"📦 文件大小: {cropped_size/1024:.0f}KB\n"
-                              f"🎯 【坐标换算】AI 返回坐标 (x, y) 后：\n"
-                              f"   实际屏幕坐标 = ({crop_offset_x} + x, {crop_offset_y} + y)\n"
-                              f"   或直接调用 mobile_click_at_coords(x, y, crop_offset_x={crop_offset_x}, crop_offset_y={crop_offset_y})"
+                    "crop_offset_y": crop_offset_y
                 }
             
             # ========== 情况2：全屏压缩截图 ==========
@@ -552,24 +460,14 @@ class BasicMobileToolsLite:
                 compressed_size = final_path.stat().st_size
                 saved_percent = (1 - compressed_size / original_size) * 100
                 
+                # 返回结果
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
-                    "screen_width": screen_width,
-                    "screen_height": screen_height,
-                    "original_img_width": original_img_width,    # 截图原始宽度
-                    "original_img_height": original_img_height,  # 截图原始高度
-                    "image_width": image_width,                  # 压缩后宽度（AI 看到的）
-                    "image_height": image_height,                # 压缩后高度（AI 看到的）
-                    "original_size": f"{original_size/1024:.1f}KB",
-                    "compressed_size": f"{compressed_size/1024:.1f}KB",
-                    "saved_percent": f"{saved_percent:.0f}%",
-                    "message": f"📸 截图已保存: {final_path}\n"
-                              f"📐 原始尺寸: {original_img_width}x{original_img_height} → 压缩后: {image_width}x{image_height}\n"
-                              f"📦 已压缩: {original_size/1024:.0f}KB → {compressed_size/1024:.0f}KB (省 {saved_percent:.0f}%)\n"
-                              f"⚠️ 【坐标转换】AI 返回坐标后，请传入：\n"
-                              f"   image_width={image_width}, image_height={image_height},\n"
-                              f"   original_img_width={original_img_width}, original_img_height={original_img_height}"
+                    "image_width": image_width,
+                    "image_height": image_height,
+                    "original_img_width": original_img_width,
+                    "original_img_height": original_img_height
                 }
             
             # ========== 情况3：全屏不压缩截图 ==========
@@ -583,21 +481,12 @@ class BasicMobileToolsLite:
                 final_path = self.screenshot_dir / filename
                 temp_path.rename(final_path)
                 
-                # 不压缩时，用截图实际尺寸（可能和 screen_width 不同）
+                # 返回结果（不压缩时尺寸相同）
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
-                    "screen_width": screen_width,
-                    "screen_height": screen_height,
-                    "original_img_width": img.width,   # 截图实际尺寸
-                    "original_img_height": img.height,
-                    "image_width": img.width,          # 未压缩，和原图一样
-                    "image_height": img.height,
-                    "file_size": f"{original_size/1024:.1f}KB",
-                    "message": f"📸 截图已保存: {final_path}\n"
-                              f"📐 截图尺寸: {img.width}x{img.height}\n"
-                              f"📦 文件大小: {original_size/1024:.0f}KB（未压缩）\n"
-                              f"💡 未压缩，坐标可直接使用"
+                    "image_width": img.width,
+                    "image_height": img.height
                 }
         except ImportError:
             # 如果没有 PIL，回退到原始方式（不压缩）
@@ -609,15 +498,11 @@ class BasicMobileToolsLite:
         """截图并添加网格坐标标注（用于精确定位元素）
         
         在截图上绘制网格线和坐标刻度，帮助快速定位元素位置。
-        
-        🎯 弹窗检测场景：
-        - show_popup_hints=True: 明确弹窗场景时使用（如调用 mobile_close_popup 前）
-        - show_popup_hints=False: 普通截图，不检测弹窗
+        如果检测到弹窗，会标注弹窗区域和可能的关闭按钮位置。
         
         Args:
             grid_size: 网格间距（像素），默认 100。建议值：50-200
-            show_popup_hints: 是否显示弹窗关闭按钮提示位置，默认 False
-                仅在明确弹窗场景时设置为 True，会标注弹窗区域和可能的关闭按钮位置。
+            show_popup_hints: 是否显示弹窗关闭按钮提示位置，默认 True
         
         Returns:
             包含标注截图路径和弹窗信息的字典
@@ -641,7 +526,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 self.client.u2.screenshot(str(temp_path))
                 info = self.client.u2.info
@@ -755,26 +640,16 @@ class BasicMobileToolsLite:
             result = {
                 "success": True,
                 "screenshot_path": str(final_path),
-                "screen_width": screen_width,
-                "screen_height": screen_height,
                 "image_width": img_width,
                 "image_height": img_height,
-                "grid_size": grid_size,
-                "message": f"📸 网格截图已保存: {final_path}\n"
-                          f"📐 尺寸: {img_width}x{img_height}\n"
-                          f"📏 网格间距: {grid_size}px"
+                "grid_size": grid_size
             }
             
             if popup_info:
-                result["popup_detected"] = True
-                result["popup_bounds"] = popup_info["bounds"]
-                result["close_button_hints"] = close_positions
-                result["message"] += f"\n🎯 检测到弹窗: {popup_info['bounds']}"
-                result["message"] += f"\n💡 可能的关闭按钮位置（绿色圆圈标注）："
-                for pos in close_positions:
-                    result["message"] += f"\n   {pos['priority']}. {pos['name']}: ({pos['x']}, {pos['y']})"
-            else:
-                result["popup_detected"] = False
+                result["popup"] = popup_info["bounds"]
+                # 只返回前3个最可能的关闭按钮位置
+                if close_positions:
+                    result["close_hints"] = [(p['x'], p['y']) for p in close_positions[:3]]
             
             return result
             
@@ -783,17 +658,12 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "message": f"❌ 网格截图失败: {e}"}
     
-    def take_screenshot_with_som(self, check_popup: bool = False) -> Dict:
+    def take_screenshot_with_som(self) -> Dict:
         """Set-of-Mark 截图：给每个可点击元素标上数字（超级好用！）
         
         在截图上给每个可点击元素画框并标上数字编号。
         AI 看图后直接说"点击 3 号"，然后调用 click_by_som(3) 即可。
         
-        Args:
-            check_popup: 是否检测弹窗，默认 False
-                        - True: 明确弹窗场景时使用（如调用 mobile_close_popup 前）
-                        - False: 普通截图，不检测弹窗
-        
         Returns:
             包含标注截图和元素列表的字典
         """
@@ -816,7 +686,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 self.client.u2.screenshot(str(temp_path))
                 info = self.client.u2.info
@@ -930,12 +800,11 @@ class BasicMobileToolsLite:
                     'resource_id': elem.get('resource_id', '')
                 })
             
-            # 第3.5步：检测弹窗区域（仅在明确弹窗场景时检测）
+            # 第3.5步：检测弹窗区域（使用严格的置信度检测，避免误识别普通页面）
             popup_bounds = None
             popup_confidence = 0
             
-            # 🎯 明确弹窗检测场景：只在 check_popup=True 时检测（明确弹窗场景）
-            if check_popup and not self._is_ios():
+            if not self._is_ios():
                 try:
                     # 使用严格的弹窗检测（置信度 >= 0.6 才认为是弹窗）
                     popup_bounds, popup_confidence = self._detect_popup_with_confidence(
@@ -977,154 +846,22 @@ class BasicMobileToolsLite:
             img.save(str(final_path), "JPEG", quality=85)
             temp_path.unlink()
             
-            # 构建元素列表文字
-            elements_text = "\n".join([
-                f"  [{e['index']}] {e['desc']} → ({e['center'][0]}, {e['center'][1]})"
-                for e in som_elements[:15]  # 只显示前15个
-            ])
-            if len(som_elements) > 15:
-                elements_text += f"\n  ... 还有 {len(som_elements) - 15} 个元素"
-            
-            # 构建弹窗提示文字
-            hints_text = ""
-            if popup_bounds:
-                hints_text = f"\n🎯 检测到弹窗区域（蓝色边框）\n"
-                hints_text += f"   如需关闭弹窗，请观察图片中的 X 按钮位置\n"
-                hints_text += f"   然后使用 mobile_click_by_percent(x%, y%) 点击"
-            
-            # 第5步：AI 分析图片内容（使用 Cursor AI 视觉能力）
-            ai_analysis = None
-            try:
-                ai_analysis = self._analyze_screenshot_with_ai(
-                    str(final_path), screen_width, screen_height, img_width, img_height
-                )
-            except Exception as e:
-                # AI 分析失败不影响主功能
-                pass
-            
-            # 构建返回消息
-            message = f"📸 SoM 截图已保存: {final_path}\n"
-            message += f"🏷️ 已标注 {len(som_elements)} 个可点击元素\n"
-            message += f"📋 元素列表：\n{elements_text}{hints_text}\n\n"
-            
-            # 添加 AI 分析提示（实际分析由 Cursor AI 在看到图片后自动完成）
-            if ai_analysis:
-                screenshot_path_for_ai = ai_analysis.get('screenshot_path', str(final_path))
-                message += f"\n🤖 【AI 视觉分析请求】\n"
-                message += f"📸 截图路径: {screenshot_path_for_ai}\n"
-                message += f"📐 屏幕尺寸: {screen_width}x{screen_height}，图片尺寸: {img_width}x{img_height}\n\n"
-                message += f"请分析这张截图：\n"
-                message += f"1. 识别页面主要内容\n"
-                message += f"2. 检测是否有弹窗（对话框、提示框、广告、教程弹窗等）\n"
-                message += f"3. 如果有弹窗，识别关闭按钮位置（×、关闭、知道了、好的、同意等）\n"
-                message += f"4. 返回关闭按钮的精确位置：\n"
-                message += f"   - 像素坐标 (x, y)\n"
-                message += f"   - 百分比坐标 (x_percent, y_percent)\n"
-                message += f"   - 按钮文本（如'知道了'、'好的'等）\n\n"
-                message += f"💡 分析结果格式（JSON）：\n"
-                message += f"{{\n"
-                message += f"  \"has_popup\": true/false,\n"
-                message += f"  \"popup_description\": \"弹窗描述\",\n"
-                message += f"  \"close_button\": {{\n"
-                message += f"    \"x\": 像素X坐标,\n"
-                message += f"    \"y\": 像素Y坐标,\n"
-                message += f"    \"x_percent\": X百分比(0-100),\n"
-                message += f"    \"y_percent\": Y百分比(0-100),\n"
-                message += f"    \"text\": \"按钮文本\"\n"
-                message += f"  }}\n"
-                message += f"}}\n"
-            
-            message += f"💡 使用方法：\n"
-            message += f"   - 点击标注元素：mobile_click_by_som(编号)\n"
-            message += f"   - 点击任意位置：mobile_click_by_percent(x%, y%)"
-            
-            result = {
+            # 返回结果（Token 优化：不返回 elements 列表，已存储在 self._som_elements）
+            return {
                 "success": True,
                 "screenshot_path": str(final_path),
                 "screen_width": screen_width,
                 "screen_height": screen_height,
-                "image_width": img_width,
-                "image_height": img_height,
                 "element_count": len(som_elements),
-                "elements": som_elements,
                 "popup_detected": popup_bounds is not None,
-                "popup_bounds": f"[{popup_bounds[0]},{popup_bounds[1]}][{popup_bounds[2]},{popup_bounds[3]}]" if popup_bounds else None,
-                "message": message
+                "hint": "查看截图上的编号，用 click_by_som(编号) 点击"
             }
             
-            # 添加 AI 分析结果到返回字典
-            if ai_analysis:
-                result["ai_analysis"] = ai_analysis
-            
-            return result
-            
         except ImportError:
             return {"success": False, "message": "❌ 需要安装 Pillow: pip install Pillow"}
         except Exception as e:
             return {"success": False, "message": f"❌ SoM 截图失败: {e}"}
     
-    def _analyze_screenshot_with_ai(self, screenshot_path: str, screen_width: int, screen_height: int, 
-                                     image_width: int, image_height: int) -> Optional[Dict]:
-        """准备 AI 分析截图内容
-        
-        在 MCP 环境中，返回图片路径和分析提示，让 Cursor AI 自动分析图片。
-        实际的 AI 分析由 Cursor AI 在看到图片后自动完成。
-        
-        Args:
-            screenshot_path: 截图文件路径
-            screen_width: 屏幕宽度
-            screen_height: 屏幕高度
-            image_width: 图片宽度
-            image_height: 图片高度
-            
-        Returns:
-            AI 分析准备信息字典
-        """
-        try:
-            from pathlib import Path
-            
-            # 检查图片文件是否存在
-            img_path = Path(screenshot_path)
-            if not img_path.exists():
-                return None
-            
-            # 返回分析准备信息
-            # 注意：实际的 AI 分析由 Cursor AI 在看到图片后自动完成
-            return {
-                "needs_ai_analysis": True,
-                "screenshot_path": screenshot_path,
-                "screen_size": {"width": screen_width, "height": screen_height},
-                "image_size": {"width": image_width, "height": image_height},
-                "analysis_instructions": (
-                    "🤖 【AI 视觉分析请求】\n"
-                    "请分析截图文件: {}\n\n"
-                    "分析要求：\n"
-                    "1. 识别页面主要内容\n"
-                    "2. 检测是否有弹窗（对话框、提示框、广告、教程弹窗等）\n"
-                    "3. 如果有弹窗，识别关闭按钮位置（×、关闭、知道了、好的、同意等）\n"
-                    "4. 返回关闭按钮的精确位置：\n"
-                    "   - 像素坐标 (x, y)\n"
-                    "   - 百分比坐标 (x_percent, y_percent)\n"
-                    "   - 按钮文本（如'知道了'、'好的'等）\n\n"
-                    "屏幕尺寸: {}x{}，图片尺寸: {}x{}\n\n"
-                    "请以 JSON 格式返回分析结果：\n"
-                    "{{\n"
-                    "  \"has_popup\": true/false,\n"
-                    "  \"popup_description\": \"弹窗描述\",\n"
-                    "  \"close_button\": {{\n"
-                    "    \"x\": 像素X坐标,\n"
-                    "    \"y\": 像素Y坐标,\n"
-                    "    \"x_percent\": X百分比(0-100),\n"
-                    "    \"y_percent\": Y百分比(0-100),\n"
-                    "    \"text\": \"按钮文本\"\n"
-                    "  }}\n"
-                    "}}"
-                ).format(screenshot_path, screen_width, screen_height, image_width, image_height)
-            }
-        except Exception as e:
-            # AI 分析准备失败不影响主功能
-            return None
-    
     def click_by_som(self, index: int) -> Dict:
         """根据 SoM 编号点击元素
         
@@ -1198,7 +935,6 @@ class BasicMobileToolsLite:
 
             return {
                 "success": True,
-                "message": f"✅ 已点击 [{index}] {target['desc']} → ({cx}, {cy})\n💡 建议：再次截图确认操作是否成功",
                 "clicked": {
                     "index": index,
                     "desc": target['desc'],
@@ -1208,23 +944,7 @@ class BasicMobileToolsLite:
             }
             
         except Exception as e:
-            # 🎯 异常情况：点击失败时检测弹窗
-            popup_detected = False
-            popup_hint = ""
-            if not self._is_ios():
-                try:
-                    page_analysis = self._analyze_page_for_popup()
-                    if page_analysis.get("has_popup"):
-                        popup_detected = True
-                        popup_hint = "\n🎯 检测到弹窗（异常情况），可能影响操作，建议先调用 mobile_close_popup() 关闭弹窗"
-                except Exception:
-                    pass
-            
-            error_msg = f"❌ 点击失败: {e}\n💡 如果页面已变化，请重新调用 mobile_screenshot_with_som 刷新元素列表"
-            if popup_detected:
-                error_msg += popup_hint
-            
-            return {"success": False, "message": error_msg, "popup_detected": popup_detected}
+            return {"success": False, "message": f"❌ 点击失败: {e}\n💡 如果页面已变化，请重新调用 mobile_screenshot_with_som 刷新元素列表"}
     
     def _take_screenshot_no_compress(self, description: str = "") -> Dict:
         """截图（不压缩，PIL 不可用时的备用方案）"""
@@ -1248,7 +968,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 self.client.u2.screenshot(str(screenshot_path))
                 info = self.client.u2.info
@@ -1326,7 +1046,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 info = self.client.u2.info
                 screen_width = info.get('displayWidth', 0)
@@ -1410,23 +1130,7 @@ class BasicMobileToolsLite:
                 "return_to_app": return_result
             }
         except Exception as e:
-            # 🎯 异常情况：点击失败时检测弹窗
-            popup_detected = False
-            popup_hint = ""
-            if not self._is_ios():
-                try:
-                    page_analysis = self._analyze_page_for_popup()
-                    if page_analysis.get("has_popup"):
-                        popup_detected = True
-                        popup_hint = "\n🎯 检测到弹窗（异常情况），可能影响操作，建议先调用 mobile_close_popup() 关闭弹窗"
-                except Exception:
-                    pass
-            
-            error_msg = f"❌ 点击失败: {e}"
-            if popup_detected:
-                error_msg += popup_hint
-            
-            return {"success": False, "message": error_msg, "popup_detected": popup_detected}
+            return {"success": False, "message": f"❌ 点击失败: {e}"}
     
     def click_by_percent(self, x_percent: float, y_percent: float) -> Dict:
         """通过百分比坐标点击（跨设备兼容）
@@ -1457,14 +1161,14 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 info = self.client.u2.info
                 width = info.get('displayWidth', 0)
                 height = info.get('displayHeight', 0)
             
             if width == 0 or height == 0:
-                return {"success": False, "message": "❌ 无法获取屏幕尺寸"}
+                return {"success": False, "msg": "无法获取屏幕尺寸"}
             
             # 第2步：百分比转像素坐标
             # 公式：像素 = 屏幕尺寸 × (百分比 / 100)
@@ -1485,15 +1189,13 @@ class BasicMobileToolsLite:
             
             return {
                 "success": True,
-                "message": f"✅ 百分比点击成功: ({x_percent}%, {y_percent}%) → 像素({x}, {y})",
-                "screen_size": {"width": width, "height": height},
-                "percent": {"x": x_percent, "y": y_percent},
                 "pixel": {"x": x, "y": y}
             }
         except Exception as e:
             return {"success": False, "message": f"❌ 百分比点击失败: {e}"}
     
-    def click_by_text(self, text: str, timeout: float = 3.0, position: Optional[str] = None) -> Dict:
+    def click_by_text(self, text: str, timeout: float = 3.0, position: Optional[str] = None, 
+                       verify: Optional[str] = None) -> Dict:
         """通过文本点击 - 先查 XML 树，再精准匹配
         
         Args:
@@ -1502,6 +1204,7 @@ class BasicMobileToolsLite:
             position: 位置信息，当有多个相同文案时使用。支持：
                 - 垂直方向: "top"/"upper"/"上", "bottom"/"lower"/"下", "middle"/"center"/"中"
                 - 水平方向: "left"/"左", "right"/"右", "center"/"中"
+            verify: 可选，点击后验证的文本。如果指定，会检查该文本是否出现在页面上
         """
         try:
             if self._is_ios():
@@ -1513,10 +1216,17 @@ class BasicMobileToolsLite:
                     if elem.exists:
                         elem.click()
                         time.sleep(0.3)
-                        # 使用标准记录格式
                         self._record_click('text', text, element_desc=text, locator_attr='text')
-                        return {"success": True, "message": f"✅ 点击成功: '{text}'"}
-                    return {"success": False, "message": f"❌ 文本不存在: {text}"}
+                        # 验证逻辑
+                        if verify:
+                            return self._verify_after_click(verify, ios=True)
+                        # 返回页面文本摘要，方便确认页面变化
+                        page_texts = self._get_page_texts(10)
+                        return {"success": True, "page_texts": page_texts}
+                    # 控件树找不到，提示用视觉识别
+                    return {"success": False, "fallback": "vision", "msg": f"未找到'{text}'，用截图点击"}
+                else:
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 # 获取屏幕尺寸用于计算百分比
                 screen_width, screen_height = self.client.u2.window_size()
@@ -1537,17 +1247,20 @@ class BasicMobileToolsLite:
                         x_pct = round(cx / screen_width * 100, 1)
                         y_pct = round(cy / screen_height * 100, 1)
                     
-                    # 如果有位置参数，直接使用坐标点击（避免 u2 选择器匹配到错误的元素）
+                    # 如果有位置参数，直接使用坐标点击
                     if position and bounds:
                         x = (bounds[0] + bounds[2]) // 2
                         y = (bounds[1] + bounds[3]) // 2
                         self.client.u2.click(x, y)
                         time.sleep(0.3)
-                        position_info = f" ({position})" if position else ""
-                        # 虽然用坐标点击，但记录时仍使用文本定位（脚本更稳定）
                         self._record_click('text', attr_value, x_pct, y_pct, 
-                                          element_desc=f"{text}{position_info}", locator_attr=attr_type)
-                        return {"success": True, "message": f"✅ 点击成功(坐标定位): '{text}'{position_info} @ ({x},{y})"}
+                                          element_desc=f"{text}({position})", locator_attr=attr_type)
+                        # 验证逻辑
+                        if verify:
+                            return self._verify_after_click(verify)
+                        # 返回页面文本摘要
+                        page_texts = self._get_page_texts(10)
+                        return {"success": True, "page_texts": page_texts}
                     
                     # 没有位置参数时，使用选择器定位
                     if attr_type == 'text':
@@ -1564,43 +1277,74 @@ class BasicMobileToolsLite:
                     if elem and elem.exists(timeout=1):
                         elem.click()
                         time.sleep(0.3)
-                        position_info = f" ({position})" if position else ""
-                        # 使用标准记录格式：文本定位
                         self._record_click('text', attr_value, x_pct, y_pct,
                                           element_desc=text, locator_attr=attr_type)
-                        return {"success": True, "message": f"✅ 点击成功({attr_type}): '{text}'{position_info}"}
+                        # 验证逻辑
+                        if verify:
+                            return self._verify_after_click(verify)
+                        # 返回页面文本摘要
+                        page_texts = self._get_page_texts(10)
+                        return {"success": True, "page_texts": page_texts}
                     
-                    # 如果选择器失败，用坐标兜底
+                    # 选择器失败，用坐标兜底
                     if bounds:
                         x = (bounds[0] + bounds[2]) // 2
                         y = (bounds[1] + bounds[3]) // 2
                         self.client.u2.click(x, y)
                         time.sleep(0.3)
-                        position_info = f" ({position})" if position else ""
-                        # 选择器失败，用百分比作为兜底
                         self._record_click('percent', f"{x_pct}%,{y_pct}%", x_pct, y_pct,
-                                          element_desc=f"{text}{position_info}")
-                        return {"success": True, "message": f"✅ 点击成功(坐标兜底): '{text}'{position_info} @ ({x},{y})"}
+                                          element_desc=text)
+                        # 验证逻辑
+                        if verify:
+                            return self._verify_after_click(verify)
+                        # 返回页面文本摘要
+                        page_texts = self._get_page_texts(10)
+                        return {"success": True, "page_texts": page_texts}
                 
-                return {"success": False, "message": f"❌ 文本不存在: {text}"}
+                # 控件树找不到，提示用视觉识别
+                return {"success": False, "fallback": "vision", "msg": f"未找到'{text}'，用截图点击"}
         except Exception as e:
-            # 🎯 异常情况：点击失败时检测弹窗
-            popup_detected = False
-            popup_hint = ""
-            if not self._is_ios():
-                try:
-                    page_analysis = self._analyze_page_for_popup()
-                    if page_analysis.get("has_popup"):
-                        popup_detected = True
-                        popup_hint = "\n🎯 检测到弹窗（异常情况），可能影响操作，建议先调用 mobile_close_popup() 关闭弹窗"
-                except Exception:
-                    pass
-            
-            error_msg = f"❌ 点击失败: {e}"
-            if popup_detected:
-                error_msg += popup_hint
+            return {"success": False, "msg": str(e)}
+    
+    def _verify_after_click(self, verify_text: str, ios: bool = False, timeout: float = 2.0) -> Dict:
+        """点击后验证期望文本是否出现
+        
+        Args:
+            verify_text: 期望出现的文本
+            ios: 是否是 iOS 设备
+            timeout: 验证超时时间
+        
+        Returns:
+            {"success": True, "verified": True/False, "hint": "..."}
+        """
+        time.sleep(0.5)  # 等待页面更新
+        
+        try:
+            if ios:
+                ios_client = self._get_ios_client()
+                if ios_client and hasattr(ios_client, 'wda'):
+                    exists = ios_client.wda(name=verify_text).exists or \
+                             ios_client.wda(label=verify_text).exists
+                else:
+                    exists = False
+            else:
+                # Android: 检查文本或包含文本
+                exists = self.client.u2(text=verify_text).exists(timeout=timeout) or \
+                         self.client.u2(textContains=verify_text).exists(timeout=0.5) or \
+                         self.client.u2(description=verify_text).exists(timeout=0.5)
             
-            return {"success": False, "message": error_msg, "popup_detected": popup_detected}
+            if exists:
+                return {"success": True, "verified": True}
+            else:
+                # 验证失败，提示可以截图确认
+                return {
+                    "success": True,  # 点击本身成功
+                    "verified": False,
+                    "expect": verify_text,
+                    "hint": "验证失败，可截图确认"
+                }
+        except Exception as e:
+            return {"success": True, "verified": False, "hint": f"验证异常: {e}"}
     
     def _find_element_in_tree(self, text: str, position: Optional[str] = None) -> Optional[Dict]:
         """在 XML 树中查找包含指定文本的元素，优先返回可点击的元素
@@ -1739,15 +1483,8 @@ class BasicMobileToolsLite:
             return None
     
     def click_by_id(self, resource_id: str, index: int = 0) -> Dict:
-        """通过 resource-id 点击（支持点击第 N 个元素）
-
-        Args:
-            resource_id: 元素的 resource-id
-            index: 第几个元素（从 0 开始），默认 0 表示第一个
-        """
+        """通过 resource-id 点击"""
         try:
-            index_desc = f"[{index}]" if index > 0 else ""
-
             if self._is_ios():
                 ios_client = self._get_ios_client()
                 if ios_client and hasattr(ios_client, 'wda'):
@@ -1755,49 +1492,31 @@ class BasicMobileToolsLite:
                     if not elem.exists:
                         elem = ios_client.wda(name=resource_id)
                     if elem.exists:
-                        # 获取所有匹配的元素
                         elements = elem.find_elements()
                         if index < len(elements):
                             elements[index].click()
                             time.sleep(0.3)
-                            # 使用标准记录格式
-                            self._record_click('id', resource_id, element_desc=f"{resource_id}{index_desc}")
-                            return {"success": True, "message": f"✅ 点击成功: {resource_id}{index_desc}"}
+                            self._record_click('id', resource_id, element_desc=resource_id)
+                            return {"success": True}
                         else:
-                            return {"success": False, "message": f"❌ 索引超出范围: 找到 {len(elements)} 个元素，但请求索引 {index}"}
-                    return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
+                            return {"success": False, "msg": f"索引{index}超出范围(共{len(elements)}个)"}
+                    return {"success": False, "fallback": "vision", "msg": f"未找到ID'{resource_id}'"}
+                else:
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 elem = self.client.u2(resourceId=resource_id)
                 if elem.exists(timeout=0.5):
-                    # 获取匹配元素数量
                     count = elem.count
                     if index < count:
                         elem[index].click()
                         time.sleep(0.3)
-                        # 使用标准记录格式
-                        self._record_click('id', resource_id, element_desc=f"{resource_id}{index_desc}")
-                        return {"success": True, "message": f"✅ 点击成功: {resource_id}{index_desc}" + (f" (共 {count} 个)" if count > 1 else "")}
+                        self._record_click('id', resource_id, element_desc=resource_id)
+                        return {"success": True}
                     else:
-                        return {"success": False, "message": f"❌ 索引超出范围: 找到 {count} 个元素，但请求索引 {index}"}
-                return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
+                        return {"success": False, "msg": f"索引{index}超出范围(共{count}个)"}
+                return {"success": False, "fallback": "vision", "msg": f"未找到ID'{resource_id}'"}
         except Exception as e:
-            # 🎯 异常情况：点击失败时检测弹窗
-            popup_detected = False
-            popup_hint = ""
-            if not self._is_ios():
-                try:
-                    page_analysis = self._analyze_page_for_popup()
-                    if page_analysis.get("has_popup"):
-                        popup_detected = True
-                        popup_hint = "\n🎯 检测到弹窗（异常情况），可能影响操作，建议先调用 mobile_close_popup() 关闭弹窗"
-                except Exception:
-                    pass
-            
-            error_msg = f"❌ 点击失败: {e}"
-            if popup_detected:
-                error_msg += popup_hint
-            
-            return {"success": False, "message": error_msg, "popup_detected": popup_detected}
+            return {"success": False, "msg": str(e)}
     
     # ==================== 长按操作 ====================
     
@@ -1831,7 +1550,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 info = self.client.u2.info
                 screen_width = info.get('displayWidth', 0)
@@ -1884,23 +1603,11 @@ class BasicMobileToolsLite:
             
             if converted:
                 if conversion_type == "crop_offset":
-                    return {
-                        "success": True,
-                        "message": f"✅ 长按成功: ({x}, {y}) 持续 {duration}s\n"
-                                  f"   🔍 局部截图坐标转换: ({original_x},{original_y}) + 偏移({crop_offset_x},{crop_offset_y}) → ({x},{y})"
-                    }
+                    return {"success": True}
                 else:
-                    return {
-                        "success": True,
-                        "message": f"✅ 长按成功: ({x}, {y}) 持续 {duration}s\n"
-                                  f"   📐 坐标已转换: ({original_x},{original_y}) → ({x},{y})\n"
-                                  f"   🖼️ 图片尺寸: {image_width}x{image_height} → 屏幕: {screen_width}x{screen_height}"
-                    }
+                    return {"success": True}
             else:
-                return {
-                    "success": True,
-                    "message": f"✅ 长按成功: ({x}, {y}) 持续 {duration}s [相对位置: {x_percent}%, {y_percent}%]"
-                }
+                return {"success": True}
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -1929,14 +1636,14 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 info = self.client.u2.info
                 width = info.get('displayWidth', 0)
                 height = info.get('displayHeight', 0)
             
             if width == 0 or height == 0:
-                return {"success": False, "message": "❌ 无法获取屏幕尺寸"}
+                return {"success": False, "msg": "无法获取屏幕尺寸"}
             
             # 第2步：百分比转像素坐标
             x = int(width * x_percent / 100)
@@ -1958,13 +1665,7 @@ class BasicMobileToolsLite:
             self._record_long_press('percent', f"{x_percent}%,{y_percent}%", duration,
                                    x_percent, y_percent, element_desc=f"百分比({x_percent}%,{y_percent}%)")
             
-            return {
-                "success": True,
-                "message": f"✅ 百分比长按成功: ({x_percent}%, {y_percent}%) → 像素({x}, {y}) 持续 {duration}s",
-                "screen_size": {"width": width, "height": height},
-                "percent": {"x": x_percent, "y": y_percent},
-                "pixel": {"x": x, "y": y},
-                "duration": duration
+            return {"success": True
             }
         except Exception as e:
             return {"success": False, "message": f"❌ 百分比长按失败: {e}"}
@@ -1994,8 +1695,8 @@ class BasicMobileToolsLite:
                             ios_client.wda.swipe(x, y, x, y, duration=duration)
                         time.sleep(0.3)
                         self._record_long_press('text', text, duration, element_desc=text, locator_attr='text')
-                        return {"success": True, "message": f"✅ 长按成功: '{text}' 持续 {duration}s"}
-                    return {"success": False, "message": f"❌ 文本不存在: {text}"}
+                        return {"success": True}
+                    return {"success": False, "msg": f"未找到'{text}'"}
             else:
                 # 获取屏幕尺寸用于计算百分比
                 screen_width, screen_height = self.client.u2.window_size()
@@ -2033,7 +1734,7 @@ class BasicMobileToolsLite:
                         time.sleep(0.3)
                         self._record_long_press('text', attr_value, duration, x_pct, y_pct,
                                                element_desc=text, locator_attr=attr_type)
-                        return {"success": True, "message": f"✅ 长按成功({attr_type}): '{text}' 持续 {duration}s"}
+                        return {"success": True}
                     
                     # 如果选择器失败，用坐标兜底
                     if bounds:
@@ -2043,9 +1744,9 @@ class BasicMobileToolsLite:
                         time.sleep(0.3)
                         self._record_long_press('percent', f"{x_pct}%,{y_pct}%", duration, x_pct, y_pct,
                                                element_desc=text)
-                        return {"success": True, "message": f"✅ 长按成功(坐标兜底): '{text}' @ ({x},{y}) 持续 {duration}s"}
+                        return {"success": True}
                 
-                return {"success": False, "message": f"❌ 文本不存在: {text}"}
+                return {"success": False, "msg": f"未找到'{text}'"}
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -2073,8 +1774,8 @@ class BasicMobileToolsLite:
                             ios_client.wda.swipe(x, y, x, y, duration=duration)
                         time.sleep(0.3)
                         self._record_long_press('id', resource_id, duration, element_desc=resource_id)
-                        return {"success": True, "message": f"✅ 长按成功: {resource_id} 持续 {duration}s"}
-                    return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
+                        return {"success": True}
+                    return {"success": False, "msg": f"未找到'{resource_id}'"}
             else:
                 elem = self.client.u2(resourceId=resource_id)
                 if elem.exists(timeout=0.5):
@@ -2082,7 +1783,7 @@ class BasicMobileToolsLite:
                     time.sleep(0.3)
                     self._record_long_press('id', resource_id, duration, element_desc=resource_id)
                     return {"success": True, "message": f"✅ 长按成功: {resource_id} 持续 {duration}s"}
-                return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
+                return {"success": False, "msg": f"未找到'{resource_id}'"}
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -2339,15 +2040,8 @@ class BasicMobileToolsLite:
             x_percent = round(x / screen_width * 100, 1) if screen_width > 0 else 0
             y_percent = round(y / screen_height * 100, 1) if screen_height > 0 else 0
             
-            self._record_operation(
-                'input', 
-                x=x, 
-                y=y, 
-                x_percent=x_percent,
-                y_percent=y_percent,
-                ref=f"coords_{x}_{y}", 
-                text=text
-            )
+            # 使用标准记录格式
+            self._record_input(text, 'percent', f"{x_percent}%,{y_percent}%", x_percent, y_percent)
             
             # 🎯 关键步骤：检查应用是否跳转，如果跳转则自动返回目标应用
             app_check = self._check_app_switched()
@@ -2377,16 +2071,13 @@ class BasicMobileToolsLite:
     
     # ==================== 导航操作 ====================
     
-    async def swipe(self, direction: str, y: Optional[int] = None, y_percent: Optional[float] = None,
-                   distance: Optional[int] = None, distance_percent: Optional[float] = None) -> Dict:
+    async def swipe(self, direction: str, y: Optional[int] = None, y_percent: Optional[float] = None) -> Dict:
         """滑动屏幕
         
         Args:
             direction: 滑动方向 (up/down/left/right)
             y: 左右滑动时指定的高度坐标（像素）
             y_percent: 左右滑动时指定的高度百分比 (0-100)
-            distance: 横向滑动时指定的滑动距离（像素），仅用于 left/right
-            distance_percent: 横向滑动时指定的滑动距离百分比 (0-100)，仅用于 left/right
         """
         try:
             if self._is_ios():
@@ -2395,7 +2086,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
+                    return {"success": False, "msg": "iOS未初始化"}
             else:
                 width, height = self.client.u2.window_size()
             
@@ -2413,53 +2104,20 @@ class BasicMobileToolsLite:
                     swipe_y = y
                 else:
                     swipe_y = center_y
-                
-                # 计算横向滑动距离
-                if distance_percent is not None:
-                    if not (0 <= distance_percent <= 100):
-                        return {"success": False, "message": f"❌ distance_percent 必须在 0-100 之间: {distance_percent}"}
-                    swipe_distance = int(width * distance_percent / 100)
-                elif distance is not None:
-                    if distance <= 0:
-                        return {"success": False, "message": f"❌ distance 必须大于 0: {distance}"}
-                    if distance > width:
-                        return {"success": False, "message": f"❌ distance 不能超过屏幕宽度 ({width}): {distance}"}
-                    swipe_distance = distance
-                else:
-                    # 默认滑动距离：屏幕宽度的 60%（从 0.8 到 0.2）
-                    swipe_distance = int(width * 0.6)
-                
-                # 计算起始和结束位置
-                if direction == 'left':
-                    # 从右向左滑动：起始点在右侧，结束点在左侧
-                    # 确保起始点不超出屏幕右边界
-                    start_x = min(center_x + swipe_distance // 2, width - 10)
-                    end_x = start_x - swipe_distance
-                    # 确保结束点不超出屏幕左边界
-                    if end_x < 10:
-                        end_x = 10
-                        start_x = min(end_x + swipe_distance, width - 10)
-                else:  # right
-                    # 从左向右滑动：起始点在左侧，结束点在右侧
-                    # 确保起始点不超出屏幕左边界
-                    start_x = max(center_x - swipe_distance // 2, 10)
-                    end_x = start_x + swipe_distance
-                    # 确保结束点不超出屏幕右边界
-                    if end_x > width - 10:
-                        end_x = width - 10
-                        start_x = max(end_x - swipe_distance, 10)
-                
-                x1, y1, x2, y2 = start_x, swipe_y, end_x, swipe_y
             else:
                 swipe_y = center_y
-                # 纵向滑动保持原有逻辑
-                swipe_map = {
-                    'up': (center_x, int(height * 0.8), center_x, int(height * 0.2)),
-                    'down': (center_x, int(height * 0.2), center_x, int(height * 0.8)),
-                }
-                if direction not in swipe_map:
-                    return {"success": False, "message": f"❌ 不支持的方向: {direction}"}
-                x1, y1, x2, y2 = swipe_map[direction]
+            
+            swipe_map = {
+                'up': (center_x, int(height * 0.8), center_x, int(height * 0.2)),
+                'down': (center_x, int(height * 0.2), center_x, int(height * 0.8)),
+                'left': (int(width * 0.8), swipe_y, int(width * 0.2), swipe_y),
+                'right': (int(width * 0.2), swipe_y, int(width * 0.8), swipe_y),
+            }
+            
+            if direction not in swipe_map:
+                return {"success": False, "message": f"❌ 不支持的方向: {direction}"}
+            
+            x1, y1, x2, y2 = swipe_map[direction]
             
             if self._is_ios():
                 ios_client.wda.swipe(x1, y1, x2, y2)
@@ -2480,21 +2138,10 @@ class BasicMobileToolsLite:
             # 构建返回消息
             msg = f"✅ 滑动成功: {direction}"
             if direction in ['left', 'right']:
-                msg_parts = []
                 if y_percent is not None:
-                    msg_parts.append(f"高度: {y_percent}% = {swipe_y}px")
+                    msg += f" (高度: {y_percent}% = {swipe_y}px)"
                 elif y is not None:
-                    msg_parts.append(f"高度: {y}px")
-                
-                if distance_percent is not None:
-                    msg_parts.append(f"距离: {distance_percent}% = {swipe_distance}px")
-                elif distance is not None:
-                    msg_parts.append(f"距离: {distance}px")
-                else:
-                    msg_parts.append(f"距离: 默认 {swipe_distance}px")
-                
-                if msg_parts:
-                    msg += f" ({', '.join(msg_parts)})"
+                    msg += f" (高度: {y}px)"
             
             # 如果检测到应用跳转，添加警告和返回结果
             if app_check['switched']:
@@ -2535,194 +2182,34 @@ class BasicMobileToolsLite:
                             ios_client.wda.send_keys('\n')
                         elif ios_key == 'home':
                             ios_client.wda.home()
-                        return {"success": True, "message": f"✅ 按键成功: {key}"}
-                return {"success": False, "message": f"❌ iOS 不支持: {key}"}
+                        return {"success": True}
+                return {"success": False, "msg": f"iOS不支持{key}"}
             else:
                 keycode = key_map.get(key.lower())
                 if keycode:
                     self.client.u2.shell(f'input keyevent {keycode}')
                     self._record_key(key)
-                    return {"success": True, "message": f"✅ 按键成功: {key}"}
-                return {"success": False, "message": f"❌ 不支持的按键: {key}"}
+                    return {"success": True}
+                return {"success": False, "msg": f"不支持按键{key}"}
         except Exception as e:
             return {"success": False, "message": f"❌ 按键失败: {e}"}
     
     def wait(self, seconds: float) -> Dict:
         """等待指定时间"""
         time.sleep(seconds)
-        return {"success": True, "message": f"✅ 已等待 {seconds} 秒"}
-    
-    async def drag_progress_bar(self, direction: str = "right", distance_percent: float = 30.0, 
-                                y_percent: Optional[float] = None, y: Optional[int] = None) -> Dict:
-        """智能拖动进度条
-        
-        自动检测进度条是否可见：
-        - 如果进度条已显示，直接拖动（无需先点击播放区域）
-        - 如果进度条未显示，先点击播放区域显示控制栏，再拖动
-        
-        Args:
-            direction: 拖动方向，'left'（倒退）或 'right'（前进），默认 'right'
-            distance_percent: 拖动距离百分比 (0-100)，默认 30%
-            y_percent: 进度条的垂直位置百分比 (0-100)，如果未指定则自动检测
-            y: 进度条的垂直位置坐标（像素），如果未指定则自动检测
-        """
-        try:
-            import xml.etree.ElementTree as ET
-            import re
-            
-            if self._is_ios():
-                return {"success": False, "message": "❌ iOS 暂不支持，请使用 mobile_swipe"}
-            
-            if direction not in ['left', 'right']:
-                return {"success": False, "message": f"❌ 拖动方向必须是 'left' 或 'right': {direction}"}
-            
-            screen_width, screen_height = self.client.u2.window_size()
-            
-            # 获取 XML 查找进度条
-            xml_string = self.client.u2.dump_hierarchy(compressed=False)
-            root = ET.fromstring(xml_string)
-            
-            progress_bar_found = False
-            progress_bar_y = None
-            progress_bar_y_percent = None
-            
-            # 查找进度条元素（SeekBar、ProgressBar）
-            for elem in root.iter():
-                class_name = elem.attrib.get('class', '')
-                resource_id = elem.attrib.get('resource-id', '')
-                bounds_str = elem.attrib.get('bounds', '')
-                
-                # 检查是否是进度条
-                is_progress_bar = (
-                    'SeekBar' in class_name or 
-                    'ProgressBar' in class_name or
-                    'progress' in resource_id.lower() or
-                    'seek' in resource_id.lower()
-                )
-                
-                if is_progress_bar and bounds_str:
-                    # 解析 bounds 获取进度条位置
-                    match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
-                    if match:
-                        x1, y1, x2, y2 = map(int, match.groups())
-                        center_y = (y1 + y2) // 2
-                        progress_bar_y = center_y
-                        progress_bar_y_percent = round(center_y / screen_height * 100, 1)
-                        progress_bar_found = True
-                        break
-            
-            # 如果未找到进度条，尝试点击播放区域显示控制栏
-            if not progress_bar_found:
-                # 点击屏幕中心显示控制栏
-                center_x, center_y = screen_width // 2, screen_height // 2
-                self.client.u2.click(center_x, center_y)
-                time.sleep(0.5)
-                
-                # 再次查找进度条
-                xml_string = self.client.u2.dump_hierarchy(compressed=False)
-                root = ET.fromstring(xml_string)
-                
-                for elem in root.iter():
-                    class_name = elem.attrib.get('class', '')
-                    resource_id = elem.attrib.get('resource-id', '')
-                    bounds_str = elem.attrib.get('bounds', '')
-                    
-                    is_progress_bar = (
-                        'SeekBar' in class_name or 
-                        'ProgressBar' in class_name or
-                        'progress' in resource_id.lower() or
-                        'seek' in resource_id.lower()
-                    )
-                    
-                    if is_progress_bar and bounds_str:
-                        match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
-                        if match:
-                            x1, y1, x2, y2 = map(int, match.groups())
-                            center_y = (y1 + y2) // 2
-                            progress_bar_y = center_y
-                            progress_bar_y_percent = round(center_y / screen_height * 100, 1)
-                            progress_bar_found = True
-                            break
-            
-            # 确定使用的高度位置
-            if y_percent is not None:
-                swipe_y = int(screen_height * y_percent / 100)
-                used_y_percent = y_percent
-            elif y is not None:
-                swipe_y = y
-                used_y_percent = round(y / screen_height * 100, 1)
-            elif progress_bar_found:
-                swipe_y = progress_bar_y
-                used_y_percent = progress_bar_y_percent
-            else:
-                # 默认使用屏幕底部附近（进度条常见位置）
-                swipe_y = int(screen_height * 0.91)
-                used_y_percent = 91.0
-            
-            # 计算滑动距离
-            swipe_distance = int(screen_width * distance_percent / 100)
-            
-            # 计算起始和结束位置
-            center_x = screen_width // 2
-            if direction == 'left':
-                start_x = min(center_x + swipe_distance // 2, screen_width - 10)
-                end_x = start_x - swipe_distance
-                if end_x < 10:
-                    end_x = 10
-                    start_x = min(end_x + swipe_distance, screen_width - 10)
-            else:  # right
-                start_x = max(center_x - swipe_distance // 2, 10)
-                end_x = start_x + swipe_distance
-                if end_x > screen_width - 10:
-                    end_x = screen_width - 10
-                    start_x = max(end_x - swipe_distance, 10)
-            
-            # 执行拖动
-            self.client.u2.swipe(start_x, swipe_y, end_x, swipe_y, duration=0.5)
-            time.sleep(0.3)
-            
-            # 记录操作
-            self._record_swipe(direction)
-            
-            # 检查应用是否跳转
-            app_check = self._check_app_switched()
-            return_result = None
-            if app_check['switched']:
-                return_result = self._return_to_target_app()
-            
-            # 构建返回消息
-            msg = f"✅ 进度条拖动成功: {direction} (高度: {used_y_percent}%, 距离: {distance_percent}%)"
-            if not progress_bar_found:
-                msg += "\n💡 已自动点击播放区域显示控制栏"
-            else:
-                msg += "\n💡 进度条已显示，直接拖动"
-            
-            if app_check['switched']:
-                msg += f"\n{app_check['message']}"
-                if return_result and return_result.get('success'):
-                    msg += f"\n{return_result['message']}"
-            
-            return {
-                "success": True,
-                "message": msg,
-                "progress_bar_found": progress_bar_found,
-                "y_percent": used_y_percent,
-                "distance_percent": distance_percent,
-                "direction": direction,
-                "app_check": app_check,
-                "return_to_app": return_result
-            }
-            
-        except Exception as e:
-            return {"success": False, "message": f"❌ 拖动进度条失败: {e}"}
+        # 记录等待操作
+        record = {
+            'action': 'wait',
+            'timestamp': datetime.now().isoformat(),
+            'seconds': seconds,
+        }
+        self.operation_history.append(record)
+        return {"success": True}
     
     # ==================== 应用管理 ====================
     
     async def launch_app(self, package_name: str) -> Dict:
-        """启动应用
-        
-        启动应用后会自动检测弹窗（启动应用场景）
-        """
+        """启动应用"""
         try:
             if self._is_ios():
                 ios_client = self._get_ios_client()
@@ -2746,45 +2233,9 @@ class BasicMobileToolsLite:
             
             self._record_operation('launch_app', package_name=package_name)
             
-            # 🎯 启动应用后检测弹窗（明确场景：启动应用后）
-            popup_detected = False
-            popup_message = ""
-            if not self._is_ios():
-                try:
-                    # 检测弹窗
-                    page_analysis = self._analyze_page_for_popup()
-                    if page_analysis.get("has_popup"):
-                        popup_detected = True
-                        popup_info = page_analysis.get("popup_info", {})
-                        popup_message = f"\n🎯 检测到弹窗（启动应用场景）\n💡 如需关闭弹窗，请调用 mobile_close_popup()"
-                except Exception:
-                    pass  # 弹窗检测失败不影响启动流程
-            
-            message = f"✅ 已启动: {package_name}\n💡 建议等待 2-3 秒让页面加载\n📱 已设置应用状态监测"
-            if popup_detected:
-                message += popup_message
-            
-            return {
-                "success": True,
-                "message": message,
-                "popup_detected": popup_detected
-            }
+            return {"success": True}
         except Exception as e:
-            # 🎯 异常情况：启动失败时也检测弹窗
-            popup_detected = False
-            if not self._is_ios():
-                try:
-                    page_analysis = self._analyze_page_for_popup()
-                    if page_analysis.get("has_popup"):
-                        popup_detected = True
-                except Exception:
-                    pass
-            
-            error_msg = f"❌ 启动失败: {e}"
-            if popup_detected:
-                error_msg += "\n🎯 检测到弹窗（异常情况），可能影响启动，建议先关闭弹窗"
-            
-            return {"success": False, "message": error_msg, "popup_detected": popup_detected}
+            return {"success": False, "message": f"❌ 启动失败: {e}"}
     
     def terminate_app(self, package_name: str) -> Dict:
         """终止应用"""
@@ -2795,9 +2246,9 @@ class BasicMobileToolsLite:
                     ios_client.wda.app_terminate(package_name)
             else:
                 self.client.u2.app_stop(package_name)
-            return {"success": True, "message": f"✅ 已终止: {package_name}"}
+            return {"success": True}
         except Exception as e:
-            return {"success": False, "message": f"❌ 终止失败: {e}"}
+            return {"success": False, "msg": str(e)}
     
     def list_apps(self, filter_keyword: str = "") -> Dict:
         """列出已安装应用"""
@@ -2909,6 +2360,35 @@ class BasicMobileToolsLite:
                     '_shadow', 'shadow_', '_divider', 'divider_', '_line', 'line_'
                 }
                 
+                # 状态栏相关关键词（这些元素对测试没有意义，直接过滤）
+                STATUS_BAR_KEYWORDS = {
+                    'status_bar', 'statusbar', 'notification_icon', 'notificationicons',
+                    'system_icons', 'statusicons', 'battery', 'wifi_', 'wifi_combo',
+                    'wifi_group', 'wifi_signal', 'wifi_in', 'wifi_out', 'signal_',
+                    'clock', 'cutout', 'networkspeed', 'speed_container',
+                    'carrier', 'operator', 'sim_', 'mobile_signal'
+                }
+                
+                # Token 优化：构建精简元素（只返回非空字段）
+                def build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name):
+                    """只返回有值的字段，节省 token"""
+                    item = {}
+                    if resource_id:
+                        # 精简 resource_id，只保留最后一段
+                        item['id'] = resource_id.split('/')[-1] if '/' in resource_id else resource_id
+                    if text:
+                        item['text'] = text
+                    if content_desc:
+                        item['desc'] = content_desc
+                    if bounds:
+                        item['bounds'] = bounds
+                    if likely_click:
+                        item['click'] = True  # 启发式判断可点击
+                    # class 精简：只保留关键类型
+                    if class_name in ('EditText', 'TextInput', 'Button', 'ImageButton', 'CheckBox', 'Switch'):
+                        item['type'] = class_name
+                    return item
+                
                 result = []
                 for elem in elements:
                     # 获取元素属性
@@ -2926,16 +2406,19 @@ class BasicMobileToolsLite:
                     if bounds == '[0,0][0,0]':
                         continue
                     
+                    # 1.5 过滤状态栏元素（对测试没有意义）
+                    if resource_id:
+                        resource_id_lower = resource_id.lower()
+                        if any(keyword in resource_id_lower for keyword in STATUS_BAR_KEYWORDS):
+                            continue
+                    
                     # 2. 检查是否是功能控件（直接保留）
                     if class_name in FUNCTIONAL_WIDGETS:
-                        result.append({
-                            'resource_id': resource_id,
-                            'text': text,
-                            'content_desc': content_desc,
-                            'bounds': bounds,
-                            'clickable': clickable,
-                            'class': class_name
-                        })
+                        # 使用启发式判断可点击性（替代不准确的 clickable 属性）
+                        likely_click = self._is_likely_clickable(class_name, resource_id, text, content_desc, clickable, bounds)
+                        item = build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name)
+                        if item:
+                            result.append(item)
                         continue
                     
                     # 3. 检查是否是容器控件
@@ -2948,14 +2431,10 @@ class BasicMobileToolsLite:
                                 # 所有属性都是默认值，过滤掉
                                 continue
                         # 有业务ID或其他有意义属性，保留
-                        result.append({
-                            'resource_id': resource_id,
-                            'text': text,
-                            'content_desc': content_desc,
-                            'bounds': bounds,
-                            'clickable': clickable,
-                            'class': class_name
-                        })
+                        likely_click = self._is_likely_clickable(class_name, resource_id, text, content_desc, clickable, bounds)
+                        item = build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name)
+                        if item:
+                            result.append(item)
                         continue
                     
                     # 4. 检查是否是装饰类控件
@@ -2972,19 +2451,72 @@ class BasicMobileToolsLite:
                         continue
                     
                     # 6. 其他情况：有意义的元素保留
-                    result.append({
-                        'resource_id': resource_id,
-                        'text': text,
-                        'content_desc': content_desc,
-                        'bounds': bounds,
-                        'clickable': clickable,
-                        'class': class_name
+                    likely_click = self._is_likely_clickable(class_name, resource_id, text, content_desc, clickable, bounds)
+                    item = build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name)
+                    if item:
+                        result.append(item)
+                
+                # Token 优化：可选限制返回元素数量（默认不限制，确保准确度）
+                if TOKEN_OPTIMIZATION and MAX_ELEMENTS > 0 and len(result) > MAX_ELEMENTS:
+                    # 仅在用户明确设置 MAX_ELEMENTS_RETURN 时才截断
+                    truncated = result[:MAX_ELEMENTS]
+                    truncated.append({
+                        '_truncated': True,
+                        '_total': len(result),
+                        '_shown': MAX_ELEMENTS
                     })
+                    return truncated
                 
                 return result
         except Exception as e:
             return [{"error": f"获取元素失败: {e}"}]
     
+    def _get_page_texts(self, max_count: int = 15) -> List[str]:
+        """获取页面关键文本列表（用于点击后快速确认页面变化）
+        
+        Args:
+            max_count: 最多返回的文本数量
+            
+        Returns:
+            页面上的关键文本列表（去重）
+        """
+        try:
+            if self._is_ios():
+                ios_client = self._get_ios_client()
+                if ios_client and hasattr(ios_client, 'wda'):
+                    # iOS: 获取所有 StaticText 的文本
+                    elements = ios_client.wda(type='XCUIElementTypeStaticText').find_elements()
+                    texts = set()
+                    for elem in elements[:50]:  # 限制扫描数量
+                        try:
+                            name = elem.name or elem.label
+                            if name and len(name) > 1 and len(name) < 50:
+                                texts.add(name)
+                        except:
+                            pass
+                    return list(texts)[:max_count]
+                return []
+            else:
+                # Android: 快速扫描 XML 获取文本
+                xml_string = self.client.u2.dump_hierarchy(compressed=True)
+                import xml.etree.ElementTree as ET
+                root = ET.fromstring(xml_string)
+                
+                texts = set()
+                for elem in root.iter():
+                    text = elem.get('text', '').strip()
+                    desc = elem.get('content-desc', '').strip()
+                    # 只收集有意义的文本（长度2-30，非纯数字）
+                    for t in [text, desc]:
+                        if t and 2 <= len(t) <= 30 and not t.isdigit():
+                            texts.add(t)
+                    if len(texts) >= max_count * 2:  # 收集足够后停止
+                        break
+                
+                return list(texts)[:max_count]
+        except Exception:
+            return []
+    
     def _has_business_id(self, resource_id: str) -> bool:
         """
         判断resource_id是否是业务相关的ID
@@ -3016,21 +2548,83 @@ class BasicMobileToolsLite:
         
         return True
     
-    def find_close_button(self) -> Dict:
-        """智能查找关闭按钮（不点击，只返回位置）
+    def _is_likely_clickable(self, class_name: str, resource_id: str, text: str,
+                             content_desc: str, clickable: bool, bounds: str) -> bool:
+        """
+        启发式判断元素是否可能可点击
         
-        从元素列表中找最可能的关闭按钮，返回其坐标和百分比位置。
-        适用于关闭弹窗广告等场景。
+        Android 的 clickable 属性经常不准确，因为：
+        1. 点击事件可能设置在父容器上
+        2. 使用 onTouchListener 而不是 onClick
+        3. RecyclerView item 通过 ItemClickListener 处理
         
-        Returns:
-            包含关闭按钮位置信息的字典，或截图让 AI 分析
+        此方法通过多种规则推断元素的真实可点击性
         """
-        try:
-            import re
-            
-            if self._is_ios():
-                return {"success": False, "message": "iOS 暂不支持，请使用截图+坐标点击"}
-            
+        # 规则1：clickable=true 肯定可点击
+        if clickable:
+            return True
+        
+        # 规则2：特定类型的控件通常可点击
+        TYPICALLY_CLICKABLE = {
+            'Button', 'ImageButton', 'CheckBox', 'RadioButton', 'Switch',
+            'ToggleButton', 'FloatingActionButton', 'Chip', 'TabView',
+            'EditText', 'TextInput',  # 输入框可点击获取焦点
+        }
+        if class_name in TYPICALLY_CLICKABLE:
+            return True
+        
+        # 规则3：resource_id 包含可点击关键词
+        if resource_id:
+            id_lower = resource_id.lower()
+            CLICK_KEYWORDS = [
+                'btn', 'button', 'click', 'tap', 'submit', 'confirm',
+                'cancel', 'close', 'back', 'next', 'prev', 'more',
+                'action', 'link', 'menu', 'tab', 'item', 'cell',
+                'card', 'avatar', 'icon', 'entry', 'option', 'arrow'
+            ]
+            for kw in CLICK_KEYWORDS:
+                if kw in id_lower:
+                    return True
+        
+        # 规则4：content_desc 包含可点击暗示
+        if content_desc:
+            desc_lower = content_desc.lower()
+            CLICK_HINTS = ['点击', '按钮', '关闭', '返回', '更多', 'click', 'tap', 'button', 'close']
+            for hint in CLICK_HINTS:
+                if hint in desc_lower:
+                    return True
+        
+        # 规则5：有 resource_id 或 content_desc 的小图标可能可点击
+        # （纯 ImageView 不加判断，误判率太高）
+        if class_name in ('ImageView', 'Image') and (resource_id or content_desc) and bounds:
+            match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
+            if match:
+                x1, y1, x2, y2 = map(int, match.groups())
+                w, h = x2 - x1, y2 - y1
+                # 小图标（20-100px）更可能是按钮
+                if 20 <= w <= 100 and 20 <= h <= 100:
+                    return True
+        
+        # 规则6：移除（TextView 误判率太高，只依赖上面的规则）
+        # 如果有 clickable=true 或 ID/desc 中有关键词，前面的规则已经覆盖
+        
+        return False
+    
+    def find_close_button(self) -> Dict:
+        """智能查找关闭按钮（不点击，只返回位置）
+        
+        从元素列表中找最可能的关闭按钮，返回其坐标和百分比位置。
+        适用于关闭弹窗广告等场景。
+        
+        Returns:
+            包含关闭按钮位置信息的字典，或截图让 AI 分析
+        """
+        try:
+            import re
+            
+            if self._is_ios():
+                return {"success": False, "msg": "iOS暂不支持"}
+            
             # 获取屏幕尺寸
             screen_width = self.client.u2.info.get('displayWidth', 720)
             screen_height = self.client.u2.info.get('displayHeight', 1280)
@@ -3040,6 +2634,14 @@ class BasicMobileToolsLite:
             import xml.etree.ElementTree as ET
             root = ET.fromstring(xml_string)
             
+            # 🔴 先检测是否有弹窗，避免误识别普通页面的按钮
+            popup_bounds, popup_confidence = self._detect_popup_with_confidence(
+                root, screen_width, screen_height
+            )
+            
+            if popup_bounds is None or popup_confidence < 0.5:
+                return {"success": True, "popup": False}
+            
             # 关闭按钮特征
             close_texts = ['×', 'X', 'x', '关闭', '取消', 'close', 'Close', '跳过', '知道了', '我知道了']
             candidates = []
@@ -3083,38 +2685,31 @@ class BasicMobileToolsLite:
                 
                 # 策略3：小尺寸的 clickable 元素（可能是 X 图标）
                 elif clickable:
-                    # 排除非关闭按钮的关键词（避免误识别更多按钮、菜单按钮等）
-                    resource_id = elem.attrib.get('resource-id', '')
-                    exclude_keywords = ['more', 'menu', 'setting', 'settings', 'option', 'options', 
-                                       'share', 'favorite', 'like', 'comment', 'follow', 'download']
-                    if any(kw in resource_id.lower() for kw in exclude_keywords):
-                        score = 0  # 排除这些元素
-                    else:
-                        min_size = max(20, int(screen_width * 0.03))
-                        max_size = max(120, int(screen_width * 0.12))
-                        if min_size <= width <= max_size and min_size <= height <= max_size:
-                            # 基于位置评分：角落位置加分
-                            rel_x = center_x / screen_width
-                            rel_y = center_y / screen_height
-                            
-                            # 右上角得分最高
-                            if rel_x > 0.6 and rel_y < 0.5:
-                                score = 70 + (rel_x - 0.6) * 50 + (0.5 - rel_y) * 50
-                                reason = f"右上角小元素 {width}x{height}px"
-                            # 左上角
-                            elif rel_x < 0.4 and rel_y < 0.5:
-                                score = 60 + (0.4 - rel_x) * 50 + (0.5 - rel_y) * 50
-                                reason = f"左上角小元素 {width}x{height}px"
-                            # 其他位置的小元素
-                            elif 'Image' in class_name:
-                                score = 50
-                                reason = f"图片元素 {width}x{height}px"
-                            else:
-                                score = 40
-                                reason = f"小型可点击元素 {width}x{height}px"
+                    min_size = max(20, int(screen_width * 0.03))
+                    max_size = max(120, int(screen_width * 0.12))
+                    if min_size <= width <= max_size and min_size <= height <= max_size:
+                        # 基于位置评分：角落位置加分
+                        rel_x = center_x / screen_width
+                        rel_y = center_y / screen_height
+                        
+                        # 右上角得分最高
+                        if rel_x > 0.6 and rel_y < 0.5:
+                            score = 70 + (rel_x - 0.6) * 50 + (0.5 - rel_y) * 50
+                            reason = f"右上角小元素 {width}x{height}px"
+                        # 左上角
+                        elif rel_x < 0.4 and rel_y < 0.5:
+                            score = 60 + (0.4 - rel_x) * 50 + (0.5 - rel_y) * 50
+                            reason = f"左上角小元素 {width}x{height}px"
+                        # 其他位置的小元素
+                        elif 'Image' in class_name:
+                            score = 50
+                            reason = f"图片元素 {width}x{height}px"
+                        else:
+                            score = 40
+                            reason = f"小型可点击元素 {width}x{height}px"
                 
                 if score > 0:
-                    candidate = {
+                    candidates.append({
                         'score': score,
                         'reason': reason,
                         'bounds': bounds_str,
@@ -3122,795 +2717,270 @@ class BasicMobileToolsLite:
                         'center_y': center_y,
                         'x_percent': x_percent,
                         'y_percent': y_percent,
-                        'size': f"{width}x{height}",
-                        'text': text,
-                        'content_desc': content_desc,
-                        'class': class_name,
-                        'clickable': clickable
-                    }
-                    # 尝试获取 resource-id（如果存在）
-                    resource_id = elem.attrib.get('resource-id', '')
-                    if resource_id:
-                        candidate['resource_id'] = resource_id
-                    candidates.append(candidate)
+                        'size': f"{width}x{height}"
+                    })
             
             if not candidates:
-                # 没找到，不截图（优化：避免频繁截图）
-                # 调用者可以使用 mobile_close_popup() 作为降级方案
+                # 没找到，截图让 AI 分析
+                screenshot_result = self.take_screenshot(description="找关闭按钮", compress=True)
                 return {
                     "success": False,
-                    "message": "❌ 元素树未找到关闭按钮",
+                    "message": "❌ 元素树未找到关闭按钮，已截图供 AI 分析",
+                    "screenshot": screenshot_result.get("screenshot_path", ""),
                     "screen_size": {"width": screen_width, "height": screen_height},
-                    "tip": "建议：1) 使用 mobile_close_popup() 作为降级方案（可能截图） 2) 或手动调用 mobile_screenshot_with_som() 进行AI分析"
+                    "image_size": {
+                        "width": screenshot_result.get("image_width"),
+                        "height": screenshot_result.get("image_height")
+                    },
+                    "original_size": {
+                        "width": screenshot_result.get("original_img_width"),
+                        "height": screenshot_result.get("original_img_height")
+                    },
+                    "tip": "请分析截图找到 X 关闭按钮，然后调用 mobile_click_by_percent(x_percent, y_percent)"
                 }
             
             # 按得分排序
             candidates.sort(key=lambda x: x['score'], reverse=True)
             best = candidates[0]
             
-            # 构建关闭按钮信息（优化：包含更多点击方式）
-            close_button_info = {
-                    "reason": best['reason'],
-                    "center": {"x": best['center_x'], "y": best['center_y']},
-                    "percent": {"x": best['x_percent'], "y": best['y_percent']},
-                    "bounds": best['bounds'],
-                    "size": best['size'],
-                    "score": best['score']
-            }
-            
-            # 添加可用的点击方式（优化：优先使用 resource_id 或 text）
-            if best.get('resource_id'):
-                close_button_info['resource_id'] = best['resource_id']
-                click_command = f"mobile_click_by_id('{best['resource_id']}')"
-            elif best.get('text'):
-                close_button_info['text'] = best['text']
-                click_command = f"mobile_click_by_text('{best['text']}')"
-            else:
-                click_command = f"mobile_click_by_percent({best['x_percent']}, {best['y_percent']})"
-            
+            # Token 优化：只返回最必要的信息
             return {
                 "success": True,
-                "message": f"✅ 找到可能的关闭按钮",
-                "close_button": close_button_info,  # 优化：统一字段名
-                "best_candidate": close_button_info,  # 保持向后兼容
-                "click_command": click_command,
-                "other_candidates": [
-                    {"reason": c['reason'], "percent": f"({c['x_percent']}%, {c['y_percent']}%)", "score": c['score']}
-                    for c in candidates[1:4]
-                ] if len(candidates) > 1 else [],
-                "screen_size": {"width": screen_width, "height": screen_height}
+                "popup": True,
+                "close": {"x": best['x_percent'], "y": best['y_percent']},
+                "cmd": f"click_by_percent({best['x_percent']},{best['y_percent']})"
             }
             
         except Exception as e:
-            return {"success": False, "message": f"❌ 查找关闭按钮失败: {e}"}
+            return {"success": False, "msg": str(e)}
     
-    def _analyze_page_for_popup(self) -> Dict:
-        """分析页面是否有弹窗（用于启动应用后、异常情况等场景）
+    def close_popup(self) -> Dict:
+        """智能关闭弹窗（改进版）
         
-        Returns:
-            包含 has_popup 和 popup_info 的字典
-        """
-        try:
-            if self._is_ios():
-                return {"has_popup": False, "popup_info": None}
-            
-            # 获取元素列表
-            elements = self.list_elements()
-            
-            # 分析页面内容
-            page_analysis = self._detect_page_content(elements)
-            
-            return {
-                "has_popup": page_analysis.get("has_popup", False),
-                "popup_info": page_analysis.get("popup_info")
-            }
-        except Exception:
-            return {"has_popup": False, "popup_info": None}
-    
-    def _detect_page_content(self, elements: List[Dict], 
-                              confidence_threshold: float = None,
-                              xml_string: str = None) -> Dict:
-        """基于元素列表识别页面内容
+        核心改进：先检测弹窗区域，再在弹窗范围内查找关闭按钮
         
-        使用全局常量 CONFIRM_BUTTON_TEXTS、CLOSE_BUTTON_TEXTS、
-        CONFIRM_BUTTON_KEYWORDS、CLOSE_BUTTON_KEYWORDS
+        策略（优先级从高到低）：
+        1. 检测弹窗区域（非全屏的大面积容器）
+        2. 在弹窗边界内查找关闭相关的文本/描述（×、X、关闭、close 等）
+        3. 在弹窗边界内查找小尺寸的 clickable 元素（优先边角位置）
+        4. 如果都找不到，截图让 AI 视觉识别
         
-        Args:
-            elements: 元素列表
-            confidence_threshold: 弹窗检测置信度阈值，默认使用 DEFAULT_POPUP_CONFIDENCE_THRESHOLD
-            xml_string: 预先获取的 XML 字符串（可选，避免重复调用）
-            
-        Returns:
-            {
-                "main_content": {...},  # 主要功能区域
-                "has_popup": bool,      # 是否有弹窗
-                "popup_info": {...},     # 弹窗信息
-                "interactive_elements": [...]  # 可交互元素
-            }
+        适配策略：
+        - X 按钮可能在任意位置（上下左右都支持）
+        - 使用百分比坐标记录，跨分辨率兼容
         """
-        if confidence_threshold is None:
-            confidence_threshold = DEFAULT_POPUP_CONFIDENCE_THRESHOLD
-        
-        if self._is_ios():
-            return self._detect_page_content_ios(elements, confidence_threshold)
-        
-        screen_width = self.client.u2.info.get('displayWidth', 720)
-        screen_height = self.client.u2.info.get('displayHeight', 1280)
-        
-        # 获取可交互元素
-        interactive_elements = [
-            elem for elem in elements 
-            if elem.get("clickable") is True or str(elem.get("clickable", "")).lower() == "true"
-        ]
-        
-        # 分析是否有弹窗（基于元素特征）
-        has_popup = False
-        popup_info = None
-        
-        # 通过XML检测弹窗（更准确）
         try:
-            if xml_string is None:
-                xml_string = self.client.u2.dump_hierarchy(compressed=False)
+            import re
             import xml.etree.ElementTree as ET
-            root = ET.fromstring(xml_string)
-            popup_bounds, popup_confidence = self._detect_popup_with_confidence(
-                root, screen_width, screen_height
-            )
-            if popup_bounds and popup_confidence >= confidence_threshold:
-                has_popup = True
-                popup_info = {
-                    "bounds": popup_bounds,
-                    "confidence": popup_confidence,
-                    "detected_by": "xml_structure"
-                }
-        except Exception:
-            pass
-        
-        # 如果没有通过XML检测到，检查是否有明显的弹窗按钮特征
-        if not has_popup:
-            for elem in interactive_elements:
-                text = elem.get("text", "")
-                resource_id = elem.get("resource_id", "")
-                content_desc = elem.get("content_desc", "")
-                
-                # 检查文本是否匹配确认按钮（优先检测）
-                if text in CONFIRM_BUTTON_TEXTS:
-                    has_popup = True
-                    popup_info = {"detected_by": "confirm_button_text", "text": text}
-                    break
-                
-                # 检查文本是否匹配关闭按钮
-                if text in CLOSE_BUTTON_TEXTS:
-                    has_popup = True
-                    popup_info = {"detected_by": "close_button_text", "text": text}
-                    break
-                
-                # 检查 resource-id 是否包含确认关键词
-                if any(kw in resource_id.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                    has_popup = True
-                    popup_info = {"detected_by": "confirm_button_id", "resource_id": resource_id}
-                    break
-                
-                # 检查 resource-id 是否包含关闭关键词
-                if any(kw in resource_id.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                    has_popup = True
-                    popup_info = {"detected_by": "close_button_id", "resource_id": resource_id}
-                    break
-                
-                # 检查 content-desc 是否包含确认关键词
-                if any(kw in content_desc.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                    has_popup = True
-                    popup_info = {"detected_by": "confirm_button_desc", "content_desc": content_desc}
-                    break
-                
-                # 检查 content-desc 是否包含关闭关键词
-                if any(kw in content_desc.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                    has_popup = True
-                    popup_info = {"detected_by": "close_button_desc", "content_desc": content_desc}
-                    break
-        
-        return {
-            "has_popup": has_popup,
-            "popup_info": popup_info,
-            "interactive_elements": interactive_elements,
-            "total_elements": len(elements)
-        }
-    
-    def _detect_page_content_ios(self, elements: List[Dict], confidence_threshold: float) -> Dict:
-        """iOS 平台基于元素列表识别页面内容
-        
-        Args:
-            elements: 元素列表
-            confidence_threshold: 弹窗检测置信度阈值
-            
-        Returns:
-            页面内容分析结果
-        """
-        # 获取可交互元素
-        interactive_elements = [
-            elem for elem in elements 
-            if elem.get("type") in ['XCUIElementTypeButton', 'XCUIElementTypeLink', 'XCUIElementTypeCell']
-        ]
-        
-        has_popup = False
-        popup_info = None
-        
-        # iOS 弹窗检测：检查是否有 Alert/Sheet 类型元素
-        for elem in elements:
-            elem_type = elem.get("type", "")
-            if elem_type in IOS_POPUP_TYPES:
-                has_popup = True
-                popup_info = {
-                    "detected_by": "ios_popup_type",
-                    "type": elem_type,
-                    "bounds": elem.get("bounds")
-                }
-                break
-        
-        # 如果没有检测到系统弹窗，检查是否有确认/关闭按钮文本
-        if not has_popup:
-            for elem in interactive_elements:
-                text = elem.get("label", "") or elem.get("text", "") or ""
-                # 优先检测确认按钮
-                if text in CONFIRM_BUTTON_TEXTS:
-                    has_popup = True
-                    popup_info = {"detected_by": "confirm_button_text", "text": text}
-                    break
-                # 其次检测关闭按钮
-                if text in CLOSE_BUTTON_TEXTS:
-                    has_popup = True
-                    popup_info = {"detected_by": "close_button_text", "text": text}
-                    break
-        
-        return {
-            "has_popup": has_popup,
-            "popup_info": popup_info,
-            "interactive_elements": interactive_elements,
-            "total_elements": len(elements)
-        }
-    
-    def _find_close_button_in_elements(self, elements: List[Dict], page_analysis: Dict = None) -> Optional[Dict]:
-        """在元素列表中查找关闭按钮
-        
-        优先级顺序：
-        1. 确认性按钮（同意、确认、允许等）- 最高优先级
-        2. 关闭/取消按钮（关闭、取消、跳过等）- 次优先级
-        3. 小尺寸可点击元素（可能是 X 图标）- 最低优先级
-        
-        使用全局常量 CONFIRM_BUTTON_TEXTS、CLOSE_BUTTON_TEXTS、
-        CONFIRM_BUTTON_KEYWORDS、CLOSE_BUTTON_KEYWORDS、EXCLUDE_ELEMENT_KEYWORDS
-        
-        Args:
-            elements: 元素列表
-            page_analysis: 页面分析结果（可选）
-            
-        Returns:
-            关闭按钮信息，如果未找到返回None
-        """
-        if self._is_ios():
-            return self._find_close_button_in_elements_ios(elements)
-        
-        screen_width = self.client.u2.info.get('displayWidth', 720)
-        screen_height = self.client.u2.info.get('displayHeight', 1280)
-        
-        candidates = []
-        
-        for elem in elements:
-            text = elem.get("text", "").strip()
-            content_desc = elem.get("content_desc", "").strip()
-            resource_id = elem.get("resource_id", "").strip()
-            bounds = elem.get("bounds", "")
-            clickable = elem.get("clickable", False)
-            
-            if not bounds:
-                continue
-            
-            # 解析 bounds
-            match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
-            if not match:
-                continue
-            
-            x1, y1, x2, y2 = map(int, match.groups())
-            width = x2 - x1
-            height = y2 - y1
-            center_x = (x1 + x2) // 2
-            center_y = (y1 + y2) // 2
-            
-            # 计算百分比
-            x_percent = round(center_x / screen_width * 100, 1)
-            y_percent = round(center_y / screen_height * 100, 1)
-            
-            score = 0
-            reason = ""
-            
-            # 策略1：确认性按钮文本（最高优先级）- 优先点击同意、确认等
-            if text in CONFIRM_BUTTON_TEXTS:
-                score = 120  # 最高分
-                reason = f"确认按钮文本='{text}'"
-            
-            # 策略2：确认类 resource-id 匹配
-            elif any(kw in resource_id.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                score = 115
-                reason = f"确认按钮ID='{resource_id}'"
-            
-            # 策略3：确认类 content-desc 匹配
-            elif any(kw in content_desc.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                score = 110
-                reason = f"确认按钮描述='{content_desc}'"
-            
-            # 策略4：关闭/取消按钮文本（次优先级）
-            elif text in CLOSE_BUTTON_TEXTS:
-                score = 100
-                reason = f"关闭按钮文本='{text}'"
-            
-            # 策略5：关闭类 resource-id 匹配
-            elif any(kw in resource_id.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                score = 95
-                reason = f"关闭按钮ID='{resource_id}'"
-            
-            # 策略6：关闭类 content-desc 匹配
-            elif any(kw in content_desc.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                score = 90
-                reason = f"关闭按钮描述='{content_desc}'"
-            
-            # 策略7：小尺寸的 clickable 元素（可能是 X 图标）- 最低优先级
-            elif clickable:
-                # 排除非关闭按钮的关键词 - 使用全局常量
-                if any(kw in resource_id.lower() for kw in EXCLUDE_ELEMENT_KEYWORDS):
-                    score = 0  # 排除这些元素
-                elif any(kw in content_desc.lower() for kw in EXCLUDE_ELEMENT_KEYWORDS):
-                    score = 0  # 排除这些元素
-                else:
-                    min_size = max(20, int(screen_width * 0.03))
-                    max_size = max(120, int(screen_width * 0.15))
-                    if min_size <= width <= max_size and min_size <= height <= max_size:
-                        rel_x = center_x / screen_width
-                        rel_y = center_y / screen_height
-                        
-                        # 右上角得分最高
-                        if rel_x > 0.6 and rel_y < 0.5:
-                            score = 70 + (rel_x - 0.6) * 50 + (0.5 - rel_y) * 50
-                            reason = f"右上角小元素 {width}x{height}px"
-                        # 左上角
-                        elif rel_x < 0.4 and rel_y < 0.5:
-                            score = 60 + (0.4 - rel_x) * 50 + (0.5 - rel_y) * 50
-                            reason = f"左上角小元素 {width}x{height}px"
-                        else:
-                            score = 40
-                            reason = f"小型可点击元素 {width}x{height}px"
-            
-            if score > 0:
-                candidates.append({
-                    'score': score,
-                    'reason': reason,
-                    'bounds': bounds,
-                    'center_x': center_x,
-                    'center_y': center_y,
-                    'x_percent': x_percent,
-                    'y_percent': y_percent,
-                    'text': text,
-                    'resource_id': resource_id,
-                    'content_desc': content_desc
-                })
-        
-        if not candidates:
-            return None
-        
-        # 按得分排序，返回最佳候选（确认按钮优先）
-        candidates.sort(key=lambda x: x['score'], reverse=True)
-        return candidates[0]
-    
-    def _find_close_button_in_elements_ios(self, elements: List[Dict]) -> Optional[Dict]:
-        """iOS 平台在元素列表中查找关闭按钮
-        
-        优先级顺序：
-        1. 确认性按钮（同意、确认、允许等）- 最高优先级
-        2. 关闭/取消按钮（关闭、取消、跳过等）- 次优先级
-        3. 小尺寸可点击元素（可能是 X 图标）- 最低优先级
-        
-        Args:
-            elements: 元素列表
-            
-        Returns:
-            关闭按钮信息，如果未找到返回None
-        """
-        ios_client = self._get_ios_client()
-        if not ios_client:
-            return None
-        
-        try:
-            screen_size = ios_client.window_size()
-            screen_width = screen_size.width
-            screen_height = screen_size.height
-        except:
-            screen_width = 375
-            screen_height = 812
-        
-        candidates = []
-        
-        for elem in elements:
-            text = elem.get("text", "") or elem.get("label", "") or ""
-            text = text.strip()
-            elem_type = elem.get("type", "")
-            bounds = elem.get("bounds", {})
-            
-            # iOS bounds 格式不同
-            if isinstance(bounds, dict):
-                x = bounds.get("x", 0)
-                y = bounds.get("y", 0)
-                width = bounds.get("width", 0)
-                height = bounds.get("height", 0)
-            else:
-                continue
             
-            center_x = int(x + width / 2)
-            center_y = int(y + height / 2)
-            x_percent = round(center_x / screen_width * 100, 1)
-            y_percent = round(center_y / screen_height * 100, 1)
-            
-            score = 0
-            reason = ""
-            
-            # 策略1：确认性按钮文本（最高优先级）
-            if text in CONFIRM_BUTTON_TEXTS:
-                score = 120
-                reason = f"确认按钮文本='{text}'"
-            
-            # 策略2：确认类关键词匹配
-            elif any(kw in text.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                score = 115
-                reason = f"确认按钮关键词: '{text}'"
-            
-            # 策略3：关闭/取消按钮文本（次优先级）
-            elif text in CLOSE_BUTTON_TEXTS:
-                score = 100
-                reason = f"关闭按钮文本='{text}'"
-            
-            # 策略4：关闭类关键词匹配
-            elif any(kw in text.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                score = 95
-                reason = f"关闭按钮关键词: '{text}'"
-            
-            # 策略5：XCUIElementTypeButton 类型的小元素（最低优先级）
-            elif elem_type == 'XCUIElementTypeButton':
-                if 20 <= width <= 60 and 20 <= height <= 60:
-                    rel_x = center_x / screen_width
-                    rel_y = center_y / screen_height
-                    if rel_x > 0.7 and rel_y < 0.3:
-                        score = 70
-                        reason = f"右上角小按钮 {width}x{height}px"
-            
-            if score > 0:
-                candidates.append({
-                    'score': score,
-                    'reason': reason,
-                    'bounds': f"[{x},{y}][{x+width},{y+height}]",
-                    'center_x': center_x,
-                    'center_y': center_y,
-                    'x_percent': x_percent,
-                    'y_percent': y_percent,
-                    'text': text,
-                    'resource_id': '',
-                    'content_desc': ''
-                })
-        
-        if not candidates:
-            return None
-        
-        # 按得分排序（确认按钮优先）
-        candidates.sort(key=lambda x: x['score'], reverse=True)
-        return candidates[0]
-    
-    def _close_popup_by_elements(self, elements: List[Dict] = None, 
-                                   xml_string: str = None,
-                                   confidence_threshold: float = None,
-                                   page_fingerprint_before: Dict = None) -> Dict:
-        """阶段1：通过控件树关闭弹窗（最快、最可靠）
-        
-        Args:
-            elements: 预获取的元素列表（可选，避免重复调用）
-            xml_string: 预获取的 XML 字符串（可选，避免重复调用）
-            confidence_threshold: 弹窗检测置信度阈值
-            page_fingerprint_before: 操作前的页面指纹（用于验证）
-            
-        Returns:
-            关闭结果
-        """
-        try:
-            if self._is_ios():
-                return {"success": False, "reason": "iOS 请使用 _close_popup_ios"}
-            
-            if confidence_threshold is None:
-                confidence_threshold = DEFAULT_POPUP_CONFIDENCE_THRESHOLD
-            
-            # 1. 获取元素列表（复用或新获取）
-            if elements is None:
-                elements = self.list_elements()
-            
-            # 2. 分析页面内容（传入预获取的 XML）
-            page_analysis = self._detect_page_content(
-                elements, 
-                confidence_threshold=confidence_threshold,
-                xml_string=xml_string
-            )
-            
-            # 3. 如果没有弹窗，直接返回
-            if not page_analysis.get("has_popup"):
-                return {"success": False, "reason": "未检测到弹窗", "method": "elements"}
-            
-            # 4. 查找关闭按钮
-            close_button = self._find_close_button_in_elements(elements, page_analysis)
-            
-            # 5. 如果找到，点击
-            if close_button:
-                center_x = close_button['center_x']
-                center_y = close_button['center_y']
-                
-                self.client.u2.click(center_x, center_y)
-                time.sleep(0.5)
-                
-                # 检查应用是否跳转
-                app_check = self._check_app_switched()
-                return_result = None
-                if app_check['switched']:
-                    return_result = self._return_to_target_app()
-                
-                # 【优化】使用页面指纹对比验证
-                verified = self._verify_popup_closed_with_fingerprint(page_fingerprint_before)
-                
-                msg = f"✅ 通过控件树找到关闭按钮并点击\n"
-                msg += f"   原因: {close_button['reason']}\n"
-                msg += f"   位置: ({center_x}, {center_y}) [({close_button['x_percent']}%, {close_button['y_percent']}%)]"
-                if close_button.get('text'):
-                    msg += f"\n   文本: {close_button['text']}"
-                if close_button.get('resource_id'):
-                    msg += f"\n   ID: {close_button['resource_id']}"
-                
-                if app_check['switched']:
-                    msg += f"\n⚠️ 应用已跳转"
-                    if return_result and return_result.get('success'):
-                        msg += f"\n{return_result['message']}"
-                
-                if not verified:
-                    msg += f"\n⚠️ 验证失败：弹窗可能未完全关闭"
-                
-                return {
-                    "success": verified,
-                    "method": "elements",
-                    "message": msg,
-                    "clicked": {
-                        "center": (center_x, center_y),
-                        "percent": (close_button['x_percent'], close_button['y_percent']),
-                        "reason": close_button['reason']
-                    },
-                    "app_check": app_check,
-                    "return_to_app": return_result,
-                    "verified": verified
-                }
-            
-            return {"success": False, "reason": "控件树中未找到关闭按钮", "method": "elements"}
-            
-        except Exception as e:
-            return {"success": False, "reason": f"控件树方法失败: {e}", "method": "elements"}
-    
-    def _close_popup_by_screenshot_ai(self, elements: List[Dict] = None) -> Dict:
-        """阶段2：通过截图AI分析关闭弹窗（仅在控件树失败时）
-        
-        【优化】提供关闭按钮候选建议，形成闭环
-        
-        Args:
-            elements: 预获取的元素列表（可选）
-            
-        Returns:
-            关闭结果（包含候选建议，需要AI分析后确定最终操作）
-        """
-        try:
+            # 获取屏幕尺寸
             if self._is_ios():
-                return {"success": False, "reason": "iOS 暂不支持"}
-            
-            # 截图（带SoM标注）
-            som_result = self.take_screenshot_with_som()
-            
-            # 【优化】基于元素列表提供关闭按钮候选建议
-            close_button_candidates = []
-            if elements is None:
-                elements = self.list_elements()
-            
-            # 查找所有可能的关闭按钮
-            for elem in elements:
-                text = elem.get("text", "").strip()
-                resource_id = elem.get("resource_id", "").strip()
-                content_desc = elem.get("content_desc", "").strip()
-                bounds = elem.get("bounds", "")
-                
-                if not bounds:
-                    continue
-                
-                match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
-                if not match:
-                    continue
-                
-                x1, y1, x2, y2 = map(int, match.groups())
-                center_x = (x1 + x2) // 2
-                center_y = (y1 + y2) // 2
-                
-                screen_width = self.client.u2.info.get('displayWidth', 720)
-                screen_height = self.client.u2.info.get('displayHeight', 1280)
-                x_percent = round(center_x / screen_width * 100, 1)
-                y_percent = round(center_y / screen_height * 100, 1)
-                
-                score = 0
-                reason = ""
-                
-                # 检查是否是确认按钮（优先）
-                if text in CONFIRM_BUTTON_TEXTS:
-                    score = 120
-                    reason = f"确认按钮文本='{text}'"
-                elif any(kw in resource_id.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                    score = 115
-                    reason = f"确认按钮ID: {resource_id}"
-                elif any(kw in content_desc.lower() for kw in CONFIRM_BUTTON_KEYWORDS):
-                    score = 110
-                    reason = f"确认按钮描述: {content_desc}"
-                # 检查是否是关闭按钮（次优先）
-                elif text in CLOSE_BUTTON_TEXTS:
-                    score = 100
-                    reason = f"关闭按钮文本='{text}'"
-                elif any(kw in resource_id.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                    score = 95
-                    reason = f"关闭按钮ID: {resource_id}"
-                elif any(kw in content_desc.lower() for kw in CLOSE_BUTTON_KEYWORDS):
-                    score = 90
-                    reason = f"关闭按钮描述: {content_desc}"
-                
-                if score > 0:
-                    # 确定推荐操作方式
-                    if text in CONFIRM_BUTTON_TEXTS or text in CLOSE_BUTTON_TEXTS:
-                        suggested_action = f"mobile_click_by_text('{text}')"
-                    else:
-                        suggested_action = f"mobile_click_by_percent({x_percent}, {y_percent})"
-                    
-                    close_button_candidates.append({
-                        'score': score,
-                        'reason': reason,
-                        'text': text,
-                        'resource_id': resource_id,
-                        'center_x': center_x,
-                        'center_y': center_y,
-                        'x_percent': x_percent,
-                        'y_percent': y_percent,
-                        'suggested_action': suggested_action
-                    })
-            
-            # 按分数排序
-            close_button_candidates.sort(key=lambda x: x['score'], reverse=True)
+                return {"success": False, "msg": "iOS暂不支持"}
             
-            # 返回结果，包含候选建议
-            return {
-                "success": False,  # 需要AI分析后才能确定
-                "method": "screenshot_ai",
-                "message": "已截图，等待AI分析",
-                "screenshot": som_result.get("screenshot_path"),
-                "elements": som_result.get("elements", []),
-                "popup_detected": som_result.get("popup_detected", False),
-                "close_button_candidates": close_button_candidates[:5],  # 返回前5个候选
-                "next_step": "AI分析截图后，根据分析结果调用对应的点击方法"
-            }
+            screen_width = self.client.u2.info.get('displayWidth', 720)
+            screen_height = self.client.u2.info.get('displayHeight', 1280)
             
-        except Exception as e:
-            return {"success": False, "reason": f"截图AI方法失败: {e}", "method": "screenshot_ai"}
-    
-    def _close_popup_by_template(self, page_fingerprint_before: Dict = None) -> Dict:
-        """阶段3：通过模板匹配关闭弹窗（最精确的兜底方案）
-        
-        Args:
-            page_fingerprint_before: 操作前的页面指纹（用于验证）
+            # 获取原始 XML
+            xml_string = self.client.u2.dump_hierarchy(compressed=False)
             
-        Returns:
-            关闭结果
-        """
-        try:
-            if self._is_ios():
-                return {"success": False, "reason": "iOS 暂不支持"}
+            # 关闭按钮的文本特征
+            close_texts = ['×', 'X', 'x', '关闭', '取消', 'close', 'Close', 'CLOSE', '跳过', '知道了']
+            close_desc_keywords = ['关闭', 'close', 'dismiss', 'cancel', '跳过']
             
-            # 模板匹配
-            match_result = self.template_match_close()
+            close_candidates = []
+            popup_bounds = None  # 弹窗区域
             
-            # 如果找到匹配，点击
-            if match_result.get("success") and match_result.get("matches"):
-                best_match = match_result["matches"][0]
-                x, y = best_match["center"]
-                
-                self.client.u2.click(x, y)
-                time.sleep(0.5)
-                
-                # 检查应用是否跳转
-                app_check = self._check_app_switched()
-                return_result = None
-                if app_check['switched']:
-                    return_result = self._return_to_target_app()
-                
-                # 【优化】使用页面指纹对比验证
-                verified = self._verify_popup_closed_with_fingerprint(page_fingerprint_before)
+            # 解析 XML
+            try:
+                root = ET.fromstring(xml_string)
+                all_elements = list(root.iter())
                 
-                msg = f"✅ 通过模板匹配找到关闭按钮并点击\n"
-                msg += f"   模板: {best_match.get('template', 'unknown')}\n"
-                msg += f"   置信度: {best_match.get('confidence', 0):.1f}%\n"
-                msg += f"   位置: ({x}, {y})"
+                # ===== 第一步：使用严格的置信度检测弹窗区域 =====
+                popup_bounds, popup_confidence = self._detect_popup_with_confidence(
+                    root, screen_width, screen_height
+                )
                 
-                if app_check['switched']:
-                    msg += f"\n⚠️ 应用已跳转"
-                    if return_result and return_result.get('success'):
-                        msg += f"\n{return_result['message']}"
+                # 如果置信度不够高，记录但继续尝试查找关闭按钮
+                popup_detected = popup_bounds is not None and popup_confidence >= 0.6
                 
-                if not verified:
-                    msg += f"\n⚠️ 验证失败：弹窗可能未完全关闭"
+                # 🔴 关键检查：如果没有检测到弹窗区域，直接返回"无弹窗"
+                # 避免误点击普通页面上的"关闭"、"取消"等按钮
+                if not popup_detected:
+                    return {"success": True, "popup": False}
                 
-                return {
-                    "success": verified,
-                    "method": "template",
-                    "message": msg,
-                    "clicked": {"center": (x, y)},
-                    "app_check": app_check,
-                    "return_to_app": return_result,
-                    "verified": verified
-                }
+                # ===== 第二步：在弹窗范围内查找关闭按钮 =====
+                for idx, elem in enumerate(all_elements):
+                    text = elem.attrib.get('text', '')
+                    content_desc = elem.attrib.get('content-desc', '')
+                    bounds_str = elem.attrib.get('bounds', '')
+                    class_name = elem.attrib.get('class', '')
+                    clickable = elem.attrib.get('clickable', 'false') == 'true'
+                    
+                    if not bounds_str:
+                        continue
+                    
+                    # 解析 bounds
+                    match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                    if not match:
+                        continue
+                    
+                    x1, y1, x2, y2 = map(int, match.groups())
+                    width = x2 - x1
+                    height = y2 - y1
+                    center_x = (x1 + x2) // 2
+                    center_y = (y1 + y2) // 2
+                    
+                    # 如果检测到弹窗区域，检查元素是否在弹窗范围内或附近
+                    in_popup = True
+                    popup_edge_bonus = 0
+                    is_floating_close = False  # 是否是浮动关闭按钮（在弹窗外部上方）
+                    if popup_bounds:
+                        px1, py1, px2, py2 = popup_bounds
+                        
+                        # 关闭按钮可能在弹窗外部（常见设计：X 按钮浮在弹窗右上角外侧）
+                        # 扩大搜索范围：弹窗上方 200 像素，右侧 50 像素
+                        margin_top = 200  # 上方扩展范围（关闭按钮常在弹窗上方）
+                        margin_side = 50  # 左右扩展范围
+                        margin_bottom = 30  # 下方扩展范围
+                        
+                        in_popup = (px1 - margin_side <= center_x <= px2 + margin_side and 
+                                   py1 - margin_top <= center_y <= py2 + margin_bottom)
+                        
+                        # 检查是否是浮动关闭按钮（在弹窗外侧：上方或下方）
+                        # 上方浮动关闭按钮（常见：右上角外侧）
+                        if center_y < py1 and center_y > py1 - margin_top:
+                            if center_x > (px1 + px2) / 2:  # 在弹窗右半部分上方
+                                is_floating_close = True
+                        # 下方浮动关闭按钮（常见：底部中间外侧）
+                        elif center_y > py2 and center_y < py2 + margin_top:
+                            # 下方关闭按钮通常在中间位置
+                            if abs(center_x - (px1 + px2) / 2) < (px2 - px1) / 2:
+                                is_floating_close = True
+                        
+                        if in_popup:
+                            # 计算元素是否在弹窗边缘（关闭按钮通常在边缘）
+                            dist_to_top = abs(center_y - py1)
+                            dist_to_bottom = abs(center_y - py2)
+                            dist_to_left = abs(center_x - px1)
+                            dist_to_right = abs(center_x - px2)
+                            min_dist = min(dist_to_top, dist_to_bottom, dist_to_left, dist_to_right)
+                            
+                            # 在弹窗边缘 100 像素内的元素加分
+                            if min_dist < 100:
+                                popup_edge_bonus = 3.0 * (1 - min_dist / 100)
+                        
+                        # 浮动关闭按钮（在弹窗上方外侧）给予高额加分
+                        if is_floating_close:
+                            popup_edge_bonus += 5.0  # 大幅加分
+                    
+                    if not in_popup:
+                        continue
+                    
+                    # 相对位置（0-1）
+                    rel_x = center_x / screen_width
+                    rel_y = center_y / screen_height
+                    
+                    score = 0
+                    match_type = ""
+                    position = self._get_position_name(rel_x, rel_y)
+                    
+                    # ===== 策略1：精确匹配关闭文本（最高优先级）=====
+                    if text in close_texts:
+                        score = 15.0 + popup_edge_bonus
+                        match_type = f"text='{text}'"
+                    
+                    # ===== 策略2：content-desc 包含关闭关键词 =====
+                    elif any(kw in content_desc.lower() for kw in close_desc_keywords):
+                        score = 12.0 + popup_edge_bonus
+                        match_type = f"desc='{content_desc}'"
+                    
+                    # ===== 策略3：clickable 的小尺寸元素（优先于非 clickable）=====
+                    elif clickable:
+                        min_size = max(20, int(screen_width * 0.03))
+                        max_size = max(120, int(screen_width * 0.15))
+                        if min_size <= width <= max_size and min_size <= height <= max_size:
+                            # clickable 元素基础分更高
+                            base_score = 8.0
+                            # 浮动关闭按钮给予最高分
+                            if is_floating_close:
+                                base_score = 12.0
+                                match_type = "floating_close"
+                            elif 'Image' in class_name:
+                                score = base_score + 2.0
+                                match_type = "clickable_image"
+                            else:
+                                match_type = "clickable"
+                            score = base_score + self._get_position_score(rel_x, rel_y) + popup_edge_bonus
+                    
+                    # ===== 策略4：ImageView/ImageButton 类型的小元素（非 clickable）=====
+                    elif 'Image' in class_name:
+                        min_size = max(15, int(screen_width * 0.02))
+                        max_size = max(120, int(screen_width * 0.12))
+                        if min_size <= width <= max_size and min_size <= height <= max_size:
+                            score = 5.0 + self._get_position_score(rel_x, rel_y) + popup_edge_bonus
+                            match_type = "ImageView"
+                    
+                    # XML 顺序加分（后出现的元素在上层，更可能是弹窗内的元素）
+                    if score > 0:
+                        xml_order_bonus = idx / len(all_elements) * 2.0  # 最多加 2 分
+                        score += xml_order_bonus
+                        
+                        close_candidates.append({
+                            'bounds': bounds_str,
+                            'center_x': center_x,
+                            'center_y': center_y,
+                            'width': width,
+                            'height': height,
+                            'score': score,
+                            'position': position,
+                            'match_type': match_type,
+                            'text': text,
+                            'content_desc': content_desc,
+                            'x_percent': round(rel_x * 100, 1),
+                            'y_percent': round(rel_y * 100, 1),
+                            'in_popup': popup_detected
+                        })
+                        
+            except ET.ParseError:
+                pass
             
-            return {"success": False, "reason": "模板匹配未找到关闭按钮", "method": "template"}
+            if not close_candidates:
+                if popup_detected and popup_bounds:
+                    return {"success": False, "fallback": "vision", "popup": True}
+                return {"success": True, "popup": False}
             
-        except ImportError:
-            return {"success": False, "reason": "需要安装 opencv-python: pip install opencv-python", "method": "template"}
-        except Exception as e:
-            return {"success": False, "reason": f"模板匹配失败: {e}", "method": "template"}
-    
-    def _verify_popup_closed(self) -> bool:
-        """验证弹窗是否已关闭（简单版本）
-        
-        Returns:
-            True 如果弹窗已关闭，False 如果弹窗仍在
-        """
-        try:
-            time.sleep(0.5)
-            elements = self.list_elements()
-            page_analysis = self._detect_page_content(elements)
-            return not page_analysis.get("has_popup")
-        except Exception:
-            return False
-    
-    def _verify_popup_closed_with_fingerprint(self, fingerprint_before: Dict = None) -> bool:
-        """验证弹窗是否已关闭（使用页面指纹对比）
-        
-        Args:
-            fingerprint_before: 操作前的页面指纹
+            # 按得分排序，取最可能的
+            close_candidates.sort(key=lambda x: x['score'], reverse=True)
+            best = close_candidates[0]
             
-        Returns:
-            True 如果弹窗已关闭，False 如果弹窗仍在
-        """
-        try:
+            # 点击
+            self.client.u2.click(best['center_x'], best['center_y'])
             time.sleep(0.5)
             
-            # 获取当前元素列表
-            elements = self.list_elements()
+            # 🎯 关键步骤：检查应用是否跳转，如果跳转说明弹窗去除失败，需要返回目标应用
+            app_check = self._check_app_switched()
+            return_result = None
+            
+            if app_check['switched']:
+                # 应用已跳转，说明弹窗去除失败，尝试返回目标应用
+                return_result = self._return_to_target_app()
             
-            # 方法1：检查是否还有弹窗
-            page_analysis = self._detect_page_content(elements)
-            if not page_analysis.get("has_popup"):
-                return True
+            # 记录操作
+            self._record_click('percent', f"{best['x_percent']}%,{best['y_percent']}%", 
+                              best['x_percent'], best['y_percent'],
+                              element_desc=f"关闭按钮({best['position']})")
             
-            # 方法2：如果有操作前的指纹，对比页面变化
-            if fingerprint_before:
-                fingerprint_after = self._get_page_fingerprint(elements)
-                page_changed = self._compare_page_fingerprint(fingerprint_before, fingerprint_after)
-                
-                # 如果页面发生了明显变化，认为弹窗可能已关闭
-                # （即使检测到还有弹窗特征，也可能是新弹窗或检测误判）
-                if page_changed:
-                    return True
+            # Token 优化：精简返回值
+            result = {"success": True, "clicked": True}
+            if app_check['switched']:
+                result["switched"] = True
+                if return_result:
+                    result["returned"] = return_result['success']
             
-            return False
+            return result
             
-        except Exception:
-            return False
+        except Exception as e:
+            return {"success": False, "msg": str(e)}
     
     def _get_position_name(self, rel_x: float, rel_y: float) -> str:
         """根据相对坐标获取位置名称"""
@@ -3954,12 +3024,9 @@ class BasicMobileToolsLite:
         else:  # 中间区域
             return 0.5
 
-    def _detect_popup_with_confidence(self, root, screen_width: int, screen_height: int) -> Tuple[Optional[Tuple[int, int, int, int]], float]:
+    def _detect_popup_with_confidence(self, root, screen_width: int, screen_height: int) -> tuple:
         """严格的弹窗检测 - 使用置信度评分，避免误识别普通页面
         
-        使用全局常量 POPUP_CLASS_KEYWORDS、POPUP_ID_KEYWORDS、AD_POPUP_KEYWORDS、
-        PAGE_CONTENT_KEYWORDS、CLOSE_BUTTON_KEYWORDS
-        
         真正的弹窗特征：
         1. class 名称包含 Dialog/Popup/Alert/Modal/BottomSheet（强特征）
         2. resource-id 包含 dialog/popup/alert/modal（强特征）
@@ -3969,8 +3036,10 @@ class BasicMobileToolsLite:
         
         Returns:
             (popup_bounds, confidence) 或 (None, 0)
-            confidence >= DEFAULT_POPUP_CONFIDENCE_THRESHOLD 才认为是弹窗
+            confidence >= 0.6 才认为是弹窗
         """
+        import re
+        
         screen_area = screen_width * screen_height
         
         # 收集所有元素信息
@@ -3992,15 +3061,6 @@ class BasicMobileToolsLite:
             class_name = elem.attrib.get('class', '')
             resource_id = elem.attrib.get('resource-id', '')
             clickable = elem.attrib.get('clickable', 'false') == 'true'
-            text = elem.attrib.get('text', '')
-            
-            # 检查是否是关闭/确认按钮 - 使用全局常量
-            is_close_button = (
-                any(kw in resource_id.lower() for kw in CLOSE_BUTTON_KEYWORDS) or
-                any(kw in resource_id.lower() for kw in CONFIRM_BUTTON_KEYWORDS) or
-                text in CLOSE_BUTTON_TEXTS or
-                text in CONFIRM_BUTTON_TEXTS
-            )
             
             all_elements.append({
                 'idx': idx,
@@ -4014,13 +3074,15 @@ class BasicMobileToolsLite:
                 'clickable': clickable,
                 'center_x': (x1 + x2) // 2,
                 'center_y': (y1 + y2) // 2,
-                'is_close_button': is_close_button,
-                'text': text,
             })
         
         if not all_elements:
             return None, 0
         
+        # 弹窗检测关键词
+        dialog_class_keywords = ['Dialog', 'Popup', 'Alert', 'Modal', 'BottomSheet', 'PopupWindow']
+        dialog_id_keywords = ['dialog', 'popup', 'alert', 'modal', 'bottom_sheet', 'overlay', 'mask']
+        
         popup_candidates = []
         has_mask_layer = False
         mask_idx = -1
@@ -4050,88 +3112,29 @@ class BasicMobileToolsLite:
             if y1 < 50:
                 continue
             
-            # 【非弹窗特征】如果元素包含底部导航栏（底部tab），则不是弹窗
-            if y2 > screen_height * 0.85:
-                if 'tab' in resource_id.lower() or 'Tab' in class_name or 'navigation' in resource_id.lower():
-                    continue
-            
-            # 【非弹窗特征】如果元素包含顶部搜索栏，则不是弹窗
-            if y1 < screen_height * 0.15:
-                if 'search' in resource_id.lower() or 'Search' in class_name:
-                    continue
-            
-            # 使用全局常量检查是否有强弹窗特征
-            has_strong_popup_feature = (
-                any(kw in class_name for kw in POPUP_CLASS_KEYWORDS) or
-                any(kw in resource_id.lower() for kw in POPUP_ID_KEYWORDS) or
-                any(kw in resource_id.lower() for kw in AD_POPUP_KEYWORDS)
-            )
-            
-            # 检查是否有子元素是关闭按钮（作为弹窗特征）
-            has_close_button_child = False
-            elem_bounds = elem['bounds']
-            for other_elem in all_elements:
-                if other_elem['idx'] == elem['idx']:
-                    continue
-                if other_elem['is_close_button']:
-                    ox1, oy1, ox2, oy2 = other_elem['bounds']
-                    ex1, ey1, ex2, ey2 = elem_bounds
-                    if ex1 <= ox1 and ey1 <= oy1 and ex2 >= ox2 and ey2 >= oy2:
-                        has_close_button_child = True
-                        break
-            
-            # 【非弹窗特征】使用全局常量检查页面内容特征
-            if any(kw in resource_id.lower() or kw in class_name.lower() for kw in PAGE_CONTENT_KEYWORDS):
-                if area_ratio > 0.6 and not has_strong_popup_feature:
-                    continue
-            
-            # 【非弹窗特征】面积过大且无强特征
-            if area_ratio > 0.6 and not has_strong_popup_feature:
-                continue
-            
-            if area_ratio > 0.7:
-                if not has_strong_popup_feature:
-                    continue
-            
             confidence = 0.0
             
-            # 【强特征】class 名称包含弹窗关键词 (+0.5) - 使用全局常量
-            if any(kw in class_name for kw in POPUP_CLASS_KEYWORDS):
+            # 【强特征】class 名称包含弹窗关键词 (+0.5)
+            if any(kw in class_name for kw in dialog_class_keywords):
                 confidence += 0.5
             
-            # 【强特征】resource-id 包含弹窗关键词 (+0.4) - 使用全局常量
-            if any(kw in resource_id.lower() for kw in POPUP_ID_KEYWORDS):
-                confidence += 0.4
-            
-            # 【强特征】resource-id 包含广告弹窗关键词 (+0.4) - 使用全局常量
-            if any(kw in resource_id.lower() for kw in AD_POPUP_KEYWORDS):
+            # 【强特征】resource-id 包含弹窗关键词 (+0.4)
+            if any(kw in resource_id.lower() for kw in dialog_id_keywords):
                 confidence += 0.4
             
-            # 【强特征】包含关闭按钮作为子元素 (+0.3)
-            if has_close_button_child:
-                confidence += 0.3
-            
             # 【中等特征】居中显示 (+0.2)
             center_x = elem['center_x']
             center_y = elem['center_y']
             is_centered_x = abs(center_x - screen_width / 2) < screen_width * 0.15
             is_centered_y = abs(center_y - screen_height / 2) < screen_height * 0.25
-            
-            has_strong_feature = (
-                any(kw in class_name for kw in POPUP_CLASS_KEYWORDS) or
-                any(kw in resource_id.lower() for kw in POPUP_ID_KEYWORDS) or
-                any(kw in resource_id.lower() for kw in AD_POPUP_KEYWORDS) or
-                has_close_button_child
-            )
-            
             if is_centered_x and is_centered_y:
-                confidence += 0.2 if has_strong_feature else 0.1
+                confidence += 0.2
             elif is_centered_x:
-                confidence += 0.1 if has_strong_feature else 0.05
+                confidence += 0.1
             
             # 【中等特征】非全屏但有一定大小 (+0.15)
             if 0.15 < area_ratio < 0.75:
-                confidence += 0.15 if has_strong_feature else 0.08
+                confidence += 0.15
             
             # 【弱特征】XML 顺序靠后（在视图层级上层）(+0.1)
             if elem['idx'] > len(all_elements) * 0.5:
@@ -4158,17 +3161,8 @@ class BasicMobileToolsLite:
         popup_candidates.sort(key=lambda x: (x['confidence'], x['idx']), reverse=True)
         best = popup_candidates[0]
         
-        # 更严格的阈值判断 - 使用全局常量
-        has_strong_feature = (
-            any(kw in best['class'] for kw in POPUP_CLASS_KEYWORDS) or
-            any(kw in best['resource_id'].lower() for kw in POPUP_ID_KEYWORDS) or
-            any(kw in best['resource_id'].lower() for kw in AD_POPUP_KEYWORDS)
-        )
-        
-        # 有强特征时阈值 0.7，否则 0.85
-        threshold = 0.7 if has_strong_feature else 0.85
-        
-        if best['confidence'] >= threshold:
+        # 只有置信度 >= 0.6 才返回弹窗
+        if best['confidence'] >= 0.6:
             return best['bounds'], best['confidence']
         
         return None, best['confidence']
@@ -4407,6 +3401,15 @@ class BasicMobileToolsLite:
         
         # 生成脚本
         safe_name = re.sub(r'[^\w\s-]', '', test_name).strip().replace(' ', '_')
+        # 确保 safe_name 不为空，否则使用默认名称
+        if not safe_name:
+            safe_name = 'generated_case'
+        
+        # 提前处理文件名，确保文档字符串中的文件名正确
+        if not filename.endswith('.py'):
+            filename = f"{filename}.py"
+        if not filename.startswith('test_'):
+            filename = f"test_{filename}"
         
         script_lines = [
             "#!/usr/bin/env python3",
@@ -4421,8 +3424,8 @@ class BasicMobileToolsLite:
             "3. 百分比定位 - 跨分辨率兼容（坐标自动转换）",
             "",
             "运行方式：",
-            "  pytest {filename} -v        # 使用 pytest 运行",
-            "  python {filename}           # 直接运行",
+            f"  pytest {filename} -v        # 使用 pytest 运行",
+            f"  python {filename}           # 直接运行",
             f'"""',
             "import time",
             "import pytest",
@@ -4683,6 +3686,12 @@ class BasicMobileToolsLite:
                 script_lines.append(f"    d.press('{key}')")
                 script_lines.append("    time.sleep(0.5)")
                 script_lines.append("    ")
+            
+            elif action == 'wait':
+                seconds = op.get('seconds', 1)
+                script_lines.append(f"    # 步骤{step_num}: 等待 {seconds} 秒")
+                script_lines.append(f"    time.sleep({seconds})")
+                script_lines.append("    ")
         
         script_lines.extend([
             "    print('✅ 测试完成')",
@@ -4706,12 +3715,6 @@ class BasicMobileToolsLite:
         output_dir = Path("tests")
         output_dir.mkdir(exist_ok=True)
         
-        # 确保文件名符合 pytest 规范（以 test_ 开头）
-        if not filename.endswith('.py'):
-            filename = f"{filename}.py"
-        if not filename.startswith('test_'):
-            filename = f"test_{filename}"
-        
         file_path = output_dir / filename
         file_path.write_text(script, encoding='utf-8')
         
@@ -4853,229 +3856,235 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "error": f"删除模板失败: {e}"}
     
-    def close_popup(self, auto_learn: bool = False, confidence_threshold: float = None) -> Dict:
-        """智能关闭弹窗（优化版）
+    def close_ad_popup(self, auto_learn: bool = True) -> Dict:
+        """智能关闭广告弹窗（专用于广告场景）
         
-        优化后的策略（降级策略）：
-        1. 控件树优先（最快、最可靠）：list_elements() → 查找关闭按钮 → 点击
-        2. 截图AI分析（中等速度、高准确率）：如果控件树失败 → 截图 → AI分析 → 返回候选
-        3. 模板匹配（最慢、最精确）：如果AI分析失败 → 模板匹配 → 点击
+        按优先级尝试：
+        1. 控件树查找关闭按钮（最可靠）
+        2. 模板匹配（需要积累模板库）
+        3. 返回视觉信息供 AI 分析（如果前两步失败）
         
-        每个阶段都会使用页面指纹对比验证弹窗是否真的关闭，如果验证失败会继续下一阶段。
-        
-        自动学习（可选）：
-        - 如果通过模板匹配成功关闭，且 auto_learn=True，会自动学习新模板
+        自动学习：
+        - 点击成功后，检查这个 X 是否已在模板库
+        - 如果是新样式，自动裁剪并添加到模板库
         
         Args:
-            auto_learn: 是否自动学习新模板（点击成功后检查并保存），默认 False
-            confidence_threshold: 弹窗检测置信度阈值，默认使用 DEFAULT_POPUP_CONFIDENCE_THRESHOLD
+            auto_learn: 是否自动学习新模板（点击成功后检查并保存）
             
         Returns:
-            关闭结果
+            结果字典
         """
-        if confidence_threshold is None:
-            confidence_threshold = DEFAULT_POPUP_CONFIDENCE_THRESHOLD
+        import time
+        import re
+        
+        result = {
+            "success": False,
+            "method": None,
+            "message": "",
+            "learned_template": None
+        }
+        
+        if self._is_ios():
+            return {"success": False, "error": "iOS 暂不支持此功能"}
         
         try:
-            # iOS 也支持基础弹窗关闭
-            if self._is_ios():
-                return self._close_popup_ios()
-            
-            tried_methods = []
+            import xml.etree.ElementTree as ET
             
-            # 【优化】一次性获取元素列表和 XML，复用于多个检测方法
-            elements = self.list_elements()
-            xml_string = None
-            try:
-                xml_string = self.client.u2.dump_hierarchy(compressed=False)
-            except Exception:
-                pass
+            # ========== 第0步：先检测是否有弹窗 ==========
+            xml_string = self.client.u2.dump_hierarchy(compressed=False)
+            root = ET.fromstring(xml_string)
             
-            # 保存页面指纹用于验证
-            page_fingerprint_before = self._get_page_fingerprint(elements)
+            screen_width = self.client.u2.info.get('displayWidth', 1440)
+            screen_height = self.client.u2.info.get('displayHeight', 3200)
             
-            # 阶段1：控件树优先（传入预获取的元素和XML）
-            result = self._close_popup_by_elements(
-                elements=elements, 
-                xml_string=xml_string,
-                confidence_threshold=confidence_threshold,
-                page_fingerprint_before=page_fingerprint_before
+            popup_bounds, popup_confidence = self._detect_popup_with_confidence(
+                root, screen_width, screen_height
             )
-            tried_methods.append("elements")
-            if result.get("success") and result.get("verified", False):
-                return result
-            # 如果明确检测到没有弹窗，直接返回，不继续后续阶段
-            if result.get("reason") == "未检测到弹窗":
-                return {
-                    "success": False,
-                    "message": "✅ 未检测到弹窗，无需关闭",
-                    "method": "elements",
-                    "tried_methods": tried_methods
-                }
             
-            # 阶段2：截图AI分析（优化：提供候选建议）
-            result = self._close_popup_by_screenshot_ai(elements=elements)
-            tried_methods.append("screenshot_ai")
-            if result.get("screenshot"):
-                # 增加候选按钮建议
-                candidates = result.get("close_button_candidates", [])
-                tip = "请AI分析截图，找到关闭按钮后调用 mobile_click_by_text/click_by_id/click_by_percent 等方法"
-                if candidates:
-                    tip += f"\n💡 候选关闭按钮（按优先级）："
-                    for i, c in enumerate(candidates[:3], 1):
-                        tip += f"\n   {i}. {c.get('reason', '')} at ({c.get('x_percent', 0)}%, {c.get('y_percent', 0)}%)"
-                
-                return {
-                    **result,
-                    "tried_methods": tried_methods,
-                    "tip": tip
-                }
+            # 如果没有检测到弹窗，直接返回"无弹窗"
+            if popup_bounds is None or popup_confidence < 0.5:
+                result["success"] = True
+                result["method"] = None
+                result["message"] = "ℹ️ 当前页面未检测到弹窗，无需关闭"
+                result["popup_detected"] = False
+                result["popup_confidence"] = popup_confidence
+                return result
             
-            # 阶段3：模板匹配
-            pre_screenshot_path = None
-            if auto_learn:
-                try:
-                    pre_screenshot_result = self.take_screenshot(description="关闭前（用于自动学习）", compress=False)
-                    pre_screenshot_path = pre_screenshot_result.get("screenshot_path")
-                except Exception:
-                    pass
+            # ========== 第1步：控件树查找关闭按钮 ==========
             
-            result = self._close_popup_by_template(page_fingerprint_before=page_fingerprint_before)
-            tried_methods.append("template")
-            if result.get("success") and result.get("verified", False):
-                if auto_learn and result.get("method") == "template" and pre_screenshot_path:
-                    clicked = result.get("clicked", {})
-                    if clicked and "center" in clicked:
-                        x, y = clicked["center"]
-                        bounds = (x - 30, y - 30, x + 30, y + 30)
-                        try:
-                            learn_result = self._auto_learn_template(pre_screenshot_path, bounds)
-                            if learn_result:
-                                result["learned_template"] = learn_result
-                                result["message"] += f"\n📚 自动学习: {learn_result}"
-                        except Exception:
-                            pass
-                
-                return result
+            # 关闭按钮的常见特征
+            close_keywords = ['关闭', '跳过', '×', 'X', 'x', 'close', 'skip', '取消']
+            close_content_desc = ['关闭', '跳过', 'close', 'skip', 'dismiss']
             
-            # 所有方法都失败
-            return {
-                "success": False,
-                "message": "❌ 所有关闭弹窗方法都失败",
-                "tried_methods": tried_methods,
-                "suggestion": "请手动查看截图，找到关闭按钮位置，然后使用 mobile_click_by_percent(x%, y%) 点击"
-            }
+            close_candidates = []
             
-        except Exception as e:
-            return {"success": False, "message": f"❌ 关闭弹窗失败: {e}"}
-    
-    def _close_popup_ios(self) -> Dict:
-        """iOS 平台关闭弹窗
-        
-        Returns:
-            关闭结果
-        """
-        try:
-            elements = self.list_elements()
-            page_analysis = self._detect_page_content_ios(elements, DEFAULT_POPUP_CONFIDENCE_THRESHOLD)
+            for elem in root.iter():
+                text = elem.attrib.get('text', '').strip()
+                content_desc = elem.attrib.get('content-desc', '').strip()
+                clickable = elem.attrib.get('clickable', 'false') == 'true'
+                bounds_str = elem.attrib.get('bounds', '')
+                resource_id = elem.attrib.get('resource-id', '')
+                
+                if not bounds_str:
+                    continue
+                
+                match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                if not match:
+                    continue
+                
+                x1, y1, x2, y2 = map(int, match.groups())
+                width = x2 - x1
+                height = y2 - y1
+                cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
+                
+                score = 0
+                reason = ""
+                
+                # 文本匹配
+                for kw in close_keywords:
+                    if kw in text:
+                        score += 10
+                        reason = f"文本含'{kw}'"
+                        break
+                
+                # content-desc 匹配
+                for kw in close_content_desc:
+                    if kw.lower() in content_desc.lower():
+                        score += 8
+                        reason = f"描述含'{kw}'"
+                        break
+                
+                # 小尺寸可点击元素（可能是 X 按钮）
+                if clickable and 30 < width < 200 and 30 < height < 200:
+                    screen_width = self.client.u2.info.get('displayWidth', 1440)
+                    screen_height = self.client.u2.info.get('displayHeight', 3200)
+                    
+                    # 在屏幕右半边上半部分，很可能是 X
+                    if cx > screen_width * 0.6 and cy < screen_height * 0.5:
+                        score += 5
+                        reason = reason or "右上角小按钮"
+                    # 在屏幕上半部分的小按钮，也可能是 X
+                    elif cy < screen_height * 0.4:
+                        score += 2
+                        reason = reason or "上部小按钮"
+                
+                # 只要是可点击的小按钮都考虑（即使没有文本）
+                if score > 0 or (clickable and 30 < width < 150 and 30 < height < 150):
+                    if not reason and clickable:
+                        reason = "可点击小按钮"
+                        score = max(score, 1)  # 确保有分数
+                    close_candidates.append({
+                        'score': score,
+                        'reason': reason,
+                        'bounds': (x1, y1, x2, y2),
+                        'center': (cx, cy),
+                        'resource_id': resource_id,
+                        'text': text
+                    })
             
-            if not page_analysis.get("has_popup"):
-                return {"success": False, "reason": "未检测到弹窗", "method": "ios_elements"}
+            # 按分数排序
+            close_candidates.sort(key=lambda x: x['score'], reverse=True)
             
-            close_button = self._find_close_button_in_elements_ios(elements)
+            if close_candidates:
+                best = close_candidates[0]
+                cx, cy = best['center']
+                bounds = best['bounds']
+                
+                # 点击（click_at_coords 内部已包含应用状态检查和自动返回）
+                click_result = self.click_at_coords(cx, cy)
+                time.sleep(0.5)
+                
+                # 🎯 再次检查应用状态（确保弹窗去除没有导致应用跳转）
+                app_check = self._check_app_switched()
+                return_result = None
+                
+                if app_check['switched']:
+                    # 应用已跳转，说明弹窗去除失败，尝试返回目标应用
+                    return_result = self._return_to_target_app()
+                
+                result["success"] = True
+                result["method"] = "控件树"
+                msg = f"✅ 通过控件树找到关闭按钮并点击\n" \
+                      f"   位置: ({cx}, {cy})\n" \
+                      f"   原因: {best['reason']}"
+                
+                if app_check['switched']:
+                    msg += f"\n⚠️ 应用已跳转，说明弹窗去除失败"
+                    if return_result:
+                        if return_result['success']:
+                            msg += f"\n{return_result['message']}"
+                        else:
+                            msg += f"\n❌ 自动返回失败: {return_result['message']}"
+                
+                result["message"] = msg
+                result["app_check"] = app_check
+                result["return_to_app"] = return_result
+                result["tip"] = "💡 建议调用 mobile_screenshot_with_som 确认弹窗是否已关闭"
+                
+                return result
             
-            if close_button:
-                ios_client = self._get_ios_client()
-                if ios_client:
-                    ios_client.click(close_button['center_x'], close_button['center_y'])
-                    time.sleep(0.5)
+            # ========== 第2步：模板匹配（自动执行，不需要 AI 介入）==========
+            screenshot_path = None
+            try:
+                from .template_matcher import TemplateMatcher
+                
+                # 截图用于模板匹配
+                screenshot_result = self.take_screenshot(description="模板匹配", compress=False)
+                screenshot_path = screenshot_result.get("screenshot_path")
+                
+                if screenshot_path:
+                    matcher = TemplateMatcher()
+                    match_result = matcher.find_close_buttons(screenshot_path, threshold=0.75)
                     
-                    # 验证
-                    new_elements = self.list_elements()
-                    new_analysis = self._detect_page_content_ios(new_elements, DEFAULT_POPUP_CONFIDENCE_THRESHOLD)
-                    verified = not new_analysis.get("has_popup")
+                    # 直接使用最佳匹配（已按置信度排序）
+                    if match_result.get("success") and match_result.get("best_match"):
+                        best = match_result["best_match"]
+                        x_pct = best["percent"]["x"]
+                        y_pct = best["percent"]["y"]
+                        
+                        # 点击
+                        click_result = self.click_by_percent(x_pct, y_pct)
+                        time.sleep(0.5)
+                        
+                        app_check = self._check_app_switched()
+                        return_result = None
+                        
+                        if app_check['switched']:
+                            return_result = self._return_to_target_app()
+                        
+                        result["success"] = True
+                        result["method"] = "模板匹配"
+                        msg = f"✅ 通过模板匹配找到关闭按钮并点击\n" \
+                              f"   模板: {best.get('template', 'unknown')}\n" \
+                              f"   置信度: {best.get('confidence', 'N/A')}%\n" \
+                              f"   位置: ({x_pct:.1f}%, {y_pct:.1f}%)"
+                        
+                        if app_check['switched']:
+                            msg += f"\n⚠️ 应用已跳转"
+                            if return_result:
+                                msg += f"\n{return_result['message']}"
+                        
+                        result["message"] = msg
+                        result["app_check"] = app_check
+                        result["return_to_app"] = return_result
+                        return result
                     
-                    return {
-                        "success": verified,
-                        "method": "ios_elements",
-                        "message": f"✅ iOS 关闭弹窗: {close_button['reason']}",
-                        "clicked": {
-                            "center": (close_button['center_x'], close_button['center_y']),
-                            "percent": (close_button['x_percent'], close_button['y_percent'])
-                        },
-                        "verified": verified
-                    }
-            
-            return {"success": False, "reason": "未找到关闭按钮", "method": "ios_elements"}
+            except ImportError:
+                pass  # OpenCV 未安装，跳过模板匹配
+            except Exception:
+                pass  # 模板匹配失败，继续下一步
             
-        except Exception as e:
-            return {"success": False, "reason": f"iOS 关闭弹窗失败: {e}", "method": "ios_elements"}
-    
-    def _get_page_fingerprint(self, elements: List[Dict]) -> Dict:
-        """获取页面指纹（用于验证弹窗是否关闭）
-        
-        Args:
-            elements: 元素列表
+            # ========== 第3步：控件树和模板匹配都失败，提示 AI 使用视觉识别 ==========
+            result["success"] = False
+            result["fallback"] = "vision"
+            result["method"] = None
+            result["popup_detected"] = True
+            result["message"] = "⚠️ 控件树和模板匹配都未找到关闭按钮，请调用 mobile_screenshot_with_som 截图后用 click_by_som 点击"
             
-        Returns:
-            页面指纹信息
-        """
-        # 提取关键特征
-        resource_ids = set()
-        texts = set()
-        clickable_count = 0
-        
-        for elem in elements:
-            rid = elem.get("resource_id", "")
-            if rid:
-                resource_ids.add(rid)
-            text = elem.get("text", "")
-            if text and len(text) < 50:  # 只记录短文本
-                texts.add(text)
-            if elem.get("clickable"):
-                clickable_count += 1
-        
-        return {
-            "element_count": len(elements),
-            "clickable_count": clickable_count,
-            "resource_ids": resource_ids,
-            "texts": texts,
-            "resource_id_hash": hash(frozenset(resource_ids)) if resource_ids else 0,
-        }
-    
-    def _compare_page_fingerprint(self, before: Dict, after: Dict) -> bool:
-        """比较页面指纹，判断页面是否发生变化
-        
-        Args:
-            before: 操作前的页面指纹
-            after: 操作后的页面指纹
+            return result
             
-        Returns:
-            True 如果页面发生了明显变化（弹窗可能已关闭）
-        """
-        if not before or not after:
-            return False
-        
-        # 元素数量变化
-        count_diff = abs(after["element_count"] - before["element_count"])
-        count_change_ratio = count_diff / max(before["element_count"], 1)
-        
-        # resource_id 集合变化
-        before_ids = before.get("resource_ids", set())
-        after_ids = after.get("resource_ids", set())
-        id_diff = len(before_ids.symmetric_difference(after_ids))
-        id_change_ratio = id_diff / max(len(before_ids), 1)
-        
-        # 如果元素数量或 resource_id 发生明显变化，认为页面已变化
-        if count_change_ratio > 0.1 or id_change_ratio > 0.1:
-            return True
-        
-        # 如果 hash 值不同，也认为有变化
-        if before.get("resource_id_hash") != after.get("resource_id_hash"):
-            return True
-        
-        return False
-    
+        except Exception as e:
+            return {"success": False, "error": f"关闭弹窗失败: {e}"}
     
     def _detect_popup_region(self, root) -> tuple:
         """从控件树中检测弹窗区域