mobile-mcp-ai 2.4.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

mobile_mcp/core/basic_tools_lite.py

@@ -616,9 +616,8 @@ class BasicMobileToolsLite:
                     'desc': elem['desc']
                 })
             
-            # 第3.5步：检测弹窗并标注可能的 X 按钮位置（如果 X 不在元素树中）
+            # 第3.5步：检测弹窗区域（用于标注）
             popup_bounds = None
-            popup_close_hints = []
             
             if not self._is_ios():
                 try:
@@ -650,69 +649,24 @@ class BasicMobileToolsLite:
                             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)
                     
-                    # 如果检测到弹窗，始终添加 X 按钮位置提示
+                    # 如果检测到弹窗，标注弹窗边界（不再猜测X按钮位置）
                     if popup_bounds:
                         px1, py1, px2, py2 = popup_bounds
-                        popup_width = px2 - px1
-                        popup_height = py2 - py1
-                        
-                        # 计算多个可能的 X 按钮位置（基于弹窗尺寸动态计算）
-                        # 【优化】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%，紧贴顶边界内侧
-                        
-                        close_positions = [
-                            # 【最高优先级】弹窗内紧贴顶部边界（大多数X按钮在这里）
-                            {"name": "右上角", "x": px2 - offset_x, "y": py1 + offset_y_near},
-                            # 弹窗边界上方（浮动X按钮）
-                            {"name": "右上浮", "x": px2 - offset_x, "y": py1 - offset_y_above},
-                            # 弹窗正下方中间（底部关闭按钮）
-                            {"name": "正下方", "x": (px1 + px2) // 2, "y": py2 + max(50, int(popup_height * 0.04))},
-                        ]
-                        
-                        # 用黄色/金色标注这些可能位置（始终显示）
-                        hint_color = (255, 200, 0)  # 金黄色
-                        next_index = len(som_elements) + 1
                         
-                        for pos in close_positions:
-                            hx, hy = pos["x"], pos["y"]
-                            if 0 <= hx <= img_width and 0 <= hy <= img_height:
-                                # 画圆圈
-                                draw.ellipse([hx-18, hy-18, hx+18, hy+18], 
-                                           outline=hint_color + (255,), width=3)
-                                # 画编号背景
-                                draw.rectangle([hx-10, hy-22, hx+10, hy-6], 
-                                             fill=hint_color + (220,))
-                                # 画编号
-                                draw.text((hx-6, hy-20), str(next_index), 
-                                        fill=(0, 0, 0), font=font_small)
-                                # 标注 "X?"
-                                draw.text((hx-8, hy-5), "X?", fill=hint_color, font=font_small)
-                                
-                                popup_close_hints.append({
-                                    'index': next_index,
-                                    'center': (hx, hy),
-                                    'bounds': f"[{hx-20},{hy-20}][{hx+20},{hy+20}]",
-                                    'desc': f"X?{pos['name']}",
-                                    'is_hint': True
-                                })
-                                next_index += 1
+                        # 只画弹窗边框（蓝色），不再猜测X按钮位置
+                        draw.rectangle([px1, py1, px2, py2], outline=(0, 150, 255, 180), width=3)
                         
-                        # 画弹窗边框（蓝色）
-                        draw.rectangle([px1, py1, px2, py2], outline=(0, 150, 255, 180), width=2)
+                        # 在弹窗边框上标注提示文字
+                        try:
+                            draw.text((px1+5, py1-25), "弹窗区域", fill=(0, 150, 255), font=font_small)
+                        except:
+                            pass
                 
                 except Exception as e:
                     pass  # 弹窗检测失败不影响主功能
             
-            # 合并元素列表
-            all_som_elements = som_elements + popup_close_hints
-            
             # 保存到实例变量，供 click_by_som 使用
-            self._som_elements = all_som_elements
+            self._som_elements = som_elements
             
             # 第4步：保存标注后的截图
             filename = f"screenshot_{platform}_som_{timestamp}.jpg"
@@ -740,12 +694,10 @@ class BasicMobileToolsLite:
             
             # 构建弹窗提示文字
             hints_text = ""
-            if popup_close_hints:
-                hints_text = "\n🎯 检测到弹窗，可能的 X 按钮位置（黄色圆圈）：\n"
-                hints_text += "\n".join([
-                    f"  [{h['index']}] {h['desc']} → ({h['center'][0]}, {h['center'][1]})"
-                    for h in popup_close_hints
-                ])
+            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,
@@ -754,15 +706,16 @@ class BasicMobileToolsLite:
                 "screen_height": screen_height,
                 "image_width": img_width,
                 "image_height": img_height,
-                "element_count": len(all_som_elements),
-                "elements": all_som_elements,
+                "element_count": len(som_elements),
+                "elements": som_elements,
                 "popup_detected": popup_bounds is not None,
                 "popup_bounds": f"[{popup_bounds[0]},{popup_bounds[1]}][{popup_bounds[2]},{popup_bounds[3]}]" if popup_bounds else None,
-                "close_hints": popup_close_hints,
                 "message": f"📸 SoM 截图已保存: {final_path}\n"
-                          f"🏷️ 已标注 {len(all_som_elements)} 个元素（{len(som_elements)} 个可点击 + {len(popup_close_hints)} 个X按钮提示）\n"
+                          f"🏷️ 已标注 {len(som_elements)} 个可点击元素\n"
                           f"📋 元素列表：\n{elements_text}{hints_text}\n\n"
-                          f"💡 使用方法：看图后调用 mobile_click_by_som(编号) 点击对应元素"
+                          f"💡 使用方法：\n"
+                          f"   - 点击标注元素：mobile_click_by_som(编号)\n"
+                          f"   - 点击任意位置：mobile_click_by_percent(x%, y%)"
             }
             
         except ImportError:
@@ -2703,3 +2656,538 @@ class BasicMobileToolsLite:
             "preview": script[:500] + "..."
         }
 
