mobile-mcp-ai 2.6.1__py3-none-any.whl → 2.6.3__py3-none-any.whl

mobile_mcp/core/basic_tools_lite.py

@@ -500,7 +500,7 @@ class BasicMobileToolsLite:
                 # 左侧标注 Y 坐标
                 draw.text((2, y + 2), str(y), fill=text_color, font=font_small)
             
-            # 第3步：检测弹窗并标注
+            # 第3步：检测弹窗并标注（使用严格的置信度检测，避免误识别）
             popup_info = None
             close_positions = []
             
@@ -510,35 +510,12 @@ class BasicMobileToolsLite:
                     xml_string = self.client.u2.dump_hierarchy(compressed=False)
                     root = ET.fromstring(xml_string)
                     
-                    # 检测弹窗区域
-                    popup_bounds = None
-                    for elem in root.iter():
-                        bounds_str = elem.attrib.get('bounds', '')
-                        class_name = elem.attrib.get('class', '')
-                        
-                        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
-                        area = width * height
-                        screen_area = screen_width * screen_height
-                        
-                        is_container = any(kw in class_name for kw in ['Layout', 'View', 'Dialog', 'Card'])
-                        area_ratio = area / screen_area if screen_area > 0 else 0
-                        is_not_fullscreen = (width < screen_width * 0.98 or height < screen_height * 0.98)
-                        is_reasonable_size = 0.08 < area_ratio < 0.85
-                        
-                        if is_container and is_not_fullscreen and is_reasonable_size and y1 > 50:
-                            if popup_bounds is None or area > (popup_bounds[2] - popup_bounds[0]) * (popup_bounds[3] - popup_bounds[1]):
-                                popup_bounds = (x1, y1, x2, y2)
+                    # 使用严格的弹窗检测（置信度 >= 0.6 才认为是弹窗）
+                    popup_bounds, popup_confidence = self._detect_popup_with_confidence(
+                        root, screen_width, screen_height
+                    )
                     
-                    if popup_bounds:
+                    if popup_bounds and popup_confidence >= 0.6:
                         px1, py1, px2, py2 = popup_bounds
                         popup_width = px2 - px1
                         popup_height = py2 - py1
@@ -769,41 +746,19 @@ class BasicMobileToolsLite:
                     'desc': elem['desc']
                 })
             
-            # 第3.5步：检测弹窗区域（用于标注）
+            # 第3.5步：检测弹窗区域（使用严格的置信度检测，避免误识别普通页面）
             popup_bounds = None
+            popup_confidence = 0
             
             if not self._is_ios():
                 try:
-                    # 检测弹窗区域
-                    for elem in root.iter():
-                        bounds_str = elem.attrib.get('bounds', '')
-                        class_name = elem.attrib.get('class', '')
-                        
-                        if not bounds_str:
-                            continue
-                        
-                        match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
-                        if not match:
-                            continue
-                        
-                        px1, py1, px2, py2 = map(int, match.groups())
-                        p_width = px2 - px1
-                        p_height = py2 - py1
-                        p_area = p_width * p_height
-                        screen_area = screen_width * screen_height
-                        
-                        is_container = any(kw in class_name for kw in ['Layout', 'View', 'Dialog', 'Card', 'Frame'])
-                        area_ratio = p_area / screen_area if screen_area > 0 else 0
-                        is_not_fullscreen = (p_width < screen_width * 0.99 or p_height < screen_height * 0.95)
-                        # 放宽面积范围：5% - 95%
-                        is_reasonable_size = 0.05 < area_ratio < 0.95
-                        
-                        if is_container and is_not_fullscreen and is_reasonable_size and py1 > 30:
-                            if popup_bounds is None or p_area > (popup_bounds[2] - popup_bounds[0]) * (popup_bounds[3] - popup_bounds[1]):
-                                popup_bounds = (px1, py1, px2, py2)
+                    # 使用严格的弹窗检测（置信度 >= 0.6 才认为是弹窗）
+                    popup_bounds, popup_confidence = self._detect_popup_with_confidence(
+                        root, screen_width, screen_height
+                    )
                     
                     # 如果检测到弹窗，标注弹窗边界（不再猜测X按钮位置）
-                    if popup_bounds:
+                    if popup_bounds and popup_confidence >= 0.6:
                         px1, py1, px2, py2 = popup_bounds
                         
                         # 只画弹窗边框（蓝色），不再猜测X按钮位置
@@ -1200,8 +1155,16 @@ class BasicMobileToolsLite:
         except Exception as e:
             return {"success": False, "message": f"❌ 百分比点击失败: {e}"}
     
-    def click_by_text(self, text: str, timeout: float = 3.0) -> Dict:
-        """通过文本点击 - 先查 XML 树，再精准匹配"""
+    def click_by_text(self, text: str, timeout: float = 3.0, position: Optional[str] = None) -> Dict:
+        """通过文本点击 - 先查 XML 树，再精准匹配
+        
+        Args:
+            text: 元素的文本内容
+            timeout: 超时时间
+            position: 位置信息，当有多个相同文案时使用。支持：
+                - 垂直方向: "top"/"upper"/"上", "bottom"/"lower"/"下", "middle"/"center"/"中"
+                - 水平方向: "left"/"左", "right"/"右", "center"/"中"
+        """
         try:
             if self._is_ios():
                 ios_client = self._get_ios_client()
@@ -1217,14 +1180,24 @@ class BasicMobileToolsLite:
                     return {"success": False, "message": f"❌ 文本不存在: {text}"}
             else:
                 # 🔍 先查 XML 树，找到元素及其属性
-                found_elem = self._find_element_in_tree(text)
+                found_elem = self._find_element_in_tree(text, position=position)
                 
                 if found_elem:
                     attr_type = found_elem['attr_type']
                     attr_value = found_elem['attr_value']
                     bounds = found_elem.get('bounds')
                     
-                    # 根据找到的属性类型，使用对应的选择器
+                    # 如果有位置参数，直接使用坐标点击（避免 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_operation('click', element=text, x=x, y=y, ref=f"coords:{x},{y}")
+                        return {"success": True, "message": f"✅ 点击成功(坐标定位): '{text}'{position_info} @ ({x},{y})"}
+                    
+                    # 没有位置参数时，使用选择器定位
                     if attr_type == 'text':
                         elem = self.client.u2(text=attr_value)
                     elif attr_type == 'textContains':
@@ -1239,8 +1212,9 @@ class BasicMobileToolsLite:
                     if elem and elem.exists(timeout=1):
                         elem.click()
                         time.sleep(0.3)
+                        position_info = f" ({position})" if position else ""
                         self._record_operation('click', element=text, ref=f"{attr_type}:{attr_value}")
