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

mobile_mcp/core/basic_tools_lite.py

@@ -14,10 +14,108 @@ import asyncio
 import time
 import re
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 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',
+]
+
+
 class BasicMobileToolsLite:
     """精简版移动端工具"""
     
@@ -511,11 +609,15 @@ class BasicMobileToolsLite:
         """截图并添加网格坐标标注（用于精确定位元素）
         
         在截图上绘制网格线和坐标刻度，帮助快速定位元素位置。
-        如果检测到弹窗，会标注弹窗区域和可能的关闭按钮位置。
+        
+        🎯 弹窗检测场景：
+        - show_popup_hints=True: 明确弹窗场景时使用（如调用 mobile_close_popup 前）
+        - show_popup_hints=False: 普通截图，不检测弹窗
         
         Args:
             grid_size: 网格间距（像素），默认 100。建议值：50-200
-            show_popup_hints: 是否显示弹窗关闭按钮提示位置，默认 True
+            show_popup_hints: 是否显示弹窗关闭按钮提示位置，默认 False
+                仅在明确弹窗场景时设置为 True，会标注弹窗区域和可能的关闭按钮位置。
         
         Returns:
             包含标注截图路径和弹窗信息的字典
@@ -681,12 +783,17 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "message": f"❌ 网格截图失败: {e}"}
     
-    def take_screenshot_with_som(self) -> Dict:
+    def take_screenshot_with_som(self, check_popup: bool = False) -> Dict:
         """Set-of-Mark 截图：给每个可点击元素标上数字（超级好用！）
         
         在截图上给每个可点击元素画框并标上数字编号。
         AI 看图后直接说"点击 3 号"，然后调用 click_by_som(3) 即可。
         
+        Args:
+            check_popup: 是否检测弹窗，默认 False
+                        - True: 明确弹窗场景时使用（如调用 mobile_close_popup 前）
+                        - False: 普通截图，不检测弹窗
+        
         Returns:
             包含标注截图和元素列表的字典
         """
@@ -823,11 +930,12 @@ class BasicMobileToolsLite:
                     'resource_id': elem.get('resource_id', '')
                 })
             
-            # 第3.5步：检测弹窗区域（使用严格的置信度检测，避免误识别普通页面）
+            # 第3.5步：检测弹窗区域（仅在明确弹窗场景时检测）
             popup_bounds = None
             popup_confidence = 0
             
-            if not self._is_ios():
+            # 🎯 明确弹窗检测场景：只在 check_popup=True 时检测（明确弹窗场景）
+            if check_popup and not self._is_ios():
                 try:
                     # 使用严格的弹窗检测（置信度 >= 0.6 才认为是弹窗）
                     popup_bounds, popup_confidence = self._detect_popup_with_confidence(
@@ -884,7 +992,53 @@ class BasicMobileToolsLite:
                 hints_text += f"   如需关闭弹窗，请观察图片中的 X 按钮位置\n"
                 hints_text += f"   然后使用 mobile_click_by_percent(x%, y%) 点击"
             
-            return {
+            # 第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 = {
                 "success": True,
                 "screenshot_path": str(final_path),
                 "screen_width": screen_width,
@@ -895,19 +1049,82 @@ class BasicMobileToolsLite:
                 "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": f"📸 SoM 截图已保存: {final_path}\n"
-                          f"🏷️ 已标注 {len(som_elements)} 个可点击元素\n"
-                          f"📋 元素列表：\n{elements_text}{hints_text}\n\n"
-                          f"💡 使用方法：\n"
-                          f"   - 点击标注元素：mobile_click_by_som(编号)\n"
-                          f"   - 点击任意位置：mobile_click_by_percent(x%, y%)"
+                "message": message
             }
             
+            # 添加 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 编号点击元素
         
@@ -991,7 +1208,23 @@ class BasicMobileToolsLite:
             }
             
         except Exception as e:
-            return {"success": False, "message": f"❌ 点击失败: {e}\n💡 如果页面已变化，请重新调用 mobile_screenshot_with_som 刷新元素列表"}
+            # 🎯 异常情况：点击失败时检测弹窗
+            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}
     
     def _take_screenshot_no_compress(self, description: str = "") -> Dict:
         """截图（不压缩，PIL 不可用时的备用方案）"""
@@ -1177,7 +1410,23 @@ class BasicMobileToolsLite:
                 "return_to_app": return_result
             }
         except Exception as e:
-            return {"success": False, "message": f"❌ 点击失败: {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}
     
     def click_by_percent(self, x_percent: float, y_percent: float) -> Dict:
         """通过百分比坐标点击（跨设备兼容）