+    # ========== 模板匹配功能 ==========
+    
+    def template_match_close(self, screenshot_path: Optional[str] = None, threshold: float = 0.75) -> Dict:
+        """使用模板匹配查找关闭按钮
+        
+        基于 OpenCV 模板匹配，从预设的X号模板库中查找匹配项。
+        比 AI 视觉识别更精准、更快速。
+        
+        Args:
+            screenshot_path: 截图路径（可选，不提供则自动截图）
+            threshold: 匹配阈值 0-1，越高越严格，默认0.75
+            
+        Returns:
+            匹配结果，包含坐标和点击命令
+        """
+        try:
+            from .template_matcher import TemplateMatcher
+            
+            # 如果没有提供截图，先截图
+            if screenshot_path is None:
+                screenshot_result = self.take_screenshot(description="模板匹配", compress=False)
+                screenshot_path = screenshot_result.get("screenshot_path")
+                if not screenshot_path:
+                    return {"success": False, "error": "截图失败"}
+            
+            matcher = TemplateMatcher()
+            result = matcher.find_close_buttons(screenshot_path, threshold)
+            
+            return result
+            
+        except ImportError:
+            return {
+                "success": False,
+                "error": "需要安装 opencv-python: pip install opencv-python"
+            }
+        except Exception as e:
+            return {"success": False, "error": f"模板匹配失败: {e}"}
+    
+    def template_click_close(self, threshold: float = 0.75) -> Dict:
+        """模板匹配并点击关闭按钮（一步到位）
+        
+        截图 -> 模板匹配 -> 点击最佳匹配位置
+        
+        Args:
+            threshold: 匹配阈值 0-1
+            
+        Returns:
+            操作结果
+        """
+        try:
+            # 先截图并匹配
+            match_result = self.template_match_close(threshold=threshold)
+            
+            if not match_result.get("success"):
+                return match_result
+            
+            # 获取最佳匹配的百分比坐标
+            best = match_result.get("best_match", {})
+            x_percent = best.get("percent", {}).get("x")
+            y_percent = best.get("percent", {}).get("y")
+            
+            if x_percent is None or y_percent is None:
+                return {"success": False, "error": "无法获取匹配坐标"}
+            
+            # 点击
+            click_result = self.click_by_percent(x_percent, y_percent)
+            
+            return {
+                "success": True,
+                "message": f"✅ 模板匹配并点击成功",
+                "matched_template": best.get("template"),
+                "confidence": best.get("confidence"),
+                "clicked_position": f"({x_percent}%, {y_percent}%)",
+                "click_result": click_result
+            }
+            
+        except Exception as e:
+            return {"success": False, "error": f"模板点击失败: {e}"}
+    
+    def template_add(self, screenshot_path: str, x: int, y: int, 
+                     width: int, height: int, template_name: str) -> Dict:
+        """从截图中裁剪并添加新模板
+        
+        当遇到新样式的X号时，用此方法添加到模板库。
+        
+        Args:
+            screenshot_path: 截图路径
+            x, y: 裁剪区域左上角坐标
+            width, height: 裁剪区域大小
+            template_name: 模板名称（如 x_circle_gray）
+            
+        Returns:
+            结果
+        """
+        try:
+            from .template_matcher import TemplateMatcher
+            
+            matcher = TemplateMatcher()
+            return matcher.crop_and_add_template(
+                screenshot_path, x, y, width, height, template_name
+            )
+        except ImportError:
+            return {"success": False, "error": "需要安装 opencv-python"}
+        except Exception as e:
+            return {"success": False, "error": f"添加模板失败: {e}"}
+    
+    def template_list(self) -> Dict:
+        """列出所有关闭按钮模板"""
+        try:
+            from .template_matcher import TemplateMatcher
+            
+            matcher = TemplateMatcher()
+            return matcher.list_templates()
+        except ImportError:
+            return {"success": False, "error": "需要安装 opencv-python"}
+        except Exception as e:
+            return {"success": False, "error": f"列出模板失败: {e}"}
+    
+    def template_delete(self, template_name: str) -> Dict:
+        """删除指定模板"""
+        try:
+            from .template_matcher import TemplateMatcher
+            
+            matcher = TemplateMatcher()
+            return matcher.delete_template(template_name)
+        except ImportError:
+            return {"success": False, "error": "需要安装 opencv-python"}
+        except Exception as e:
+            return {"success": False, "error": f"删除模板失败: {e}"}
+    
+    def close_ad_popup(self, auto_learn: bool = True) -> Dict:
+        """智能关闭广告弹窗（专用于广告场景）
+        
+        按优先级尝试：
+        1. 控件树查找关闭按钮（最可靠）
+        2. 模板匹配（需要积累模板库）
+        3. 返回视觉信息供 AI 分析（如果前两步失败）
+        
+        自动学习：
+        - 点击成功后，检查这个 X 是否已在模板库
+        - 如果是新样式，自动裁剪并添加到模板库
+        
+        Args:
+            auto_learn: 是否自动学习新模板（点击成功后检查并保存）
+            
+        Returns:
+            结果字典
+        """
+        import time
+        import re
+        
+        result = {
+            "success": False,
+            "method": None,
+            "message": "",
+            "learned_template": None
+        }
+        
+        if self._is_ios():
+            return {"success": False, "error": "iOS 暂不支持此功能"}
+        
+        try:
+            import xml.etree.ElementTree as ET
+            
+            # ========== 第1步：控件树查找关闭按钮 ==========
+            xml_string = self.client.u2.dump_hierarchy()
+            root = ET.fromstring(xml_string)
+            
+            # 关闭按钮的常见特征
+            close_keywords = ['关闭', '跳过', '×', 'X', 'x', 'close', 'skip', '取消']
+            close_content_desc = ['关闭', '跳过', 'close', 'skip', 'dismiss']
+            
+            close_candidates = []
+            
+            for elem in root.iter():
+                text = elem.attrib.get('text', '').strip()
+                content_desc = elem.attrib.get('content-desc', '').strip()
+                clickable = elem.attrib.get('clickable', 'false') == 'true'
+                bounds_str = elem.attrib.get('bounds', '')
+                resource_id = elem.attrib.get('resource-id', '')
+                
+                if not bounds_str:
+                    continue
+                
+                match = re.match(r'\[(\d+),(\d+)\]\[(\d+),(\d+)\]', bounds_str)
+                if not match:
+                    continue
+                
+                x1, y1, x2, y2 = map(int, match.groups())
+                width = x2 - x1
+                height = y2 - y1
+                cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
+                
+                score = 0
+                reason = ""
+                
+                # 文本匹配
+                for kw in close_keywords:
+                    if kw in text:
+                        score += 10
+                        reason = f"文本含'{kw}'"
+                        break
+                
+                # content-desc 匹配
+                for kw in close_content_desc:
+                    if kw.lower() in content_desc.lower():
+                        score += 8
+                        reason = f"描述含'{kw}'"
+                        break
+                
+                # 小尺寸可点击元素（可能是 X 按钮）
+                if clickable and 30 < width < 200 and 30 < height < 200:
+                    screen_width = self.client.u2.info.get('displayWidth', 1440)
+                    screen_height = self.client.u2.info.get('displayHeight', 3200)
+                    
+                    # 在屏幕右半边上半部分，很可能是 X
+                    if cx > screen_width * 0.6 and cy < screen_height * 0.5:
+                        score += 5
+                        reason = reason or "右上角小按钮"
+                    # 在屏幕上半部分的小按钮，也可能是 X
+                    elif cy < screen_height * 0.4:
+                        score += 2
+                        reason = reason or "上部小按钮"
+                
+                # 只要是可点击的小按钮都考虑（即使没有文本）
+                if score > 0 or (clickable and 30 < width < 150 and 30 < height < 150):
+                    if not reason and clickable:
+                        reason = "可点击小按钮"
+                        score = max(score, 1)  # 确保有分数
+                    close_candidates.append({
+                        'score': score,
+                        'reason': reason,
+                        'bounds': (x1, y1, x2, y2),
+                        'center': (cx, cy),
+                        'resource_id': resource_id,
+                        'text': text
+                    })
+            
+            # 按分数排序
+            close_candidates.sort(key=lambda x: x['score'], reverse=True)
+            
+            if close_candidates:
+                best = close_candidates[0]
+                cx, cy = best['center']
+                bounds = best['bounds']
+                
+                # 点击前截图（用于自动学习）
+                pre_screenshot = None
+                if auto_learn:
+                    pre_result = self.take_screenshot(description="关闭前", compress=False)
+                    pre_screenshot = pre_result.get("screenshot_path")
+                
+                # 点击
+                self.click_at_coords(cx, cy)
+                time.sleep(0.5)
+                
+                result["success"] = True
+                result["method"] = "控件树"
+                result["message"] = f"✅ 通过控件树找到关闭按钮并点击\n" \
+                                   f"   位置: ({cx}, {cy})\n" \
+                                   f"   原因: {best['reason']}"
+                
+                # 自动学习：检查这个 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步：模板匹配 ==========
+            screenshot_path = None
+            try:
+                from .template_matcher import TemplateMatcher
+                
+                # 截图用于模板匹配
+                screenshot_result = self.take_screenshot(description="模板匹配", compress=False)
+                screenshot_path = screenshot_result.get("screenshot_path")
+                
+                if screenshot_path:
+                    matcher = TemplateMatcher()
+                    match_result = matcher.find_close_buttons(screenshot_path, threshold=0.75)
+                    
+                    # 直接使用最佳匹配（已按置信度排序）
+                    if match_result.get("success") and match_result.get("best_match"):
+                        best = match_result["best_match"]
+                        x_pct = best["percent"]["x"]
+                        y_pct = best["percent"]["y"]
+                        
+                        # 点击
+                        self.click_by_percent(x_pct, y_pct)
+                        time.sleep(0.5)
+                        
+                        result["success"] = True
+                        result["method"] = "模板匹配"
+                        result["message"] = f"✅ 通过模板匹配找到关闭按钮并点击\n" \
+                                           f"   模板: {best.get('template', 'unknown')}\n" \
+                                           f"   置信度: {best.get('confidence', 'N/A')}%\n" \
+                                           f"   位置: ({x_pct:.1f}%, {y_pct:.1f}%)"
+                        return result
+                    
+            except ImportError:
+                pass  # OpenCV 未安装，跳过模板匹配
+            except Exception:
+                pass  # 模板匹配失败，继续下一步
+            
+            # ========== 第3步：返回截图供 AI 分析 ==========
+            if not screenshot_path:
+                screenshot_result = self.take_screenshot(description="需要AI分析", compress=True)
+            
+            result["success"] = False
+            result["method"] = None
+            result["message"] = "❌ 控件树和模板匹配都未找到关闭按钮\n" \
+                               "📸 已截图，请 AI 分析图片中的 X 按钮位置\n" \
+                               "💡 找到后使用 mobile_click_by_percent(x%, y%) 点击"
+            result["screenshot"] = screenshot_result if not screenshot_path else {"screenshot_path": screenshot_path}
+            result["need_ai_analysis"] = True
+            
+            return result
+            
+        except Exception as e:
+            return {"success": False, "error": f"关闭弹窗失败: {e}"}
+    
+    def _detect_popup_region(self, root) -> tuple:
+        """从控件树中检测弹窗区域
+        
+        Args:
+            root: 控件树根元素
+            
+        Returns:
+            弹窗边界 (x1, y1, x2, y2) 或 None
+        """
+        import re
+        
+        screen_width = self.client.u2.info.get('displayWidth', 1440)
+        screen_height = self.client.u2.info.get('displayHeight', 3200)
+        
+        popup_candidates = []
+        
+        for elem in 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
+            
+            # 弹窗特征：
+            # 1. 不是全屏
+            # 2. 在屏幕中央
+            # 3. 有一定大小
+            is_fullscreen = (width >= screen_width * 0.95 and height >= screen_height * 0.9)
+            is_centered = (x1 > screen_width * 0.05 and x2 < screen_width * 0.95)
+            is_reasonable_size = (width > 200 and height > 200 and 
+                                  width < screen_width * 0.95 and 
+                                  height < screen_height * 0.8)
+            
+            if not is_fullscreen and is_centered and is_reasonable_size:
+                # 计算"弹窗感"分数
+                area = width * height
+                center_x = (x1 + x2) / 2
+                center_y = (y1 + y2) / 2
+                center_dist = abs(center_x - screen_width/2) + abs(center_y - screen_height/2)
+                
+                score = area / 1000 - center_dist / 10
+                popup_candidates.append({
+                    'bounds': (x1, y1, x2, y2),
+                    'score': score
+                })
+        
+        if popup_candidates:
+            # 返回分数最高的弹窗
+            popup_candidates.sort(key=lambda x: x['score'], reverse=True)
+            return popup_candidates[0]['bounds']
+        
+        return None
+
+    def _auto_learn_template(self, screenshot_path: str, bounds: tuple, threshold: float = 0.6) -> str:
+        """自动学习：检查 X 按钮是否已在模板库，不在就添加
+        
+        Args:
+            screenshot_path: 截图路径
+            bounds: X 按钮的边界 (x1, y1, x2, y2)
+            threshold: 判断是否已存在的阈值（高于此值认为已存在）
+            
+        Returns:
+            新模板名称，如果是新模板的话；已存在或失败返回 None
+        """
+        try:
+            from .template_matcher import TemplateMatcher
+            from PIL import Image
+            import time
+            
+            x1, y1, x2, y2 = bounds
+            cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
+            width = x2 - x1
+            height = y2 - y1
+            
+            # 扩展一点边界，确保裁剪完整
+            padding = max(10, int(max(width, height) * 0.2))
+            
+            # 打开截图
+            img = Image.open(screenshot_path)
+            
+            # 裁剪 X 按钮区域
+            crop_x1 = max(0, x1 - padding)
+            crop_y1 = max(0, y1 - padding)
+            crop_x2 = min(img.width, x2 + padding)
+            crop_y2 = min(img.height, y2 + padding)
+            
+            cropped = img.crop((crop_x1, crop_y1, crop_x2, crop_y2))
+            
+            # 保存临时文件用于匹配检查
+            temp_path = self.screenshot_dir / "temp_new_x.png"
+            cropped.save(str(temp_path))
+            
+            # 检查是否已在模板库中（用模板匹配检测相似度）
+            matcher = TemplateMatcher()
+            
+            import cv2
+            new_img = cv2.imread(str(temp_path), cv2.IMREAD_GRAYSCALE)
+            if new_img is None:
+                return None
+            
+            is_new = True
+            for template_file in matcher.template_dir.glob("*.png"):
+                template = cv2.imread(str(template_file), cv2.IMREAD_GRAYSCALE)
+                if template is None:
+                    continue
+                
+                # 将两个图都调整到合适大小，然后用小模板在大图中搜索
+                # 这样比较更接近实际匹配场景
+                
+                # 新图作为搜索区域（稍大一点）
+                new_resized = cv2.resize(new_img, (100, 100))
+                # 模板调整到较小尺寸
+                template_resized = cv2.resize(template, (60, 60))
+                
+                # 在新图中搜索模板
+                result = cv2.matchTemplate(new_resized, template_resized, cv2.TM_CCOEFF_NORMED)
+                _, max_val, _, _ = cv2.minMaxLoc(result)
+                
+                if max_val >= threshold:
+                    is_new = False
+                    break
+            
+            # 清理临时文件
+            if temp_path.exists():
+                temp_path.unlink()
+            
+            if is_new:
+                # 生成唯一模板名
+                timestamp = time.strftime("%m%d_%H%M%S")
+                template_name = f"auto_x_{timestamp}.png"
+                template_path = matcher.template_dir / template_name
+                
+                # 保存新模板
+                cropped.save(str(template_path))
+                
+                return template_name
+            else:
+                return None  # 已存在类似模板
+                
+        except Exception as e:
+            return None  # 学习失败，不影响主流程
+    
+    def template_add_by_percent(self, x_percent: float, y_percent: float, 
+                                 size: int, template_name: str) -> Dict:
+        """通过百分比坐标添加模板（更方便！）
+        
+        自动截图 → 根据百分比位置裁剪 → 保存为模板
+        
+        Args:
+            x_percent: X号中心的水平百分比 (0-100)
+            y_percent: X号中心的垂直百分比 (0-100)
+            size: 裁剪区域大小（正方形边长，像素）
+            template_name: 模板名称
+            
+        Returns:
+            结果
+        """
+        try:
+            from .template_matcher import TemplateMatcher
+            from PIL import Image
+            
+            # 先截图（不带 SoM 标注的干净截图）
+            screenshot_result = self.take_screenshot(description="添加模板", compress=False)
+            screenshot_path = screenshot_result.get("screenshot_path")
+            
+            if not screenshot_path:
+                return {"success": False, "error": "截图失败"}
+            
+            # 读取截图获取尺寸
+            img = Image.open(screenshot_path)
+            img_w, img_h = img.size
+            
+            # 计算中心点像素坐标
+            cx = int(img_w * x_percent / 100)
+            cy = int(img_h * y_percent / 100)
+            
+            # 计算裁剪区域
+            half = size // 2
+            x1 = max(0, cx - half)
+            y1 = max(0, cy - half)
+            x2 = min(img_w, cx + half)
+            y2 = min(img_h, cy + half)
+            
+            # 裁剪并保存
+            cropped = img.crop((x1, y1, x2, y2))
+            
+            matcher = TemplateMatcher()
+            output_path = matcher.template_dir / f"{template_name}.png"
+            cropped.save(str(output_path))
+            
+            return {
+                "success": True,
+                "message": f"✅ 模板已保存: {template_name}",
+                "template_path": str(output_path),
+                "center_percent": f"({x_percent}%, {y_percent}%)",
+                "center_pixel": f"({cx}, {cy})",
+                "crop_region": f"({x1},{y1}) - ({x2},{y2})",
+                "size": f"{cropped.size[0]}x{cropped.size[1]}"
+            }
+            
+        except ImportError as e:
+            return {"success": False, "error": f"需要安装依赖: {e}"}
+        except Exception as e:
+            return {"success": False, "error": f"添加模板失败: {e}"}
+