-                        return {"success": True, "message": f"✅ 点击成功({attr_type}): '{text}'"}
+                        return {"success": True, "message": f"✅ 点击成功({attr_type}): '{text}'{position_info}"}
                     
                     # 如果选择器失败，用坐标兜底
                     if bounds:
@@ -1248,24 +1222,37 @@ class BasicMobileToolsLite:
                         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_operation('click', element=text, x=x, y=y, ref=f"coords:{x},{y}")
-                        return {"success": True, "message": f"✅ 点击成功(坐标兜底): '{text}' @ ({x},{y})"}
+                        return {"success": True, "message": f"✅ 点击成功(坐标兜底): '{text}'{position_info} @ ({x},{y})"}
                 
                 return {"success": False, "message": f"❌ 文本不存在: {text}"}
         except Exception as e:
             return {"success": False, "message": f"❌ 点击失败: {e}"}
     
-    def _find_element_in_tree(self, text: str) -> Optional[Dict]:
-        """在 XML 树中查找包含指定文本的元素"""
+    def _find_element_in_tree(self, text: str, position: Optional[str] = None) -> Optional[Dict]:
+        """在 XML 树中查找包含指定文本的元素，优先返回可点击的元素
+        
+        Args:
+            text: 要查找的文本
+            position: 位置信息，用于在有多个相同文案时筛选
+        """
         try:
             xml = self.client.u2.dump_hierarchy(compressed=False)
             import xml.etree.ElementTree as ET
             root = ET.fromstring(xml)
             
+            # 获取屏幕尺寸
+            screen_width, screen_height = self.client.u2.window_size()
+            
+            # 存储所有匹配的元素（包括不可点击的）
+            matched_elements = []
+            
             for elem in root.iter():
                 elem_text = elem.attrib.get('text', '')
                 elem_desc = elem.attrib.get('content-desc', '')
                 bounds_str = elem.attrib.get('bounds', '')
+                clickable = elem.attrib.get('clickable', 'false').lower() == 'true'
                 
                 # 解析 bounds
                 bounds = None
@@ -1275,24 +1262,108 @@ class BasicMobileToolsLite:
                     if len(match) == 4:
                         bounds = [int(x) for x in match]
                 
+                # 判断是否匹配
+                is_match = False
+                attr_type = None
+                attr_value = None
+                
                 # 精确匹配 text
                 if elem_text == text:
-                    return {'attr_type': 'text', 'attr_value': text, 'bounds': bounds}
-                
+                    is_match = True
+                    attr_type = 'text'
+                    attr_value = text
                 # 精确匹配 content-desc
-                if elem_desc == text:
-                    return {'attr_type': 'description', 'attr_value': text, 'bounds': bounds}
-                
+                elif elem_desc == text:
+                    is_match = True
+                    attr_type = 'description'
+                    attr_value = text
                 # 模糊匹配 text
-                if text in elem_text:
-                    return {'attr_type': 'textContains', 'attr_value': text, 'bounds': bounds}
-                
+                elif text in elem_text:
+                    is_match = True
+                    attr_type = 'textContains'
+                    attr_value = text
                 # 模糊匹配 content-desc
-                if text in elem_desc:
-                    return {'attr_type': 'descriptionContains', 'attr_value': text, 'bounds': bounds}
+                elif text in elem_desc:
+                    is_match = True
+                    attr_type = 'descriptionContains'
+                    attr_value = text
+                
+                if is_match and bounds:
+                    # 计算元素的中心点坐标
+                    center_x = (bounds[0] + bounds[2]) / 2
+                    center_y = (bounds[1] + bounds[3]) / 2
+                    
+                    matched_elements.append({
+                        'attr_type': attr_type,
+                        'attr_value': attr_value,
+                        'bounds': bounds,
+                        'clickable': clickable,
+                        'center_x': center_x,
+                        'center_y': center_y
+                    })
+            
+            if not matched_elements:
+                return None
+            
+            # 如果有位置信息，根据位置筛选
+            if position and len(matched_elements) > 1:
+                position_lower = position.lower()
+                
+                # 根据位置信息排序
+                if position_lower in ['top', 'upper', '上', '上方']:
+                    # 选择 y 坐标最小的（最上面的）
+                    matched_elements = sorted(matched_elements, key=lambda x: x['center_y'])
+                elif position_lower in ['bottom', 'lower', '下', '下方', '底部']:
+                    # 选择 y 坐标最大的（最下面的）
+                    matched_elements = sorted(matched_elements, key=lambda x: x['center_y'], reverse=True)
+                elif position_lower in ['left', '左', '左侧']:
+                    # 选择 x 坐标最小的（最左边的）
+                    matched_elements = sorted(matched_elements, key=lambda x: x['center_x'])
+                elif position_lower in ['right', '右', '右侧']:
+                    # 选择 x 坐标最大的（最右边的）
+                    matched_elements = sorted(matched_elements, key=lambda x: x['center_x'], reverse=True)
+                elif position_lower in ['middle', 'center', '中', '中间']:
+                    # 选择最接近屏幕中心的
+                    screen_mid_x = screen_width / 2
+                    screen_mid_y = screen_height / 2
+                    matched_elements = sorted(
+                        matched_elements,
+                        key=lambda x: abs(x['center_x'] - screen_mid_x) + abs(x['center_y'] - screen_mid_y)
+                    )
+            
+            # 如果有位置信息，优先返回排序后的第一个元素（最符合位置要求的）
+            # 如果没有位置信息，优先返回可点击的元素
+            if position and matched_elements:
+                # 有位置信息时，直接返回排序后的第一个（最符合位置要求的）
+                first_match = matched_elements[0]
+                return {
+                    'attr_type': first_match['attr_type'],
+                    'attr_value': first_match['attr_value'],
+                    'bounds': first_match['bounds']
+                }
+            
+            # 没有位置信息时，优先返回可点击的元素
+            for match in matched_elements:
+                if match['clickable']:
+                    return {
+                        'attr_type': match['attr_type'],
+                        'attr_value': match['attr_value'],
+                        'bounds': match['bounds']
+                    }
+            
+            # 如果没有可点击的元素，直接返回第一个匹配元素的 bounds（使用坐标点击）
+            if matched_elements:
+                first_match = matched_elements[0]
+                return {
+                    'attr_type': first_match['attr_type'],
+                    'attr_value': first_match['attr_value'],
+                    'bounds': first_match['bounds']
+                }
             
             return None
-        except Exception:
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
             return None
     
     def click_by_id(self, resource_id: str, index: int = 0) -> Dict:
@@ -2349,7 +2420,6 @@ class BasicMobileToolsLite:
             for elem in root.iter():
                 text = elem.attrib.get('text', '')
                 content_desc = elem.attrib.get('content-desc', '')
