Skip to content

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

feat: 资源/磁盘可控 + 修掉「磁盘满自动清数据」等三个严重问题(v0.3.3 未发布)

RoutineMikufd93c5c6c4ee
diff --git a/package.json b/package.json
index 6eb4caf..02c2834 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
{
"name": "apkstart",
"productName": "ApkStart",
- "version": "0.3.2",
+ "version": "0.3.3",
"description": "极致轻量的 Windows 安卓应用运行器:双击 APK 即装,应用以独立窗口与桌面图标运行",
"main": "src/main.js",
"author": "RoutineMiku",
diff --git a/src/core/appwin.js b/src/core/appwin.js
index 173c5e8..bff92dc 100644
--- a/src/core/appwin.js
+++ b/src/core/appwin.js
@@ -212,16 +212,21 @@ class AppWindow {
*/
async embed() {
if (!this.isOpen) return false;
- for (let attempt = 0; attempt < 3; attempt += 1) {
+ let last = null;
+ for (let attempt = 0; attempt < 4; attempt += 1) {
if (!this.isOpen) return false;
const hwnd = this._hwnd();
if (!hwnd) return false;
// eslint-disable-next-line no-await-in-loop
- const r = await this.agent.embed(hwnd, this._rect()).catch(() => null);
+ const r = await this.agent.embed(hwnd, this._rect()).catch((e) => ({ ok: false, error: e.message }));
+ last = r;
if (r && r.ok) return true;
// eslint-disable-next-line no-await-in-loop
- await new Promise((res) => setTimeout(res, 300));
+ await sleep(attempt < 2 ? 300 : 800);
}
+ // 把失败原因带出去:上层会写进 app.log,出问题时一眼能看出是「没找到模拟器窗口」
+ // 还是「SetParent 失败」,不用再靠猜。
+ this.lastEmbedError = last ? (last.error || `emu=${last.emu}`) : 'no-response';
return false;
}
diff --git a/src/core/doctor.js b/src/core/doctor.js
index d8c4119..0e4840d 100644
--- a/src/core/doctor.js
+++ b/src/core/doctor.js
@@ -109,7 +109,12 @@ function shortPath(p) {
*/
function liteProfile({ host = hostInfo(), engine = {} } = {}) {
if (engine && engine.liteMode === false) return null;
- const cores = clamp(Math.floor((host.cores || 2) / 4), 2, 3);
+ const cores = engine && engine.resourceMode === 'save'
+ ? 2
+ // 老逻辑是 floor(核数/4) 再夹到 2~3 —— 8 核机器只给 2 个 vCPU,软件解码视频
+ // (红果/抖音这类)直接卡成幻灯片。改成「一半物理核、上限 4」:
+ // 8 核给 4、4 核给 2,桌面仍有富余核,视频也够用。
+ : clamp(Math.floor((host.cores || 2) / 2), 2, 4);
return { cores, priority: 'below' };
}
@@ -133,16 +138,31 @@ function chooseProfile({
if (lite && !overrides.cores) cores = Math.min(cores, lite.cores);
const disk = diskMB || freeDiskMB(host.tmp);
- const dataMB = disk && disk < 8192 ? 2048 : 4096;
+ // /data 容量:应用本体、游戏资源包和它们的「更新包」都占这里,4GB 太容易满
+ // (表现就是应用内更新时提示「磁盘空间不足」)。默认按磁盘余量给 6/8GB,
+ // 用户也可以直接在设置里指定(改大后下次开机就地扩容,不丢数据)。
+ const wantGB = Number((settings && settings.engine && settings.engine.dataPartitionGB) || 0);
+ const autoDataMB = disk && disk < 12288 ? 4096 : 6144;
+ const dataMB = wantGB > 0 ? clamp(Math.round(wantGB * 1024), 2048, 65536) : autoDataMB;
const gpus = gpuCandidates(emulatorVersion);
const gpu = overrides.gpuMode && gpus.includes(overrides.gpuMode) ? overrides.gpuMode : gpus[0];
+ // 渲染分辨率:auto 时按加速状态选(软件模拟降到 540x960 保流畅)
+ const wantLcd = String((settings && settings.engine && settings.engine.renderSize) || 'auto');
+ const lcd = /^\d{3,4}x\d{3,4}$/.test(wantLcd)
+ ? { ...lcdFor({ accelOk }), ...(() => {
+ const [w, h] = wantLcd.split('x').map(Number);
+ return { w, h, dpi: w <= 540 ? 240 : (w <= 720 ? 320 : 420) };
+ })() }
+ : lcdFor({ accelOk });
+
return {
memoryMB,
cores,
heapMB: memoryMB >= 3072 ? 384 : 256,
dataMB,
+ lcd,
gpu,
gpuCandidates: gpus,
accel: accelOk ? 'auto' : 'off',
@@ -214,14 +234,20 @@ function planVariants(profile) {
cores: 2,
dataMB: Math.min(profile.dataMB, 2048),
label: '保守冷启动(最小内存 + 清快照)',
- wipe: true,
+ // 这里**绝对不能** wipe:以前写的是 wipe:true,而磁盘写满时每次尝试都会失败,
+ // 于是连续重试把用户已装的应用和存档一起「清快照 + 清数据」了 ——
+ // 「磁盘满了,结果打开 ApkStart 应用全没了」就是这么发生的。
+ // 需要重建 userdata 时由 ensureDataPartition 自己判断(它只在镜像损坏时重建),
+ // 不靠启动参数里的 -wipe-data。
+ wipe: false,
snapshot: false,
lastResort: true,
});
- // 去重(相同 gpu/accel/wipe 组合不重复试)
+ // 去重(相同 gpu/accel/wipe 组合不重复试)——但「最后一档」必须保留:
+ // 它是唯一「不加载快照」的方案,小内存机器上可能和前一档参数完全一样。
const seen = new Set();
return out.filter((v) => {
- const k = `${v.gpu}|${v.accel}|${!!v.wipe}|${v.memoryMB}`;
+ const k = `${v.gpu}|${v.accel}|${!!v.wipe}|${v.memoryMB}|${v.snapshot !== false ? 'snap' : 'nosnap'}|${v.lastResort ? 'last' : ''}`;
if (seen.has(k)) return false;
seen.add(k);
return true;
@@ -262,9 +288,16 @@ async function freeAdbPort(start = 5044) {
* 故意不包含 GPU、加速方式、内存 —— 那些是自动重试会频繁切换的参数,
* 若纳入会让每次重试都触发 -wipe-data,把用户已装的应用清空。
*/
+/**
+ * quickboot 快照的「配置指纹」:只有这些变化会让旧快照失效(加载后黑屏/起不来)。
+ *
+ * 刻意**不包含 dataMB**:数据分区调大以后旧快照照样能用(qemu 会按新的分区大小
+ * 重新挂载),把它算进指纹的后果是「用户只想扩个容,结果快照作废 + 冷启动 +
+ * 数据被删」—— 实测踩过一次,代价是整机应用全丢。
+ */
function snapshotKey(plan, imageDir) {
return crypto.createHash('sha1').update([
- imageDir, plan.dataMB || 0, plan.emulatorVersion || '', plan.api || '', plan.tag || '',
+ imageDir, plan.emulatorVersion || '', plan.api || '', plan.tag || '',
].join('|')).digest('hex').slice(0, 16);
}
@@ -321,8 +354,9 @@ const RULES = [
{
code: 'DISK_FULL',
re: /No space left|disk full|not enough space|磁盘空间不足/i,
- title: '磁盘空间不足',
- hint: '已自动缩小数据分区并清理旧快照。请给系统盘留出至少 8GB 可用空间。',
+ title: '磁盘空间不足,无法启动安卓',
+ hint: '请把运行时目录(设置 → 系统集成 → 运行时数据目录)改到空间充足的盘,'
+ + '或在设置里关掉「保留快速启动快照」/ 调小数据分区。安卓数据不会被自动清除。',
},
{
code: 'NON_ASCII',
diff --git a/src/core/emulator.js b/src/core/emulator.js
index c7f8b60..3787410 100644
--- a/src/core/emulator.js
+++ b/src/core/emulator.js
@@ -257,15 +257,16 @@ class EmulatorEngine {
}
}
- // 配置指纹变化 → 旧 quickboot 快照必然加载失败或产生黑屏,主动作废
+ // 配置指纹变化 → 旧 quickboot 快照必然加载失败或产生黑屏,主动作废。
+ // 注意:这里只作废**快照**,绝不能顺手 -wipe-data —— 用户数据里是已装的应用和存档。
const key = `${doctor.snapshotKey({
dataMB, emulatorVersion: this._emuVersion || '', api, tag,
}, choice.dir)}|${screen.w}x${screen.h}@${screen.dpi}`;
const keyFile = path.join(avdDir, 'snapshot.key');
let prevKey = '';
try { prevKey = fs.readFileSync(keyFile, 'utf8').trim(); } catch (_) { /* 首次 */ }
- if (prevKey && prevKey !== key) this.wipePending = true;
- if (this.wipePending || wipe) {
+ const snapshotStale = !!(prevKey && prevKey !== key);
+ if (this.wipePending || snapshotStale || wipe) {
// 删除可能被系统/安全软件拦截(快照目录常有几个 GB)。
// 失败就改名让 emulator 不再加载它,绝不因为清理失败而中断启动。
const snapDir = path.join(avdDir, 'snapshots');
@@ -274,8 +275,9 @@ class EmulatorEngine {
} catch (_) {
try { fs.renameSync(snapDir, `${snapDir}.stale-${Date.now()}`); } catch (__) { /* ignore */ }
}
- // 用户数据不删(保留已装应用),只让模拟器按需重建;镜像切换本身由 -wipe-data 处理
}
+ // 只有「镜像换了」(tag / sysdir 变化)才需要 -wipe-data:旧 userdata 与新镜像
+ // 的 APEX 不兼容,不重建会一直卡在引导循环。改容量 / 改分辨率 / 换渲染后端都不算。
fs.writeFileSync(keyFile, key, 'utf8');
// hw.cpu.arch 必须是 ABI 本身(x86_64 不能截成 x86)
@@ -342,6 +344,7 @@ class EmulatorEngine {
ensureDataPartition(avdDir, dataMB = 4096) {
const emulatorExe = this.locate().emulatorExe;
if (!emulatorExe || !fs.existsSync(emulatorExe)) return { ok: false, reason: 'no-emulator' };
+ try { fs.mkdirSync(avdDir, { recursive: true }); } catch (_) { /* ignore */ }
const emuDir = path.dirname(emulatorExe);
const img = path.join(avdDir, 'userdata-qemu.img');
const wantBytes = Math.max(1024, Math.round(dataMB || 4096)) * 1024 * 1024;
@@ -349,17 +352,25 @@ class EmulatorEngine {
try { size = fs.statSync(img).size; } catch (_) { /* 不存在 */ }
if (size > 0 && userdata.hasExt4Superblock(img)) {
- if (size >= wantBytes) return { ok: true, created: false, size };
- // 容量配置变大了:就地扩容(不重建,保留已装应用)
+ // 文件够大 + 文件系统也真的长到了这个大小,才算「不用动」。
+ // 只看文件大小会漏掉一种真实故障:qemu-img 撑开了文件、resize2fs 却失败了,
+ // 于是文件 6GB、安卓只有 64MB —— 用户看到的就是「装游戏说空间不足」。
+ const fsBytes = userdata.fsBytes(img);
+ const fsOk = fsBytes >= Math.min(size, wantBytes) * 0.95;
+ if (size >= wantBytes && fsOk) return { ok: true, created: false, size, fsBytes };
+ // 容量配置变大了(或文件系统没长到位):就地扩容,不重建、保留已装应用
try {
userdata.clearEncryptFlag(img);
- this._qemuImg('resize', img, wantBytes);
+ if (size < wantBytes) this._qemuImg('resize', img, wantBytes);
this._resize2fs(img);
userdata.setEncryptFlag(img);
- return { ok: true, created: false, grown: true, size: wantBytes };
+ const grown = userdata.fsBytes(img);
+ this.log(`userdata 扩容:文件 ${size} → ${wantBytes},文件系统 ${fsBytes} → ${grown}`);
+ return { ok: true, created: false, grown: true, size: wantBytes, fsBytes: grown };
} catch (e) {
this.log(`扩容 userdata 失败(继续用现有分区):${e.message}`);
- return { ok: true, created: false, size, error: e.message };
+ // 老分区仍然可用,但必须如实告诉调用方「这次没扩成」,不能让设置页显示成功
+ return { ok: false, created: false, size, fsBytes, error: e.message };
}
}
@@ -382,13 +393,15 @@ class EmulatorEngine {
}
}
- /** emulator 自带 qemu-img.exe:把原始镜像文件撑到目标大小(稀疏,瞬间完成) */
- _qemuImg(...args) {
+ /** emulator 自带 qemu-img.exe:把原始镜像文件撑到目标大小(稀疏,瞬间完成)
+ * 注意参数顺序:`qemu-img <命令> -f raw <文件> <大小>`。
+ * 把 -f 放命令前面会被它当成全局参数直接报 unrecognized option。 */
+ _qemuImg(op, ...rest) {
const exe = path.join(path.dirname(this.locate().emulatorExe), 'qemu-img.exe');
- const r = spawnSync(exe, ['-f', 'raw', ...args], {
+ const r = spawnSync(exe, [op, '-f', 'raw', ...rest], {
cwd: path.dirname(exe), windowsHide: true, encoding: 'utf8',
});
- if (r.status !== 0) throw new Error(`qemu-img ${args[0]} 失败: ${(r.stderr || '').trim() || r.status}`);
+ if (r.status !== 0) throw new Error(`qemu-img ${op} 失败: ${(r.stderr || '').trim() || r.status}`);
}
/** emulator 自带 resize2fs.exe(cygwin 版,必须在 bin64 目录下跑才能找到 DLL) */
@@ -447,6 +460,15 @@ class EmulatorEngine {
// (那必须 -netdev tap 或桥接才会发生,我们全程不启用)。
// 所以安卓应用用的是"一台挂在主机 NAT 后面的设备",主机网络栈完全不动,
// 不需要装驱动、也不多一个网络适配器。
+ // 显式声明不限速:默认值虽然是 full,但某些 -gpu / -net 组合下会被带上
+ // 模拟器的保守配置,视频类应用(红果、抖音)首屏就会明显慢半拍。
+ args.push('-netdelay', 'none', '-netspeed', 'full');
+ // DNS:安卓默认用 10.0.2.3(转发到主机 DNS)。主机走 VPN / 公司网 / 某些运营商
+ // 时,一次解析能拖到几百毫秒,表现为「页面转圈半天才开始加载」。给一份国内公共
+ // DNS 作为首选,失败时系统仍会回退。用户可在设置里关掉(内网域名场景)。
+ if (this.settings?.engine?.fastDns !== false) {
+ args.push('-dns-server', '223.5.5.5,119.29.29.29');
+ }
if (lcd) args.push('-skin', `${lcd.w}x${lcd.h}`);
if (headless) {
args.push('-no-window');
@@ -467,7 +489,9 @@ class EmulatorEngine {
// 于是第一次冷启动结束后永远产生不了快照,用户每次点开都是全量引导。
// 正确做法是 -no-snapshot-load:这次不加载(避免等一个不存在的快照),
// 但退出时照常把内存状态写成 apkstart,下次就直接恢复。
- if (wipe) {
+ // 快照要占一份约 2~3GB 的 ram.bin(磁盘紧张的用户可以关掉,只影响启动速度)
+ const wantSnapshot = this.settings?.engine?.keepSnapshot !== false;
+ if (wipe || !wantSnapshot) {
args.push('-no-snapshot');
} else if (snapshot !== false) {
args.push('-snapshot', SNAPSHOT_NAME);
@@ -489,7 +513,7 @@ class EmulatorEngine {
memoryMB: plan.memoryMB, cores: plan.cores,
snapshot: plan.snapshot, wipe: plan.wipe, lcd: plan.lcd,
});
- fs.appendFileSync(logFile, `\n--- ${new Date().toISOString()} ${plan.label} ---\n${loc.emulatorExe} ${args.join(' ')}\n`);
+ this._logWrite(logFile, `\n--- ${new Date().toISOString()} ${plan.label} ---\n${loc.emulatorExe} ${args.join(' ')}\n`);
const proc = spawn(loc.emulatorExe, args, {
cwd: path.dirname(loc.emulatorExe),
@@ -515,7 +539,7 @@ class EmulatorEngine {
for (const l of lines) {
if (!l.trim()) continue;
this.log(l.trim());
- fs.appendFileSync(logFile, `${l.trim()}\n`);
+ this._logWrite(logFile, `${l.trim()}\n`);
}
});
};
@@ -523,13 +547,13 @@ class EmulatorEngine {
pipe(proc.stderr);
proc.on('exit', (code) => {
this.log(`emulator exit ${code}`);
- fs.appendFileSync(logFile, `emulator exit ${code}\n`);
+ this._logWrite(logFile, `emulator exit ${code}\n`);
this.proc = null;
onLog(`运行时已退出(code=${code})`);
});
proc.on('error', (e) => {
this.log(`spawn error: ${e.message}`);
- fs.appendFileSync(logFile, `spawn error: ${e.message}\n`);
+ this._logWrite(logFile, `spawn error: ${e.message}\n`);
this.proc = null;
});
@@ -543,6 +567,36 @@ class EmulatorEngine {
return { proc, args };
}
+ /** 写模拟器日志:带大小滚动,避免长期使用把磁盘写满 */
+ _logWrite(file, text) {
+ const limit = Math.max(2048, Number(this.settings?.engine?.logLimitKB || 2048) * 4);
+ require('./logfile').append(file, text, limit);
+ }
+
+ /** 当前 /data 镜像的实际情况(设置页展示用,不启动安卓也能取) */
+ dataInfo() {
+ const dir = path.join(this.provisioner.paths().avdHome, `${AVD_NAME}.avd`);
+ const img = path.join(dir, 'userdata-qemu.img');
+ let bytes = 0;
+ try { bytes = fs.statSync(img).size; } catch (_) { /* 还没建 */ }
+ return {
+ avdDir: dir,
+ imageBytes: bytes,
+ imageGB: bytes ? Number((bytes / 1073741824).toFixed(1)) : 0,
+ configuredGB: Number(this.settings?.engine?.dataPartitionGB || 0),
+ };
+ }
+
+ /**
+ * 立即把 /data 分区扩容到指定大小(必须保证模拟器已停止,否则镜像被占用)。
+ * 走的是 ensureDataPartition 的就地扩容路径:qemu-img resize + resize2fs,
+ * 不重建、不丢已装应用与存档。
+ */
+ resizeDataPartition(dataMB) {
+ const dir = path.join(this.provisioner.paths().avdHome, `${AVD_NAME}.avd`);
+ return this.ensureDataPartition(dir, dataMB);
+ }
+
/**
* 调整本机 qemu/emulator 进程的优先级(只匹配命令行里带本 AVD 名的进程)。
* level: idle(容器停放)| below(有应用在前台)| normal(性能优先)。
@@ -667,7 +721,29 @@ class EmulatorEngine {
}
const s = this.settings;
+ // 开机前先看一眼磁盘:模拟器写的是 AVD(数据分区 + 快照,几个 GB),
+ // 只有它所在磁盘的余量才决定能不能开机;运行时目录只写日志,要求低得多。
+ // 之前把两者的余量取最小值,结果「数据目录已经挪到 D 盘、C 盘只剩 400MB」
+ // 会被误判成磁盘不足 —— 挪盘等于白挪。
+ const avdHome = this.provisioner.paths().avdHome;
+ const avdFreeMB = doctor.freeDiskMB(avdHome);
const diskMB = doctor.freeDiskMB(loc.root);
+ const needMB = 2500;
+ if (avdFreeMB && avdFreeMB < needMB) {
+ const msg = `磁盘空间不足:安卓数据目录(${avdHome})所在磁盘只剩 ${(avdFreeMB / 1024).toFixed(1)} GB,`
+ + `运行时至少要 ${(needMB / 1024).toFixed(1)} GB 可用。请在「设置 → 系统集成 → 安卓数据目录」`
+ + '把它改到空间充足的盘(例如 D:),或先清理磁盘。你的应用与存档不会被自动删除。';
+ this.log(msg);
+ onLog(msg);
+ return { ok: false, error: msg, needsSpace: true, attempts: [] };
+ }
+ if (diskMB && diskMB < 300) {
+ const msg = `运行时目录(${loc.root})所在磁盘只剩 ${(diskMB / 1024).toFixed(1)} GB,`
+ + '连日志和临时文件都写不下。请清理磁盘,或把「运行时数据目录」也换到别的盘。';
+ this.log(msg);
+ onLog(msg);
+ return { ok: false, error: msg, needsSpace: true, attempts: [] };
+ }
const adbPort = await doctor.freeAdbPort(Number(process.env.ANDROID_ADB_SERVER_PORT) || 5044);
// 让本进程里所有 adb 调用和 emulator 用同一个 server 端口
process.env.ANDROID_ADB_SERVER_PORT = String(adbPort);
@@ -711,10 +787,11 @@ class EmulatorEngine {
const logFile = path.join(store.DATA_DIR, 'logs', 'emulator.log');
fs.mkdirSync(path.dirname(logFile), { recursive: true });
- fs.appendFileSync(logFile, `\n\n=== ${new Date().toISOString()} START ${doctor.describeProfile(profile)} ===\n`);
+ this._logWrite(logFile, `\n\n=== ${new Date().toISOString()} START ${doctor.describeProfile(profile)} ===\n`);
- // 屏幕规格在整个启动过程中保持一致,否则每次重试都换分辨率会狂清快照
- const screen = doctor.lcdFor({ accelOk: accelInfo.ok });
+ // 屏幕规格在整个启动过程中保持一致,否则每次重试都换分辨率会狂清快照。
+ // 分辨率来自 doctor 的 profile(设置里可改「画质」),auto 时按加速状态选。
+ const screen = (profile && profile.lcd) || doctor.lcdFor({ accelOk: accelInfo.ok });
this.attempts = [];
this.lastDiagnosis = null;
let lastError = '';
@@ -756,6 +833,12 @@ class EmulatorEngine {
this.attempts.push({ plan: plan.label, diagnosis: d.code });
this.lastDiagnosis = d;
lastError = `${d.title}:${d.hint}`;
+ // 磁盘写满不是「换组参数就能好」的问题:继续重试只会反复失败,
+ // 而且历史上最后那组参数带 wipe,会把用户数据一起抹掉。直接收工、如实报错。
+ if (d.code === 'DISK_FULL') {
+ onLog('磁盘空间不足,已停止重试(不会动你的应用与存档)。');
+ return { ok: false, error: lastError, needsSpace: true, attempts: this.attempts };
+ }
// 加速/镜像类结论可能是缓存里的旧数据,作废掉,下次启动重新探测
if (['ACCEL', 'GPU_INIT', 'GPU_MODE', 'IMAGE', 'DLL'].includes(d.code)) {
try { this.provisioner.invalidateEnvCache(); } catch (_) { /* ignore */ }
@@ -880,6 +963,14 @@ class EmulatorEngine {
this._snapTimer = null;
if (!this.running()) return;
if (!isIdle()) { arm(15000); return; }
+ // 磁盘余量不够写快照(内存大小 + 1GB 余量)就跳过:硬写只会把磁盘写满,
+ // 进而让下一次开机直接失败。快照只影响启动速度,不写也不影响数据。
+ const freeMB = require('./doctor').freeDiskMB(store.DATA_DIR);
+ const needMB = Math.round(Number(this.profile?.memoryMB || 3072) * 1.15) + 1024;
+ if (freeMB && freeMB < needMB) {
+ this.log(`跳过快照保存:磁盘剩余 ${(freeMB / 1024).toFixed(1)}GB < 需要 ${(needMB / 1024).toFixed(1)}GB`);
+ return;
+ }
await this.saveSnapshotNow(adbPath).catch(() => false);
this._snapSaved = true;
}, ms);
diff --git a/src/core/engine.js b/src/core/engine.js
index 9648da5..e12347b 100644
--- a/src/core/engine.js
+++ b/src/core/engine.js
@@ -309,6 +309,18 @@ class Runtime {
onLog,
probe,
});
+ // start() 失败时是「返回 {ok:false}」而不是抛异常(磁盘不足、多次重试仍失败等)。
+ // 老实现不看这个字段,直接把 ok:true 往上返回 —— 上层于是认为「已经就绪」,
+ // 接着 adb 一顿报 device not found,用户看到的是「点开没反应」而不是真实原因。
+ if (!st || st.ok === false) {
+ return {
+ ok: false,
+ error: (st && st.error) || '安卓运行时未能启动',
+ needsSpace: !!(st && st.needsSpace),
+ attempts: (st && st.attempts) || [],
+ diagnosis: this.emulator.lastDiagnosis,
+ };
+ }
this.lastActivity = Date.now();
this.emuSerial = st.serial || this.emulator.serial;
const client = this.client(this.emuSerial);
diff --git a/src/core/layers.js b/src/core/layers.js
index 37bd0c4..58484ef 100644
--- a/src/core/layers.js
+++ b/src/core/layers.js
@@ -154,11 +154,29 @@ function prune(root, { apply = false, keepAvd, aggressive = false, keepSnapshots
/** 给设置页用的简短摘要 */
function summary(root) {
const a = analyze(root);
- const mb = (n) => `${(n / 1048576).toFixed(0)} MB`;
+ const mb = (n) => (n >= 1048576 * 1024
+ ? `${(n / 1073741824).toFixed(2)} GB`
+ : `${(n / 1048576).toFixed(0)} MB`);
+ // 除了运行时目录,用户最关心「这东西一共占了我多少盘」:
+ // AVD(应用数据 + 快照)、APK 缓存、图标、日志都算进来。
+ const store = require('./store');
+ const extra = [
+ { key: 'avd', label: '安卓数据(应用 + 快照)', path: path.join(store.DATA_DIR, 'avd') },
+ { key: 'apk', label: 'APK 安装包缓存', path: store.APK_DIR },
+ { key: 'icons', label: '桌面图标缓存', path: store.ICON_DIR },
+ { key: 'logs', label: '日志', path: path.join(store.DATA_DIR, 'logs') },
+ ].map((g) => ({ ...g, size: dirSize(g.path) })).filter((g) => g.size > 0);
+
+ const extraTotal = extra.reduce((n, g) => n + g.size, 0);
+ const totalAll = a.total + extraTotal;
return {
- total: a.total,
- totalText: mb(a.total),
- groups: a.groups.map((g) => ({ ...g, text: mb(g.size) })),
+ total: totalAll,
+ totalText: mb(totalAll),
+ runtimeText: mb(a.total),
+ groups: [
+ { key: 'runtime', label: '运行时(引擎 + 系统镜像)', size: a.total, text: mb(a.total) },
+ ...extra.map((g) => ({ ...g, text: mb(g.size) })),
+ ],
reclaimable: a.candidates.reduce((n, c) => n + c.size, 0),
reclaimableText: mb(a.candidates.reduce((n, c) => n + c.size, 0)),
count: a.candidates.length,
diff --git a/src/core/logfile.js b/src/core/logfile.js
new file mode 100644
index 0000000..3cf71a7
--- /dev/null
+++ b/src/core/logfile.js
@@ -0,0 +1,52 @@
+'use strict';
+/**
+ * 轻量日志写入 + 滚动。
+ *
+ * 以前 app.log / emulator.log 是纯 append,长期使用会一直长:
+ * emulator 每次开机的内核日志就有几十 KB,一天开关十几次、再加上 qemu 的
+ * verbose 输出,几个月就是几百 MB —— 磁盘就是这么被悄悄吃掉的。
+ * 这里按大小滚动,只保留一份 .1.log 备份,上限由设置里的「日志上限」控制。
+ */
+const fs = require('fs');
+const path = require('path');
+
+const counters = new Map();
+
+function rotate(file, limitKB) {
+ try {
+ const st = fs.statSync(file);
+ if (st.size < limitKB * 1024) return false;
+ const bak = file.replace(/\.log$/i, '.1.log');
+ try { fs.rmSync(bak, { force: true }); } catch (_) { /* ignore */ }
+ fs.renameSync(file, bak);
+ return true;
+ } catch (_) {
+ return false;
+ }
+}
+
+/**
+ * @param {string} file 目标日志
+ * @param {string} line 一行内容(自动补换行)
+ * @param {number} [limitKB] 超过这个大小就滚动
+ */
+function append(file, line, limitKB = 2048) {
+ try {
+ fs.mkdirSync(path.dirname(file), { recursive: true });
+ const n = (counters.get(file) || 0) + 1;
+ counters.set(file, n);
+ // 每次进程启动检查一次,之后每 200 行检查一次(statSync 很便宜,但没必要每行都做)
+ if (n === 1 || n % 200 === 0) rotate(file, Math.max(256, Number(limitKB) || 2048));
+ fs.appendFileSync(file, line.endsWith('\n') ? line : `${line}\n`);
+ return true;
+ } catch (_) {
+ return false;
+ }
+}
+
+/** 启动时清理:把过大的日志先滚掉(不看计数器) */
+function trimNow(file, limitKB = 2048) {
+ return rotate(file, Math.max(256, Number(limitKB) || 2048));
+}
+
+module.exports = { append, rotate, trimNow };
diff --git a/src/core/provision.js b/src/core/provision.js
index 40d6c37..f070f9c 100644
--- a/src/core/provision.js
+++ b/src/core/provision.js
@@ -190,7 +190,10 @@ class Provisioner {
// AVD(含用户数据、已装应用、quickboot 快照)必须落在可写且不会被清理的地方。
// 单文件发行版的运行时是随包解压到临时目录的,把 AVD 放进去等于每次退出都丢应用。
// 只要运行时目录不在 %APPDATA% 里,就把 AVD 固定指到用户数据目录。
- const writable = path.join(store.DATA_DIR, 'avd');
+ // 另外:允许在设置里单独指定「安卓数据目录」——它才是真正吃盘的地方
+ // (6~24GB 数据分区 + 2~3GB 快照),只挪运行时、不挪它,C 盘一样会满。
+ const explicitAvd = String(store.getSettings().runtime.avdDir || '').trim();
+ const writable = explicitAvd || path.join(store.DATA_DIR, 'avd');
const insideData = root.toLowerCase().startsWith(store.DATA_DIR.toLowerCase());
// 单文件发行版的镜像会展开到用户目录(见 materializeImages),那里有就用那里的
const dataImg = path.join(store.DATA_DIR, 'system-images');
diff --git a/src/core/sharer.js b/src/core/sharer.js
index 33c896f..32b7066 100644
--- a/src/core/sharer.js
+++ b/src/core/sharer.js
@@ -69,16 +69,27 @@ class Sharer {
const state = this.loadState();
// --- 本机 → 设备 ---
+ // 状态里同时记「本机 mtime」和「设备 mtime」两个值。
+ // 老实现只记一个 mtime、拉完写回本机时间,于是下一轮拿本机时间去和设备的
+ // 时间比 —— 永远不相等 → 每 8 秒把同一个文件从设备拉一遍,落盘时间又变,
+ // 再下一轮继续拉……表现就是「硬盘一直转、文件反复重写、空间越用越少」。
+ const stateOf = (prev) => (prev ? {
+ size: prev.size,
+ lmtime: prev.lmtime || prev.mtime || 0,
+ rmtime: prev.rmtime || 0,
+ dir: prev.dir || '',
+ } : null);
+
const localFiles = walk(this.localDir);
for (const f of localFiles) {
- const prev = state[f.rel];
- const changed = !prev || Math.abs((prev.mtime || 0) - f.mtime) > 1500 || prev.size !== f.size;
+ const prev = stateOf(state[f.rel]);
+ const changed = !prev || prev.size !== f.size || Math.abs(prev.lmtime - f.mtime) > 1500;
if (!changed) continue;
const remote = `${this.remoteDir}/${f.rel}`;
try {
await client.shell(`mkdir -p "$(dirname '${remote}')"`);
await client.push(f.abs, remote);
- state[f.rel] = { mtime: f.mtime, size: f.size, dir: 'up' };
+ state[f.rel] = { size: f.size, lmtime: f.mtime, rmtime: 0, dir: 'up', at: Date.now() };
result.pushed++;
} catch (e) {
result.errors.push(`↑ ${f.rel}: ${e.message}`);
@@ -98,18 +109,27 @@ class Sharer {
}
for (const r of remoteList) {
- const prev = state[r.rel];
+ // 超大文件(视频/游戏数据包)不往回拉:本地目录不该成为设备缓存的下水道
+ if (r.size > MAX_FILE) continue;
+ const prev = stateOf(state[r.rel]);
const sizeSame = !!prev && prev.size === r.size;
- // 新文件(prev 为空)必须拉回来;旧版在这里直接读 prev.mtime 会抛异常,
- // 让整次同步中断,表现为「设备 → 本机永远不同步」
- const mtimeSame = (prev && r.mtime) ? Math.abs((prev.mtime || 0) - r.mtime) <= 1500 : false;
- if (prev && sizeSame && mtimeSame) continue;
+ const rmtimeSame = !!(prev && prev.rmtime && r.mtime)
+ && Math.abs(prev.rmtime - r.mtime) <= 1500;
+ if (prev && sizeSame && (rmtimeSame || prev.dir === 'up')) {
+ // 大小一致,且要么设备时间没变、要么这个文件就是我们刚推上去的:
+ // 只把设备时间记下来收工,绝不重复下载
+ if (r.mtime && prev.rmtime !== r.mtime) {
+ state[r.rel] = { ...prev, rmtime: r.mtime };
+ }
+ continue;
+ }
+ if (prev && sizeSame && !r.mtime) continue; // 拿不到设备时间且大小相同 → 视为一致
const local = path.join(this.localDir, r.rel);
try {
fs.mkdirSync(path.dirname(local), { recursive: true });
await client.pull(`${this.remoteDir}/${r.rel}`, local);
const st = fs.statSync(local);
- state[r.rel] = { mtime: st.mtimeMs, size: st.size, dir: 'down' };
+ state[r.rel] = { size: st.size, lmtime: st.mtimeMs, rmtime: r.mtime || 0, dir: 'down', at: Date.now() };
result.pulled++;
} catch (e) {
result.errors.push(`↓ ${r.rel}: ${e.message}`);
diff --git a/src/core/store.js b/src/core/store.js
index e0ab3a2..45d4722 100644
--- a/src/core/store.js
+++ b/src/core/store.js
@@ -36,6 +36,23 @@ const DEFAULT_SETTINGS = {
audio: true, // 安卓应用的声音(提示音/视频)。关闭可省一点 CPU
// ---- 轻量容器(默认全开省资源,用户可逐项关掉)----
liteMode: true, // 收敛 vCPU 配额,避免 qemu 占满物理核拖慢 Windows
+ // 一句话策略:save(省资源)/ balanced(均衡)/ smooth(流畅,视频·游戏优先)。
+ // 界面上只暴露这一个选项,保存时自动翻译成 liteMode / priorityMode / renderSize,
+ // 底部仍然保留细项开关给高级用户。
+ resourceMode: 'balanced',
+ // 数据分区容量(GB):应用、游戏缓存和它们的更新包都装在这里。
+ // 0 = 自动(按磁盘剩余给 6/8GB)。改大后在下次开安卓时**就地扩容**,不丢已装应用。
+ dataPartitionGB: 0,
+ // 渲染分辨率:越低越流畅、越省电;auto = 按加速状态选 720x1280 / 540x960
+ renderSize: 'auto',
+ // 网络加速:给模拟器指定国内公共 DNS。安卓默认的 10.0.2.3 要走主机 DNS,
+ // VPN / 公司网 / 某些运营商下解析会拖到几百毫秒,视频类应用首屏会明显发卡。
+ fastDns: true,
+ // 快照:quickboot 内存快照让二次启动只要几秒,代价是磁盘上多一份约 2~3GB 的
+ // ram.bin。磁盘紧张时可以关掉(只影响启动速度,不影响应用数据)。
+ keepSnapshot: true,
+ // 日志上限(KB):超过就滚动备份一份,避免长期使用把磁盘写满
+ logLimitKB: 2048,
// 鼠标键位:左键由模拟器原生映射为「确认/点击」,无需开关。
// 右键返回与平滑滚轮需要低级钩子,但只在应用窗口前台时装,失焦即卸载。
mouseRightBack: true, // 右键 = 安卓返回(拦下 Qt 默认的「右键也当点击」误触)
@@ -117,6 +134,26 @@ function deepMerge(base, patch) {
return out;
}
+/**
+ * 资源策略 → 具体开关。
+ * save :2 vCPU + 低优先级 + 540x960,老笔记本 / 挂机用;
+ * balanced :vCPU 取物理核的一半(2~4)+ 让出前台 + 720x1280;
+ * smooth :不限制 vCPU + 与前台同优先级 + 720x1280,视频与游戏优先。
+ * 分辨率先不动 1080p:quickboot 快照指纹与它绑定,改一次就要重冷启动,而 720p
+ * 在手机比例的窗口里已经看不出区别,性能却差一档。
+ */
+function resourcePreset(mode) {
+ switch (String(mode || '')) {
+ case 'save':
+ return { resourceMode: 'save', liteMode: true, priorityMode: 'balanced', renderSize: '540x960' };
+ case 'smooth':
+ return { resourceMode: 'smooth', liteMode: false, priorityMode: 'performance', renderSize: '720x1280' };
+ case 'balanced':
+ default:
+ return { resourceMode: 'balanced', liteMode: true, priorityMode: 'balanced', renderSize: 'auto' };
+ }
+}
+
const store = {
DATA_DIR, ICON_DIR, APK_DIR,
@@ -135,6 +172,10 @@ const store = {
saveSettings(patch) {
const next = deepMerge(this.getSettings(), patch);
+ // 只改了「资源策略」时,把它翻译成具体的三个开关,避免两套配置各说各话
+ if (patch && patch.engine && patch.engine.resourceMode) {
+ Object.assign(next.engine, resourcePreset(next.engine.resourceMode));
+ }
writeJson(SETTINGS_FILE, next);
return next;
},
diff --git a/src/core/userdata.js b/src/core/userdata.js
index 5537925..ea70bba 100644
--- a/src/core/userdata.js
+++ b/src/core/userdata.js
@@ -222,6 +222,34 @@ function clearEncryptFlag(file) {
}
}
+/**
+ * 读文件系统**自身**的容量(字节)。
+ * 关键用途:镜像文件被 qemu-img 撑到 8GB,不代表里面的 ext4 也长到了 8GB。
+ * 如果 resize2fs 没跑成功(老版本 qemu-img 参数顺序写错就会这样),
+ * 文件看着有 6GB、安卓却只有 64MB 可用 —— 表现正是「装游戏/更新时空间不足」。
+ * 这里直接读超级块的块数与块大小,判断要不要补一次 resize2fs。
+ */
+function fsBytes(file) {
+ let fd;
+ try {
+ fd = require('fs').openSync(file, 'r');
+ const sb = Buffer.alloc(2048);
+ const n = require('fs').readSync(fd, sb, 0, sb.length, 0);
+ if (n < 2048) return 0;
+ if (sb.readUInt16LE(1024 + 0x38) !== 0xEF53) return 0;
+ const blocksLo = sb.readUInt32LE(1024 + 0x4);
+ const logBlock = sb.readUInt32LE(1024 + 0x18) & 0xffff;
+ const blockSize = 1024 << logBlock;
+ return blocksLo * blockSize;
+ } catch (_) {
+ return 0;
+ } finally {
+ if (fd !== undefined) {
+ try { require('fs').closeSync(fd); } catch (_) { /* ignore */ }
+ }
+ }
+}
+
module.exports = {
- buildEmptyExt4, hasExt4Superblock, setEncryptFlag, clearEncryptFlag, BLOCK,
+ buildEmptyExt4, hasExt4Superblock, setEncryptFlag, clearEncryptFlag, fsBytes, BLOCK,
};
diff --git a/src/core/win/agent.ps1 b/src/core/win/agent.ps1
index 30878b0..c05853f 100644
--- a/src/core/win/agent.ps1
+++ b/src/core/win/agent.ps1
@@ -366,6 +366,15 @@ public class ApkAgent
if (_emu == IntPtr.Zero) return;
if (w < 16) w = 16;
if (h < 16) h = 16;
+ // 只有「确实已经嵌进我们窗口」的才允许显示。
+ // 万一 embed 失败(模拟器窗口还没建好 / 句柄换了),Fit 绝不能把它当独立窗口
+ // 顶到桌面上 —— 那正是用户看到的那个 "Android Emulator - apkstart5554" 黑窗。
+ bool embedded = _host != IntPtr.Zero && GetParent(_emu) == _host;
+ if (!embedded)
+ {
+ ShowWindow(_emu, 0);
+ return;
+ }
// SWP_FRAMECHANGED forces Windows to recompute the whole non-client area and
// repaint it. It is needed exactly once (right after SetParent); repeating it
// on every periodic sweep caused visible stutter and wasted GPU/CPU.
diff --git a/src/main.js b/src/main.js
index 06a0557..0b2ccef 100644
--- a/src/main.js
+++ b/src/main.js
@@ -40,6 +40,28 @@ const { Updater } = require('./core/updater');
// Windows 下窗口被遮挡时 capturePage 会拿到旧帧,自动化截图需要禁用遮挡计算
app.commandLine.appendSwitch('disable-features', 'CalculateNativeWinOcclusion');
+/**
+ * 系统盘快满时,把 Chromium 自己的缓存(Cache / GPUCache / Local Storage …)
+ * 挪到「安卓数据目录」所在的盘。
+ * 默认这些缓存写在 %APPDATA%\apkstart 里 —— C 盘只剩几百 MB 时,连启动都可能失败,
+ * 而用户往往已经把安卓数据挪到别的盘了,缓存却还在 C 盘上挤。
+ * 必须在 app ready 之前设置,之后改无效。
+ */
+function relocateUserDataIfCrowded() {
+ try {
+ const doctor = require('./core/doctor');
+ const freeMB = doctor.freeDiskMB(store.DATA_DIR);
+ const avd = String(store.getSettings().runtime.avdDir || '').trim();
+ if (!avd) return;
+ const avdFree = doctor.freeDiskMB(avd);
+ if (freeMB >= 2048 || avdFree <= freeMB * 2) return;
+ const target = path.join(avd, 'appdata');
+ fs.mkdirSync(target, { recursive: true });
+ app.setPath('userData', target);
+ } catch (_) { /* 放不进去就维持默认,不影响启动 */ }
+}
+relocateUserDataIfCrowded();
+
// 应用窗口把模拟器以 SetParent 方式嵌进来当子窗口。Chromium 默认用
// DirectComposition 上半透明图层(Intermediate D3D Window /
// WS_EX_NOREDIRECTIONBITMAP)绘制网页,这层由 DWM 在窗口级别合成,
@@ -59,8 +81,8 @@ const IS_DEV = process.argv.includes('--dev');
function appLog(line) {
try {
const dir = path.join(store.DATA_DIR, 'logs');
- fs.mkdirSync(dir, { recursive: true });
- fs.appendFileSync(path.join(dir, 'app.log'), `${new Date().toISOString()} ${line}\n`);
+ const limit = store.getSettings().engine.logLimitKB || 2048;
+ require('./core/logfile').append(path.join(dir, 'app.log'), `${new Date().toISOString()} ${line}`, limit);
} catch (_) { /* 日志失败不能影响主流程 */ }
}
process.on('uncaughtException', (e) => appLog(`UNCAUGHT ${e && (e.stack || e.message)}`));
@@ -575,8 +597,15 @@ async function runLaunch(pkg) {
// 2) 应用真的活下来了,才把画面嵌进窗口(否则用户会看到闪一下的桌面/崩溃页)
const embedded = await appWin.embed();
- mark('embedded');
+ if (!embedded) appLog(`embed failed: ${appWin.lastEmbedError || 'unknown'}`);
+ mark(`embedded=${embedded}`);
appWin.setState({ ready: true, tip: '' });
+ // 嵌入失败(模拟器窗口还没建好)时再补两次:用户看到的是黑窗口,
+ // 后台补上就恢复正常,不用让用户手动重开。
+ if (!embedded) {
+ setTimeout(() => { if (appWin.isOpen) appWin.embed().catch(() => {}); }, 1500);
+ setTimeout(() => { if (appWin.isOpen) appWin.embed().catch(() => {}); }, 4000);
+ }
// 容器会话:环境已经就绪,这里只做「按应用裁剪 + 打开后台轮询」,
// 不再为这个 App 重新引导一遍 Android。鼠标键位钩子由窗口 focus 事件
// 按设置决定,失焦即卸载。
@@ -931,6 +960,56 @@ function registerIpc() {
ipcMain.handle('runtime:usage', () => runtime.usage());
+ // 通用确认框(渲染层统一走这里,避免各处自己拼 dialog 文案)
+ ipcMain.handle('app:confirm', async (_e, opts = {}) => {
+ const { response } = await dialog.showMessageBox(mainWindow || undefined, {
+ type: opts.type || 'question',
+ title: opts.title || '确认',
+ message: opts.message || '',
+ detail: opts.detail || '',
+ buttons: ['取消', opts.okLabel || '确定'],
+ defaultId: 1,
+ cancelId: 0,
+ noLink: true,
+ });
+ return { response };
+ });
+
+ // 数据分区(/data)容量:应用、游戏与它们的更新包都装在这里。
+ // 「游戏更新提示空间不足」几乎都是这一项太小,扩容是就地做的,不丢数据。
+ ipcMain.handle('runtime:dataInfo', () => {
+ const doctor = require('./core/doctor');
+ const info = runtime.emulator.dataInfo();
+ return { ...info, freeDiskMB: doctor.freeDiskMB(runtime.provisioner.paths().root) };
+ });
+
+ ipcMain.handle('runtime:setDataSize', async (_e, gb) => {
+ const want = Math.max(0, Math.min(64, Number(gb) || 0));
+ store.saveSettings({ engine: { dataPartitionGB: want } });
+ if (!want) {
+ const info = runtime.emulator.dataInfo();
+ return { ok: true, auto: true, ...info };
+ }
+ const mb = Math.round(want * 1024);
+ // 镜像正被 qemu 占着时不能改,先停容器(应用会跟着退出,属于预期)
+ let stopped = false;
+ try {
+ const online = await runtime.client().isOnline().catch(() => false);
+ if (runtime.emulator.running() || online) {
+ await runtime.stop().catch(() => {});
+ stopped = true;
+ }
+ } catch (_) { /* ignore */ }
+ try {
+ const r = runtime.emulator.resizeDataPartition(mb);
+ appLog(`data partition -> ${want}GB: ${JSON.stringify(r)}`);
+ if (r && r.ok) notify('数据分区已调整', `安卓可用空间约 ${want} GB${stopped ? '(运行时已重启)' : ''}`);
+ return { ok: !!(r && r.ok), stopped, ...r, ...runtime.emulator.dataInfo() };
+ } catch (e) {
+ return { ok: false, error: e.message };
+ }
+ });
+
ipcMain.handle('runtime:cleanup', async (_e, opts = {}) => {
// 明确两次确认:先给清单,用户确认后才真正删;且只清理 ApkStart 自己的运行时目录
if (!opts.apply) return runtime.cleanup({ apply: false, aggressive: !!opts.aggressive });
@@ -1442,6 +1521,20 @@ if (!gotLock) {
buildTray();
applyAutoStart();
+ // 磁盘余量:小于 3GB 时安卓根本起不来(写镜像/快照都会失败)。
+ // 与其让用户看着「打不开」不明所以,不如开门见山告诉他往哪儿改。
+ {
+ const doctor = require('./core/doctor');
+ const freeMB = doctor.freeDiskMB(store.DATA_DIR);
+ if (freeMB && freeMB < 3072) {
+ appLog(`LOW_DISK free=${freeMB}MB dir=${store.DATA_DIR}`);
+ setTimeout(() => {
+ notify('磁盘空间不足', `只剩 ${(freeMB / 1024).toFixed(1)} GB。请到「设置 → 系统集成」把安卓数据目录/运行时目录改到其他盘,或先清理磁盘。`);
+ send('toast', { type: 'error', message: `磁盘只剩 ${(freeMB / 1024).toFixed(1)} GB,安卓可能无法启动(设置 → 系统集成 可换盘)` });
+ }, 3000).unref?.();
+ }
+ }
+
// 老版本只建过桌面快捷方式 / 图标是 null:启动即自动补齐,不用用户操作
installer.ensureShortcuts().then((fixed) => {
if (fixed && fixed.length) {
@@ -1559,6 +1652,13 @@ if (!gotLock) {
console.log('[smoke] saved', file);
};
await snap(out);
+ if (process.argv.includes('--perf')) {
+ // 拍一张「性能与资源占用」区(设置页里控件最多的一块)
+ await mainWindow.webContents.executeJavaScript(
+ "document.getElementById('perfGroup').scrollIntoView({ block: 'start' }); true;",
+ );
+ await snap(out.replace(/\.png$/i, '-perf.png'));
+ }
if (process.argv.includes('--settings')) {
// 再拍一张「关于」区(二维码 / GitHub / Powered by)
await mainWindow.webContents.executeJavaScript(
diff --git a/src/preload.js b/src/preload.js
index 92cc816..9825aaf 100644
--- a/src/preload.js
+++ b/src/preload.js
@@ -35,6 +35,9 @@ contextBridge.exposeInMainWorld('apkstart', {
installVcRedist: () => invoke('runtime:installVcRedist'),
runtimeUsage: () => invoke('runtime:usage'),
runtimeCleanup: (opts) => invoke('runtime:cleanup', opts || {}),
+ dataInfo: () => invoke('runtime:dataInfo'),
+ setDataSize: (gb) => invoke('runtime:setDataSize', gb),
+ confirm: (opts) => invoke('app:confirm', opts || {}),
displayState: () => invoke('display:state'),
displaySet: (patch) => invoke('display:set', patch || {}),
displayToggle: () => invoke('display:toggle'),
diff --git a/src/ui/app.js b/src/ui/app.js
index 3f1c9f9..fe7e285 100644
--- a/src/ui/app.js
+++ b/src/ui/app.js
@@ -664,16 +664,39 @@ function fillSettings(s) {
$('setDeviceSharedDir').value = s.deviceSharedDir || '';
const d = s.display || {};
$('setAutoStart').checked = s.autoStart !== false;
+ const eng = s.engine || {};
+ if ($('setResourceMode')) $('setResourceMode').value = eng.resourceMode || 'balanced';
+ if ($('setRenderSize')) $('setRenderSize').value = eng.renderSize || 'auto';
+ if ($('setDataGB')) $('setDataGB').value = String(Number(eng.dataPartitionGB || 0));
+ if ($('setFastDns')) $('setFastDns').checked = eng.fastDns !== false;
+ if ($('setKeepSnapshot')) $('setKeepSnapshot').checked = eng.keepSnapshot !== false;
$('setDisplayMode').value = d.mode === 'fullscreen' ? 'fullscreen' : 'window';
$('setPortrait').value = d.portrait || '900x1600';
$('portraitField').hidden = $('setDisplayMode').value === 'fullscreen';
}
+/** 数据分区实际大小 + 磁盘余量,显示在设置页容量选择下方 */
+async function refreshDataInfo() {
+ const el = $('dataNote');
+ if (!el) return;
+ const info = await api.dataInfo().catch(() => null);
+ if (!info) { el.textContent = '读取数据分区信息失败'; return; }
+ const auto = Number(($('setDataGB') || {}).value || 0) === 0;
+ const img = info.imageGB ? `${info.imageGB} GB` : '尚未创建';
+ const free = info.freeDiskMB ? `${(info.freeDiskMB / 1024).toFixed(1)} GB` : '未知';
+ el.textContent = `当前数据分区镜像:${img}${auto ? '(自动)' : ''} · 所在磁盘剩余 ${free}。`
+ + '游戏提示「存储空间不足」就把这里调大后点「立即扩容」——扩容是就地做的,已装应用与存档都保留。';
+}
+
async function openSettings() {
state.settings = await api.getSettings();
fillSettings(state.settings);
const info = await api.info();
$('setRuntimeDir').value = info.runtimeDir || info.dataDir;
+ if ($('setAvdDir')) {
+ const di = await api.dataInfo().catch(() => null);
+ $('setAvdDir').value = (di && di.avdDir) || '';
+ }
const verEl = document.getElementById('aboutVer');
if (verEl && info.version) verEl.textContent = `v${info.version}`;
const curVerEl = document.getElementById('updateCurrent');
@@ -694,6 +717,7 @@ async function openSettings() {
$('settingsMask').classList.add('on');
refreshAndroid();
+ refreshDataInfo();
}
function closeSettings() {
@@ -831,8 +855,65 @@ function bindSettings() {
refreshStatus();
});
$('setSystemImage').addEventListener('change', (e) => save({ runtime: { isoPath: e.target.value.trim() } }));
- $('setMemory').addEventListener('change', (e) => save({ engine: { memoryMB: Number(e.target.value) || 0 } }));
- $('setCores').addEventListener('change', (e) => save({ engine: { cores: Number(e.target.value) || 0 } }));
+ // 内存 / 核心:填了具体值就关掉「自动」,填 0 又回到自动。
+ // 旧代码只写 memoryMB,而 overridesFromSettings 只在 autoMemory=false 时才认它,
+ // 于是「手动填了内存」一直被忽略 —— 这是设置页最容易被当成“没用”的一项。
+ $('setMemory').addEventListener('change', (e) => {
+ const v = Number(e.target.value) || 0;
+ save(v > 0 ? { engine: { memoryMB: v, autoMemory: false } } : { engine: { memoryMB: 0, autoMemory: true } });
+ });
+ $('setCores').addEventListener('change', (e) => {
+ const v = Number(e.target.value) || 0;
+ save(v > 0 ? { engine: { cores: v, autoMemory: false } } : { engine: { cores: 0, autoMemory: true } });
+ });
+ if ($('setResourceMode')) {
+ $('setResourceMode').addEventListener('change', async (e) => {
+ // 资源策略会连带改 liteMode / priorityMode / renderSize(主进程里翻译)
+ state.settings = await api.setSettings({ engine: { resourceMode: e.target.value } });
+ fillSettings(state.settings);
+ toast({ title: '资源策略已切换', body: '下一次打开应用生效', type: 'ok' });
+ });
+ }
+ if ($('setRenderSize')) {
+ $('setRenderSize').addEventListener('change', (e) => save({ engine: { renderSize: e.target.value } }));
+ }
+ if ($('setFastDns')) {
+ $('setFastDns').addEventListener('change', (e) => save({ engine: { fastDns: e.target.checked } }));
+ }
+ if ($('setKeepSnapshot')) {
+ $('setKeepSnapshot').addEventListener('change', (e) => save({ engine: { keepSnapshot: e.target.checked } }));
+ }
+ if ($('setDataGB')) {
+ $('setDataGB').addEventListener('change', (e) => {
+ save({ engine: { dataPartitionGB: Number(e.target.value) || 0 } });
+ refreshDataInfo();
+ });
+ }
+ if ($('btnGrowData')) {
+ $('btnGrowData').addEventListener('click', async () => {
+ const gb = Number($('setDataGB').value) || 0;
+ if (!gb) { toast({ title: '先选一个容量', body: '「自动」表示由软件按磁盘余量决定,不需要扩容', type: 'info' }); return; }
+ const { response } = await api.confirm({
+ title: '立刻把安卓数据分区扩容?',
+ message: `将把 /data 调整为 ${gb} GB(就地扩容,已装应用和存档都会保留)。`,
+ detail: '扩容需要先关掉正在运行的安卓应用,完成后下次打开应用会重新引导,约多花十几秒。',
+ okLabel: '开始扩容',
+ });
+ if (response !== 1) return;
+ $('btnGrowData').disabled = true;
+ const old = $('btnGrowData').textContent;
+ $('btnGrowData').textContent = '扩容中…';
+ const r = await api.setDataSize(gb).catch((e) => ({ ok: false, error: e.message }));
+ $('btnGrowData').disabled = false;
+ $('btnGrowData').textContent = old;
+ toast({
+ type: r && r.ok ? 'ok' : 'error',
+ title: r && r.ok ? '数据分区已扩容' : '扩容失败',
+ body: r && r.ok ? `现在约 ${r.imageGB || gb} GB 可用` : (r && r.error) || '未知错误',
+ });
+ refreshDataInfo();
+ });
+ }
$('setIdle').addEventListener('change', (e) => save({ engine: { idleShutdownMinutes: Number(e.target.value) || 0 } }));
$('setAudio').addEventListener('change', (e) => save({ engine: { audio: e.target.checked } }));
$('setLiteMode').addEventListener('change', (e) => save({ engine: { liteMode: e.target.checked } }));
@@ -1040,6 +1121,29 @@ function bindSettings() {
toast({ title: '数据目录已更新', body: '请重启 ApkStart 使其生效(旧数据不会自动搬移)', type: 'ok', sticky: true });
});
+ // 安卓数据目录(AVD + 快照):真正吃盘的那块,单独指到别的盘
+ if ($('btnBrowseAvdDir')) {
+ $('btnBrowseAvdDir').addEventListener('click', async () => {
+ const picked = await api.openDir();
+ if (!picked) return;
+ await api.setSettings({ runtime: { avdDir: picked } });
+ $('setAvdDir').value = picked;
+ toast({
+ title: '安卓数据目录已更新',
+ body: '请重启 ApkStart 使其生效。旧目录里的 apkstart.avd 可以整体搬到新目录,再删掉旧的。',
+ type: 'ok',
+ sticky: true,
+ });
+ });
+ }
+ if ($('btnOpenAvdDir')) {
+ $('btnOpenAvdDir').addEventListener('click', async () => {
+ const info = await api.dataInfo().catch(() => null);
+ const dir = (info && info.avdDir) || (await api.info()).dataDir;
+ window.open(`file:///${String(dir).replace(/\\/g, '/')}`);
+ });
+ }
+
$('btnProbe').addEventListener('click', async () => {
const el = $('probeResult');
el.textContent = '探测中…';
diff --git a/src/ui/index.html b/src/ui/index.html
index bbf99b7..d2166ab 100644
--- a/src/ui/index.html
+++ b/src/ui/index.html
@@ -145,12 +145,12 @@
<span class="sub">内存、核心数、渲染后端、端口、加速方式全部自动选择;启动失败会自动降级重试,不需要手动改。</span>
</div>
<div class="field">
- <label>运行时占用(文件逻辑大小)</label>
+ <label>磁盘总占用(运行时 + 安卓数据 + 缓存)</label>
<div class="row">
<span class="inline-note" id="usageText">正在统计…</span>
<button class="btn ghost sm" id="btnCleanup">清理可回收文件</button>
</div>
- <span class="sub">只读系统镜像全机共享一份,应用数据用差分层保存;旧镜像、旧快照和锁文件可随时回收。</span>
+ <span class="sub">系统镜像全机共享一份,应用数据用差分层保存;旧镜像、旧快照、日志和锁文件都可回收。日志超过上限会自动滚动,不会无限增长。</span>
</div>
<div class="runtime-actions">
<button class="btn ghost sm" id="btnDiagnostics">导出诊断报告</button>
@@ -222,8 +222,56 @@
</div>
</div>
- <div class="group">
- <div class="group-title">性能与轻量容器</div>
+ <div class="group" id="perfGroup">
+ <div class="group-title">性能与资源占用</div>
+ <div class="field">
+ <label>资源策略</label>
+ <select id="setResourceMode">
+ <option value="save">省资源 · 2 核 / 让出前台 / 540p(老机器、挂机)</option>
+ <option value="balanced">均衡 · 一半物理核 / 让出前台 / 720p(推荐)</option>
+ <option value="smooth">流畅 · 不限核数 / 与前台同优先级(视频、游戏)</option>
+ </select>
+ <span class="sub">决定安卓虚拟机吃多少 CPU、画面多细腻。红果/抖音发卡就切「流畅」,只想挂着跑小应用就切「省资源」。改完下一次打开应用生效。</span>
+ </div>
+ <div class="field two">
+ <div>
+ <label>画质(安卓内部渲染分辨率)</label>
+ <select id="setRenderSize">
+ <option value="auto">自动(按加速状态)</option>
+ <option value="540x960">流畅 · 540 × 960</option>
+ <option value="720x1280">均衡 · 720 × 1280</option>
+ <option value="1080x1920">高清 · 1080 × 1920</option>
+ </select>
+ </div>
+ <div>
+ <label>安卓数据分区(应用与游戏装这里)</label>
+ <select id="setDataGB">
+ <option value="0">自动</option>
+ <option value="4">4 GB</option>
+ <option value="6">6 GB</option>
+ <option value="8">8 GB</option>
+ <option value="12">12 GB</option>
+ <option value="16">16 GB</option>
+ <option value="24">24 GB</option>
+ </select>
+ </div>
+ </div>
+ <div class="field">
+ <div class="row">
+ <button class="btn ghost sm" id="btnGrowData">立即扩容</button>
+ <span class="sub" style="flex:1;margin:0">扩容是就地做的:已装应用与存档都保留,只是下次打开应用会多花十几秒。</span>
+ </div>
+ </div>
+ <div class="field">
+ <span class="sub" id="dataNote">正在读取数据分区…</span>
+ </div>
+ <div class="field switch-field">
+ <div>
+ <label>网络加速(推荐)</label>
+ <span class="sub">给安卓指定国内公共 DNS(阿里 / 腾讯)。安卓默认走主机的 DNS,主机挂着 VPN 或走公司网时解析会拖到几百毫秒,视频类应用首屏发慢。内网域名访问异常时可关掉。</span>
+ </div>
+ <input type="checkbox" id="setFastDns" class="switch" />
+ </div>
<div class="field switch-field">
<div>
<label>安卓声音</label>
@@ -233,19 +281,29 @@
</div>
<div class="field switch-field">
<div>
- <label>轻量容器(推荐)</label>
- <span class="sub">把安卓虚拟机限制在 2–3 个 vCPU 并降低进程优先级,CPU 优先让给 Windows 桌面。关掉后按机器配置分配更多核心,安卓更猛但主机会明显变卡。</span>
+ <label>保留快速启动快照(推荐)</label>
+ <span class="sub">第二次打开应用只要几秒,代价是磁盘上多一份约 2–3 GB 的 <code>ram.bin</code>。磁盘紧张可以关掉:只影响启动速度,不影响应用与存档。</span>
</div>
- <input type="checkbox" id="setLiteMode" class="switch" />
- </div>
- <div class="field">
- <label>虚拟机优先级</label>
- <select id="setPriorityMode">
- <option value="balanced">均衡(推荐)· 运行时让着前台窗口</option>
- <option value="performance">性能优先 · 运行时与前台同等优先级</option>
- </select>
- <span class="sub">没有应用窗口时,容器一律自动降到最低优先级停放。</span>
+ <input type="checkbox" id="setKeepSnapshot" class="switch" />
</div>
+ <details class="mini-details">
+ <summary>容器细节(高级)</summary>
+ <div class="field switch-field">
+ <div>
+ <label>轻量容器</label>
+ <span class="sub">收敛 vCPU 配额并降低进程优先级,CPU 优先让给 Windows 桌面。上面的「资源策略」已经会自动设置这一项。</span>
+ </div>
+ <input type="checkbox" id="setLiteMode" class="switch" />
+ </div>
+ <div class="field">
+ <label>虚拟机优先级</label>
+ <select id="setPriorityMode">
+ <option value="balanced">均衡(推荐)· 运行时让着前台窗口</option>
+ <option value="performance">性能优先 · 运行时与前台同等优先级</option>
+ </select>
+ <span class="sub">没有应用窗口时,容器一律自动降到最低优先级停放。</span>
+ </div>
+ </details>
<div class="field switch-field">
<div>
<label>深度裁剪系统后台</label>
@@ -459,6 +517,16 @@
</div>
<span class="sub">这里占用空间最大(数 GB)。改到非系统盘可大幅减轻 C 盘压力;修改后需重启软件,已存在的数据不会自动搬移(请手动复制后删除旧目录)。</span>
</div>
+ <div class="field">
+ <label>安卓数据目录(应用、游戏与快速启动快照)</label>
+ <div class="row">
+ <input id="setAvdDir" type="text" readonly placeholder="默认:运行时目录下的 avd 文件夹" />
+ <button class="btn ghost sm" id="btnBrowseAvdDir">浏览</button>
+ <button class="btn ghost sm" id="btnOpenAvdDir">打开</button>
+ </div>
+ <span class="sub">真正吃盘的是这一块:数据分区(默认 6 GB,可在上面对大)+ 快速启动快照(约 2–3 GB)。
+ 磁盘紧张时把它指到另一个盘(如 D:),重启软件后生效;旧目录里的 <code>apkstart.avd</code> 可整体搬过去再删。</span>
+ </div>
<div class="field">
<label>卸载 ApkStart</label>
<div class="row">
diff --git a/src/ui/style.css b/src/ui/style.css
index 0630237..91d968a 100644
--- a/src/ui/style.css
+++ b/src/ui/style.css
@@ -802,3 +802,31 @@ kbd {
white-space: pre-wrap;
color: var(--text-2, #556);
}
+
+/* 组内的小号折叠块(容器细节等) */
+.mini-details {
+ margin: 2px 0 6px;
+ border: 1px dashed var(--line, #e8ebf0);
+ border-radius: 10px;
+ padding: 0 10px 2px;
+}
+.mini-details > summary {
+ cursor: pointer;
+ list-style: none;
+ user-select: none;
+ padding: 10px 0 8px;
+ font-size: 12px;
+ color: var(--muted, #7b828e);
+ font-weight: 600;
+}
+.mini-details > summary::-webkit-details-marker { display: none; }
+.mini-details > summary::before {
+ content: '▸';
+ display: inline-block;
+ margin-right: 6px;
+ transition: transform .15s ease;
+}
+.mini-details[open] > summary::before { transform: rotate(90deg); }
+
+/* 行内按钮不要折行(空间紧张时「立即扩容」会被拆成两行) */
+.row .btn { white-space: nowrap; flex: 0 0 auto; }
diff --git a/test/auto-test.js b/test/auto-test.js
index 3b3583b..9d294b1 100644
--- a/test/auto-test.js
+++ b/test/auto-test.js
@@ -52,7 +52,13 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
// accel 关闭时的保底参数必须是软件渲染,否则 TCG 下无 GPU 可用
const lastResort = doctor.planVariants(p).find((v) => v.lastResort);
assert(lastResort && /software|swiftshader/.test(lastResort.gpu), '保底方案必须用软件渲染');
- assert(p.dataMB <= 4096, '数据分区不应再是 16G');
+ // 数据分区默认按磁盘余量给 4/6/8GB(不再写死 16G),且可以被设置覆盖
+ assert(p.dataMB >= 4096 && p.dataMB <= 8192, `数据分区应在 4~8GB,实际 ${p.dataMB}`);
+ const big = doctor.chooseProfile({
+ host, accel: { ok: true }, emulatorVersion: '37.3.8.0', diskMB: 200000,
+ settings: { engine: { dataPartitionGB: 24 } }, overrides: {},
+ });
+ assert(big.dataMB === 24 * 1024, '设置里的数据分区容量必须生效');
});
await test('大内存机器不会无限吃内存', () => {
@@ -70,9 +76,12 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
const v = doctor.planVariants(p);
assert(v.length >= 3 && v.length <= 4, `重试次数应 3-4,实际 ${v.length}`);
assert(v.some((x) => x.accel === 'off'), '缺少软件模拟兜底');
- assert(v[v.length - 1].wipe === true, '最后一档应强制冷启动清快照');
+ // 最后一档只做「不加载快照 + 最小内存」,绝不允许 -wipe-data:
+ // 磁盘写满时每一档都会失败,带 wipe 的话会把用户已装应用一起清掉(实测踩过)。
+ assert(v[v.length - 1].snapshot === false, '最后一档必须跳过快照加载');
+ assert(v[v.length - 1].wipe === false, '任何自动重试都不允许清用户数据');
assert(v[v.length - 1].memoryMB <= 2048, '最后一档应降到最小内存');
- const keys = v.map((x) => `${x.gpu}|${x.accel}|${x.wipe}|${x.memoryMB}`);
+ const keys = v.map((x) => `${x.gpu}|${x.accel}|${x.wipe}|${x.memoryMB}|${x.snapshot !== false}`);
assert(new Set(keys).size === keys.length, '重试方案不应重复');
});
@@ -168,6 +177,62 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
assert(s.includes('ARM 翻译层') && s.includes('兼容镜像'), s);
});
+ console.log('\n[sharer 不再来回搬运(磁盘写满的元凶)]');
+
+ await test('同一个文件不会每轮都被从设备拉回来', async () => {
+ const { Sharer } = require('../src/core/sharer');
+ const localDir = path.join(TMP, 'shared');
+ fs.mkdirSync(localDir, { recursive: true });
+ const file = path.join(localDir, 'a.txt');
+ fs.writeFileSync(file, 'hello');
+
+ const calls = { push: 0, pull: 0 };
+ const fakeClient = {
+ isOnline: async () => true,
+ shellMkdir: async () => {},
+ shell: async () => '',
+ push: async () => { calls.push += 1; },
+ pull: async (_r, dst) => { calls.pull += 1; fs.writeFileSync(dst, 'hello'); },
+ listRemoteStat: async () => [{ rel: 'a.txt', size: 5, mtime: Date.now() - 60000 }],
+ };
+ const sh = new Sharer({ client: () => fakeClient });
+ sh.localDirOverride = localDir;
+ // 用真实的路径/状态文件,但目录指向临时目录
+ Object.defineProperty(sh, 'localDir', { get: () => localDir });
+ Object.defineProperty(sh, 'remoteDir', { get: () => '/sdcard/x' });
+ sh.stateFile = path.join(TMP, 'shared-state.json');
+
+ await sh.sync(); // 第 1 轮:本机新文件 → 推上去
+ const firstPull = calls.pull;
+ await sh.sync(); // 第 2 轮
+ await sh.sync(); // 第 3 轮
+ await sh.sync(); // 第 4 轮
+ assert(calls.push === 1, `只应推送一次,实际 ${calls.push}`);
+ assert(firstPull === 0, `刚推上去的文件不该立刻被拉回来,实际拉取 ${firstPull} 次`);
+ assert(calls.pull === firstPull, `后续轮次不应再反复拉取,实际累计 ${calls.pull} 次`);
+ });
+
+ await test('超大文件不会被反向拉回本机(本地目录不是设备缓存下水道)', async () => {
+ const { Sharer } = require('../src/core/sharer');
+ const localDir = path.join(TMP, 'shared2');
+ fs.mkdirSync(localDir, { recursive: true });
+ let pulled = 0;
+ const fakeClient = {
+ isOnline: async () => true,
+ shellMkdir: async () => {},
+ shell: async () => '',
+ push: async () => {},
+ pull: async () => { pulled += 1; },
+ listRemoteStat: async () => [{ rel: 'big.mp4', size: 600 * 1024 * 1024, mtime: Date.now() }],
+ };
+ const sh = new Sharer({ client: () => fakeClient });
+ Object.defineProperty(sh, 'localDir', { get: () => localDir });
+ Object.defineProperty(sh, 'remoteDir', { get: () => '/sdcard/x' });
+ sh.stateFile = path.join(TMP, 'shared-state2.json');
+ await sh.sync();
+ assert(pulled === 0, '超过 512MB 的文件不应拉回本机');
+ });
+
console.log('\n[adb/sharer 文件互通]');
await test('ls -l 解析兼容 Android 的含 group / 日期格式', async () => {
@@ -566,7 +631,11 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
await test('doctor 轻量容器:收敛 vCPU,手动设置优先', () => {
const host = { totalMB: 32768, freeMB: 20000, cores: 16, home: 'C:\\x', homeAscii: true, tmp: TMP, platform: 'win32', arch: 'x64', rdp: false };
const lite = doctor.liteProfile({ host, engine: {} });
- assert(lite && lite.cores <= 3 && lite.cores >= 2, `16 核机器轻量模式应给 2~3 核,实际 ${lite && lite.cores}`);
+ // 老逻辑是 floor(核数/4) 夹到 2~3 —— 8 核机器只给 2 个 vCPU,视频应用直接卡。
+ // 现在均衡模式给「一半物理核、上限 4」,省资源模式固定 2。
+ assert(lite && lite.cores === 4, `16 核机器均衡模式应给 4 核,实际 ${lite && lite.cores}`);
+ const save = doctor.liteProfile({ host, engine: { resourceMode: 'save' } });
+ assert(save.cores === 2, `省资源模式应固定 2 核,实际 ${save.cores}`);
assert(doctor.liteProfile({ host, engine: { liteMode: false } }) === null, '显式关闭应返回 null');
const low = doctor.liteProfile({ host: { ...host, cores: 2 }, engine: {} });
assert(low.cores === 2, '2 核机器至少保留 2 核');
@@ -575,7 +644,7 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
settings: { engine: { autoMemory: true, liteMode: true } },
accel: { ok: true }, emulatorVersion: '37.3.8.0', diskMB: 100000,
});
- assert(auto.lite === true && auto.cores <= 3, JSON.stringify({ lite: auto.lite, cores: auto.cores }));
+ assert(auto.lite === true && auto.cores <= 4, JSON.stringify({ lite: auto.lite, cores: auto.cores }));
const manual = doctor.autoProfile({
settings: { engine: { autoMemory: false, cores: 6, liteMode: true } },
accel: { ok: true }, emulatorVersion: '37.3.8.0', diskMB: 100000,
@@ -761,6 +830,48 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
assert(/portable.*\.zip$/i.test('ApkStart-v0.3.2-win64-portable.zip'), '便携版资产名匹配');
});
+ console.log('\n[资源策略 / 磁盘分配 / 日志上限]');
+
+ await test('资源策略一处切换,自动翻译成 vCPU/优先级/分辨率', () => {
+ const store = require('../src/core/store');
+ let s = store.saveSettings({ engine: { resourceMode: 'smooth' } });
+ assert(s.engine.liteMode === false, '流畅模式不应限制核数');
+ assert(s.engine.priorityMode === 'performance', '流畅模式应与前台同优先级');
+ assert(s.engine.renderSize === '720x1280', `分辨率应 720p,实际 ${s.engine.renderSize}`);
+ s = store.saveSettings({ engine: { resourceMode: 'save' } });
+ assert(s.engine.liteMode === true && s.engine.renderSize === '540x960', '省资源应 540p + 轻量容器');
+ s = store.saveSettings({ engine: { resourceMode: 'balanced' } });
+ assert(s.engine.renderSize === 'auto', '均衡模式分辨率交给自动');
+ });
+
+ await test('数据分区容量可配置,且默认不再是死数字', () => {
+ const store = require('../src/core/store');
+ store.saveSettings({ engine: { dataPartitionGB: 12 } });
+ const p = doctor.autoProfile({ settings: store.getSettings(), accel: { ok: true }, emulatorVersion: '37.3.8.0', diskMB: 50000 });
+ assert(p.dataMB === 12 * 1024, `应为 12GB,实际 ${p.dataMB}MB`);
+ store.saveSettings({ engine: { dataPartitionGB: 0 } });
+ const auto = doctor.autoProfile({ settings: store.getSettings(), accel: { ok: true }, emulatorVersion: '37.3.8.0', diskMB: 50000 });
+ assert(auto.dataMB === 6144, `磁盘充裕时自动应 6GB,实际 ${auto.dataMB}`);
+ });
+
+ await test('快照指纹不含数据分区大小(扩容不该作废快照、更不该清数据)', () => {
+ const base = { emulatorVersion: '37.3.8', api: '34', tag: 'google_apis_playstore' };
+ const a = doctor.snapshotKey({ ...base, dataMB: 4096 }, 'img');
+ const b = doctor.snapshotKey({ ...base, dataMB: 24576 }, 'img');
+ assert(a === b, '只改容量不应改变指纹');
+ const c = doctor.snapshotKey({ ...base, dataMB: 4096, emulatorVersion: '36.0.0' }, 'img');
+ assert(a !== c, '换引擎版本应改变指纹');
+ });
+
+ await test('日志超过上限自动滚动,只保留一份备份', () => {
+ const lf = require('../src/core/logfile');
+ const f = path.join(TMP, 'rot.log');
+ fs.writeFileSync(f, 'x'.repeat(300 * 1024));
+ const rotated = lf.rotate(f, 256);
+ assert(rotated === true, '应执行滚动');
+ assert(!fs.existsSync(f) && fs.existsSync(path.join(TMP, 'rot.1.log')), '应变成 .1.log');
+ });
+
console.log(results.join('\n'));
console.log(`\n结果:${passed} 通过,${failed} 失败\n`);
try { fs.rmSync(TMP, { recursive: true, force: true }); } catch (_) { /* ignore */ }