mobile_mcp/core/ios_client_wda.py

@@ -564,5 +564,6 @@ class IOSClientWDA:
 
 
 
+
 
 

mobile_mcp/core/template_matcher.py

@@ -0,0 +1,418 @@
+"""
+OpenCV 模板匹配器 - 用于精确识别广告弹窗X号
+核心优势：
+1. 收集常见X号样式建立模板库
+2. 多尺度匹配解决分辨率差异
+3. 返回精确坐标，点击准确率高
+"""
+
+import os
+import cv2
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+from pathlib import Path
+
+
+class TemplateMatcher:
+    """OpenCV 模板匹配器"""
+    
+    def __init__(self, template_dir: Optional[str] = None):
+        """
+        初始化模板匹配器
+        
+        Args:
+            template_dir: 模板目录路径，默认为 templates/close_buttons/
+        """
+        if template_dir is None:
+            # 默认模板目录
+            base_dir = Path(__file__).parent.parent
+            self.template_dir = base_dir / "templates" / "close_buttons"
+        else:
+            self.template_dir = Path(template_dir)
+        
+        # 确保目录存在
+        self.template_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 多尺度匹配的缩放范围
+        self.scales = [0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.5, 1.8, 2.0]
+        
+        # 匹配阈值（越高越严格）
+        self.match_threshold = 0.75
+        
+        # 缓存加载的模板
+        self._template_cache: Dict[str, np.ndarray] = {}
+    
+    def load_templates(self) -> List[Tuple[str, np.ndarray]]:
+        """
+        加载所有模板图片
+        
+        Returns:
+            List of (template_name, template_image) tuples
+        """
+        templates = []
+        
+        if not self.template_dir.exists():
+            return templates
+        
+        # 支持的图片格式
+        extensions = ['.png', '.jpg', '.jpeg', '.bmp']
+        
+        for file in self.template_dir.iterdir():
+            if file.suffix.lower() in extensions:
+                template_name = file.stem
+                
+                # 使用缓存
+                if template_name in self._template_cache:
+                    templates.append((template_name, self._template_cache[template_name]))
+                    continue
+                
+                # 读取模板（支持透明通道）
+                template = cv2.imread(str(file), cv2.IMREAD_UNCHANGED)
+                if template is not None:
+                    self._template_cache[template_name] = template
+                    templates.append((template_name, template))
+        
+        return templates
+    
+    def match_single_template(
+        self, 
+        screenshot: np.ndarray, 
+        template: np.ndarray,
+        threshold: Optional[float] = None
+    ) -> List[Dict]:
+        """
+        单模板多尺度匹配
+        
+        Args:
+            screenshot: 截图 (BGR格式)
+            template: 模板图片
+            threshold: 匹配阈值
+            
+        Returns:
+            匹配结果列表
+        """
+        if threshold is None:
+            threshold = self.match_threshold
+        
+        results = []
+        
+        # 转灰度图
+        if len(screenshot.shape) == 3:
+            gray_screen = cv2.cvtColor(screenshot, cv2.COLOR_BGR2GRAY)
+        else:
+            gray_screen = screenshot
+        
+        # 处理模板（可能有透明通道）
+        # 注意：不使用 mask，因为 TM_CCOEFF_NORMED + mask 可能返回 INF
+        if len(template.shape) == 3:
+            if template.shape[2] == 4:  # BGRA
+                template_gray = cv2.cvtColor(template[:, :, :3], cv2.COLOR_BGR2GRAY)
+            else:  # BGR
+                template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
+        else:
+            template_gray = template
+        
+        template_h, template_w = template_gray.shape[:2]
+        
+        # 多尺度匹配
+        for scale in self.scales:
+            # 缩放模板
+            new_w = int(template_w * scale)
+            new_h = int(template_h * scale)
+            
+            # 跳过太小或太大的模板
+            if new_w < 10 or new_h < 10:
+                continue
+            if new_w > gray_screen.shape[1] or new_h > gray_screen.shape[0]:
+                continue
+            
+            resized_template = cv2.resize(template_gray, (new_w, new_h))
+            
+            # 模板匹配
+            try:
+                result = cv2.matchTemplate(
+                    gray_screen, resized_template, 
+                    cv2.TM_CCOEFF_NORMED
+                )
+            except cv2.error:
+                continue
+            
+            # 跳过包含 INF/NAN 的结果
+            if np.isinf(result).any() or np.isnan(result).any():
+                continue
+            
+            # 找所有超过阈值的匹配点
+            locations = np.where(result >= threshold)
+            
+            for pt in zip(*locations[::-1]):  # (x, y)
+                confidence = float(result[pt[1], pt[0]])
+                center_x = int(pt[0] + new_w // 2)
+                center_y = int(pt[1] + new_h // 2)
+                
+                results.append({
+                    'x': center_x,
+                    'y': center_y,
+                    'width': int(new_w),
+                    'height': int(new_h),
+                    'scale': float(scale),
+                    'confidence': confidence,
+                    'top_left': (int(pt[0]), int(pt[1])),
+                    'bottom_right': (int(pt[0] + new_w), int(pt[1] + new_h))
+                })
+        
+        # 非极大值抑制（去除重叠的检测框）
+        results = self._non_max_suppression(results)
+        
+        return results
+    
+    def _non_max_suppression(self, results: List[Dict], overlap_thresh: float = 0.3) -> List[Dict]:
+        """
+        非极大值抑制，去除重叠的检测框
+        """
+        if len(results) == 0:
+            return []
+        
+        # 按置信度排序
+        results = sorted(results, key=lambda x: x['confidence'], reverse=True)
+        
+        kept = []
+        for result in results:
+            is_duplicate = False
+            for kept_result in kept:
+                # 计算中心点距离
+                dx = abs(result['x'] - kept_result['x'])
+                dy = abs(result['y'] - kept_result['y'])
+                
+                # 如果中心点距离小于框的一半大小，认为是重复
+                avg_size = (result['width'] + result['height'] + 
+                           kept_result['width'] + kept_result['height']) / 4
+                
+                if dx < avg_size * overlap_thresh and dy < avg_size * overlap_thresh:
+                    is_duplicate = True
+                    break
+            
+            if not is_duplicate:
+                kept.append(result)
+        
+        return kept
+    
+    def find_close_buttons(
+        self, 
+        screenshot_path: str,
+        threshold: Optional[float] = None
+    ) -> Dict:
+        """
+        在截图中查找所有关闭按钮
+        
+        Args:
+            screenshot_path: 截图路径
+            threshold: 匹配阈值 (0-1)
+            
+        Returns:
+            匹配结果
+        """
+        # 读取截图
+        screenshot = cv2.imread(screenshot_path)
+        if screenshot is None:
+            return {
+                "success": False,
+                "error": f"无法读取截图: {screenshot_path}"
+            }
+        
+        img_height, img_width = screenshot.shape[:2]
+        
+        # 加载模板
+        templates = self.load_templates()
+        if not templates:
+            return {
+                "success": False,
+                "error": "没有找到模板图片，请在 templates/close_buttons/ 目录添加X号模板",
+                "template_dir": str(self.template_dir),
+                "tip": "添加常见X号截图到模板目录，命名如 x_circle.png, x_white.png 等"
+            }
+        
+        all_matches = []
+        
+        for template_name, template in templates:
+            matches = self.match_single_template(screenshot, template, threshold)
+            for match in matches:
+                match['template'] = template_name
+                all_matches.append(match)
+        
+        # 按置信度排序
+        all_matches = sorted(all_matches, key=lambda x: x['confidence'], reverse=True)
+        
+        # 再次 NMS 去除不同模板的重复检测
+        all_matches = self._non_max_suppression(all_matches)
+        
+        if not all_matches:
+            return {
+                "success": False,
+                "message": "未找到匹配的关闭按钮",
+                "templates_used": [t[0] for t in templates],
+                "threshold": threshold or self.match_threshold,
+                "tip": "可能需要添加新的X号模板，或降低匹配阈值"
+            }
+        
+        # 计算百分比坐标
+        for match in all_matches:
+            match['x_percent'] = round(match['x'] / img_width * 100, 1)
+            match['y_percent'] = round(match['y'] / img_height * 100, 1)
+        
+        best = all_matches[0]
+        
+        return {
+            "success": True,
+            "message": f"✅ 找到 {len(all_matches)} 个关闭按钮",
+            "best_match": {
+                "template": best['template'],
+                "center": {"x": int(best['x']), "y": int(best['y'])},
+                "percent": {"x": float(best['x_percent']), "y": float(best['y_percent'])},
+                "size": f"{best['width']}x{best['height']}",
+                "confidence": float(round(best['confidence'] * 100, 1))
+            },
+            "click_command": f"mobile_click_by_percent({best['x_percent']}, {best['y_percent']})",
+            "all_matches": [
+                {
+                    "template": m['template'],
+                    "percent": f"({m['x_percent']}%, {m['y_percent']}%)",
+                    "confidence": f"{m['confidence']*100:.1f}%"
+                }
+                for m in all_matches[:5]  # 最多返回5个
+            ],
+            "image_size": {"width": img_width, "height": img_height}
+        }
+    
+    def add_template(self, image_path: str, template_name: str) -> Dict:
+        """
+        添加新模板到模板库
+        
+        Args:
+            image_path: 图片路径（可以是截图的一部分）
+            template_name: 模板名称
+            
+        Returns:
+            结果
+        """
+        # 读取图片
+        img = cv2.imread(image_path)
+        if img is None:
+            return {"success": False, "error": f"无法读取图片: {image_path}"}
+        
+        # 保存到模板目录
+        output_path = self.template_dir / f"{template_name}.png"
+        cv2.imwrite(str(output_path), img)
+        
+        # 清除缓存
+        self._template_cache.clear()
+        
+        return {
+            "success": True,
+            "message": f"✅ 模板已保存: {output_path}",
+            "template_name": template_name
+        }
+    
+    def crop_and_add_template(
+        self, 
+        screenshot_path: str, 
+        x: int, y: int, 
+        width: int, height: int,
+        template_name: str
+    ) -> Dict:
+        """
+        从截图中裁剪区域并添加为模板
+        
+        Args:
+            screenshot_path: 截图路径
+            x, y: 左上角坐标
+            width, height: 裁剪尺寸
+            template_name: 模板名称
+            
+        Returns:
+            结果
+        """
+        img = cv2.imread(screenshot_path)
+        if img is None:
+            return {"success": False, "error": f"无法读取截图: {screenshot_path}"}
+        
+        # 裁剪
+        cropped = img[y:y+height, x:x+width]
+        
+        if cropped.size == 0:
+            return {"success": False, "error": "裁剪区域无效"}
+        
+        # 保存
+        output_path = self.template_dir / f"{template_name}.png"
+        cv2.imwrite(str(output_path), cropped)
+        
+        # 清除缓存
+        self._template_cache.clear()
+        
+        return {
+            "success": True,
+            "message": f"✅ 模板已保存: {output_path}",
+            "template_name": template_name,
+            "size": f"{width}x{height}"
+        }
+    
+    def list_templates(self) -> Dict:
+        """列出所有模板"""
+        templates = self.load_templates()
+        
+        if not templates:
+            return {
+                "success": True,
+                "templates": [],
+                "message": "模板库为空",
+                "template_dir": str(self.template_dir)
+            }
+        
+        template_info = []
+        for name, img in templates:
+            h, w = img.shape[:2]
+            template_info.append({
+                "name": name,
+                "size": f"{w}x{h}",
+                "path": str(self.template_dir / f"{name}.png")
+            })
+        
+        return {
+            "success": True,
+            "templates": template_info,
+            "count": len(template_info),
+            "template_dir": str(self.template_dir)
+        }
+    
+    def delete_template(self, template_name: str) -> Dict:
+        """删除模板"""
+        # 查找模板文件
+        for ext in ['.png', '.jpg', '.jpeg', '.bmp']:
+            path = self.template_dir / f"{template_name}{ext}"
+            if path.exists():
+                path.unlink()
+                self._template_cache.pop(template_name, None)
+                return {
+                    "success": True,
+                    "message": f"✅ 已删除模板: {template_name}"
+                }
+        
+        return {
+            "success": False,
+            "error": f"模板不存在: {template_name}"
+        }
+
+
+# 便捷函数
+def match_close_button(screenshot_path: str, threshold: float = 0.75) -> Dict:
+    """
+    快速匹配关闭按钮
+    
+    用法：
+        from core.template_matcher import match_close_button
+        result = match_close_button("screenshot.png")
+        if result["success"]:
+            print(result["click_command"])
+    """
+    matcher = TemplateMatcher()
+    return matcher.find_close_buttons(screenshot_path, threshold)
+

mobile_mcp/mcp_tools/mcp_server.py

@@ -162,12 +162,14 @@ class MobileMCPServer:
                        "SoM 截图会给元素标号，AI 可以直接说'点击几号'，更精准！\n\n"
                        "🎯 本工具仅用于：\n"
                        "- 快速确认页面状态（不需要点击时）\n"
-                       "- 操作后确认结果\n\n"
+                       "- 操作后确认结果\n"
+                       "- compress=false 时可获取原始分辨率截图（用于添加模板）\n\n"
                        "💡 如需点击元素，请用 mobile_screenshot_with_som + mobile_click_by_som",
             inputSchema={
                 "type": "object",
                 "properties": {
                     "description": {"type": "string", "description": "截图描述（可选）"},
+                    "compress": {"type": "boolean", "description": "是否压缩，默认 true。设为 false 可获取原始分辨率（用于模板添加）", "default": True},
                     "crop_x": {"type": "integer", "description": "局部裁剪中心 X 坐标（屏幕坐标，0 表示不裁剪）"},
                     "crop_y": {"type": "integer", "description": "局部裁剪中心 Y 坐标（屏幕坐标，0 表示不裁剪）"},
                     "crop_size": {"type": "integer", "description": "裁剪区域大小（推荐 200-400，0 表示不裁剪）"}
@@ -629,6 +631,90 @@ class MobileMCPServer:
             }
         ))
         
+        # ==================== 广告弹窗关闭工具 ====================
+        tools.append(Tool(
+            name="mobile_close_ad",
+            description="""🚫 【推荐】智能关闭广告弹窗
+
+专门用于关闭广告弹窗，按优先级自动尝试多种方式：
+
+1️⃣ **控件树查找**（最可靠）
+   - 自动查找"关闭"、"跳过"、"×"等关闭按钮
+   - 找到直接点击，实时可靠
+
+2️⃣ **模板匹配**（次优）
+   - 用 OpenCV 匹配已保存的 X 按钮模板
+   - 需要积累模板库，模板越多成功率越高
+
+3️⃣ **返回截图供 AI 分析**（兜底）
+   - 如果前两步失败，返回截图
+   - AI 分析后用 mobile_click_by_percent 点击
+   - 点击成功后用 mobile_template_add 添加模板（自动学习）
+
+💡 使用流程：
+1. 遇到广告弹窗 → 调用此工具
+2. 如果成功 → 完成
+3. 如果失败 → 看截图找 X → 点击 → 添加模板""",
+            inputSchema={
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        ))
+        
+        tools.append(Tool(
+            name="mobile_template_close",
+            description="""🎯 模板匹配关闭弹窗（仅模板匹配）
+
+只用 OpenCV 模板匹配，不走控件树。
+一般建议用 mobile_close_ad 代替（会自动先查控件树）。
+
+⚙️ 参数：
+- click: 是否点击，默认 true
+- threshold: 匹配阈值 0-1，默认 0.75""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "click": {"type": "boolean", "description": "是否点击，默认 true"},
+                    "threshold": {"type": "number", "description": "匹配阈值 0-1，默认 0.75"}
+                },
+                "required": []
+            }
+        ))
+        
+        tools.append(Tool(
+            name="mobile_template_add",
+            description="""➕ 添加 X 号模板
+
+遇到新样式 X 号时，截图并添加到模板库。
+
+⚙️ 两种方式（二选一）：
+1. 百分比定位（推荐）：提供 x_percent, y_percent, size
+2. 像素定位：提供 screenshot_path, x, y, width, height
+
+📋 流程：
+1. mobile_screenshot_with_grid 查看 X 号位置
+2. 调用此工具添加模板
+3. 下次同样 X 号就能自动匹配
+
+💡 百分比示例：X 在右上角 → x_percent=85, y_percent=12, size=80""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "template_name": {"type": "string", "description": "模板名称"},
+                    "x_percent": {"type": "number", "description": "X号中心水平百分比 (0-100)"},
+                    "y_percent": {"type": "number", "description": "X号中心垂直百分比 (0-100)"},
+                    "size": {"type": "integer", "description": "裁剪正方形边长（像素）"},
+                    "screenshot_path": {"type": "string", "description": "截图路径（像素定位时用）"},
+                    "x": {"type": "integer", "description": "左上角 X 坐标"},
+                    "y": {"type": "integer", "description": "左上角 Y 坐标"},
+                    "width": {"type": "integer", "description": "裁剪宽度"},
+                    "height": {"type": "integer", "description": "裁剪高度"}
+                },
+                "required": ["template_name"]
+            }
+        ))
+        
         return tools
     
     async def handle_tool_call(self, name: str, arguments: dict):