-                resource_id = elem.attrib.get('resource-id', '')
                 bounds_str = elem.attrib.get('bounds', '')
                 class_name = elem.attrib.get('class', '')
                 clickable = elem.attrib.get('clickable', 'false') == 'true'
@@ -2384,13 +2454,6 @@ class BasicMobileToolsLite:
                     score = 90
                     reason = f"描述='{content_desc}'"
                 
-                # 策略2.5：resource-id 包含关闭关键词（如 close_icon, ad_close 等）
-                elif resource_id and any(kw in resource_id.lower() for kw in ['close', 'dismiss', 'skip', 'cancel']):
-                    score = 95
-                    # 提取简短的 id 名
-                    short_id = resource_id.split('/')[-1] if '/' in resource_id else resource_id
-                    reason = f"resource-id='{short_id}'"
-                
                 # 策略3：小尺寸的 clickable 元素（可能是 X 图标）
                 elif clickable:
                     min_size = max(20, int(screen_width * 0.03))
@@ -2425,9 +2488,7 @@ class BasicMobileToolsLite:
                         'center_y': center_y,
                         'x_percent': x_percent,
                         'y_percent': y_percent,
-                        'size': f"{width}x{height}",
-                        'resource_id': resource_id,
-                        'text': text
+                        'size': f"{width}x{height}"
                     })
             
             if not candidates:
@@ -2453,16 +2514,7 @@ class BasicMobileToolsLite:
             candidates.sort(key=lambda x: x['score'], reverse=True)
             best = candidates[0]
             
-            # 生成推荐的点击命令（优先使用 resource-id）
-            if best.get('resource_id'):
-                short_id = best['resource_id'].split('/')[-1] if '/' in best['resource_id'] else best['resource_id']
-                click_cmd = f"mobile_click_by_id('{best['resource_id']}')"
-            elif best.get('text') and best['text'] in ['×', 'X', 'x', '关闭', '取消', '跳过', '知道了']:
-                click_cmd = f"mobile_click_by_text('{best['text']}')"
-            else:
-                click_cmd = f"mobile_click_by_percent({best['x_percent']}, {best['y_percent']})"
-            
-            result = {
+            return {
                 "success": True,
                 "message": f"✅ 找到可能的关闭按钮",
                 "best_candidate": {
@@ -2473,7 +2525,7 @@ class BasicMobileToolsLite:
                     "size": best['size'],
                     "score": best['score']
                 },
-                "click_command": click_cmd,
+                "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]
@@ -2481,14 +2533,6 @@ class BasicMobileToolsLite:
                 "screen_size": {"width": screen_width, "height": screen_height}
             }
             
-            # 如果有 resource-id，额外提供
-            if best.get('resource_id'):
-                result["best_candidate"]["resource_id"] = best['resource_id']
-            if best.get('text'):
-                result["best_candidate"]["text"] = best['text']
-            
-            return result
-            
         except Exception as e:
             return {"success": False, "message": f"❌ 查找关闭按钮失败: {e}"}
     
@@ -2533,53 +2577,13 @@ class BasicMobileToolsLite:
                 root = ET.fromstring(xml_string)
                 all_elements = list(root.iter())
                 
-                # ===== 第一步：检测弹窗区域 =====
-                # 弹窗特征：非全屏、面积较大、通常在屏幕中央的容器
-                popup_containers = []
-                for idx, elem in enumerate(all_elements):
-                    bounds_str = elem.attrib.get('bounds', '')
-                    class_name = elem.attrib.get('class', '')
-                    
-                    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
-                    area = width * height
-                    screen_area = screen_width * screen_height
-                    
-                    # 弹窗容器特征：
-                    # 1. 面积在屏幕的 10%-90% 之间（非全屏）
-                    # 2. 宽度或高度不等于屏幕尺寸
-                    # 3. 是容器类型（Layout/View/Dialog）
-                    is_container = any(kw in class_name for kw in ['Layout', 'View', 'Dialog', 'Card', 'Container'])
-                    area_ratio = area / screen_area
-                    is_not_fullscreen = (width < screen_width * 0.98 or height < screen_height * 0.98)
-                    is_reasonable_size = 0.08 < area_ratio < 0.9
-                    
-                    # 排除状态栏区域（y1 通常很小）
-                    is_below_statusbar = y1 > 50
-                    
-                    if is_container and is_not_fullscreen and is_reasonable_size and is_below_statusbar:
-                        popup_containers.append({
-                            'bounds': (x1, y1, x2, y2),
-                            'bounds_str': bounds_str,
-                            'area': area,
-                            'area_ratio': area_ratio,
-                            'idx': idx,  # 元素在 XML 中的顺序（越后越上层）
-                            'class': class_name
-                        })
+                # ===== 第一步：使用严格的置信度检测弹窗区域 =====
+                popup_bounds, popup_confidence = self._detect_popup_with_confidence(
+                    root, screen_width, screen_height
+                )
                 
-                # 选择最可能的弹窗容器（优先选择：XML 顺序靠后 + 面积适中）
-                if popup_containers:
-                    # 按 XML 顺序倒序（后出现的在上层），然后按面积适中程度排序
-                    popup_containers.sort(key=lambda x: (x['idx'], -abs(x['area_ratio'] - 0.3)), reverse=True)
-                    popup_bounds = popup_containers[0]['bounds']
+                # 如果置信度不够高，记录但继续尝试查找关闭按钮
+                popup_detected = popup_bounds is not None and popup_confidence >= 0.6
                 
                 # ===== 第二步：在弹窗范围内查找关闭按钮 =====
                 for idx, elem in enumerate(all_elements):
@@ -2711,15 +2715,15 @@ class BasicMobileToolsLite:
                             'content_desc': content_desc,
                             'x_percent': round(rel_x * 100, 1),
                             'y_percent': round(rel_y * 100, 1),
-                            'in_popup': popup_bounds is not None
+                            'in_popup': popup_detected
                         })
                         
             except ET.ParseError:
                 pass
             
             if not close_candidates:
-                # 如果检测到弹窗区域，先尝试点击常见的关闭按钮位置
-                if popup_bounds:
+                # 如果检测到高置信度的弹窗区域，先尝试点击常见的关闭按钮位置
+                if popup_detected and popup_bounds:
                     px1, py1, px2, py2 = popup_bounds
                     popup_width = px2 - px1
                     popup_height = py2 - py1
@@ -2852,8 +2856,9 @@ class BasicMobileToolsLite:
                     "percent": (best['x_percent'], best['y_percent'])
                 },
                 "screenshot": screenshot_result.get("screenshot_path", ""),
