mobile-mcp-ai 2.6.5__py3-none-any.whl → 2.6.7__py3-none-any.whl

mobile_mcp/core/basic_tools_lite.py

@@ -8,7 +8,6 @@
 - 核心功能精简
 - 保留 pytest 脚本生成
 - 支持操作历史记录
-- Token 优化模式（省钱）
 """
 
 import asyncio
@@ -18,19 +17,6 @@ from pathlib import Path
 from typing import Dict, List, Optional
 from datetime import datetime
 
-# Token 优化配置（只精简格式，不限制数量，确保准确度）
-try:
-    from mobile_mcp.config import Config
-    TOKEN_OPTIMIZATION = Config.TOKEN_OPTIMIZATION_ENABLED
-    MAX_ELEMENTS = Config.MAX_ELEMENTS_RETURN
-    MAX_SOM_ELEMENTS = Config.MAX_SOM_ELEMENTS_RETURN
-    COMPACT_RESPONSE = Config.COMPACT_RESPONSE
-except ImportError:
-    TOKEN_OPTIMIZATION = True
-    MAX_ELEMENTS = 0  # 0 = 不限制
-    MAX_SOM_ELEMENTS = 0  # 0 = 不限制
-    COMPACT_RESPONSE = True
-
 
 class BasicMobileToolsLite:
     """精简版移动端工具"""
@@ -349,7 +335,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 self.client.u2.screenshot(str(temp_path))
                 info = self.client.u2.info
@@ -400,14 +386,22 @@ class BasicMobileToolsLite:
                 
                 cropped_size = final_path.stat().st_size
                 
-                # 返回结果
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
+                    "screen_width": screen_width,
+                    "screen_height": screen_height,
                     "image_width": img.width,
                     "image_height": img.height,
                     "crop_offset_x": crop_offset_x,
-                    "crop_offset_y": crop_offset_y
+                    "crop_offset_y": crop_offset_y,
+                    "file_size": f"{cropped_size/1024:.1f}KB",
+                    "message": f"🔍 局部截图已保存: {final_path}\n"
+                              f"📐 裁剪区域: ({crop_offset_x}, {crop_offset_y}) 起，{img.width}x{img.height} 像素\n"
+                              f"📦 文件大小: {cropped_size/1024:.0f}KB\n"
+                              f"🎯 【坐标换算】AI 返回坐标 (x, y) 后：\n"
+                              f"   实际屏幕坐标 = ({crop_offset_x} + x, {crop_offset_y} + y)\n"
+                              f"   或直接调用 mobile_click_at_coords(x, y, crop_offset_x={crop_offset_x}, crop_offset_y={crop_offset_y})"
                 }
             
             # ========== 情况2：全屏压缩截图 ==========
@@ -460,14 +454,24 @@ class BasicMobileToolsLite:
                 compressed_size = final_path.stat().st_size
                 saved_percent = (1 - compressed_size / original_size) * 100
                 
-                # 返回结果
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
-                    "image_width": image_width,
-                    "image_height": image_height,
-                    "original_img_width": original_img_width,
-                    "original_img_height": original_img_height
+                    "screen_width": screen_width,
+                    "screen_height": screen_height,
+                    "original_img_width": original_img_width,    # 截图原始宽度
+                    "original_img_height": original_img_height,  # 截图原始高度
+                    "image_width": image_width,                  # 压缩后宽度（AI 看到的）
+                    "image_height": image_height,                # 压缩后高度（AI 看到的）
+                    "original_size": f"{original_size/1024:.1f}KB",
+                    "compressed_size": f"{compressed_size/1024:.1f}KB",
+                    "saved_percent": f"{saved_percent:.0f}%",
+                    "message": f"📸 截图已保存: {final_path}\n"
+                              f"📐 原始尺寸: {original_img_width}x{original_img_height} → 压缩后: {image_width}x{image_height}\n"
+                              f"📦 已压缩: {original_size/1024:.0f}KB → {compressed_size/1024:.0f}KB (省 {saved_percent:.0f}%)\n"
+                              f"⚠️ 【坐标转换】AI 返回坐标后，请传入：\n"
+                              f"   image_width={image_width}, image_height={image_height},\n"
+                              f"   original_img_width={original_img_width}, original_img_height={original_img_height}"
                 }
             
             # ========== 情况3：全屏不压缩截图 ==========
@@ -481,12 +485,21 @@ class BasicMobileToolsLite:
                 final_path = self.screenshot_dir / filename
                 temp_path.rename(final_path)
                 
-                # 返回结果（不压缩时尺寸相同）
+                # 不压缩时，用截图实际尺寸（可能和 screen_width 不同）
                 return {
                     "success": True,
                     "screenshot_path": str(final_path),
-                    "image_width": img.width,
-                    "image_height": img.height
+                    "screen_width": screen_width,
+                    "screen_height": screen_height,
+                    "original_img_width": img.width,   # 截图实际尺寸
+                    "original_img_height": img.height,
+                    "image_width": img.width,          # 未压缩，和原图一样
+                    "image_height": img.height,
+                    "file_size": f"{original_size/1024:.1f}KB",
+                    "message": f"📸 截图已保存: {final_path}\n"
+                              f"📐 截图尺寸: {img.width}x{img.height}\n"
+                              f"📦 文件大小: {original_size/1024:.0f}KB（未压缩）\n"
+                              f"💡 未压缩，坐标可直接使用"
                 }
         except ImportError:
             # 如果没有 PIL，回退到原始方式（不压缩）
@@ -526,7 +539,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 self.client.u2.screenshot(str(temp_path))
                 info = self.client.u2.info
@@ -640,16 +653,26 @@ class BasicMobileToolsLite:
             result = {
                 "success": True,
                 "screenshot_path": str(final_path),
+                "screen_width": screen_width,
+                "screen_height": screen_height,
                 "image_width": img_width,
                 "image_height": img_height,
-                "grid_size": grid_size
+                "grid_size": grid_size,
+                "message": f"📸 网格截图已保存: {final_path}\n"
+                          f"📐 尺寸: {img_width}x{img_height}\n"
+                          f"📏 网格间距: {grid_size}px"
             }
             
             if popup_info:
-                result["popup"] = popup_info["bounds"]
-                # 只返回前3个最可能的关闭按钮位置
-                if close_positions:
-                    result["close_hints"] = [(p['x'], p['y']) for p in close_positions[:3]]
+                result["popup_detected"] = True
+                result["popup_bounds"] = popup_info["bounds"]
+                result["close_button_hints"] = close_positions
+                result["message"] += f"\n🎯 检测到弹窗: {popup_info['bounds']}"
+                result["message"] += f"\n💡 可能的关闭按钮位置（绿色圆圈标注）："
+                for pos in close_positions:
+                    result["message"] += f"\n   {pos['priority']}. {pos['name']}: ({pos['x']}, {pos['y']})"
+            else:
+                result["popup_detected"] = False
             
             return result
             
@@ -686,7 +709,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 self.client.u2.screenshot(str(temp_path))
                 info = self.client.u2.info
@@ -846,15 +869,38 @@ class BasicMobileToolsLite:
             img.save(str(final_path), "JPEG", quality=85)
             temp_path.unlink()
             
-            # 返回结果（Token 优化：不返回 elements 列表，已存储在 self._som_elements）
+            # 构建元素列表文字
+            elements_text = "\n".join([
+                f"  [{e['index']}] {e['desc']} → ({e['center'][0]}, {e['center'][1]})"
+                for e in som_elements[:15]  # 只显示前15个
+            ])
+            if len(som_elements) > 15:
+                elements_text += f"\n  ... 还有 {len(som_elements) - 15} 个元素"
+            
+            # 构建弹窗提示文字
+            hints_text = ""
+            if popup_bounds:
+                hints_text = f"\n🎯 检测到弹窗区域（蓝色边框）\n"
+                hints_text += f"   如需关闭弹窗，请观察图片中的 X 按钮位置\n"
+                hints_text += f"   然后使用 mobile_click_by_percent(x%, y%) 点击"
+            
             return {
                 "success": True,
                 "screenshot_path": str(final_path),
                 "screen_width": screen_width,
                 "screen_height": screen_height,
+                "image_width": img_width,
+                "image_height": img_height,
                 "element_count": len(som_elements),
+                "elements": som_elements,
                 "popup_detected": popup_bounds is not None,
-                "hint": "查看截图上的编号，用 click_by_som(编号) 点击"
+                "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%)"
             }
             
         except ImportError:
@@ -935,6 +981,7 @@ class BasicMobileToolsLite:
 
             return {
                 "success": True,
+                "message": f"✅ 已点击 [{index}] {target['desc']} → ({cx}, {cy})\n💡 建议：再次截图确认操作是否成功",
                 "clicked": {
                     "index": index,
                     "desc": target['desc'],
@@ -968,7 +1015,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 self.client.u2.screenshot(str(screenshot_path))
                 info = self.client.u2.info
@@ -1046,7 +1093,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 info = self.client.u2.info
                 screen_width = info.get('displayWidth', 0)
@@ -1161,14 +1208,14 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 info = self.client.u2.info
                 width = info.get('displayWidth', 0)
                 height = info.get('displayHeight', 0)
             
             if width == 0 or height == 0:
-                return {"success": False, "msg": "无法获取屏幕尺寸"}
+                return {"success": False, "message": "❌ 无法获取屏幕尺寸"}
             
             # 第2步：百分比转像素坐标
             # 公式：像素 = 屏幕尺寸 × (百分比 / 100)
@@ -1189,13 +1236,15 @@ class BasicMobileToolsLite:
             
             return {
                 "success": True,
+                "message": f"✅ 百分比点击成功: ({x_percent}%, {y_percent}%) → 像素({x}, {y})",
+                "screen_size": {"width": width, "height": height},
+                "percent": {"x": x_percent, "y": y_percent},
                 "pixel": {"x": x, "y": y}
             }
         except Exception as e:
             return {"success": False, "message": f"❌ 百分比点击失败: {e}"}
     
-    def click_by_text(self, text: str, timeout: float = 3.0, position: Optional[str] = None, 
-                       verify: Optional[str] = None) -> Dict:
+    def click_by_text(self, text: str, timeout: float = 3.0, position: Optional[str] = None) -> Dict:
         """通过文本点击 - 先查 XML 树，再精准匹配
         
         Args:
@@ -1204,7 +1253,6 @@ class BasicMobileToolsLite:
             position: 位置信息，当有多个相同文案时使用。支持：
                 - 垂直方向: "top"/"upper"/"上", "bottom"/"lower"/"下", "middle"/"center"/"中"
                 - 水平方向: "left"/"左", "right"/"右", "center"/"中"
-            verify: 可选，点击后验证的文本。如果指定，会检查该文本是否出现在页面上
         """
         try:
             if self._is_ios():
@@ -1216,17 +1264,10 @@ class BasicMobileToolsLite:
                     if elem.exists:
                         elem.click()
                         time.sleep(0.3)
+                        # 使用标准记录格式
                         self._record_click('text', text, element_desc=text, locator_attr='text')
-                        # 验证逻辑
-                        if verify:
-                            return self._verify_after_click(verify, ios=True)
-                        # 返回页面文本摘要，方便确认页面变化
-                        page_texts = self._get_page_texts(10)
-                        return {"success": True, "page_texts": page_texts}
-                    # 控件树找不到，提示用视觉识别
-                    return {"success": False, "fallback": "vision", "msg": f"未找到'{text}'，用截图点击"}
-                else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                        return {"success": True, "message": f"✅ 点击成功: '{text}'"}
+                    return {"success": False, "message": f"❌ 文本不存在: {text}"}
             else:
                 # 获取屏幕尺寸用于计算百分比
                 screen_width, screen_height = self.client.u2.window_size()
@@ -1247,20 +1288,17 @@ class BasicMobileToolsLite:
                         x_pct = round(cx / screen_width * 100, 1)
                         y_pct = round(cy / screen_height * 100, 1)
                     
-                    # 如果有位置参数，直接使用坐标点击
+                    # 如果有位置参数，直接使用坐标点击（避免 u2 选择器匹配到错误的元素）
                     if position and bounds:
                         x = (bounds[0] + bounds[2]) // 2
                         y = (bounds[1] + bounds[3]) // 2
                         self.client.u2.click(x, y)
                         time.sleep(0.3)
+                        position_info = f" ({position})" if position else ""
+                        # 虽然用坐标点击，但记录时仍使用文本定位（脚本更稳定）
                         self._record_click('text', attr_value, x_pct, y_pct, 
-                                          element_desc=f"{text}({position})", locator_attr=attr_type)
-                        # 验证逻辑
-                        if verify:
-                            return self._verify_after_click(verify)
-                        # 返回页面文本摘要
-                        page_texts = self._get_page_texts(10)
-                        return {"success": True, "page_texts": page_texts}
+                                          element_desc=f"{text}{position_info}", locator_attr=attr_type)
+                        return {"success": True, "message": f"✅ 点击成功(坐标定位): '{text}'{position_info} @ ({x},{y})"}
                     
                     # 没有位置参数时，使用选择器定位
                     if attr_type == 'text':
@@ -1277,74 +1315,27 @@ class BasicMobileToolsLite:
                     if elem and elem.exists(timeout=1):
                         elem.click()
                         time.sleep(0.3)
+                        position_info = f" ({position})" if position else ""
+                        # 使用标准记录格式：文本定位
                         self._record_click('text', attr_value, x_pct, y_pct,
                                           element_desc=text, locator_attr=attr_type)
-                        # 验证逻辑
-                        if verify:
-                            return self._verify_after_click(verify)
-                        # 返回页面文本摘要
-                        page_texts = self._get_page_texts(10)
-                        return {"success": True, "page_texts": page_texts}
+                        return {"success": True, "message": f"✅ 点击成功({attr_type}): '{text}'{position_info}"}
                     
-                    # 选择器失败，用坐标兜底
+                    # 如果选择器失败，用坐标兜底
                     if bounds:
                         x = (bounds[0] + bounds[2]) // 2
                         y = (bounds[1] + bounds[3]) // 2
                         self.client.u2.click(x, y)
                         time.sleep(0.3)
+                        position_info = f" ({position})" if position else ""
+                        # 选择器失败，用百分比作为兜底
                         self._record_click('percent', f"{x_pct}%,{y_pct}%", x_pct, y_pct,
-                                          element_desc=text)
-                        # 验证逻辑
-                        if verify:
-                            return self._verify_after_click(verify)
-                        # 返回页面文本摘要
-                        page_texts = self._get_page_texts(10)
-                        return {"success": True, "page_texts": page_texts}
+                                          element_desc=f"{text}{position_info}")
+                        return {"success": True, "message": f"✅ 点击成功(坐标兜底): '{text}'{position_info} @ ({x},{y})"}
                 
-                # 控件树找不到，提示用视觉识别
-                return {"success": False, "fallback": "vision", "msg": f"未找到'{text}'，用截图点击"}
-        except Exception as e:
-            return {"success": False, "msg": str(e)}
-    
-    def _verify_after_click(self, verify_text: str, ios: bool = False, timeout: float = 2.0) -> Dict:
-        """点击后验证期望文本是否出现
-        
-        Args:
-            verify_text: 期望出现的文本
-            ios: 是否是 iOS 设备
-            timeout: 验证超时时间
-        
-        Returns:
-            {"success": True, "verified": True/False, "hint": "..."}
-        """
-        time.sleep(0.5)  # 等待页面更新
-        
-        try:
-            if ios:
-                ios_client = self._get_ios_client()
-                if ios_client and hasattr(ios_client, 'wda'):
-                    exists = ios_client.wda(name=verify_text).exists or \
-                             ios_client.wda(label=verify_text).exists
-                else:
-                    exists = False
-            else:
-                # Android: 检查文本或包含文本
-                exists = self.client.u2(text=verify_text).exists(timeout=timeout) or \
-                         self.client.u2(textContains=verify_text).exists(timeout=0.5) or \
-                         self.client.u2(description=verify_text).exists(timeout=0.5)
-            
-            if exists:
-                return {"success": True, "verified": True}
-            else:
-                # 验证失败，提示可以截图确认
-                return {
-                    "success": True,  # 点击本身成功
-                    "verified": False,
-                    "expect": verify_text,
-                    "hint": "验证失败，可截图确认"
-                }
+                return {"success": False, "message": f"❌ 文本不存在: {text}"}
         except Exception as e:
-            return {"success": True, "verified": False, "hint": f"验证异常: {e}"}
+            return {"success": False, "message": f"❌ 点击失败: {e}"}
     
     def _find_element_in_tree(self, text: str, position: Optional[str] = None) -> Optional[Dict]:
         """在 XML 树中查找包含指定文本的元素，优先返回可点击的元素