@@ -643,6 +729,7 @@ class MobileMCPServer:
             if name == "mobile_take_screenshot":
                 result = self.tools.take_screenshot(
                     description=arguments.get("description", ""),
+                    compress=arguments.get("compress", True),
                     crop_x=arguments.get("crop_x", 0),
                     crop_y=arguments.get("crop_y", 0),
                     crop_size=arguments.get("crop_size", 0)
@@ -809,6 +896,46 @@ class MobileMCPServer:
                 )
                 return [TextContent(type="text", text=self.format_response(result))]
             
+            # 智能关闭广告弹窗
+            elif name == "mobile_close_ad":
+                result = self.tools.close_ad_popup(auto_learn=True)
+                return [TextContent(type="text", text=self.format_response(result))]
+            
+            # 模板匹配（精简版）
+            elif name == "mobile_template_close":
+                click = arguments.get("click", True)
+                threshold = arguments.get("threshold", 0.75)
+                if click:
+                    result = self.tools.template_click_close(threshold=threshold)
+                else:
+                    result = self.tools.template_match_close(threshold=threshold)
+                return [TextContent(type="text", text=self.format_response(result))]
+            
+            elif name == "mobile_template_add":
+                template_name = arguments["template_name"]
+                # 判断使用哪种方式
+                if "x_percent" in arguments and "y_percent" in arguments:
+                    # 百分比方式
+                    result = self.tools.template_add_by_percent(
+                        arguments["x_percent"],
+                        arguments["y_percent"],
+                        arguments.get("size", 80),
+                        template_name
+                    )
+                elif "screenshot_path" in arguments:
+                    # 像素方式
+                    result = self.tools.template_add(
+                        arguments["screenshot_path"],
+                        arguments["x"],
+                        arguments["y"],
+                        arguments["width"],
+                        arguments["height"],
+                        template_name
+                    )
+                else:
+                    result = {"success": False, "error": "请提供 x_percent/y_percent 或 screenshot_path/x/y/width/height"}
+                return [TextContent(type="text", text=self.format_response(result))]
+            
             else:
                 return [TextContent(type="text", text=f"❌ 未知工具: {name}")]
         
