AIWROK 屏幕触摸事件监听工具

QQ896757558

AIWROK 屏幕触摸事件监听工具

1. /**
   
2. * ╔══════════════════════════════════════════════════╗
   
3. * ║     AIWROK 屏幕触摸事件监听工具                   ║
   
4. * ║     (模拟 events.observeTouch 功能)               ║
   
5. * ╚══════════════════════════════════════════════════╝
   
6. *
   
7. * 核心能力：
   
8. *   ① 检测是否有 root 权限
   
9. *   ② 自动查找触摸设备节点（/dev/input/eventX）
   
10. *   ③ 实时解析触摸事件 → 回调 onTouchDown/Move/Up
    
11. *   ④ 自动坐标转换（ABS_MT_POSITION_X/Y）
    
12. *   ⑤ 提供 observeTouch() 统一入口
    
13. *
    
14. * 原理：通过 su + getevent -lt 读取 /dev/input/eventX 原始事件流
    
15. *
    
16. * 依赖：需要 root 权限（雷电/夜神/逍遥模拟器默认自带 root）
    
17. */
    
18. 
    
19. // ======================== Shell 执行工具 ========================
    
20. 
    
21. /**
    
22. * 统一 shell 执行入口
    
23. * 优先用 AIWROK 自带的 agent.shell（已经处理了 root）
    
24. * 兜底用 java.lang.Runtime.exec
    
25. */
    
26. function shellExec(cmd) {
    
27.     // 优先走 agent.shell
    
28.     if (typeof agent !== "undefined" && typeof agent.shell === "function") {
    
29.         try {
    
30.             var ret = agent.shell(cmd);
    
31.             return ret === null ? "" : ret.toString();
    
32.         } catch (e) {
    
33.             printl("[shell] agent.shell('" + cmd + "') 异常: " + e.message);
    
34.         }
    
35.     }
    
36.     // 兜底：Runtime.exec（不要 su -c，雷电自带 root 直接跑就行）
    
37.     try {
    
38.         var proc = java.lang.Runtime.getRuntime().exec(cmd);
    
39.         var reader = new java.io.BufferedReader(
    
40.             new java.io.InputStreamReader(proc.getInputStream())
    
41.         );
    
42.         var errReader = new java.io.BufferedReader(
    
43.             new java.io.InputStreamReader(proc.getErrorStream())
    
44.         );
    
45.         var sb = new java.lang.StringBuilder();
    
46.         var errSb = new java.lang.StringBuilder();
    
47.         var line;
    
48.         while ((line = reader.readLine()) !== null) {
    
49.             sb.append(line).append("\n");
    
50.         }
    
51.         while ((line = errReader.readLine()) !== null) {
    
52.             errSb.append(line).append("\n");
    
53.         }
    
54.         proc.waitFor();
    
55.         var stdout = sb.toString();
    
56.         var stderr = errSb.toString();
    
57.         if (stderr && stderr.length() > 0) {
    
58.             printl("[shell] cmd=" + cmd + "  stderr=" + stderr.trim());
    
59.         }
    
60.         return stdout.trim();
    
61.     } catch (e2) {
    
62.         printl("[shell] Runtime.exec('" + cmd + "') 异常: " + e2.message);
    
63.         return "";
    
64.     }
    
65. }
    
66. 
    
67. // ======================== 设备检测 ========================
    
68. 
    
69. /**
    
70. * 检测设备是否有 root 权限
    
71. * 直接跑 id 看 uid=0
    
72. */
    
73. function isRootAvailable() {
    
74.     // AIWROK 里 agent.shell 本身就需要 root 才能用
    
75.     if (typeof agent !== "undefined" && typeof agent.shell === "function") {
    
76.         try {
    
77.             var ret = shellExec("id");
    
78.             printl("[root检测] agent.shell('id') → " + ret);
    
79.             if (ret && ret.indexOf("uid=0") >= 0) return true;
    
80.         } catch (e) {}
    
81.     }
    
82. 
    
83.     // 再试 Runtime 方式
    
84.     try {
    
85.         var r2 = shellExec("id");
    
86.         printl("[root检测] Runtime exec('id') → " + r2);
    
87.         if (r2 && r2.indexOf("uid=0") >= 0) return true;
    
88.     } catch (e2) {}
    
89. 
    
90.     printl("[root检测] 所有策略均失败");
    
91.     return false;
    
92. }
    