@@ -1335,7 +1584,23 @@ class BasicMobileToolsLite:
                 
                 return {"success": False, "message": f"❌ 文本不存在: {text}"}
         except Exception as e:
-            return {"success": False, "message": f"❌ 点击失败: {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}
     
     def _find_element_in_tree(self, text: str, position: Optional[str] = None) -> Optional[Dict]:
         """在 XML 树中查找包含指定文本的元素，优先返回可点击的元素
@@ -1516,7 +1781,23 @@ class BasicMobileToolsLite:
                         return {"success": False, "message": f"❌ 索引超出范围: 找到 {count} 个元素，但请求索引 {index}"}
                 return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
         except Exception as e:
-            return {"success": False, "message": f"❌ 点击失败: {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}
     
     # ==================== 长按操作 ====================
     
@@ -2438,7 +2719,10 @@ class BasicMobileToolsLite:
     # ==================== 应用管理 ====================
     
     async def launch_app(self, package_name: str) -> Dict:
-        """启动应用"""
+        """启动应用
+        
+        启动应用后会自动检测弹窗（启动应用场景）
+        """
         try:
             if self._is_ios():
                 ios_client = self._get_ios_client()
@@ -2462,12 +2746,45 @@ 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": f"✅ 已启动: {package_name}\n💡 建议等待 2-3 秒让页面加载\n📱 已设置应用状态监测"
+                "message": message,
+                "popup_detected": popup_detected
             }
         except Exception as e:
-            return {"success": False, "message": f"❌ 启动失败: {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}
     
     def terminate_app(self, package_name: str) -> Dict:
         """终止应用"""
@@ -2766,31 +3083,38 @@ class BasicMobileToolsLite:
                 
                 # 策略3：小尺寸的 clickable 元素（可能是 X 图标）
                 elif clickable:
-                    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"
+                    # 排除非关闭按钮的关键词（避免误识别更多按钮、菜单按钮等）
+                    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"
                 
                 if score > 0:
-                    candidates.append({
+                    candidate = {
                         'score': score,
                         'reason': reason,
                         'bounds': bounds_str,
@@ -2798,44 +3122,58 @@ class BasicMobileToolsLite:
                         'center_y': center_y,
                         'x_percent': x_percent,
                         'y_percent': y_percent,
-                        'size': f"{width}x{height}"
-                    })
+                        '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)
             
             if not candidates:
-                # 没找到，截图让 AI 分析
-                screenshot_result = self.take_screenshot(description="找关闭按钮", compress=True)
+                # 没找到，不截图（优化：避免频繁截图）
+                # 调用者可以使用 mobile_close_popup() 作为降级方案
                 return {
                     "success": False,
-                    "message": "❌ 元素树未找到关闭按钮，已截图供 AI 分析",
-                    "screenshot": screenshot_result.get("screenshot_path", ""),
+                    "message": "❌ 元素树未找到关闭按钮",
                     "screen_size": {"width": screen_width, "height": screen_height},
-                    "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)"
+                    "tip": "建议：1) 使用 mobile_close_popup() 作为降级方案（可能截图） 2) 或手动调用 mobile_screenshot_with_som() 进行AI分析"
                 }
             
             # 按得分排序
             candidates.sort(key=lambda x: x['score'], reverse=True)
             best = candidates[0]
             
-            return {
-                "success": True,
-                "message": f"✅ 找到可能的关闭按钮",
-                "best_candidate": {
+            # 构建关闭按钮信息（优化：包含更多点击方式）
+            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']
-                },
-                "click_command": f"mobile_click_by_percent({best['x_percent']}, {best['y_percent']})",
+            }
+            
+            # 添加可用的点击方式（优化：优先使用 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']})"
+            
+            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]
@@ -2846,363 +3184,733 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "message": f"❌ 查找关闭按钮失败: {e}"}
     
-    def close_popup(self) -> Dict:
-        """智能关闭弹窗（改进版）
+    def _analyze_page_for_popup(self) -> Dict:
+        """分析页面是否有弹窗（用于启动应用后、异常情况等场景）
         
-        核心改进：先检测弹窗区域，再在弹窗范围内查找关闭按钮
-        
-        策略（优先级从高到低）：
-        1. 检测弹窗区域（非全屏的大面积容器）
-        2. 在弹窗边界内查找关闭相关的文本/描述（×、X、关闭、close 等）
-        3. 在弹窗边界内查找小尺寸的 clickable 元素（优先边角位置）
-        4. 如果都找不到，截图让 AI 视觉识别
-        
-        适配策略：
-        - X 按钮可能在任意位置（上下左右都支持）
-        - 使用百分比坐标记录，跨分辨率兼容
+        Returns:
+            包含 has_popup 和 popup_info 的字典
         """
         try:
-            import re
-            import xml.etree.ElementTree as ET
-            
-            # 获取屏幕尺寸
             if self._is_ios():
-                return {"success": False, "message": "iOS 暂不支持，请使用截图+坐标点击"}
+                return {"has_popup": False, "popup_info": None}
             
-            screen_width = self.client.u2.info.get('displayWidth', 720)
-            screen_height = self.client.u2.info.get('displayHeight', 1280)
-            
-            # 获取原始 XML
-            xml_string = self.client.u2.dump_hierarchy(compressed=False)
+            # 获取元素列表
+            elements = self.list_elements()
             
-            # 关闭按钮的文本特征
-            close_texts = ['×', 'X', 'x', '关闭', '取消', 'close', 'Close', 'CLOSE', '跳过', '知道了']
-            close_desc_keywords = ['关闭', 'close', 'dismiss', 'cancel', '跳过']
+            # 分析页面内容
+            page_analysis = self._detect_page_content(elements)
             
-            close_candidates = []
-            popup_bounds = None  # 弹窗区域
+            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
+        
+        Args:
+            elements: 元素列表
+            confidence_threshold: 弹窗检测置信度阈值，默认使用 DEFAULT_POPUP_CONFIDENCE_THRESHOLD
+            xml_string: 预先获取的 XML 字符串（可选，避免重复调用）
             
-            # 解析 XML
-            try:
-                root = ET.fromstring(xml_string)
-                all_elements = list(root.iter())
+        Returns:
+            {
+                "main_content": {...},  # 主要功能区域
+                "has_popup": bool,      # 是否有弹窗
+                "popup_info": {...},     # 弹窗信息
+                "interactive_elements": [...]  # 可交互元素
+            }
+        """
+        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 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", "")
                 
-                # ===== 第一步：使用严格的置信度检测弹窗区域 =====
-                popup_bounds, popup_confidence = self._detect_popup_with_confidence(
-                    root, screen_width, screen_height
-                )
+                # 检查文本是否匹配确认按钮（优先检测）
+                if text in CONFIRM_BUTTON_TEXTS:
+                    has_popup = True
+                    popup_info = {"detected_by": "confirm_button_text", "text": text}
+                    break
                 
-                # 如果置信度不够高，记录但继续尝试查找关闭按钮
-                popup_detected = popup_bounds is not None and popup_confidence >= 0.6
+                # 检查文本是否匹配关闭按钮
+                if text in CLOSE_BUTTON_TEXTS:
+                    has_popup = True
+                    popup_info = {"detected_by": "close_button_text", "text": text}
+                    break
                 
-                # 【重要修复】如果没有检测到弹窗区域，只搜索有明确关闭特征的元素（文本、resource-id等）
-                # 避免误点击普通页面的右上角图标
+                # 检查 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
                 
-                # ===== 第二步：在弹窗范围内查找关闭按钮 =====
-                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'
-                    resource_id = elem.attrib.get('resource-id', '')
-                    
-                    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 = False
-                    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  # 大幅加分
-                    elif not popup_detected:
-                        # 没有检测到弹窗时，只处理有明确关闭特征的元素
-                        # 检查是否有明确的关闭特征（文本、resource-id、content-desc）
-                        has_explicit_close_feature = (
-                            text in close_texts or
-                            any(kw in content_desc.lower() for kw in close_desc_keywords) or
-                            'close' in resource_id.lower() or
-                            'dismiss' in resource_id.lower() or
-                            'cancel' in resource_id.lower()
-                        )
-                        if not has_explicit_close_feature:
-                            continue  # 没有明确关闭特征，跳过
-                        # 有明确关闭特征时，允许处理
-                        in_popup = True
-                    
-                    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
-            
-            if not close_candidates:
-                # 如果检测到高置信度的弹窗区域，先尝试点击常见的关闭按钮位置
-                if popup_detected and popup_bounds:
-                    px1, py1, px2, py2 = popup_bounds
-                    popup_width = px2 - px1
-                    popup_height = py2 - py1
-                    
-                    # 【优化】X按钮有三种常见位置：
-                    # 1. 弹窗内靠近顶部边界（内嵌X按钮）- 最常见
-                    # 2. 弹窗边界上方（浮动X按钮）
-                    # 3. 弹窗正下方（底部关闭按钮）
-                    offset_x = max(60, int(popup_width * 0.07))   # 宽度7%
-                    offset_y_above = max(35, int(popup_height * 0.025))  # 高度2.5%，在边界之上
-                    offset_y_near = max(45, int(popup_height * 0.03))    # 高度3%，紧贴顶边界内侧
-                    
-                    try_positions = [
-                        # 【最高优先级】弹窗内紧贴顶部边界
-                        (px2 - offset_x, py1 + offset_y_near, "弹窗右上角"),
-                        # 弹窗边界上方（浮动X按钮）
-                        (px2 - offset_x, py1 - offset_y_above, "弹窗右上浮"),
-                        # 弹窗正下方中间（底部关闭按钮）
-                        ((px1 + px2) // 2, py2 + max(50, int(popup_height * 0.04)), "弹窗下方中间"),
-                        # 弹窗正上方中间
-                        ((px1 + px2) // 2, py1 - 40, "弹窗正上方"),
-                    ]
-                    
-                    for try_x, try_y, position_name in try_positions:
-                        if 0 <= try_x <= screen_width and 0 <= try_y <= screen_height:
-                            self.client.u2.click(try_x, try_y)
-                            time.sleep(0.3)
-                    
-                    # 🎯 关键步骤：检查应用是否跳转，如果跳转说明弹窗去除失败，需要返回目标应用
-                    app_check = self._check_app_switched()
-                    return_result = None
-                    
-                    if app_check['switched']:
-                        # 应用已跳转，说明弹窗去除失败，尝试返回目标应用
-                        return_result = self._return_to_target_app()
-                    
-                    # 尝试后截图，让 AI 判断是否成功
-                    screenshot_result = self.take_screenshot("尝试关闭后")
-                    
-                    msg = f"✅ 已尝试点击常见关闭按钮位置"
-                    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']}"
-                    
-                    return {
-                        "success": True,
-                        "message": msg,
-                        "tried_positions": [p[2] for p in try_positions],
-                        "screenshot": screenshot_result.get("screenshot_path", ""),
-                        "app_check": app_check,
-                        "return_to_app": return_result,
-                        "tip": "请查看截图确认弹窗是否已关闭。如果还在，可手动分析截图找到关闭按钮位置。"
-                    }
+                # 检查 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
                 
-                # 没有检测到弹窗区域，截图让 AI 分析
-                screenshot_result = self.take_screenshot(description="页面截图", compress=True)
+                # 检查 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
                 
-                return {
-                    "success": False,
-                    "message": "❌ 未检测到弹窗区域，已截图供 AI 分析",
-                    "action_required": "请查看截图找到关闭按钮，调用 mobile_click_at_coords 点击",
-                    "screenshot": screenshot_result.get("screenshot_path", ""),
-                    "screen_size": {"width": screen_width, "height": screen_height},
-                    "image_size": {
-                        "width": screenshot_result.get("image_width", screen_width),
-                        "height": screenshot_result.get("image_height", screen_height)
-                    },
-                    "original_size": {
-                        "width": screenshot_result.get("original_img_width", screen_width),
-                        "height": screenshot_result.get("original_img_height", screen_height)
-                    },
-                    "search_areas": ["弹窗右上角", "弹窗正上方", "弹窗下方中间", "屏幕右上角"],
-                    "time_warning": "⚠️ 截图分析期间弹窗可能自动消失。如果是定时弹窗，建议等待其自动消失。"
-                }
+                # 检查 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: 弹窗检测置信度阈值
             
-            # 按得分排序，取最可能的
-            close_candidates.sort(key=lambda x: x['score'], reverse=True)
-            best = close_candidates[0]
+        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: 页面分析结果（可选）
             
-            # 点击
-            self.client.u2.click(best['center_x'], best['center_y'])
-            time.sleep(0.5)
+        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
             
-            # 🎯 关键步骤：检查应用是否跳转，如果跳转说明弹窗去除失败，需要返回目标应用
-            app_check = self._check_app_switched()
-            return_result = None
+            # 解析 bounds
+            match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
+            if not match:
+                continue
             
-            if app_check['switched']:
-                # 应用已跳转，说明弹窗去除失败，尝试返回目标应用
-                return_result = self._return_to_target_app()
+            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"
             
-            # 点击后截图，让 AI 判断是否成功
-            screenshot_result = self.take_screenshot("关闭弹窗后")
+            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: 元素列表
             
-            # 记录操作（使用百分比，跨设备兼容）
-            self._record_operation(
-                'click',
-                x=best['center_x'],
-                y=best['center_y'],
-                x_percent=best['x_percent'],
-                y_percent=best['y_percent'],
-                screen_width=screen_width,
-                screen_height=screen_height,
-                ref=f"close_popup_{best['position']}"
+        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
             )
             
-            # 构建返回消息
-            msg = f"✅ 已点击关闭按钮 ({best['position']}): ({best['center_x']}, {best['center_y']})"
-            if app_check['switched']:
-                msg += f"\n⚠️ 应用已跳转，说明弹窗去除失败"
-                if return_result:
-                    if return_result['success']:
+            # 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:
-                        msg += f"\n❌ 自动返回失败: {return_result['message']}"
+                        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)
             
-            # 返回候选按钮列表，让 AI 看截图判断
-            # 如果弹窗还在，AI 可以选择点击其他候选按钮
+            # 返回结果，包含候选建议
             return {
-                "success": True,
-                "message": msg,
-                "clicked": {
-                    "position": best['position'],
-                    "match_type": best['match_type'],
-                    "coords": (best['center_x'], best['center_y']),
-                    "percent": (best['x_percent'], best['y_percent'])
-                },
-                "screenshot": screenshot_result.get("screenshot_path", ""),
-                "popup_detected": popup_detected,
-                "popup_confidence": popup_confidence if popup_bounds else 0,
-                "popup_bounds": f"[{popup_bounds[0]},{popup_bounds[1]}][{popup_bounds[2]},{popup_bounds[3]}]" if popup_detected else None,
-                "app_check": app_check,
-                "return_to_app": return_result,
-                "other_candidates": [
-                    {
-                        "position": c['position'], 
-                        "type": c['match_type'], 
-                        "coords": (c['center_x'], c['center_y']),
-                        "percent": (c['x_percent'], c['y_percent'])
-                    }
-                    for c in close_candidates[1:4]  # 返回其他3个候选，AI 可以选择
-                ],
-                "tip": "请查看截图判断弹窗是否已关闭。如果弹窗还在，可以尝试点击 other_candidates 中的其他位置"
+                "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分析截图后，根据分析结果调用对应的点击方法"
             }
             
         except Exception as e:
-            return {"success": False, "message": f"❌ 关闭弹窗失败: {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: 操作前的页面指纹（用于验证）
+            
+        Returns:
+            关闭结果
+        """
+        try:
+            if self._is_ios():
+                return {"success": False, "reason": "iOS 暂不支持"}
+            
+            # 模板匹配
+            match_result = self.template_match_close()
+            
+            # 如果找到匹配，点击
+            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)
+                
+                msg = f"✅ 通过模板匹配找到关闭按钮并点击\n"
+                msg += f"   模板: {best_match.get('template', 'unknown')}\n"
+                msg += f"   置信度: {best_match.get('confidence', 0):.1f}%\n"
+                msg += f"   位置: ({x}, {y})"
+                
+                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": "template",
+                    "message": msg,
+                    "clicked": {"center": (x, y)},
+                    "app_check": app_check,
+                    "return_to_app": return_result,
+                    "verified": verified
+                }
+            
+            return {"success": False, "reason": "模板匹配未找到关闭按钮", "method": "template"}
+            
+        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: 操作前的页面指纹
+            
+        Returns:
+            True 如果弹窗已关闭，False 如果弹窗仍在
+        """
+        try:
+            time.sleep(0.5)
+            
+            # 获取当前元素列表
+            elements = self.list_elements()
+            
+            # 方法1：检查是否还有弹窗
+            page_analysis = self._detect_page_content(elements)
+            if not page_analysis.get("has_popup"):
+                return True
+            
+            # 方法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
+            
+            return False
+            
+        except Exception:
+            return False
     
     def _get_position_name(self, rel_x: float, rel_y: float) -> str:
         """根据相对坐标获取位置名称"""
@@ -3246,9 +3954,12 @@ class BasicMobileToolsLite:
         else:  # 中间区域
             return 0.5
 
-    def _detect_popup_with_confidence(self, root, screen_width: int, screen_height: int) -> tuple:
+    def _detect_popup_with_confidence(self, root, screen_width: int, screen_height: int) -> Tuple[Optional[Tuple[int, int, int, int]], float]:
         """严格的弹窗检测 - 使用置信度评分，避免误识别普通页面
         