@@ -831,7 +958,7 @@ async def async_main():
     async def call_tool(name: str, arguments: dict):
         return await server.handle_tool_call(name, arguments)
     
-    print("🚀 Mobile MCP Server 启动中... [24 个工具]", file=sys.stderr)
+    print("🚀 Mobile MCP Server 启动中... [26 个工具]", file=sys.stderr)
     print("📱 支持 Android / iOS", file=sys.stderr)
     print("👁️ 完全依赖 Cursor 视觉能力，无需 AI 密钥", file=sys.stderr)
     

{mobile_mcp_ai-2.4.3.dist-info → mobile_mcp_ai-2.5.0.dist-info}/METADATA

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

{mobile_mcp_ai-2.4.3.dist-info → mobile_mcp_ai-2.5.0.dist-info}/RECORD

@@ -1,25 +1,26 @@
 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=WNtNUFy7MOPaD7rl7fZFE01wj7ruDpnNHBTsJKx7n60,130899
+mobile_mcp/core/basic_tools_lite.py,sha256=BzPT180GPQjhTNHaAKl46m1jvCM5KoQIPgySGdNSD30,149836
 mobile_mcp/core/device_manager.py,sha256=PX3-B5bJFnKNt6C8fT7FSY8JwD-ngZ3toF88bcOV9qA,8766
 mobile_mcp/core/dynamic_config.py,sha256=Ja1n1pfb0HspGByqk2_A472mYVniKmGtNEWyjUjmgK8,9811