93. 
    
94. /**
    
95. * 查找触摸设备 eventX 节点
    
96. * 策略1: cat /proc/bus/input/devices 找 Name 含 touch 的
    
97. * 策略2(兜底): getevent -lp 找含 ABS_MT_POSITION_X/Y 的
    
98. */
    
99. function findTouchEventDevice() {
    
100.     // 先把每个 eventX 的完整配置都打出来
     
101.     printl("[触摸检测] ========= 所有设备完整信息 ==========");
     
102.     var allDev = shellExec("getevent -lp");
     
103.     // 按 "add device" 分段
     
104.     var devBlocks = allDev.split(/add device \d+: /);
     
105.     for (var b = 0; b < devBlocks.length; b++) {
     
106.         var block = devBlocks[b].trim();
     
107.         if (!block) continue;
     
108.         // 提取 eventX 名
     
109.         var evtMatch = block.match(/^\/dev\/input\/(event\d+)/);
     
110.         if (!evtMatch) continue;
     
111.         // 提取 name
     
112.         var nameMatch = block.match(/name:\s*"([^"]*)"/);
     
113.         // 提取 events 描述
     
114.         var eventsStr = "";
     
115.         var evMatch = block.match(/events:([\s\S]*?)(?=input props|add device|$)/);
     
116.         if (evMatch) eventsStr = evMatch[1].trim();
     
117.         printl("");
     
118.         printl("  设备: " + evtMatch[1]);
     
119.         printl("    名称: " + (nameMatch ? nameMatch[1] : "(无)"));
     
120.         // 只看前 300 字的 events，别太长
     
121.         printl("    events: " + eventsStr.substring(0, Math.min(300, eventsStr.length())));
     
122.     }
     
123.     printl("[触摸检测] ====================================");
     
124. 
     
125.     // 再扫一遍完整输出找触摸特征
     
126.     if (allDev && allDev.length() > 0) {
     
127.         var re = /add device \d+: \/dev\/input\/(event\d+)\s+name:\s*"([^"]*)"([\s\S]*?)(?=add device|$)/g;
     
128.         var m;
     
129.         while ((m = re.exec(allDev)) !== null) {
     
130.             var evtName = m[1];
     
131.             var devName = m[2].toLowerCase();
     
132.             var eventsInfo = m[3];
     
133. 
     
134.             // 策略 A: 名字含触摸关键词
     
135.             if (devName.indexOf("touch") >= 0 ||
     
136.                 devName.indexOf("tsp") >= 0 ||
     
137.                 devName.indexOf("panel") >= 0 ||
     
138.                 devName.indexOf("goodix") >= 0 ||
     
139.                 devName.indexOf("synaptics") >= 0) {
     
140.                 printl("[触摸检测] ✓ 名字匹配: " + evtName + " (" + m[2] + ")");
     
141.                 return evtName;
     
142.             }
     
143. 
     
144.             // 策略 B: events 含 ABS_MT_POSITION（多点触控）
     
145.             if (eventsInfo.indexOf("ABS_MT_POSITION_X") >= 0 &&
     
146.                 eventsInfo.indexOf("ABS_MT_POSITION_Y") >= 0) {
     
147.                 printl("[触摸检测] ✓ 多点触控特征: " + evtName + " (" + m[2] + ")");
     
148.                 return evtName;
     
149.             }
     
150. 
     
151.             // 策略 C: events 含 BTN_TOUCH + ABS_X + ABS_Y（单点触控）
     
152.             if (eventsInfo.indexOf("BTN_TOUCH") >= 0 &&
     
153.                 eventsInfo.indexOf("ABS_X") >= 0 &&
     
154.                 eventsInfo.indexOf("ABS_Y") >= 0) {
     
155.                 printl("[触摸检测] ✓ 单点触控特征: " + evtName + " (" + m[2] + ")");
     
156.                 return evtName;
     
157.             }
     
158. 
     
159.             // 策略 D: HID 触摸（雷电常见）
     
160.             if ((devName.indexOf("hid") >= 0 || devName.indexOf("mouse") >= 0) &&
     
161.                 eventsInfo.indexOf("BTN_TOUCH") >= 0) {
     
162.                 printl("[触摸检测] ✓ HID 触摸: " + evtName + " (" + m[2] + ")");
     
163.                 return evtName;
     
164.             }
     
165.         }
     
