offscreen-android 0.0.0-stage → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/src/vd.js ADDED
@@ -0,0 +1,2354 @@
1
+ /**
2
+ * vd.js — 私有虚拟屏(headless virtual display)的核心。
3
+ *
4
+ * 原理:用 uid 2000 调 scrcpy-server 的 `new_display`,它走
5
+ * DisplayManager.createNewVirtualDisplay,带回这些标志:
6
+ * FLAG_OWN_CONTENT_ONLY 内容不跟主屏同步(不是镜像)
7
+ * FLAG_OWN_FOCUS 不抢主屏焦点(Android 14+ 才有)
8
+ * FLAG_TRUSTED / FLAG_OWN_DISPLAY_GROUP / FLAG_PRESENTATION …
9
+ * 关键:**没有 FLAG_PUBLIC**,所以这块屏不画在物理屏幕上,用户完全看不见。
10
+ *
11
+ * 四个实测坑(都会让人白折腾半天):
12
+ * 1. socket 名是 `scrcpy_<scid>`,**有下划线**。写成 scrcpy<scid> 会连不上,
13
+ * server 卡在 accept 不建屏,日志只打到 "Device:" 那一行。
14
+ * 2. screencap -d 要的是 SurfaceFlinger 的 64 位 display id,不是逻辑 displayId。
15
+ * 传逻辑 id 会报 "Display Id '64' is not valid";不带 -d 就截到主屏,
16
+ * 于是看起来像"这块屏在镜像主屏",其实是截图截错了。
17
+ * 3. scrcpy-server 启动后会删自己的 jar(unlinkSelf),所以要放在 chmod 555 的目录里。
18
+ * 4. 客户端一断,server 退出、屏立刻消失。必须常驻一个哑客户端。
19
+ *
20
+ * 判据:`dumpsys display` 里看 **DisplayDeviceInfo** 那一行,
21
+ * 同时有 FLAG_OWN_CONTENT_ONLY + FLAG_OWN_FOCUS 才是"能托管 App"的屏。
22
+ * mBaseDisplayInfo 那一段永远不带这两个标志,别拿它判断(我踩过)。
23
+ */
24
+
25
+ import { execFile, execFileSync, spawn } from 'node:child_process';
26
+ import { promisify } from 'node:util';
27
+ import net from 'node:net';
28
+ import { mkdir, readFile, writeFile, access } from 'node:fs/promises';
29
+ import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
30
+ import { homedir } from 'node:os';
31
+ import { join, dirname } from 'node:path';
32
+ import { fileURLToPath } from 'node:url';
33
+ import { adbTarget } from './target.js';
34
+
35
+ const pexec = promisify(execFile);
36
+ const ADB = process.env.ADB_BIN || 'adb';
37
+ const REMOTE_DIR = '/data/local/tmp/dshvd';
38
+ const REMOTE_JAR = `${REMOTE_DIR}/scrcpy-server.jar`;
39
+ const SERVER_VER = '5.0.1';
40
+
41
+ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
42
+
43
+
44
+ /**
45
+ * watchFrames —— 高密度采样视频流帧计数,返回「变化时间线」
46
+ *
47
+ * ## 为什么需要它
48
+ *
49
+ * 现在 input() 里的 waitChanged 只回答「有没有变」,回答不了:
50
+ * - **什么时候变的**(点击后 50ms 就变,还是 800ms 才变)
51
+ * - **变了多久**(瞬时弹窗 300ms,还是一直保持)
52
+ * - **变化了几次**(弹出来又消失 = 两次变化)
53
+ *
54
+ * 「弹出又消失」这类瞬时状态,用首尾截图对比永远看不见。
55
+ * 帧计数是 **0 成本、约 30ms 分辨率**(34fps 流),采样它就能还原时间线。
56
+ *
57
+ * ## 返回
58
+ *
59
+ * ```
60
+ * {
61
+ * totalFrames: 期间新增总帧数,
62
+ * samples: [{ t, frames, delta }], // 时间线
63
+ * bursts: [{ startMs, endMs, frames }], // 连续重绘段
64
+ * firstChangeMs: 第一次重绘的时间点(相对开始),
65
+ * changed: bool
66
+ * }
67
+ * ```
68
+ */
69
+ export async function watchFrames(ms = 2000, intervalMs = 40) {
70
+ // **用 state.videoReader.frames(单调递增),不是 packets.length。**
71
+ // packets 数组有 PACKET_KEEP=400 上限,跑久了会饱和,饱和后 delta 恒为 0,
72
+ // 看起来像「画面不动」—— 这个坑之前踩过。
73
+ const rd = () => (state.videoReader ? state.videoReader.frames : 0);
74
+ const t0 = Date.now();
75
+ const samples = [];
76
+ let prev = rd();
77
+ while (Date.now() - t0 < ms) {
78
+ await sleep(intervalMs);
79
+ const cur = rd();
80
+ samples.push({ t: Date.now() - t0, frames: cur, delta: cur - prev });
81
+ prev = cur;
82
+ }
83
+ // 把连续有增量的采样合并成「重绘段」
84
+ const bursts = [];
85
+ let curBurst = null;
86
+ for (const sm of samples) {
87
+ if (sm.delta > 0) {
88
+ if (!curBurst) curBurst = { startMs: sm.t, endMs: sm.t, frames: 0 };
89
+ curBurst.endMs = sm.t;
90
+ curBurst.frames += sm.delta;
91
+ } else if (curBurst) {
92
+ // 允许 200ms 的空档,超过才算一段结束
93
+ if (sm.t - curBurst.endMs > 200) { bursts.push(curBurst); curBurst = null; }
94
+ }
95
+ }
96
+ if (curBurst) bursts.push(curBurst);
97
+ const totalFrames = samples.reduce((a, b) => a + b.delta, 0);
98
+ return {
99
+ totalFrames,
100
+ samples,
101
+ bursts,
102
+ firstChangeMs: bursts.length ? bursts[0].startMs : null,
103
+ changed: totalFrames > 0,
104
+ };
105
+ }
106
+
107
+ export async function adb(args, timeout = 30000) {
108
+ try {
109
+ // 目标地址每次现取:adb 插件会把 adbd 迁到别的端口并写在 state.json 里。
110
+ const target = await adbTarget();
111
+ const { stdout, stderr } = await pexec(ADB, ['-s', target, ...args], { timeout, maxBuffer: 16 * 1024 * 1024 });
112
+ return { ok: true, out: stdout || '', err: stderr || '' };
113
+ } catch (e) {
114
+ const out = typeof e.stdout === 'string' ? e.stdout : '';
115
+ const err = typeof e.stderr === 'string' && e.stderr ? e.stderr : String(e.message || e);
116
+ return { ok: false, out, err };
117
+ }
118
+ }
119
+
120
+ export async function shell(cmd, timeout = 30000) {
121
+ const r = await adb(['shell', cmd], timeout);
122
+ return `${r.out}${r.err}`.trim();
123
+ }
124
+
125
+ /** 插件自带的 jar 路径(打包在 assets 里)。 */
126
+ function localJar() {
127
+ // import.meta.url 在常规 ESM 下是有的,但宿主用 bundle 方式加载插件时会是 undefined,
128
+ // 实测表现:vdisplay_start 直接报
129
+ // The "path" argument must be of type string or an instance of URL. Received undefined
130
+ // 这是发布版必须兜住的坑——不能假设宿主一定按 ESM 文件加载。
131
+ // 三级兜底,取第一个真实存在的:
132
+ // ① 常规 ESM:从模块自身位置往上找 assets/
133
+ // ② 环境变量 DSH_SCREEN_JAR(给特殊部署留的口子)
134
+ // ③ 从 DSH_HOME 推 profile 里的安装位置
135
+ const cands = [];
136
+ try {
137
+ const u = import.meta?.url;
138
+ if (typeof u === 'string' && u) {
139
+ cands.push(join(dirname(fileURLToPath(u)), '..', 'assets', 'scrcpy-server.jar'));
140
+ }
141
+ } catch { /* import.meta.url 不可用,走后面的兜底 */ }
142
+ if (process.env.DSH_SCREEN_JAR) cands.push(process.env.DSH_SCREEN_JAR);
143
+ const home = process.env.DSH_HOME || join(homedir(), '.dsh');
144
+ // 不写死 profile 名:别人可能装在 web / desktop / 自建 profile 下,逐个扫一遍。
145
+ const profilesDir = join(home, 'profiles');
146
+ try {
147
+ for (const p of readdirSync(profilesDir)) {
148
+ cands.push(join(profilesDir, p, 'node_modules', 'dsh-go-plugin-screen', 'assets', 'scrcpy-server.jar'));
149
+ }
150
+ } catch { /* 没有 profiles 目录就跳过 */ }
151
+
152
+ for (const c of cands) {
153
+ try { if (existsSync(c)) return c; } catch { /* ignore */ }
154
+ }
155
+ return cands[0]; // 一个都不存在时返回首选,交给调用方报清晰的错
156
+ }
157
+
158
+ /** 确保设备上有 jar,且在 555 目录里(防自杀)。 */
159
+ export async function ensureJar() {
160
+ const local = localJar();
161
+ let localSize = 0;
162
+ try {
163
+ const { stat } = await import('node:fs/promises');
164
+ localSize = (await stat(local)).size;
165
+ } catch { /* 见下面的报错 */ }
166
+
167
+ // 目录必须可写才推得进去。早期版本推完会把目录 chmod 555「保护」起来,
168
+ // 结果是**永远无法升级 jar**,而且一旦目录已是 555 又缺 jar,就直接死锁
169
+ // (实测 push 报 Permission denied)。所以每次先确保可写。
170
+ await shell(`mkdir -p ${REMOTE_DIR} 2>/dev/null; chmod 777 ${REMOTE_DIR} 2>/dev/null`);
171
+
172
+ const remoteSize = await shell(`stat -c '%s' ${REMOTE_JAR} 2>/dev/null || echo 0`);
173
+ const have = Number(String(remoteSize).trim()) || 0;
174
+
175
+ if (!localSize) {
176
+ if (have > 0) {
177
+ // **必须把 jar 设成 444 并且目录设成 555。**
178
+ // scrcpy-server 启动时会 unlinkSelf(删自己),目录可写就删得掉 ——
179
+ // 然后下一次启动就 Aborted,而报错只有一句「Aborted」,极难定位。
180
+ // 这个坑代码注释里写着,但实现一直用 chmod 777 目录,等于没防。
181
+ await shell(`chmod 444 ${REMOTE_JAR} 2>/dev/null; chmod 555 ${REMOTE_DIR} 2>/dev/null`);
182
+ return { ok: true, existed: true, remote: REMOTE_JAR, hint: '插件包里没有 jar,用设备上已有的(版本可能与客户端不匹配)' };
183
+ }
184
+ return { ok: false, hint: `设备上没有 jar,插件包里也没有:${local}(需要 scrcpy-server-v${SERVER_VER},可从 GitHub 下载放进 assets/)` };
185
+ }
186
+
187
+ // 大小一致就当作同一个版本,跳过推送(省一次 700KB 传输)
188
+ if (have === localSize) {
189
+ // **必须把 jar 设成 444 并且目录设成 555。**
190
+ // scrcpy-server 启动时会 unlinkSelf(删自己),目录可写就删得掉 ——
191
+ // 然后下一次启动就 Aborted,而报错只有一句「Aborted」,极难定位。
192
+ // 这个坑代码注释里写着,但实现一直用 chmod 777 目录,等于没防。
193
+ await shell(`chmod 444 ${REMOTE_JAR} 2>/dev/null; chmod 555 ${REMOTE_DIR} 2>/dev/null`);
194
+ return { ok: true, existed: true, remote: REMOTE_JAR };
195
+ }
196
+
197
+ const p = await adb(['push', local, REMOTE_JAR], 120000);
198
+ if (!p.ok) return { ok: false, hint: `推送 jar 失败:${p.err}` };
199
+ // 文件本身设只读(防误改),目录保持可写(否则下次升级又会失败)
200
+ // **必须把 jar 设成 444 并且目录设成 555。**
201
+ // scrcpy-server 启动时会 unlinkSelf(删自己),目录可写就删得掉 ——
202
+ // 然后下一次启动就 Aborted,而报错只有一句「Aborted」,极难定位。
203
+ // 这个坑代码注释里写着,但实现一直用 chmod 777 目录,等于没防。
204
+ await shell(`chmod 444 ${REMOTE_JAR} 2>/dev/null; chmod 555 ${REMOTE_DIR} 2>/dev/null`);
205
+ return { ok: true, existed: false, remote: REMOTE_JAR, hint: have > 0 ? 'jar 版本已更新' : '' };
206
+ }
207
+
208
+ /** 列出当前的 displayId 集合,用于差集。 */
209
+ /**
210
+ * 读屏 id 列表。
211
+ * **查询失败时返回 null**,而不是空集合——空集和"屏真的没了"无法区分,
212
+ * 早期版本因此把一次 adb 抖动当成"虚拟屏消失",直接把正常屏拆了重建
213
+ * (复核实测:单次失败 3.6 秒后重建、旧屏上 App 的上下文全丢)。
214
+ */
215
+ async function displayIds() {
216
+ const out = await shell(`dumpsys display 2>/dev/null | grep -oE "mDisplayId=[0-9]+" | sort -u`);
217
+ if (!String(out || '').trim() || /error|not found|failed/i.test(String(out))) return null;
218
+ return new Set(out.split('\n').map((s) => s.replace('mDisplayId=', '').trim()).filter(Boolean));
219
+ }
220
+
221
+ async function sfIds() {
222
+ // 不要先 grep 再判空:grep 无匹配时输出为空,和"dumpsys 查询失败"长得一模一样,
223
+ // 于是屏真的没了也会被当成"查询失败",alive() 保守判活,start() 复用一块死屏,
224
+ // 最后 am start --display 抛 SecurityException(性能测试那路实测踩到)。
225
+ // 现在拿全量输出:只要里面有 Display 行,就说明 dumpsys 正常工作过,
226
+ // 此时"没有 scrcpy 行"= 确实不存在虚拟屏,返回空集合。
227
+ const out = await shell(`dumpsys SurfaceFlinger --display-id 2>/dev/null`);
228
+ const text = String(out || '');
229
+ if (!/Display\s+\d+/.test(text)) return null; // 一行 Display 都没有 → 查询失败
230
+ const ids = new Set();
231
+ for (const line of text.split('\n')) {
232
+ if (!/scrcpy/i.test(line)) continue;
233
+ const m = line.match(/Display\s+(\d+)/);
234
+ if (m) ids.add(m[1]);
235
+ }
236
+ return ids; // 空集合 = 确实没有 scrcpy 虚拟屏,不是查询失败
237
+ }
238
+
239
+ /* ═══ 虚拟屏状态持久化 ═══
240
+ *
241
+ * 为什么必须做:state 是进程内的。DSH 引擎重启、插件热重载、或者任何一个
242
+ * 新 Node 进程调工具时,state.displayId 都是 null → alive() 直接判死 →
243
+ * start() 又建一块新屏。
244
+ *
245
+ * 实机表现(用户报的):
246
+ * · display 号一路涨:448 → 452 → 453 → 457 → 460
247
+ * · framesrv/悬浮窗还指着旧屏 → 画面看起来"变成前台画面"
248
+ * · 屏越积越多,stop 也停不对
249
+ *
250
+ * 修法:把 displayId/sfId/scid 写盘,模块加载时读回来。
251
+ */
252
+ const VD_STATE_FILE = join(homedir(), '.dsh', 'plugin-screen', 'vdisplay.json');
253
+ let _vdRestored = false;
254
+
255
+ function loadPersistedState() {
256
+ if (_vdRestored) return;
257
+ _vdRestored = true;
258
+ try {
259
+ const j = JSON.parse(readFileSync(VD_STATE_FILE, 'utf8'));
260
+ if (j && j.displayId) {
261
+ state.displayId = j.displayId;
262
+ state.sfId = j.sfId || null;
263
+ state.scid = j.scid || null;
264
+ if (j.width) state.width = j.width;
265
+ if (j.height) state.height = j.height;
266
+ state.startedAt = j.startedAt || 0;
267
+ }
268
+ } catch { /* 没有或读坏了就算了 */ }
269
+ }
270
+
271
+ function savePersistedState() {
272
+ try {
273
+ mkdirSync(dirname(VD_STATE_FILE), { recursive: true });
274
+ writeFileSync(VD_STATE_FILE, JSON.stringify({
275
+ displayId: state.displayId, sfId: state.sfId, scid: state.scid,
276
+ width: state.width, height: state.height, startedAt: state.startedAt,
277
+ at: Date.now(),
278
+ }));
279
+ } catch { /* ignore */ }
280
+ }
281
+
282
+ function clearPersistedState() {
283
+ try { rmSync(VD_STATE_FILE, { force: true }); } catch { /* ignore */ }
284
+ }
285
+
286
+ /**
287
+ * 一块屏的完整上下文。
288
+ *
289
+ * **为什么改成工厂函数**:多屏需要 N 份独立的 state(各自的 displayId、sockets、
290
+ * 截图缓存)。原来 `const state = {...}` 是模块级单例,148 处引用全都指着它。
291
+ *
292
+ * 改成「一个可切换的当前上下文」是改动最小的做法:
293
+ * · 所有 148 处 `state.xxx` 逻辑一行不用动
294
+ * · pool 切换时执行 `setActive(ctx)`,之后的调用自然作用在那块屏上
295
+ * · 没有并发问题,因为 daemon 已经把有副作用的命令串行化了
296
+ */
297
+ /**
298
+ * 清掉「上一次截图」留下的全部坐标基准。
299
+ *
300
+ * **必须一次清全 8 个字段。** 原来 stop() 只清 3 个(hash/path/imgWidth),
301
+ * 漏了 lastShotRegion 和 lastShotImgHeight —— 于是 `shot(region) → stop → start → 点击`
302
+ * 会拿上一块屏的 region 偏移和缩放比去换算,点歪(对抗审查 S15)。
303
+ *
304
+ * forget() 当时清了 region,stop() 没清,两处不一致本身就是 bug 的温床。
305
+ */
306
+ /**
307
+ * 清理 /tmp 里过期的截图。
308
+ *
309
+ * **为什么必须有**:每次截图写一个 vd-<时间戳>.png(720×1592 约 1-1.5MB),
310
+ * 从不删除。`/tmp` 在 proot 里是 tmpfs —— 占的是内存。
311
+ * 几十次视觉调用后就是几十上百 MB 常驻,用户只看到"内存怎么越来越少"。
312
+ *
313
+ * 策略:每次截图后顺手清一次,只留最近 20 个、且删除超过 10 分钟的。
314
+ * 同步操作很快(一个目录枚举 + 若干 unlink),不影响截图延迟。
315
+ */
316
+ let lastJanitorAt = 0;
317
+ function cleanShotDir(dir = '/tmp') {
318
+ const now = Date.now();
319
+ if (now - lastJanitorAt < 30_000) return; // 最多 30 秒清一次
320
+ lastJanitorAt = now;
321
+ try {
322
+ const names = readdirSync(dir).filter((f) => /^(vd|main)-\d+\.png$/.test(f));
323
+ if (names.length <= 20) {
324
+ // 数量不多时只删超龄的
325
+ for (const f of names) {
326
+ try {
327
+ const st2 = statSync(`${dir}/${f}`);
328
+ if (now - st2.mtimeMs > 600_000) rmSync(`${dir}/${f}`, { force: true });
329
+ } catch { /* ignore */ }
330
+ }
331
+ return;
332
+ }
333
+ // 按名字里的时间戳排序(就是生成顺序),删最老的
334
+ const sorted = names.slice().sort((a, b) => {
335
+ const ta = Number((a.match(/(\d+)\.png$/) || [])[1] || 0);
336
+ const tb = Number((b.match(/(\d+)\.png$/) || [])[1] || 0);
337
+ return ta - tb;
338
+ });
339
+ for (const f of sorted.slice(0, sorted.length - 20)) {
340
+ try { rmSync(`${dir}/${f}`, { force: true }); } catch { /* ignore */ }
341
+ }
342
+ } catch { /* 清理失败不影响截图 */ }
343
+ }
344
+
345
+ function resetShotBasis() {
346
+ state.lastShotHash = null;
347
+ state.lastShotPath = null;
348
+ state.lastShotImgWidth = 0;
349
+ state.lastShotImgHeight = 0;
350
+ state.lastShotW = 0;
351
+ state.lastShotH = 0;
352
+ state.lastShotRegion = null;
353
+ state.lastShotCacheKey = null;
354
+ }
355
+
356
+ function makeState() {
357
+ return {
358
+ child: null,
359
+ sockets: [],
360
+ // 视频流解析状态(src/video.js)。以前 socket[0] 的数据是直接丢掉的,
361
+ // 现在喂给它 —— 实测这条流是 720x1592 的 H.264,约 25fps。
362
+ videoReader: null,
363
+ scid: null,
364
+ port: null,
365
+ displayId: null,
366
+ sfId: null,
367
+ width: 720,
368
+ height: 1280,
369
+ startedAt: 0,
370
+ lastShotHash: null,
371
+ lastShotPath: null,
372
+ lastShotImgWidth: 0,
373
+ systemDecorations: false,
374
+ hwc: null, // 建屏时请求的 hwc 值('auto'/'on'/'off')。
375
+ // **之前没有这个字段**,导致 :292 的
376
+ // `state.hwc !== hwc` 恒真 —— 复用一块
377
+ // 已经开着 HWC 的屏时也会报"请求 hwc=on,实际 undefined"。
378
+ dpi: 320, // 建屏时用的 dpi,池用来做身份金丝雀
379
+ launchedPkgs: [],
380
+ // HWC 虚拟屏:部分 Qualcomm 设备的 HWC 支持合成虚拟屏,能让 3D 游戏不再黑屏。
381
+ // hwcPrev 记的是开启前的原值,hwcChanged 表示这次是不是我们改的——只恢复自己改过的。
382
+ hwcPrev: null,
383
+ hwcChanged: false,
384
+ lastSizeCheckAt: 0,
385
+ };
386
+ }
387
+
388
+ /** 当前活动的屏幕上下文。pool 通过 setActive() 切换它。 */
389
+ let state = makeState();
390
+
391
+ /** 取出当前上下文(pool 用,用来保存/恢复) */
392
+ export function getActive() { return state; }
393
+
394
+ /**
395
+ * 切换当前活动屏。
396
+ * @param {object} ctx 之前的 getActive() 返回值,或新的 makeState()
397
+ */
398
+ export function setActive(ctx) {
399
+ state = ctx || makeState();
400
+ }
401
+
402
+ /** 新造一个空上下文(pool 建新屏时用) */
403
+ export function newContext() { return makeState(); }
404
+
405
+ /** 建一块私有虚拟屏。返回 {ok, displayId, sfId} */
406
+ export async function start({ width = 0, height = 0, dpi = 320, systemDecorations = false, orientation = 'auto', hwc = 'auto', maxFps = 60, imePolicy = 'hide' } = {}) {
407
+ // 记下调用方有没有显式传尺寸 —— square 分支靠它决定用默认值还是尊重传入值
408
+ const explicitSize = width > 0 && height > 0;
409
+
410
+ // **尺寸自动探测**:不传 width/height 时按物理屏比例生成同比例的虚拟屏。
411
+ // 虚拟屏是合成的(scrcpy new_display),跟物理屏大小无关,但比例会影响 App 的
412
+ // 布局判断(平板/手机模式、横竖屏)。写死 720x1280 在 9:19.4 的屏上窄 25%,
413
+ // 少数 App 会进错布局。默认值从设备真实比例推,换手机也适用。
414
+ if (!width || !height) {
415
+ let pw = 0;
416
+ let ph = 0;
417
+ try {
418
+ const r = await shell('wm size 2>/dev/null');
419
+ const m = String(r || '').match(/(\d+)x(\d+)/);
420
+ if (m) { pw = Number(m[1]); ph = Number(m[2]); }
421
+ } catch { /* 拿不到就用兜底 */ }
422
+ if (pw > 0 && ph > 0) {
423
+ // 宽度基准 720,长边不超过 1600(太高的屏会拖慢截图和编码)
424
+ const scale = Math.min(720 / pw, 1600 / ph);
425
+ width = Math.max(320, Math.round(pw * scale));
426
+ height = Math.max(320, Math.round(ph * scale));
427
+ } else {
428
+ width = 720; height = 1280;
429
+ }
430
+ }
431
+
432
+ // 处理 orientation 参数:landscape 时自动交换宽高
433
+ let finalWidth = width;
434
+ let finalHeight = height;
435
+ if (orientation === 'landscape') {
436
+ // 横屏:确保宽 > 高
437
+ if (width < height) {
438
+ finalWidth = height;
439
+ finalHeight = width;
440
+ }
441
+ } else if (orientation === 'portrait') {
442
+ // 竖屏:确保高 > 宽
443
+ if (width > height) {
444
+ finalWidth = height;
445
+ finalHeight = width;
446
+ }
447
+ } else if (orientation === 'square') {
448
+ /* **正方形:旋转不变的尺寸。**
449
+ *
450
+ * 虚拟屏带 FLAG_ROTATES_WITH_CONTENT —— App 强制横屏时屏的**尺寸会真的变**
451
+ * (720×1592 → 1592×720),而取帧服务的镜像是建的时候定死的,
452
+ * 结果投横屏游戏时画面挤在顶部一条、其余全黑(2026-11-20 实测)。
453
+ *
454
+ * 720×720 转 90° 还是 720×720,**尺寸不变**,从根上绕开这个问题。
455
+ *
456
+ * 边长取「短边」再夹在 720~1080:太小横屏游戏看不清,太大拖慢编码。
457
+ */
458
+ /* **边长 1080px,不是短边。**
459
+ *
460
+ * dpi 320 时 dp = px/2:
461
+ * 720×720 = 360dp ⚠️ 低于「正常屏」门槛 470dp,部分 App 进小屏布局
462
+ * 1080×1080 = 540dp ✅ 高于 470dp、低于平板门槛 600dp —— 唯一两边都安全
463
+ * 1280×1280 = 640dp ⚠️ 触发 sw600dp,微信/Chrome/设置切平板双栏
464
+ *
465
+ * 之前按「短边」算,720 宽的屏上会给出 720×720,正好踩进风险区。
466
+ * 调用方显式传了 width/height 就尊重它(夹在 720~1080)。
467
+ */
468
+ const side = explicitSize
469
+ ? Math.min(1080, Math.max(720, Math.min(width, height)))
470
+ : 1080;
471
+ finalWidth = side;
472
+ finalHeight = side;
473
+ }
474
+ // 如果 orientation 是具体数值(旋转角度),这里暂时不处理,
475
+ // 因为 scrcpy new_display 不直接支持旋转参数,只支持尺寸。
476
+ // 旋转由 App 自己根据屏幕尺寸判断(横屏 App 看到宽>高的屏会自动横屏)。
477
+ if (state.displayId) {
478
+ /* **只要屏还活着就复用,配置不同只提示不重建。**
479
+ *
480
+ * 以前的逻辑只比较 systemDecorations,尺寸/DPI/方向全不比 —— 于是:
481
+ * · 有人显式建了带装饰的屏,别处一句 start()(默认 false)就把它拆了,
482
+ * 屏上的 App 一起没了,工具还报"就绪"
483
+ * · 更糟的是 forget() 不清 hwcPrev,重建时 getprop 已经是 1,
484
+ * 于是 hwcPrev 被记成 '1',stop 时又恢复成 1,全局 HWC 残留到重启
485
+ *
486
+ * 现在的取舍:**拆掉一个正在用的屏,代价远大于配置和请求不一致**。
487
+ * 所以活着就复用,把差异如实说出来,让调用方自己决定要不要 stop 再建。
488
+ */
489
+ // **复用检查带 1.5 秒 TTL**:连着截图时省掉 3 次 dumpsys(实测省 ~250ms/次)。
490
+ const nowReuse = Date.now();
491
+ const reuseFresh = lastReuseResult && (nowReuse - lastReuseCheckAt) < REUSE_TTL_MS;
492
+ const isAlive = reuseFresh ? lastReuseResult.alive : await alive();
493
+ if (!reuseFresh) { lastReuseCheckAt = nowReuse; lastReuseResult = { alive: isAlive }; }
494
+ if (isAlive) {
495
+ const fl = reuseFresh && lastReuseResult.fl
496
+ ? lastReuseResult.fl
497
+ : await shell('dumpsys display 2>/dev/null | grep "DisplayDeviceInfo.*scrcpy" | head -1');
498
+ if (!reuseFresh) lastReuseResult.fl = fl;
499
+ const wantW = width; const wantH = height;
500
+ const diff = [];
501
+ if (wantW && wantH && (wantW !== state.width || wantH !== state.height)) {
502
+ diff.push(`请求 ${wantW}x${wantH},实际 ${state.width}x${state.height}`);
503
+ }
504
+ if (state.systemDecorations !== systemDecorations) {
505
+ diff.push(`请求 decorations=${systemDecorations},实际 ${state.systemDecorations}`);
506
+ }
507
+ if (state.hwc !== hwc && hwc !== 'auto') {
508
+ diff.push(`请求 hwc=${hwc},实际 ${state.hwc}`);
509
+ }
510
+ savePersistedState(); // 复用也刷新一下,保证文件里的值是最新的
511
+ return {
512
+ ok: true, displayId: state.displayId, sfId: state.sfId, reused: true,
513
+ width: state.width, height: state.height,
514
+ canHost: /FLAG_OWN_CONTENT_ONLY/.test(fl) && /FLAG_OWN_FOCUS/.test(fl),
515
+ flags: (fl.match(/FLAG_[A-Z_]+/g) || []).join(' '),
516
+ // 复用分支以前不返回 hwc,调用方只能当'未开启',于是一个 HWC 开着的屏
517
+ // 会被报成'3D 游戏会黑屏';实际开没开要看真实属性,不是猜。
518
+ hwc: (await shell('getprop debug.sf.enable_hwc_vds').catch(() => '')).trim() === '1',
519
+ // 配置和请求不一致时明确告诉调用方,不要假装按请求建了
520
+ configMismatch: diff.length ? diff.join(';') : null,
521
+ };
522
+ }
523
+ // 走到这里说明记着有屏但实际已经没了(server 被回收 / adb 断开 / 被 pkill),
524
+ // 或者是调用方明确要换配置。清干净重来,别继续报"已就绪"骗调用方。
525
+ forget('旧屏已失效,重建');
526
+ }
527
+
528
+ const jar = await ensureJar();
529
+ if (!jar.ok) return { ok: false, hint: jar.hint };
530
+
531
+ // 权限前提:shell 必须有 ADD_TRUSTED_DISPLAY(本机有,Pixel 没有)
532
+ const perm = await shell(`dumpsys package com.android.shell 2>/dev/null | grep -c "ADD_TRUSTED_DISPLAY: granted=true"`);
533
+ if (Number(perm.trim()) === 0) {
534
+ return { ok: false, hint: '这台机器的 com.android.shell 没有 ADD_TRUSTED_DISPLAY 权限,私有虚拟屏起不来(scrcpy 官方 issue #5523)。这条路只在一部分机型上可用。' };
535
+ }
536
+
537
+ // displayIds/sfIds 查询失败会返回 null,这里兜底成空集合(start 时还没有旧屏可比)
538
+ const before = (await displayIds()) || new Set();
539
+ const beforeSf = (await sfIds()) || new Set();
540
+
541
+ // scid 会被 scrcpy 用 Integer.parseInt(radix 16) 解析,必须是**有符号 32 位**内的正整数。
542
+ // 用 0xffffffff 随机会得到 cd7bccd6 这种超范围值,server 直接 NumberFormatException 退出(踩过)。
543
+ // ---- HWC 虚拟屏(让 3D 游戏不再黑屏)----
544
+ // 背景:虚拟屏默认走 GPU 软件合成,SurfaceView 拿不到硬件叠加层 → 3D 游戏全黑。
545
+ // 实测 REDMAGIC NX809J(Adreno 8 Gen 3):vendor.display.vds_allow_hwc=1 但
546
+ // debug.sf.enable_hwc_vds=0,把它置 1 后王者荣耀在虚拟屏正常渲染。
547
+ //
548
+ // 这是**全局** SurfaceFlinger 属性,会影响整台设备,所以:
549
+ // 1. 只在硬件声明支持(vds_allow_hwc=1)时才开,不盲开;
550
+ // 2. 记下原值,stop() 时只恢复我们自己改过的那种;
551
+ // 3. 任何一步失败都静默降级,不能因为开不了 HWC 就建不了屏。
552
+ // 它是 debug.* 属性,重启设备自动复原,不会留下永久改动。
553
+ if (hwc !== 'off') {
554
+ const allow = (await shell('getprop vendor.display.vds_allow_hwc')).trim();
555
+ if (allow === '1' || hwc === 'on') {
556
+ const prev = (await shell('getprop debug.sf.enable_hwc_vds')).trim() || '0';
557
+ state.hwcPrev = prev;
558
+ if (prev !== '1') {
559
+ await shell('setprop debug.sf.enable_hwc_vds 1');
560
+ const now = (await shell('getprop debug.sf.enable_hwc_vds')).trim();
561
+ state.hwcChanged = now === '1';
562
+ }
563
+ }
564
+ }
565
+
566
+ const scid = (1 + Math.floor(Math.random() * 0x7ffffffe)).toString(16).padStart(8, '0');
567
+ const port = 28000 + Math.floor(Math.random() * 900);
568
+ state.scid = scid;
569
+ state.port = port;
570
+
571
+ const target = await adbTarget();
572
+ await adb(['forward', `tcp:${port}`, `localabstract:scrcpy_${scid}`]);
573
+
574
+ const cmd = `CLASSPATH=${REMOTE_JAR} app_process / com.genymobile.scrcpy.Server ${SERVER_VER} `
575
+ // display_ime_policy 三个取值(从 scrcpy-server dex 挖出来的):
576
+ // hide 默认,虚拟屏上没有输入法,打字打不进去
577
+ // local 输入法渲染到这块虚拟屏上,打字能用
578
+ // fallback_display 回退到默认屏
579
+ //
580
+ // 默认 hide 是必须的:不加这个,虚拟屏上的输入框会把系统输入法焦点
581
+ // 抢过去(实测 mDisplayIdToShowIme 会变成虚拟屏的 id),用户在主屏打字时键盘就没了。
582
+ // 代价:虚拟屏上也打不了字(没有输入法连接),所以文字要么用深链带参数进去,要么用坐标点选。
583
+ // vd_system_decorations=false(scrcpy ≥3.1):不加这个,虚拟屏上会自带
584
+ // 二级桌面 launcher、导航栏和权限弹窗——AI 截图会把这些系统 UI 一起截进去,
585
+ // 以为是自己要操作的界面。实测关掉后屏上窗口数=0,画面干净。
586
+ + `log_level=info tunnel_forward=true display_ime_policy=${imePolicy} vd_system_decorations=${systemDecorations ? 'true' : 'false'} new_display=${finalWidth}x${finalHeight}/${dpi} `
587
+ + `control=true audio=false scid=${scid}`
588
+ // **max_fps 以前从来没传过 —— 等于无限帧率。**
589
+ // 实测 MC 跑起来视频流 145fps(远超 60),CPU 和带宽都白烧。
590
+ // 默认限到 60:够流畅,又不浪费。
591
+ + (maxFps > 0 ? ` max_fps=${maxFps}` : '');
592
+ // 把 server 的输出落到日志文件:出问题时没有日志只能瞎猜(刚踩过:服务秒退却不知道为什么)
593
+ const logPath = '/tmp/dsh-vd-server.log';
594
+ const { openSync } = await import('node:fs');
595
+ let fd = 'ignore';
596
+ try { fd = openSync(logPath, 'w'); } catch { /* 写不了就用 ignore */ }
597
+ state.logPath = logPath;
598
+
599
+ const cleanupForward = async () => {
600
+ try { await adb(['forward', '--remove', `tcp:${port}`]); } catch { /* 清不掉不影响返回 */ }
601
+ };
602
+
603
+ // ---- 这里是整个插件唯一能把引擎进程带崩的调用 ----
604
+ // Node 行为:spawn 找不到可执行文件(ENOENT)时 emit 'error';没有 'error' 监听
605
+ // 就是 Unhandled 'error' event → uncaughtException → 进程直接退出
606
+ // (本机 node 24.22.1 实测 exit 1)。环境升级清空过 apt 装的 adb,这场景真实发生过。
607
+ // 所以做两层:① 同步 try/catch 兜 spawn 自身的参数/stdio 错误;
608
+ // ② 等 spawn/error 落定,失败就返回可读 hint,绝不把异常抛出去。
609
+ let child;
610
+ try {
611
+ child = spawn(ADB, ['-s', target, 'shell', cmd], { detached: true, stdio: ['ignore', fd, fd] });
612
+ } catch (e) {
613
+ await cleanupForward();
614
+ return { ok: false, hint: `无法启动 adb(${ADB}):${e?.message || e}。先装 android-tools-adb(apt-get install -y android-tools-adb)` };
615
+ }
616
+ let spawnError = null;
617
+ child.on('error', (e) => { if (!spawnError) spawnError = e; state.child = null; });
618
+ await new Promise((resolve) => {
619
+ let settled = false;
620
+ const done = () => { if (!settled) { settled = true; resolve(); } };
621
+ child.once('spawn', done);
622
+ child.once('error', done);
623
+ setTimeout(done, 3000).unref?.();
624
+ });
625
+ if (spawnError) {
626
+ try { child.kill('SIGKILL'); } catch { /* 没起来就没什么可杀 */ }
627
+ await cleanupForward();
628
+ return {
629
+ ok: false,
630
+ hint: `启动 adb 失败(${ADB}):${spawnError?.message || spawnError}\n`
631
+ + '先装 android-tools-adb(apt-get install -y android-tools-adb)再重试。',
632
+ };
633
+ }
634
+ state.child = child;
635
+ child.unref?.();
636
+
637
+ // 这个固定等待**不能省**:试过改成"能连上就往下走",结果连太早 server 还没准备完,
638
+ // 屏建不出来(实测 10.6 秒后失败)。1800ms 是 server 初始化 + new_display 的时序要求。
639
+ await sleep(1800);
640
+
641
+ // 两个客户端:video(第 0 个)+ control(第 1 个)。断开即销毁整个屏。
642
+ //
643
+ // **第 0 个不是「哑客户端」** —— 它传的是实时 H.264。以前这里写
644
+ // `s.on('data', () => {})` 把数据丢了,于是所有截图只能走 screencap(7fps)。
645
+ // 现在喂给 video.js 解析,能用的时候就有 25fps 的实时帧。
646
+ const videoMod = await import('./video.js');
647
+ state.videoReader = videoMod.createReader();
648
+
649
+ const connect = (isVideo) => new Promise((res) => {
650
+ const s = net.connect(port, '127.0.0.1', () => res(s));
651
+ s.on('error', () => res(null));
652
+ if (isVideo) {
653
+ s.on('data', (d) => { try { videoMod.push(state.videoReader, d); } catch { /* 解析出错不能影响连接 */ } });
654
+ } else {
655
+ s.on('data', () => {});
656
+ }
657
+ });
658
+ const s1 = await connect(true);
659
+ await sleep(500);
660
+ const s2 = await connect(false);
661
+ state.sockets = [s1, s2].filter(Boolean);
662
+ state.startedAt = Date.now();
663
+
664
+ // 等屏出现(差集)
665
+ for (let i = 0; i < 20; i += 1) {
666
+ await sleep(400);
667
+ const now = await displayIds();
668
+ if (!now) { await sleep(300); continue; } // 查询失败这一轮跳过,别误判成屏没出来
669
+ const added = [...now].filter((d) => !before.has(d));
670
+ if (added.length) {
671
+ state.displayId = added[0];
672
+ state.width = finalWidth; state.height = finalHeight;
673
+ state.dpi = dpi; // 记录给池认身份用
674
+ state.hwc = hwc; // 记下请求值,复用分支的差异对比要用
675
+ state.systemDecorations = systemDecorations;
676
+ break;
677
+ }
678
+ }
679
+ if (!state.displayId) {
680
+ await stop();
681
+ return { ok: false, hint: 'server 起来了但没等到新屏出现。常见原因:socket 名没带下划线、客户端没连上、或者权限不足。' };
682
+ }
683
+
684
+ for (let i = 0; i < 10; i += 1) {
685
+ await sleep(300);
686
+ const nowSf = await sfIds();
687
+ if (!nowSf) { await sleep(300); continue; }
688
+ const added = [...nowSf].filter((d) => !beforeSf.has(d));
689
+ if (added.length) { state.sfId = added[0]; break; }
690
+ }
691
+
692
+ // 校验能力标志
693
+ const flags = await shell(`dumpsys display 2>/dev/null | grep "DisplayDeviceInfo.*scrcpy" | head -1`);
694
+ const canHost = /FLAG_OWN_CONTENT_ONLY/.test(flags) && /FLAG_OWN_FOCUS/.test(flags);
695
+
696
+ // **建屏成功就落盘**:之后任何进程都能复用这块屏,不会重复建。
697
+ savePersistedState();
698
+ return {
699
+ ok: true,
700
+ displayId: state.displayId,
701
+ sfId: state.sfId,
702
+ canHost,
703
+ width: state.width, height: state.height,
704
+ flags: (flags.match(/FLAG_[A-Z_]+/g) || []).join(' '),
705
+ // HWC 是否生效:true 表示这次的屏有硬件合成,3D 游戏能正常渲染
706
+ hwc: state.hwcChanged || state.hwcPrev === '1',
707
+ };
708
+ }
709
+
710
+ /**
711
+ * **同步**把 HWC 属性恢复原值。只给进程退出钩子用 —— 那里不能 await。
712
+ *
713
+ * 为什么必须有:debug.sf.enable_hwc_vds 是全局 SurfaceFlinger 属性,
714
+ * 开着的时候整台设备的合成策略都变了。正常路径 stop() 会恢复它,
715
+ * 但守护进程被 SIGKILL / OOM 杀掉时 stop() 根本不会执行 ——
716
+ * 属性就永远停在 1,直到手机重启。
717
+ *
718
+ * SIGKILL 抓不到,所以这个函数也只能覆盖 SIGTERM/正常退出。
719
+ * 但对 OOM 和时间超时这两种最常见的情况是有效的。
720
+ */
721
+ export function restoreHwcSync() {
722
+ if (!state.hwcChanged) return false;
723
+ let target = process.env.ADB_TARGET || '127.0.0.1:5555';
724
+ try {
725
+ const dir = process.env.DSH_ADB_STATE_DIR
726
+ || join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'plugin-adb');
727
+ const st = JSON.parse(readFileSync(join(dir, 'state.json'), 'utf8'));
728
+ const port = Number(st?.port);
729
+ if (Number.isInteger(port) && port > 0 && port < 65536) target = `127.0.0.1:${port}`;
730
+ } catch { /* 读不到就用默认回环地址 */ }
731
+
732
+ const ADBBIN = process.env.ADB_BIN || 'adb';
733
+ try {
734
+ execFileSync(ADBBIN, ['-s', target, 'shell',
735
+ `setprop debug.sf.enable_hwc_vds ${state.hwcPrev || '0'}`], { timeout: 5000 });
736
+ state.hwcChanged = false;
737
+ return true;
738
+ } catch {
739
+ return false;
740
+ }
741
+ }
742
+
743
+ /** 销毁虚拟屏。 */
744
+ export async function stop({ forceStopApps = false } = {}) {
745
+ const pkgList = [...(state.launchedPkgs || [])];
746
+ const killed = [];
747
+ // 默认**不杀**投过的 App:里面有可能是 DSH、Shizuku、微信这类不能随便杀的。
748
+ // 需要清后台时调用方显式传 forceStopApps:true,并且自己判断这个包该不该杀。
749
+ if (forceStopApps) {
750
+ for (const pkg of pkgList) {
751
+ // 硬保护:这些包杀了会直接影响用户(DSH 就是当前 App 本身)
752
+ if (/^(io\.github\.ccch1mneyyy\.dsh_app|moe\.shizuku\.)/.test(pkg)) continue;
753
+ /* **App 已经跑在这块屏上时不要 force-stop。**
754
+ *
755
+ * 2026-11-21 事故:隔壁「热成像助手」对话反馈「调用一会摄像头就没了」。
756
+ * 查 logcat 是 com.jminno.thermal 每 2 分钟被 Force stopping 一次 ——
757
+ * 因为它每轮迭代都调 vdisplay_launch 想「刷新」屏,而这里无条件 force-stop,
758
+ * 把正在开相机的进程杀了。相机客户端跟着 cameraserver 一起断。
759
+ *
760
+ * force-stop 的初衷是防止「App 已在主屏后台 → am start --display 只把主屏任务
761
+ * 拉过来」那个坑。但如果它已经在那块虚拟屏上跑着,这个担心不成立,
762
+ * 直接 reuse 反而更安全(也保住了它的相机/连接/进度)。
763
+ */
764
+ const _onVd = await shell(`dumpsys window displays 2>/dev/null | grep -A30 "mDisplayId=${state.displayId}" | grep -c "${pkg}"`);
765
+ const _alreadyThere = Number(String(_onVd).trim()) > 0;
766
+ if (!_alreadyThere) {
767
+ await shell(`am force-stop ${pkg}`);
768
+ await sleep(600);
769
+ }
770
+ killed.push(pkg);
771
+ }
772
+ }
773
+ // 逐个包判断:以前只要有一个命中就把整个列表都报成"还在跑"(复核实测)。
774
+ const still = [];
775
+ for (const pkg of pkgList) {
776
+ // 用 pidof 精确匹配进程名:grep 子串会命中同类包
777
+ // (实测 com.android.settings 已 force-stop,却因为命中
778
+ // com.android.settings.intelligence 而误报"仍在后台")。
779
+ const pid = await shell(`pidof ${pkg} 2>/dev/null || true`);
780
+ if (String(pid || '').trim()) still.push(pkg);
781
+ }
782
+ const scid = state.scid;
783
+ if (scid) await shell(`pkill -f '${scid}' 2>/dev/null`);
784
+ // 清掉本次用的 adb forward:以前从不清,复核实测攒了 9 条残留。
785
+ if (state.port) await adb(['forward', '--remove', `tcp:${state.port}`], 10000).catch(() => {});
786
+ // 不能用 --remove-all:那会删掉别的插件(比如 web_* 的 CDP)的 forward。只删自己那条。
787
+ for (const sk of state.sockets || []) { try { sk?.destroy(); } catch { /* ignore */ } }
788
+ if (state.child) { try { state.child.kill('SIGKILL'); } catch { /* ignore */ } }
789
+ // 恢复 HWC 属性。只恢复这次由我们改成的那个值——
790
+ // 如果开机时它本来就是 1,说明用户或别的工具故意开着,我们不去动它。
791
+ if (state.hwcChanged) {
792
+ await shell(`setprop debug.sf.enable_hwc_vds ${state.hwcPrev || '0'}`);
793
+ state.hwcChanged = false;
794
+ }
795
+ state.hwcPrev = null;
796
+ state.sockets = [];
797
+ state.videoReader = null;
798
+ state.child = null;
799
+ state.displayId = null; state.sfId = null; state.scid = null; state.port = null;
800
+ resetShotBasis(); // **8 个字段一次清全**(原来只清 3 个,region 会漏)
801
+ state.launchedPkgs = [];
802
+ return {
803
+ ok: true,
804
+ killed,
805
+ stillRunning: still,
806
+ hint: still.length
807
+ ? `虚拟屏已销毁。这些 App 仍在后台运行:${still.join('、')}。如果要清掉,下次 stop 时传 forceStopApps:true(DSH 和 Shizuku 会被跳过)。`
808
+ : '虚拟屏已销毁,没有需要清理的后台 App。',
809
+ };
810
+ }
811
+
812
+ /**
813
+ * 虚拟屏是不是**真的**还活着。
814
+ * 只看 state.displayId 会撒谎:server 被系统回收、adb 断开、用户手动 pkill 之后,
815
+ * state 里还留着旧的 displayId,于是 status 报"运行中"、start 报"已就绪"、
816
+ * shot 报原始的 "Display Id is not valid"(复核实测踩到)。
817
+ * 这里用两个客观信号交叉验证:屏还在不在 displayIds 里、SF id 还在不在 sfIds 里。
818
+ */
819
+ /**
820
+ * 重新解析当前 scrcpy 虚拟屏的 SurfaceFlinger display id。
821
+ *
822
+ * 为什么需要:屏幕一转向(游戏强制横屏就会),SurfaceFlinger 会**重建**这块虚拟屏
823
+ * 并分配一个新的 SF display id,而逻辑 displayId 保持不变。实测证据:
824
+ *
825
+ * 逻辑 id 110 / 空屏 → SF …8400646736,图层 0,截图 0% 非黑
826
+ * 逻辑 id 110 / MC 起 → SF …9638300942,图层 4,截图 95.45% 非黑
827
+ * 逻辑 id 110 / 转屏后 → SF 换新,缓存里的旧 id 不在列表里
828
+ *
829
+ * 早期版本把「缓存的 sfId 不在列表里」当成「屏已死」,于是每次截图都 forget() 杀掉
830
+ * scrcpy server 再重建一块空屏,结果永远是全黑——**根本不是 3D 渲染不出来**。
831
+ *
832
+ * @returns {Promise<string|null>} 唯一确定的 scrcpy SF id;0 个或多个时返回 null
833
+ */
834
+ async function resolveScrcpySfId() {
835
+ const out = await shell(`dumpsys SurfaceFlinger --display-id 2>/dev/null | grep scrcpy`);
836
+ if (!String(out || '').trim()) return null;
837
+ const ids = [];
838
+ for (const line of String(out).split('\n')) {
839
+ // 形如:Display 11529215048987737530 (Virtual display): displayName="scrcpy"
840
+ const m = line.match(/Display\s+(\d+).*scrcpy/);
841
+ if (m) ids.push(m[1]);
842
+ }
843
+ if (ids.length !== 1) return null; // 多个时分不清,宁可不更新
844
+ return ids[0];
845
+ }
846
+
847
+ /** 确保 state.sfId 是当前有效的;变了就更新,**不重建屏**。 */
848
+ /**
849
+ * `start()` 的复用检查缓存。
850
+ *
851
+ * **为什么必须有**:实测 `shot()` 单张 623ms,而 screencap 本身只要 225ms。
852
+ * 差的 400ms 里,大头是 `start()` 每次都要:
853
+ * alive() → displayIds() + sfIds() = 2 次 dumpsys
854
+ * 复用分支 → DisplayDeviceInfo = 1 次 dumpsys
855
+ * 同一个操作序列里连着截图/OCR/模板匹配,这些查询全是重复的。
856
+ *
857
+ * 缓存 1.5 秒:正常操作节奏(每步几百毫秒)内不会过期;
858
+ * 真转屏/屏死时,screencap 失败会触发强制刷新(captureAndConvert 有兜底)。
859
+ */
860
+ const REUSE_TTL_MS = 1500;
861
+ let lastReuseCheckAt = 0;
862
+ let lastReuseResult = null;
863
+
864
+ /**
865
+ * 刷新 SurfaceFlinger id。
866
+ *
867
+ * **实测:这个函数每次调用要 ~150-400ms**(内部 dumpsys + grep),
868
+ * 而 `vd.shot()` 每张截图都会调它 → 单张截图从 225ms 涨到 623ms。
869
+ * 所有基于截图的工具(OCR、模板匹配、指纹)都被这个拖慢。
870
+ *
871
+ * 加 2 秒 TTL:同一个操作序列里连着截图不会重复查。
872
+ * 转屏时 id 会变,但下次 TTL 过期就会重新解析;而且 screencap 失败时
873
+ * 会强制刷新(下面 captureAndConvert 里有兜底)。
874
+ */
875
+ const SFID_TTL_MS = 2000;
876
+ let lastSfIdCheckAt = 0;
877
+
878
+ async function refreshSfId(force = false) {
879
+ const now = Date.now();
880
+ if (!force && state.sfId && (now - lastSfIdCheckAt) < SFID_TTL_MS) {
881
+ return state.sfId; // **缓存命中,省掉 150-400ms 的 dumpsys**
882
+ }
883
+ lastSfIdCheckAt = now;
884
+ if (!state.sfId) { const r = await resolveScrcpySfId(); if (r) state.sfId = r; return state.sfId; }
885
+ const cur = await resolveScrcpySfId();
886
+ if (!cur) return state.sfId; // 查不到(可能刚好在转屏瞬间)→ 先用旧的
887
+ if (cur !== state.sfId) {
888
+ state.sfId = cur; // 转屏导致 id 变了 → 更新即可,不要杀 server
889
+ }
890
+ return state.sfId;
891
+ }
892
+
893
+ /**
894
+ * 刷新"当前实际渲染尺寸"。
895
+ *
896
+ * **为什么必须做**:`dumpsys display` 报的是虚拟屏的**初始声明**尺寸(比如 720x1592),
897
+ * 但 App 强制横屏后实际画面会变成 1592x720。`nx/ny` 如果按 state.width/height 换算,
898
+ * 点「设置」会落到屏幕外面 —— 实测表现是"点了没反应",很容易误判成按钮不可点。
899
+ *
900
+ * `dumpsys window displays` 里的 `cur=1592x720` 才是当前真实尺寸。
901
+ * 实测代价约 50ms,比多截一张图(133-240ms)便宜。
902
+ */
903
+ /**
904
+ * 刷新虚拟屏真实尺寸。
905
+ *
906
+ * **带 2 秒 TTL。** 原来每次 input() 都调它,等于每步多一次 `dumpsys window displays`
907
+ * (150-300ms)。连续操作时尺寸根本不会变,重复查纯属浪费。
908
+ *
909
+ * 实测账:一次 input 里有 5 次 adb 往返(alive 两次 + dumpsys display + getprop +
910
+ * refreshRealSize),150-300ms/次 → 0.75-1.5s。真正注入只要 20-50ms。
911
+ * 加 TTL 后连续操作可以省掉绝大部分。
912
+ */
913
+ async function refreshRealSize(force = false) {
914
+ if (!state.displayId) return false;
915
+ const now = Date.now();
916
+ if (!force && state.lastSizeCheckAt && (now - state.lastSizeCheckAt) < 2000) {
917
+ return false; // 2 秒内查过了,直接用缓存值
918
+ }
919
+ state.lastSizeCheckAt = now;
920
+ try {
921
+ const out = await shell(`dumpsys window displays 2>/dev/null | grep -A2 "mDisplayId=${state.displayId} " | head -3`);
922
+ const m = String(out || '').match(/cur=(\d+)x(\d+)/);
923
+ if (!m) return false;
924
+ const w = Number(m[1]);
925
+ const h = Number(m[2]);
926
+ if (w > 0 && h > 0 && (w !== state.width || h !== state.height)) {
927
+ state.width = w;
928
+ state.height = h;
929
+ state.lastShotHash = null; // 尺寸变了,旧的去重基准作废
930
+ return true;
931
+ }
932
+ } catch { /* 查不到就用旧值 */ }
933
+ return false;
934
+ }
935
+
936
+ async function alive() {
937
+ if (!state.displayId) return false;
938
+ const [ids, sf] = await Promise.all([displayIds(), sfIds()]);
939
+ // null = 查询失败(adb 抖动),不能据此判定屏没了 → 保守认为还活着
940
+ if (!ids || !sf) return true;
941
+ const hasDisplay = ids.has(String(state.displayId));
942
+ if (!hasDisplay) return false; // 逻辑屏真没了 → 确实死了
943
+ if (state.sfId && sf.has(String(state.sfId))) return true; // 缓存的 SF id 还有效
944
+ // 逻辑屏在、但缓存的 SF id 不在列表里 → **多半是转屏换了 id**,重新解析而不是判死
945
+ const fresh = await resolveScrcpySfId();
946
+ if (fresh) { state.sfId = fresh; return true; }
947
+ return false;
948
+ }
949
+
950
+ /** 状态不一致时,把内存状态清干净,免得后面每个工具都报假消息。 */
951
+ function forget(reason) {
952
+ // **清 hwcPrev 之前必须先恢复 HWC。** 上一版只清了记录,没恢复实际属性:
953
+ // 重建时 getprop 还是 '1',于是 hwcPrev 又被记成 '1',stop 再写回 1,
954
+ // 全局 debug.sf.enable_hwc_vds 就残到重启,原始值 '0' 永远丢了。
955
+ try { restoreHwcSync(); } catch { /* 恢复失败也不能挡住重建 */ }
956
+ const dead = { displayId: state.displayId, sfId: state.sfId, port: state.port };
957
+ try { state.child?.kill('SIGKILL'); } catch { /* ignore */ }
958
+ for (const sk of state.sockets || []) { try { sk?.destroy(); } catch { /* ignore */ } }
959
+ state.child = null; state.sockets = [];
960
+ state.displayId = null; state.sfId = null; state.scid = null; state.port = null;
961
+ // **8 个字段一次清全**(原来只清 4 个:ImgHeight/W/H/cacheKey 会漏,和 stop() 不一致)
962
+ resetShotBasis();
963
+ state.lastInputAt = null; // pickRoi 的兜底 ROI 用它,不清会拿上一块屏的坐标当中心
964
+ lastReuseResult = null; // **复用检查缓存也作废**,否则新建屏后还在用旧的判定
965
+ lastReuseCheckAt = 0;
966
+ clearPersistedState(); // **盘上的记录也清掉**,否则下个进程会去复用死屏
967
+ // **hwcPrev 必须清掉**:不清的话,重建时 getprop 已经是 1,于是 hwcPrev 被记成 '1',
968
+ // stop 时又恢复成 1,全局 debug.sf.enable_hwc_vds 残到重启(对抗审查 S1)。
969
+ state.hwcPrev = null;
970
+ state.hwc = null;
971
+ state.systemDecorations = false;
972
+ return { ...dead, reason };
973
+ }
974
+
975
+ /** 取虚拟屏上当前前台 App 的窗口串(胶囊用来显示"AI 在操作 XX")。 */
976
+ export async function focusedApp() {
977
+ if (!state.displayId) return '';
978
+ const r = await shell(`dumpsys window displays 2>/dev/null | grep -A30 "mDisplayId=${state.displayId}" | grep -m1 mCurrentFocus`);
979
+ return String(r || '').trim();
980
+ }
981
+
982
+ export async function status() {
983
+ const ids = await displayIds();
984
+ const sf = await sfIds();
985
+ const app = state.displayId ? await shell(`dumpsys window displays 2>/dev/null | grep -A20 "mDisplayId=${state.displayId}" | grep -m1 mCurrentFocus`) : '';
986
+ return {
987
+ running: await alive(),
988
+ displayId: state.displayId,
989
+ sfId: state.sfId,
990
+ uptimeSec: state.startedAt ? Math.round((Date.now() - state.startedAt) / 1000) : 0,
991
+ dpi: state.dpi, // 池的金丝雀身份(U8 实测 320/321 可区分)
992
+ width: state.width, height: state.height, // 转屏后这两个值会变,坐标空间跟着变
993
+ allDisplays: ids ? [...ids].sort((a, b) => a - b) : null, // null 表示查询失败,不是没有屏
994
+ scrcpyScreens: sf ? [...sf] : null,
995
+ focusedApp: app.trim(),
996
+ };
997
+ }
998
+
999
+ /**
1000
+ * 把 App 投到虚拟屏。
1001
+ *
1002
+ * 必须先 force-stop:如果这个 App 已经跑在主屏后台,`am start --display N` 只会把
1003
+ * 那个已有任务拉到前台(实测踩过:计算器就是这么跑到主屏、把用户的视频顶掉的)。
1004
+ * 投完还要**校验主屏焦点没变**,变了立刻切回去——「不影响主屏」是硬要求。
1005
+ */
1006
+ export async function launch(pkg, activity) {
1007
+ // 投完 App 立刻把它的风控等级同步给浮窗(不等下一次 input)
1008
+ setTimeout(() => { try { syncRiskLevel(); } catch { /* ignore */ } }, 2500);
1009
+ const s = await start();
1010
+ if (!s.ok) return { ok: false, hint: s.hint };
1011
+
1012
+ const mainBefore = await mainFocus();
1013
+
1014
+ /* **App 已经跑在这块虚拟屏上时不要 force-stop。**
1015
+ *
1016
+ * 2026-11-21 「热成像助手」对话反馈「调用一会摄像头就没了」:
1017
+ * logcat 显示 com.jminno.thermal 每约 2 分钟被 Force stopping 一次,
1018
+ * 因为它每轮迭代都调 launch 想刷新屏,而这里无条件 force-stop,
1019
+ * 把正在开相机的进程杀了,相机客户端跟着断。
1020
+ *
1021
+ * 原注释担心的坑是「App 已在主屏后台 → am start --display 只拉主屏任务」,
1022
+ * 但它如果已经在那块屏上跑着,这个担心不成立;reuse 反而保住了
1023
+ * 它的相机、连接和进度。
1024
+ */
1025
+ const _onVdL = await shell(`dumpsys window displays 2>/dev/null | grep -A30 "mDisplayId=${state.displayId}" | grep -c "${pkg}"`);
1026
+ const _alreadyOnDisplay = Number(String(_onVdL).trim()) > 0;
1027
+ if (!_alreadyOnDisplay) {
1028
+ await shell(`am force-stop ${pkg}`);
1029
+ await sleep(600);
1030
+ }
1031
+ if (!state.launchedPkgs.includes(pkg)) state.launchedPkgs.push(pkg);
1032
+
1033
+ // 省略 activity 时不能只写 `-n <pkg>`——实测报 Bad component name。
1034
+ // 先用 resolve-activity 查出默认入口,查不到再退回 monkey 的 launcher intent。
1035
+ let comp;
1036
+ if (activity) {
1037
+ comp = `-n ${pkg}/${activity}`;
1038
+ } else {
1039
+ const res = await shell(`cmd package resolve-activity --brief -c android.intent.category.LAUNCHER ${pkg} 2>/dev/null | tail -1`);
1040
+ const m = String(res).trim().match(/^([\w.]+)\/([\w.$]+)$/);
1041
+ comp = m ? `-n ${m[1]}/${m[2]}` : `-a android.intent.action.MAIN -c android.intent.category.LAUNCHER -p ${pkg}`;
1042
+ }
1043
+ const out = await shell(`am start --display ${state.displayId} ${comp}`);
1044
+ await sleep(2000);
1045
+
1046
+ // 校验是不是真的落在虚拟屏上
1047
+ const onVd = await shell(`dumpsys window displays 2>/dev/null | grep -A30 "mDisplayId=${state.displayId}" | grep -m1 mCurrentFocus`);
1048
+ const landedOnVd = onVd.includes(pkg);
1049
+
1050
+ // 校验主屏
1051
+ const mainAfter = await mainFocus();
1052
+ // 只有**两边都测到**且真的不同,才算"主屏被抢"。空值代表"没测到",不能当变化——
1053
+ // 之前用空值比较,导致前后都是 B 站却报"主屏被抢、已切回"(假报警,踩过)。
1054
+ const bothKnown = Boolean(mainBefore) && Boolean(mainAfter);
1055
+ // **绝对不对主屏做任何操作。**
1056
+ // 以前这里会在"判定主屏被抢"时跑 monkey 把原来的 App 拉回来,
1057
+ // 但那个判定在"用户自己在这 2 秒里切了 App"时会误判——于是插件反过来
1058
+ // 用 monkey 改了用户的主屏,比它要防的问题更打扰人(复核实测踩到)。
1059
+ // 现在只观察、只报告,让调用方决定。
1060
+ const mainChanged = bothKnown && mainAfter !== mainBefore;
1061
+ const restored = false;
1062
+
1063
+ return {
1064
+ ok: landedOnVd && !restored,
1065
+ displayId: state.displayId,
1066
+ landedOnVd,
1067
+ mainFocusBefore: mainBefore,
1068
+ mainFocusAfter: mainAfter,
1069
+ mainChanged,
1070
+ restoredMain: false,
1071
+ out: out.trim() || (landedOnVd ? '已在虚拟屏上启动' : '没落在虚拟屏上'),
1072
+ };
1073
+ }
1074
+
1075
+
1076
+ /**
1077
+ * 取当前虚拟屏的一帧,只算哈希,不落盘。
1078
+ *
1079
+ * 为什么要这个:之前的 input() 只要 adb 不报错就返回 ok:true,**点空了也算成功**。
1080
+ * 实测(隔壁对线会话 15 张截图里有 5 张与上一张逐像素相同)意味着 一定比例 的操作是白点的,
1081
+ * 而调用方完全看不出来,只能靠额外交一张截图 + 模型看图才可能发现。
1082
+ * 所以每个输入动作前后各取一次哈希,变了才算真生效。
1083
+ */
1084
+ /**
1085
+ * 往 scrcpy 的控制 socket 发一条控制消息。
1086
+ *
1087
+ * 为什么值得做:现在所有输入都走 `adb shell input`,那条路对中文必抛 NPE
1088
+ * (实测 `input text 中文` → java NPE),而且每次起一个子进程要 30–50ms。
1089
+ * scrcpy 的控制通道支持 SET_CLIPBOARD,实测设置页能粘进 `abc中文测试abc`,
1090
+ * 所以中文输入的正解是「写剪贴板 → KEYCODE_PASTE」。
1091
+ *
1092
+ * SET_CLIPBOARD 报文(scrcpy 5.x):
1093
+ * type=9 (1B) | sequence (8B i64) | paste (1B bool) | length (4B i32) | text (utf8)
1094
+ */
1095
+ /**
1096
+ * 控制通道当前是否可用。返回 socket 或 null。
1097
+ *
1098
+ * tap/swipe 用它决定走 scrcpy 控制通道还是退回 adb input。
1099
+ * 注意:**必须检查 destroyed**,socket 断了但对象还在的情况实测会出现。
1100
+ */
1101
+ function sendControlRaw() {
1102
+ const ctl = state.sockets?.[1];
1103
+ if (!ctl || ctl.destroyed) return null;
1104
+ return ctl;
1105
+ }
1106
+
1107
+ function sendControl(buf) {
1108
+ const ctl = state.sockets?.[1];
1109
+ if (!ctl || ctl.destroyed) return false;
1110
+ try { ctl.write(buf); return true; } catch { return false; }
1111
+ }
1112
+
1113
+ let clipSequence = 0;
1114
+
1115
+ /** 把文字写进设备剪贴板。返回是否发成功。 */
1116
+ export function setClipboard(text) {
1117
+ const body = Buffer.from(String(text ?? ''), 'utf8');
1118
+ const buf = Buffer.alloc(1 + 8 + 1 + 4 + body.length);
1119
+ let off = 0;
1120
+ buf.writeUInt8(9, off); off += 1; // TYPE_SET_CLIPBOARD
1121
+ clipSequence += 1;
1122
+ buf.writeBigInt64BE(BigInt(clipSequence), off); off += 8;
1123
+ buf.writeUInt8(1, off); off += 1; // paste = true(让设备侧标记为可粘贴)
1124
+ buf.writeInt32BE(body.length, off); off += 4;
1125
+ body.copy(buf, off);
1126
+ return sendControl(buf);
1127
+ }
1128
+
1129
+ /**
1130
+ * 从视频流里拿一张实时画面。
1131
+ *
1132
+ * ## 和 `shot()` 的区别(实测数据)
1133
+ *
1134
+ * ```
1135
+ * shot() screencap 143 ms/帧 7 fps 每次一次 adb 往返
1136
+ * liveShot() 视频流解码 4 ms/帧 25 fps 不占 adb 通道
1137
+ * ```
1138
+ *
1139
+ * 但 liveShot 有个**严格前提**:画面必须在他妈的动,scrcpy 才会发帧。
1140
+ * 静止的屏(空虚拟屏、纯黑)一个包都收不到,这时会返回 `ok:false`,
1141
+ * 调用方应该回退到 `shot()`。
1142
+ *
1143
+ * ## 为什么不是「更快就无脑用它」
1144
+ *
1145
+ * 它是**编解码后的画面**,可能比 screencap 少几个像素的精度(H.264 有损),
1146
+ * 而且要求画面有变化。所以策略应该是:
1147
+ * · 要快的连续观察 → liveShot
1148
+ * · 要一张确定准确的定帧 → shot
1149
+ *
1150
+ * @param {object} [o]
1151
+ * @param {string} [o.dir='/tmp'] 输出目录
1152
+ * @param {number} [o.width=0] 缩放宽度,0=原生
1153
+ * @returns {Promise<{ok:boolean, path?:string, width?:number, height?:number, ms?:number, fps?:number, hint?:string}>}
1154
+ */
1155
+ export async function liveShot(o = {}) {
1156
+ const mod = await import('./video.js');
1157
+ const rd = state.videoReader;
1158
+ if (!rd) return { ok: false, hint: '视频流没接上(屏可能没起,或者用了不支持的 server 配置)' };
1159
+
1160
+ const st = mod.stats(rd);
1161
+ if (!st.headerDone) return { ok: false, hint: `视频流头部还没到(已收 ${st.bytes} 字节)` };
1162
+ if (st.headerError) return { ok: false, hint: st.headerError };
1163
+ if (!st.hasKeyframe) {
1164
+ return {
1165
+ ok: false,
1166
+ hint: `视频流有 ${st.frames} 帧但缓冲里还没有关键帧(SPS/PPS),解不出来。`
1167
+ + '等画面变化出下一个关键帧,或者用 vdisplay_shot。',
1168
+ fps: st.fps,
1169
+ };
1170
+ }
1171
+ if (!st.frames) {
1172
+ return {
1173
+ ok: false,
1174
+ hint: `视频流已连上(${st.width}x${st.height})但还没收到画面 —— `
1175
+ + 'scrcpy 只在画面变化时发帧,静止的屏收不到。这种情况用 vdisplay_shot。',
1176
+ fps: 0,
1177
+ };
1178
+ }
1179
+
1180
+ const dir = String(o.dir || '/tmp').replace(/\/+$/, '') || '/tmp';
1181
+ const stamp = Date.now();
1182
+ const out = `${dir}/vd-live-${stamp}.jpg`;
1183
+
1184
+ // **有常驻解码器就直接读内存**,实测远低于 1ms;没有才回退到按需解 GOP(约 240ms)
1185
+ const cached = mod.latestJpeg(rd);
1186
+ if (cached && cached.length) {
1187
+ const { writeFile } = await import('node:fs/promises');
1188
+ await writeFile(out, cached);
1189
+ const dec = mod.decoderStats(rd);
1190
+ return {
1191
+ ok: true,
1192
+ path: out,
1193
+ width: Number(o.width) || st.width,
1194
+ height: st.height,
1195
+ ms: 0,
1196
+ fps: st.fps,
1197
+ decoderFrames: dec.frames,
1198
+ frameAgeMs: dec.ageMs,
1199
+ displayId: state.displayId,
1200
+ source: 'persistent-decoder',
1201
+ };
1202
+ }
1203
+
1204
+ const r = await mod.grabJpeg(rd, { out, width: Number(o.width) || 0 });
1205
+ if (!r.ok) return { ok: false, hint: r.hint };
1206
+ return {
1207
+ ok: true,
1208
+ path: r.path,
1209
+ width: Number(o.width) || st.width,
1210
+ height: st.height,
1211
+ ms: r.ms,
1212
+ fps: st.fps,
1213
+ displayId: state.displayId,
1214
+ source: 'on-demand',
1215
+ };
1216
+ }
1217
+
1218
+ /** 拿到当前这块屏的视频流解析器(给 video.js 的常驻解码器用) */
1219
+ export function videoReader() {
1220
+ return state.videoReader;
1221
+ }
1222
+
1223
+ /**
1224
+ * P0-2:**等画面稳了再截图。**
1225
+ *
1226
+ * ## 为什么比固定 sleep 强
1227
+ *
1228
+ * 原来点完之后 `sleep(500)` 再截图。撞上转场/动画中间态就会截到:
1229
+ * 半截页面、半透明叠层、运动模糊的字 —— 贵(一张 230-684 token)而且读不准,
1230
+ * 模型会判断"页面坏了",然后做错决策。
1231
+ *
1232
+ * 现在用 32×32 灰度信号盯:**连续 stableMs 内 tailMad 都低于阈值**才截图。
1233
+ * 这个信号免费(本来就在收),粒度 25Hz,比 sleep 准得多。
1234
+ *
1235
+ * ## 和固定 sleep 的实测差别
1236
+ *
1237
+ * 固定 500ms:可能还在动(滑动惯性 800ms+),也可能早就稳了(白等)。
1238
+ * 这里:稳了立刻截,没稳就等,上限兜底。
1239
+ *
1240
+ * @param {object} [o]
1241
+ * @param {number} [o.stableMs=120] 要连续稳多久才算稳
1242
+ * @param {number} [o.maxWaitMs=2500] 最多等多久,超了就用当前帧
1243
+ * @param {number} [o.threshold=0.5] tailMad 低于它算稳(实测滑动时 8-9,静止 0)
1244
+ * @returns {Promise<{waitedMs:number, stable:boolean}>}
1245
+ */
1246
+ export async function waitStable(o = {}) {
1247
+ const mod = await import('./video.js');
1248
+ const st = state.videoReader;
1249
+ const stableMs = Number(o.stableMs) || 120;
1250
+ const maxWait = Number(o.maxWaitMs) || 2500;
1251
+ const th = Number(o.threshold) || 0.5;
1252
+ const t0 = Date.now();
1253
+
1254
+ // 没有视频流就别等了,直接返回(调用方按老路走)
1255
+ if (!st || !st.sensor || !st.sensor.length) {
1256
+ return { waitedMs: 0, stable: null, hint: '没有灰度信号,无法判断稳定性' };
1257
+ }
1258
+
1259
+ let quietSince = null;
1260
+ for (;;) {
1261
+ const m = mod.motion(st, { recent: 8 });
1262
+ const now = Date.now();
1263
+ if (m.tailMad !== null && m.tailMad < th) {
1264
+ if (quietSince === null) quietSince = now;
1265
+ if (now - quietSince >= stableMs) {
1266
+ return { waitedMs: now - t0, stable: true, tailMad: m.tailMad };
1267
+ }
1268
+ } else {
1269
+ quietSince = null; // 又动了,重新计时
1270
+ }
1271
+ if (now - t0 >= maxWait) {
1272
+ return {
1273
+ waitedMs: now - t0,
1274
+ stable: false,
1275
+ tailMad: m.tailMad,
1276
+ hint: `等了 ${maxWait}ms 还没稳(tailMad=${m.tailMad}),直接截当前帧`,
1277
+ };
1278
+ }
1279
+ await sleep(60);
1280
+ }
1281
+ }
1282
+
1283
+ /**
1284
+ * P0-3:**自动挑 ROI(局部放大)。**
1285
+ *
1286
+ * ## 为什么值得
1287
+ *
1288
+ * token 计价是 `⌈宽/42⌉ × ⌈高/42⌉`,低于 544×544 按地板价 169-180 收。
1289
+ * 所以同样 171 token:
1290
+ * · 全屏 720 缩到 360 宽 → 只有 0.5x 像素(字糊)
1291
+ * · 裁一块 360 宽原生 → **1:1 像素**(字清楚)
1292
+ *
1293
+ * 一倍清晰度的差价,就在这里。
1294
+ *
1295
+ * ## 怎么挑
1296
+ *
1297
+ * 优先级:
1298
+ * ① 灰度 bbox(哪里在动)—— 0 成本
1299
+ * ② 最近一次交互坐标 ±120px
1300
+ * ③ 都不可用 → 返回 null,调用方走全屏
1301
+ *
1302
+ * 然后把区域扩 15% 边距,并保证**不超出屏幕**、**面积不超过整屏 35%**
1303
+ * (太大就没有裁剪的意义了)。
1304
+ *
1305
+ * @param {object} [o]
1306
+ * @param {number} [o.minArea=0.04] 区域至少占整屏多少(太小没信息)
1307
+ * @param {number} [o.maxArea=0.35] 超过这个比例就不裁了,直接全屏
1308
+ * @returns {{x:number,y:number,w:number,h:number,src:string}|null}
1309
+ */
1310
+ export async function pickRoi(o = {}) {
1311
+ const mod = await import('./video.js');
1312
+ const st = state.videoReader;
1313
+ const W = state.width;
1314
+ const H = state.height;
1315
+ if (!(W > 0 && H > 0)) return null;
1316
+
1317
+ const minArea = Number(o.minArea) || 0.04;
1318
+ // 输出宽度:裁剪区超过它就得不到放大收益,就是该往细里挑的信号
1319
+ /*
1320
+ * **默认输出宽度 544,不是 420。**
1321
+ *
1322
+ * token 计价是 ceil(w/42)*ceil(h/42),544 以下全部按地板价 169 收。
1323
+ * 所以 420 见方和 544 见方**同一个价钱**,但 544 多了 29.5% 边长、68% 面积。
1324
+ *
1325
+ * 之前默认 420 是白扔分辨率 —— 纯粹是浪费,没有任何好处。
1326
+ * 544 = ceil(544/42)=13 → 13*13=169,正好卡在地板价线上。
1327
+ */
1328
+ const outW = Number(o.outputWidth) || 544;
1329
+
1330
+ let box = null;
1331
+ let src = '';
1332
+
1333
+ // ① 灰度 bbox:32×32 分辨率下 1 格 = 屏宽/32 ≈ 22px
1334
+ if (st && st.sensor && st.sensor.length) {
1335
+ const m = mod.motion(st, { recent: 10 });
1336
+ if (m.lastBbox) {
1337
+ const gx = W / 32;
1338
+ const gy = H / 32;
1339
+ box = {
1340
+ x: m.lastBbox.minX * gx,
1341
+ y: m.lastBbox.minY * gy,
1342
+ w: (m.lastBbox.maxX - m.lastBbox.minX + 1) * gx,
1343
+ h: (m.lastBbox.maxY - m.lastBbox.minY + 1) * gy,
1344
+ };
1345
+ src = 'sensor-bbox';
1346
+ }
1347
+ }
1348
+
1349
+ // ② 回退:最近一次交互坐标
1350
+ if (!box && state.lastInputAt) {
1351
+ const { x, y } = state.lastInputAt;
1352
+ const r = 120;
1353
+ box = { x: x - r, y: y - r, w: r * 2, h: r * 2 };
1354
+ src = 'last-input';
1355
+ }
1356
+
1357
+ if (!box) return null;
1358
+
1359
+ // 扩 15% 边距(别把控件边缘切掉)
1360
+ const mx = box.w * 0.15;
1361
+ const my = box.h * 0.15;
1362
+ let x = Math.max(0, Math.round(box.x - mx));
1363
+ let y = Math.max(0, Math.round(box.y - my));
1364
+ let w = Math.round(box.w + mx * 2);
1365
+ let h = Math.round(box.h + my * 2);
1366
+
1367
+ // 贴边修正
1368
+ if (x + w > W) w = W - x;
1369
+ if (y + h > H) h = H - y;
1370
+ if (w < 40 || h < 40) return null;
1371
+
1372
+ const area = (w * h) / (W * H);
1373
+ if (area < minArea) {
1374
+ // 太小了,扩到最小面积(以中心扩)
1375
+ const need = Math.sqrt(minArea * W * H);
1376
+ const cx = x + w / 2;
1377
+ const cy = y + h / 2;
1378
+ w = Math.min(W, Math.round(need));
1379
+ h = Math.min(H, Math.round(need));
1380
+ x = Math.max(0, Math.min(W - w, Math.round(cx - w / 2)));
1381
+ y = Math.max(0, Math.min(H - h, Math.round(cy - h / 2)));
1382
+ } else if (w > outW) {
1383
+ /*
1384
+ * **判据是「裁剪后能不能 1:1」,不是「面积有没有超过某个比例」。**
1385
+ *
1386
+ * 第一版用 `area > 0.35` 判断该不该裁 —— 实测横屏 B站首页拿到 720×517、
1387
+ * 面积 0.32,刚好没超阈值于是原样返回,输出 420 宽时放大率只有 0.58x,
1388
+ * 白丢裁剪红利。
1389
+ *
1390
+ * 正确的判据:输出宽度是 outW 时,裁剪区宽度**超过 outW 就没有放大收益了**。
1391
+ * 这时候应该在包围盒里挑一块 outW 见方(且不超过 544 地板价上限)的子区,
1392
+ * 挑变化最密集的位置。这样无论画面动得多散,都能拿到 1:1 像素。
1393
+ */
1394
+ // 544 是地板价上限;再大就开始按面积收费了(560² = 196 token)
1395
+ const side = Math.min(Math.max(outW, 64), 544, W, H);
1396
+ const winCells = Math.max(1, Math.round((side / W) * 32));
1397
+ const hot = mod.densestCellWindow(st, winCells);
1398
+ if (!hot) return null; // 没有热力图数据,只能放弃
1399
+ const gx = W / 32;
1400
+ const gy = H / 32;
1401
+ w = side;
1402
+ h = side;
1403
+ x = Math.max(0, Math.min(W - w, Math.round(hot.cx * gx - w / 2)));
1404
+ y = Math.max(0, Math.min(H - h, Math.round(hot.cy * gy - h / 2)));
1405
+ src = `${src}+hotspot`;
1406
+ }
1407
+
1408
+ return { x, y, w, h, src, area: Math.round(((w * h) / (W * H)) * 100) / 100 };
1409
+ }
1410
+
1411
+ /**
1412
+ * 黑屏探针:判断这块屏上「视频/受保护内容」是不是抓不到。
1413
+ *
1414
+ * ## 为什么这条最要紧
1415
+ *
1416
+ * Android 对受保护内容(DRM 视频、银行界面)会给窗口设 `FLAG_SECURE`,
1417
+ * 任何截屏 API 拿到的都是**纯黑**。这不分 screencap / scrcpy 流 / MediaProjection
1418
+ * —— 全是黑的,是无 root 的硬边界。
1419
+ *
1420
+ * 所以它决定三条产品线的生死:
1421
+ * · 会员长视频(腾讯/爱奇艺 VIP)
1422
+ * · 微信视频号
1423
+ * · 游戏过场动画
1424
+ *
1425
+ * ## 三态判定(必须分开记,不能混成「通过/失败」)
1426
+ *
1427
+ * A 正常出画 → 视频区有内容,可以做
1428
+ * B 视频区黑但 UI 可读 → FLAG_SECURE,结构性不可做
1429
+ * C 整屏黑/App 拒启动 → 虚拟屏不支持这个 App
1430
+ *
1431
+ * B 和 C 的区别很重要:B 是「内容受保护」,C 是「这个 App 不认虚拟屏」。
1432
+ *
1433
+ * ## 判据
1434
+ *
1435
+ * 用灰度统计,不看像素内容:
1436
+ * · 整屏 max == 0 → C(全黑)
1437
+ * · 下半屏 max 很小、上半屏正常 → B(视频区黑,UI 可读)
1438
+ * · 两半都有内容 → A
1439
+ *
1440
+ * @returns {Promise<{verdict:'A'|'B'|'C'|'?', ...}>}
1441
+ */
1442
+ export async function probeSecure(o = {}) {
1443
+ const mod = await import('./video.js');
1444
+ const st = state.videoReader;
1445
+
1446
+ // 先拿一张全尺寸帧做像素级统计(不走 OCR,快)
1447
+ const shotR = await shot(o.dir || '/tmp', { width: 360 });
1448
+ if (!shotR.ok) return { ok: false, verdict: '?', hint: `截图失败:${shotR.hint}` };
1449
+
1450
+ const { execFile } = await import('node:child_process');
1451
+ // 用 ffmpeg 把图缩成 16x16 灰度,读原始像素 —— 比装图像库轻
1452
+ const raw = await new Promise((resolve) => {
1453
+ const p2 = execFile('ffmpeg', [
1454
+ '-v', 'error', '-i', shotR.path,
1455
+ '-vf', 'scale=16:16:flags=area,format=gray',
1456
+ '-f', 'rawvideo', '-pix_fmt', 'gray', 'pipe:1',
1457
+ ], { encoding: 'buffer', maxBuffer: 1 << 20 }, (err, stdout) => resolve(err ? null : stdout));
1458
+ if (!p2) resolve(null);
1459
+ });
1460
+ if (!raw || raw.length < 256) {
1461
+ return { ok: false, verdict: '?', hint: '读不出像素(ffmpeg 失败)' };
1462
+ }
1463
+
1464
+ // 分上下两半统计(视频一般在上,UI 在下;这里只做粗判)
1465
+ const half = 128; // 16x16 的上半 8 行 = 128 像素
1466
+ let upMax = 0, downMax = 0, upSum = 0, downSum = 0;
1467
+ for (let i = 0; i < 256; i += 1) {
1468
+ const v = raw[i];
1469
+ if (i < half) { upSum += v; if (v > upMax) upMax = v; }
1470
+ else { downSum += v; if (v > downMax) downMax = v; }
1471
+ }
1472
+ const upMean = upSum / half;
1473
+ const downMean = downSum / half;
1474
+ const wholeMax = Math.max(upMax, downMax);
1475
+
1476
+ /*
1477
+ * 三态判定。
1478
+ *
1479
+ * **这里踩过一个假阳性,值得写下来。**
1480
+ *
1481
+ * 第一版规则是「上黑下亮 = FLAG_SECURE」。实测遇到一个「打开方式」选择器弹窗
1482
+ * (底部 bottom sheet + 黑色背景),上 max=0 下 max=189,被误判成 B。
1483
+ * 截图一看根本不是受保护内容,就是个选择器。
1484
+ *
1485
+ * 所以现在 B 判得更严:**必须同时**
1486
+ * ① 上黑下亮,且
1487
+ * ② 黑色区域占比很大(不是薄薄一条),且
1488
+ * ③ 下半部有明显内容(说明 App 确实在渲染,只是上半部被屏蔽)
1489
+ *
1490
+ * 而且 B 只作为**怀疑**,最终确认要靠窗口标志(`secureWindows()`)。
1491
+ */
1492
+ let verdict = '?';
1493
+ let why = '';
1494
+ let confidence = 'low';
1495
+ if (wholeMax === 0) {
1496
+ verdict = 'C';
1497
+ why = '整屏纯黑 —— App 可能拒绝在虚拟屏渲染,或者根本没起来';
1498
+ confidence = 'high';
1499
+ } else if (upMax <= 6 && downMax > 40) {
1500
+ // 上黑下亮:可能是 FLAG_SECURE,也可能是底部弹窗,需要进一步确认
1501
+ verdict = 'B?';
1502
+ why = '上半屏纯黑、下半屏有明显内容 —— 疑似 FLAG_SECURE,但底部弹窗也会这样,需核对窗口标志';
1503
+ confidence = 'low';
1504
+ } else if (upMax > 20 && downMax > 20) {
1505
+ verdict = 'A';
1506
+ why = '上下都有内容,出画正常';
1507
+ confidence = 'high';
1508
+ } else {
1509
+ verdict = '?';
1510
+ why = `分不清(上 max=${upMax} 下 max=${downMax})`;
1511
+ confidence = 'low';
1512
+ }
1513
+ // 顺便查一下窗口标志 —— 这才是 FLAG_SECURE 的权威证据
1514
+ let secureWins = null;
1515
+ try {
1516
+ const w = await shell('dumpsys window windows 2>/dev/null | grep -c "FLAG_SECURE"');
1517
+ secureWins = Number(String(w).trim()) || 0;
1518
+ } catch { /* 查不到就算了 */ }
1519
+
1520
+ // 有窗口标志这个权威证据时,用它纠正 B?
1521
+ if (verdict === 'B?' && secureWins !== null) {
1522
+ if (secureWins === 0) {
1523
+ verdict = 'A?';
1524
+ why += '(但 dumpsys 里没有任何 FLAG_SECURE 窗口,所以大概率不是受保护内容,而是弹窗)';
1525
+ } else {
1526
+ confidence = 'high';
1527
+ why += `(dumpsys 里有 ${secureWins} 个 FLAG_SECURE 窗口,支持这个判断)`;
1528
+ }
1529
+ }
1530
+
1531
+ return {
1532
+ ok: true,
1533
+ verdict,
1534
+ confidence,
1535
+ secureWins,
1536
+ why,
1537
+ upMax, downMax, upMean: Math.round(upMean), downMean: Math.round(downMean),
1538
+ path: shotR.path,
1539
+ displayId: state.displayId,
1540
+ hint: verdict === 'B'
1541
+ ? '这块屏上的受保护内容抓不到(FLAG_SECURE)。换非 DRM 内容,或者接受这条线做不了。'
1542
+ : undefined,
1543
+ };
1544
+ }
1545
+
1546
+ /** 视频流的现状(给诊断用) */
1547
+ export async function videoStats() {
1548
+ const mod = await import('./video.js');
1549
+ const st = state.videoReader;
1550
+ const base = mod.stats(st);
1551
+ return { ...base, decoder: mod.decoderStats(st) };
1552
+ }
1553
+
1554
+ /**
1555
+ * 起常驻解码器。之后 liveShot 直接读内存,不再等解码。
1556
+ *
1557
+ * 冷启动要等一个关键帧(实测约 10 秒),期间 `liveShot` 会返回「还没关键帧」。
1558
+ * 想立刻有画面就先调一次 `shot()`。
1559
+ */
1560
+ export async function startLive(o = {}) {
1561
+ const mod = await import('./video.js');
1562
+ if (!state.videoReader) return { ok: false, hint: '视频流没接上(屏可能没起)' };
1563
+ return mod.startDecoder(state.videoReader, o);
1564
+ }
1565
+
1566
+ /** 停常驻解码器 */
1567
+ export async function stopLive() {
1568
+ const mod = await import('./video.js');
1569
+ if (!state.videoReader) return { ok: true, stopped: false };
1570
+ return mod.stopDecoder(state.videoReader);
1571
+ }
1572
+
1573
+ /**
1574
+ * 一次「画面现在变了多少」的廉价探测。
1575
+ *
1576
+ * ## 为什么不能用 frameHash 做输入校验
1577
+ *
1578
+ * 原来 input() 用 `frameHash()` 前后各截一张图比哈希:**两次 screencap = 286ms**,
1579
+ * 而且实测会误判 —— 明明视频流涨了 8 帧(画面确实变了),哈希却判"没变",
1580
+ * 于是 `ok:false`,调用方以为没生效就重试,造成重复操作。
1581
+ *
1582
+ * ## 用视频流包数当信号
1583
+ *
1584
+ * scrcpy 的编码器**只在画面变化时出帧**。所以「包数涨没涨」就是最直接的
1585
+ * 「画面变了没」的证据,而且:
1586
+ * · 免费(包本来就在收)
1587
+ * · 即时(一次内存读取,0ms)
1588
+ * · 更灵敏(25fps 粒度 vs screencap 的 143ms 粒度)
1589
+ *
1590
+ * 视频流不可用时才回退到 screencap 哈希。
1591
+ */
1592
+ function frameTick() {
1593
+ const st = state.videoReader;
1594
+ // **必须用单调递增的 frames,不能用 packets.length。**
1595
+ // packets 缓冲上限 400,16 秒后饱和不再增长 → 每次 input 都以为"画面没变",
1596
+ // 退化成两次 screencap,单次输入从 243ms 涨到 2 秒以上。
1597
+ // 审计发现:watchFrames 的注释写过这个坑,但 frameTick 没改。
1598
+ if (st && typeof st.frames === 'number') return { kind: 'frames', v: st.frames };
1599
+ if (st && st.packets) return { kind: 'packets', v: st.packets.length };
1600
+ return { kind: 'none', v: 0 };
1601
+ }
1602
+
1603
+ /** 等画面变化:返回 true 表示在 waitMs 内观察到了变化。 */
1604
+ async function waitChanged(tick, waitMs = 900) {
1605
+ const t0 = Date.now();
1606
+ for (;;) {
1607
+ const cur = frameTick();
1608
+ if (cur.kind === tick.kind && cur.v !== tick.v) return true;
1609
+ if (Date.now() - t0 >= waitMs) return false;
1610
+ await sleep(60);
1611
+ }
1612
+ }
1613
+
1614
+ async function frameHash() {
1615
+ // 必须刷新 SF id:转屏后旧 id 失效,两次 screencap 都失败会让 before/after 都为 null,
1616
+ // 于是 changed 变 null、调用方看到 ok=true —— **校验被静默关闭**(监督复核指出的高危项)。
1617
+ await refreshSfId();
1618
+ if (!state.sfId) return null;
1619
+ const capOnce = async () => {
1620
+ const r = await adb(['exec-out', 'screencap', '-p', '-d', String(state.sfId)], 20000);
1621
+ return r.ok && r.out ? r.out : null;
1622
+ };
1623
+ let buf = await capOnce();
1624
+ // **必须传 true 强制刷新。**
1625
+ // refreshSfId() 加了 2 秒 TTL,这里刚刷过就会命中缓存拿到同一个失效 id,
1626
+ // 于是两次 capOnce 都失败 → 返回 null → changed=null → ok:true,
1627
+ // 注释里说的「校验被静默关闭」又被 TTL 关回去了(对抗审查指出)。
1628
+ if (!buf) { await refreshSfId(true); buf = await capOnce(); }
1629
+ if (!buf) return null;
1630
+ const { createHash } = await import('node:crypto');
1631
+ return createHash('sha1').update(buf, 'utf8').digest('hex');
1632
+ }
1633
+
1634
+ /**
1635
+ * 定向输入。kind: tap | swipe | text | key | paste
1636
+ *
1637
+ * 默认会在动作前后各取一次画面哈希:**画面没变就返回 changed:false**,
1638
+ * 让调用方知道"这一下没生效",而不是像以前那样一律 ok:true(实测 一定比例 白点)。
1639
+ * 传 verify:false 可跳过校验(省 2 次截图,约 0.3 秒),适合连续点同一个界面时。
1640
+ */
1641
+ /** 把「当前操作方式 + 风控等级」写到浮窗能读到的地方。
1642
+ *
1643
+ * 浮窗(Java 进程)和插件(Node 进程)是两个进程,
1644
+ * 共同能写的地方只有 /data/local/tmp。落一行文本最省事,不用开 socket。
1645
+ *
1646
+ * 为什么要给用户看:风控等级越高,能用的操作就越朴素(越要拟人化)。
1647
+ * 用户看得见当前在哪一档,才知道为什么这一步慢了、为什么不直接点。
1648
+ */
1649
+ let _riskCache = { at: 0, pkg: '', lv: '', op: '待机' };
1650
+
1651
+ /** 读 docs/risk.json,返回某包的风控等级(0-5)。读不到返回 -1。 */
1652
+ async function riskLevelOf(pkg) {
1653
+ try {
1654
+ const { readFile } = await import('node:fs/promises');
1655
+ const { fileURLToPath } = await import('node:url');
1656
+ const { dirname, join } = await import('node:path');
1657
+ const here = dirname(fileURLToPath(import.meta.url));
1658
+ for (const rel of ['../docs/risk.json', '../../docs/risk.json']) {
1659
+ try {
1660
+ const d = JSON.parse(await readFile(join(here, rel), 'utf8'));
1661
+ const apps = d.apps || d;
1662
+ const info = apps[pkg];
1663
+ if (info && typeof info.level === 'number') return info.level;
1664
+ /* **unknown_level 在 rules 下面,不在顶层。**
1665
+ * 2026-11-21 对抗审查抓到:原来读 d.unknown_level 永远是 undefined,
1666
+ * 于是未收录的 App 返回 -1 → 不写文件 → 浮窗继续显示上一个 App 的等级。
1667
+ * 更糟:如果上一个是 L0(设置),切到银行类未收录 App 仍显示「L0 自由」。
1668
+ */
1669
+ const unk = (d.rules && d.rules.unknown_level);
1670
+ return typeof unk === 'number' ? unk : 3;
1671
+ } catch { /* 试下一个路径 */ }
1672
+ }
1673
+ } catch { /* ignore */ }
1674
+ return -1;
1675
+ }
1676
+
1677
+ /** 算出后台屏上当前 App 的风控等级,并写进浮窗读的那个文件。
1678
+ *
1679
+ * 为什么只写 `L2` 两个字符:用户 2026-11-21 说浮窗底部那行
1680
+ * 「屏 38820 · 注入·tap」一堆看不懂的,唯一有意义的是风控等级。
1681
+ * 所以这里只输出等级,格式化交给浮窗自己做(它还要按等级上色)。
1682
+ *
1683
+ * 5 秒缓存:一次 dumpsys 约 250ms,每次点击都查会把操作拖慢一倍。
1684
+ * 用户要看的是「当前处在哪一档」,5 秒的滞后完全够。
1685
+ */
1686
+ export async function syncRiskLevel() {
1687
+ try {
1688
+ if (Date.now() - _riskCache.at < 5000 && _riskCache.lv) {
1689
+ markOpMode(_riskCache.lv);
1690
+ return _riskCache.lv;
1691
+ }
1692
+ const st = await status();
1693
+ const m = String(st.focusedApp || '').match(/([a-zA-Z][\w.]*\.[\w.]+)\//);
1694
+ const pkg = m ? m[1] : '';
1695
+ let lv = '';
1696
+ if (pkg) {
1697
+ const n = await riskLevelOf(pkg);
1698
+ lv = n >= 0 ? 'L' + n : '';
1699
+ }
1700
+ /* 拿不到 pkg 或等级也要写 L3(未知即严格),
1701
+ * 不能让上一个 App 的等级继续挂在浮窗上 —— 那比不显示更误导。 */
1702
+ if (!lv) lv = 'L3';
1703
+ /* 写 `等级|操作方式|屏号` 三段。浮窗那边三个都要显示:
1704
+ * 用户 2026-11-21 明确要求「风控等级、操作方式、和后台屏编号」都要有。
1705
+ * 用竖线分隔,浮窗 split 后逐段解析,缺哪段就跳过哪段。 */
1706
+ const _op = (_riskCache.op || '待机');
1707
+ const _dn = state.displayId ? String(state.displayId) : '-';
1708
+ markOpMode(lv + '|' + _op + '|' + _dn);
1709
+ _riskCache = { at: Date.now(), pkg, lv };
1710
+ return lv;
1711
+ } catch { return ''; }
1712
+ }
1713
+
1714
+ export function markOpMode(text) {
1715
+ /* 插件跑在 proot 里,没有设备的 /data/local/tmp,只能通过 adb 写。
1716
+ * 用 fire-and-forget:这一步只是为了给用户看状态,不能拖慢真正的操作,
1717
+ * 所以不 await、失败也不管。 */
1718
+ try {
1719
+ const t = String(text || '').replace(/["'`$\\]/g, '').slice(0, 60);
1720
+ adb(['shell', 'mkdir -p /data/local/tmp/dshframe; echo "' + t + '" > /data/local/tmp/dshframe/opmode'])
1721
+ .catch(() => {});
1722
+ } catch { /* ignore */ }
1723
+ }
1724
+
1725
+ export async function input(kind, a = {}) {
1726
+ try { _riskCache.op = '注入·' + kind; _riskCache.at = 0; syncRiskLevel(); } catch { /* 不影响操作 */ }
1727
+ const s = await start();
1728
+ if (!s.ok) return { ok: false, hint: s.hint };
1729
+ const d = state.displayId;
1730
+ let cmd;
1731
+ // 归一化坐标:给 nx/ny(0..1)就按当前屏尺寸换算,省得调用方猜坐标系。
1732
+ // 实测白点率 一定比例 的主因不是点不准,是模型不知道屏多大、坐标系对不上。
1733
+ // 三种坐标写法,优先级从高到低:
1734
+ // nx/ny(0..1) —— 最稳,永远对
1735
+ // x/y —— **按"上一次截图里的像素"理解**,自动放大到显示坐标
1736
+ // 都没给 —— (0,0)
1737
+ //
1738
+ // 为什么要换算 x/y:截图默认是 540 宽,而显示是 720x1280。
1739
+ // 实测照图片像素直接传会系统性偏 33%(点放大镜画面零变化)。
1740
+ // 先刷新真实尺寸:转屏后 state.width/height 是初始声明值,直接用来算 nx/ny 会点到屏外。
1741
+ await refreshRealSize();
1742
+ // **交付图可能只是屏幕的一块(region),也可能被裁过(cropPx)。**
1743
+ // 之前的实现只按「图宽 / 屏宽」比例换算,完全没算 region 的偏移 ——
1744
+ // 于是看过 region 图之后,模型按那张图的像素给 x/y,会点到屏幕左上角那片去。
1745
+ // 对抗审查给的算例:720 屏 + region{x:180,y:300,w:360,h:600} + 交付 420 宽,
1746
+ // 图内 (100,50) 应该是屏幕 (265.7,342.9),旧算法给出 (171.4,85.7),差了一个 region 偏移。
1747
+ const regionUsed = state.lastShotRegion;
1748
+ const imgW = state.lastShotImgWidth || state.width;
1749
+
1750
+ /*
1751
+ * 坐标换算,**四个坐标全部走同一套逻辑**。
1752
+ *
1753
+ * 上一版在这里连着翻过两次车,都记在下面,免得第三次重犯:
1754
+ *
1755
+ * ① 有 region 时漏了偏移 → 看过局部图后点按全错。
1756
+ * ② 修 ① 的时候把无 region 的基准写成「图宽」而不是「屏宽」:
1757
+ * scale = (region ? region.w : imgW) / imgW
1758
+ * 无 region 时恒等于 1,而正确值是 720/540=1.333,
1759
+ * 于是默认截图(540 宽)之后按图内像素点按,**系统偏 33%**。
1760
+ * 这条比 ① 更险,因为它坏的是最常用的路径,而端到端测试当时只覆盖了 region 算例。
1761
+ * ③ swipe 只修了起点 x,起点还读错了字段(读 a.x 而用户给的是 a.x1),
1762
+ * 于是 swipe 起点恒为 0,实测会变成从屏幕最左边斜着划,可能触发返回手势把 App 划走。
1763
+ *
1764
+ * 所以现在:**屏幕像素 = region 偏移 + 图内像素 × (region尺寸 / 图尺寸)**,
1765
+ * region 不存在时退化成「屏尺寸 / 图尺寸」。nx/ny 是归一化,按同一基准换算。
1766
+ */
1767
+ const baseW = regionUsed ? regionUsed.w : state.width;
1768
+ const baseH = regionUsed ? regionUsed.h : Math.max(1, state.height - Math.round(Number(a.cropBottom) || 0));
1769
+ const offX = regionUsed ? regionUsed.x : 0;
1770
+ const offY = regionUsed ? regionUsed.y : 0;
1771
+ const scaleX = imgW > 0 ? baseW / imgW : 1;
1772
+ // 图高按宽等比推(出图是等比缩放的);拿不到图高就沿用 x 的比例
1773
+ const imgH = (state.lastShotImgHeight && state.lastShotImgHeight > 0)
1774
+ ? state.lastShotImgHeight
1775
+ : imgW * (state.height / Math.max(1, state.width));
1776
+ const scaleY = imgH > 0 ? baseH / imgH : scaleX;
1777
+
1778
+ /** 取某个坐标字段的映射结果;nx 优先,其次像素 */
1779
+ const mapX = (nxKey, xKey) => {
1780
+ if (a[nxKey] !== undefined && a[nxKey] !== null) return Math.round(offX + Number(a[nxKey]) * baseW);
1781
+ if (a[xKey] === undefined || a[xKey] === null) return null;
1782
+ return Math.round(offX + Number(a[xKey]) * scaleX);
1783
+ };
1784
+ const mapY = (nyKey, yKey) => {
1785
+ if (a[nyKey] !== undefined && a[nyKey] !== null) return Math.round(offY + Number(a[nyKey]) * baseH);
1786
+ if (a[yKey] === undefined || a[yKey] === null) return null;
1787
+ return Math.round(offY + Number(a[yKey]) * scaleY);
1788
+ };
1789
+
1790
+ const toX = () => mapX('nx', 'x') ?? 0;
1791
+ const toY = () => mapY('ny', 'y') ?? 0;
1792
+
1793
+
1794
+ /*
1795
+ * **基准必须在这里采,不能在后面。**
1796
+ *
1797
+ * 走 scrcpy 控制通道时,事件在「构造命令」阶段就发出去了(下面 tap 分支里
1798
+ * sent === bufs.length 就把 cmd 置 null),而原代码把 tick 采样放在 1829 行
1799
+ * —— **先注入、后采基准**。
1800
+ *
1801
+ * 后果:对「只重绘一帧就静止」的控件(复选框、开关、单帧跳转),
1802
+ * 基准里已经包含了这次变化 → waitChanged 永远看不到增量 → changed=false
1803
+ * → 3 次补轮询也看不到 → ok:false +「这一下可能真的没生效」
1804
+ * → 调用方重试 → **重复点击**(购买/发送类操作会出事)。
1805
+ *
1806
+ * 独立复核指出这是三个最危险的问题之一,修法就是把采样点提前。
1807
+ */
1808
+ // **verify 必须在这里就声明**:它原来在 1836 行(分派之后),
1809
+ // 而 tick 采样要在分派之前,直接用会踩 const 的暂时性死区
1810
+ // (ReferenceError: Cannot access 'verify' before initialization,实测踩到)。
1811
+ const verify = a.verify !== false;
1812
+ const tick = verify ? frameTick() : null;
1813
+
1814
+ if (kind === 'tap') {
1815
+ // **优先走 scrcpy 控制通道**:能给真实压力、能插 MOVE、延迟也低。
1816
+ // 只有控制通道不可用(老 server / socket 断了)才退回 adb input。
1817
+ const inj = await import('./inject.js');
1818
+ const useCtl = sendControlRaw() !== null;
1819
+ if (useCtl) {
1820
+ const sw = state.width; const sh = state.height;
1821
+ const { bufs } = inj.buildTap({
1822
+ x: toX(), y: toY(), screenW: sw, screenH: sh,
1823
+ holdMs: Number(a.holdMs) || (60 + Math.random() * 90),
1824
+ moves: 2 + Math.floor(Math.random() * 3),
1825
+ });
1826
+ let sent = 0;
1827
+ for (let k = 0; k < bufs.length; k += 1) {
1828
+ if (!sendControl(bufs[k])) break;
1829
+ sent += 1;
1830
+ if (k < bufs.length - 1) await sleep(8 + Math.random() * 14);
1831
+ }
1832
+ if (sent === bufs.length) {
1833
+ state.lastInjectVia = 'scrcpy-control';
1834
+ cmd = null; // 已经注入完,不再走 adb
1835
+ } else {
1836
+ cmd = `input -d ${d} tap ${toX()} ${toY()}`;
1837
+ state.lastInjectVia = 'adb-input-fallback';
1838
+ }
1839
+ } else {
1840
+ cmd = `input -d ${d} tap ${toX()} ${toY()}`;
1841
+ state.lastInjectVia = 'adb-input';
1842
+ }
1843
+ } else if (kind === 'hold') {
1844
+ /*
1845
+ * 按住不动(游戏摇杆 / 长按菜单 / 挖方块)。
1846
+ *
1847
+ * 和 swipe 的区别:起点终点基本相同,重点是**持续**送 60Hz 的 MOVE。
1848
+ * 实测固定 14 步在 5 秒长按时会退化成 3Hz,游戏直接当手指没动。
1849
+ */
1850
+ const hx = a.nx != null ? Number(a.nx) * state.width : Number(a.x);
1851
+ const hy = a.ny != null ? Number(a.ny) * state.height : Number(a.y);
1852
+ if (!Number.isFinite(hx) || !Number.isFinite(hy)) return { ok: false, hint: 'hold 需要坐标(x/y 或 nx/ny)' };
1853
+ const inj = await import('./inject.js');
1854
+ if (sendControlRaw() === null) {
1855
+ // 控制通道不可用时 hold 没法做(adb input 没有等价的「按住不放」)
1856
+ return { ok: false, hint: 'hold 需要 scrcpy 控制通道,当前不可用' };
1857
+ }
1858
+ const h = inj.buildHold({
1859
+ x: hx, y: hy, screenW: state.width, screenH: state.height,
1860
+ ms: Number(a.ms) || 1000,
1861
+ jitter: a.jitter != null ? Number(a.jitter) : 2,
1862
+ driftX: Number(a.driftX) || 0,
1863
+ driftY: Number(a.driftY) || 0,
1864
+ });
1865
+ // 按 buildHold 算出的间隔逐帧送出去
1866
+ let sentH = 0;
1867
+ for (let k = 0; k < h.bufs.length; k += 1) {
1868
+ if (!sendControl(h.bufs[k])) break;
1869
+ sentH += 1;
1870
+ if (k < h.delays.length) await sleep(h.delays[k]);
1871
+ }
1872
+ // 和 tap/swipe 一致:直接 return,不设外层变量
1873
+ return { ok: sentH > 0, displayId: d, out: `hold ${sentH} 帧(${h.bufs.length - 2} 个 MOVE @60Hz, ${h.totalMs}ms)`, changed: null };
1874
+ } else if (kind === 'multitouch') {
1875
+ /*
1876
+ * 双指手势:一根手指按住不动(摇杆),另一根滑动(转视角)。
1877
+ *
1878
+ * 游戏双手操作的基础 —— 现在只有单指,走位和转视角不能同时做。
1879
+ */
1880
+ const p1 = a.p1 || { nx: a.nx1, ny: a.ny1 };
1881
+ const p2 = a.p2 || { nx: a.nx2, ny: a.ny2 };
1882
+ const f = (q, kx, ky) => ({
1883
+ x: q[kx] != null ? Number(q[kx]) * state.width : Number(q.x || 0),
1884
+ y: q[ky] != null ? Number(q[ky]) * state.height : Number(q.y || 0),
1885
+ });
1886
+ const P1 = f(p1, 'nx', 'ny');
1887
+ const P2 = f(p2, 'nx', 'ny');
1888
+ const P2T = a.p2To ? f(a.p2To, 'nx', 'ny') : P2;
1889
+ if (!Number.isFinite(P1.x) || !Number.isFinite(P2.x)) {
1890
+ return { ok: false, hint: 'multitouch 需要 p1 和 p2 的坐标(nx/ny 或 x/y)' };
1891
+ }
1892
+ const inj = await import('./inject.js');
1893
+ if (sendControlRaw() === null) {
1894
+ return { ok: false, hint: 'multitouch 需要 scrcpy 控制通道(adb input 不支持多指)' };
1895
+ }
1896
+ const mt = inj.buildMultiTouch({
1897
+ p1: P1, p2: P2, p2To: P2T,
1898
+ screenW: state.width, screenH: state.height,
1899
+ ms: Number(a.ms) || 600,
1900
+ p1DriftX: Number(a.driftX) || 0,
1901
+ p1DriftY: Number(a.driftY) || 0,
1902
+ releaseP1: a.releaseP1 !== false,
1903
+ });
1904
+ let sent = 0;
1905
+ for (let k = 0; k < mt.bufs.length; k += 1) {
1906
+ if (!sendControl(mt.bufs[k])) break;
1907
+ sent += 1;
1908
+ if (k < mt.delays.length) await sleep(mt.delays[k]);
1909
+ }
1910
+ return { ok: sent > 0, displayId: d, out: `multitouch ${sent} 帧(双指 ${mt.totalMs}ms)`, changed: null };
1911
+ } else if (kind === 'swipe') {
1912
+ // **四个坐标都要映射,起点也不能漏。** 上一版起点读的是 a.x(用户给的是 x1),
1913
+ // 于是恒为 0;另外 y1/x2/y2 只乘比例没加 region 偏移。
1914
+ const sx = mapX('nx1', 'x1'); const sy = mapY('ny1', 'y1');
1915
+ const ex = mapX('nx2', 'x2'); const ey = mapY('ny2', 'y2');
1916
+ if (sx === null || sy === null || ex === null || ey === null) {
1917
+ return { ok: false, hint: 'swipe 需要完整坐标:x1/y1/x2/y2(或 nx1/ny1/nx2/ny2)。' +
1918
+ ' 拒绝用 0 当默认值 —— 那会从屏幕最左边划出去,在开了手势导航的屏上可能把 App 划走。' };
1919
+ }
1920
+ // 同上:优先控制通道。**swipe 的收益更大** ——
1921
+ // `adb input swipe` 的 MOVE 是严格等距线性的,行为统计一眼能看出来;
1922
+ // 走控制通道可以按缓动曲线走、叠加垂直抖动、压力沿轨迹变化。
1923
+ const inj2 = await import('./inject.js');
1924
+ if (sendControlRaw() !== null) {
1925
+ const swp = inj2.buildSwipe({
1926
+ x1: sx, y1: sy, x2: ex, y2: ey,
1927
+ screenW: state.width, screenH: state.height,
1928
+ ms: Number(a.ms) || 300,
1929
+ steps: Number(a.steps) || 14,
1930
+ });
1931
+ let sentAll = true;
1932
+ for (let k = 0; k < swp.bufs.length; k += 1) {
1933
+ if (!sendControl(swp.bufs[k])) { sentAll = false; break; }
1934
+ const wait = k < swp.delays.length ? swp.delays[k] : 8;
1935
+ await sleep(wait);
1936
+ }
1937
+ if (sentAll) {
1938
+ state.lastInjectVia = 'scrcpy-control';
1939
+ cmd = null;
1940
+ }
1941
+ }
1942
+ // **只有控制通道没发成功才回退到 adb。**
1943
+ // 原来这行是无条件执行的,于是控制通道发完之后又被 adb 覆盖了一遍 ——
1944
+ // 每次滑动实际滑两下(翻页翻两页)。tap 分支没这个问题,对比上面 tap 的写法。
1945
+ //
1946
+ // 用显式布尔判断而不是 `cmd !== null`:`let cmd;` 的初值是 undefined,
1947
+ // `undefined !== null` 为真,靠这个特性"碰巧对"是脆的,改成看得懂的写法。
1948
+ if (cmd === undefined) {
1949
+ cmd = `input -d ${d} swipe ${sx} ${sy} ${ex} ${ey} ${Number(a.ms) || 300}`;
1950
+ }
1951
+ }
1952
+ else if (kind === 'text') {
1953
+ const txt = String(a.text ?? '');
1954
+ // 实测:非 ASCII(中文)走 input text 会让设备侧抛 NPE,而且异常文本会被当输出回填。
1955
+ // 别假装支持——直接告诉调用方改用 paste。
1956
+ if (/[^\x00-\x7F]/.test(txt)) {
1957
+ return { ok: false, hint: 'input text 只支持 ASCII。中文等非 ASCII 字符请改用 kind:"paste"(需先让剪贴板里有内容)。' };
1958
+ }
1959
+ if (!/^[\w\s.,:/@#%&*()\-+=?!']{0,400}$/.test(txt)) return { ok: false, hint: 'text 含不支持的字符' };
1960
+ cmd = `input -d ${d} text "${txt.replace(/["\\$`]/g, '')}"`;
1961
+ } else if (kind === 'key') cmd = `input -d ${d} keyevent ${String(a.key || '').replace(/[^A-Z0-9_]/gi, '')}`;
1962
+ else if (kind === 'paste') {
1963
+ // 两种用法,行为不同:
1964
+ // 带 text → 发 SET_CLIPBOARD(paste=1),**server 自己会粘一次**,不能再补 keyevent,
1965
+ // 否则内容会粘两遍(复核实测:ZQ中文 → ZQ中文ZQ中文)。
1966
+ // 不带 text → 发 KEYCODE_PASTE,粘设备剪贴板里现有的内容。
1967
+ //
1968
+ // 注意:剪贴板是系统全局的,写它就是覆盖用户自己的剪贴板内容。
1969
+ if (a.text !== undefined && a.text !== null && String(a.text) !== '') {
1970
+ if (!setClipboard(String(a.text))) {
1971
+ return { ok: false, hint: '写剪贴板失败(控制通道没连上)。可以改用 kind:"text"(仅 ASCII)。' };
1972
+ }
1973
+ await sleep(300); // SET_CLIPBOARD 已经连带粘贴,等它生效即可
1974
+ cmd = null; // 不再补 keyevent
1975
+ } else {
1976
+ cmd = `input -d ${d} keyevent 279`; // KEYCODE_PASTE:粘现有剪贴板
1977
+ }
1978
+ }
1979
+ else return { ok: false, hint: `不认识的输入类型:${kind}` };
1980
+
1981
+ // 记下这次点/滑的位置,pickRoi 在没有 bbox 时用它兜底
1982
+ state.lastInputAt = {
1983
+ x: a.nx != null ? Number(a.nx) * state.width : (Number(a.x) || 0),
1984
+ y: a.ny != null ? Number(a.ny) * state.height : (Number(a.y) || 0),
1985
+ };
1986
+
1987
+ // verify 已在前面声明(tick 采样需要它)
1988
+ /*
1989
+ * **优先用视频流包数做校验,不用 screencap 哈希。**
1990
+ *
1991
+ * 实测:一次滑动让视频流从 102 个包涨到 110 个(画面确实变了),
1992
+ * 但 frameHash 前后哈希一样,于是返回 ok:false,调用方以为失败会重试。
1993
+ * 而且每次双截图要 286ms。
1994
+ *
1995
+ * 包数探测是 0ms、免费、而且 25fps 粒度比 screencap 的 143ms 灵敏。
1996
+ */
1997
+ // tick 已经在分派之前采好了(见上面的注释)
1998
+ // SET_CLIPBOARD 那条路 cmd 是 null(server 已经自己粘过,不能再发 keyevent)
1999
+ const out = cmd ? await shell(cmd) : '(SET_CLIPBOARD 已连带粘贴)';
2000
+ if (!verify) return { ok: true, displayId: d, out: out.trim(), changed: null };
2001
+
2002
+ await sleep(Number(a.settleMs) || 500);
2003
+ let changed = null;
2004
+ let probe = 'none';
2005
+ // **不能只认 'packets'。**
2006
+ // frameTick() 现在优先返回 { kind:'frames' }(videoReader 有 frames 字段时),
2007
+ // 只认 'packets' 会永远落进下面的 else 分支 → 两次 frameHash 之间没有 sleep
2008
+ // → 同帧 → changed 恒为 false → **每一次点击都报「画面没变」**(对抗审查发现的新回归)。
2009
+ if (tick && tick.kind !== 'none') {
2010
+ changed = await waitChanged(tick, Number(a.settleMs) || 900);
2011
+ probe = 'frame-' + tick.kind;
2012
+ if (!changed) {
2013
+ // 包数没动可能是编码器暂时没吐,再用 screencap 确认一次(贵但准)
2014
+ const bh = await frameHash();
2015
+ if (bh) {
2016
+ const ah = await sleep(300).then(() => frameHash());
2017
+ if (bh && ah && bh !== ah) { changed = true; probe = 'screencap-fallback'; }
2018
+ }
2019
+ }
2020
+ } else {
2021
+ // 没有视频流:回退到 screencap 哈希
2022
+ // **两次之间必须 sleep**,否则截的是同一帧,永远判「没变」。
2023
+ const before = await frameHash();
2024
+ await sleep(400);
2025
+ const after = await frameHash();
2026
+ changed = before && after ? before !== after : null;
2027
+ probe = 'screencap';
2028
+ }
2029
+
2030
+ // 只查一次会误报。实测:给虚拟屏发 KEYCODE_BACK 退掉设置页,
2031
+ // 画面确实变了(随后截是纯黑),但 500ms 那个时间点还没变完,
2032
+ // 于是返回 changed:false —— AI 会以为没生效、重复操作,造成双击这类事故。
2033
+ // 所以没变的时候再轮询几次,任一次变了就算生效。
2034
+ if (changed === false) {
2035
+ // 再给一点时间:有些操作(BACK 退动画)在 500ms 那个点还没变完
2036
+ for (let i = 0; i < 3 && changed === false; i += 1) {
2037
+ await sleep(400);
2038
+ if (tick && tick.kind !== 'none') {
2039
+ const cur = frameTick();
2040
+ if (cur.kind === tick.kind && cur.v !== tick.v) changed = true;
2041
+ }
2042
+ }
2043
+ }
2044
+
2045
+ return {
2046
+ ok: changed !== false, // 轮询完还是没变,才算这次操作大概率没生效
2047
+ displayId: d,
2048
+ changed,
2049
+ probe, // 用哪条路判断的:video-packets / screencap / screencap-fallback
2050
+ hint: changed === false
2051
+ ? '画面在 2 秒内一直没有变化,这一下可能真的没生效(坐标偏了 / 控件不可点 / 界面还没加载完)。建议重新截一张图确认位置,不要盲目重复点同一坐标。'
2052
+ : undefined,
2053
+ out: out.trim(),
2054
+ };
2055
+ }
2056
+
2057
+ /**
2058
+ * 截虚拟屏。返回本地路径。
2059
+ *
2060
+ * 带**画面去重**:如果这一帧和上次截的完全一样,直接返回上次那个路径并标 `unchanged:true`,
2061
+ * 调用方就不用再 read_image 了。为什么值得做:一张 720x1280 截图约 1.1k tokens
2062
+ * 且永久留在上下文里,长任务翻几屏就把上下文吃满了(实测 15 屏 → 上下文 203k→243k)。
2063
+ */
2064
+ export async function shot(dir = '/tmp', { width = 540, format = 'jpeg', cropPx = 0, region = null } = {}) {
2065
+ const s = await start();
2066
+ if (!s.ok) return { ok: false, hint: s.hint };
2067
+
2068
+ // **截图前先刷新 SF id**:转屏会让 SurfaceFlinger 重建虚拟屏并换新 id,
2069
+ // 拿旧 id 去 screencap 会报 "Display Id is not valid"(或静默截到别的屏)。
2070
+ await refreshSfId();
2071
+ if (!state.sfId) return { ok: false, hint: '没拿到这块屏的 SurfaceFlinger id,无法截图。' };
2072
+
2073
+ // 只截一次:以前先用 exec-out 算哈希、再 screencap 存文件,同一帧截了两次,
2074
+ // 复杂画面每张多花约 0.5 秒。现在截一次、哈希从本地文件算。
2075
+ const stamp = Date.now();
2076
+ const local = `${dir}/vd-${stamp}.png`;
2077
+ const remotePng = `/sdcard/dsh-vd-${stamp}.png`;
2078
+ const cap = await shell(`screencap -p -d ${state.sfId} ${remotePng}`);
2079
+ if (/Failed|invalid/i.test(cap)) {
2080
+ // 可能刚好卡在转屏瞬间:强制重新解析(不沿用旧值)再试一次
2081
+ const fresh = await resolveScrcpySfId();
2082
+ if (fresh) state.sfId = fresh;
2083
+ const cap2 = await shell(`screencap -p -d ${state.sfId} ${remotePng}`);
2084
+ if (/Failed|invalid/i.test(cap2)) {
2085
+ return {
2086
+ ok: false,
2087
+ hint: `截图失败:${cap2}\n当前缓存的 SF id=${state.sfId},重新解析${fresh ? '得到 ' + fresh : '失败(没有 scrcpy 屏,或同时存在多块分不清)'}。`
2088
+ + '\n可能虚拟屏已被销毁。可以先 vdisplay_status 确认,再 vdisplay_start 重建。',
2089
+ };
2090
+ }
2091
+ }
2092
+
2093
+ const pull = await adb(['pull', remotePng, local], 60000);
2094
+ await shell(`rm -f ${remotePng}`);
2095
+ if (!pull.ok) return { ok: false, hint: `拉取失败:${pull.err}` };
2096
+
2097
+ const { readFile: readBin } = await import('node:fs/promises');
2098
+ const { createHash } = await import('node:crypto');
2099
+ const pngBytes = await readBin(local);
2100
+ const hash = createHash('sha1').update(pngBytes).digest('hex');
2101
+
2102
+ // 从 PNG 的 IHDR 读真实像素尺寸(宽高在字节 16..24,大端 32 位)。
2103
+ // 为什么必须做:游戏强制横屏后这块屏会变成 1280x720,
2104
+ // 如果坐标换算还按 720x1280 算,nx/ny 和 x/y 全都会错。
2105
+ try {
2106
+ if (pngBytes.length > 24 && pngBytes.readUInt32BE(12) === 0x49484452 /* 'IHDR' */) {
2107
+ const w = pngBytes.readUInt32BE(16);
2108
+ const h = pngBytes.readUInt32BE(20);
2109
+ if (w > 0 && h > 0 && (w !== state.width || h !== state.height)) {
2110
+ state.width = w;
2111
+ state.height = h;
2112
+ state.lastShotHash = null; // 尺寸变了,旧的去重基准作废
2113
+ state.lastShotPath = null;
2114
+ state.lastShotImgWidth = 0; // 旧的图片宽度也作废,否则坐标换算倍率会错
2115
+ }
2116
+ }
2117
+ } catch { /* 读不出来就沿用旧值 */ }
2118
+ // **去重必须带上出图参数**:以前只比 hash,导致「画面没变时改了 width 或 crop,
2119
+ // 拿回来还是上一张旧图」—— 实测把 540 改成 720、开了 crop 都没反应,极易误判成
2120
+ // 裁剪功能坏了。现在 hash + 参数全一致才复用。
2121
+ const regionKey = region ? `${region.x},${region.y},${region.w},${region.h}` : "-";
2122
+ const cacheKey = `${hash}|${width}|${format}|${Math.round(cropPx)}|${regionKey}`;
2123
+ if (cacheKey === state.lastShotCacheKey && state.lastShotPath && state.lastShotPath !== local) {
2124
+ try {
2125
+ const { unlink } = await import('node:fs/promises');
2126
+ await unlink(local);
2127
+ // **命中缓存也要返回完整字段。** 之前只回 path/displayId/unchanged,
2128
+ // 缺 width/height/imageWidth/imageHeight/regionUsed —— 调用方(比如 vdisplay_text)
2129
+ // 拿不到尺寸就退回 720x1280 的默认值,算出来的坐标全偏。
2130
+ return {
2131
+ ok: true, path: state.lastShotPath, displayId: state.displayId, unchanged: true,
2132
+ // **必须带 hash。**
2133
+ // 这条是「画面没变,复用上次截图」的快路 —— 而它恰恰是最该命中 OCR 缓存的时候。
2134
+ // 原来这里不返回 hash,调用方拿到 undefined → cacheKey=null → 缓存永远不命中
2135
+ // → 每次仍然白跑 1.6 秒 OCR(对抗审查 + OCR 专项审查都指出了这个洞)。
2136
+ hash: state.lastShotHash,
2137
+ width: state.lastShotW || state.width, height: state.lastShotH || state.height,
2138
+ imageWidth: state.lastShotImgWidth || state.width,
2139
+ imageHeight: state.lastShotImgHeight || state.height,
2140
+ croppedBottom: 0,
2141
+ regionUsed: state.lastShotRegion || null,
2142
+ hint: '画面和上次截图完全一样,复用上次那张',
2143
+ };
2144
+ } catch { /* 删不掉就继续用新的 */ }
2145
+ }
2146
+
2147
+ // 转成 540 宽 JPEG。**必须用本地 proot 的 ffmpeg**:设备上没有 ffmpeg
2148
+ // (实测 `adb shell ffmpeg` → inaccessible or not found)。
2149
+ let finalPath = local;
2150
+ // 记录**实际**产出的图片宽度:转码失败会退回原始 PNG(720 宽),
2151
+ // 这时如果还按 540 报,坐标换算的倍率就错了,33% 偏移会重新出现
2152
+ // (复核实测:PATH 去掉 ffmpeg 后返回 720 宽 PNG 却声明 imageWidth 540)。
2153
+ let finalImgWidth = state.width;
2154
+ // region:只看屏幕的某一块,把那一块按 width 交付。
2155
+ // **为什么这样比全屏缩放强**:全屏 720 宽交付到 420 是 0.583x(缩了);
2156
+ // 取 360 宽的局部交付到 420,是 1.167x —— 相对全屏有 2 倍线性分辨率,
2157
+ // 而 360x796 面积 286K 刚好卡在地板价上,只要 180 token(全屏要 684)。
2158
+ // 也就是说:更少的 token,两倍的细节。这就是"看不清就放大"的正确做法。
2159
+ const regionFilter = (() => {
2160
+ if (!region || !Number.isFinite(region.w) || region.w <= 0) return '';
2161
+ const rx = Math.max(0, Math.round(region.x || 0));
2162
+ const ry = Math.max(0, Math.round(region.y || 0));
2163
+ const rw = Math.round(region.w);
2164
+ const rh = Math.round(region.h || 0);
2165
+ if (rw < 8 || rh < 8) return '';
2166
+ // 越界必须拦下来:ffmpeg 的 crop 默认 exact=0,会给一个超界的框自动平移进图内
2167
+ // (比如 720 宽屏上要 x=700,w=360,实际裁 360..720),结果是看着成功、位置全错。
2168
+ // 宁可报错让调用方改,也不静默平移。
2169
+ if (state.width && state.height) {
2170
+ if (rx + rw > state.width || ry + rh > state.height) {
2171
+ region.__oob = `region 超出屏幕范围(屏 ${state.width}x${state.height},要 ${rx},${ry} ${rw}x${rh})`;
2172
+ return '';
2173
+ }
2174
+ }
2175
+ return `crop=${rw}:${rh}:${rx}:${ry},`;
2176
+ })();
2177
+ // region 和 crop **互斥**:先 region 再切底部会把 region 里靠下的部分切掉,
2178
+ // region 高度 ≤ 裁剪量时 ffmpeg 还会直接报错、退回未裁剪整屏(连 region 都白给)。
2179
+ // 有 region 时以 region 为准,忽略 crop。
2180
+ // region 越界直接拒绝,不要拿一张位置错的图给模型
2181
+ if (region && region.__oob) {
2182
+ return { ok: false, hint: region.__oob + '。请改成屏内的坐标,或用 nx/ny 归一化。' };
2183
+ }
2184
+
2185
+ const pre = region ? regionFilter : (cropPx > 0 ? `crop=iw:ih-${Math.round(cropPx)}:0:0,` : '');
2186
+ if (format === 'jpeg') {
2187
+ const jpg = local.replace(/\.png$/, '.jpg');
2188
+ // 限制宽高比:region 可能是 100x1000 这种极端形状,按宽缩到 540 会变成 540x5400,
2189
+ // 既贵到爆又没法看。按长边限制,同时保证短边不小于 240。
2190
+ let targetW = Math.max(240, Math.min(1080, Number(width) || 540));
2191
+ if (region && Number(region.w) > 0 && Number(region.h) > 0) {
2192
+ const aspect = Number(region.h) / Number(region.w);
2193
+ const MAX_H = 2400;
2194
+ if (targetW * aspect > MAX_H) targetW = Math.max(240, Math.round(MAX_H / aspect));
2195
+ }
2196
+ // cropPx > 0 时先裁掉底部(浏览器壳),再缩放。实测 720x1592 → 720x1372,
2197
+ // 内容一像素不变,token 从 684 降到 594。裁不动就自动忽略。
2198
+ const conv = await new Promise((res) => {
2199
+ execFile('ffmpeg', ['-y', '-loglevel', 'error', '-i', local, '-vf', `${pre}scale=${targetW}:-1`, '-q:v', '4', jpg],
2200
+ (e) => res(!e));
2201
+ });
2202
+ if (conv) {
2203
+ try {
2204
+ const { access } = await import('node:fs/promises');
2205
+ await access(jpg);
2206
+ finalPath = jpg;
2207
+ finalImgWidth = targetW;
2208
+ } catch { finalPath = local; finalImgWidth = state.width; }
2209
+ } else {
2210
+ finalPath = local;
2211
+ finalImgWidth = state.width; // 退回 PNG,宽度就是显示宽度
2212
+ }
2213
+ }
2214
+ // PNG 路径也要支持裁剪,否则行为不一致:OCR 走的就是 png,
2215
+ // 不带裁剪会多读地址栏里的网址和按钮文字(实测会混进结果里)。
2216
+ // PNG 也要支持 region 和 crop,否则行为不一致(OCR 走的就是 png)。
2217
+ if (format !== 'jpeg' && (pre || region)) {
2218
+ const png2 = local.replace(/\.png$/, '-view.png');
2219
+ // 跟 jpeg 分支保持一致:region 和 crop 互斥(region 优先),不要各写一套
2220
+ const filt2 = region
2221
+ ? `crop=${Math.round(region.w)}:${Math.round(region.h)}:${Math.max(0, Math.round(region.x || 0))}:${Math.max(0, Math.round(region.y || 0))}`
2222
+ : (cropPx > 0 ? `crop=iw:ih-${Math.round(cropPx)}:0:0` : '');
2223
+ if (filt2) {
2224
+ const ok2 = await new Promise((res) => {
2225
+ execFile('ffmpeg', ['-y', '-loglevel', 'error', '-i', local, '-vf', filt2, png2],
2226
+ (e) => res(!e));
2227
+ });
2228
+ if (ok2) {
2229
+ try {
2230
+ const { access } = await import('node:fs/promises');
2231
+ await access(png2);
2232
+ finalPath = png2;
2233
+ // PNG 分支只裁不缩,出图宽就是 region 宽(不是屏宽)。写错会让 input 的 scale 错 2 倍。
2234
+ finalImgWidth = (region && Number(region.w) > 0) ? Math.round(region.w) : state.width;
2235
+ } catch { /* 用原图 */ }
2236
+ }
2237
+ }
2238
+ }
2239
+ state.lastShotHash = hash;
2240
+ state.lastShotCacheKey = `${hash}|${width}|${format}|${Math.round(cropPx)}|${regionKey}`;
2241
+ // 记下这张图是屏幕的哪一块,input 换算坐标时要用(region 没记会导致点歪)
2242
+ state.lastShotRegion = region ? { x: Math.max(0, Math.round(region.x||0)), y: Math.max(0, Math.round(region.y||0)), w: Math.round(region.w), h: Math.round(region.h||0) } : null;
2243
+ state.lastShotPath = finalPath;
2244
+ state.lastShotImgWidth = finalImgWidth;
2245
+ state.lastShotW = state.width;
2246
+ state.lastShotH = state.height;
2247
+ try {
2248
+ // 记录实际出图高度,缓存命中时要原样返回
2249
+ const { execFileSync } = await import('node:child_process');
2250
+ const out2 = execFileSync('ffprobe', ['-v','error','-select_streams','v:0','-show_entries','stream=width,height','-of','csv=p=0', finalPath], { timeout: 8000 }).toString().trim();
2251
+ const parts = out2.split(',').map(Number);
2252
+ if (parts.length === 2 && parts[1] > 0) state.lastShotImgHeight = parts[1];
2253
+ } catch { state.lastShotImgHeight = state.height; }
2254
+ return {
2255
+ ok: true, path: finalPath, displayId: state.displayId, unchanged: false,
2256
+ hash, // 必须返回:vdisplay_text 拿它做 OCR 缓存键,不然缓存永远不命中,每次白等 1.6 秒
2257
+ // **一定要带尺寸**:之前完全不返回,调用方只能猜坐标系。
2258
+ // 注意分清两个尺寸:imageWidth/imageHeight 是**你正在看的这张图**的像素,
2259
+ // width/height 是显示的逻辑像素。点 x/y 时按图片像素给就行(插件会自动换算)。
2260
+ width: state.width, height: state.height,
2261
+ imageWidth: state.lastShotImgWidth || state.width,
2262
+ // imageHeight 必须按**实际出图**算:裁剪和 region 都改变了内容区域,
2263
+ // 以前直接按整屏比例算,裁剪后返回 1592 而实际只有 1372,谁拿它算坐标就会偏。
2264
+ // **分母必须跟 region 一致**:出图高度 = region 高度 × (出图宽 / region 宽)。
2265
+ // 之前用 state.width 当分母,region 时算出 464 而实际 929(差 2 倍),
2266
+ // 谁拿它算坐标就偏一倍 —— 对抗审查第 S6 条。
2267
+ imageHeight: Math.round((() => {
2268
+ const outW = state.lastShotImgWidth || state.width;
2269
+ const srcW = region && Number(region.w) > 0 ? Number(region.w) : state.width;
2270
+ const ratio = srcW > 0 ? outW / srcW : 1;
2271
+ let contentH = state.height;
2272
+ if (cropPx > 0 && cropPx < state.height) contentH -= cropPx;
2273
+ if (region && Number(region.h) > 0) contentH = Number(region.h);
2274
+ return contentH * ratio;
2275
+ })()),
2276
+ // 调用方要拿这两个才能把 nx/ny 算对
2277
+ croppedBottom: cropPx > 0 && cropPx < state.height ? cropPx : 0,
2278
+ regionUsed: region ? { x: region.x || 0, y: region.y || 0, w: region.w, h: region.h } : null,
2279
+ hint: `这张图是 ${state.lastShotImgWidth || state.width} 宽,显示逻辑尺寸 ${state.width}x${state.height}。`
2280
+ + '点 x/y 按图片里的像素给即可(插件自动换算),或者直接用 nx/ny(0..1)。',
2281
+ };
2282
+ }
2283
+
2284
+ /** 主屏截图(只读,不打扰)。 */
2285
+ export async function mainShot(dir = '/tmp', { width = 540, format = 'jpeg' } = {}) {
2286
+ await mkdir(dir, { recursive: true });
2287
+ const stamp = Date.now();
2288
+ const remote = `/sdcard/dsh-main-${stamp}.png`;
2289
+ await shell(`screencap -p ${remote}`);
2290
+ const local = join(dir, `main-${stamp}.png`);
2291
+ const pull = await adb(['pull', remote, local], 60000);
2292
+ await shell(`rm -f ${remote}`);
2293
+ if (!pull.ok) return { ok: false, hint: pull.err };
2294
+
2295
+ // **参数必须真的生效。** tool-spec 承诺"width 默认 540,省约 44% token""format jpeg 默认",
2296
+ // 但实现一直只回原生 PNG(1.1MP+,token 是承诺的 3-5 倍),长任务里很吃上下文。
2297
+ // 这里按跟 vd.shot 一样的规则走一次 ffmpeg。
2298
+ let finalPath = local;
2299
+ let finalW = 0;
2300
+ try {
2301
+ const { execFileSync } = await import('node:child_process');
2302
+ const probe = execFileSync('ffprobe', ['-v', 'error', '-select_streams', 'v:0',
2303
+ '-show_entries', 'stream=width,height', '-of', 'csv=p=0', local], { timeout: 8000 }).toString().trim();
2304
+ const parts = probe.split(',').map(Number);
2305
+ const srcW = parts[0] || 0;
2306
+ finalW = srcW;
2307
+ const targetW = Math.max(240, Math.min(1080, Number(width) || 540));
2308
+ const ext = format === 'png' ? 'png' : 'jpg';
2309
+ const out = local.replace(/\.png$/, `-s.${ext}`);
2310
+ const vf = format === 'png' ? `scale=${targetW}:-1` : `scale=${targetW}:-1`;
2311
+ const args = ['-y', '-loglevel', 'error', '-i', local, '-vf', vf];
2312
+ if (format !== 'png') args.push('-q:v', '4');
2313
+ args.push(out);
2314
+ execFileSync('ffmpeg', args, { timeout: 20000 });
2315
+ finalPath = out;
2316
+ finalW = targetW;
2317
+ } catch { /* ffmpeg 不可用就回原生 PNG,把真实宽度报出去 */ }
2318
+
2319
+ return { ok: true, path: finalPath, imageWidth: finalW };
2320
+ }
2321
+
2322
+ /**
2323
+ * 主屏(display 0)当前前台是谁。
2324
+ *
2325
+ * 不能用 `dumpsys activity activities | grep topResumedActivity` —— 那是**全局**的,
2326
+ * 虚拟屏上的 Activity 也会算进来,会误判「主屏被抢」。
2327
+ * 也不能用固定行数的 `grep -A40`:有虚拟屏时 display 0 那一段会变长,40 行不够(踩过)。
2328
+ * 所以整段解析:找到 "Display: mDisplayId=0" 之后,一直读到下一个 "Display:" 为止。
2329
+ *
2330
+ * 建屏/销毁的瞬间焦点可能是 null,读一次会拿到空。重试四次,仍空就返回 '' 表示"没测到",
2331
+ * 让调用方区分「没变化」和「没测到」,而不是拿空值当变化(踩过:误判后去 monkey 桌面,把用户屏幕切了)。
2332
+ */
2333
+ export async function mainFocus() {
2334
+ for (let i = 0; i < 4; i += 1) {
2335
+ const out = await shell('dumpsys window displays 2>/dev/null');
2336
+ const lines = out.split('\n');
2337
+ let inside = false;
2338
+ for (const line of lines) {
2339
+ if (/Display:\s*mDisplayId=/.test(line)) {
2340
+ inside = /Display:\s*mDisplayId=0\b/.test(line);
2341
+ continue;
2342
+ }
2343
+ if (inside) {
2344
+ const m = line.match(/mCurrentFocus=Window\{[0-9a-f]+ u0 ([\w.]+)\/([\w.$]+)\}/);
2345
+ if (m) return `${m[1]}/${m[2]}`;
2346
+ }
2347
+ }
2348
+ await sleep(300);
2349
+ }
2350
+ return '';
2351
+ }
2352
+
2353
+ // **模块加载时恢复上次的屏**,这样新进程不会重复建屏。
2354
+ try { loadPersistedState(); } catch { /* ignore */ }