-                "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,
+                "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": [
@@ -2912,6 +2917,348 @@ class BasicMobileToolsLite:
                 return 0.8
         else:  # 中间区域
             return 0.5
+
+    def _detect_popup_with_confidence(self, root, screen_width: int, screen_height: int) -> tuple:
+        """严格的弹窗检测 - 使用置信度评分，避免误识别普通页面
+        
+        真正的弹窗特征：
+        1. class 名称包含 Dialog/Popup/Alert/Modal/BottomSheet（强特征）
+        2. resource-id 包含 dialog/popup/alert/modal（强特征）
+        3. 有遮罩层（大面积半透明 View 在弹窗之前）
+        4. 居中显示且非全屏
+        5. XML 层级靠后且包含可交互元素
+        
+        Returns:
+            (popup_bounds, confidence) 或 (None, 0)
+            confidence >= 0.6 才认为是弹窗
+        """
+        import re
+        
+        screen_area = screen_width * screen_height
+        
+        # 收集所有元素信息
+        all_elements = []
+        for idx, elem in enumerate(root.iter()):
+            bounds_str = elem.attrib.get('bounds', '')
+            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
+            area = width * height
+            
+            class_name = elem.attrib.get('class', '')
+            resource_id = elem.attrib.get('resource-id', '')
+            clickable = elem.attrib.get('clickable', 'false') == 'true'
+            
+            all_elements.append({
+                'idx': idx,
+                'bounds': (x1, y1, x2, y2),
+                'width': width,
+                'height': height,
+                'area': area,
+                'area_ratio': area / screen_area if screen_area > 0 else 0,
+                'class': class_name,
+                'resource_id': resource_id,
+                'clickable': clickable,
+                'center_x': (x1 + x2) // 2,
+                'center_y': (y1 + y2) // 2,
+            })
+        
+        if not all_elements:
+            return None, 0
+        
+        # 弹窗检测关键词
+        dialog_class_keywords = ['Dialog', 'Popup', 'Alert', 'Modal', 'BottomSheet', 'PopupWindow']
+        dialog_id_keywords = ['dialog', 'popup', 'alert', 'modal', 'bottom_sheet', 'overlay', 'mask']
+        
+        popup_candidates = []
+        has_mask_layer = False
+        mask_idx = -1
+        
+        # 【新增】检测浮动关闭按钮（小尺寸 clickable ImageView，位于屏幕中央偏上）
+        floating_close_buttons = []
+        for elem in all_elements:
+            x1, y1, x2, y2 = elem['bounds']
+            class_name = elem['class']
+            width = elem['width']
+            height = elem['height']
+            
+            # 浮动关闭按钮特征：
+            # 1. 小尺寸（50-200px）
+            # 2. clickable 或 ImageView
+            # 3. 位于屏幕中央区域的上半部分
+            # 4. 接近正方形
+            is_small = 50 < width < 200 and 50 < height < 200
+            is_square_like = 0.5 < (width / height if height > 0 else 0) < 2.0
+            is_clickable_image = elem['clickable'] or 'Image' in class_name
+            is_upper_center = (screen_width * 0.2 < x1 < screen_width * 0.8 and 
+                              y1 < screen_height * 0.5)
+            
+            if is_small and is_square_like and is_clickable_image and is_upper_center:
+                floating_close_buttons.append({
+                    'bounds': elem['bounds'],
+                    'center_x': elem['center_x'],
+                    'center_y': elem['center_y'],
+                    'idx': elem['idx']
+                })
+        
+        for elem in all_elements:
+            x1, y1, x2, y2 = elem['bounds']
+            class_name = elem['class']
+            resource_id = elem['resource_id']
+            area_ratio = elem['area_ratio']
+            
+            # 检测遮罩层（大面积、几乎全屏、通常是 FrameLayout/View）
+            if area_ratio > 0.85 and elem['width'] >= screen_width * 0.95:
+                # 可能是遮罩层，记录位置
+                if 'FrameLayout' in class_name or 'View' in class_name:
+                    has_mask_layer = True
+                    mask_idx = elem['idx']
+            
+            # 跳过全屏元素
+            if area_ratio > 0.9:
+                continue
+            
+            # 跳过太小的元素
+            if area_ratio < 0.05:
+                continue
+            
+            # 跳过状态栏区域
+            if y1 < 50:
+                continue
+            
+            confidence = 0.0
+            
+            # 【强特征】class 名称包含弹窗关键词 (+0.5)
+            if any(kw in class_name for kw in dialog_class_keywords):
+                confidence += 0.5
+            
+            # 【强特征】resource-id 包含弹窗关键词 (+0.4)
+            if any(kw in resource_id.lower() for kw in dialog_id_keywords):
+                confidence += 0.4
+            
+            # 【中等特征】居中显示 (+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
+            if is_centered_x and is_centered_y:
+                confidence += 0.2
+            elif is_centered_x:
+                confidence += 0.1
+            
+            # 【中等特征】非全屏但有一定大小 (+0.15)
+            if 0.15 < area_ratio < 0.75:
+                confidence += 0.15
+            
+            # 【弱特征】XML 顺序靠后（在视图层级上层）(+0.1)
+            if elem['idx'] > len(all_elements) * 0.5:
+                confidence += 0.1
+            
+            # 【弱特征】有遮罩层且在遮罩层之后 (+0.15)
+            if has_mask_layer and elem['idx'] > mask_idx:
+                confidence += 0.15
+            
+            # 【新增强特征】有浮动关闭按钮在此容器上方附近 (+0.4)
+            # 这是很多 App 弹窗的典型设计：内容区域 + 上方的 X 按钮
+            for close_btn in floating_close_buttons:
+                btn_x, btn_y = close_btn['center_x'], close_btn['center_y']
+                # 检查关闭按钮是否在容器的上方（扩大范围到 400px）
+                is_above_container = (
+                    x1 - 100 < btn_x < x2 + 100 and  # 在容器水平范围内
+                    y1 - 400 < btn_y < y1 + 100       # 在容器上方 400px 范围内
+                )
+                if is_above_container:
+                    confidence += 0.4
+                    break  # 只加一次分
+            
+            # 只有达到阈值才加入候选
+            if confidence >= 0.3:
+                popup_candidates.append({
+                    'bounds': elem['bounds'],
+                    'confidence': confidence,
+                    'class': class_name,
+                    'resource_id': resource_id,
+                    'idx': elem['idx']
+                })
+        
+        if not popup_candidates:
+            return None, 0
+        
+        # 选择置信度最高的
+        popup_candidates.sort(key=lambda x: (x['confidence'], x['idx']), reverse=True)
+        best = popup_candidates[0]
+        
+        # 只有置信度 >= 0.6 才返回弹窗
+        if best['confidence'] >= 0.6:
+            return best['bounds'], best['confidence']
+        
+        return None, best['confidence']
+    
+    def start_toast_watch(self) -> Dict:
+        """开始监听 Toast（仅 Android）
+        
+        ⚠️ 必须在执行操作之前调用！
+        
+        正确流程：
+        1. 调用 mobile_start_toast_watch() 开始监听
+        2. 执行操作（如点击提交按钮）
+        3. 调用 mobile_get_toast() 获取 Toast 内容
+        
+        Returns:
+            监听状态
+        """
+        if self._is_ios():
+            return {
+                "success": False,
+                "message": "❌ iOS 不支持 Toast 检测，Toast 是 Android 特有功能"
+            }
+        
+        try:
+            # 清除缓存并开始监听
+            self.client.u2.toast.reset()
+            return {
+                "success": True,
+                "message": "✅ Toast 监听已开启，请立即执行操作，然后调用 mobile_get_toast 获取结果"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"❌ 开启 Toast 监听失败: {e}"
+            }
+    
+    def get_toast(self, timeout: float = 5.0, reset_first: bool = False) -> Dict:
+        """获取 Toast 消息（仅 Android）
+        
+        Toast 是 Android 系统级的短暂提示消息，常用于显示操作结果。
+        
+        ⚠️ 推荐用法（两步走）：
+        1. 先调用 mobile_start_toast_watch() 开始监听
+        2. 执行操作（如点击提交按钮）
+        3. 调用 mobile_get_toast() 获取 Toast
+        
+        或者设置 reset_first=True，会自动 reset 后等待（适合操作已自动触发的场景）
+        
+        Args:
+            timeout: 等待 Toast 出现的超时时间（秒），默认 5 秒
+            reset_first: 是否先 reset（清除旧缓存），默认 False
+        
+        Returns:
+            包含 Toast 消息的字典
+        """
+        if self._is_ios():
+            return {
+                "success": False,
+                "message": "❌ iOS 不支持 Toast 检测，Toast 是 Android 特有功能"
+            }
+        
+        try:
+            if reset_first:
+                # 清除旧缓存，适合等待即将出现的 Toast
+                self.client.u2.toast.reset()
+            
+            # 等待并获取 Toast 消息
+            toast_message = self.client.u2.toast.get_message(
+                wait_timeout=timeout,
+                default=None
+            )
+            
+            if toast_message:
+                return {
+                    "success": True,
+                    "toast_found": True,
+                    "message": toast_message,
+                    "tip": "Toast 消息获取成功"
+                }
+            else:
+                return {
+                    "success": True,
+                    "toast_found": False,
+                    "message": None,
+                    "tip": f"在 {timeout} 秒内未检测到 Toast。提示：先调用 mobile_start_toast_watch，再执行操作，最后调用此工具"
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"❌ 获取 Toast 失败: {e}"
+            }
+    
+    def assert_toast(self, expected_text: str, timeout: float = 5.0, contains: bool = True) -> Dict:
+        """断言 Toast 消息（仅 Android）
+        
+        等待 Toast 出现并验证内容是否符合预期。
+        
+        ⚠️ 推荐用法：先调用 mobile_start_toast_watch，再执行操作，最后调用此工具
+        
+        Args:
+            expected_text: 期望的 Toast 文本
+            timeout: 等待超时时间（秒）
+            contains: True 表示包含匹配，False 表示精确匹配
+        
+        Returns:
+            断言结果
+        """
+        if self._is_ios():
+            return {
+                "success": False,
+                "passed": False,
+                "message": "❌ iOS 不支持 Toast 检测"
+            }
+        
+        try:
+            # 获取 Toast（不 reset，假设之前已经调用过 start_toast_watch）
+            toast_message = self.client.u2.toast.get_message(
+                wait_timeout=timeout,
+                default=None
+            )
+            
+            if toast_message is None:
+                return {
+                    "success": True,
+                    "passed": False,
+                    "expected": expected_text,
+                    "actual": None,
+                    "message": f"❌ 断言失败：未检测到 Toast 消息"
+                }
+            
+            # 匹配检查
+            if contains:
+                passed = expected_text in toast_message
+                match_type = "包含"
+            else:
+                passed = expected_text == toast_message
+                match_type = "精确"
+            
+            if passed:
+                return {
+                    "success": True,
+                    "passed": True,
+                    "expected": expected_text,
+                    "actual": toast_message,
+                    "match_type": match_type,
+                    "message": f"✅ Toast 断言通过：'{toast_message}'"
+                }
+            else:
+                return {
+                    "success": True,
+                    "passed": False,
+                    "expected": expected_text,
+                    "actual": toast_message,
+                    "match_type": match_type,
+                    "message": f"❌ Toast 断言失败：期望 '{expected_text}'，实际 '{toast_message}'"
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "passed": False,
+                "message": f"❌ Toast 断言异常: {e}"
+            }
     
     def assert_text(self, text: str) -> Dict:
         """检查页面是否包含文本（支持精确匹配和包含匹配）"""
@@ -2997,8 +3344,8 @@ class BasicMobileToolsLite:
             f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
             "",
             "定位策略（按优先级）：",
-            "1. ID 定位 - 最稳定，跨设备兼容",
-            "2. 文本定位 - 稳定，跨设备兼容",
+            "1. 文本定位 - 最稳定，跨设备兼容",
+            "2. ID 定位 - 稳定，跨设备兼容",
             "3. 百分比定位 - 跨分辨率兼容（坐标自动转换）",
             f'"""',
             "import time",
@@ -3113,21 +3460,21 @@ class BasicMobileToolsLite:
                 is_coords_ref = ref.startswith('coords_') or ref.startswith('coords:')
                 is_percent_ref = ref.startswith('percent_')
                 
-                # 优先级：ID > 文本 > 百分比 > 坐标（兜底）
-                if ref and (':id/' in ref or ref.startswith('com.')):
-                    # 1️⃣ 使用 resource-id（最稳定）
-                    script_lines.append(f"    # 步骤{step_num}: 点击元素 (ID定位，最稳定)")
-                    script_lines.append(f"    safe_click(d, d(resourceId='{ref}'))")
-                elif ref and not is_coords_ref and not is_percent_ref and ':' not in ref:
-                    # 2️⃣ 使用文本（稳定）- 排除 "text:xxx" 等带冒号的格式
-                    script_lines.append(f"    # 步骤{step_num}: 点击文本 '{ref}' (文本定位)")
+                # 优先级：文本 > ID > 百分比 > 坐标（兜底）
+                if ref and not is_coords_ref and not is_percent_ref and ':' not in ref:
+                    # 1️⃣ 使用文本（最稳定，优先）- 排除 "text:xxx" 等带冒号的格式
+                    script_lines.append(f"    # 步骤{step_num}: 点击文本 '{ref}' (文本定位，最稳定)")
                     script_lines.append(f"    safe_click(d, d(text='{ref}'))")
                 elif ref and ':' in ref and not is_coords_ref and not is_percent_ref:
-                    # 2️⃣-b 使用文本（Android 的 text:xxx 或 description:xxx 格式）
+                    # 1️⃣-b 使用文本（Android 的 text:xxx 或 description:xxx 格式）
                     # 提取冒号后面的实际文本值
                     actual_text = ref.split(':', 1)[1] if ':' in ref else ref
-                    script_lines.append(f"    # 步骤{step_num}: 点击文本 '{actual_text}' (文本定位)")
+                    script_lines.append(f"    # 步骤{step_num}: 点击文本 '{actual_text}' (文本定位，最稳定)")
                     script_lines.append(f"    safe_click(d, d(text='{actual_text}'))")
+                elif ref and (':id/' in ref or ref.startswith('com.')):
+                    # 2️⃣ 使用 resource-id（稳定）
+                    script_lines.append(f"    # 步骤{step_num}: 点击元素 (ID定位)")
+                    script_lines.append(f"    safe_click(d, d(resourceId='{ref}'))")
                 elif has_percent:
                     # 3️⃣ 使用百分比（跨分辨率兼容）
                     x_pct = op['x_percent']
@@ -3193,19 +3540,20 @@ class BasicMobileToolsLite:
                 is_coords_ref = ref.startswith('coords_') or ref.startswith('coords:')
                 is_percent_ref = ref.startswith('percent_')
                 
-                # 优先级：ID > 文本 > 百分比 > 坐标
-                if ref and (':id/' in ref or ref.startswith('com.')):
-                    # 使用 resource-id
-                    script_lines.append(f"    # 步骤{step_num}: 长按元素 (ID定位，最稳定)")
-                    script_lines.append(f"    d(resourceId='{ref}').long_click(duration={duration})")
-                elif ref and not is_coords_ref and not is_percent_ref and ':' not in ref:
-                    # 使用文本
-                    script_lines.append(f"    # 步骤{step_num}: 长按文本 '{ref}' (文本定位)")
+                # 优先级：文本 > ID > 百分比 > 坐标
+                if ref and not is_coords_ref and not is_percent_ref and ':' not in ref:
+                    # 1️⃣ 使用文本（最稳定，优先）
+                    script_lines.append(f"    # 步骤{step_num}: 长按文本 '{ref}' (文本定位，最稳定)")
                     script_lines.append(f"    d(text='{ref}').long_click(duration={duration})")
                 elif ref and ':' in ref and not is_coords_ref and not is_percent_ref:
+                    # 1️⃣-b 使用文本（Android 的 text:xxx 或 description:xxx 格式）
                     actual_text = ref.split(':', 1)[1] if ':' in ref else ref
-                    script_lines.append(f"    # 步骤{step_num}: 长按文本 '{actual_text}' (文本定位)")
+                    script_lines.append(f"    # 步骤{step_num}: 长按文本 '{actual_text}' (文本定位，最稳定)")
                     script_lines.append(f"    d(text='{actual_text}').long_click(duration={duration})")
+                elif ref and (':id/' in ref or ref.startswith('com.')):
+                    # 2️⃣ 使用 resource-id（稳定）
+                    script_lines.append(f"    # 步骤{step_num}: 长按元素 (ID定位)")
+                    script_lines.append(f"    d(resourceId='{ref}').long_click(duration={duration})")
                 elif has_percent:
                     # 使用百分比
                     x_pct = op['x_percent']
@@ -3469,16 +3817,6 @@ class BasicMobileToolsLite:
                         reason = f"文本含'{kw}'"
                         break
                 
-                # resource-id 匹配（如 close_icon, ad_close 等）
-                if resource_id:
-                    res_id_lower = resource_id.lower()
-                    for kw in ['close', 'dismiss', 'skip', 'cancel']:
-                        if kw in res_id_lower:
-                            score += 9
-                            short_id = resource_id.split('/')[-1] if '/' in resource_id else resource_id
-                            reason = f"resource-id='{short_id}'"
-                            break
-                
                 # content-desc 匹配
                 for kw in close_content_desc:
                     if kw.lower() in content_desc.lower():

mobile_mcp/mcp_tools/mcp_server.py

@@ -206,7 +206,7 @@ class MobileMCPServer:
             name="mobile_list_elements",
             description="📋 列出页面所有可交互元素\n\n"
                        "⚠️ 【重要】点击元素前必须先调用此工具！\n"
-                       "如果元素在控件树中存在，使用 click_by_id 或 click_by_text 定位。\n"
+                       "如果元素在控件树中存在，使用 click_by_text 或 click_by_id 定位。\n"
                        "只有当此工具返回空或找不到目标元素时，才使用截图+坐标方式。\n\n"
                        "📌 控件树定位优势：\n"
                        "- 实时检测元素是否存在\n"
@@ -313,14 +313,21 @@ class MobileMCPServer:
         # ==================== 点击操作 ====================
         tools.append(Tool(
             name="mobile_click_by_text",
-            description="👆 通过文本点击元素（推荐）\n\n"
+            description="👆 通过文本点击元素（最推荐）\n\n"
+                       "✅ 最稳定的定位方式，跨设备兼容\n"
                        "✅ 实时检测元素是否存在，元素不存在会报错\n"
                        "✅ 不会误点击到其他位置\n"
-                       "📋 使用前先调用 mobile_list_elements 确认元素文本",
+                       "📋 使用前先调用 mobile_list_elements 确认元素文本\n"
+                       "💡 定位优先级：文本 > ID > 百分比 > 坐标\n\n"
+                       "📍 当页面有多个相同文案时，可使用 position 参数指定位置：\n"
+                       "   - 垂直方向: \"top\"/\"upper\"/\"上\", \"bottom\"/\"lower\"/\"下\", \"middle\"/\"center\"/\"中\"\n"
+                       "   - 水平方向: \"left\"/\"左\", \"right\"/\"右\", \"center\"/\"中\"\n"
+                       "   例如：点击\"底部\"的\"微剧\"tab，使用 position=\"bottom\"",
             inputSchema={
                 "type": "object",
                 "properties": {
-                    "text": {"type": "string", "description": "元素的文本内容（精确匹配）"}
+                    "text": {"type": "string", "description": "元素的文本内容（精确匹配）"},
+                    "position": {"type": "string", "description": "位置信息（可选）。当有多个相同文案时使用，支持：top/bottom/left/right/middle 或 上/下/左/右/中"}
                 },
                 "required": ["text"]
             }
@@ -328,11 +335,12 @@ class MobileMCPServer:
         
         tools.append(Tool(
             name="mobile_click_by_id",
-            description="👆 通过 resource-id 点击元素（最推荐）\n\n"
-                       "✅ 最稳定的定位方式\n"
+            description="👆 通过 resource-id 点击元素（推荐）\n\n"
+                       "✅ 稳定的定位方式\n"
                        "✅ 实时检测元素是否存在，元素不存在会报错\n"
                        "📋 使用前先调用 mobile_list_elements 获取元素 ID\n"
-                       "💡 当有多个相同 ID 的元素时，用 index 指定第几个（从 0 开始）",
+                       "💡 当有多个相同 ID 的元素时，用 index 指定第几个（从 0 开始）\n"
+                       "💡 定位优先级：文本 > ID > 百分比 > 坐标",
             inputSchema={
                 "type": "object",
                 "properties": {
@@ -346,7 +354,7 @@ class MobileMCPServer:
         tools.append(Tool(
             name="mobile_click_at_coords",
             description="👆 点击指定坐标（兜底方案）\n\n"
-                       "⚠️ 【重要】优先使用 mobile_click_by_id 或 mobile_click_by_text！\n"
+                       "⚠️ 【重要】优先使用 mobile_click_by_text 或 mobile_click_by_id！\n"
                        "仅在 mobile_list_elements 无法获取元素时使用此工具。\n\n"
                        "⚠️ 【时序限制】截图分析期间页面可能变化：\n"
                        "- 坐标是基于截图时刻的，点击时页面可能已不同\n"
@@ -447,7 +455,7 @@ class MobileMCPServer:
         
         tools.append(Tool(
             name="mobile_long_press_at_coords",
-            description="👆 长按指定坐标（⚠️ 兜底方案，优先用 ID/文本定位！）\n\n"
+            description="👆 长按指定坐标（⚠️ 兜底方案，优先用文本/ID定位！）\n\n"
                        "🎯 仅在以下场景使用：\n"
                        "- 游戏（Unity/Cocos）无法获取元素\n"
                        "- mobile_list_elements 返回空\n"
@@ -623,7 +631,7 @@ class MobileMCPServer:
 ✅ 返回内容：
 - 坐标 (x, y) 和百分比 (x%, y%)
 - resource-id（如果有）
-- 推荐的点击命令（优先 click_by_id，其次 click_by_text，最后 click_by_percent）
+- 推荐的点击命令（优先 click_by_text，其次 click_by_id，最后 click_by_percent）
 
 💡 使用流程：
 1. 直接调用此工具（无需先截图/列元素）
@@ -663,6 +671,72 @@ class MobileMCPServer:
             }
         ))
         
+        # ==================== Toast 检测工具（仅 Android）====================
+        tools.append(Tool(
+            name="mobile_start_toast_watch",
+            description="""🔔 开始监听 Toast（仅 Android）
+
+⚠️ 【重要】必须在执行操作之前调用！
+
+📋 正确流程（三步走）：
+1️⃣ 调用 mobile_start_toast_watch() 开始监听
+2️⃣ 执行操作（如点击提交按钮）
+3️⃣ 调用 mobile_get_toast() 或 mobile_assert_toast() 获取结果
+
+❌ 错误用法：先点击按钮，再调用此工具（Toast 可能已消失）""",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        ))
+        
+        tools.append(Tool(
+            name="mobile_get_toast",
+            description="""🍞 获取 Toast 消息（仅 Android）
+
+Toast 是 Android 系统级的短暂提示消息，常用于显示操作结果。
+⚠️ Toast 不在控件树中，无法通过 mobile_list_elements 获取。
+
+📋 推荐用法（三步走）：
+1️⃣ mobile_start_toast_watch() - 开始监听
+2️⃣ 执行操作（点击按钮等）
+3️⃣ mobile_get_toast() - 获取 Toast
+
+⏱️ timeout 设置等待时间，默认 5 秒。""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "timeout": {"type": "number", "description": "等待 Toast 出现的超时时间（秒），默认 5"},
+                    "reset_first": {"type": "boolean", "description": "是否先清除旧缓存，默认 False"}
+                },
+                "required": []
+            }
+        ))
+        
+        tools.append(Tool(
+            name="mobile_assert_toast",
+            description="""✅ 断言 Toast 消息（仅 Android）
+
+等待 Toast 出现并验证内容是否符合预期。
+
+📋 推荐用法（三步走）：
+1️⃣ mobile_start_toast_watch() - 开始监听
+2️⃣ 执行操作（点击按钮等）
+3️⃣ mobile_assert_toast(expected_text="成功") - 断言
+
+💡 支持包含匹配（默认）和精确匹配。""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "expected_text": {"type": "string", "description": "期望的 Toast 文本"},
+                    "timeout": {"type": "number", "description": "等待超时时间（秒），默认 5"},
+                    "contains": {"type": "boolean", "description": "True=包含匹配（默认），False=精确匹配"}
+                },
+                "required": ["expected_text"]
+            }
+        ))
+        
         # ==================== pytest 脚本生成 ====================
         tools.append(Tool(
             name="mobile_get_operation_history",
@@ -680,7 +754,7 @@ class MobileMCPServer:
             name="mobile_clear_operation_history",
             description="🗑️ 清空操作历史记录。\n\n"
                        "⚠️ 开始新的测试录制前必须调用！\n"
-                       "📋 录制流程：清空历史 → 执行操作（优先用ID/文本定位）→ 生成脚本",
+                       "📋 录制流程：清空历史 → 执行操作（优先用文本/ID定位）→ 生成脚本",
             inputSchema={"type": "object", "properties": {}, "required": []}
         ))
         
@@ -689,15 +763,15 @@ class MobileMCPServer:
             description="📝 生成 pytest 测试脚本。基于操作历史自动生成。\n\n"
                        "⚠️ 【重要】录制操作时请优先使用稳定定位：\n"
                        "1️⃣ 先调用 mobile_list_elements 获取元素列表\n"
-                       "2️⃣ 优先用 mobile_click_by_id（最稳定，跨设备兼容）\n"
-                       "3️⃣ 其次用 mobile_click_by_text（稳定）\n"
+                       "2️⃣ 优先用 mobile_click_by_text（最稳定，跨设备兼容）\n"
+                       "3️⃣ 其次用 mobile_click_by_id（稳定）\n"
                        "4️⃣ 最后才用坐标点击（会自动转百分比，跨分辨率兼容）\n\n"
                        "使用流程：\n"
                        "1. 清空历史 mobile_clear_operation_history\n"
-                       "2. 执行操作（优先用 ID/文本定位）\n"
+                       "2. 执行操作（优先用文本/ID定位）\n"
                        "3. 调用此工具生成脚本\n"
                        "4. 脚本保存到 tests/ 目录\n\n"
-                       "💡 定位优先级：ID > 文本 > 百分比 > 坐标",
+                       "💡 定位优先级：文本 > ID > 百分比 > 坐标",
             inputSchema={
                 "type": "object",
                 "properties": {
@@ -863,7 +937,10 @@ class MobileMCPServer:
                 return [TextContent(type="text", text=self.format_response(result))]
             
             elif name == "mobile_click_by_text":
-                result = self.tools.click_by_text(arguments["text"])
+                result = self.tools.click_by_text(
+                    arguments["text"],
+                    position=arguments.get("position")
+                )
                 return [TextContent(type="text", text=self.format_response(result))]
             
             elif name == "mobile_click_by_id":
@@ -979,6 +1056,25 @@ class MobileMCPServer:
                 result = self.tools.assert_text(arguments["text"])
                 return [TextContent(type="text", text=self.format_response(result))]
             
+            # Toast 检测（仅 Android）
+            elif name == "mobile_start_toast_watch":
+                result = self.tools.start_toast_watch()
+                return [TextContent(type="text", text=self.format_response(result))]
+            
+            elif name == "mobile_get_toast":
+                timeout = arguments.get("timeout", 5.0)
+                reset_first = arguments.get("reset_first", False)
+                result = self.tools.get_toast(timeout=timeout, reset_first=reset_first)
+                return [TextContent(type="text", text=self.format_response(result))]
+            
+            elif name == "mobile_assert_toast":
+                result = self.tools.assert_toast(
+                    expected_text=arguments["expected_text"],
+                    timeout=arguments.get("timeout", 5.0),
+                    contains=arguments.get("contains", True)
+                )
+                return [TextContent(type="text", text=self.format_response(result))]
+            
             # 脚本生成
             elif name == "mobile_get_operation_history":
                 result = self.tools.get_operation_history(arguments.get("limit"))

{mobile_mcp_ai-2.6.1.dist-info → mobile_mcp_ai-2.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mobile-mcp-ai
-Version: 2.6.1
+Version: 2.6.3
 Summary: 移动端自动化 MCP Server - 支持 Android/iOS，AI 功能可选（基础工具不需要 AI）
 Home-page: https://github.com/test111ddff-hash/mobile-mcp-ai
 Author: douzi

{mobile_mcp_ai-2.6.1.dist-info → mobile_mcp_ai-2.6.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 mobile_mcp/__init__.py,sha256=sQJZTL_sxQFzmcS7jOtS2AHCfUySz40vhX96N6u1qy4,816
 mobile_mcp/config.py,sha256=yaFLAV4bc2wX0GQPtZDo7OYF9E88tXV-av41fQsJwK4,4480
 mobile_mcp/core/__init__.py,sha256=ndMy-cLAIsQDG5op7gM_AIplycqZSZPWEkec1pEhvEY,170
-mobile_mcp/core/basic_tools_lite.py,sha256=zBKruc_z-iYaa5PysC91AAB0eydt_qDFNTT7o5OuUqU,181240
+mobile_mcp/core/basic_tools_lite.py,sha256=_hN1gsno7fa3pQYOIkzquGYwRvgIOLp1h8bYpZnwaNE,194014
 mobile_mcp/core/device_manager.py,sha256=xG5DoeNFs45pl-FTEhEWblqVwxtFK-FmVEGlNL6EqRI,8798
 mobile_mcp/core/dynamic_config.py,sha256=Ja1n1pfb0HspGByqk2_A472mYVniKmGtNEWyjUjmgK8,9811
 mobile_mcp/core/ios_client_wda.py,sha256=Nq9WxevhTWpVpolM-Ymp-b0nUQV3tXLFszmJHbDC4wA,18770
@@ -19,14 +19,14 @@ mobile_mcp/core/utils/logger.py,sha256=XXQAHUwT1jc70pq_tYFmL6f_nKrFlYm3hcgl-5RYR
 mobile_mcp/core/utils/operation_history_manager.py,sha256=gi8S8HJAMqvkUrY7_-kVbko3Xt7c4GAUziEujRd-N-Y,4792
 mobile_mcp/core/utils/smart_wait.py,sha256=N5wKTUYrNWPruBILqrAjpvtso8Z3GRWCfMIR_aZxPLg,8649
 mobile_mcp/mcp_tools/__init__.py,sha256=xkro8Rwqv_55YlVyhh-3DgRFSsLE3h1r31VIb3bpM6E,143
-mobile_mcp/mcp_tools/mcp_server.py,sha256=T6H3jAEfxQzGeQgiTg9ROn2GpgonARrrlFWrzVfxmKU,50135
+mobile_mcp/mcp_tools/mcp_server.py,sha256=x_qvP94FjTeFkk_Tc3rwXtN0Fmp4yblm8b5eoeTOR8w,54744
 mobile_mcp/utils/__init__.py,sha256=8EH0i7UGtx1y_j_GEgdN-cZdWn2sRtZSEOLlNF9HRnY,158
 mobile_mcp/utils/logger.py,sha256=Sqq2Nr0Y4p03erqcrbYKVPCGiFaNGHMcE_JwCkeOfU4,3626
 mobile_mcp/utils/xml_formatter.py,sha256=uwTRb3vLbqhT8O-udzWT7s7LsV-DyDUz2DkofD3hXOE,4556
 mobile_mcp/utils/xml_parser.py,sha256=QhL8CWbdmNDzmBLjtx6mEnjHgMFZzJeHpCL15qfXSpI,3926
-mobile_mcp_ai-2.6.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-mobile_mcp_ai-2.6.1.dist-info/METADATA,sha256=oa_vxBNab-rKPX3yXVbetv6Joc-jjdh_XxgYA7vbEfY,10495
-mobile_mcp_ai-2.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mobile_mcp_ai-2.6.1.dist-info/entry_points.txt,sha256=KB_FglozgPHBprSM1vFbIzGyheFuHFmGanscRdMJ_8A,68
-mobile_mcp_ai-2.6.1.dist-info/top_level.txt,sha256=lLm6YpbTv855Lbh8BIA0rPxhybIrvYUzMEk9OErHT94,11
-mobile_mcp_ai-2.6.1.dist-info/RECORD,,
+mobile_mcp_ai-2.6.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+mobile_mcp_ai-2.6.3.dist-info/METADATA,sha256=j4pJ-FkSVtIy9YEW4HbmVa0u-WSc5LqKqUj7_Sd27cU,10495
+mobile_mcp_ai-2.6.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mobile_mcp_ai-2.6.3.dist-info/entry_points.txt,sha256=KB_FglozgPHBprSM1vFbIzGyheFuHFmGanscRdMJ_8A,68
+mobile_mcp_ai-2.6.3.dist-info/top_level.txt,sha256=lLm6YpbTv855Lbh8BIA0rPxhybIrvYUzMEk9OErHT94,11
+mobile_mcp_ai-2.6.3.dist-info/RECORD,,