166.     }
     
167. 
     
168.     printl("[触摸检测] 所有策略均未找到触摸设备");
     
169.     return null;
     
170. }
     
171. 
     
172. // ======================== 触摸观察器 ========================
     
173. 
     
174. /**
     
175. * 触摸观察器
     
176. * 后台线程跑 getevent -lt，解析后回调 down/move/up
     
177. */
     
178. function TouchObserver(eventDevice) {
     
179.     this.device = eventDevice;
     
180.     this.running = false;
     
181.     this.process = null;
     
182.     this.listeners = { down: [], move: [], up: [], touch: [] };
     
183.     this.currentX = -1;
     
184.     this.currentY = -1;
     
185.     this.currentPointer = -1;
     
186.     this.pointerDown = false;
     
187.     this._downFired = false;
     
188. }
     
189. 
     
190. TouchObserver.prototype.onDown = function (fn) { this.listeners.down.push(fn); };
     
191. TouchObserver.prototype.onMove = function (fn) { this.listeners.move.push(fn); };
     
192. TouchObserver.prototype.onUp   = function (fn) { this.listeners.up.push(fn);   };
     
193. TouchObserver.prototype.onTouch = function (fn) { this.listeners.touch.push(fn); };
     
194. 
     
195. TouchObserver.prototype._emit = function (type, ev) {
     
196.     var i, arr;
     
197.     // 专属回调
     
198.     arr = this.listeners[type];
     
199.     for (i = 0; i < arr.length; i++) {
     
200.         try { arr[i](ev); } catch (e) { printl("[触摸回调错] " + e.message); }
     
201.     }
     
202.     // 统一回调：(type, event)
     
203.     arr = this.listeners.touch;
     
204.     for (i = 0; i < arr.length; i++) {
     
205.         try { arr[i](type, ev); } catch (e2) { printl("[触摸回调错] " + e2.message); }
     
206.     }
     
207. };
     
208. 
     
209. TouchObserver.prototype.start = function () {
     
210.     if (this.running) { printl("[触摸] 已在运行"); return; }
     
211.     if (!this.device) { printl("[触摸] 无有效设备节点"); return; }
     
212. 
     
213.     var target = this;
     
214.     target.running = true;
     
215. 
     
216.     // AIWROK 正确的线程写法：new thread().runJsCode(fn, "线程名")
     
217.     var t = new thread();
     
218.     target._thread = t;
     
219.     t.runJsCode(function () {
     
220.         try {
     
221.             var dev = target.device;
     
222.             var tmpFile = "/sdcard/aiwrok_touch_events.log";
     
223.             target._tmpFile = tmpFile;
     
224. 
     
225.             // 先杀掉可能残留的旧 getevent 进程，避免重复输出
     
226.             try { agent.shell("su -c 'pkill -9 -f getevent'"); } catch (e) {}
     
227.             java.lang.Thread.sleep(200);
     
228. 
     
229.             // 清理旧文件
     
230.             try { agent.shell("su -c 'rm -f " + tmpFile + "'"); } catch (e) {}
     
231. 
     
232.             // 后台运行 getevent，输出重定向到临时文件
     
233.             var bgCmd = "su -c 'getevent -lt /dev/input/" + dev + " > " + tmpFile + " 2>&1 &'";
     
234.             printl("[触摸] 启动 getevent: " + bgCmd);
     
235.             agent.shell(bgCmd);
     
236. 
     
237.             // 等一下让进程启动
     
238.             java.lang.Thread.sleep(500);
     
239. 
     
240.             printl("[触摸] ✓ 启动完成，去屏幕上滑动吧！");
     
241. 
     
242.             // 用 RandomAccessFile 自己的 readLine()，自己维护偏移量
     
243.             var raf = new java.io.RandomAccessFile(tmpFile, "r");
     
244.             var lastPos = 0;  // 上次读到的位置
     
245.             var gotFirst = false;
     
246. 
     
247.             while (target.running) {
     
248.                 try {
     
249.                     var curLen = raf.length();
     
250. 
     
251.                     if (curLen > lastPos) {
     
252.                         raf.seek(lastPos);
     
253.                         var line;
     
254.                         while ((line = raf.readLine()) !== null) {
     
255.                             if (!gotFirst) {
     
256.                                 gotFirst = true;
     
257.                                 printl("[触摸] ✓✓✓ 收到触摸事件！滑动中...");
     
258.                             }
     
259.                             target._parseLine(line);
     
260.                             lastPos = raf.getFilePointer();
     
261.                         }
     
262.                     }
     
263. 
     
264.                     java.lang.Thread.sleep(30);
     
265.                 } catch (ie) {
     
266.                     printl("[触摸] 读异常: " + ie.message);
     
267.                     break;
     
268.                 }
     
269.             }
     
270. 
     
271.             try { raf.close(); } catch (e) {}
     
272.             printl("[触摸] 监听线程已退出");
     
273.         } catch (e) {
     
274.             if (target.running) {
     
275.                 printl("[触摸] 线程异常: " + e.message);
     
276.             }
     
277.         }
     
278.     }, "触摸监听");
     
279. };
     