-mobile_mcp/core/ios_client_wda.py,sha256=dXs6KDUZrQxT_4t8-VBGN5EnmpVCRsPHOmD5NmDCwWA,18769
+mobile_mcp/core/ios_client_wda.py,sha256=Nq9WxevhTWpVpolM-Ymp-b0nUQV3tXLFszmJHbDC4wA,18770
 mobile_mcp/core/ios_device_manager_wda.py,sha256=A44glqI-24un7qST-E3w6BQD8mV92YVUbxy4rLlTScY,11264
 mobile_mcp/core/mobile_client.py,sha256=bno3HvU-QSAC3G4TnoFngTxqXeu-ZP5rGlEWdWh8jOo,62570
+mobile_mcp/core/template_matcher.py,sha256=dGYrae6cAWiPhF6U4WtYFz_4o7a-LQc3FdZnFq4nHNE,14018
 mobile_mcp/core/utils/__init__.py,sha256=RhMMsPszmEn8Q8GoNufypVSHJxyM9lio9U6jjpnuoPI,378
 mobile_mcp/core/utils/logger.py,sha256=XXQAHUwT1jc70pq_tYFmL6f_nKrFlYm3hcgl-5RYRg0,3402
 mobile_mcp/core/utils/operation_history_manager.py,sha256=gi8S8HJAMqvkUrY7_-kVbko3Xt7c4GAUziEujRd-N-Y,4792
 mobile_mcp/core/utils/smart_wait.py,sha256=PvKXImfN9Irru3bQJUjf4FLGn8LjY2VLzUNEl-i7xLE,8601
 mobile_mcp/mcp_tools/__init__.py,sha256=xkro8Rwqv_55YlVyhh-3DgRFSsLE3h1r31VIb3bpM6E,143
