Skip to content

Windows 上的安卓应用运行器:双击 APK 即装,应用以独立窗口与桌面图标运行,自持 QEMU 运行时

fix: 下载器不再挂死 + 分块断点续传;镜像换盘不再清用户数据

RoutineMikud505c9d5dfdc
diff --git a/.github/release-notes-v0.3.3.md b/.github/release-notes-v0.3.3.md
new file mode 100644
index 0000000..b5777b2
--- /dev/null
+++ b/.github/release-notes-v0.3.3.md
@@ -0,0 +1,48 @@
+## 这一版解决什么
+
+### 1. 下载慢:真正的原因是「所有线程都挤在一个被墙的地址上」
+
+实测这台机器:8 线程全打 GitHub 只有 **0.23 MB/s**,113MB 的更新包要 **493 秒**;
+同一时间两条连接打直连是**零字节**(TCP 通但没有数据),只有镜像在跑。
+
+- **多源并行分片**:文件切块后,不同块同时从「GitHub 直连 / ghfast / gh-proxy」拉,带宽叠加。
+ 同一台机器实测:**113MB 从 493 秒降到 77 秒**(约 1.5 MB/s,含测速与解压)。
+- **停滞看门狗**:连接建立了但 20 秒不给字节,立刻丢弃这条连接换下一个源,
+ 不再傻等 30 秒 socket 超时把整包卡死。
+- **每次现测现选**:每个候选地址真下 256KB 测速,只算「收到首字节之后」的吞吐
+ (握手几百毫秒算进去会把「延迟高但带宽大」的源误判成慢);顺序测避免互相抢带宽。
+
+### 2. 双源:GitHub 与 Gitee 自动选优
+
+- 两个仓库现在都是公开的:GitHub `RoutineMiku/apkstart`、Gitee `daily-miku/apkstart`。
+- 版本检查同时问两边,取版本号更高的;一个源超时/被墙不影响另一个。
+- Gitee 发行版附件单文件上限 100MB,所以便携包在那里以 `.part1/.part2` 发布,
+ 客户端自动逐片选源下载再拼回整包(校验各片大小,缺片即中止)。
+- Gitee 匿名调用有限流:加了 10 分钟版本缓存 + 403/429 熔断 15 分钟,
+ 两个源全挂时退回上一次结果并标记 `stale`,界面不会直接报错。
+
+### 3. 不会再误删用户数据
+
+- **磁盘写满时不再自动清数据**:以前重试矩阵最后一档带 `-wipe-data`,磁盘满时每档都失败,
+ 连续重试会把应用和存档一起抹掉。现在任何自动重试都禁止清数据,磁盘不足直接停下并告诉你怎么办。
+- **镜像换盘不算换镜像**:把运行时目录从 C 盘挪到 D 盘(设置里就建议这么做)以后,
+ 以前会被判定「镜像变了」→ `-wipe-data` → 已装应用全丢。现在按镜像身份比较,换盘不动数据。
+- **`qemu-img resize` 参数顺序**修正:以前会出现「文件撑到 6GB、文件系统还是 64MB」,
+ 安卓一写就满,所有服务 `setxattr` 报 ENOSPC 崩掉。现在启动时还会自愈比对。
+
+### 4. 其他
+
+- 安装失败不再刷屏:同一个 APK 连点只跑一次;失败提示按类型给出可执行结论
+ (分区不够 / ARM 包 / 签名冲突 / 版本降级)。
+- 资源与磁盘可控:资源策略三档(省资源 / 均衡 / 流畅)、画质三档、
+ 安卓数据分区 4–24GB 可调并支持就地扩容(不丢已装应用)、安卓数据目录可单独指到别的盘。
+- 体积:便携版 230MB(裁掉 52 个用不到的语言包,省 39MB)。
+- 日志按大小滚动,不再无限增长;共享目录同步不再把同一个文件反复搬来搬去。
+
+## 安装
+
+- **完整版** `ApkStart-*-Setup.exe`:自带运行时,装完即用(约 1.4GB)。
+- **轻量版** `ApkStart-*-win64-portable.zip`:解压即用,首次启动自动下载运行时
+ (现在会挑最快的源,且断点续传)。
+
+两个仓库内容一致,国内建议走 Gitee。
diff --git a/src/core/doctor.js b/src/core/doctor.js
index 0e4840d..8805c21 100644
--- a/src/core/doctor.js
+++ b/src/core/doctor.js
@@ -297,10 +297,25 @@ async function freeAdbPort(start = 5044) {
*/
function snapshotKey(plan, imageDir) {
return crypto.createHash('sha1').update([
- imageDir, plan.emulatorVersion || '', plan.api || '', plan.tag || '',
+ imageIdentity(imageDir), plan.emulatorVersion || '', plan.api || '', plan.tag || '',
].join('|')).digest('hex').slice(0, 16);
}
+/**
+ * 系统镜像的「身份」:只保留 `system-images/...` 之后的部分。
+ *
+ * 镜像放哪个盘都无所谓,同一套镜像换个目录不该被当成「换了镜像」——
+ * 否则用户把运行时从 C 盘挪到 D 盘(我们自己在设置里就建议这么做)以后,
+ * AVD 里的 sysdir 与新路径不一致 → 判定镜像变了 → -wipe-data → 已装应用全丢。
+ * 这个坑在实测中真的会踩到,所以两个地方(AVD 配置、快照指纹)都必须用身份而不是绝对路径。
+ */
+function imageIdentity(dir) {
+ const p = String(dir || '').replace(/\\/g, '/').replace(/\/+$/, '');
+ const i = p.indexOf('system-images/');
+ if (i >= 0) return p.slice(i);
+ return p.split('/').slice(-3).join('/');
+}
+
const RULES = [
{
code: 'GPU_INIT',
@@ -470,6 +485,6 @@ module.exports = {
hostInfo, freeDiskMB, isAsciiPath, shortPath, lcdFor, liteProfile,
versionNumbers, gpuCandidates, chooseProfile, planVariants,
overridesFromSettings, autoProfile,
- freePortPair, freeAdbPort, snapshotKey,
+ freePortPair, freeAdbPort, snapshotKey, imageIdentity,
diagnose, describeProfile, writeReport, vcRedistOk,
};
diff --git a/src/core/download.js b/src/core/download.js
index bfbecf5..b2ffce1 100644
--- a/src/core/download.js
+++ b/src/core/download.js
@@ -106,11 +106,35 @@ async function download(url, dest, opt = {}) {
let lastBytes = got;
const ws = fs.createWriteStream(dest, { flags: startSize > 0 ? 'a' : 'w' });
+ // 和分块下载一样:必须保证 promise 一定会 settle。
+ // 连接静默(被墙/被限速)时 res 既不 end 也不 error,pipe 永远不 finish,
+ // 整个下载就卡死在这里,用户看到的是进度条不动、也没有报错。
+ const idleMs = Number(opt.idleMs) > 0 ? Number(opt.idleMs) : 30000;
+ let settled = false;
+ let idle = null;
+ const finish = (err) => {
+ if (settled) return;
+ settled = true;
+ if (idle) clearTimeout(idle);
+ try { ws.destroy(); } catch (_) { /* ignore */ }
+ if (err) reject(err); else resolve();
+ };
+ const kick = () => {
+ if (settled) return;
+ if (idle) clearTimeout(idle);
+ idle = setTimeout(() => {
+ res.destroy();
+ finish(new Error('连接停滞(长时间无数据)'));
+ }, idleMs);
+ };
+ kick();
+
const onAbort = () => { res.destroy(new Error('已取消')); };
if (signal) signal.addEventListener('abort', onAbort, { once: true });
res.on('data', (c) => {
got += c.length;
+ kick();
const now = Date.now();
if (now - lastTick > 400) {
const speed = (got - lastBytes) / ((now - lastTick) / 1000);
@@ -125,9 +149,10 @@ async function download(url, dest, opt = {}) {
}
});
res.pipe(ws);
- ws.on('finish', () => resolve());
- ws.on('error', reject);
- res.on('error', reject);
+ ws.on('finish', () => finish());
+ ws.on('error', (e) => finish(e));
+ res.on('error', (e) => finish(e));
+ res.on('close', () => { if (!res.complete) finish(new Error('连接被中断')); });
});
break;
@@ -186,6 +211,7 @@ async function downloadParallel(url, dest, opt = {}) {
const n = Math.max(1, Math.min(connections, Math.ceil(total / minChunk)));
const per = Math.ceil(total / n);
+ const idleMs = Number(opt.idleMs) > 0 ? Number(opt.idleMs) : 20000;
fs.mkdirSync(path.dirname(dest), { recursive: true });
fs.rmSync(dest, { force: true });
@@ -223,19 +249,35 @@ async function downloadParallel(url, dest, opt = {}) {
throw new Error(`分块请求被拒绝 HTTP ${res.statusCode}`);
}
await new Promise((resolve, reject) => {
+ // 必须自己兜住「promise 永远不 settle」:res.destroy(err) 在某些情况下只发
+ // close 不发 error,没有这个 guard 的话一整块会挂死,整个下载停在那里不动。
+ let settled = false;
+ const finish = (err) => {
+ if (settled) return;
+ settled = true;
+ clearTimeout(idle);
+ if (err) reject(err); else resolve();
+ };
+ let idle = setTimeout(() => { res.destroy(); finish(new Error('连接停滞(长时间无数据)')); }, idleMs);
+ const kick = () => {
+ clearTimeout(idle);
+ idle = setTimeout(() => { res.destroy(); finish(new Error('连接停滞(长时间无数据)')); }, idleMs);
+ };
res.on('data', (buf) => {
try {
fs.writeSync(fd, buf, 0, buf.length, c.pos);
} catch (e) {
res.destroy();
- return reject(e);
+ return finish(e);
}
c.pos += buf.length;
got += buf.length;
+ kick();
tick();
});
- res.on('end', resolve);
- res.on('error', reject);
+ res.on('end', () => finish());
+ res.on('error', (e) => finish(e));
+ res.on('close', () => finish(new Error('连接被中断')));
});
return c.pos > c.end;
};
@@ -298,8 +340,12 @@ async function downloadMulti(urls, dest, opt = {}) {
connections = 8,
onProgress = () => {},
minChunk = 2 * 1024 * 1024,
- retries = 3,
+ // 每个分块的重试次数。3 次在「三个源里有两个偶尔停摆」的链路上不够用:
+ // 1.4GB 的运行时包一旦有块耗尽重试,整包作废重下。给到 6 次(每源两轮)。
+ // 重试是从断点继续的(c.pos 保留),不会重复下载已收到的字节。
+ retries = 6,
} = opt;
+ const idleMs = Number(opt.idleMs) > 0 ? Number(opt.idleMs) : 20000;
const list = [...new Set((urls || []).filter(Boolean))];
if (!list.length) throw new Error('没有可用的下载地址');
@@ -333,9 +379,27 @@ async function downloadMulti(urls, dest, opt = {}) {
const n = Math.max(2, Math.min(connections, Math.ceil(total / minChunk)));
const per = Math.ceil(total / n);
fs.mkdirSync(path.dirname(dest), { recursive: true });
- fs.rmSync(dest, { force: true });
- const fd = fs.openSync(dest, 'w');
- fs.ftruncateSync(fd, total);
+
+ // 分块断点续传:1.4GB 的包在「镜像偶尔停摆」的链路上很容易有块耗尽重试,
+ // 一旦整包作废重下,用户要再等十几分钟。这里把「哪些块已经下完」记在
+ // 边车文件里,下次(同一路径、同一分块方式)只补缺的块。
+ const meta = `${dest}.chunks.json`;
+ let doneSet = new Set();
+ let resume = false;
+ try {
+ const m = JSON.parse(fs.readFileSync(meta, 'utf8'));
+ if (m && m.total === total && m.n === n && fs.existsSync(dest) && fs.statSync(dest).size === total) {
+ doneSet = new Set(m.done || []);
+ resume = true;
+ }
+ } catch (_) { /* 没有边车就全新下 */ }
+
+ if (!resume) {
+ fs.rmSync(dest, { force: true });
+ fs.rmSync(meta, { force: true });
+ }
+ const fd = resume ? fs.openSync(dest, 'r+') : fs.openSync(dest, 'w');
+ if (!resume) fs.ftruncateSync(fd, total);
const chunks = Array.from({ length: n }, (_, i) => ({
start: i * per,
@@ -343,11 +407,20 @@ async function downloadMulti(urls, dest, opt = {}) {
pos: i * per,
src: i % same.length,
tries: 0,
- }));
+ })).filter((c) => !doneSet.has(c.start));
- let got = 0;
+ const saveMeta = () => {
+ try {
+ fs.writeFileSync(meta, JSON.stringify({ total, n, done: [...doneSet] }));
+ } catch (_) { /* 边车写不进去不影响下载 */ }
+ };
+
+ // 续传时把已完成的块算进进度,用户看到的百分比不会从 0 重来
+ let got = resume ? [...doneSet].reduce((sum, start) => (
+ sum + (Math.min(total - 1, start + per - 1) - start + 1)
+ ), 0) : 0;
let lastTick = Date.now();
- let lastBytes = 0;
+ let lastBytes = got;
const tick = (force) => {
const now = Date.now();
if (!force && now - lastTick < 400) return;
@@ -372,24 +445,37 @@ async function downloadMulti(urls, dest, opt = {}) {
throw new Error(`分块被拒绝 HTTP ${res.statusCode}`);
}
await new Promise((resolve, reject) => {
- // 空闲看门狗:连接建立了但一个字节都不来(常见的「TCP 通但被墙/被限」),
- // 光等 socket 超时要 30 秒,一块卡住整包就停在那里。20 秒没动静就换源。
- let idle = setTimeout(() => res.destroy(new Error('连接停滞(20 秒无数据)')), 20000);
- const kick = () => { clearTimeout(idle); idle = setTimeout(() => res.destroy(new Error('连接停滞(20 秒无数据)')), 20000); };
+ // 空闲看门狗 + 「保证 settle」:连接建立了但一个字节都不来(常见的
+ // 「TCP 通但被墙/被限」),光等 socket 超时要 30 秒;而 res.destroy(err)
+ // 可能只发 close 不发 error,promise 就永远不会 reject —— 表现是一块挂死、
+ // 整个下载停在那里(实测踩过)。所以看门狗自己调用 finish。
+ let settled = false;
+ const finish = (err) => {
+ if (settled) return;
+ settled = true;
+ clearTimeout(idle);
+ if (err) reject(err); else resolve();
+ };
+ let idle = setTimeout(() => { res.destroy(); finish(new Error('连接停滞(长时间无数据)')); }, idleMs);
+ const kick = () => {
+ clearTimeout(idle);
+ idle = setTimeout(() => { res.destroy(); finish(new Error('连接停滞(无数据超时)')); }, idleMs);
+ };
res.on('data', (buf) => {
try {
fs.writeSync(fd, buf, 0, buf.length, c.pos);
} catch (e) {
res.destroy();
- return reject(e);
+ return finish(e);
}
c.pos += buf.length;
got += buf.length;
kick();
tick(false);
});
- res.on('end', () => { clearTimeout(idle); resolve(); });
- res.on('error', (e) => { clearTimeout(idle); reject(e); });
+ res.on('end', () => finish());
+ res.on('error', (e) => finish(e));
+ res.on('close', () => finish(new Error('连接被中断')));
});
return c.pos > c.end;
};
@@ -399,11 +485,19 @@ async function downloadMulti(urls, dest, opt = {}) {
for (;;) {
try {
// eslint-disable-next-line no-await-in-loop
- if (await fetchChunk(c)) return;
+ if (await fetchChunk(c)) {
+ doneSet.add(c.start);
+ saveMeta();
+ return;
+ }
throw new Error('分块未完整返回');
} catch (e) {
c.tries += 1;
- if (c.tries >= retries) throw new Error(`分块失败(${c.start}-${c.end}):${e.message}`);
+ if (c.tries >= retries) {
+ // 记下已完成的部分(边车),下次从缺的块继续,而不是从头再下 1.4GB
+ saveMeta();
+ throw new Error(`分块失败(${c.start}-${c.end}):${e.message}`);
+ }
// 换一个源再试:一个镜像抽风不该拖垮整个下载
c.src += 1;
// eslint-disable-next-line no-await-in-loop
@@ -416,11 +510,12 @@ async function downloadMulti(urls, dest, opt = {}) {
throw e;
}
fs.closeSync(fd);
+ fs.rmSync(meta, { force: true });
const size = fs.statSync(dest).size;
tick(true);
if (size !== total) throw new Error(`下载不完整:${size}/${total} 字节`);
- return { file: dest, size, parallel: n, sources: same.length, multi: true };
+ return { file: dest, size, parallel: n, sources: same.length, multi: true, resumed: resume };
}
/** 依次尝试多个源(并行分块版),任一成功即返回 */
diff --git a/src/core/emulator.js b/src/core/emulator.js
index 3787410..078c0fd 100644
--- a/src/core/emulator.js
+++ b/src/core/emulator.js
@@ -251,7 +251,11 @@ class EmulatorEngine {
const prev = fs.readFileSync(cfgPath, 'utf8');
const prevTag = /tag\.id=(.+)$/m.exec(prev);
const prevImg = /image\.sysdir\.1=(.+)$/m.exec(prev);
- if ((prevTag && prevTag[1].trim() !== tag) || (prevImg && prevImg[1].trim() !== wantImg)) {
+ // 比较「镜像身份」而不是绝对路径:同一套镜像换盘/换目录不算换镜像,
+ // 否则用户一改运行时目录就会被清掉所有已装应用(见 doctor.imageIdentity 注释)。
+ const prevId = prevImg ? doctor.imageIdentity(prevImg[1].trim()) : '';
+ const wantId = doctor.imageIdentity(wantImg);
+ if ((prevTag && prevTag[1].trim() !== tag) || (prevId && prevId !== wantId)) {
// 旧 userdata 与新镜像不兼容(APEX 引导循环),必须重建
this.wipePending = true;
}
diff --git a/src/core/sources.js b/src/core/sources.js
index 39deb6d..c048d8e 100644
--- a/src/core/sources.js
+++ b/src/core/sources.js
@@ -346,11 +346,20 @@ class Sources {
return result;
}
- /** 某个资产在所有源 + 镜像下的候选地址(去重、保序:源站优先,其次镜像) */
+ /**
+ * 某个资产在所有源 + 镜像下的候选地址(去重、保序:源站优先,其次镜像)。
+ * 镜像只套在 GitHub 的地址上:ghfast / gh-proxy 只代理 GitHub,
+ * 把 Gitee 的链接拼上去只会得到一个 403,白白多测一次速。
+ */
candidates(assetOrUrl) {
const url = typeof assetOrUrl === 'string' ? assetOrUrl : assetOrUrl.url;
const out = [];
- if (url) out.push(url);
+ if (!url) return out;
+ out.push(url);
+ let host = '';
+ try { host = new URL(url).host.toLowerCase(); } catch (_) { return out; }
+ const isGithub = /(^|\.)github\.com$/.test(host) || /(^|\.)githubusercontent\.com$/.test(host);
+ if (!isGithub) return out;
for (const m of mirrorList(this.settings())) {
const u = withMirror(url, m);
if (u && !out.includes(u)) out.push(u);
diff --git a/test/auto-test.js b/test/auto-test.js
index 25c72e2..a1f3bbd 100644
--- a/test/auto-test.js
+++ b/test/auto-test.js
@@ -85,6 +85,16 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
assert(new Set(keys).size === keys.length, '重试方案不应重复');
});
+ await test('镜像换盘不算换镜像:sysdir 换了目录不该清用户数据', () => {
+ const c = 'C:/Users/x/AppData/Roaming/apkstart/system-images/android-34/google_apis_playstore/x86_64/';
+ const d = 'D:/ApkStartRuntime/system-images/android-34/google_apis_playstore/x86_64/';
+ assert(doctor.imageIdentity(c) === doctor.imageIdentity(d), '同一套镜像的路径身份必须相同');
+ const key = (p) => doctor.snapshotKey({ emulatorVersion: '37.3.8', api: '34', tag: 'google_apis_playstore' }, p);
+ assert(key(c) === key(d), '换盘后快照不该作废(否则白等一次冷启动)');
+ const other = 'D:/rt/system-images/android-34/google_apis/x86_64/';
+ assert(doctor.imageIdentity(other) !== doctor.imageIdentity(d), '真的换了镜像必须能识别出来');
+ });
+
await test('快照指纹不随 GPU/加速/内存重试变化(避免每次重试都清空已装应用)', () => {
const a = doctor.snapshotKey({ dataMB: 4096, emulatorVersion: '37.3.8.0', api: '34', tag: 'google_apis_playstore' }, 'C:\\img');
const b = doctor.snapshotKey({ dataMB: 4096, emulatorVersion: '37.3.8.0', api: '34', tag: 'google_apis_playstore' }, 'C:\\img');
@@ -845,6 +855,10 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
const off = new Sources(() => ({ runtime: { autoMirror: false } }));
assert(off.candidates(url).length === 1, '关掉自动镜像后只剩直连');
assert(withMirror(url, 'https://x/') === `https://x/${url}`, '前缀缺尾斜杠要自动补');
+
+ // 镜像只代理 GitHub:Gitee 的地址拼上镜像前缀只会 403,不该被列入候选
+ const giteeUrl = 'https://gitee.com/daily-miku/apkstart/releases/download/v1/a.zip.part1';
+ assert(auto.candidates(giteeUrl).length === 1, 'Gitee 资产不应套 GitHub 镜像前缀');
});
await test('双源:测速结果按速度排序,全部失败时保持原序不丢可用地址', async () => {
@@ -971,6 +985,96 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
}
});
+ await test('多源并行下载:失败后重来只补缺的块(不重下整个 1.4GB)', async () => {
+ const http = require('http');
+ const { downloadMulti } = require('../src/core/download');
+ const MB = 1024 * 1024;
+ const total = 3 * MB;
+ const data = Buffer.alloc(total);
+ for (let i = 0; i < total; i += 1) data[i] = i % 251;
+ let ranged = 0;
+ const handler = (req, res) => {
+ const r = /bytes=(\d+)-(\d+)/.exec(req.headers.range || '');
+ if (!r) { res.writeHead(200, { 'Content-Length': total }); res.end(data); return; }
+ const a = Number(r[1]);
+ const b = Math.min(Number(r[2]), total - 1);
+ if (b > a) ranged += 1; // 只统计真正的数据块请求(探测用 0-0 不算)
+ res.writeHead(206, { 'Content-Range': `bytes ${a}-${b}/${total}`, 'Content-Length': b - a + 1 });
+ res.end(data.slice(a, b + 1));
+ };
+ // 必须是两条地址:只有一条时 downloadMulti 会直接交给单源分块(那条路径自带续传)
+ const mk = () => new Promise((resolve) => {
+ const srv = http.createServer(handler);
+ srv.listen(0, '127.0.0.1', () => resolve(srv));
+ });
+ const s1 = await mk();
+ const s2 = await mk();
+ const urls = [`http://127.0.0.1:${s1.address().port}/f`, `http://127.0.0.1:${s2.address().port}/f`];
+ const out = path.join(TMP, 'multi-resume.bin');
+ try {
+ // 造出「前两块已下完、最后一块没下」的现场(分块方式:3 连接 × 1MB)
+ const per = Math.ceil(total / 3);
+ const fd = fs.openSync(out, 'w');
+ fs.ftruncateSync(fd, total);
+ fs.writeSync(fd, data, 0, per * 2, 0);
+ fs.closeSync(fd);
+ fs.writeFileSync(`${out}.chunks.json`, JSON.stringify({ total, n: 3, done: [0, per] }));
+
+ const r = await downloadMulti(urls, out, { connections: 3, minChunk: MB });
+ assert(r.resumed === true, '应识别出这是断点续传');
+ assert(ranged === 1, `只应补下 1 个块,实际请求 ${ranged} 块`);
+ assert(Buffer.compare(fs.readFileSync(out), data) === 0, '续传后的文件必须与源完全一致');
+ assert(!fs.existsSync(`${out}.chunks.json`), '完成后要清掉边车文件');
+ } finally {
+ s1.close(); s2.close();
+ fs.rmSync(out, { force: true });
+ fs.rmSync(`${out}.chunks.json`, { force: true });
+ }
+ });
+
+ await test('下载器:连接建立后一个字节都不来,必须超时换源而不是挂死', async () => {
+ const http = require('http');
+ const { downloadMulti } = require('../src/core/download');
+ const data = Buffer.alloc(4 * 1024 * 1024, 9);
+ // 头正常回、然后一直不说话:模拟「TCP 通但被墙/被限速」的经典状态
+ const stall = http.createServer((req, res) => {
+ const r = /bytes=(\d+)-(\d+)/.exec(req.headers.range || '');
+ if (!r) { res.writeHead(200, { 'Content-Length': data.length }); res.end(data); return; }
+ const a = Number(r[1]);
+ const b = Math.min(Number(r[2]), data.length - 1);
+ res.writeHead(206, { 'Content-Range': `bytes ${a}-${b}/${data.length}`, 'Content-Length': b - a + 1 });
+ // 先给 1KB,然后不再发任何东西
+ res.write(data.slice(a, a + 1024));
+ });
+ const good = http.createServer((req, res) => {
+ const r = /bytes=(\d+)-(\d+)/.exec(req.headers.range || '');
+ if (!r) { res.writeHead(200, { 'Content-Length': data.length }); res.end(data); return; }
+ const a = Number(r[1]);
+ const b = Math.min(Number(r[2]), data.length - 1);
+ res.writeHead(206, { 'Content-Range': `bytes ${a}-${b}/${data.length}`, 'Content-Length': b - a + 1 });
+ res.end(data.slice(a, b + 1));
+ });
+ const listen = (srv) => new Promise((r) => srv.listen(0, '127.0.0.1', () => r(srv)));
+ const s1 = await listen(stall);
+ const s2 = await listen(good);
+ const out = path.join(TMP, 'stall.bin');
+ const t0 = Date.now();
+ try {
+ const r = await downloadMulti(
+ [`http://127.0.0.1:${s1.address().port}/f`, `http://127.0.0.1:${s2.address().port}/f`],
+ out,
+ { connections: 4, minChunk: 1024 * 1024, idleMs: 400, retries: 2 },
+ );
+ const cost = Date.now() - t0;
+ assert(fs.statSync(out).size === data.length, '最终必须下完整');
+ assert(cost < 15000, `不能在停滞的连接上挂住,实际用了 ${cost}ms`);
+ } finally {
+ s1.close(); s2.close();
+ fs.rmSync(out, { force: true });
+ fs.rmSync(`${out}.chunks.json`, { force: true });
+ }
+ });
+
await test('多源并行下载:只有一条可用地址时退回单源分块', async () => {
const http = require('http');
const { downloadMulti } = require('../src/core/download');
diff --git a/tools/check-quit-clean.js b/tools/check-quit-clean.js
index e18d7f5..6e31794 100644
--- a/tools/check-quit-clean.js
+++ b/tools/check-quit-clean.js
@@ -14,7 +14,10 @@ const { spawn } = require('child_process');
const { WinAgent } = require('../src/core/agent');
const ROOT = path.join(__dirname, '..');
-const ENGINE = path.join(ROOT, 'engine');
+// 运行时与安卓数据目录都可能被用户改到别的盘,测试时用环境变量指过去,
+// 免得每次都重新下载 1.4GB 运行时、或另建一个空 AVD。
+const ENGINE = path.resolve(process.env.APKSTART_RUNTIME || path.join(ROOT, 'engine'));
+const AVD_DIR = process.env.APKSTART_AVD_HOME || '';
const ELECTRON = path.join(ROOT, 'node_modules', 'electron', 'dist', 'electron.exe');
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -34,7 +37,7 @@ const bad = (w) => {
apps: [{ package: 'com.example.demo', label: 'Demo', installedAt: Date.now() }],
}));
fs.writeFileSync(path.join(appData, 'settings.json'), JSON.stringify({
- runtime: { dir: ENGINE },
+ runtime: { dir: ENGINE, avdDir: AVD_DIR },
engine: { prewarm: true },
}));
diff --git a/tools/check-windows.js b/tools/check-windows.js
index 318cc39..3f24394 100644
--- a/tools/check-windows.js
+++ b/tools/check-windows.js
@@ -16,9 +16,12 @@ const path = require('path');
const { spawn } = require('child_process');
const { WinAgent } = require('../src/core/agent');
-const ROOT = path.resolve(process.argv[2] || path.join(__dirname, '..', 'engine'));
+// 运行时目录:命令行参数 > 环境变量 > 仓库里的 engine/
+const ROOT = path.resolve(process.argv[2] || process.env.APKSTART_RUNTIME || path.join(__dirname, '..', 'engine'));
const EMU = path.join(ROOT, 'emulator', 'emulator.exe');
-const AVD_HOME = path.join(process.env.APPDATA || '', 'apkstart', 'avd');
+// AVD 可能在别的盘(设置里 runtime.avdDir),线上用户常见;这里也支持显式指定
+const AVD_HOME = process.env.APKSTART_AVD_HOME
+ || path.join(process.env.APPDATA || '', 'apkstart', 'avd');
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const bad = (w) => {