豆包对话采集示例

QQ896757558

豆包对话采集示例

1. // AIWROK 自动化流程：启动豆包 → 输入问题 → 点击发送 → 等待AI回答 → 采集回答内容 → 保存到文件
   
2. // 全程使用 agent.getXml() 获取界面源码
   
3. // 包名：com.larus.nova（豆包）
   
4. //
   
5. // 使用说明：
   
6. //   1. 修改下方【配置区】中的"要发送的问题列表"
   
7. //   2. 采集结果保存到 /sdcard/豆包对话记录.txt
   
8. 
   
9. print.log("===== 豆包对话采集流程启动 =====");
   
10. print.time();
    
11. 
    
12. // ========== 配置区 ==========
    
13. var 豆包包名 = "com.larus.nova";
    
14. 
    
15. // 输出文件路径
    
16. var 输出文件路径 = "/sdcard/豆包对话记录.txt";
    
17. 
    
18. // 要发送的问题列表（按顺序发送）
    
19. var 要发送的问题列表 = [
    
20.     "你好，请用一句话介绍你自己",
    
21.     "中国平安股票最近走势如何？",
    
22.     "招商银行持有3年卖出需要交股息税吗？"
    
23. ];
    
24. 
    
25. // 发送后等待AI回答的最大秒数（整体超时，最长10秒）
    
26. var 等待回答超时秒 = 10;
    
27. 
    
28. // 检测到新回答出现后，再等待多少秒让回答尽量输出完整（然后直接返回）
    
29. var 回答输出等待秒 = 8;
    
30. 
    
31. // 每个问题之间的间隔秒数
    
32. var 问题间隔秒 = 2;
    
33. 
    
34. // ========== 获取设备信息 ==========
    
35. var 屏幕宽 = screen.getScreenWidth();
    
36. var 屏幕高 = screen.getScreenHeight();
    
37. print.log("屏幕尺寸：" + 屏幕宽 + " x " + 屏幕高);
    
38. print.log("代理状态：" + (agent.isOpen() ? "已开启" : "未开启"));
    
39. 
    
40. // ========== 工具函数 ==========
    
41. 
    
42. // 获取 UI XML 字符串（使用 agent.getXml()，强制转为字符串）
    
43. function 获取UI() {
    
44.     var xml = agent.getXml();
    
45.     // agent.getXml() 返回对象，需强制转为字符串
    
46.     return "" + xml;
    
47. }
    
48. 
    
49. // 字符串长度兼容函数（避免 Java String 对象 .length() 方法问题）
    
50. function 字符串长度(s) {
    
51.     var str = "" + s;
    
52.     return str.length;
    
53. }
    
54. 
    
55. // HTML实体解码（豆包TextView中的换行符等会被编码为 
 ' 等）
    