+        使用全局常量 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（强特征）
@@ -3258,10 +3969,8 @@ class BasicMobileToolsLite:
         
         Returns:
             (popup_bounds, confidence) 或 (None, 0)
-            confidence >= 0.6 才认为是弹窗
+            confidence >= DEFAULT_POPUP_CONFIDENCE_THRESHOLD 才认为是弹窗
         """
-        import re
-        
         screen_area = screen_width * screen_height
         
         # 收集所有元素信息
@@ -3283,14 +3992,14 @@ 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 = (
-                'close' in resource_id.lower() or 
-                'dismiss' in resource_id.lower() or
-                'cancel' in resource_id.lower() or
-                '×' in elem.attrib.get('text', '') or
-                'X' in elem.attrib.get('text', '')
+                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({
@@ -3306,17 +4015,12 @@ class BasicMobileToolsLite:
                 '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']
-        # 广告弹窗关键词（全屏广告、激励视频等）
-        ad_popup_keywords = ['ad_close', 'ad_button', 'full_screen', 'interstitial', 'reward', 'close_icon', 'close_btn']
-        
         popup_candidates = []
         has_mask_layer = False
         mask_idx = -1
@@ -3347,22 +4051,20 @@ class BasicMobileToolsLite:
                 continue
             
             # 【非弹窗特征】如果元素包含底部导航栏（底部tab），则不是弹窗
-            # 底部导航栏通常在屏幕底部，高度约100-200像素
             if y2 > screen_height * 0.85:
-                # 检查是否包含tab相关的resource-id或class
                 if 'tab' in resource_id.lower() or 'Tab' in class_name or 'navigation' in resource_id.lower():
-                    continue  # 跳过底部导航栏
+                    continue
             
             # 【非弹窗特征】如果元素包含顶部搜索栏，则不是弹窗
             if y1 < screen_height * 0.15:
                 if 'search' in resource_id.lower() or 'Search' in class_name:
-                    continue  # 跳过顶部搜索栏
+                    continue
             
-            # 先检查是否有强弹窗特征（用于后续判断）
+            # 使用全局常量检查是否有强弹窗特征
             has_strong_popup_feature = (
-                any(kw in class_name for kw in dialog_class_keywords) or
-                any(kw in resource_id.lower() for kw in dialog_id_keywords) or
-                any(kw in resource_id.lower() for kw in ad_popup_keywords)  # 广告弹窗关键词
+                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)
             )
             
             # 检查是否有子元素是关闭按钮（作为弹窗特征）
@@ -3372,45 +4074,37 @@ class BasicMobileToolsLite:
                 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
             
-            # 【非弹窗特征】如果元素包含明显的页面内容特征，则不是弹窗
-            # 检查是否包含视频播放器、内容列表等页面元素
-            page_content_keywords = ['video', 'player', 'recycler', 'list', 'scroll', 'viewpager', 'fragment']
-            if any(kw in resource_id.lower() or kw in class_name.lower() for kw in page_content_keywords):
-                # 如果面积很大且没有强弹窗特征，则不是弹窗
+            # 【非弹窗特征】使用全局常量检查页面内容特征
+            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
             
-            # 【非弹窗特征】如果元素面积过大（接近全屏），即使居中也不应该是弹窗
-            # 真正的弹窗通常不会超过屏幕的60%
-            # 对于面积 > 0.6 的元素，如果没有强特征，直接跳过（避免误判首页内容区域）
+            # 【非弹窗特征】面积过大且无强特征
             if area_ratio > 0.6 and not has_strong_popup_feature:
-                continue  # 跳过大面积非弹窗元素（接近全屏的内容区域，如首页视频播放区域）
+                continue
             
-            # 对于面积 > 0.7 的元素，即使有强特征也要更严格
             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 dialog_class_keywords):
+            # 【强特征】class 名称包含弹窗关键词 (+0.5) - 使用全局常量
+            if any(kw in class_name for kw in POPUP_CLASS_KEYWORDS):
                 confidence += 0.5
             
-            # 【强特征】resource-id 包含弹窗关键词 (+0.4)
-            if any(kw in resource_id.lower() for kw in dialog_id_keywords):
+            # 【强特征】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 AD_POPUP_KEYWORDS):
                 confidence += 0.4
             
             # 【强特征】包含关闭按钮作为子元素 (+0.3)
@@ -3418,37 +4112,26 @@ class BasicMobileToolsLite:
                 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 dialog_class_keywords) or
-                any(kw in resource_id.lower() for kw in dialog_id_keywords) or
-                any(kw in resource_id.lower() for kw in ad_popup_keywords) or
+                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:
-                if has_strong_feature:
-                    confidence += 0.2
-                else:
-                    confidence += 0.1  # 没有强特征时降低权重
+                confidence += 0.2 if has_strong_feature else 0.1
             elif is_centered_x:
-                if has_strong_feature:
-                    confidence += 0.1
-                else:
-                    confidence += 0.05  # 没有强特征时降低权重
+                confidence += 0.1 if has_strong_feature else 0.05
             
             # 【中等特征】非全屏但有一定大小 (+0.15)
-            # 但如果没有强特征，降低权重
             if 0.15 < area_ratio < 0.75:
-                if has_strong_feature:
-                    confidence += 0.15
-                else:
-                    confidence += 0.08  # 没有强特征时降低权重
+                confidence += 0.15 if has_strong_feature else 0.08
             
             # 【弱特征】XML 顺序靠后（在视图层级上层）(+0.1)
             if elem['idx'] > len(all_elements) * 0.5:
@@ -3475,20 +4158,15 @@ class BasicMobileToolsLite:
         popup_candidates.sort(key=lambda x: (x['confidence'], x['idx']), reverse=True)
         best = popup_candidates[0]
         
-        # 更严格的阈值：只有置信度 >= 0.7 才返回弹窗
-        # 如果没有强特征（class或resource-id包含弹窗关键词），需要更高的置信度
+        # 更严格的阈值判断 - 使用全局常量
         has_strong_feature = (
-            any(kw in best['class'] for kw in dialog_class_keywords) or
-            any(kw in best['resource_id'].lower() for kw in dialog_id_keywords) or
-            any(kw in best['resource_id'].lower() for kw in ad_popup_keywords)
+            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)
         )
         
-        if has_strong_feature:
-            # 有强特征时，阈值0.7
-            threshold = 0.7
-        else:
-            # 没有强特征时，阈值0.85（更严格）
-            threshold = 0.85
+        # 有强特征时阈值 0.7，否则 0.85
+        threshold = 0.7 if has_strong_feature else 0.85
         
         if best['confidence'] >= threshold:
             return best['bounds'], best['confidence']
@@ -4175,239 +4853,229 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "error": f"删除模板失败: {e}"}
     
-    def close_ad_popup(self, auto_learn: bool = True) -> Dict:
-        """智能关闭广告弹窗（专用于广告场景）
+    def close_popup(self, auto_learn: bool = False, confidence_threshold: float = None) -> Dict:
+        """智能关闭弹窗（优化版）
+        
+        优化后的策略（降级策略）：
+        1. 控件树优先（最快、最可靠）：list_elements() → 查找关闭按钮 → 点击
+        2. 截图AI分析（中等速度、高准确率）：如果控件树失败 → 截图 → AI分析 → 返回候选
+        3. 模板匹配（最慢、最精确）：如果AI分析失败 → 模板匹配 → 点击
         
-        按优先级尝试：
-        1. 控件树查找关闭按钮（最可靠）
-        2. 模板匹配（需要积累模板库）
-        3. 返回视觉信息供 AI 分析（如果前两步失败）
+        每个阶段都会使用页面指纹对比验证弹窗是否真的关闭，如果验证失败会继续下一阶段。
         
-        自动学习：
-        - 点击成功后，检查这个 X 是否已在模板库
-        - 如果是新样式，自动裁剪并添加到模板库
+        自动学习（可选）：
+        - 如果通过模板匹配成功关闭，且 auto_learn=True，会自动学习新模板
         
         Args:
-            auto_learn: 是否自动学习新模板（点击成功后检查并保存）
+            auto_learn: 是否自动学习新模板（点击成功后检查并保存），默认 False
+            confidence_threshold: 弹窗检测置信度阈值，默认使用 DEFAULT_POPUP_CONFIDENCE_THRESHOLD
             
         Returns:
-            结果字典
+            关闭结果
         """