@@ -1483,8 +1474,15 @@ class BasicMobileToolsLite:
             return None
     
     def click_by_id(self, resource_id: str, index: int = 0) -> Dict:
-        """通过 resource-id 点击"""
+        """通过 resource-id 点击（支持点击第 N 个元素）
+
+        Args:
+            resource_id: 元素的 resource-id
+            index: 第几个元素（从 0 开始），默认 0 表示第一个
+        """
         try:
+            index_desc = f"[{index}]" if index > 0 else ""
+
             if self._is_ios():
                 ios_client = self._get_ios_client()
                 if ios_client and hasattr(ios_client, 'wda'):
@@ -1492,31 +1490,33 @@ class BasicMobileToolsLite:
                     if not elem.exists:
                         elem = ios_client.wda(name=resource_id)
                     if elem.exists:
+                        # 获取所有匹配的元素
                         elements = elem.find_elements()
                         if index < len(elements):
                             elements[index].click()
                             time.sleep(0.3)
-                            self._record_click('id', resource_id, element_desc=resource_id)
-                            return {"success": True}
+                            # 使用标准记录格式
+                            self._record_click('id', resource_id, element_desc=f"{resource_id}{index_desc}")
+                            return {"success": True, "message": f"✅ 点击成功: {resource_id}{index_desc}"}
                         else:
-                            return {"success": False, "msg": f"索引{index}超出范围(共{len(elements)}个)"}
-                    return {"success": False, "fallback": "vision", "msg": f"未找到ID'{resource_id}'"}
-                else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                            return {"success": False, "message": f"❌ 索引超出范围: 找到 {len(elements)} 个元素，但请求索引 {index}"}
+                    return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
             else:
                 elem = self.client.u2(resourceId=resource_id)
                 if elem.exists(timeout=0.5):
+                    # 获取匹配元素数量
                     count = elem.count
                     if index < count:
                         elem[index].click()
                         time.sleep(0.3)
-                        self._record_click('id', resource_id, element_desc=resource_id)
-                        return {"success": True}
+                        # 使用标准记录格式
+                        self._record_click('id', resource_id, element_desc=f"{resource_id}{index_desc}")
+                        return {"success": True, "message": f"✅ 点击成功: {resource_id}{index_desc}" + (f" (共 {count} 个)" if count > 1 else "")}
                     else:
-                        return {"success": False, "msg": f"索引{index}超出范围(共{count}个)"}
-                return {"success": False, "fallback": "vision", "msg": f"未找到ID'{resource_id}'"}
+                        return {"success": False, "message": f"❌ 索引超出范围: 找到 {count} 个元素，但请求索引 {index}"}
+                return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
         except Exception as e:
-            return {"success": False, "msg": str(e)}
+            return {"success": False, "message": f"❌ 点击失败: {e}"}
     
     # ==================== 长按操作 ====================
     
@@ -1550,7 +1550,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     screen_width, screen_height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 info = self.client.u2.info
                 screen_width = info.get('displayWidth', 0)
@@ -1603,11 +1603,23 @@ class BasicMobileToolsLite:
             
             if converted:
                 if conversion_type == "crop_offset":
-                    return {"success": True}
+                    return {
+                        "success": True,
+                        "message": f"✅ 长按成功: ({x}, {y}) 持续 {duration}s\n"
+                                  f"   🔍 局部截图坐标转换: ({original_x},{original_y}) + 偏移({crop_offset_x},{crop_offset_y}) → ({x},{y})"
+                    }
                 else:
-                    return {"success": True}
+                    return {
+                        "success": True,
+                        "message": f"✅ 长按成功: ({x}, {y}) 持续 {duration}s\n"
+                                  f"   📐 坐标已转换: ({original_x},{original_y}) → ({x},{y})\n"
+                                  f"   🖼️ 图片尺寸: {image_width}x{image_height} → 屏幕: {screen_width}x{screen_height}"
+                    }
             else:
-                return {"success": True}
+                return {
+                    "success": True,
+                    "message": f"✅ 长按成功: ({x}, {y}) 持续 {duration}s [相对位置: {x_percent}%, {y_percent}%]"
+                }
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -1636,14 +1648,14 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 info = self.client.u2.info
                 width = info.get('displayWidth', 0)
                 height = info.get('displayHeight', 0)
             
             if width == 0 or height == 0:
-                return {"success": False, "msg": "无法获取屏幕尺寸"}
+                return {"success": False, "message": "❌ 无法获取屏幕尺寸"}
             
             # 第2步：百分比转像素坐标
             x = int(width * x_percent / 100)
@@ -1665,7 +1677,13 @@ class BasicMobileToolsLite:
             self._record_long_press('percent', f"{x_percent}%,{y_percent}%", duration,
                                    x_percent, y_percent, element_desc=f"百分比({x_percent}%,{y_percent}%)")
             
-            return {"success": True
+            return {
+                "success": True,
+                "message": f"✅ 百分比长按成功: ({x_percent}%, {y_percent}%) → 像素({x}, {y}) 持续 {duration}s",
+                "screen_size": {"width": width, "height": height},
+                "percent": {"x": x_percent, "y": y_percent},
+                "pixel": {"x": x, "y": y},
+                "duration": duration
             }
         except Exception as e:
             return {"success": False, "message": f"❌ 百分比长按失败: {e}"}
@@ -1695,8 +1713,8 @@ class BasicMobileToolsLite:
                             ios_client.wda.swipe(x, y, x, y, duration=duration)
                         time.sleep(0.3)
                         self._record_long_press('text', text, duration, element_desc=text, locator_attr='text')
-                        return {"success": True}
-                    return {"success": False, "msg": f"未找到'{text}'"}
+                        return {"success": True, "message": f"✅ 长按成功: '{text}' 持续 {duration}s"}
+                    return {"success": False, "message": f"❌ 文本不存在: {text}"}
             else:
                 # 获取屏幕尺寸用于计算百分比
                 screen_width, screen_height = self.client.u2.window_size()
@@ -1734,7 +1752,7 @@ class BasicMobileToolsLite:
                         time.sleep(0.3)
                         self._record_long_press('text', attr_value, duration, x_pct, y_pct,
                                                element_desc=text, locator_attr=attr_type)
-                        return {"success": True}
+                        return {"success": True, "message": f"✅ 长按成功({attr_type}): '{text}' 持续 {duration}s"}
                     
                     # 如果选择器失败，用坐标兜底
                     if bounds:
@@ -1744,9 +1762,9 @@ class BasicMobileToolsLite:
                         time.sleep(0.3)
                         self._record_long_press('percent', f"{x_pct}%,{y_pct}%", duration, x_pct, y_pct,
                                                element_desc=text)
-                        return {"success": True}
+                        return {"success": True, "message": f"✅ 长按成功(坐标兜底): '{text}' @ ({x},{y}) 持续 {duration}s"}
                 
-                return {"success": False, "msg": f"未找到'{text}'"}
+                return {"success": False, "message": f"❌ 文本不存在: {text}"}
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -1774,8 +1792,8 @@ class BasicMobileToolsLite:
                             ios_client.wda.swipe(x, y, x, y, duration=duration)
                         time.sleep(0.3)
                         self._record_long_press('id', resource_id, duration, element_desc=resource_id)
-                        return {"success": True}
-                    return {"success": False, "msg": f"未找到'{resource_id}'"}
+                        return {"success": True, "message": f"✅ 长按成功: {resource_id} 持续 {duration}s"}
+                    return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
             else:
                 elem = self.client.u2(resourceId=resource_id)
                 if elem.exists(timeout=0.5):
@@ -1783,7 +1801,7 @@ class BasicMobileToolsLite:
                     time.sleep(0.3)
                     self._record_long_press('id', resource_id, duration, element_desc=resource_id)
                     return {"success": True, "message": f"✅ 长按成功: {resource_id} 持续 {duration}s"}
-                return {"success": False, "msg": f"未找到'{resource_id}'"}
+                return {"success": False, "message": f"❌ 元素不存在: {resource_id}"}
         except Exception as e:
             return {"success": False, "message": f"❌ 长按失败: {e}"}
     
@@ -2040,8 +2058,15 @@ class BasicMobileToolsLite:
             x_percent = round(x / screen_width * 100, 1) if screen_width > 0 else 0
             y_percent = round(y / screen_height * 100, 1) if screen_height > 0 else 0
             
-            # 使用标准记录格式
-            self._record_input(text, 'percent', f"{x_percent}%,{y_percent}%", x_percent, y_percent)
+            self._record_operation(
+                'input', 
+                x=x, 
+                y=y, 
+                x_percent=x_percent,
+                y_percent=y_percent,
+                ref=f"coords_{x}_{y}", 
+                text=text
+            )
             
             # 🎯 关键步骤：检查应用是否跳转，如果跳转则自动返回目标应用
             app_check = self._check_app_switched()
@@ -2071,13 +2096,16 @@ class BasicMobileToolsLite:
     
     # ==================== 导航操作 ====================
     
-    async def swipe(self, direction: str, y: Optional[int] = None, y_percent: Optional[float] = None) -> Dict:
+    async def swipe(self, direction: str, y: Optional[int] = None, y_percent: Optional[float] = None,
+                   distance: Optional[int] = None, distance_percent: Optional[float] = None) -> Dict:
         """滑动屏幕
         
         Args:
             direction: 滑动方向 (up/down/left/right)
             y: 左右滑动时指定的高度坐标（像素）
             y_percent: 左右滑动时指定的高度百分比 (0-100)
+            distance: 横向滑动时指定的滑动距离（像素），仅用于 left/right
+            distance_percent: 横向滑动时指定的滑动距离百分比 (0-100)，仅用于 left/right
         """
         try:
             if self._is_ios():
@@ -2086,7 +2114,7 @@ class BasicMobileToolsLite:
                     size = ios_client.wda.window_size()
                     width, height = size[0], size[1]
                 else:
-                    return {"success": False, "msg": "iOS未初始化"}
+                    return {"success": False, "message": "❌ iOS 客户端未初始化"}
             else:
                 width, height = self.client.u2.window_size()
             
@@ -2104,20 +2132,53 @@ class BasicMobileToolsLite:
                     swipe_y = y
                 else:
                     swipe_y = center_y
+                
+                # 计算横向滑动距离
+                if distance_percent is not None:
+                    if not (0 <= distance_percent <= 100):
+                        return {"success": False, "message": f"❌ distance_percent 必须在 0-100 之间: {distance_percent}"}
+                    swipe_distance = int(width * distance_percent / 100)
+                elif distance is not None:
+                    if distance <= 0:
+                        return {"success": False, "message": f"❌ distance 必须大于 0: {distance}"}
+                    if distance > width:
+                        return {"success": False, "message": f"❌ distance 不能超过屏幕宽度 ({width}): {distance}"}
+                    swipe_distance = distance
+                else:
+                    # 默认滑动距离：屏幕宽度的 60%（从 0.8 到 0.2）
+                    swipe_distance = int(width * 0.6)
+                
+                # 计算起始和结束位置
+                if direction == 'left':
+                    # 从右向左滑动：起始点在右侧，结束点在左侧
+                    # 确保起始点不超出屏幕右边界
+                    start_x = min(center_x + swipe_distance // 2, width - 10)
+                    end_x = start_x - swipe_distance
+                    # 确保结束点不超出屏幕左边界
+                    if end_x < 10:
+                        end_x = 10
+                        start_x = min(end_x + swipe_distance, width - 10)
+                else:  # right
+                    # 从左向右滑动：起始点在左侧，结束点在右侧
+                    # 确保起始点不超出屏幕左边界
+                    start_x = max(center_x - swipe_distance // 2, 10)
+                    end_x = start_x + swipe_distance
+                    # 确保结束点不超出屏幕右边界
+                    if end_x > width - 10:
+                        end_x = width - 10
+                        start_x = max(end_x - swipe_distance, 10)
+                
+                x1, y1, x2, y2 = start_x, swipe_y, end_x, swipe_y
             else:
                 swipe_y = center_y
-            
-            swipe_map = {
-                'up': (center_x, int(height * 0.8), center_x, int(height * 0.2)),
-                'down': (center_x, int(height * 0.2), center_x, int(height * 0.8)),
-                'left': (int(width * 0.8), swipe_y, int(width * 0.2), swipe_y),
-                'right': (int(width * 0.2), swipe_y, int(width * 0.8), swipe_y),
-            }
-            
-            if direction not in swipe_map:
-                return {"success": False, "message": f"❌ 不支持的方向: {direction}"}
-            
-            x1, y1, x2, y2 = swipe_map[direction]
+                # 纵向滑动保持原有逻辑
+                swipe_map = {
+                    'up': (center_x, int(height * 0.8), center_x, int(height * 0.2)),
+                    'down': (center_x, int(height * 0.2), center_x, int(height * 0.8)),
+                }
+                if direction not in swipe_map:
+                    return {"success": False, "message": f"❌ 不支持的方向: {direction}"}
+                x1, y1, x2, y2 = swipe_map[direction]
             
             if self._is_ios():
                 ios_client.wda.swipe(x1, y1, x2, y2)
@@ -2138,10 +2199,21 @@ class BasicMobileToolsLite:
             # 构建返回消息
             msg = f"✅ 滑动成功: {direction}"
             if direction in ['left', 'right']:
+                msg_parts = []
                 if y_percent is not None:
-                    msg += f" (高度: {y_percent}% = {swipe_y}px)"
+                    msg_parts.append(f"高度: {y_percent}% = {swipe_y}px")
                 elif y is not None:
-                    msg += f" (高度: {y}px)"
+                    msg_parts.append(f"高度: {y}px")
+                
+                if distance_percent is not None:
+                    msg_parts.append(f"距离: {distance_percent}% = {swipe_distance}px")
+                elif distance is not None:
+                    msg_parts.append(f"距离: {distance}px")
+                else:
+                    msg_parts.append(f"距离: 默认 {swipe_distance}px")
+                
+                if msg_parts:
+                    msg += f" ({', '.join(msg_parts)})"
             
             # 如果检测到应用跳转，添加警告和返回结果
             if app_check['switched']:
@@ -2182,22 +2254,22 @@ class BasicMobileToolsLite:
                             ios_client.wda.send_keys('\n')
                         elif ios_key == 'home':
                             ios_client.wda.home()
-                        return {"success": True}
-                return {"success": False, "msg": f"iOS不支持{key}"}
+                        return {"success": True, "message": f"✅ 按键成功: {key}"}
+                return {"success": False, "message": f"❌ iOS 不支持: {key}"}
             else:
                 keycode = key_map.get(key.lower())
                 if keycode:
                     self.client.u2.shell(f'input keyevent {keycode}')
                     self._record_key(key)
-                    return {"success": True}
-                return {"success": False, "msg": f"不支持按键{key}"}
+                    return {"success": True, "message": f"✅ 按键成功: {key}"}
+                return {"success": False, "message": f"❌ 不支持的按键: {key}"}
         except Exception as e:
             return {"success": False, "message": f"❌ 按键失败: {e}"}
     
     def wait(self, seconds: float) -> Dict:
         """等待指定时间"""
         time.sleep(seconds)
-        return {"success": True}
+        return {"success": True, "message": f"✅ 已等待 {seconds} 秒"}
     
     # ==================== 应用管理 ====================
     
@@ -2226,7 +2298,10 @@ class BasicMobileToolsLite:
             
             self._record_operation('launch_app', package_name=package_name)
             
-            return {"success": True}
+            return {
+                "success": True,
+                "message": f"✅ 已启动: {package_name}\n💡 建议等待 2-3 秒让页面加载\n📱 已设置应用状态监测"
+            }
         except Exception as e:
             return {"success": False, "message": f"❌ 启动失败: {e}"}
     
@@ -2239,9 +2314,9 @@ class BasicMobileToolsLite:
                     ios_client.wda.app_terminate(package_name)
             else:
                 self.client.u2.app_stop(package_name)
-            return {"success": True}
+            return {"success": True, "message": f"✅ 已终止: {package_name}"}
         except Exception as e:
-            return {"success": False, "msg": str(e)}
+            return {"success": False, "message": f"❌ 终止失败: {e}"}
     
     def list_apps(self, filter_keyword: str = "") -> Dict:
         """列出已安装应用"""
@@ -2353,26 +2428,6 @@ class BasicMobileToolsLite:
                     '_shadow', 'shadow_', '_divider', 'divider_', '_line', 'line_'
                 }
                 
-                # Token 优化：构建精简元素（只返回非空字段）
-                def build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name):
-                    """只返回有值的字段，节省 token"""
-                    item = {}
-                    if resource_id:
-                        # 精简 resource_id，只保留最后一段
-                        item['id'] = resource_id.split('/')[-1] if '/' in resource_id else resource_id
-                    if text:
-                        item['text'] = text
-                    if content_desc:
-                        item['desc'] = content_desc
-                    if bounds:
-                        item['bounds'] = bounds
-                    if likely_click:
-                        item['click'] = True  # 启发式判断可点击
-                    # class 精简：只保留关键类型
-                    if class_name in ('EditText', 'TextInput', 'Button', 'ImageButton', 'CheckBox', 'Switch'):
-                        item['type'] = class_name
-                    return item
-                
                 result = []
                 for elem in elements:
                     # 获取元素属性
@@ -2392,11 +2447,14 @@ class BasicMobileToolsLite:
                     
                     # 2. 检查是否是功能控件（直接保留）
                     if class_name in FUNCTIONAL_WIDGETS:
-                        # 使用启发式判断可点击性（替代不准确的 clickable 属性）
-                        likely_click = self._is_likely_clickable(class_name, resource_id, text, content_desc, clickable, bounds)
-                        item = build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name)
-                        if item:
-                            result.append(item)
+                        result.append({
+                            'resource_id': resource_id,
+                            'text': text,
+                            'content_desc': content_desc,
+                            'bounds': bounds,
+                            'clickable': clickable,
+                            'class': class_name
+                        })
                         continue
                     
                     # 3. 检查是否是容器控件
