682 lines
31 KiB
TypeScript
682 lines
31 KiB
TypeScript
import { allBlockTexturePaths, BLOCK_TEXTURE_TRIMS, collectBlockTexturePaths } from "./BlockTexturePaths";
|
||
|
||
declare const wx: any;
|
||
declare const tt: any;
|
||
|
||
type ImageSource = "内存复用" | "本地缓存" | "临时缓存" | "远程下载";
|
||
|
||
interface BlockWindowOptions {
|
||
onRemoteRequired?: () => void;
|
||
currentLevel?: number;
|
||
nextLevel?: number;
|
||
stage?: string;
|
||
}
|
||
|
||
interface BlockCacheCheck {
|
||
cached: number;
|
||
temporary: number;
|
||
missing: number;
|
||
complete: boolean;
|
||
}
|
||
|
||
interface BlockDownloadJob {
|
||
path: string;
|
||
priority: number;
|
||
background: boolean;
|
||
started: boolean;
|
||
resolve: () => void;
|
||
reject: (error: any) => void;
|
||
}
|
||
|
||
/** Block 原始 PNG：版本化磁盘缓存与 SpriteFrame/纹理内存分开管理。 */
|
||
export default class BlockAssetManager {
|
||
static readonly instance = new BlockAssetManager();
|
||
static readonly CACHE_KEY = "block_image_cache_v1";
|
||
private static readonly BACKGROUND_CONCURRENCY = 8;
|
||
// Block 自己调度直存下载：后台最多 8 路，进关可使用总计 10 路。
|
||
private static readonly FOREGROUND_DOWNLOAD_LIMIT = 10;
|
||
private static readonly BACKGROUND_RETRY_MS = 10000;
|
||
|
||
private ready: Promise<void> = null;
|
||
private version: string = null;
|
||
private imageBase = "";
|
||
private paths = allBlockTexturePaths();
|
||
private frames = new Map<string, cc.SpriteFrame>();
|
||
private loading = new Map<string, Promise<void>>();
|
||
private fileDownloads = new Map<string, { promise: Promise<void>, job: BlockDownloadJob }>();
|
||
private downloadQueue: BlockDownloadJob[] = [];
|
||
private activeFileDownloads = 0;
|
||
private activeBackgroundDownloads = 0;
|
||
private reportSource: (path: string, source: ImageSource) => void = null;
|
||
private backgroundDownloads = new Set<string>();
|
||
private windowPaths = new Set<string>();
|
||
private committedPaths = new Set<string>();
|
||
private activePaths = new Set<string>();
|
||
private requestId = 0;
|
||
private foregroundLoads = 0;
|
||
private backgroundRunning = false;
|
||
private backgroundTimer: any = null;
|
||
private backgroundStarted = false;
|
||
|
||
private initialize(): Promise<void> {
|
||
if (!this.ready) {
|
||
this.ready = this.selectVersion().then(() => {
|
||
const previous = this.readCacheState();
|
||
if (this.getFileSystem() && (previous.version !== this.version || previous.baseUrl !== this.imageBase)) {
|
||
this.writeCacheState(this.paths.length, 0, false);
|
||
}
|
||
}).catch(error => {
|
||
this.ready = null;
|
||
throw error;
|
||
});
|
||
}
|
||
return this.ready;
|
||
}
|
||
|
||
/** 一次启动只选择一个版本，切场景/回到前台不更换正在使用的缓存命名空间。 */
|
||
private async selectVersion(): Promise<string> {
|
||
if (this.version !== null) return this.version;
|
||
const config = cc.fx.GameConfig;
|
||
const base = config.BLOCK_IMAGE_BASE_URL;
|
||
const defaultVersion = config.BLOCK_IMAGE_VERSION;
|
||
if (!/^https?:\/\//.test(base) || !this.isVersion(defaultVersion)) {
|
||
throw new Error("Block 图片地址或默认版本配置无效");
|
||
}
|
||
this.imageBase = base.replace(/\/+$/, "") + "/";
|
||
const sdk = typeof wx !== "undefined" && wx && wx.request ? wx
|
||
: typeof tt !== "undefined" && tt && tt.request ? tt : null;
|
||
|
||
const previous = this.readCacheState();
|
||
const fallback = previous.baseUrl === this.imageBase && this.isVersion(previous.version)
|
||
? previous.version : defaultVersion;
|
||
const url = this.imageBase + "version.json?_t=" + Date.now();
|
||
// console.log(`[Block图片][版本检查] 开始，${url}`);
|
||
this.version = await new Promise<string>(resolve => {
|
||
let finished = false;
|
||
let request: any = null;
|
||
const finish = (error: any, version?: string) => {
|
||
if (finished) return;
|
||
finished = true;
|
||
clearTimeout(timer);
|
||
// if (error) cc.warn("Block 版本检查失败，本次使用已知版本:", fallback, error);
|
||
// if (error) console.log(`[Block图片][版本检查] 失败，回退到版本=${fallback}`, error);
|
||
// else console.log(`[Block图片][版本检查] 成功，版本=${version}`);
|
||
resolve(version || fallback);
|
||
};
|
||
const timer = setTimeout(() => {
|
||
finish(new Error("Block 版本检查超时"));
|
||
if (request && request.abort) request.abort();
|
||
}, 5000);
|
||
const accept = (error: any, data: any) => {
|
||
try {
|
||
if (error) throw error;
|
||
if (typeof data === "string") data = JSON.parse(data);
|
||
if (!data || !this.isVersion(data.version)) throw new Error("Block 版本清单无效");
|
||
finish(null, data.version);
|
||
} catch (error) { finish(error); }
|
||
};
|
||
try {
|
||
// 版本 JSON 不写 Cocos 文件缓存；CDN 也应设置不缓存。
|
||
if (sdk) {
|
||
request = sdk.request({
|
||
url, method: "GET", timeout: 5000, header: { "Cache-Control": "no-cache" },
|
||
success: (response: any) => accept(response.statusCode === 200 ? null
|
||
: new Error("Block 版本 HTTP " + response.statusCode), response.data),
|
||
fail: (error: any) => finish(error)
|
||
});
|
||
} else {
|
||
// 2.4.15 运行时提供此 XHR 接口，项目旧版类型声明未包含。
|
||
request = (cc.assetManager.downloader as any).downloadFile(url,
|
||
{ responseType: "json", timeout: 5000, header: { "Cache-Control": "no-cache" } }, null, accept);
|
||
}
|
||
} catch (error) { finish(error); }
|
||
});
|
||
return this.version;
|
||
}
|
||
|
||
private isVersion(value: any): boolean {
|
||
return typeof value === "string" && value.length <= 32 && /^\d+\.\d+\.\d+$/.test(value);
|
||
}
|
||
|
||
private readCacheState(): any {
|
||
try {
|
||
return JSON.parse(cc.sys.localStorage.getItem(BlockAssetManager.CACHE_KEY)) || {};
|
||
} catch (error) { return {}; }
|
||
}
|
||
|
||
/** 当前场景还在显示时保留它的图片，切场景销毁后再释放旧关独占资源。 */
|
||
async prepareWindow(current: any[], next: any[], options: BlockWindowOptions = {}): Promise<boolean> {
|
||
const currentPaths = collectBlockTexturePaths(current);
|
||
const nextPaths = collectBlockTexturePaths(next);
|
||
const paths = new Set(currentPaths.concat(nextPaths));
|
||
const id = ++this.requestId;
|
||
const stage = options.stage || "进关";
|
||
const currentLabel = "当前关" + (options.currentLevel || "");
|
||
const nextLabel = "下一关" + (options.nextLevel || "");
|
||
// 同时存在多个进关请求时，只通知最新窗口；共享加载失败后的远程重试也走这里。
|
||
this.reportSource = (path, source) => {
|
||
if (id !== this.requestId || !paths.has(path)) return;
|
||
const levels = [currentPaths.indexOf(path) >= 0 ? currentLabel : "",
|
||
nextPaths.indexOf(path) >= 0 ? nextLabel : ""].filter(Boolean).join(" / ");
|
||
// console.log(`[Block图片][${stage}来源] ${levels} ${path}.png -> ${source}，版本=${this.version}`);
|
||
if (source === "远程下载" && options.onRemoteRequired) options.onRemoteRequired();
|
||
};
|
||
this.windowPaths = paths;
|
||
this.foregroundLoads++;
|
||
this.releaseUnused();
|
||
try {
|
||
await this.initialize();
|
||
if (id !== this.requestId) return false;
|
||
this.ensureUserCacheFolder();
|
||
// console.log(`[Block图片][${stage}检查] ${currentLabel} / ${nextLabel}，版本=${this.version}，共${paths.size}张`);
|
||
const names = Array.from(paths);
|
||
// 限制前台并发，后台队列在此期间让出下载机会。
|
||
for (let i = 0; i < names.length; i += 4) {
|
||
if (id !== this.requestId) return false;
|
||
const results = await Promise.all(names.slice(i, i + 4).map(name =>
|
||
this.loadFrame(name).then(() => null, error => error)));
|
||
const error = results.find(result => result != null);
|
||
if (error) throw error;
|
||
}
|
||
if (id !== this.requestId) return false;
|
||
this.committedPaths = paths;
|
||
return true;
|
||
} catch (error) {
|
||
if (id !== this.requestId) return false;
|
||
this.windowPaths = this.committedPaths;
|
||
throw error;
|
||
} finally {
|
||
if (id === this.requestId) this.reportSource = null;
|
||
this.foregroundLoads--;
|
||
this.pumpDownloadQueue();
|
||
this.releaseUnused();
|
||
}
|
||
}
|
||
|
||
activateScene(blocks: any[]): void {
|
||
const paths = collectBlockTexturePaths(blocks);
|
||
paths.forEach(path => this.getFrame(path));
|
||
this.activePaths = new Set(paths);
|
||
this.releaseUnused();
|
||
}
|
||
|
||
releaseScene(): void {
|
||
this.activePaths.clear();
|
||
this.releaseUnused();
|
||
}
|
||
|
||
getFrame(path: string): cc.SpriteFrame {
|
||
const frame = this.frames.get(path);
|
||
if (!frame || !cc.isValid(frame)) throw new Error("方块图片尚未就绪: " + path);
|
||
return frame;
|
||
}
|
||
|
||
/** 调试时可核对是否只有当前关、下一关，以及尚未销毁的旧场景资源。 */
|
||
getLoadedPaths(): string[] {
|
||
return Array.from(this.frames.keys()).sort();
|
||
}
|
||
|
||
private releaseUnused(): void {
|
||
this.frames.forEach((frame, path) => {
|
||
if (this.windowPaths.has(path) || this.committedPaths.has(path) || this.activePaths.has(path)) return;
|
||
this.frames.delete(path);
|
||
// 动态 SpriteFrame 没有导入依赖表，必须显式释放持有的纹理引用。
|
||
const texture = frame.getTexture();
|
||
frame.destroy();
|
||
texture.decRef();
|
||
this.clearImageCaches(path);
|
||
});
|
||
}
|
||
|
||
private loadFrame(path: string): Promise<void> {
|
||
if (this.frames.has(path) || this.loading.has(path)) {
|
||
if (this.reportSource) this.reportSource(path, this.getImageSource(path));
|
||
return this.loading.get(path) || Promise.resolve();
|
||
}
|
||
const promise = this.loadTextureWithRetry(path).then(texture => {
|
||
// 在任何 Sprite 使用前禁用合图，确保独立小图可以独立释放。
|
||
texture.packable = false;
|
||
texture.addRef();
|
||
const trim = BLOCK_TEXTURE_TRIMS[path];
|
||
// 保留原图的裁剪布局；换图时需保持画布尺寸和透明边距兼容。
|
||
const frame = trim && texture.width === trim[6] && texture.height === trim[7]
|
||
? new cc.SpriteFrame(texture, cc.rect(trim[0], trim[1], trim[2], trim[3]), false,
|
||
cc.v2(trim[4], trim[5]), cc.size(trim[6], trim[7]))
|
||
: new cc.SpriteFrame(texture);
|
||
frame.name = path;
|
||
this.frames.set(path, frame);
|
||
this.releaseUnused();
|
||
}).then(() => {
|
||
this.loading.delete(path);
|
||
}, error => {
|
||
this.loading.delete(path);
|
||
throw error;
|
||
});
|
||
this.loading.set(path, promise);
|
||
return promise;
|
||
}
|
||
|
||
private async loadTextureWithRetry(path: string): Promise<cc.Texture2D> {
|
||
const url = this.imageUrl(path);
|
||
const load = async (reload: boolean): Promise<cc.Texture2D> => {
|
||
const source: ImageSource = reload ? "远程下载" : this.getImageSource(path);
|
||
if (this.reportSource) this.reportSource(path, source);
|
||
const remote = source === "远程下载";
|
||
// if (remote) console.log(`[Block图片][远程加载] ${this.backgroundDownloads.has(path) ? "等待后台下载" : "开始"} `
|
||
// + `${path}.png，进关${reload ? "重试" : ""}，${url}`);
|
||
try {
|
||
let loadUrl = source === "本地缓存" ? this.getPersistentFile(path)
|
||
: source === "临时缓存" ? this.getTempFile(path) : url;
|
||
if (remote && this.canUseUserCache()) {
|
||
await this.downloadToUserCache(path, 10);
|
||
loadUrl = this.userFilePath(path);
|
||
}
|
||
const texture = await new Promise<cc.Texture2D>((resolve, reject) => {
|
||
const direct = loadUrl !== url;
|
||
cc.assetManager.loadRemote(loadUrl,
|
||
{
|
||
ext: ".png", priority: 10, cacheEnabled: !direct, reload: !direct && reload,
|
||
__cacheBundleRoot__: direct ? undefined : "Block",
|
||
maxConcurrency: BlockAssetManager.FOREGROUND_DOWNLOAD_LIMIT,
|
||
// 本地读取失败由外层显式重试；直存下载失败也只立即重试一次。
|
||
maxRetryCount: direct ? 0 : remote ? cc.assetManager.downloader.maxRetryCount : 0
|
||
},
|
||
(err, result: cc.Texture2D) => err || !result
|
||
? reject(err || new Error("Block 图片为空: " + path)) : resolve(result));
|
||
});
|
||
// if (remote) console.log(`[Block图片][远程加载] 成功 ${path}.png，已直存并加载，${url}`);
|
||
return texture;
|
||
} catch (error) {
|
||
// if (remote) console.log(`[Block图片][远程加载] 失败 ${path}.png，${url}`, error);
|
||
throw error;
|
||
}
|
||
};
|
||
try {
|
||
return await load(false);
|
||
} catch (error) {
|
||
// 缓存损坏也要重下，不能仅凭文件存在/完成标记一直命中坏文件。
|
||
// console.log(`[Block图片][加载重试] ${path}.png，清理无效缓存后从远程重试`, error);
|
||
// this.invalidateFile(path);
|
||
return load(true);
|
||
}
|
||
}
|
||
|
||
private getFileSystem(): any {
|
||
if (typeof wx !== "undefined" && wx && wx.getFileSystemManager) return wx.getFileSystemManager();
|
||
if (typeof tt !== "undefined" && tt && tt.getFileSystemManager) return tt.getFileSystemManager();
|
||
return null;
|
||
}
|
||
|
||
private getDownloadSdk(): any {
|
||
if (typeof wx !== "undefined" && wx && wx.downloadFile) return wx;
|
||
if (typeof tt !== "undefined" && tt && tt.downloadFile) return tt;
|
||
return null;
|
||
}
|
||
|
||
private userCacheRoot(): string {
|
||
const sdk = this.getDownloadSdk();
|
||
const root = sdk && sdk.env && sdk.env.USER_DATA_PATH;
|
||
return typeof root === "string" && root ? root.replace(/\/$/, "") + "/Block/" + this.version : "";
|
||
}
|
||
|
||
private userFilePath(path: string): string {
|
||
const root = this.userCacheRoot();
|
||
return root ? root + "/" + path + ".png" : "";
|
||
}
|
||
|
||
private canUseUserCache(): boolean {
|
||
const fs = this.getFileSystem();
|
||
return !!(this.version && this.userCacheRoot() && fs && fs.mkdirSync && fs.renameSync && fs.unlinkSync);
|
||
}
|
||
|
||
private ensureUserCacheFolder(): void {
|
||
const fs = this.getFileSystem();
|
||
const folder = this.userCacheRoot();
|
||
if (!folder || !fs) return;
|
||
try {
|
||
if (fs.statSync(folder).isDirectory()) return;
|
||
} catch (error) { /* missing */ }
|
||
try {
|
||
fs.mkdirSync(folder, true);
|
||
} catch (error) {
|
||
// 并发创建时允许另一个调用先成功；权限/同名文件错误必须继续抛出。
|
||
try { if (fs.statSync(folder).isDirectory()) return; } catch (ignored) { /* keep original */ }
|
||
// console.log(`[Block图片][用户缓存] 创建目录失败 ${folder}`, error);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
private fileExists(path: string): boolean {
|
||
if (typeof path !== "string" || !path) return false;
|
||
try {
|
||
const stat = this.getFileSystem().statSync(path);
|
||
return stat.isFile() && stat.size > 0;
|
||
} catch (error) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private imageUrl(path: string): string {
|
||
if (this.paths.indexOf(path) < 0) throw new Error("未知的 Block 图片: " + path);
|
||
return this.imageBase + path + ".png?v=" + this.version;
|
||
}
|
||
|
||
private getPersistentFile(path: string): string {
|
||
const direct = this.userFilePath(path);
|
||
if (this.fileExists(direct)) return direct;
|
||
const cache = cc.assetManager.cacheManager as any;
|
||
if (!cache || !this.getFileSystem()) return "";
|
||
const url = this.imageUrl(path);
|
||
const local = cache.getCache(url);
|
||
if (this.fileExists(local)) return local;
|
||
if (local) {
|
||
cache.removeCache(url);
|
||
this.clearDownloadedFile(url);
|
||
}
|
||
return "";
|
||
}
|
||
|
||
private hasLocalFile(path: string): boolean {
|
||
const cache = cc.assetManager.cacheManager as any;
|
||
if (!this.getFileSystem()) return false;
|
||
if (this.getPersistentFile(path)) return true;
|
||
if (!cache) return false;
|
||
const url = this.imageUrl(path);
|
||
const temp = cache.getTemp(url);
|
||
if (temp && !this.fileExists(temp)) {
|
||
cache.tempFiles.remove(url);
|
||
this.clearDownloadedFile(url);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private getTempFile(path: string): string {
|
||
if (!this.getFileSystem()) return "";
|
||
const cache = cc.assetManager.cacheManager as any;
|
||
const url = this.imageUrl(path);
|
||
const temp = cache && cache.getTemp(url);
|
||
if (this.fileExists(temp)) return temp;
|
||
const native = (cc.assetManager as any)._files.get(url + "@native");
|
||
if (this.fileExists(native)) return native;
|
||
if (native) this.clearDownloadedFile(url);
|
||
return "";
|
||
}
|
||
|
||
private getImageSource(path: string): ImageSource {
|
||
if (this.frames.has(path)) return "内存复用";
|
||
if (this.hasLocalFile(path)) return "本地缓存";
|
||
if (this.getTempFile(path)) return "临时缓存";
|
||
return "远程下载";
|
||
}
|
||
|
||
private invalidateFile(path: string): void {
|
||
const url = this.imageUrl(path);
|
||
this.deleteFile(this.userFilePath(path));
|
||
this.deleteFile(this.userFilePath(path) + ".tmp");
|
||
const cache = cc.assetManager.cacheManager as any;
|
||
if (cache) {
|
||
cache.removeCache(url);
|
||
cache.tempFiles && cache.tempFiles.remove(url);
|
||
}
|
||
this.clearImageCaches(path);
|
||
}
|
||
|
||
private deleteFile(path: string): void {
|
||
if (!path) return;
|
||
try { this.getFileSystem().unlinkSync(path); } catch (error) { /* already absent */ }
|
||
}
|
||
|
||
private clearImageCaches(path: string): void {
|
||
const url = this.imageUrl(path);
|
||
this.clearDownloadedFile(url);
|
||
this.clearDownloadedFile(this.userFilePath(path));
|
||
}
|
||
|
||
private clearDownloadedFile(url: string): void {
|
||
// 2.4.15 运行时提供这两个缓存，项目的 creator.d.ts 未声明它们。
|
||
const manager = cc.assetManager as any;
|
||
if (!url) return;
|
||
manager._files && manager._files.remove(url + "@native");
|
||
manager._parsed && manager._parsed.remove(url + "@native");
|
||
}
|
||
|
||
/** 同一路径共享任务；排队中的后台任务被进关请求命中时立即提升优先级。 */
|
||
private downloadToUserCache(path: string, priority: number): Promise<void> {
|
||
if (this.fileExists(this.userFilePath(path))) return Promise.resolve();
|
||
const existing = this.fileDownloads.get(path);
|
||
if (existing) {
|
||
if (priority > existing.job.priority) existing.job.priority = priority;
|
||
if (priority > 0 && !existing.job.started) existing.job.background = false;
|
||
this.pumpDownloadQueue();
|
||
return existing.promise;
|
||
}
|
||
this.ensureUserCacheFolder();
|
||
let resolve: () => void;
|
||
let reject: (error: any) => void;
|
||
const promise = new Promise<void>((ok, fail) => { resolve = ok; reject = fail; });
|
||
const job: BlockDownloadJob = {
|
||
path, priority, background: priority < 0, started: false,
|
||
resolve: resolve!, reject: reject!
|
||
};
|
||
this.fileDownloads.set(path, { promise, job });
|
||
this.downloadQueue.push(job);
|
||
this.pumpDownloadQueue();
|
||
return promise;
|
||
}
|
||
|
||
private pumpDownloadQueue(): void {
|
||
this.downloadQueue.sort((a, b) => b.priority - a.priority);
|
||
while (this.activeFileDownloads < BlockAssetManager.FOREGROUND_DOWNLOAD_LIMIT) {
|
||
const index = this.downloadQueue.findIndex(job => !job.background
|
||
|| (this.foregroundLoads === 0
|
||
&& this.activeBackgroundDownloads < BlockAssetManager.BACKGROUND_CONCURRENCY));
|
||
if (index < 0) return;
|
||
const job = this.downloadQueue.splice(index, 1)[0];
|
||
job.started = true;
|
||
this.activeFileDownloads++;
|
||
if (job.background) this.activeBackgroundDownloads++;
|
||
this.startUserDownload(job);
|
||
}
|
||
}
|
||
|
||
private startUserDownload(job: BlockDownloadJob): void {
|
||
const sdk = this.getDownloadSdk();
|
||
const fs = this.getFileSystem();
|
||
const url = this.imageUrl(job.path);
|
||
const target = this.userFilePath(job.path);
|
||
const temporary = target + ".tmp";
|
||
this.deleteFile(temporary);
|
||
let finished = false;
|
||
const finish = (error?: any) => {
|
||
if (finished) return;
|
||
finished = true;
|
||
this.activeFileDownloads--;
|
||
if (job.background) this.activeBackgroundDownloads--;
|
||
this.fileDownloads.delete(job.path);
|
||
if (error) {
|
||
this.deleteFile(temporary);
|
||
job.reject(error);
|
||
} else {
|
||
job.resolve();
|
||
}
|
||
this.pumpDownloadQueue();
|
||
};
|
||
try {
|
||
sdk.downloadFile({
|
||
url, filePath: temporary,
|
||
success: (response: any) => {
|
||
try {
|
||
if (!response || response.statusCode !== 200 || !this.fileExists(temporary)) {
|
||
throw new Error("Block 图片 HTTP " + (response && response.statusCode));
|
||
}
|
||
this.deleteFile(target);
|
||
fs.renameSync(temporary, target);
|
||
if (!this.fileExists(target)) throw new Error("Block 图片直存失败: " + target);
|
||
finish();
|
||
} catch (error) { finish(error); }
|
||
},
|
||
fail: (error: any) => finish(error || new Error("Block 图片下载失败: " + job.path))
|
||
});
|
||
} catch (error) { finish(error); }
|
||
}
|
||
|
||
/** 兼容升级前已经下载到 Cocos 临时目录的文件，直接复制到用户版本目录。 */
|
||
private copyToUserCache(path: string, source: string): Promise<void> {
|
||
if (this.fileExists(this.userFilePath(path))) return Promise.resolve();
|
||
this.ensureUserCacheFolder();
|
||
const fs = this.getFileSystem();
|
||
const target = this.userFilePath(path);
|
||
const temporary = target + ".tmp";
|
||
this.deleteFile(temporary);
|
||
return new Promise<void>((resolve, reject) => fs.copyFile({
|
||
srcPath: source, destPath: temporary,
|
||
success: () => {
|
||
try {
|
||
this.deleteFile(target);
|
||
fs.renameSync(temporary, target);
|
||
if (!this.fileExists(target)) throw new Error("Block 临时图片迁移失败: " + target);
|
||
resolve();
|
||
} catch (error) { this.deleteFile(temporary); reject(error); }
|
||
},
|
||
fail: (error: any) => { this.deleteFile(temporary); reject(error); }
|
||
}));
|
||
}
|
||
|
||
startBackgroundCache(): void {
|
||
this.runBackgroundCache();
|
||
}
|
||
|
||
private runBackgroundCache(): void {
|
||
// 浏览器不做全量预缓存；小游戏必须支持用户目录直存。
|
||
const hasFileSystem = !!this.getFileSystem();
|
||
const hasUserCache = !!this.getDownloadSdk();
|
||
if (!hasFileSystem || !hasUserCache) {
|
||
// console.log(`[Block图片][后台缓存] 跳过：用户缓存环境不可用，下载接口=${hasUserCache}，文件系统=${hasFileSystem}`);
|
||
return;
|
||
}
|
||
if (!this.backgroundStarted) {
|
||
this.backgroundStarted = true;
|
||
cc.game.on(cc.game.EVENT_SHOW, this.startBackgroundCache, this);
|
||
}
|
||
if (this.backgroundRunning) {
|
||
// console.log("[Block图片][后台缓存] 任务正在运行，不重复启动");
|
||
return;
|
||
}
|
||
if (this.backgroundTimer) clearTimeout(this.backgroundTimer);
|
||
this.backgroundTimer = null;
|
||
this.backgroundRunning = true;
|
||
// console.log(`[Block图片][后台缓存] 启动，资源清单共${this.paths.length}张，补齐缺失图片`);
|
||
this.cacheAllFiles().catch(error => {
|
||
// console.log("[Block图片][后台缓存] 任务失败，稍后重试", error);
|
||
// cc.warn("Block 后台缓存未完成，稍后重试:", error);
|
||
return null;
|
||
}).then(result => {
|
||
this.backgroundRunning = false;
|
||
if (result && result.complete) {
|
||
// console.log("[Block图片][后台缓存] 本轮结束，全部已持久缓存");
|
||
return;
|
||
}
|
||
const reason = !result ? "任务异常" : result.missing ? `仍缺少${result.missing}张图片`
|
||
: `${result.temporary}张旧临时文件待迁移`;
|
||
// console.log(`[Block图片][后台缓存] 本轮结束，${reason}，10秒后重试`);
|
||
this.backgroundTimer = setTimeout(() => this.runBackgroundCache(), BlockAssetManager.BACKGROUND_RETRY_MS);
|
||
});
|
||
}
|
||
|
||
private async cacheAllFiles(): Promise<BlockCacheCheck> {
|
||
await this.initialize();
|
||
if (!this.canUseUserCache()) throw new Error("Block 用户缓存环境不可用");
|
||
this.ensureUserCacheFolder();
|
||
const paths = this.paths;
|
||
const checked = await this.saveCacheState(paths);
|
||
if (checked.complete) {
|
||
// console.log("[Block图片][后台缓存] 全部本地缓存有效，无需下载");
|
||
return checked;
|
||
}
|
||
const concurrency = BlockAssetManager.BACKGROUND_CONCURRENCY;
|
||
// console.log(`[Block图片][后台缓存] 滚动下载队列，最多${concurrency}张并发，进关期间停止派发`);
|
||
let index = 0;
|
||
let paused = false;
|
||
const worker = async () => {
|
||
while (index < paths.length) {
|
||
while (this.foregroundLoads > 0) {
|
||
// if (!paused) console.log("[Block图片][后台缓存] 暂停派发，优先等待进关图片，已发出的请求继续完成");
|
||
paused = true;
|
||
await this.delay(100);
|
||
}
|
||
if (paused) {
|
||
// console.log("[Block图片][后台缓存] 进关图片处理结束，继续后台缓存");
|
||
paused = false;
|
||
}
|
||
// 每次只领取一张；完成一张就补一张，等待前台期间其他 worker 可能已取完队列。
|
||
if (index >= paths.length) return;
|
||
const path = paths[index++];
|
||
if (this.hasLocalFile(path)) continue;
|
||
const url = this.imageUrl(path);
|
||
const temp = this.getTempFile(path);
|
||
const fs = this.getFileSystem();
|
||
if (temp && fs && fs.copyFile) {
|
||
try {
|
||
await this.copyToUserCache(path, temp);
|
||
// console.log(`[Block图片][用户缓存] 已迁移临时文件 ${path}.png -> ${this.userFilePath(path)}`);
|
||
} catch (error) {
|
||
// console.log(`[Block图片][用户缓存] 临时文件迁移失败 ${path}.png`, error);
|
||
// cc.warn("Block 临时图片迁移失败:", path, error);
|
||
}
|
||
continue;
|
||
}
|
||
// 极旧环境没有 copyFile 时不依赖 Cocos 临时缓存，直接补一份用户目录文件。
|
||
this.backgroundDownloads.add(path);
|
||
// console.log(`[Block图片][远程下载] 开始 ${path}.png，后台缓存，在途=${this.backgroundDownloads.size}/${concurrency}，${url}`);
|
||
try {
|
||
await this.downloadToUserCache(path, -10);
|
||
// console.log(`[Block图片][远程下载] 成功 ${path}.png，已直存=${this.userFilePath(path)}，${url}`);
|
||
} catch (error) {
|
||
// console.log(`[Block图片][远程下载] 失败 ${path}.png，${url}`, error);
|
||
// cc.warn("Block 图片缓存失败，保留未完成状态:", path, error);
|
||
} finally {
|
||
this.backgroundDownloads.delete(path);
|
||
}
|
||
await this.delay(0);
|
||
}
|
||
};
|
||
await Promise.all(Array.from({ length: concurrency }, () => worker()));
|
||
return this.saveCacheState(paths);
|
||
}
|
||
|
||
private async saveCacheState(paths: string[]): Promise<BlockCacheCheck> {
|
||
let cached = 0;
|
||
let temporary = 0;
|
||
let missing = 0;
|
||
for (let i = 0; i < paths.length; i++) {
|
||
if (this.hasLocalFile(paths[i])) cached++;
|
||
else if (this.getTempFile(paths[i])) temporary++;
|
||
else missing++;
|
||
// 分批检查，避免一次同步扫描全部文件阻塞游戏帧。
|
||
if (i % 8 === 7) await this.delay(0);
|
||
}
|
||
const complete = paths.length > 0 && cached === paths.length;
|
||
this.writeCacheState(paths.length, cached, complete);
|
||
console.log(`[Block图片][缓存校验] 版本=${this.version}，用户目录=${this.userCacheRoot()}，有效持久文件=${cached}/${paths.length}，完整落盘=${complete}，临时文件=${temporary}，缺失=${missing}`);
|
||
return { cached, temporary, missing, complete };
|
||
}
|
||
|
||
private writeCacheState(total: number, cached: number, complete: boolean): void {
|
||
const state = JSON.stringify({
|
||
version: this.version, baseUrl: this.imageBase,
|
||
total, cached, complete
|
||
});
|
||
try {
|
||
if (cc.sys.localStorage.getItem(BlockAssetManager.CACHE_KEY) !== state) {
|
||
cc.sys.localStorage.setItem(BlockAssetManager.CACHE_KEY, state);
|
||
}
|
||
} catch (error) {
|
||
// cc.warn("Block 缓存状态保存失败:", error);
|
||
}
|
||
}
|
||
|
||
private delay(ms: number): Promise<void> {
|
||
return new Promise(resolve => setTimeout(resolve, ms));
|
||
}
|
||
}
|