-        import time
-        import re
-        
-        result = {
-            "success": False,
-            "method": None,
-            "message": "",
-            "learned_template": None
-        }
-        
-        if self._is_ios():
-            return {"success": False, "error": "iOS 暂不支持此功能"}
+        if confidence_threshold is None:
+            confidence_threshold = DEFAULT_POPUP_CONFIDENCE_THRESHOLD
         
         try:
-            import xml.etree.ElementTree as ET
+            # iOS 也支持基础弹窗关闭
+            if self._is_ios():
+                return self._close_popup_ios()
             
-            # ========== 第1步：控件树查找关闭按钮 ==========
-            xml_string = self.client.u2.dump_hierarchy(compressed=False)
-            root = ET.fromstring(xml_string)
+            tried_methods = []
             
-            # 关闭按钮的常见特征
-            close_keywords = ['关闭', '跳过', '×', 'X', 'x', 'close', 'skip', '取消']
-            close_content_desc = ['关闭', '跳过', 'close', 'skip', 'dismiss']
+            # 【优化】一次性获取元素列表和 XML，复用于多个检测方法
+            elements = self.list_elements()
+            xml_string = None
+            try:
+                xml_string = self.client.u2.dump_hierarchy(compressed=False)
+            except Exception:
+                pass
             
-            close_candidates = []
+            # 保存页面指纹用于验证
+            page_fingerprint_before = self._get_page_fingerprint(elements)
             