280. 
     
281. /** 解析一行 getevent 输出 */
     
282. TouchObserver.prototype._parseLine = function (line) {
     
283.     if (!line) return;
     
284. 
     
285.     // 雷电格式：
     
286.     // [    1950.000612] EV_ABS       ABS_MT_POSITION_X    00000385            
     
287.     // [    1950.152524] EV_ABS       ABS_MT_TRACKING_ID   ffffffff            
     
288.     // [    1950.152524] EV_KEY       BTN_TOUCH            UP                  
     
289.     // [    1952.376642] EV_ABS       ABS_MT_TRACKING_ID   00000096            
     
290.     // [    1952.376642] EV_KEY       BTN_TOUCH            DOWN               
     
291.     // [    1952.376642] EV_SYN       SYN_REPORT           00000000            
     
292. 
     
293.     // 直接字符串匹配，绕开 split 的各种坑
     
294.     var self = this;
     
295. 
     
296.     // ABS_MT_POSITION_X
     
297.     var xIdx = line.indexOf("ABS_MT_POSITION_X");
     
298.     if (xIdx >= 0) {
     
299.         var hex = line.substring(xIdx + "ABS_MT_POSITION_X".length).trim();
     
300.         var v = parseInt(hex, 16);
     
301.         // 过滤异常值：屏幕分辨率 1080x1920，超过 2000 或负数都是垃圾数据
     
302.         if (v >= 0 && v < 5000) self.currentX = v;
     
303.         return;
     
304.     }
     
305. 
     
306.     // ABS_MT_POSITION_Y
     
307.     var yIdx = line.indexOf("ABS_MT_POSITION_Y");
     
308.     if (yIdx >= 0) {
     
309.         var hex2 = line.substring(yIdx + "ABS_MT_POSITION_Y".length).trim();
     
310.         var v2 = parseInt(hex2, 16);
     
311.         if (v2 >= 0 && v2 < 5000) self.currentY = v2;
     
312.         return;
     
313.     }
     
314. 
     
315.     // ABS_MT_TRACKING_ID
     
316.     var tIdx = line.indexOf("ABS_MT_TRACKING_ID");
     
317.     if (tIdx >= 0) {
     
318.         var hex3 = line.substring(tIdx + "ABS_MT_TRACKING_ID".length).trim();
     
319.         var tid = parseInt(hex3, 16);
     
320.         if (tid < 0 || hex3.indexOf("ffffffff") >= 0) {
     
321.             // 抬起
     
322.             if (self.pointerDown) {
     
323.                 self.pointerDown = false;
     
324.                 self._downFired = false;
     
325.                 self._emit("up", {
     
326.                     x: self.currentX, y: self.currentY,
     
327.                     pointerId: self.currentPointer,
     
328.                     timestamp: java.lang.System.currentTimeMillis()
     
329.                 });
     
330.             }
     
331.         } else {
     
332.             // 按下
     
333.             self.currentPointer = tid;
     
334.             self.pointerDown = true;
     
335.             self._downFired = false;
     
336.         }
     
337.         return;
     
338.     }
     
339. 
     
340.     // BTN_TOUCH DOWN
     
341.     if (line.indexOf("BTN_TOUCH") >= 0 && line.indexOf("DOWN") >= 0) {
     
342.         self.pointerDown = true;
     
343.         self._downFired = false;
     
344.         return;
     
345.     }
     
346. 
     
347.     // BTN_TOUCH UP
     
348.     if (line.indexOf("BTN_TOUCH") >= 0 && line.indexOf("UP") >= 0) {
     
349.         if (self.pointerDown) {
     
350.             self.pointerDown = false;
     
351.             self._downFired = false;
     
352.             self._emit("up", {
     
353.                 x: self.currentX, y: self.currentY,
     
354.                 pointerId: self.currentPointer,
     
355.                 timestamp: java.lang.System.currentTimeMillis()
     
356.             });
     
357.         }
     
358.         return;
     
359.     }
     
360. 
     
361.     // SYN_REPORT —— 一帧数据结束，触发回调
     
362.     if (line.indexOf("SYN_REPORT") >= 0) {
     
363.         if (self.pointerDown && self.currentX >= 0 && self.currentY >= 0) {
     
364.             if (!self._downFired) {
     
365.                 self._downFired = true;
     
366.                 self._emit("down", {
     
367.                     x: self.currentX, y: self.currentY,
     
368.                     pointerId: self.currentPointer,
     
369.                     timestamp: java.lang.System.currentTimeMillis()
     
370.                 });
     
371.             } else {
     
372.                 self._emit("move", {
     
373.                     x: self.currentX, y: self.currentY,
     
374.                     pointerId: self.currentPointer,
     
375.                     timestamp: java.lang.System.currentTimeMillis()
     
376.                 });
     
377.             }
     
378.         }
     
379.         return;
     
380.     }
     
381. };
     
