设为首页收藏本站
AIWORK»AIWORK论坛 › AIWORK主页 › AIWORK技术交流 › 示例千问自动采集文章保存记事本

示例千问自动采集文章保存记事本

QQ896757558

380

主题

193

回帖

2397

积分

管理员

积分
2397
显示全部楼层
示例千问自动采集文章保存记事本

1.png

2.png

3.png

4.png

  1. // AIWROK 自动化流程：启动千问 → 输入问题 → 点击发送 → 等待AI回答 → 采集回答内容 → 保存到文件
  2. // 全程使用 agent.getXml() 获取界面源码
  3. // 包名：com.aliyun.tongyi（千问）

  5. print.log("===== 千问对话采集流程启动 =====");
  6. print.time();

  8. // ========== 配置区 ==========
  9. var 千问包名 = "com.aliyun.tongyi";

  11. // 输出文件路径（JSON格式，UTF-8编码）
  12. var 输出文件路径 = "/sdcard/千问对话记录.txt";

  14. // 要发送的问题列表（按顺序发送）
  15. var 要发送的问题列表 = [
  16.     "你好，请用一句话介绍你自己",
  17.     "中国平安股票最近走势如何？",
  18.     "招商银行持有3年卖出需要交股息税吗？"
  19. ];

  21. // 发送后等待AI回答的最大秒数（整体超时，最长35秒）
  22. var 等待回答超时秒 = 35;

  24. // 检测到新回答出现后，再等待多少秒让回答尽量输出完整（然后直接返回）
  25. var 回答输出等待秒 = 12;

  27. // 每个问题之间的间隔秒数
  28. var 问题间隔秒 = 2;

  30. // ========== 获取设备信息 ==========
  31. var 屏幕宽 = screen.getScreenWidth();
  32. var 屏幕高 = screen.getScreenHeight();
  33. print.log("屏幕尺寸：" + 屏幕宽 + " x " + 屏幕高);
  34. print.log("代理状态：" + (agent.isOpen() ? "已开启" : "未开启"));

  36. // ========== 工具函数 ==========

  38. // 获取 UI XML 字符串（使用 agent.getXml()，强制转为字符串）
  39. function 获取UI() {
  40.     var xml = agent.getXml();
  41.     // agent.getXml() 返回对象，需强制转为字符串
  42.     return "" + xml;
  43. }

  45. // 字符串长度兼容函数（避免 Java String 对象 .length() 方法问题）
  46. function 字符串长度(s) {
  47.     var str = "" + s;
  48.     return str.length;
  49. }

  51. // HTML实体解码（千问TextView中的换行符等会被编码为 
 ' 等）
  52. function 解码HTML实体(s) {
  53.     var str = "" + s;
  54.     str = str.replace(/
/g, "\n");
  55.     str = str.replace(/
/g, "\r");
  56.     str = str.replace(/	/g, "\t");
  57.     str = str.replace(/'/g, "'");
  58.     str = str.replace(/"/g, '"');
  59.     str = str.replace(/"/g, '"');
  60.     str = str.replace(/'/g, "'");
  61.     str = str.replace(/&/g, "&");
  62.     str = str.replace(/&lt;/g, "<");
  63.     str = str.replace(/&gt;/g, ">");
  64.     return str;
  65. }

  67. // 采集千问 RecyclerView 中所有长文本 TextView（即AI回答）
  68. // 参数 严格过滤: true=排除短文本按钮等, false=不过滤（用于检测新回答出现，更灵敏）
  69. function 采集AI回答列表(xml, 严格过滤) {
  70.     if (严格过滤 === undefined) 严格过滤 = true;
  71.     var xmlStr = "" + xml;
  72.     var 回答列表 = [];

  74.     // 定位 RecyclerView 节点（千问消息列表使用 RecyclerView）
  75.     var rvPattern = /<node[^>]*?class="androidx\.recyclerview\.widget\.RecyclerView"[^>]*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/g;
  76.     var rvMatch;
  77.     var 消息列表区域 = null;

  79.     while ((rvMatch = rvPattern.exec(xmlStr)) !== null) {
  80.         var rx1 = parseInt(rvMatch[1]);
  81.         var ry1 = parseInt(rvMatch[2]);
  82.         var rx2 = parseInt(rvMatch[3]);
  83.         var ry2 = parseInt(rvMatch[4]);
  84.         var 高度 = ry2 - ry1;
  85.         var 宽度 = rx2 - rx1;

  87.         if (高度 > 500 && 宽度 > 屏幕宽 * 0.8) {
  88.             消息列表区域 = {x1: rx1, y1: ry1, x2: rx2, y2: ry2};
  89.             break;
  90.         }
  91.     }

  93.     if (!消息列表区域) {
  94.         print.log("⚠ 未找到消息列表RecyclerView节点");
  95.         return 回答列表;
  96.     }

  98.     print.log("✓ 找到消息列表区域：[" + 消息列表区域.x1 + "," + 消息列表区域.y1 + "][" + 消息列表区域.x2 + "," + 消息列表区域.y2 + "]");

  100.     // 提取消息列表区域内的所有 TextView（两阶段匹配：先找节点，再提取属性）
  101.     var tvPattern = /<node[^>]*?class="android\.widget\.TextView"[^>]*?\/?>/g;
  102.     var tvMatch;

  104.     while ((tvMatch = tvPattern.exec(xmlStr)) !== null) {
  105.         var tvNode = tvMatch[0];

  107.         // 从节点中提取文本（支持双引号和单引号）
  108.         var textMatch = tvNode.match(/text="([^"]+)"/);
  109.         if (!textMatch) {
  110.             textMatch = tvNode.match(/text='([^']+)'/);
  111.         }
  112.         if (!textMatch) continue;
  113.         var 文本 = textMatch[1];

  115.         // 从节点中提取边界
  116.         var boundsMatch = tvNode.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  117.         if (!boundsMatch) continue;
  118.         var tx1 = parseInt(boundsMatch[1]);
  119.         var ty1 = parseInt(boundsMatch[2]);
  120.         var tx2 = parseInt(boundsMatch[3]);
  121.         var ty2 = parseInt(boundsMatch[4]);

  123.         // 判断该 TextView 是否在消息列表区域内
  124.         var 在区域内 = (tx1 >= 消息列表区域.x1 && tx2 <= 消息列表区域.x2 &&
  125.                         ty1 >= 消息列表区域.y1 && ty2 <= 消息列表区域.y2);

  127.         if (!在区域内) continue;

  129.         var 解码文本 = 解码HTML实体(文本);

  131.         // 排除用户消息特征：位于消息列表顶部区域（y坐标较小）且是单行短文本
  132.         var 是用户消息 = (ty1 < 消息列表区域.y1 + 500) && (解码文本.indexOf("\n") === -1) && (字符串长度(解码文本) < 100);
  133.         
  134.         // 排除搜索步骤文本（包含"查询"、"检索"、"调研"等关键词的是搜索计划，不是最终回答）
  135.         var 是搜索步骤 = (解码文本.indexOf("查询") !== -1 || 解码文本.indexOf("检索") !== -1 ||
  136.                           解码文本.indexOf("调研") !== -1 || 解码文本.indexOf("确认") !== -1 ||
  137.                           解码文本.indexOf("分析") !== -1 || 解码文本.indexOf("查找") !== -1) &&
  138.                          (字符串长度(解码文本) < 500);
  139.         
  140.         // 排除视频推荐区域的文本（视频推荐通常在AI回答下方，y坐标较大且有特定特征）
  141.         // AI回答通常在消息列表顶部区域，视频推荐在下方
  142.         var 消息列表高度 = 消息列表区域.y2 - 消息列表区域.y1;
  143.         var 是视频推荐 = (ty1 > 消息列表区域.y1 + 消息列表高度 * 0.3) &&
  144.                          (解码文本.indexOf("笔记") !== -1 || 解码文本.indexOf("作者") !== -1 ||
  145.                           字符串长度(解码文本) < 30);
  146.         
  147.         if (严格过滤) {
  148.             if (!是用户消息 && !是搜索步骤 && !是视频推荐 && (解码文本.indexOf("\n") !== -1 || 字符串长度(解码文本) > 50)) {
  149.                 回答列表.push(解码文本);
  150.             }
  151.         } else {
  152.             if (!是用户消息 && !是搜索步骤 && !是视频推荐 && 字符串长度(解码文本) > 0) {
  153.                 回答列表.push(解码文本);
  154.             }
  155.         }
  156.     }

  158.     return 回答列表;
  159. }

  161. // 查找输入框中心坐标（查找 hint 文本为"发消息或按住说话..."的 TextView）
  162. function 查找输入框中心(xml) {
  163.     var xmlStr = "" + xml;

  165.     var inputIdx = xmlStr.indexOf('text="发消息或按住说话..."');
  166.     if (inputIdx === -1) {
  167.         inputIdx = xmlStr.indexOf("text='发消息或按住说话...'");
  168.     }
  169.     if (inputIdx !== -1) {
  170.         var 段 = xmlStr.substring(inputIdx);
  171.         var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  172.         if (m) {
  173.             print.log("✓ 输入框定位：hint文本匹配");
  174.             return {
  175.                 x: (parseInt(m[1]) + parseInt(m[3])) / 2,
  176.                 y: (parseInt(m[2]) + parseInt(m[4])) / 2
  177.             };
  178.         }
  179.     }

  181.     var editTextPattern = /<node[^>]*?class="android\.widget\.EditText"[^>]*?\/?>/g;
  182.     var etMatch;
  183.     while ((etMatch = editTextPattern.exec(xmlStr)) !== null) {
  184.         var etNode = etMatch[0];
  185.         var boundsMatch = etNode.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  186.         if (boundsMatch) {
  187.             var ex1 = parseInt(boundsMatch[1]);
  188.             var ey1 = parseInt(boundsMatch[2]);
  189.             var ex2 = parseInt(boundsMatch[3]);
  190.             var ey2 = parseInt(boundsMatch[4]);
  191.             
  192.             if (ey1 > 屏幕高 * 0.8) {
  193.                 print.log("✓ 输入框定位：EditText匹配");
  194.                 return {
  195.                     x: (ex1 + ex2) / 2,
  196.                     y: (ey1 + ey2) / 2
  197.                 };
  198.             }
  199.         }
  200.     }

  202.     var viewGroupPattern = /<node[^>]*?class="android\.view\.ViewGroup"[^>]*?clickable="true"[^>]*?\/?>/g;
  203.     var vgMatch;
  204.     while ((vgMatch = viewGroupPattern.exec(xmlStr)) !== null) {
  205.         var vgNode = vgMatch[0];
  206.         var boundsMatch = vgNode.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  207.         if (boundsMatch) {
  208.             var vx1 = parseInt(boundsMatch[1]);
  209.             var vy1 = parseInt(boundsMatch[2]);
  210.             var vx2 = parseInt(boundsMatch[3]);
  211.             var vy2 = parseInt(boundsMatch[4]);
  212.             
  213.             var vWidth = vx2 - vx1;
  214.             var vHeight = vy2 - vy1;
  215.             
  216.             if (vy1 > 屏幕高 * 0.8 && vWidth > 屏幕宽 * 0.4 && vWidth < 屏幕宽 * 0.8) {
  217.                 print.log("✓ 输入框定位：ViewGroup匹配");
  218.                 return {
  219.                     x: (vx1 + vx2) / 2,
  220.                     y: (vy1 + vy2) / 2
  221.                 };
  222.             }
  223.         }
  224.     }

  226.     print.log("⚠ 未找到输入框，使用兜底坐标");
  227.     return {
  228.         x: 屏幕宽 * 0.4,
  229.         y: 屏幕高 * 0.92
  230.     };
  231. }

  233. // 查找发送按钮坐标
  234. // 千问输入框下方右侧的按钮，输入文字后会变成发送按钮
  235. function 查找发送按钮中心(xml) {
  236.     var xmlStr = "" + xml;

  238.     // 1. 优先查找文字"发送"
  239.     var sendTextIdx = xmlStr.indexOf('text="发送"');
  240.     if (sendTextIdx === -1) {
  241.         sendTextIdx = xmlStr.indexOf("text='发送'");
  242.     }
  243.     if (sendTextIdx !== -1) {
  244.         var 段 = xmlStr.substring(sendTextIdx);
  245.         var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  246.         if (m) {
  247.             print.log("✓ 发送按钮定位：文本匹配");
  248.             return {
  249.                 x: (parseInt(m[1]) + parseInt(m[3])) / 2,
  250.                 y: (parseInt(m[2]) + parseInt(m[4])) / 2
  251.             };
  252.         }
  253.     }

  255.     // 2. 查找屏幕底部区域的点击区域（FrameLayout）
  256.     var clickablePattern = /<node[^>]*?clickable="true"[^>]*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"[^>]*?\/?>/g;
  257.     var clickMatch;
  258.     var candidates = [];

  260.     while ((clickMatch = clickablePattern.exec(xmlStr)) !== null) {
  261.         var cx1 = parseInt(clickMatch[1]);
  262.         var cy1 = parseInt(clickMatch[2]);
  263.         var cx2 = parseInt(clickMatch[3]);
  264.         var cy2 = parseInt(clickMatch[4]);

  266.         if (cy1 > 屏幕高 * 0.85) {
  267.             candidates.push({
  268.                 x1: cx1, y1: cy1, x2: cx2, y2: cy2,
  269.                 x: (cx1 + cx2) / 2,
  270.                 y: (cy1 + cy2) / 2
  271.             });
  272.         }
  273.     }

  275.     if (candidates.length > 0) {
  276.         candidates.sort(function(a, b) {
  277.             return b.x1 - a.x1;
  278.         });
  279.         print.log("✓ 找到" + candidates.length + "个候选按钮，选择最右侧的，坐标(" + Math.round(candidates[0].x) + "," + Math.round(candidates[0].y) + ")");
  280.         return {
  281.             x: candidates[0].x,
  282.             y: candidates[0].y
  283.         };
  284.     }

  286.     // 3. 查找屏幕底部区域的 FrameLayout（千问发送按钮特征）
  287.     var flPattern = /<node[^>]*?class="android\.widget\.FrameLayout"[^>]*?\/?>/g;
  288.     var flMatch;
  289.     var flCandidates = [];

  291.     while ((flMatch = flPattern.exec(xmlStr)) !== null) {
  292.         var flNode = flMatch[0];
  293.         
  294.         if (flNode.indexOf('clickable="true"') === -1) continue;
  295.         
  296.         var boundsMatch = flNode.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  297.         if (!boundsMatch) continue;
  298.         
  299.         var fx1 = parseInt(boundsMatch[1]);
  300.         var fy1 = parseInt(boundsMatch[2]);
  301.         var fx2 = parseInt(boundsMatch[3]);
  302.         var fy2 = parseInt(boundsMatch[4]);

  304.         if (fy1 > 屏幕高 * 0.85) {
  305.             flCandidates.push({
  306.                 x1: fx1, y1: fy1, x2: fx2, y2: fy2,
  307.                 x: (fx1 + fx2) / 2,
  308.                 y: (fy1 + fy2) / 2
  309.             });
  310.         }
  311.     }

  313.     if (flCandidates.length > 0) {
  314.         flCandidates.sort(function(a, b) {
  315.             return b.x1 - a.x1;
  316.         });
  317.         print.log("✓ 找到" + flCandidates.length + "个FrameLayout候选，选择最右侧的，坐标(" + Math.round(flCandidates[0].x) + "," + Math.round(flCandidates[0].y) + ")");
  318.         return {
  319.             x: flCandidates[0].x,
  320.             y: flCandidates[0].y
  321.         };
  322.     }

  324.     // 4. 兜底：基于屏幕百分比定位发送按钮（输入框下方右侧）
  325.     print.log("⚠ 使用兜底策略定位发送按钮，坐标(" + Math.round(屏幕宽 * 0.92) + "," + Math.round(屏幕高 * 0.92) + ")");
  326.     return {
  327.         x: 屏幕宽 * 0.92,
  328.         y: 屏幕高 * 0.92
  329.     };
  330. }

  332. // 粘贴文本到当前焦点输入框（剪贴板法，兼容中文）
  333. function 粘贴文本(文本) {
  334.     try {
  335.         Clipboard.copy("" + 文本);
  336.     } catch (e) {
  337.         print.log("⚠ Clipboard.copy 失败：" + e.message);
  338.     }
  339.     sleep.millisecond(毫秒 = 300);

  341.     // 双保险：通过 shell 写剪贴板
  342.     try {
  343.         agent.shell("service call clipboard 3 i32 1 s16 '" + 文本 + "' i32 0");
  344.     } catch (e2) {
  345.         // 忽略错误
  346.     }
  347.     sleep.millisecond(毫秒 = 300);

  349.     // 触发粘贴：KEYCODE_PASTE = 279
  350.     agent.shell("input keyevent 279");
  351.     sleep.second(秒 = 1);
  352.     print.log("✓ 已粘贴文本：" + 文本);
  353. }

  355. // 查找并点击AI回答底部的展开按钮（向下箭头）
  356. // 千问长回答会折叠显示，需要点击底部向下箭头才能看到完整内容
  357. function 查找并点击展开按钮(xml) {
  358.     var xmlStr = "" + xml;
  359.    
  360.     // 1. 查找消息列表底部中间的小区域clickable节点（向下箭头特征）
  361.     var rvPattern = /<node[^>]*?class="androidx\.recyclerview\.widget\.RecyclerView"[^>]*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/g;
  362.     var rvMatch;
  363.     while ((rvMatch = rvPattern.exec(xmlStr)) !== null) {
  364.         var rx1 = parseInt(rvMatch[1]);
  365.         var ry1 = parseInt(rvMatch[2]);
  366.         var rx2 = parseInt(rvMatch[3]);
  367.         var ry2 = parseInt(rvMatch[4]);
  368.         var 高度 = ry2 - ry1;
  369.         if (高度 > 500) {
  370.             var viewPattern = /<node[^>]*?clickable="true"[^>]*?\/?>/g;
  371.             var viewMatch;
  372.             while ((viewMatch = viewPattern.exec(xmlStr)) !== null) {
  373.                 var vNode = viewMatch[0];
  374.                 var boundsMatch = vNode.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  375.                 if (!boundsMatch) continue;
  376.                
  377.                 var vx1 = parseInt(boundsMatch[1]);
  378.                 var vy1 = parseInt(boundsMatch[2]);
  379.                 var vx2 = parseInt(boundsMatch[3]);
  380.                 var vy2 = parseInt(boundsMatch[4]);
  381.                
  382.                 var vWidth = vx2 - vx1;
  383.                 var vHeight = vy2 - vy1;
  384.                
  385.                 var 在区域内 = (vx1 >= rx1 && vx2 <= rx2 && vy1 >= ry1 && vy2 <= ry2);
  386.                 var 是小按钮 = (vWidth < 200 && vHeight < 200);
  387.                 var 在底部 = (vy1 > ry1 + 高度 * 0.7);
  388.                
  389.                 if (在区域内 && 是小按钮 && 在底部) {
  390.                     var centerX = (vx1 + vx2) / 2;
  391.                     var centerY = (vy1 + vy2) / 2;
  392.                     agent.click(centerX, centerY);
  393.                     print.log("✓ 已点击展开箭头（消息列表底部小按钮），坐标(" + Math.round(centerX) + "," + Math.round(centerY) + ")");
  394.                     sleep.second(秒 = 2);
  395.                     return true;
  396.                 }
  397.             }
  398.             break;
  399.         }
  400.     }

  402.     // 2. 查找文本"查看全部"的按钮
  403.     var textExpandIdx = xmlStr.indexOf('text="查看全部"');
  404.     if (textExpandIdx === -1) {
  405.         textExpandIdx = xmlStr.indexOf("text='查看全部'");
  406.     }
  407.     if (textExpandIdx !== -1) {
  408.         var 段 = xmlStr.substring(textExpandIdx);
  409.         var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  410.         if (m) {
  411.             var x = (parseInt(m[1]) + parseInt(m[3])) / 2;
  412.             var y = (parseInt(m[2]) + parseInt(m[4])) / 2;
  413.             agent.click(x, y);
  414.             print.log("✓ 已点击查看全部按钮，坐标(" + Math.round(x) + "," + Math.round(y) + ")");
  415.             sleep.second(秒 = 2);
  416.             return true;
  417.         }
  418.     }

  420.     // 3. 查找 content-desc 含"展开"或"更多"的按钮
  421.     var expandIdx = xmlStr.indexOf('content-desc="展开"');
  422.     if (expandIdx === -1) {
  423.         expandIdx = xmlStr.indexOf('content-desc="更多"');
  424.     }
  425.     if (expandIdx !== -1) {
  426.         var 段2 = xmlStr.substring(expandIdx);
  427.         var m2 = 段2.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  428.         if (m2) {
  429.             var x2 = (parseInt(m2[1]) + parseInt(m2[3])) / 2;
  430.             var y2 = (parseInt(m2[2]) + parseInt(m2[4])) / 2;
  431.             agent.click(x2, y2);
  432.             print.log("✓ 已点击展开按钮（content-desc），坐标(" + Math.round(x2) + "," + Math.round(y2) + ")");
  433.             sleep.second(秒 = 1);
  434.             return true;
  435.         }
  436.     }

  438.     // 4. 查找文本"展开"或"更多"的按钮
  439.     var textExpandIdx2 = xmlStr.indexOf('text="展开"');
  440.     if (textExpandIdx2 === -1) {
  441.         textExpandIdx2 = xmlStr.indexOf('text="更多"');
  442.     }
  443.     if (textExpandIdx2 !== -1) {
  444.         var 段3 = xmlStr.substring(textExpandIdx2);
  445.         var m3 = 段3.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  446.         if (m3) {
  447.             var x3 = (parseInt(m3[1]) + parseInt(m3[3])) / 2;
  448.             var y3 = (parseInt(m3[2]) + parseInt(m3[4])) / 2;
  449.             agent.click(x3, y3);
  450.             print.log("✓ 已点击展开按钮（文本匹配），坐标(" + Math.round(x3) + "," + Math.round(y3) + ")");
  451.             sleep.second(秒 = 1);
  452.             return true;
  453.         }
  454.     }

  456.     // 5. 查找消息列表底部区域内的ImageView（箭头图标）
  457.     var ivPattern = /<node[^>]*?class="android\.widget\.ImageView"[^>]*?clickable="true"[^>]*?\/?>/g;
  458.     var ivMatch;
  459.     while ((ivMatch = ivPattern.exec(xmlStr)) !== null) {
  460.         var ivNode = ivMatch[0];
  461.         var boundsMatch = ivNode.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
  462.         if (!boundsMatch) continue;
  463.         
  464.         var ivx1 = parseInt(boundsMatch[1]);
  465.         var ivy1 = parseInt(boundsMatch[2]);
  466.         var ivx2 = parseInt(boundsMatch[3]);
  467.         var ivy2 = parseInt(boundsMatch[4]);
  468.         
  469.         var 在底部 = (ivy1 > 屏幕高 * 0.5);
  470.         var 在中间 = (ivx1 > 屏幕宽 * 0.3 && ivx2 < 屏幕宽 * 0.7);
  471.         
  472.         if (在底部 && 在中间) {
  473.             var centerX = (ivx1 + ivx2) / 2;
  474.             var centerY = (ivy1 + ivy2) / 2;
  475.             agent.click(centerX, centerY);
  476.             print.log("✓ 已点击ImageView（箭头图标），坐标(" + Math.round(centerX) + "," + Math.round(centerY) + ")");
  477.             sleep.second(秒 = 2);
  478.             return true;
  479.         }
  480.     }

  482.     // 6. 最终兜底：点击消息列表底部中心位置（展开箭头通常在这里）
  483.     var rvPattern2 = /<node[^>]*?class="androidx\.recyclerview\.widget\.RecyclerView"[^>]*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/g;
  484.     var rvMatch2;
  485.     while ((rvMatch2 = rvPattern2.exec(xmlStr)) !== null) {
  486.         var rx1 = parseInt(rvMatch2[1]);
  487.         var ry1 = parseInt(rvMatch2[2]);
  488.         var rx2 = parseInt(rvMatch2[3]);
  489.         var ry2 = parseInt(rvMatch2[4]);
  490.         var 高度 = ry2 - ry1;
  491.         if (高度 > 500) {
  492.             var centerX = (rx1 + rx2) / 2;
  493.             var bottomY = ry2 - 60;
  494.             agent.click(centerX, bottomY);
  495.             print.log("✓ 已点击消息列表底部中心（兜底展开），坐标(" + Math.round(centerX) + "," + Math.round(bottomY) + ")");
  496.             sleep.second(秒 = 2);
  497.             return true;
  498.         }
  499.     }

  501.     var pctX = 屏幕宽 / 2;
  502.     var pctY = 屏幕高 * 0.75;
  503.     agent.click(pctX, pctY);
  504.     print.log("✓ 已点击屏幕底部中间（最终兜底），坐标(" + Math.round(pctX) + "," + Math.round(pctY) + ")");
  505.     sleep.second(秒 = 1);
  506.     return true;
  507. }

  509. // 从XML解析 RecyclerView 的边界，然后在其中滑动到底部
  510. function 滑动消息列表到底部(xml) {
  511.     var xmlStr = "" + xml;

  513.     var rvPattern = /<node[^>]*?class="androidx\.recyclerview\.widget\.RecyclerView"[^>]*?bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/g;
  514.     var rvMatch;

  516.     while ((rvMatch = rvPattern.exec(xmlStr)) !== null) {
  517.         var rx1 = parseInt(rvMatch[1]);
  518.         var ry1 = parseInt(rvMatch[2]);
  519.         var rx2 = parseInt(rvMatch[3]);
  520.         var ry2 = parseInt(rvMatch[4]);
  521.         var 高度 = ry2 - ry1;

  523.         if (高度 > 500) {
  524.             var startX = (rx1 + rx2) / 2;
  525.             var startY = ry1 + (ry2 - ry1) * 0.2;
  526.             var endX = startX;
  527.             var endY = ry1 + (ry2 - ry1) * 0.8;

  529.             agent.swip(startX, startY, endX, endY, 500);
  530.             print.log("✓ 已在RecyclerView内滑动，区域[" + rx1 + "," + ry1 + "][" + rx2 + "," + ry2 + "]");
  531.             return;
  532.         }
  533.     }

  535.     print.log("⚠ 未找到RecyclerView，使用屏幕百分比滑动");
  536.     agent.swip(屏幕宽 / 2, 屏幕高 * 0.3, 屏幕宽 / 2, 屏幕高 * 0.8, 500);
  537. }

  539. // 等待AI回答完成
  540. // 逻辑：
  541. //   阶段1：等待新回答出现（文本变化）
  542. //   阶段2：点击展开按钮（在消息列表底部）
  543. //   阶段3：动态检测回答是否完成（连续2次检查文本不变，则认为完成）
  544. // 参数：发送前的最后一条AI回答文本（用于对比检测新回答）
  545. // 返回：新回答的文本内容
  546. function 等待AI回答完成(发送前的最后文本) {
  547.     var 已耗时 = 0;
  548.     var 检查间隔秒 = 2;
  549.     var 已检测到新回答 = false;
  550.     var 已点击展开按钮 = false;
  551.     var 上次文本 = "";
  552.     var 文本不变次数 = 0;
  553.     var 已检测到思考完成 = false;

  555.     while (已耗时 < 等待回答超时秒) {
  556.         sleep.second(秒 = 检查间隔秒);
  557.         已耗时 += 检查间隔秒;

  559.         var xml = 获取UI();
  560.         var xmlStr = "" + xml;

  562.         if (!已检测到新回答) {
  563.             // 阶段1：等待新回答出现
  564.             var 宽松列表 = 采集AI回答列表(xml, false);
  565.             if (宽松列表.length === 0) {
  566.                 continue;
  567.             }
  568.             var 当前最后文本 = 宽松列表[宽松列表.length - 1];
  569.             if (当前最后文本 !== 发送前的最后文本 && 字符串长度(当前最后文本) > 0) {
  570.                 print.log("✓ 检测到新回答出现（" + 已耗时 + "秒）");
  571.                 已检测到新回答 = true;
  572.                 上次文本 = 当前最后文本;
  573.             }
  574.         } else {
  575.             // 阶段2和3：点击展开按钮并检测完成
  576.             var 当前列表 = 采集AI回答列表(xml, false);
  577.             var 当前文本 = "";
  578.             if (当前列表.length > 0) {
  579.                 当前文本 = 当前列表[当前列表.length - 1];
  580.             }

  582.             // 检查是否完成思考（宽松条件）
  583.             if (!已检测到思考完成 && (xmlStr.indexOf("参考") !== -1)) {
  584.                 print.log("✓ 检测到AI思考完成（" + 已耗时 + "秒）");
  585.                 已检测到思考完成 = true;
  586.             }

  588.             // 点击展开按钮（在检测到思考完成后立即点击）
  589.             if (!已点击展开按钮 && 已检测到思考完成) {
  590.                 查找并点击展开按钮(xml);
  591.                 已点击展开按钮 = true;
  592.                 print.log("✓ 已点击展开按钮");
  593.             }

  595.             // 如果没检测到思考完成，但文本很长，也尝试点击展开
  596.             if (!已点击展开按钮 && !已检测到思考完成 && 字符串长度(当前文本) > 100 && 已耗时 >= 8) {
  597.                 查找并点击展开按钮(xml);
  598.                 已点击展开按钮 = true;
  599.                 print.log("✓ 文本较长，尝试点击展开按钮");
  600.             }

  602.             // 检查文本是否停止变化
  603.             if (当前文本 === 上次文本) {
  604.                 文本不变次数++;
  605.             } else {
  606.                 文本不变次数 = 0;
  607.                 上次文本 = 当前文本;
  608.             }

  610.             // 判断完成条件：
  611.             // 1. 文本连续2次不变
  612.             // 2. 且文本长度大于50
  613.             // 3. 且已等待至少6秒（确保展开后有时间显示完整内容）
  614.             if (文本不变次数 >= 2 && 字符串长度(当前文本) > 50 && 已耗时 >= 6) {
  615.                 print.log("✓ 检测到回答完成（文本连续不变），返回采集结果");
  616.                 return 当前文本;
  617.             }

  619.             // 如果文本很短但停止变化很久，也返回
  620.             if (文本不变次数 >= 4 && 字符串长度(当前文本) > 10 && 已耗时 >= 10) {
  621.                 print.log("✓ 文本停止变化已久，返回采集结果");
  622.                 return 当前文本;
  623.             }
  624.         }
  625.     }

  627.     // 超时兜底：尽量返回当前能采集到的最后一条回答
  628.     print.log("⚠ 等待AI回答超时（" + 等待回答超时秒 + "秒），尝试返回当前内容");
  629.     var xml = 获取UI();
  630.     var 兜底列表 = 采集AI回答列表(xml, true);
  631.     if (兜底列表.length > 0) {
  632.         var 兜底文本 = 兜底列表[兜底列表.length - 1];
  633.         if (兜底文本 !== 发送前的最后文本) {
  634.             print.log("✓ 超时兜底：返回当前采集到的回答");
  635.             return 兜底文本;
  636.         }
  637.     }
  638.     var 兜底宽松 = 采集AI回答列表(xml, false);
  639.     if (兜底宽松.length > 0) {
  640.         var 兜底文本2 = 兜底宽松[兜底宽松.length - 1];
  641.         if (兜底文本2 !== 发送前的最后文本 && 字符串长度(兜底文本2) > 5) {
  642.             print.log("✓ 超时兜底（宽松）：返回当前采集到的回答");
  643.             return 兜底文本2;
  644.         }
  645.     }
  646.     return null;
  647. }

  649. // 获取当前页面最后一条AI回答文本（用于发送前记录基线）
  650. function 获取当前最后AI回答(xml) {
  651.     var 回答列表 = 采集AI回答列表(xml);
  652.     if (回答列表.length === 0) return "";
  653.     return 回答列表[回答列表.length - 1];
  654. }

  656. // 格式化对话内容输出（TXT格式）
  657. function 格式化对话(对话列表) {
  658.     var result = "========== 千问对话记录 ==========\n";
  659.     result += "采集时间：" + new Date().toString() + "\n";
  660.     result += "对话轮数：" + 对话列表.length + "\n";
  661.     result += "==================================\n\n";
  662.    
  663.     for (var i = 0; i < 对话列表.length; i++) {
  664.         result += "【" + 对话列表[i].角色 + "】\n";
  665.         result += 对话列表[i].内容 + "\n";
  666.         result += "----------------------------------\n";
  667.         if (i < 对话列表.length - 1) {
  668.             result += "\n";
  669.         }
  670.     }
  671.    
  672.     return result;
  673. }

  675. // 写入文件（TXT格式，GBK编码）
  676. function 写入文件(文件路径, 内容) {
  677.     var javaStr = new java.lang.String(内容);
  678.    
  679.     try {
  680.         var fos = new java.io.FileOutputStream(文件路径);
  681.         fos.write(javaStr.getBytes("GBK"));
  682.         fos.close();
  683.         
  684.         print.log("✓ 已写入文件（TXT格式，GBK编码）：" + 文件路径);
  685.         
  686.         var catResult = agent.shell("cat " + 文件路径 + " | head -2");
  687.         print.log("✓ cat验证结果：" + catResult);
  688.         
  689.         return true;
  690.     } catch (e) {
  691.         print.log("⚠ FileOutputStream写入异常：" + e.message);
  692.     }

  694.     try {
  695.         var base64Content = java.util.Base64.getEncoder().encodeToString(javaStr.getBytes("GBK"));
  696.         agent.shell("echo '" + base64Content + "' | base64 -d > " + 文件路径);
  697.         
  698.         print.log("✓ 已通过base64写入文件（GBK）：" + 文件路径);
  699.         
  700.         var catResult = agent.shell("cat " + 文件路径 + " | head -2");
  701.         print.log("✓ cat验证结果：" + catResult);
  702.         
  703.         return true;
  704.     } catch (e2) {
  705.         print.log("⚠ base64写入异常：" + e2.message);
  706.     }

  708.     try {
  709.         var fos2 = new java.io.FileOutputStream(文件路径);
  710.         fos2.write(javaStr.getBytes("UTF-8"));
  711.         fos2.close();
  712.         
  713.         print.log("✓ 已通过FileOutputStream写入文件（UTF-8）：" + 文件路径);
  714.         
  715.         return true;
  716.     } catch (e3) {
  717.         print.log("⚠ UTF-8写入异常：" + e3.message);
  718.     }

  720.     print.log("✗ 写入文件失败：" + 文件路径);
  721.     return false;
  722. }

  724. // ========== 主流程开始 ==========

  726. // 步骤1：启动千问APP
  727. print.log("\n========== 步骤1：启动千问APP ==========");
  728. try {
  729.     app.openApp(千问包名);
  730.     print.log("✓ 已启动千问");
  731. } catch (e) {
  732.     print.log("⚠ 启动失败：" + e.message);
  733. }
  734. sleep.second(秒 = 5);

  736. // 步骤2：确认进入对话页面
  737. print.log("\n========== 步骤2：确认进入对话页面 ==========");
  738. var xml = 获取UI();
  739. var hasRecyclerView = (xml.indexOf("androidx.recyclerview.widget.RecyclerView") !== -1);
  740. if (!hasRecyclerView) {
  741.     print.log("⚠ 当前页面可能不是千问对话页，再次等待");
  742.     sleep.second(秒 = 3);
  743.     xml = 获取UI();
  744.     hasRecyclerView = (xml.indexOf("androidx.recyclerview.widget.RecyclerView") !== -1);
  745. }

  747. if (hasRecyclerView) {
  748.     print.log("✓ 已进入千问对话页面");
  749. } else {
  750.     print.log("⚠ 未检测到消息列表，继续尝试");
  751. }

  753. // 步骤3：循环发送问题并采集回答
  754. print.log("\n========== 步骤3：循环发送问题并采集回答 ==========");

  756. // 完整对话列表（包含用户问题和AI回答）
  757. var 完整对话 = [];

  759. // 获取发送第一个问题前的最后AI回答文本（作为基线，用于检测新回答）
  760. var 初始最后文本 = 获取当前最后AI回答(xml);
  761. print.log("✓ 初始页面最后一条AI回答长度：" + 字符串长度(初始最后文本));

  763. // 开始发送问题
  764. for (var q = 0; q < 要发送的问题列表.length; q++) {
  765.     var 当前问题 = 要发送的问题列表[q];
  766.     print.log("\n---- 第 " + (q + 1) + " / " + 要发送的问题列表.length + " 个问题 ----");
  767.     print.log("问题：" + 当前问题);

  769.     // 3.1 重新获取UI，定位输入框
  770.     xml = 获取UI();
  771.     var 输入框 = 查找输入框中心(xml);
  772.     if (!输入框) {
  773.         print.log("⚠ 未找到输入框，跳过此问题");
  774.         sleep.second(秒 = 问题间隔秒);
  775.         continue;
  776.     }

  778.     // 3.2 记录发送前的最后一条AI回答文本（作为检测新回答的基线）
  779.     var 发送前最后文本 = 获取当前最后AI回答(xml);

  781.     // 3.3 点击输入框获取焦点
  782.     agent.click(输入框.x, 输入框.y);
  783.     sleep.second(秒 = 1);

  785.     // 3.4 粘贴问题文本
  786.     粘贴文本(当前问题);

  788.     // 3.5 重新获取UI，查找发送按钮
  789.     xml = 获取UI();
  790.     var 发送按钮 = 查找发送按钮中心(xml);

  792.     if (发送按钮) {
  793.         agent.click(发送按钮.x, 发送按钮.y);
  794.         print.log("✓ 已点击发送按钮");
  795.     } else {
  796.         // 兜底：按回车键发送
  797.         agent.shell("input keyevent 66");
  798.         print.log("⚠ 未找到发送按钮，已尝试按回车发送");
  799.     }

  801.     // 3.6 记录用户问题
  802.     完整对话.push({
  803.         角色: "用户",
  804.         内容: 当前问题
  805.     });

  807.     // 3.7 等待AI回答完成（基于"最后一条回答文本变化"判断，不依赖数量递增）
  808.     print.log("等待AI回答，发送前最后文本长度：" + 字符串长度(发送前最后文本));

  810.     var 新回答文本 = 等待AI回答完成(发送前最后文本);
  811.     if (新回答文本 && 字符串长度(新回答文本) > 0) {
  812.         完整对话.push({
  813.             角色: "AI",
  814.             内容: 新回答文本
  815.         });
  816.         print.log("✓ 采集到新回答，当前总对话条数：" + 完整对话.length);
  817.         print.log("--- 采集内容开始 ---");
  818.         print.log(新回答文本);
  819.         print.log("--- 采集内容结束 ---");
  820.     } else {
  821.         print.log("⚠ 未能采集到新回答");
  822.     }

  824.     sleep.second(秒 = 问题间隔秒);
  825. }

  827. // 步骤4：保存对话到文件
  828. print.log("\n========== 步骤4：保存对话到文件 ==========");
  829. var 输出内容 = 格式化对话(完整对话);
  830. var 写入成功 = 写入文件(输出文件路径, 输出内容);

  832. if (写入成功) {
  833.     print.log("✓ 对话已保存到：" + 输出文件路径);
  834.     print.log("✓ 总对话条数：" + 完整对话.length);
  835. } else {
  836.     print.log("✗ 保存失败，请检查存储权限");
  837. }

  839. // 步骤5：打印全部采集到的对话内容
  840. print.log("\n========== 全部采集内容 ==========");
  841. print.log(输出内容);
  842. print.log("========== 内容结束 ==========");

  844. print.log("\n===== 千问对话采集流程结束 =====");
复制代码


quot var 回答 文本
相关帖子

上一篇: 豆包识别验证码加拖动验证码示例

下一篇: 元宝截图B站验证码示例测试

发表于 2026-7-15 06:50:04

举报 回复

返回列表 发新帖

网站地图|手机版|AIWORK |网站地图

Copyright © 2001-2020, Tencent Cloud.　Powered by 留下备用