-            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 "上部小按钮"
+            # 阶段1：控件树优先（传入预获取的元素和XML）
+            result = self._close_popup_by_elements(
+                elements=elements, 
+                xml_string=xml_string,
+                confidence_threshold=confidence_threshold,
+                page_fingerprint_before=page_fingerprint_before
+            )
+            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)}%)"
                 
-                # 只要是可点击的小按钮都考虑（即使没有文本）
-                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
-                    })
+                return {
+                    **result,
+                    "tried_methods": tried_methods,
+                    "tip": tip
+                }
             
-            # 按分数排序
-            close_candidates.sort(key=lambda x: x['score'], reverse=True)
+            # 阶段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
             
-            if close_candidates:
-                best = close_candidates[0]
-                cx, cy = best['center']
-                bounds = best['bounds']
-                
-                # 点击前截图（用于自动学习）
-                pre_screenshot = None
-                if auto_learn:
-                    pre_result = self.take_screenshot(description="关闭前", compress=False)
-                    pre_screenshot = pre_result.get("screenshot_path")
-                
-                # 点击（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
-                
-                # 自动学习：检查这个 X 是否已在模板库，不在就添加
-                if auto_learn and pre_screenshot:
-                    learn_result = self._auto_learn_template(pre_screenshot, bounds)
-                    if learn_result:
-                        result["learned_template"] = learn_result
-                        result["message"] += f"\n📚 自动学习: {learn_result}"
+            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
             