382. 
     
383. TouchObserver.prototype.stop = function () {
     
384.     this.running = false;
     
385.     // 用 agent.shell kill 后台 getevent 进程
     
386.     try {
     
387.         agent.shell("su -c 'pkill -f getevent'");
     
388.     } catch (e) {}
     
389.     // 清理临时文件
     
390.     try {
     
391.         if (this._tmpFile) {
     
392.             agent.shell("su -c 'rm -f " + this._tmpFile + "'");
     
393.         }
     
394.     } catch (e) {}
     
395.     if (this.process) {
     
396.         try { this.process.destroy(); } catch (e) {}
     
397.         this.process = null;
     
398.     }
     
399.     if (this._thread) {
     
400.         try { this._thread.stop(); } catch (e) {}
     
401.         this._thread = null;
     
402.     }
     
403.     printl("[触摸] 已停止");
     
404. };
     
405. 
     
406. // ======================== 统一入口 observeTouch ========================
     
407. 
     
408. var _currentObserver = null;
     
409. 
     
410. /**
     
411. * 启动屏幕触摸监听（模拟 Hamibot events.observeTouch）
     
412. * @param {Object} options
     
413. * @param {Function} [options.onTouchDown]  按下回调 function(event){}
     
414. * @param {Function} [options.onTouchMove]  移动回调 function(event){}
     
415. * @param {Function} [options.onTouchUp]    抬起回调 function(event){}
     
416. * @param {Function} [options.onTouch]      统一回调 function(type, event){}
     
417. * @returns {TouchObserver} 可调用 .stop() 停止；无 root 返回 null
     
418. *
     
419. * event 结构: { x, y, pointerId, timestamp }
     
420. * type: "down" | "move" | "up"
     
421. */
     