@@ -2409,10 +2467,14 @@ class BasicMobileToolsLite:
                                 # 所有属性都是默认值，过滤掉
                                 continue
                         # 有业务ID或其他有意义属性，保留
-                        likely_click = self._is_likely_clickable(class_name, resource_id, text, content_desc, clickable, bounds)
-                        item = build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name)
-                        if item:
-                            result.append(item)
+                        result.append({
+                            'resource_id': resource_id,
+                            'text': text,
+                            'content_desc': content_desc,
+                            'bounds': bounds,
+                            'clickable': clickable,
+                            'class': class_name
+                        })
                         continue
                     
                     # 4. 检查是否是装饰类控件
@@ -2429,72 +2491,19 @@ class BasicMobileToolsLite:
                         continue
                     
                     # 6. 其他情况：有意义的元素保留
-                    likely_click = self._is_likely_clickable(class_name, resource_id, text, content_desc, clickable, bounds)
-                    item = build_compact_element(resource_id, text, content_desc, bounds, likely_click, class_name)
-                    if item:
-                        result.append(item)
-                
-                # Token 优化：可选限制返回元素数量（默认不限制，确保准确度）
-                if TOKEN_OPTIMIZATION and MAX_ELEMENTS > 0 and len(result) > MAX_ELEMENTS:
-                    # 仅在用户明确设置 MAX_ELEMENTS_RETURN 时才截断
-                    truncated = result[:MAX_ELEMENTS]
-                    truncated.append({
-                        '_truncated': True,
-                        '_total': len(result),
-                        '_shown': MAX_ELEMENTS
+                    result.append({
+                        'resource_id': resource_id,
+                        'text': text,
+                        'content_desc': content_desc,
+                        'bounds': bounds,
+                        'clickable': clickable,
+                        'class': class_name
                     })
-                    return truncated
                 
                 return result
         except Exception as e:
             return [{"error": f"获取元素失败: {e}"}]
     
-    def _get_page_texts(self, max_count: int = 15) -> List[str]:
-        """获取页面关键文本列表（用于点击后快速确认页面变化）
-        
-        Args:
-            max_count: 最多返回的文本数量
-            
-        Returns:
-            页面上的关键文本列表（去重）
-        """
-        try:
-            if self._is_ios():
-                ios_client = self._get_ios_client()
-                if ios_client and hasattr(ios_client, 'wda'):
-                    # iOS: 获取所有 StaticText 的文本
-                    elements = ios_client.wda(type='XCUIElementTypeStaticText').find_elements()
-                    texts = set()
-                    for elem in elements[:50]:  # 限制扫描数量
-                        try:
-                            name = elem.name or elem.label
-                            if name and len(name) > 1 and len(name) < 50:
-                                texts.add(name)
-                        except:
-                            pass
-                    return list(texts)[:max_count]
-                return []
-            else:
-                # Android: 快速扫描 XML 获取文本
-                xml_string = self.client.u2.dump_hierarchy(compressed=True)
-                import xml.etree.ElementTree as ET
-                root = ET.fromstring(xml_string)
-                
-                texts = set()
-                for elem in root.iter():
-                    text = elem.get('text', '').strip()
-                    desc = elem.get('content-desc', '').strip()
-                    # 只收集有意义的文本（长度2-30，非纯数字）
-                    for t in [text, desc]:
-                        if t and 2 <= len(t) <= 30 and not t.isdigit():
-                            texts.add(t)
-                    if len(texts) >= max_count * 2:  # 收集足够后停止
-                        break
-                
-                return list(texts)[:max_count]
-        except Exception:
-            return []
-    
     def _has_business_id(self, resource_id: str) -> bool:
         """
         判断resource_id是否是业务相关的ID
@@ -2526,68 +2535,6 @@ class BasicMobileToolsLite:
         
         return True
     
-    def _is_likely_clickable(self, class_name: str, resource_id: str, text: str,
-                             content_desc: str, clickable: bool, bounds: str) -> bool:
-        """
-        启发式判断元素是否可能可点击
-        
-        Android 的 clickable 属性经常不准确，因为：
-        1. 点击事件可能设置在父容器上
-        2. 使用 onTouchListener 而不是 onClick
-        3. RecyclerView item 通过 ItemClickListener 处理
-        
-        此方法通过多种规则推断元素的真实可点击性
-        """
-        # 规则1：clickable=true 肯定可点击
-        if clickable:
-            return True
-        
-        # 规则2：特定类型的控件通常可点击
-        TYPICALLY_CLICKABLE = {
-            'Button', 'ImageButton', 'CheckBox', 'RadioButton', 'Switch',
-            'ToggleButton', 'FloatingActionButton', 'Chip', 'TabView',
-            'EditText', 'TextInput',  # 输入框可点击获取焦点
-        }
-        if class_name in TYPICALLY_CLICKABLE:
-            return True
-        
-        # 规则3：resource_id 包含可点击关键词
-        if resource_id:
-            id_lower = resource_id.lower()
-            CLICK_KEYWORDS = [
-                'btn', 'button', 'click', 'tap', 'submit', 'confirm',
-                'cancel', 'close', 'back', 'next', 'prev', 'more',
-                'action', 'link', 'menu', 'tab', 'item', 'cell',
-                'card', 'avatar', 'icon', 'entry', 'option', 'arrow'
-            ]
-            for kw in CLICK_KEYWORDS:
-                if kw in id_lower:
-                    return True
-        
-        # 规则4：content_desc 包含可点击暗示
-        if content_desc:
-            desc_lower = content_desc.lower()
-            CLICK_HINTS = ['点击', '按钮', '关闭', '返回', '更多', 'click', 'tap', 'button', 'close']
-            for hint in CLICK_HINTS:
-                if hint in desc_lower:
-                    return True
-        
-        # 规则5：有 resource_id 或 content_desc 的小图标可能可点击
-        # （纯 ImageView 不加判断，误判率太高）
-        if class_name in ('ImageView', 'Image') and (resource_id or content_desc) and bounds:
-            match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds)
-            if match:
-                x1, y1, x2, y2 = map(int, match.groups())
-                w, h = x2 - x1, y2 - y1
-                # 小图标（20-100px）更可能是按钮
-                if 20 <= w <= 100 and 20 <= h <= 100:
-                    return True
-        
-        # 规则6：移除（TextView 误判率太高，只依赖上面的规则）
-        # 如果有 clickable=true 或 ID/desc 中有关键词，前面的规则已经覆盖
-        
-        return False
-    
     def find_close_button(self) -> Dict:
         """智能查找关闭按钮（不点击，只返回位置）
         
@@ -2601,7 +2548,7 @@ class BasicMobileToolsLite:
             import re
             
             if self._is_ios():
-                return {"success": False, "msg": "iOS暂不支持"}
+                return {"success": False, "message": "iOS 暂不支持，请使用截图+坐标点击"}
             
             # 获取屏幕尺寸
             screen_width = self.client.u2.info.get('displayWidth', 720)
@@ -2612,14 +2559,6 @@ class BasicMobileToolsLite:
             import xml.etree.ElementTree as ET
             root = ET.fromstring(xml_string)
             
-            # 🔴 先检测是否有弹窗，避免误识别普通页面的按钮
-            popup_bounds, popup_confidence = self._detect_popup_with_confidence(
-                root, screen_width, screen_height
-            )
-            
-            if popup_bounds is None or popup_confidence < 0.5:
-                return {"success": True, "popup": False}
-            
             # 关闭按钮特征
             close_texts = ['×', 'X', 'x', '关闭', '取消', 'close', 'Close', '跳过', '知道了', '我知道了']
             candidates = []
@@ -2721,16 +2660,27 @@ class BasicMobileToolsLite:
             candidates.sort(key=lambda x: x['score'], reverse=True)
             best = candidates[0]
             
-            # Token 优化：只返回最必要的信息
             return {
                 "success": True,
-                "popup": True,
-                "close": {"x": best['x_percent'], "y": best['y_percent']},
-                "cmd": f"click_by_percent({best['x_percent']},{best['y_percent']})"
+                "message": f"✅ 找到可能的关闭按钮",
+                "best_candidate": {
+                    "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']})",
+                "other_candidates": [
+                    {"reason": c['reason'], "percent": f"({c['x_percent']}%, {c['y_percent']}%)", "score": c['score']}
+                    for c in candidates[1:4]
+                ] if len(candidates) > 1 else [],
+                "screen_size": {"width": screen_width, "height": screen_height}
             }
             
         except Exception as e:
-            return {"success": False, "msg": str(e)}
+            return {"success": False, "message": f"❌ 查找关闭按钮失败: {e}"}
     
     def close_popup(self) -> Dict:
         """智能关闭弹窗（改进版）
@@ -2753,7 +2703,7 @@ class BasicMobileToolsLite:
             
             # 获取屏幕尺寸
             if self._is_ios():
-                return {"success": False, "msg": "iOS暂不支持"}
+                return {"success": False, "message": "iOS 暂不支持，请使用截图+坐标点击"}
             
             screen_width = self.client.u2.info.get('displayWidth', 720)
             screen_height = self.client.u2.info.get('displayHeight', 1280)
@@ -2781,10 +2731,8 @@ class BasicMobileToolsLite:
                 # 如果置信度不够高，记录但继续尝试查找关闭按钮
                 popup_detected = popup_bounds is not None and popup_confidence >= 0.6
                 
-                # 🔴 关键检查：如果没有检测到弹窗区域，直接返回"无弹窗"
-                # 避免误点击普通页面上的"关闭"、"取消"等按钮
-                if not popup_detected:
-                    return {"success": True, "popup": False}
+                # 【重要修复】如果没有检测到弹窗区域，只搜索有明确关闭特征的元素（文本、resource-id等）
+                # 避免误点击普通页面的右上角图标
                 
                 # ===== 第二步：在弹窗范围内查找关闭按钮 =====
                 for idx, elem in enumerate(all_elements):
@@ -2793,6 +2741,7 @@ class BasicMobileToolsLite:
                     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
@@ -2809,7 +2758,7 @@ class BasicMobileToolsLite:
                     center_y = (y1 + y2) // 2
                     
                     # 如果检测到弹窗区域，检查元素是否在弹窗范围内或附近
-                    in_popup = True
+                    in_popup = False
                     popup_edge_bonus = 0
                     is_floating_close = False  # 是否是浮动关闭按钮（在弹窗外部上方）
                     if popup_bounds:
@@ -2850,6 +2799,20 @@ class BasicMobileToolsLite:
                         # 浮动关闭按钮（在弹窗上方外侧）给予高额加分
                         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
@@ -2923,9 +2886,86 @@ class BasicMobileToolsLite:
                 pass
             
             if not close_candidates:
+                # 如果检测到高置信度的弹窗区域，先尝试点击常见的关闭按钮位置
                 if popup_detected and popup_bounds:
-                    return {"success": False, "fallback": "vision", "popup": True}
-                return {"success": True, "popup": False}
+                    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": "请查看截图确认弹窗是否已关闭。如果还在，可手动分析截图找到关闭按钮位置。"
+                    }
+                
+                # 没有检测到弹窗区域，截图让 AI 分析
+                screenshot_result = self.take_screenshot(description="页面截图", compress=True)
+                
+                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": "⚠️ 截图分析期间弹窗可能自动消失。如果是定时弹窗，建议等待其自动消失。"
+                }
             
             # 按得分排序，取最可能的
             close_candidates.sort(key=lambda x: x['score'], reverse=True)
@@ -2943,22 +2983,62 @@ class BasicMobileToolsLite:
                 # 应用已跳转，说明弹窗去除失败，尝试返回目标应用
                 return_result = self._return_to_target_app()
             
-            # 记录操作
-            self._record_click('percent', f"{best['x_percent']}%,{best['y_percent']}%", 
-                              best['x_percent'], best['y_percent'],
-                              element_desc=f"关闭按钮({best['position']})")
+            # 点击后截图，让 AI 判断是否成功
+            screenshot_result = self.take_screenshot("关闭弹窗后")
+            
+            # 记录操作（使用百分比，跨设备兼容）
+            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']}"
+            )
             
-            # Token 优化：精简返回值
-            result = {"success": True, "clicked": True}
+            # 构建返回消息
+            msg = f"✅ 已点击关闭按钮 ({best['position']}): ({best['center_x']}, {best['center_y']})"
             if app_check['switched']:
-                result["switched"] = True
+                msg += f"\n⚠️ 应用已跳转，说明弹窗去除失败"
                 if return_result:
-                    result["returned"] = return_result['success']
+                    if return_result['success']:
+                        msg += f"\n{return_result['message']}"
+                    else:
+                        msg += f"\n❌ 自动返回失败: {return_result['message']}"
             
-            return result
+            # 返回候选按钮列表，让 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 中的其他位置"
+            }
             
         except Exception as e:
-            return {"success": False, "msg": str(e)}
+            return {"success": False, "message": f"❌ 关闭弹窗失败: {e}"}
     
     def _get_position_name(self, rel_x: float, rel_y: float) -> str:
         """根据相对坐标获取位置名称"""
@@ -3040,6 +3120,15 @@ class BasicMobileToolsLite:
             resource_id = elem.attrib.get('resource-id', '')
             clickable = elem.attrib.get('clickable', 'false') == 'true'
             
+            # 检查是否是关闭按钮
+            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', '')
+            )
+            
             all_elements.append({
                 'idx': idx,
                 'bounds': (x1, y1, x2, y2),
@@ -3052,6 +3141,7 @@ class BasicMobileToolsLite:
                 'clickable': clickable,
                 'center_x': (x1 + x2) // 2,
                 'center_y': (y1 + y2) // 2,
+                'is_close_button': is_close_button,
             })
         
         if not all_elements:
@@ -3060,6 +3150,8 @@ class BasicMobileToolsLite:
         # 弹窗检测关键词
         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
@@ -3090,6 +3182,59 @@ class BasicMobileToolsLite:
             if y1 < 50:
                 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  # 跳过底部导航栏
+            
+            # 【非弹窗特征】如果元素包含顶部搜索栏，则不是弹窗
+            if y1 < screen_height * 0.15:
+                if 'search' in resource_id.lower() or 'Search' in class_name:
+                    continue  # 跳过顶部搜索栏
+            
+            # 先检查是否有强弹窗特征（用于后续判断）
+            has_strong_popup_feature = (
+                any(kw in class_name for kw in 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)  # 广告弹窗关键词
+            )
+            
+            # 检查是否有子元素是关闭按钮（作为弹窗特征）
+            has_close_button_child = False
+            elem_bounds = elem['bounds']
+            for other_elem in all_elements:
+                if other_elem['idx'] == elem['idx']:
+                    continue
+                if other_elem['is_close_button']:
+                    # 检查关闭按钮是否在这个元素范围内
+                    ox1, oy1, ox2, oy2 = other_elem['bounds']
+                    ex1, ey1, ex2, ey2 = elem_bounds
+                    if ex1 <= ox1 and ey1 <= oy1 and ex2 >= ox2 and ey2 >= oy2:
+                        has_close_button_child = True
+                        break
+            
+            # 【非弹窗特征】如果元素包含明显的页面内容特征，则不是弹窗
+            # 检查是否包含视频播放器、内容列表等页面元素
+            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 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  # 跳过大面积非弹窗元素（接近全屏的内容区域，如首页视频播放区域）
+            
+            # 对于面积 > 0.7 的元素，即使有强特征也要更严格
+            if area_ratio > 0.7:
+                # 需要非常强的特征才认为是弹窗
+                if not has_strong_popup_feature:
+                    continue
+            
             confidence = 0.0
             
             # 【强特征】class 名称包含弹窗关键词 (+0.5)
@@ -3100,19 +3245,46 @@ class BasicMobileToolsLite:
             if any(kw in resource_id.lower() for kw in dialog_id_keywords):
                 confidence += 0.4
             
+            # 【强特征】resource-id 包含广告弹窗关键词 (+0.4)
+            if any(kw in resource_id.lower() for kw in ad_popup_keywords):
+                confidence += 0.4
+            
+            # 【强特征】包含关闭按钮作为子元素 (+0.3)
+            if has_close_button_child:
+                confidence += 0.3
+            
             # 【中等特征】居中显示 (+0.2)
+            # 但如果没有强特征，降低权重
             center_x = elem['center_x']
             center_y = elem['center_y']
             is_centered_x = abs(center_x - screen_width / 2) < screen_width * 0.15
             is_centered_y = abs(center_y - screen_height / 2) < screen_height * 0.25
+            
+            has_strong_feature = (
+                any(kw in class_name for kw in 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
+                has_close_button_child
+            )
+            
             if is_centered_x and is_centered_y:
-                confidence += 0.2
+                if has_strong_feature:
+                    confidence += 0.2
+                else:
+                    confidence += 0.1  # 没有强特征时降低权重
             elif is_centered_x:
-                confidence += 0.1
+                if has_strong_feature:
+                    confidence += 0.1
+                else:
+                    confidence += 0.05  # 没有强特征时降低权重
             
             # 【中等特征】非全屏但有一定大小 (+0.15)
+            # 但如果没有强特征，降低权重
             if 0.15 < area_ratio < 0.75:
-                confidence += 0.15
+                if has_strong_feature:
+                    confidence += 0.15
+                else:
+                    confidence += 0.08  # 没有强特征时降低权重
             
             # 【弱特征】XML 顺序靠后（在视图层级上层）(+0.1)
             if elem['idx'] > len(all_elements) * 0.5:
@@ -3139,8 +3311,22 @@ class BasicMobileToolsLite:
         popup_candidates.sort(key=lambda x: (x['confidence'], x['idx']), reverse=True)
         best = popup_candidates[0]
         
-        # 只有置信度 >= 0.6 才返回弹窗
-        if best['confidence'] >= 0.6:
+        # 更严格的阈值：只有置信度 >= 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)
+        )
+        
+        if has_strong_feature:
+            # 有强特征时，阈值0.7
+            threshold = 0.7
+        else:
+            # 没有强特征时，阈值0.85（更严格）
+            threshold = 0.85
+        
+        if best['confidence'] >= threshold:
             return best['bounds'], best['confidence']
         
         return None, best['confidence']
@@ -3859,28 +4045,10 @@ class BasicMobileToolsLite:
         try:
             import xml.etree.ElementTree as ET
             
-            # ========== 第0步：先检测是否有弹窗 ==========
+            # ========== 第1步：控件树查找关闭按钮 ==========
             xml_string = self.client.u2.dump_hierarchy(compressed=False)
             root = ET.fromstring(xml_string)
             
-            screen_width = self.client.u2.info.get('displayWidth', 1440)
-            screen_height = self.client.u2.info.get('displayHeight', 3200)
-            
-            popup_bounds, popup_confidence = self._detect_popup_with_confidence(
-                root, screen_width, screen_height
-            )
-            
-            # 如果没有检测到弹窗，直接返回"无弹窗"
-            if popup_bounds is None or popup_confidence < 0.5:
-                result["success"] = True
-                result["method"] = None
-                result["message"] = "ℹ️ 当前页面未检测到弹窗，无需关闭"
-                result["popup_detected"] = False
-                result["popup_confidence"] = popup_confidence
-                return result
-            
-            # ========== 第1步：控件树查找关闭按钮 ==========
-            
             # 关闭按钮的常见特征
             close_keywords = ['关闭', '跳过', '×', 'X', 'x', 'close', 'skip', '取消']
             close_content_desc = ['关闭', '跳过', 'close', 'skip', 'dismiss']
@@ -3959,6 +4127,12 @@ class BasicMobileToolsLite:
                 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)
@@ -3988,11 +4162,17 @@ class BasicMobileToolsLite:
                 result["message"] = msg
                 result["app_check"] = app_check
                 result["return_to_app"] = return_result
-                result["tip"] = "💡 建议调用 mobile_screenshot_with_som 确认弹窗是否已关闭"
+                
+                # 自动学习：检查这个 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}"
                 
                 return result
             
-            # ========== 第2步：模板匹配（自动执行，不需要 AI 介入）==========
+            # ========== 第2步：模板匹配 ==========
             screenshot_path = None
             try:
                 from .template_matcher import TemplateMatcher
@@ -4011,14 +4191,16 @@ class BasicMobileToolsLite:
                         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
@@ -4029,9 +4211,12 @@ class BasicMobileToolsLite:
                               f"   位置: ({x_pct:.1f}%, {y_pct:.1f}%)"
                         
                         if app_check['switched']:
-                            msg += f"\n⚠️ 应用已跳转"
+                            msg += f"\n⚠️ 应用已跳转，说明弹窗去除失败"
                             if return_result:
-                                msg += f"\n{return_result['message']}"
+                                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
@@ -4043,12 +4228,17 @@ class BasicMobileToolsLite:
             except Exception:
                 pass  # 模板匹配失败，继续下一步
             
-            # ========== 第3步：控件树和模板匹配都失败，提示 AI 使用视觉识别 ==========
+            # ========== 第3步：返回截图供 AI 分析 ==========
+            if not screenshot_path:
+                screenshot_result = self.take_screenshot(description="需要AI分析", compress=True)
+            
             result["success"] = False
-            result["fallback"] = "vision"
             result["method"] = None
-            result["popup_detected"] = True
-            result["message"] = "⚠️ 控件树和模板匹配都未找到关闭按钮，请调用 mobile_screenshot_with_som 截图后用 click_by_som 点击"
+            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
             
             return result