-mobile_mcp/mcp_tools/mcp_server.py,sha256=QEehNZCSQjyaH-ST7kmAc6lu0kbgpCpCi3MCHDmA1ZI,39504
+mobile_mcp/mcp_tools/mcp_server.py,sha256=K53DSxKGT3B_f6mqaoTID2th5luBtwlh5MjoUDGbhl0,45263
 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.4.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-mobile_mcp_ai-2.4.3.dist-info/METADATA,sha256=Rtv9Nly-13_zoASQ_nX5ML3R4bZo21OFOsms6bNLC1g,9745
-mobile_mcp_ai-2.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mobile_mcp_ai-2.4.3.dist-info/entry_points.txt,sha256=KB_FglozgPHBprSM1vFbIzGyheFuHFmGanscRdMJ_8A,68
-mobile_mcp_ai-2.4.3.dist-info/top_level.txt,sha256=lLm6YpbTv855Lbh8BIA0rPxhybIrvYUzMEk9OErHT94,11
-mobile_mcp_ai-2.4.3.dist-info/RECORD,,
+mobile_mcp_ai-2.5.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+mobile_mcp_ai-2.5.0.dist-info/METADATA,sha256=nbbNqfi6O5zgrLLGP0QgZdRCUKT_4iYHmySIx5jabJk,9745
+mobile_mcp_ai-2.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mobile_mcp_ai-2.5.0.dist-info/entry_points.txt,sha256=KB_FglozgPHBprSM1vFbIzGyheFuHFmGanscRdMJ_8A,68
+mobile_mcp_ai-2.5.0.dist-info/top_level.txt,sha256=lLm6YpbTv855Lbh8BIA0rPxhybIrvYUzMEk9OErHT94,11
+mobile_mcp_ai-2.5.0.dist-info/RECORD,,