422. function observeTouch(options) {
     
423.     options = options || {};
     
424. 
     
425.     if (!isRootAvailable()) {
     
426.         printl("✗ observeTouch 需要 root 权限，当前设备无 root");
     
427.         printl("  雷电 / 夜神 / 逍遥 模拟器默认自带 root");
     
428.         return null;
     
429.     }
     
430. 
     
431.     printl("🔍 正在检测触摸设备节点...");
     
432.     var device = findTouchEventDevice();
     
433.     if (!device) {
     
434.         printl("✗ 找不到触摸设备节点");
     
435.         return null;
     
436.     }
     
437.     printl("✓ 触摸设备: /dev/input/" + device);
     
438. 
     
439.     var obs = new TouchObserver(device);
     
440.     if (typeof options.onTouchDown === "function") obs.onDown(options.onTouchDown);
     
441.     if (typeof options.onTouchMove === "function") obs.onMove(options.onTouchMove);
     
442.     if (typeof options.onTouchUp   === "function") obs.onUp(options.onTouchUp);
     
443.     if (typeof options.onTouch     === "function") obs.onTouch(options.onTouch);
     
444. 
     
445.     obs.start();
     
446.     _currentObserver = obs;
     
447.     return obs;
     
448. }
     
449. 
     
450. /** 停止全局触摸监听 */
     
451. function stopObserveTouch() {
     
452.     if (_currentObserver) {
     
453.         _currentObserver.stop();
     
454.         _currentObserver = null;
     
455.     }
     
456. }
     
457. 
     
458. // ======================== demo ========================
     
459. 
     
460. function demo() {
     
461.     printl("╔══════════════════════════════════════════════╗");
     
462.     printl("║   AIWROK 屏幕触摸事件监听 - 演示             ║");
     
463.     printl("╚══════════════════════════════════════════════╝");
     
464.     sleep.millisecond(600);
     
465. 
     
466.     // ---- 步骤 1: 检查 root ----
     
467.     printl("\n🔐 [1/4] 检查 root 权限...");
     
468.     sleep.millisecond(300);
     
469.     var hasRoot = isRootAvailable();
     
470.     printl("  root 权限: " + (hasRoot ? "✓ 可用" : "✗ 不可用"));
     
471.     sleep.millisecond(800);
     
472. 
     
473.     if (!hasRoot) {
     
474.         printl("\n⚠️  无 root，演示停止。请先 root 设备后再试。");
     
475.         return;
     
476.     }
     
477. 
     
478.     // ---- 步骤 2: 找设备 ----
     
479.     printl("\n🔍 [2/4] 扫描触摸设备节点...");
     
480.     sleep.millisecond(300);
     
481.     var device = findTouchEventDevice();
     
482.     if (device) {
     
483.         printl("  ✓ 找到: /dev/input/" + device);
     
484.     } else {
     
485.         printl("  ✗ 未找到触摸设备");
     
486.         return;
     
487.     }
     
488.     sleep.millisecond(800);
     
489. 
     
490.     // ---- 步骤 3: 启动监听 ----
     
491.     printl("\n👆 [3/4] 启动触摸监听");
     
492.     sleep.millisecond(300);
     
493.     printl("  👉 请在屏幕上滑动/点击，观察日志");
     
494.     printl("  15 秒后自动停止（也可手动按停止按钮）");
     
495.     sleep.millisecond(500);
     
496. 
     
497.     var lastMoveLog = 0;  // 节流 move 日志
     
498.     var obs = observeTouch({
     
499.         onTouchDown: function (e) {
     
500.             printl("  🔽 DOWN   x=" + e.x + "  y=" + e.y);
     
501.         },
     
502.         onTouchMove: function (e) {
     
503.             // move 很密集，每 80ms 最多打一条
     
504.             var now = java.lang.System.currentTimeMillis();
     
505.             if (now - lastMoveLog > 80) {
     
506.                 lastMoveLog = now;
     
507.                 printl("  ➡️  MOVE   x=" + e.x + "  y=" + e.y);
     
508.             }
     
509.         },
     
510.         onTouchUp: function (e) {
     
511.             printl("  🔼 UP     x=" + e.x + "  y=" + e.y);
     
512.         }
     
513.     });
     
514. 
     
515.     // ---- 步骤 4: 15 秒后自动停 ----
     
516.     sleep.millisecond(15000);
     
517. 
     
518.     if (obs) obs.stop();
     
519. 
     
520.     printl("\n╔══════════════════════════════════════════════╗");
     
521.     printl("║              演示结束！                       ║");
     
522.     printl("║  observeTouch() 可直接集成到你的脚本          ║");
     
523.     printl("╚══════════════════════════════════════════════╝");
     
524. }
     
525. 
     
526. demo();
     

复制代码