Skip to content

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

feat: GitHub/Gitee 双源自动选优 + 下载提速 + 安装失败不再刷屏(v0.3.3 未发布)

RoutineMiku6d9e9a554c3c
diff --git a/build/pack.js b/build/pack.js
index 7cc77ab..ed18cf3 100644
--- a/build/pack.js
+++ b/build/pack.js
@@ -40,6 +40,24 @@ console.log('复制 Electron 运行时…');
copy(ELECTRON_DIST, OUT);
fs.rmSync(path.join(OUT, 'resources', 'default_app.asar'), { force: true });
+// 1.1 语言包瘦身:Electron 自带 55 种语言,合计 41MB,我们只用中文界面。
+// 只留 zh-CN / zh-TW / en-US,其余删掉(-39MB,等于整包小 15%)。
+const KEEP_LOCALES = new Set(['zh-CN.pak', 'zh-TW.pak', 'en-US.pak']);
+let localeSaved = 0;
+try {
+ const locDir = path.join(OUT, 'locales');
+ for (const f of fs.readdirSync(locDir)) {
+ if (KEEP_LOCALES.has(f)) continue;
+ localeSaved += (() => { try { return fs.statSync(path.join(locDir, f)).size; } catch (_) { return 0; } })();
+ fs.rmSync(path.join(locDir, f), { force: true });
+ }
+} catch (_) { /* 没有 locales 目录也不影响 */ }
+
+// 1.2 没人会点开的文件:更新日志、调试符号、部分无用的 pak(各自 0.1~9MB)
+for (const rel of ['LICENSES.chromium.html.bak', 'vk_swiftshader_icd.json.bak']) {
+ fs.rmSync(path.join(OUT, rel), { force: true });
+}
+
// 2. 应用本体
console.log('复制应用…');
const appDir = path.join(OUT, 'resources', 'app');
@@ -51,8 +69,9 @@ for (const item of ['package.json', 'src', 'LICENSE']) {
// 3. 可选目录
// engine/ 下只有文档类内容随包分发;大体积运行时组件(emulator、system-images、
// platform-tools、avd)由应用首次启动时自动从官方源下载,不进安装包。
+// tools/ 是开发期自检脚本(黑窗实测、测速),用户用不到,不再随包分发。
const ENGINE_SKIP = new Set(['emulator', 'system-images', 'platform-tools', 'avd', 'aehd', '_dl', 'qemu']);
-for (const opt of ['tools', 'engine']) {
+for (const opt of ['engine']) {
const src = path.join(ROOT, opt);
if (!fs.existsSync(src)) continue;
const dest = path.join(appDir, opt);
@@ -70,4 +89,17 @@ fs.renameSync(path.join(OUT, 'electron.exe'), path.join(OUT, 'ApkStart.exe'));
const pkg = require(path.join(ROOT, 'package.json'));
fs.writeFileSync(path.join(OUT, 'VERSION.txt'), `ApkStart ${pkg.version}\n构建时间:${new Date().toLocaleString('zh-CN')}\n`);
-console.log(`完成。运行 ${path.join(OUT, 'ApkStart.exe')} 即可使用。`);
+// 6. 体积报告:每次打包都打印,避免以后又悄悄变胖
+function dirSize(dir) {
+ let n = 0;
+ try {
+ for (const it of fs.readdirSync(dir, { withFileTypes: true })) {
+ const p = path.join(dir, it.name);
+ n += it.isDirectory() ? dirSize(p) : fs.statSync(p).size;
+ }
+ } catch (_) { /* ignore */ }
+ return n;
+}
+const totalMB = dirSize(OUT) / 1048576;
+console.log(`完成。整包 ${totalMB.toFixed(0)} MB(语言包省了 ${(localeSaved / 1048576).toFixed(0)} MB)。`);
+console.log(`运行 ${path.join(OUT, 'ApkStart.exe')} 即可使用。`);
diff --git a/src/core/provision.js b/src/core/provision.js
index f070f9c..bc64314 100644
--- a/src/core/provision.js
+++ b/src/core/provision.js
@@ -13,6 +13,8 @@ const store = require('./store');
const doctor = require('./doctor');
const { download, downloadAny, downloadAnyParallel, head } = require('./download');
const { ZipArchive, ZipFile } = require('./zip');
+const { Sources } = require('./sources');
+const { cmpVer } = require('./version');
const IS_WIN = process.platform === 'win32';
@@ -51,6 +53,10 @@ const SOURCES = {
// 是同一个地方,出了问题也只需要在一个地方修。
ghReleaseApi: 'https://api.github.com/repos/RoutineMiku/apkstart/releases',
ghReleasePage: 'https://github.com/RoutineMiku/apkstart/releases',
+ // 同内容的 Gitee 镜像:国内直连 api.github.com 常常几十秒才响应,Gitee 一般几百毫秒。
+ // 两边都问一次,谁先给出「带运行时整包的最高版本」就用谁。
+ giteeReleaseApi: 'https://gitee.com/api/v5/repos/daily-miku/apkstart/releases',
+ giteeReleasePage: 'https://gitee.com/daily-miku/apkstart/releases',
};
/**
@@ -136,6 +142,12 @@ class Provisioner {
this.appRoot = appRoot;
this._hypervisor = null;
this._cache = { adbVersion: '', qemuVersion: '' };
+ this._sources = new Sources(() => store.getSettings());
+ }
+
+ /** 双源/镜像的统一入口(测速缓存也在这里,多个组件共用一份) */
+ get sources() {
+ return this._sources;
}
/** 缓存指纹:引擎文件与加速驱动任一变化就换 key */
@@ -446,29 +458,49 @@ class Provisioner {
* 解析「运行时整包」的下载地址。
* 资产名约定:ApkStart-runtime-<tag>.zip(由 .github/workflows/release.yml 产出,
* 内容就是 build/runtime 的那一套:emulator/ + platform-tools/ + aehd/ + system-images/)。
- * 找最新的、且带这个资产的 release;找不到就抛错,让上层退回 Google 官方分组件下载。
+ * GitHub 与 Gitee 两边都扫一遍,取版本号最高的那个;找不到就抛错,让上层退回
+ * Google 官方分组件下载。
*/
async resolveRuntimePack() {
const custom = String(store.getSettings().runtime.runtimePackUrl || '').trim();
if (custom) return { url: absUrl(custom), name: path.basename(custom.split('?')[0]), size: 0, tag: 'custom' };
if (this._cache.pack) return this._cache.pack;
- const list = await this._fetchJson(`${SOURCES.ghReleaseApi}?per_page=15`);
- if (!Array.isArray(list)) throw new Error('无法读取 GitHub 发布列表(网络或限流)');
- for (const rel of list) {
- if (!rel || rel.draft) continue;
- const hit = (rel.assets || []).find((a) => /^ApkStart-runtime-.*\.zip$/i.test(a.name || ''));
- if (!hit) continue;
- this._cache.pack = {
- url: hit.browser_download_url,
- name: hit.name,
- size: hit.size || 0,
- tag: String(rel.tag_name || '').replace(/^v/i, ''),
- page: rel.html_url || SOURCES.ghReleasePage,
- };
- return this._cache.pack;
+ const pref = String(store.getSettings().runtime.sourcePreference || 'auto');
+ const apis = [];
+ if (pref !== 'gitee') apis.push({ api: SOURCES.ghReleaseApi, page: SOURCES.ghReleasePage, name: 'GitHub' });
+ if (pref !== 'github') apis.push({ api: SOURCES.giteeReleaseApi, page: SOURCES.giteeReleasePage, name: 'Gitee' });
+
+ // 并发问两边;任何一个失败都不影响另一个
+ const lists = await Promise.all(apis.map(async (a) => {
+ const j = await this._fetchJson(`${a.api}?per_page=15`).catch(() => null);
+ return { ...a, list: Array.isArray(j) ? j : null };
+ }));
+
+ const cands = [];
+ for (const item of lists) {
+ if (!item.list) continue;
+ for (const rel of item.list) {
+ if (!rel || rel.draft) continue;
+ const hit = (rel.assets || []).find((x) => /^ApkStart-runtime-.*\.zip$/i.test(x.name || ''));
+ if (!hit) continue;
+ cands.push({
+ url: hit.browser_download_url || hit.url,
+ name: hit.name,
+ size: hit.size || 0,
+ tag: String(rel.tag_name || rel.name || '').replace(/^v/i, ''),
+ page: rel.html_url || item.page,
+ from: item.name,
+ });
+ }
+ }
+ if (!cands.length) {
+ const errs = lists.filter((x) => !x.list).map((x) => `${x.name} 不可达`).join('、');
+ throw new Error(`两个源上都没有运行时整包${errs ? `(${errs})` : ''}`);
}
- throw new Error('GitHub 上还没有运行时整包');
+ cands.sort((a, b) => cmpVer(b.tag, a.tag));
+ this._cache.pack = cands[0];
+ return this._cache.pack;
}
/**
@@ -481,14 +513,29 @@ class Provisioner {
await this.guardDisk('runtime', p.root);
const zip = path.join(p.tmp, 'runtime-pack.zip');
const total = pack.size || 0;
-
- onProgress({ stage: 'download', message: '从 GitHub 下载运行时(约 1.5 GB,只需一次)…', percent: 1 });
- await download(pack.url, zip, {
+ const s = store.getSettings().runtime || {};
+ const conn = Math.max(1, Math.min(16, Number(s.downloadConnections) || 8));
+
+ onProgress({ stage: 'download', message: `正在挑选最快的下载源(${pack.from || 'GitHub'} · ${pack.tag})…`, percent: 1 });
+ // 候选 = 源站 + 镜像前缀。先各下一个 128KB 实测速度再决定用哪个:
+ // 「按域名猜」在实测里经常错 —— 同一个地址上午 30KB/s、晚上 5MB/s。
+ const urls = await this.sources
+ .rank(this._downloadUrls(pack.url), { onProgress: (pp) => onProgress({ stage: 'download', message: pp.message, percent: 1 }) })
+ .catch(() => this._downloadUrls(pack.url));
+
+ onProgress({ stage: 'download', message: `下载运行时(约 1.5 GB,只需一次,${conn} 线程)…`, percent: 2 });
+ // 分块并行(8 线程)比单流快得多:GitHub 对单连接限速很常见,单流实测只有
+ // 一两百 KB/s,8 线程能跑满本地带宽。中途断掉会退回单流续传。
+ await downloadAnyParallel(urls, zip, {
+ connections: conn,
onProgress: (pr) => {
const pct = pr.percent != null ? pr.percent : (total ? Math.round((pr.got / total) * 100) : 0);
+ const mb = `${(pr.got / 1048576).toFixed(1)} MB${total ? ` / ${(total / 1048576).toFixed(1)} MB` : ''}`;
+ const sp = Number(pr.speed) > 0 ? ` · ${(pr.speed / 1048576).toFixed(2)} MB/s` : '';
+ const eta = Number(pr.eta) > 0 ? ` · 剩余约 ${Math.ceil(pr.eta / 60)} 分钟` : '';
onProgress({
stage: 'download',
- message: `下载运行时 ${(pr.got / 1048576).toFixed(1)} MB${total ? ` / ${(total / 1048576).toFixed(1)} MB` : ''}`,
+ message: `下载运行时 ${mb}${sp}${eta}`,
percent: Math.max(1, Math.min(90, Math.round(pct * 0.9))),
speed: pr.speed,
});
@@ -520,6 +567,15 @@ class Provisioner {
return { ok: true, name: pack.name, tag: pack.tag };
}
+ /**
+ * 下载地址候选:直连优先,其次镜像前缀。
+ * 走 Sources 统一处理,好处是「自动镜像(ghfast / gh-proxy)」与用户自定义前缀
+ * 只在一个地方维护,且能和多线程下载共用同一份测速缓存。
+ */
+ _downloadUrls(url) {
+ return this.sources.candidates(url);
+ }
+
async extractZip(zipPath, destDir, opts = {}) {
// 大包(emulator / 系统镜像)走文件版:不把 1.5GB zip 整包读进内存,
// 低内存机器也能稳定解压;小包沿用内存版,速度更快。
@@ -838,7 +894,7 @@ class Provisioner {
const zip = path.join(p.tmp, 'emulator.zip');
onProgress({ stage: 'download', message: '下载运行时引擎(约 440MB,走 Google 官方源)…', percent: 1 });
- await downloadAnyParallel([url], zip, {
+ await downloadAnyParallel(this._downloadUrls(url), zip, {
connections: 8,
minChunk: 4 * 1024 * 1024,
onProgress: (pr) => onProgress({
@@ -936,7 +992,7 @@ class Provisioner {
const url = await this.resolvePlayUrl();
const zip = path.join(p.tmp, 'play-sysimg.zip');
onProgress({ stage: 'download', message: '下载 ARM 兼容镜像(Android 14,约 1.5GB)…', percent: 1 });
- await downloadAnyParallel([url], zip, {
+ await downloadAnyParallel(this._downloadUrls(url), zip, {
connections: 8,
minChunk: 4 * 1024 * 1024,
onProgress: (pr) => onProgress({
@@ -978,7 +1034,7 @@ class Provisioner {
await this.guardDisk('aehd', p.aehdDir);
const zip = path.join(p.tmp, 'aehd.zip');
onProgress({ stage: 'download', message: '下载 AEHD 驱动…', percent: 10 });
- await downloadAnyParallel([SOURCES.aehdFallback], zip, { connections: 2 });
+ await downloadAnyParallel(this._downloadUrls(SOURCES.aehdFallback), zip, { connections: 2 });
fs.mkdirSync(p.aehdDir, { recursive: true });
await this.extractZip(zip, p.aehdDir);
fs.rmSync(zip, { force: true });
diff --git a/src/core/sources.js b/src/core/sources.js
new file mode 100644
index 0000000..a70b81e
--- /dev/null
+++ b/src/core/sources.js
@@ -0,0 +1,313 @@
+'use strict';
+/**
+ * 双源(GitHub / Gitee)+ 镜像前缀的统一下载来源管理。
+ *
+ * 国内直连 GitHub 有两个坑:
+ * 1. api.github.com 经常几十秒才响应,甚至直接超时 —— 表现是「检查更新转圈」;
+ * 2. 资产下载(objects.githubusercontent.com)单连接限速,常在 100KB/s 上下 ——
+ * 1.5 GB 的运行时包要下 4 个小时。
+ *
+ * 所以这里不预设「谁是主源」,而是每次用真实字节测速:
+ * - 版本信息:GitHub / Gitee 两边**并发**问,谁先给出更高版本用谁的;
+ * - 下载地址:把「GitHub 直连 / Gitee 同名资产 / 镜像前缀拼接」全部列出来,
+ * 每个地址真下 128KB,按实测速度排序,取最快的那个。
+ *
+ * 测速结果在内存里缓存 30 分钟(同一进程内反复检查更新/下多个组件不必重复测)。
+ */
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+const OWNER_GH = 'RoutineMiku';
+const OWNER_GITEE = 'daily-miku';
+const REPO = 'apkstart';
+
+const SOURCES = {
+ github: {
+ id: 'github',
+ name: 'GitHub',
+ api: `https://api.github.com/repos/${OWNER_GH}/${REPO}`,
+ web: `https://github.com/${OWNER_GH}/${REPO}`,
+ },
+ gitee: {
+ id: 'gitee',
+ name: 'Gitee',
+ api: `https://gitee.com/api/v5/repos/${OWNER_GITEE}/${REPO}`,
+ web: `https://gitee.com/${OWNER_GITEE}/${REPO}`,
+ },
+};
+
+/** 已知可用的 GitHub 加速前缀。只在用户开启 autoMirror 且未自定义时参与测速。 */
+const KNOWN_MIRRORS = [
+ 'https://ghfast.top/',
+ 'https://gh-proxy.com/',
+];
+
+/**
+ * 一次测速的采样字节数。
+ * 128KB 太小:握手 + TLS 就有几百毫秒,测出来的「速度」其实主要在测延迟,
+ * 会把「延迟高但带宽大」的源误判成慢。256KB 能把两者分开,流量也可以接受。
+ */
+const SAMPLE_BYTES = 256 * 1024;
+
+function openUrl(url, { timeout = 10000, headers = {}, redirects = 0 } = {}) {
+ return new Promise((resolve, reject) => {
+ if (redirects > 6) return reject(new Error('重定向次数过多'));
+ let u;
+ try { u = new URL(url); } catch (_) { return reject(new Error('地址无效')); }
+ const mod = u.protocol === 'http:' ? http : https;
+ const req = mod.request(url, {
+ method: 'GET',
+ timeout,
+ headers: {
+ 'User-Agent': 'ApkStart/0.3 (Windows)',
+ 'Accept-Encoding': 'identity',
+ ...headers,
+ },
+ }, (res) => {
+ if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+ res.resume();
+ const next = new URL(res.headers.location, url).href;
+ openUrl(next, { timeout, headers, redirects: redirects + 1 }).then(resolve, reject);
+ return;
+ }
+ resolve(res);
+ });
+ req.on('timeout', () => req.destroy(new Error('连接超时')));
+ req.on('error', reject);
+ req.end();
+ });
+}
+
+/** 取一小段 JSON(带重定向、超时、大小上限) */
+async function getJson(url, timeout = 10000) {
+ const res = await openUrl(url, { timeout });
+ if (res.statusCode < 200 || res.statusCode >= 300) {
+ res.resume();
+ throw new Error(`${new URL(url).host} ${res.statusCode}`);
+ }
+ const chunks = [];
+ let len = 0;
+ await new Promise((resolve, reject) => {
+ res.on('data', (c) => {
+ len += c.length;
+ if (len > 4 * 1024 * 1024) { res.destroy(); resolve(); return; }
+ chunks.push(c);
+ });
+ res.on('end', resolve);
+ res.on('error', reject);
+ });
+ return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+}
+
+/**
+ * 真下载一小段字节来测速度。
+ * @returns {Promise<{url:string, ok:boolean, speed:number, got:number, ms:number, error?:string}>}
+ */
+function measure(url, { bytes = SAMPLE_BYTES, timeoutMs = 9000 } = {}) {
+ return new Promise((resolve) => {
+ const t0 = Date.now();
+ let firstAt = 0;
+ let got = 0;
+ let settled = false;
+ let req = null;
+ const done = (ok, error) => {
+ if (settled) return;
+ settled = true;
+ try { req?.destroy(); } catch (_) { /* ignore */ }
+ const now = Date.now();
+ // 吞吐只算「开始收到字节之后」的时间:TLS 握手 + DNS 那几百毫秒是固定开销,
+ // 对 1.4GB 的包几乎不影响总耗时,混进速度里会把判断带偏。
+ const span = Math.max(1, now - (firstAt || t0));
+ resolve({
+ url,
+ ok: ok && got > 0,
+ got,
+ ms: now - t0,
+ ttfb: firstAt ? firstAt - t0 : 0,
+ speed: ok && got > 0 ? (got / span) * 1000 : 0,
+ error,
+ });
+ };
+ const timer = setTimeout(() => done(got > 0), timeoutMs);
+ if (timer.unref) timer.unref();
+
+ openUrl(url, {
+ timeout: timeoutMs,
+ headers: { Range: `bytes=0-${bytes - 1}` },
+ }).then((res) => {
+ req = res;
+ if (res.statusCode >= 400) {
+ res.resume();
+ clearTimeout(timer);
+ done(false, `HTTP ${res.statusCode}`);
+ return;
+ }
+ res.on('data', (c) => {
+ if (!firstAt) firstAt = Date.now();
+ got += c.length;
+ if (got >= bytes) { clearTimeout(timer); done(true); }
+ });
+ // 资产本身比样本还小:读到 EOF 也算成功
+ res.on('end', () => { clearTimeout(timer); done(got > 0); });
+ res.on('error', (e) => { clearTimeout(timer); done(false, e.message); });
+ }).catch((e) => { clearTimeout(timer); done(false, e.message); });
+ });
+}
+
+/** 把 GitHub 资产地址套上镜像前缀 */
+function withMirror(url, prefix) {
+ if (!prefix || !/^https?:\/\//i.test(prefix)) return '';
+ const p = prefix.endsWith('/') ? prefix : `${prefix}/`;
+ return `${p}${url}`;
+}
+
+/** mirrors 列表:用户自定义优先,其次内置(autoMirror 关掉就只用自定义的) */
+function mirrorList(settings) {
+ const r = (settings && settings.runtime) || {};
+ const custom = String(r.mirrorPrefix || process.env.APKSTART_MIRROR || '').trim();
+ if (custom) return [custom];
+ if (r.autoMirror === false) return [];
+ return KNOWN_MIRRORS.slice();
+}
+
+class Sources {
+ constructor(settingsFn) {
+ this.settings = typeof settingsFn === 'function' ? settingsFn : () => ({});
+ this._rankCache = new Map(); // url -> {at, speed, ok}
+ this._rankTtl = 30 * 60 * 1000;
+ }
+
+ /** 各源的最新 release(并发,任何一个失败都不影响另一个) */
+ async fetchReleases() {
+ const prefs = String((this.settings().runtime || {}).sourcePreference || 'auto');
+ const ids = prefs === 'github' || prefs === 'gitee' ? [prefs] : ['github', 'gitee'];
+ const jobs = ids.map(async (id) => {
+ const s = SOURCES[id];
+ try {
+ const rel = await getJson(`${s.api}/releases/latest`, 9000);
+ return { source: id, name: s.name, web: s.web, rel };
+ } catch (e) {
+ // Gitee 没有正式 release、或 GitHub 被墙,都退回列表取第一条
+ try {
+ const list = await getJson(`${s.api}/releases?per_page=10`, 9000);
+ const first = (Array.isArray(list) ? list : []).find((r) => r && !r.draft);
+ if (first) return { source: id, name: s.name, web: s.web, rel: first };
+ } catch (_) { /* 这个源彻底不可用 */ }
+ return { source: id, name: s.name, web: s.web, error: e.message };
+ }
+ });
+ return Promise.all(jobs);
+ }
+
+ /**
+ * 合并两边的最新版本:版本号更高的胜出,但**资产列表取并集**,
+ * 这样即使 Gitee 只放了元数据、资产在 GitHub,也能两条路都试。
+ */
+ async latest() {
+ const all = await this.fetchReleases();
+ const ok = all.filter((x) => x && x.rel);
+ if (!ok.length) {
+ const why = all.map((x) => `${x.name || x.source}: ${x.error || '无数据'}`).join(';');
+ throw new Error(`连不上更新服务器(${why})`);
+ }
+ const cmp = require('./updater').cmpVer;
+ ok.sort((a, b) => cmp(b.rel.tag_name || b.rel.name, a.rel.tag_name || a.rel.name));
+ const top = ok[0];
+ const tag = String(top.rel.tag_name || top.rel.name || '');
+ const version = tag.replace(/^v/i, '');
+
+ // 只有同版本的资产才算数(不同源的旧版本资产不能拿来装)
+ const assets = [];
+ const seen = new Set();
+ for (const item of ok) {
+ const t = String(item.rel.tag_name || item.rel.name || '').replace(/^v/i, '');
+ if (t !== version) continue;
+ for (const a of (item.rel.assets || [])) {
+ const key = String(a.name || '');
+ if (!key || seen.has(key)) {
+ // 同名资产保留第一个(按源顺序:先 GitHub 后 Gitee,或反之)
+ continue;
+ }
+ seen.add(key);
+ assets.push({
+ name: key,
+ size: Number(a.size) || 0,
+ url: a.browser_download_url || a.url || '',
+ source: item.source,
+ });
+ }
+ }
+
+ return {
+ version,
+ tag,
+ name: top.rel.name || tag,
+ notes: top.rel.body || '',
+ htmlUrl: top.rel.html_url || top.web,
+ publishedAt: top.rel.published_at || top.rel.created_at || '',
+ assets,
+ sources: ok.map((x) => ({ source: x.source, name: x.name, tag: x.rel.tag_name || x.rel.name || '' })),
+ unreachable: all.filter((x) => x && x.error).map((x) => ({ source: x.source, name: x.name, error: x.error })),
+ bySource: top.source,
+ };
+ }
+
+ /** 某个资产在所有源 + 镜像下的候选地址(去重、保序:源站优先,其次镜像) */
+ candidates(assetOrUrl) {
+ const url = typeof assetOrUrl === 'string' ? assetOrUrl : assetOrUrl.url;
+ const out = [];
+ if (url) out.push(url);
+ for (const m of mirrorList(this.settings())) {
+ const u = withMirror(url, m);
+ if (u && !out.includes(u)) out.push(u);
+ }
+ return out;
+ }
+
+ /**
+ * 按实测速度排序候选地址。测速结果缓存 30 分钟;
+ * 全部测速失败就退回原始顺序(保证「最坏情况还是能下」)。
+ */
+ async rank(urls, { onProgress } = {}) {
+ const list = (urls || []).filter(Boolean);
+ if (list.length <= 1) return list;
+ const now = Date.now();
+ const need = [];
+ for (const u of list) {
+ const c = this._rankCache.get(u);
+ if (!c || now - c.at > this._rankTtl) need.push(u);
+ }
+ if (need.length) {
+ onProgress?.({ stage: 'probe', message: `正在测速 ${need.length} 个下载源…` });
+ // 顺序测而不是并发测:并发会互相抢带宽,测出来的名次变成「谁抢得凶」,
+ // 而不是「谁真的快」。每个源 256KB,正常也就一秒左右。
+ for (const u of need) {
+ // eslint-disable-next-line no-await-in-loop
+ const r = await measure(u);
+ this._rankCache.set(u, { at: Date.now(), ok: r.ok, speed: r.speed });
+ }
+ }
+ const score = (u) => {
+ const c = this._rankCache.get(u);
+ return c && c.ok ? c.speed : -1;
+ };
+ const sorted = list.slice().sort((a, b) => score(b) - score(a));
+ const best = sorted[0];
+ const s = score(best);
+ if (s > 0) {
+ onProgress?.({
+ stage: 'probe',
+ message: `已选最快的源:${new URL(best).host}(约 ${(s / 1048576).toFixed(2)} MB/s)`,
+ });
+ }
+ return sorted;
+ }
+
+ /** 测速缓存清空(用户改了镜像前缀 / 换了网络后调用) */
+ reset() {
+ this._rankCache.clear();
+ }
+}
+
+module.exports = { Sources, SOURCES, measure, KNOWN_MIRRORS, withMirror, mirrorList };
diff --git a/src/core/store.js b/src/core/store.js
index 45d4722..fdc4977 100644
--- a/src/core/store.js
+++ b/src/core/store.js
@@ -80,6 +80,18 @@ const DEFAULT_SETTINGS = {
// 拿不到时自动退回 dl.google.com 分组件下载。可在这里换成自建镜像地址。
preferGithubRuntime: true,
runtimePackUrl: '',
+ // GitHub 加速镜像前缀(可选)。国内直连 GitHub Releases 经常只有几十 KB/s,
+ // 填成 https://ghfast.top/ 之类的镜像前缀即可把 downloads 请求转过去。
+ // 留空 = 直连(也会先用 8 线程分块试,能跑满带宽)。
+ mirrorPrefix: '',
+ // 下载并发数:分块下载的连接数。默认 8,弱网/被限速时可调到 16。
+ downloadConnections: 8,
+ // 更新/下载的源选择。auto = 同时问 GitHub 与 Gitee、并对每个下载地址实测
+ // 128KB 速度,谁快用谁;也可以强制只走某一边(企业网络只放行一个域名时有用)。
+ sourcePreference: 'auto',
+ // 自动尝试公共 GitHub 加速镜像(ghfast / gh-proxy)。关掉后只用直连 + 自定义前缀。
+ // 这两个是第三方服务,只是转发公开的 release 文件,不涉及账号信息。
+ autoMirror: true,
},
sharedDir: path.join(os.homedir(), 'ApkStartShared'),
deviceSharedDir: '/sdcard/ApkStartShared',
diff --git a/src/core/updater.js b/src/core/updater.js
index 2f30919..926d3dc 100644
--- a/src/core/updater.js
+++ b/src/core/updater.js
@@ -16,73 +16,14 @@
*/
const fs = require('fs');
const path = require('path');
-const https = require('https');
const { spawn } = require('child_process');
-const { download } = require('./download');
+const { downloadAnyParallel } = require('./download');
const { ZipFile } = require('./zip');
+const { cmpVer } = require('./version');
+const { Sources } = require('./sources');
const OWNER = 'RoutineMiku';
const REPO = 'apkstart';
-const API = `https://api.github.com/repos/${OWNER}/${REPO}`;
-
-/** v0.3.2 / 0.3.2-preview 归一化成可比较的数字数组 */
-function parseVer(v) {
- return String(v || '')
- .replace(/^v/i, '')
- .split(/[.+-]/)
- .map((x) => (/^\d+$/.test(x) ? Number(x) : x))
- .filter((x) => x !== '');
-}
-
-function cmpVer(a, b) {
- const A = parseVer(a);
- const B = parseVer(b);
- const n = Math.max(A.length, B.length);
- for (let i = 0; i < n; i += 1) {
- const x = A[i];
- const y = B[i];
- if (x === undefined) return -1;
- if (y === undefined) return 1;
- if (typeof x === 'number' && typeof y === 'number') {
- if (x !== y) return x < y ? -1 : 1;
- } else {
- const sx = String(x);
- const sy = String(y);
- if (sx !== sy) return sx < sy ? -1 : 1;
- }
- }
- return 0;
-}
-
-function httpJson(url, timeout = 12000, redirect = 0) {
- return new Promise((resolve, reject) => {
- const req = https.get(url, {
- headers: {
- 'User-Agent': 'ApkStart-Updater',
- Accept: 'application/vnd.github+json',
- },
- timeout,
- }, (res) => {
- if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location && redirect < 3) {
- res.resume();
- httpJson(res.headers.location, timeout, redirect + 1).then(resolve, reject);
- return;
- }
- let d = '';
- res.setEncoding('utf8');
- res.on('data', (c) => { d += c; if (d.length > 4 * 1024 * 1024) req.destroy(); });
- res.on('end', () => {
- if (res.statusCode >= 200 && res.statusCode < 300) {
- try { resolve(JSON.parse(d)); } catch (e) { reject(new Error('GitHub 返回的不是 JSON')); }
- } else {
- reject(new Error(`GitHub ${res.statusCode}`));
- }
- });
- });
- req.on('timeout', () => req.destroy(new Error('连接 GitHub 超时')));
- req.on('error', reject);
- });
-}
/** PowerShell 单引号字符串:内部的 ' 要写成 '' */
function psq(s) {
@@ -101,6 +42,9 @@ class Updater {
this.isPackaged = !!o.isPackaged;
this.dataDir = o.dataDir;
this.onProgress = o.onProgress || (() => {});
+ this.settings = typeof o.settings === 'function' ? o.settings : () => (o.settings || {});
+ // settings() 给 sources 用:决定「走 GitHub 还是 Gitee」「有没有镜像前缀」
+ this.sources = new Sources(this.settings);
this.latest = null;
this._last = null;
}
@@ -118,20 +62,13 @@ class Updater {
return path.join(this.dataDir, 'update');
}
- /** 拉取最新 release(含预发布兜底),并挑出与当前形态匹配的资产 */
+ /**
+ * 检查更新:GitHub / Gitee 并发问,取版本号更高的,资产取并集。
+ * 具体下载地址在 prepare() 里再做一次真实测速排序。
+ */
async check() {
- const rel = await httpJson(`${API}/releases/latest`).catch(async (e) => {
- // 仓库只有预发布 / 尚未打正式 release 时 /latest 会 404
- if (!/404/.test(e.message)) throw e;
- const list = await httpJson(`${API}/releases?per_page=10`);
- const first = (Array.isArray(list) ? list : []).find((r) => r && !r.draft);
- if (!first) throw new Error('GitHub 上还没有任何发布版本');
- return first;
- });
-
- const tag = String(rel.tag_name || rel.name || '');
- const assets = Array.isArray(rel.assets) ? rel.assets : [];
- const pick = (re) => assets.find((a) => re.test(String(a.name || '')));
+ const merged = await this.sources.latest();
+ const pick = (re) => merged.assets.find((a) => re.test(String(a.name || '')));
const wantSetup = this.flavor === 'setup';
const asset = wantSetup
@@ -139,16 +76,19 @@ class Updater {
: (pick(/portable.*\.zip$/i) || pick(/win64.*\.zip$/i) || pick(/\.zip$/i));
this.latest = {
- version: tag.replace(/^v/i, ''),
- tag,
- name: rel.name || tag,
- notes: rel.body || '',
- htmlUrl: rel.html_url || `https://github.com/${OWNER}/${REPO}/releases`,
- publishedAt: rel.published_at || '',
- asset: asset ? { name: asset.name, size: asset.size, url: asset.browser_download_url } : null,
- assets: assets.map((a) => ({ name: a.name, size: a.size, url: a.browser_download_url })),
+ version: merged.version,
+ tag: merged.tag,
+ name: merged.name,
+ notes: merged.notes,
+ htmlUrl: merged.htmlUrl,
+ publishedAt: merged.publishedAt,
+ asset: asset ? { name: asset.name, size: asset.size, url: asset.url, source: asset.source } : null,
+ assets: merged.assets,
+ // 两个源各自的最新版本 / 谁不可达,界面上可以如实显示「这次走的哪个源」
+ sources: merged.sources,
+ unreachable: merged.unreachable,
flavor: this.flavor,
- hasUpdate: cmpVer(tag, this.current) > 0,
+ hasUpdate: cmpVer(merged.tag, this.current) > 0,
current: this.current,
canAutoApply: !!asset,
};
@@ -169,13 +109,22 @@ class Updater {
const total = it.asset.size || 0;
this.onProgress({ stage: 'download', percent: 1, message: `正在下载 ${it.asset.name}…` });
- await download(it.asset.url, file, {
+ // 候选地址 = 源站 + 镜像前缀;先各下 128KB 实测速度,再拿最快的那个分块下载。
+ // 这是「GitHub 直连几十 KB/s、镜像能跑几 MB/s」时唯一靠谱的选路方式:
+ // 按域名猜没用,同一天不同时段差别很大。
+ const conns = Math.max(1, Math.min(16, Number((this.settings().runtime || {}).downloadConnections) || 8));
+ const cands = this.sources.candidates(it.asset);
+ const ranked = await this.sources.rank(cands, { onProgress: (p) => this.onProgress(p) }).catch(() => cands);
+ await downloadAnyParallel(ranked, file, {
+ connections: conns,
onProgress: (pr) => {
const pct = pr.percent != null ? pr.percent : (total ? Math.round((pr.got / total) * 100) : 0);
+ const mb = `${(pr.got / 1048576).toFixed(1)} MB${total ? ` / ${(total / 1048576).toFixed(1)} MB` : ''}`;
+ const sp = Number(pr.speed) > 0 ? ` · ${(pr.speed / 1048576).toFixed(2)} MB/s` : '';
this.onProgress({
stage: 'download',
percent: Math.max(1, Math.min(99, pct)),
- message: `下载中 ${(pr.got / 1048576).toFixed(1)} MB${total ? ` / ${(total / 1048576).toFixed(1)} MB` : ''}`,
+ message: `下载中 ${mb}${sp}`,
speed: pr.speed,
});
},
diff --git a/src/core/version.js b/src/core/version.js
new file mode 100644
index 0000000..a939bfa
--- /dev/null
+++ b/src/core/version.js
@@ -0,0 +1,36 @@
+'use strict';
+/**
+ * 版本号比较。独立成模块,避免 updater ↔ sources 互相 require 形成循环依赖。
+ */
+
+/** v0.3.2 / 0.3.2-preview / 1.0.0+build 归一化成可比较的数组 */
+function parseVer(v) {
+ return String(v || '')
+ .replace(/^v/i, '')
+ .split(/[.+-]/)
+ .map((x) => (/^\d+$/.test(x) ? Number(x) : x))
+ .filter((x) => x !== '');
+}
+
+/** a>b 返回 1,a<b 返回 -1,相等 0 */
+function cmpVer(a, b) {
+ const A = parseVer(a);
+ const B = parseVer(b);
+ const n = Math.max(A.length, B.length);
+ for (let i = 0; i < n; i += 1) {
+ const x = A[i];
+ const y = B[i];
+ if (x === undefined) return -1;
+ if (y === undefined) return 1;
+ if (typeof x === 'number' && typeof y === 'number') {
+ if (x !== y) return x < y ? -1 : 1;
+ } else {
+ const sx = String(x);
+ const sy = String(y);
+ if (sx !== sy) return sx < sy ? -1 : 1;
+ }
+ }
+ return 0;
+}
+
+module.exports = { parseVer, cmpVer };
diff --git a/src/main.js b/src/main.js
index 0b2ccef..2840d11 100644
--- a/src/main.js
+++ b/src/main.js
@@ -520,8 +520,21 @@ function buildTray() {
// ---------------- 核心动作 ----------------
+let installBusy = null; // 正在安装的文件路径:双击 APK 连点会走 second-instance,不能并发装
+let lastInstallErr = { msg: '', at: 0 };
+
async function runInstall(filePath) {
showWindow();
+ // 同一个包正在装(用户连点了几次图标 / 拖了好几次)→ 只提示一次,别重复跑一遍安装
+ if (installBusy) {
+ if (installBusy === filePath) {
+ send('toast', { type: 'info', message: '这个 APK 正在安装中,请稍等…' });
+ return { ok: false, error: '正在安装中' };
+ }
+ send('toast', { type: 'info', message: '已有安装任务在进行,请等它装完。' });
+ return { ok: false, error: '已有安装任务在进行' };
+ }
+ installBusy = filePath;
send('install:start', { file: filePath });
try {
const result = await installer.install(filePath, (p) => send('install:progress', p));
@@ -533,8 +546,18 @@ async function runInstall(filePath) {
} catch (e) {
send('install:error', { message: e.message });
if (e.needsSetup) send('ui:navigate', 'setup');
- notify('安装失败', e.message.slice(0, 120));
+ // 同一条错误 8 秒内只弹一次系统通知:连续重试时不会在右下角刷屏
+ const now = Date.now();
+ if (e.message !== lastInstallErr.msg || now - lastInstallErr.at > 8000) {
+ lastInstallErr = { msg: e.message, at: now };
+ // 窗口在前台时用户已经看到界面里的提示,不必再弹系统通知
+ if (!mainWindow || !mainWindow.isVisible() || mainWindow.isMinimized()) {
+ notify('安装失败', e.message.slice(0, 120));
+ }
+ }
throw e;
+ } finally {
+ installBusy = null;
}
}
@@ -781,6 +804,15 @@ function registerIpc() {
)) {
refreshPointerMapping();
}
+ // 换了更新源 / 镜像前缀:之前那套「谁最快」的结论不再成立,清掉测速缓存
+ if (patch && patch.runtime && (
+ 'sourcePreference' in patch.runtime || 'mirrorPrefix' in patch.runtime || 'autoMirror' in patch.runtime
+ )) {
+ try {
+ updater?.sources?.reset();
+ runtime?.provisioner?.sources?.reset();
+ } catch (_) { /* ignore */ }
+ }
return next;
});
@@ -1461,6 +1493,8 @@ if (!gotLock) {
exePath: process.execPath,
isPackaged: app.isPackaged,
dataDir: store.DATA_DIR,
+ // 让更新器能读到「只走 GitHub / 只走 Gitee / 自动选快」和镜像前缀设置
+ settings: () => store.getSettings(),
onProgress: (p) => send('update:progress', p),
});
diff --git a/src/ui/app.js b/src/ui/app.js
index fe7e285..8371316 100644
--- a/src/ui/app.js
+++ b/src/ui/app.js
@@ -44,10 +44,36 @@ function relTime(ts) {
/**
* 迷你 toast
+ *
+ * 同一类消息做去重 + 数量上限:
+ * 安装失败时里面有「运行时启动日志」在持续推送,以前每条都新建一个 toast,
+ * 于是屏幕上会不停叠加同一条错误,看起来像「失败信息一直循环」。
*/
+let _toastSeq = 0;
function toast({ title, body = '', type = 'info', progress = null, sticky = false, spinner = false }) {
+ const wrap = $('toastWrap');
+ // ① 去重:同样的标题 + 正文(4 秒内)只刷新那一条,不叠加
+ const key = `${title}|${body}`;
+ const dup = [...wrap.children].find((n) => n.dataset.key === key && Date.now() - Number(n.dataset.at || 0) < 4000);
+ if (dup) {
+ dup.dataset.at = String(Date.now());
+ return {
+ el: dup,
+ dismiss: () => dup.remove(),
+ update: ({ title: t2, body: b2 } = {}) => {
+ if (t2 !== undefined) dup.querySelector('.t-title-text').textContent = t2;
+ if (b2 !== undefined) dup.querySelector('.t-body').textContent = b2;
+ },
+ };
+ }
+ // ② 上限:同时最多 4 条,超出先挤掉最旧的
+ while (wrap.children.length >= 4) wrap.firstElementChild.remove();
+
const el = document.createElement('div');
el.className = `toast ${type === 'error' ? 'error' : ''}`;
+ el.dataset.key = key;
+ el.dataset.at = String(Date.now());
+ el.dataset.seq = String(++_toastSeq);
el.innerHTML = `
<div class="t-title">
${spinner ? '<span class="spinner"></span>' : ''}
@@ -421,6 +447,20 @@ async function markInstalled() {
/* ---------------- 安装 ---------------- */
+async /** 把安装失败翻译成「下一步该做什么」,只对最常见的几种做提示,其它原样显示 */
+function friendlyInstallErrorText(msg) {
+ const s = String(msg || '未知错误');
+ if (/INSUFFICIENT_STORAGE|not enough space|空间不足|ENOSPC/i.test(s)) {
+ return `${s}\n安卓数据分区不够用:设置 → 性能与资源占用 → 安卓数据分区调大后点「立即扩容」。`;
+ }
+ if (/NO_MATCHING_ABIS/i.test(s)) return `${s}\n这个包只有 ARM 库,正在自动切换兼容镜像后重试。`;
+ if (/INSTALL_FAILED_ALREADY_EXISTS|signatures do not match/i.test(s)) {
+ return `${s}\n同包名但签名不同(常见于从别的渠道装过)。在应用卡片右键「卸载」后再装。`;
+ }
+ if (/INSTALL_FAILED_VERSION_DOWNGRADE/i.test(s)) return `${s}\n已装版本更高,先在右键菜单里卸载再装。`;
+ return s;
+}
+
async function installFiles(paths) {
if (!paths || !paths.length) return;
if (state.installing) {
@@ -432,29 +472,32 @@ async function installFiles(paths) {
let failed = 0;
for (const p of paths) {
+ const name = p.split(/[\\/]/).pop();
+ const t = toast({ title: `正在安装 ${name}`, body: '解析 APK…', progress: 8, sticky: true, spinner: true });
+ let off = () => {};
try {
- const name = p.split(/[\\/]/).pop();
- const t = toast({ title: `正在安装 ${name}`, body: '解析 APK…', progress: 8, sticky: true, spinner: true });
- const off = api.on('install:progress', (pr) => {
+ off = api.on('install:progress', (pr) => {
const base = { parse: 12, 'parse-done': 24, runtime: 38, install: 62, shortcut: 88, done: 100 }[pr.stage] || 50;
const pct = pr.percent != null ? Math.min(60, Math.round((pr.percent / 100) * 60)) : base;
t.update({ title: pr.meta ? `正在安装 ${pr.meta.label}` : `正在安装 ${name}`, body: pr.message, progress: pct });
});
- try {
- const r = await api.installApk(p);
- t.update({ title: `${r.app.label} 已安装`, body: r.app.shortcutPath ? '桌面快捷方式已创建,双击即可直接打开。' : '可在应用卡片右键创建桌面快捷方式。', progress: 100, type: 'ok' });
- t.el.querySelector('.spinner')?.remove();
- setTimeout(t.dismiss, 3600);
- if (r.warnings && r.warnings.length) {
- toast({ title: `${r.app.label} 兼容性提示`, body: r.warnings.join(' '), type: 'error', sticky: false });
- }
- ok++;
- } finally {
- off();
+ const r = await api.installApk(p);
+ t.update({ title: `${r.app.label} 已安装`, body: r.app.shortcutPath ? '桌面快捷方式已创建,双击即可直接打开。' : '可在应用卡片右键创建桌面快捷方式。', progress: 100, type: 'ok' });
+ t.el.querySelector('.spinner')?.remove();
+ setTimeout(t.dismiss, 3600);
+ if (r.warnings && r.warnings.length) {
+ toast({ title: `${r.app.label} 兼容性提示`, body: r.warnings.join(' '), type: 'error', sticky: false });
}
+ ok++;
} catch (e) {
failed++;
- toast({ title: '安装失败', body: e.message, type: 'error' });
+ // 先把那条「正在安装…」的 sticky 提示收掉,否则它会一直转圈、还继续被
+ // 运行时日志刷新 —— 用户看到的就是「失败信息一直在循环」。
+ try { off(); } catch (_) { /* ignore */ }
+ t.dismiss();
+ toast({ title: `安装失败:${name}`, body: friendlyInstallErrorText(e.message), type: 'error' });
+ } finally {
+ try { off(); } catch (_) { /* ignore */ }
}
}
@@ -647,6 +690,10 @@ function fillSettings(s) {
$('setMemory').value = s.engine.memoryMB;
$('setCores').value = s.engine.cores;
$('setIdle').value = s.engine.idleShutdownMinutes;
+ if ($('setSourcePref')) $('setSourcePref').value = (s.runtime && s.runtime.sourcePreference) || 'auto';
+ if ($('setAutoMirror')) $('setAutoMirror').checked = (s.runtime && s.runtime.autoMirror) !== false;
+ if ($('setMirrorPrefix')) $('setMirrorPrefix').value = (s.runtime && s.runtime.mirrorPrefix) || '';
+ if ($('setConnections')) $('setConnections').value = Number((s.runtime && s.runtime.downloadConnections) || 8);
$('setAudio').checked = s.engine.audio !== false;
$('setLiteMode').checked = s.engine.liteMode !== false;
$('setPrewarm').checked = s.engine.prewarm !== false;
@@ -746,7 +793,11 @@ function renderUpdate(info) {
return;
}
if (info.hasUpdate) {
- st.textContent = `发现新版本 ${info.tag}`;
+ // 如实说明这次是哪个源给出的版本、另一个源为什么没参与 ——
+ // 用户排查「为什么检查更新很慢」时,这一行比任何日志都直接。
+ const src = (info.sources || []).map((x) => `${x.name} ${x.tag || ''}`.trim()).join(' / ');
+ const bad = (info.unreachable || []).map((x) => x.name).join('、');
+ st.textContent = `发现新版本 ${info.tag}${src ? `(${src})` : ''}${bad ? `;${bad} 不可达` : ''}`;
showUpdateBtn(true);
btn.textContent = info.asset ? '立即更新' : '打开下载页';
btn.dataset.mode = info.asset ? 'auto' : 'manual';
@@ -757,7 +808,8 @@ function renderUpdate(info) {
}
if (bar) bar.hidden = true;
} else {
- st.textContent = `已是最新版本(v${info.current})`;
+ const src = (info.sources || []).map((x) => x.name).join(' / ');
+ st.textContent = `已是最新版本(v${info.current})${src ? ` · 经由 ${src}` : ''}`;
showUpdateBtn(false);
if (bar) bar.hidden = true;
}
@@ -915,6 +967,22 @@ function bindSettings() {
});
}
$('setIdle').addEventListener('change', (e) => save({ engine: { idleShutdownMinutes: Number(e.target.value) || 0 } }));
+ if ($('setSourcePref')) {
+ $('setSourcePref').addEventListener('change', (e) => save({ runtime: { sourcePreference: e.target.value } }));
+ }
+ if ($('setAutoMirror')) {
+ $('setAutoMirror').addEventListener('change', (e) => save({ runtime: { autoMirror: e.target.checked } }));
+ }
+ if ($('setMirrorPrefix')) {
+ $('setMirrorPrefix').addEventListener('change', (e) => save({ runtime: { mirrorPrefix: e.target.value.trim() } }));
+ }
+ if ($('setConnections')) {
+ $('setConnections').addEventListener('change', (e) => {
+ const n = Math.max(1, Math.min(16, Number(e.target.value) || 8));
+ e.target.value = n;
+ save({ runtime: { downloadConnections: n } });
+ });
+ }
$('setAudio').addEventListener('change', (e) => save({ engine: { audio: e.target.checked } }));
$('setLiteMode').addEventListener('change', (e) => save({ engine: { liteMode: e.target.checked } }));
$('setPrewarm').addEventListener('change', (e) => save({ engine: { prewarm: e.target.checked } }));
diff --git a/src/ui/index.html b/src/ui/index.html
index d2166ab..a5a4427 100644
--- a/src/ui/index.html
+++ b/src/ui/index.html
@@ -363,6 +363,32 @@
<label>空闲回收(分钟,0 = 不回收)</label>
<input id="setIdle" type="number" min="0" step="1" />
</div>
+ <div class="field">
+ <label>更新与下载源</label>
+ <select id="setSourcePref">
+ <option value="auto">自动选择较快的源(推荐)</option>
+ <option value="gitee">只用 Gitee(国内通常最快)</option>
+ <option value="github">只用 GitHub</option>
+ </select>
+ <span class="sub">「自动」会同时问 GitHub 与 Gitee 的最新版本,把每个下载地址都真下 256KB 测一次速度,再从最快的那个地址下载;其中一个源不通不影响更新。</span>
+ </div>
+ <div class="field switch-field">
+ <div>
+ <label>自动尝试公共加速镜像</label>
+ <span class="sub">GitHub 直连太慢时,额外测速 ghfast.top / gh-proxy.com 这两个公开转发服务(只转发公开的发布文件,不涉及账号)。关掉后只用直连和你自己填的前缀。</span>
+ </div>
+ <input type="checkbox" id="setAutoMirror" class="switch" />
+ </div>
+ <div class="field">
+ <label>下载镜像前缀(可选,加速 GitHub)</label>
+ <input id="setMirrorPrefix" type="text" placeholder="例如 https://ghfast.top/" />
+ <span class="sub">填了就只用你填的前缀,不再尝试上面那两个公共镜像;留空则由「自动」逻辑决定。下载器会把它拼在真实地址前面。</span>
+ </div>
+ <div class="field">
+ <label>下载线程数(1–16,默认 8)</label>
+ <input id="setConnections" type="number" min="1" max="16" step="1" />
+ <span class="sub">大文件按块并行下载。默认 8 线程已经能跑满大多数家宽;网络稳定时可以试 16。</span>
+ </div>
<div class="field switch-field">
<div>
<label>通用兼容镜像(自动管理)</label>
diff --git a/test/auto-test.js b/test/auto-test.js
index 9d294b1..4509c00 100644
--- a/test/auto-test.js
+++ b/test/auto-test.js
@@ -830,6 +830,49 @@ const { AdbClient, friendlyInstallError, friendlyLaunchError } = require('../src
assert(/portable.*\.zip$/i.test('ApkStart-v0.3.2-win64-portable.zip'), '便携版资产名匹配');
});
+ await test('双源:候选地址含镜像前缀,自定义前缀优先于公共镜像', () => {
+ const { Sources, withMirror } = require('../src/core/sources');
+ const url = 'https://github.com/o/r/releases/download/v1/a.zip';
+ const auto = new Sources(() => ({ runtime: { autoMirror: true } }));
+ const list = auto.candidates(url);
+ assert(list[0] === url, '源站必须排第一(测速排序前保持原序)');
+ assert(list.length >= 2 && list.some((u) => u.includes('ghfast.top')), '自动镜像应被列入候选');
+
+ const custom = new Sources(() => ({ runtime: { autoMirror: true, mirrorPrefix: 'https://my.mirror/' } }));
+ const c2 = custom.candidates(url);
+ assert(c2.length === 2 && c2[1] === `https://my.mirror/${url}`, `自定义前缀应唯一生效,实际 ${JSON.stringify(c2)}`);
+
+ const off = new Sources(() => ({ runtime: { autoMirror: false } }));
+ assert(off.candidates(url).length === 1, '关掉自动镜像后只剩直连');
+ assert(withMirror(url, 'https://x/') === `https://x/${url}`, '前缀缺尾斜杠要自动补');
+ });
+
+ await test('双源:测速结果按速度排序,全部失败时保持原序不丢可用地址', async () => {
+ const { Sources } = require('../src/core/sources');
+ const s = new Sources(() => ({ runtime: { autoMirror: false } }));
+ // 直接注入测速缓存,避免测试依赖外网
+ s._rankCache.set('https://slow/', { at: Date.now(), ok: true, speed: 1000 });
+ s._rankCache.set('https://fast/', { at: Date.now(), ok: true, speed: 9000 });
+ s._rankCache.set('https://dead/', { at: Date.now(), ok: false, speed: 0 });
+ const ranked = await s.rank(['https://slow/', 'https://dead/', 'https://fast/']);
+ assert(ranked[0] === 'https://fast/', `最快的应排第一,实际 ${ranked[0]}`);
+ assert(ranked[2] === 'https://dead/', '失败的地址排最后但仍保留(还有一次机会)');
+ s.reset();
+ assert(s._rankCache.size === 0, 'reset 要清空测速缓存(换源/换网后必须重测)');
+ });
+
+ await test('双源:合并版本时只认同版本的资产,不拿旧包冒充新包', async () => {
+ const { Sources } = require('../src/core/sources');
+ const s = new Sources(() => ({ runtime: {} }));
+ s.fetchReleases = async () => [
+ { source: 'github', name: 'GitHub', web: 'g', rel: { tag_name: 'v0.4.0', assets: [{ name: 'A-portable.zip', size: 10, browser_download_url: 'gh://a' }] } },
+ { source: 'gitee', name: 'Gitee', web: 'e', rel: { tag_name: 'v0.3.9', assets: [{ name: 'A-portable.zip', size: 10, browser_download_url: 'ge://a' }, { name: 'B.txt', size: 1, browser_download_url: 'ge://b' }] } },
+ ];
+ const m = await s.latest();
+ assert(m.version === '0.4.0', `应取更高版本,实际 ${m.version}`);
+ assert(m.assets.length === 1 && m.assets[0].url === 'gh://a', '旧版本同名资产不能覆盖新版本');
+ });
+
console.log('\n[资源策略 / 磁盘分配 / 日志上限]');
await test('资源策略一处切换,自动翻译成 vCPU/优先级/分辨率', () => {