56. function 解码HTML实体(s) {
    
57.     var str = "" + s;
    
58.     str = str.replace(/
/g, "\n");
    
59.     str = str.replace(/
/g, "\r");
    
60.     str = str.replace(/	/g, "\t");
    
61.     str = str.replace(/'/g, "'");
    
62.     str = str.replace(/"/g, '"');
    
63.     str = str.replace(/"/g, '"');
    
64.     str = str.replace(/'/g, "'");
    
65.     str = str.replace(/&/g, "&");
    
66.     str = str.replace(/&lt;/g, "<");
    
67.     str = str.replace(/&gt;/g, ">");
    
68.     return str;
    
69. }
    
70. 
    
71. // 采集豆包 message_list 中所有 content_view 下的 TextView 文本（即AI回答）
    
72. // 参数 严格过滤: true=排除短文本按钮等, false=不过滤（用于检测新回答出现，更灵敏）
    
73. function 采集AI回答列表(xml, 严格过滤) {
    
74.     if (严格过滤 === undefined) 严格过滤 = true;
    
75.     var xmlStr = "" + xml;
    
76.     var 回答列表 = [];
    
77. 
    
78.     // 定位 message_list 节点
    
79.     var listIdx = xmlStr.indexOf('id/message_list"');
    
80.     if (listIdx === -1) {
    
81.         print.log("⚠ 未找到消息列表节点，可能不在豆包对话页面");
    
82.         return 回答列表;
    
83.     }
    
84. 
    
85.     // 截取 message_list 之后的部分
    
86.     var 后面 = xmlStr.substring(listIdx);
    
87. 
    
88.     // 遍历所有 content_view 节点
    
89.     var 位置 = 0;
    
90.     while (true) {
    
91.         var cvIdx = 后面.indexOf('id/content_view"', 位置);
    
92.         if (cvIdx === -1) break;
    
93. 
    
94.         // 从 content_view 起始位置截取一段，找它内部第一个有非空 text 的 TextView
    
95.         var 段 = 后面.substring(cvIdx);
    
96.         // 找到 content_view 节点开始标签的结束位置 ">"
    
97.         var 标签结束 = 段.indexOf(">");
    
98.         if (标签结束 === -1) break;
    
99.         var 子段 = 段.substring(标签结束 + 1);
    
100. 
     
101.         // 在子段中查找第一个有非空 text 的 TextView 节点
     
102.         var 文本匹配 = 子段.match(/<node[^>]*?text="([^"]+)"[^>]*?class="android\.widget\.TextView"[^>]*?\/?>/);
     
103.         if (!文本匹配) {
     
104.             // 备选顺序：先 class 再 text
     
105.             文本匹配 = 子段.match(/<node[^>]*?class="android\.widget\.TextView"[^>]*?text="([^"]+)"[^>]*?\/?>/);
     
106.         }
     
107. 
     
108.         if (文本匹配 && 文本匹配[1]) {
     
109.             var 原始文本 = 文本匹配[1];
     
110.             var 解码文本 = 解码HTML实体(原始文本);
     
111.             if (严格过滤) {
     
112.                 // 严格模式：排除按钮文案（复制、分享等），AI回答特征：含换行 或 长度>30
     
113.                 if (解码文本.indexOf("\n") !== -1 || 字符串长度(解码文本) > 30) {
     
114.                     回答列表.push(解码文本);
     
115.                 }
     
116.             } else {
     
117.                 // 宽松模式：只要有非空文本就算，用于灵敏检测新回答出现
     
118.                 if (字符串长度(解码文本) > 0) {
     
119.                     回答列表.push(解码文本);
     
120.                 }
     
121.             }
     
122.         }
     
123. 
     
124.         位置 = cvIdx + 30;
     
125.     }
     
126. 
     
127.     return 回答列表;
     
128. }
     
129. 
     
130. // 查找输入框中心坐标（resource-id 含 input_text 的 EditText）
     
131. function 查找输入框中心(xml) {
     
132.     var xmlStr = "" + xml;
     
133.     var idx = xmlStr.indexOf('id/input_text"');
     
134.     if (idx === -1) return null;
     
135. 
     
136.     var 段 = xmlStr.substring(idx);
     
137.     var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
138.     if (!m) return null;
     
139. 
     
140.     var x1 = parseInt(m[1]);
     
141.     var y1 = parseInt(m[2]);
     
142.     var x2 = parseInt(m[3]);
     
143.     var y2 = parseInt(m[4]);
     
144.     return {
     
145.         x: (x1 + x2) / 2,
     
146.         y: (y1 + y2) / 2
     
147.     };
     
148. }
     
149. 
     
150. // 查找发送按钮坐标
     
151. // 豆包输入框右侧的 action_speak 节点，输入文字后会变成发送按钮
     
152. // 也查找文字"发送"或 resource-id 含 action_send 的节点
     
153. function 查找发送按钮中心(xml) {
     
154.     var xmlStr = "" + xml;
     
155. 
     
156.     // 1. 优先查找文字"发送"
     
157.     var sendTextIdx = xmlStr.indexOf('text="发送"');
     
158.     if (sendTextIdx !== -1) {
     
159.         var 段 = xmlStr.substring(sendTextIdx);
     
160.         var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
161.         if (m) {
     
162.             return {
     
163.                 x: (parseInt(m[1]) + parseInt(m[3])) / 2,
     
164.                 y: (parseInt(m[2]) + parseInt(m[4])) / 2
     
165.             };
     
166.         }
     
167.     }
     
168. 
     
169.     // 2. 查找 resource-id 含 action_send
     
170.     var sendIdIdx = xmlStr.indexOf('id/action_send"');
     
171.     if (sendIdIdx !== -1) {
     
172.         var 段2 = xmlStr.substring(sendIdIdx);
     
173.         var m2 = 段2.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
174.         if (m2) {
     
175.             return {
     
176.                 x: (parseInt(m2[1]) + parseInt(m2[3])) / 2,
     
177.                 y: (parseInt(m2[2]) + parseInt(m2[4])) / 2
     
178.             };
     
179.         }
     
180.     }
     
181. 
     
182.     // 3. 兜底：使用 action_speak 节点坐标（输入文字后该按钮变为发送功能）
     
183.     var speakIdx = xmlStr.indexOf('id/action_speak"');
     
184.     if (speakIdx !== -1) {
     
185.         var 段3 = xmlStr.substring(speakIdx);
     
186.         var m3 = 段3.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
187.         if (m3) {
     
188.             return {
     
189.                 x: (parseInt(m3[1]) + parseInt(m3[3])) / 2,
     
190.                 y: (parseInt(m3[2]) + parseInt(m3[4])) / 2
     
191.             };
     
192.         }
     
193.     }
     
194. 
     
195.     return null;
     
196. }
     
197. 
     
198. // 粘贴文本到当前焦点输入框（剪贴板法，兼容中文）
     
199. function 粘贴文本(文本) {
     
200.     try {
     
201.         Clipboard.copy("" + 文本);
     
202.     } catch (e) {
     
203.         print.log("⚠ Clipboard.copy 失败：" + e.message);
     
204.     }
     
205.     sleep.millisecond(毫秒 = 300);
     
206. 
     
207.     // 双保险：通过 shell 写剪贴板
     
208.     try {
     
209.         agent.shell("service call clipboard 3 i32 1 s16 '" + 文本 + "' i32 0");
     
210.     } catch (e2) {
     
211.         // 忽略错误
     
212.     }
     
213.     sleep.millisecond(毫秒 = 300);
     
214. 
     
215.     // 触发粘贴：KEYCODE_PASTE = 279
     
216.     agent.shell("input keyevent 279");
     
217.     sleep.second(秒 = 1);
     
218.     print.log("✓ 已粘贴文本：" + 文本);
     
219. }
     
220. 
     
221. // 查找并点击AI回答底部的展开按钮（向下箭头）
     
222. // 豆包长回答会折叠显示，需要点击展开箭头才能看到完整内容
     
223. // 从XML中动态定位，不依赖硬编码坐标
     
224. function 查找并点击展开按钮(xml) {
     
225.     var xmlStr = "" + xml;
     
226.    
     
227.     // 1. 查找 content-desc 含"展开"或"更多"的按钮
     
228.     var expandIdx = xmlStr.indexOf('content-desc="展开"');
     
229.     if (expandIdx === -1) {
     
230.         expandIdx = xmlStr.indexOf('content-desc="更多"');
     
231.     }
     
232.     if (expandIdx === -1) {
     
233.         expandIdx = xmlStr.indexOf('content-desc="收起"');
     
234.     }
     
235.    
     
236.     if (expandIdx !== -1) {
     
237.         var 段 = xmlStr.substring(expandIdx);
     
238.         var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
239.         if (m) {
     
240.             var x = (parseInt(m[1]) + parseInt(m[3])) / 2;
     
241.             var y = (parseInt(m[2]) + parseInt(m[4])) / 2;
     
242.             agent.click(x, y);
     
243.             print.log("✓ 已点击展开按钮（content-desc），坐标(" + Math.round(x) + "," + Math.round(y) + ")");
     
244.             sleep.second(秒 = 1);
     
245.             return true;
     
246.         }
     
247.     }
     
248. 
     
249.     // 2. 查找文本"展开"或"更多"的按钮
     
250.     var textExpandIdx = xmlStr.indexOf('text="展开"');
     
251.     if (textExpandIdx === -1) {
     
252.         textExpandIdx = xmlStr.indexOf('text="更多"');
     
253.     }
     
254.     if (textExpandIdx !== -1) {
     
255.         var 段2 = xmlStr.substring(textExpandIdx);
     
256.         var m2 = 段2.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
257.         if (m2) {
     
258.             var x2 = (parseInt(m2[1]) + parseInt(m2[3])) / 2;
     
259.             var y2 = (parseInt(m2[2]) + parseInt(m2[4])) / 2;
     
260.             agent.click(x2, y2);
     
261.             print.log("✓ 已点击展开按钮（文本匹配），坐标(" + Math.round(x2) + "," + Math.round(y2) + ")");
     
262.             sleep.second(秒 = 1);
     
263.             return true;
     
264.         }
     
265.     }
     
266. 
     
267.     // 3. 兜底：从XML解析最后一个 content_view 的底部中心位置（展开箭头通常在回答底部中间）
     
268.     var lastCVIdx = xmlStr.lastIndexOf('id/content_view"');
     
269.     if (lastCVIdx !== -1) {
     
270.         var cv段 = xmlStr.substring(lastCVIdx);
     
271.         var cvM = cv段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
272.         if (cvM) {
     
273.             var cvX1 = parseInt(cvM[1]);
     
274.             var cvY1 = parseInt(cvM[2]);
     
275.             var cvX2 = parseInt(cvM[3]);
     
276.             var cvY2 = parseInt(cvM[4]);
     
277.             // 点击 content_view 底部中间位置（展开箭头通常在这里）
     
278.             var centerX = (cvX1 + cvX2) / 2;
     
279.             var bottomY = cvY2 - 50; // 稍微往上一点，避开边缘
     
280.             agent.click(centerX, bottomY);
     
281.             print.log("✓ 已点击content_view底部（兜底展开），坐标(" + Math.round(centerX) + "," + Math.round(bottomY) + ")");
     
282.             sleep.second(秒 = 1);
     
283.             return true;
     
284.         }
     
285.     }
     
286. 
     
287.     // 4. 最终兜底：使用屏幕百分比坐标（仅作为最后备选）
     
288.     var pctX = 屏幕宽 / 2;
     
289.     var pctY = 屏幕高 * 0.85;
     
290.     agent.click(pctX, pctY);
     
291.     print.log("✓ 已点击屏幕底部（最终兜底），坐标(" + Math.round(pctX) + "," + Math.round(pctY) + ")");
     
292.     sleep.second(秒 = 1);
     
293.     return true;
     
294. }
     
295. 
     
296. // 从XML解析 message_list 的边界，然后在其中滑动到底部
     
297. // 不依赖硬编码坐标，换手机也能运行
     
298. function 滑动消息列表到底部(xml) {
     
299.     var xmlStr = "" + xml;
     
300.     var listIdx = xmlStr.indexOf('id/message_list"');
     
301.     if (listIdx === -1) {
     
302.         print.log("⚠ 未找到message_list，使用屏幕百分比滑动");
     
303.         agent.swip(屏幕宽 / 2, 屏幕高 * 0.3, 屏幕宽 / 2, 屏幕高 * 0.8, 500);
     
304.         return;
     
305.     }
     
306. 
     
307.     var 段 = xmlStr.substring(listIdx);
     
308.     var m = 段.match(/bounds="\[(\d+),(\d+)\]\[(\d+),(\d+)\]"/);
     
309.     if (!m) {
     
310.         print.log("⚠ 未找到message_list边界，使用屏幕百分比滑动");
     
311.         agent.swip(屏幕宽 / 2, 屏幕高 * 0.3, 屏幕宽 / 2, 屏幕高 * 0.8, 500);
     
312.         return;
     
313.     }
     
314. 
     
315.     var x1 = parseInt(m[1]);
     
316.     var y1 = parseInt(m[2]);
     
317.     var x2 = parseInt(m[3]);
     
318.     var y2 = parseInt(m[4]);
     
319. 
     
320.     // 在 message_list 区域内滑动：从上半部分滑到下半部分
     
321.     var startX = (x1 + x2) / 2;
     
322.     var startY = y1 + (y2 - y1) * 0.2; // 区域上方20%位置
     
323.     var endX = startX;
     
324.     var endY = y1 + (y2 - y1) * 0.8;   // 区域下方20%位置
     
325. 
     
326.     agent.swip(startX, startY, endX, endY, 500);
     
327.     print.log("✓ 已在message_list内滑动，区域[" + x1 + "," + y1 + "][" + x2 + "," + y2 + "]");
     
328. }
     
329. // 等待AI回答完成
     
330. // 逻辑：
     
331. //   阶段1：宽松检测 - 等待最后一条回答文本变化（新回答出现）
     
332. //   阶段2：检测到新回答后，先点击展开按钮，再等待回答输出等待秒，然后直接返回
     
333. //   超时兜底：若整体超时但能采到非空文本，也返回当前内容
     
334. // 参数：发送前的最后一条AI回答文本（用于对比检测新回答）
     
335. // 返回：新回答的文本内容
     
336. function 等待AI回答完成(发送前的最后文本) {
     
337.     var 已耗时 = 0;
     
338.     var 检查间隔秒 = 2;
     
339.     var 已检测到新回答 = false;
     
340.     var 检测到的时间点 = 0;
     
341.     var 已点击展开按钮 = false;
     
342. 
     
343.     while (已耗时 < 等待回答超时秒) {
     
344.         sleep.second(秒 = 检查间隔秒);
     
345.         已耗时 += 检查间隔秒;
     
346. 
     
347.         var xml = 获取UI();
     
348. 
     
349.         if (!已检测到新回答) {
     
350.             // 阶段1：宽松模式检测新回答是否出现
     
351.             var 宽松列表 = 采集AI回答列表(xml, false);
     
352.             if (宽松列表.length === 0) {
     
353.                 continue;
     
354.             }
     
355.             var 当前最后文本 = 宽松列表[宽松列表.length - 1];
     
356.             if (当前最后文本 !== 发送前的最后文本 && 字符串长度(当前最后文本) > 0) {
     
357.                 print.log("✓ 检测到新回答出现（" + 已耗时 + "秒），等待" + 回答输出等待秒 + "秒后采集");
     
358.                 已检测到新回答 = true;
     
359.                 检测到的时间点 = 已耗时;
     
360.             }
     
361.         } else {
     
362.             // 阶段2：已检测到新回答
     
363.             var 已等待 = 已耗时 - 检测到的时间点;
     
364.             
     
365.             // 先点击展开按钮（只点击一次）
     
366.             if (!已点击展开按钮 && 已等待 >= 2) {
     
367.                 查找并点击展开按钮(xml);
     
368.                 已点击展开按钮 = true;
     
369.             }
     
370.             
     
371.             // 再等回答输出等待秒后直接返回
     
372.             if (已等待 >= 回答输出等待秒) {
     
373.                 var 严格列表 = 采集AI回答列表(xml, true);
     
374.                 if (严格列表.length > 0) {
     
375.                     var 最终回答 = 严格列表[严格列表.length - 1];
     
376.                     if (最终回答 !== 发送前的最后文本 && 字符串长度(最终回答) > 0) {
     
377.                         print.log("✓ 已等待" + 已等待 + "秒，返回采集结果");
     
378.                         return 最终回答;
     
379.                     }
     
380.                 }
     
381.                 // 严格模式没采到，用宽松模式
     
382.                 var 宽松列表2 = 采集AI回答列表(xml, false);
     
383.                 if (宽松列表2.length > 0) {
     
384.                     var 最终回答2 = 宽松列表2[宽松列表2.length - 1];
     
385.                     if (最终回答2 !== 发送前的最后文本 && 字符串长度(最终回答2) > 5) {
     
386.                         print.log("✓ 已等待" + 已等待 + "秒（宽松模式），返回采集结果");
     
387.                         return 最终回答2;
     
388.                     }
     
389.                 }
     
390.             }
     
391.         }
     
392.     }
     
393. 
     
394.     // 超时兜底：尽量返回当前能采集到的最后一条回答
     
395.     print.log("⚠ 等待AI回答超时（" + 等待回答超时秒 + "秒），尝试返回当前内容");
     
396.     var xml = 获取UI();
     
397.     var 兜底列表 = 采集AI回答列表(xml, true);
     
398.     if (兜底列表.length > 0) {
     
399.         var 兜底文本 = 兜底列表[兜底列表.length - 1];
     
400.         if (兜底文本 !== 发送前的最后文本) {
     
401.             print.log("✓ 超时兜底：返回当前采集到的回答");
     
402.             return 兜底文本;
     
403.         }
     
404.     }
     
405.     var 兜底宽松 = 采集AI回答列表(xml, false);
     
406.     if (兜底宽松.length > 0) {
     
407.         var 兜底文本2 = 兜底宽松[兜底宽松.length - 1];
     
408.         if (兜底文本2 !== 发送前的最后文本 && 字符串长度(兜底文本2) > 5) {
     
409.             print.log("✓ 超时兜底（宽松）：返回当前采集到的回答");
     
410.             return 兜底文本2;
     
411.         }
     
412.     }
     
413.     return null;
     
414. }
     
415. 
     
416. // 获取当前页面最后一条AI回答文本（用于发送前记录基线）
     
417. function 获取当前最后AI回答(xml) {
     
418.     var 回答列表 = 采集AI回答列表(xml);
     
419.     if (回答列表.length === 0) return "";
     
420.     return 回答列表[回答列表.length - 1];
     
421. }
     
422. 
     
423. // 格式化对话内容输出
     
424. function 格式化对话(对话列表) {
     
425.     var 输出 = "";
     
426.     输出 += "========================================\n";
     
427.     输出 += "豆包对话采集记录\n";
     
428.     输出 += "采集时间：" + new Date().toString() + "\n";
     
429.     输出 += "对话轮数：" + 对话列表.length + "\n";
     
430.     输出 += "========================================\n\n";
     
431. 
     
432.     for (var i = 0; i < 对话列表.length; i++) {
     
433.         var 对话 = 对话列表[i];
     
434.         if (对话.角色 === "用户") {
     
435.             输出 += "【用户提问 " + (i + 1) + "】\n";
     
436.         } else {
     
437.             输出 += "【豆包回答 " + (i + 1) + "】\n";
     
438.         }
     
439.         输出 += 对话.内容 + "\n";
     
440.         输出 += "----------------------------------------\n\n";
     
441.     }
     
442. 
     
443.     输出 += "\n===== 采集结束 =====\n";
     
444.     return 输出;
     
445. }
     
446. 
     
447. // 写入文件（UTF-8 BOM格式，兼容Windows记事本）
     
448. function 写入文件(文件路径, 内容) {
     
449.     try {
     
450.         var fos = new java.io.FileOutputStream(文件路径);
     
451.         var osw = new java.io.OutputStreamWriter(fos, "UTF-8");
     
452.         osw.write('\ufeff');
     
453.         osw.write(内容);
     
454.         osw.flush();
     
455.         osw.close();
     
456.         fos.close();
     
457.         print.log("✓ 已写入文件（UTF-8 BOM）：" + 文件路径);
     
458.         
     
459.         var catResult = agent.shell("cat " + 文件路径 + " | head -3");
     
460.         print.log("✓ cat验证结果：" + catResult);
     
461.         
     
462.         var fileSize = agent.shell("ls -la " + 文件路径);
     
463.         print.log("✓ 文件信息：" + fileSize);
     
464.         
     
465.         return true;
     
466.     } catch (e) {
     
467.         print.log("⚠ UTF-8 BOM写入异常：" + e.message);
     
468.     }
     
469. 
     
470.     try {
     
471.         var fos2 = new java.io.FileOutputStream(文件路径);
     
472.         fos2.write(239);
     
473.         fos2.write(187);
     
474.         fos2.write(191);
     
475.         fos2.write(内容.getBytes("UTF-8"));
     
476.         fos2.close();
     
477.         print.log("✓ 已写入文件（字节写入BOM）：" + 文件路径);
     
478.         return true;
     
479.     } catch (e2) {
     
480.         print.log("⚠ 字节写入异常：" + e2.message);
     
481.     }
     
482. 
     
483.     print.log("✗ 写入文件失败：" + 文件路径);
     
484.     return false;
     
485. }
     
486. 
     
487. // ========== 主流程开始 ==========
     
488. 
     
489. // 步骤1：启动豆包APP
     
490. print.log("\n========== 步骤1：启动豆包APP ==========");
     
491. try {
     
492.     app.openApp(豆包包名);
     
493.     print.log("✓ 已启动豆包");
     
494. } catch (e) {
     
495.     print.log("⚠ 启动失败：" + e.message);
     
496. }
     
497. sleep.second(秒 = 5);
     
498. 
     
499. // 步骤2：确认进入对话页面
     
500. print.log("\n========== 步骤2：确认进入对话页面 ==========");
     
501. var xml = 获取UI();
     
502. if (xml.indexOf("message_list") === -1) {
     
503.     print.log("⚠ 当前页面可能不是豆包对话页，再次等待");
     
504.     sleep.second(秒 = 3);
     
505.     xml = 获取UI();
     
506. }
     
507. 
     
508. if (xml.indexOf("message_list") !== -1) {
     
509.     print.log("✓ 已进入豆包对话页面");
     
510. } else {
     
511.     print.log("⚠ 未检测到消息列表，继续尝试");
     
512. }
     
513. 
     
514. // 步骤3：循环发送问题并采集回答
     
515. print.log("\n========== 步骤3：循环发送问题并采集回答 ==========");
     
516. 
     
517. // 完整对话列表（包含用户问题和AI回答）
     
518. var 完整对话 = [];
     
519. 
     
520. // 先采集当前页面已有的AI回答
     
521. var 已有回答 = 采集AI回答列表(xml);
     
522. print.log("✓ 当前页面已有AI回答数量：" + 已有回答.length);
     
523. for (var i = 0; i < 已有回答.length; i++) {
     
524.     完整对话.push({
     
525.         角色: "AI",
     
526.         内容: 已有回答[i]
     
527.     });
     
528. }
     
529. 
     
530. // 开始发送问题
     
531. for (var q = 0; q < 要发送的问题列表.length; q++) {
     
532.     var 当前问题 = 要发送的问题列表[q];
     
533.     print.log("\n---- 第 " + (q + 1) + " / " + 要发送的问题列表.length + " 个问题 ----");
     
534.     print.log("问题：" + 当前问题);
     
535. 
     
536.     // 3.1 重新获取UI，定位输入框
     
537.     xml = 获取UI();
     
538.     var 输入框 = 查找输入框中心(xml);
     
539.     if (!输入框) {
     
540.         print.log("⚠ 未找到输入框，跳过此问题");
     
541.         sleep.second(秒 = 问题间隔秒);
     
542.         continue;
     
543.     }
     
544. 
     
545.     // 3.2 记录发送前的最后一条AI回答文本（作为检测新回答的基线）
     
546.     var 发送前最后文本 = 获取当前最后AI回答(xml);
     
547. 
     
548.     // 3.3 点击输入框获取焦点
     
549.     agent.click(输入框.x, 输入框.y);
     
550.     sleep.second(秒 = 1);
     
551. 
     
552.     // 3.4 粘贴问题文本
     
553.     粘贴文本(当前问题);
     
554. 
     
555.     // 3.5 重新获取UI，查找发送按钮
     
556.     xml = 获取UI();
     
557.     var 发送按钮 = 查找发送按钮中心(xml);
     
558. 
     
559.     if (发送按钮) {
     
560.         agent.click(发送按钮.x, 发送按钮.y);
     
561.         print.log("✓ 已点击发送按钮");
     
562.     } else {
     
563.         // 兜底：按回车键发送
     
564.         agent.shell("input keyevent 66");
     
565.         print.log("⚠ 未找到发送按钮，已尝试按回车发送");
     
566.     }
     
567. 
     
568.     // 3.6 记录用户问题
     
569.     完整对话.push({
     
570.         角色: "用户",
     
571.         内容: 当前问题
     
572.     });
     
573. 
     
574.     // 3.7 等待AI回答完成（基于"最后一条回答文本变化"判断，不依赖数量递增）
     
575.     print.log("等待AI回答，发送前最后文本长度：" + 字符串长度(发送前最后文本));
     
576. 
     
577.     var 新回答文本 = 等待AI回答完成(发送前最后文本);
     
578.     if (新回答文本 && 字符串长度(新回答文本) > 0) {
     
579.         完整对话.push({
     
580.             角色: "AI",
     
581.             内容: 新回答文本
     
582.         });
     
583.         print.log("✓ 采集到新回答，当前总对话条数：" + 完整对话.length);
     
584.         print.log("--- 采集内容开始 ---");
     
585.         print.log(新回答文本);
     
586.         print.log("--- 采集内容结束 ---");
     
587.     } else {
     
588.         print.log("⚠ 未能采集到新回答");
     
589.     }
     
590. 
     
591.     sleep.second(秒 = 问题间隔秒);
     
592. }
     
593. 
     
594. // 步骤4：保存对话到文件
     
595. print.log("\n========== 步骤4：保存对话到文件 ==========");
     
596. var 输出内容 = 格式化对话(完整对话);
     
597. var 写入成功 = 写入文件(输出文件路径, 输出内容);
     
598. 
     
599. if (写入成功) {
     
600.     print.log("✓ 对话已保存到：" + 输出文件路径);
     
601.     print.log("✓ 总对话条数：" + 完整对话.length);
     
602. } else {
     
603.     print.log("✗ 保存失败，请检查存储权限");
     
604. }
     
605. 
     
606. // 步骤5：打印全部采集到的对话内容
     
607. print.log("\n========== 全部采集内容 ==========");
     
608. print.log(输出内容);
     
609. print.log("========== 内容结束 ==========");
     
610. 
     
611. print.log("\n===== 豆包对话采集流程结束 =====");
     

复制代码