-            # ========== 第2步：模板匹配 ==========
-            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)
+            # 所有方法都失败
+            return {
+                "success": False,
+                "message": "❌ 所有关闭弹窗方法都失败",
+                "tried_methods": tried_methods,
+                "suggestion": "请手动查看截图，找到关闭按钮位置，然后使用 mobile_click_by_percent(x%, y%) 点击"
+            }
+            
+        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)
+            
+            if not page_analysis.get("has_popup"):
+                return {"success": False, "reason": "未检测到弹窗", "method": "ios_elements"}
+            
+            close_button = self._find_close_button_in_elements_ios(elements)
+            
+            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)
                     
-                    # 直接使用最佳匹配（已按置信度排序）
-                    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_by_percent 内部已包含应用状态检查和自动返回）
-                        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:
-                                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
-                        return result
+                    # 验证
+                    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")
                     
-            except ImportError:
-                pass  # OpenCV 未安装，跳过模板匹配
-            except Exception:
-                pass  # 模板匹配失败，继续下一步
+                    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
+                    }
             
-            # ========== 第3步：返回截图供 AI 分析 ==========
-            if not screenshot_path:
-                screenshot_result = self.take_screenshot(description="需要AI分析", compress=True)
+            return {"success": False, "reason": "未找到关闭按钮", "method": "ios_elements"}
             
-            result["success"] = False
-            result["method"] = None
-            result["message"] = "❌ 控件树和模板匹配都未找到关闭按钮\n" \
-                               "📸 已截图，请 AI 分析图片中的 X 按钮位置\n" \
-                               "💡 找到后使用 mobile_click_by_percent(x%, y%) 点击"
-            result["screenshot"] = screenshot_result if not screenshot_path else {"screenshot_path": screenshot_path}
-            result["need_ai_analysis"] = True
+        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: 元素列表
             
-            return result
+        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: 操作后的页面指纹
             
-        except Exception as e:
-            return {"success": False, "error": f"关闭弹窗失败: {e}"}
+        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
+    
     
     def _detect_popup_region(self, root) -> tuple:
         """从控件树中检测弹窗区域