@xmov/avatar 2.0.0-alpha.38

package/src/modules/ResourceManager.ts

@@ -0,0 +1,899 @@
+import Pako from 'pako'
+import { IAvatarOptions, INetworkInfo, Layout, WalkConfig } from "../types/index";
+import request, { XMLRequest } from "../utils/request";
+import {
+  IBRAnimationGeneratorCharInfo_NN,
+} from "../utils/DataInterface";
+import XmovAvatar from "../index";
+import { EErrorCode } from "../types/error";
+import { headersNeedSign } from "../utils/encodeToken";
+// import { isDEV } from "../utils";
+import CacheManager from './cache-manager';
+
+/**
+ * 资源处理模块，加载并存储资源
+ */
+
+type TOptions = Pick<
+  IAvatarOptions,
+  "appId" | "appSecret" | "gatewayServer" | 'cacheServer' | "sdkInstance" | "config" | "headers" | "gateway_type" | "tag" |
+  "asr_id" | "llm_id" | "session_speak_req_id"
+> & {
+  sessionRequestData?: Record<string, unknown>
+  onNetworkInfo(quality: INetworkInfo): void
+  onStartSessionWarning?: (message: Object) => void
+};
+export type TDownloadProgress = (progress: number) => void;
+export interface IOfflineIdle {
+  asf: number
+  aef: number
+  n: string
+}
+export interface IResumeParams {
+  client_frame: number
+  current_ani: string
+  current_ani_frame: number
+  next_state: string
+}
+export interface ISessionResponse {
+  session_id: string;
+  room: string;
+  token: string;
+  socket_io_url: string;
+  e2e_resp?: {
+    ws_url?: string;
+    e2e_token?: string;
+    monitor_ws_url?: string;
+    features?: {
+      speech_frontend?: {
+        enable_aec?: boolean;
+        [key: string]: unknown;
+      };
+      [key: string]: unknown;
+    };
+  };
+  features?: {
+    speech_frontend?: {
+      enable_aec?: boolean;
+      [key: string]: unknown;
+    };
+    [key: string]: unknown;
+  };
+  session_start_time: string;
+  resource_pack: {
+    enable_robot_expression: boolean;
+    body_data_dir: string;
+    face_ani_char_data: string;
+    face_ani_preload_data: string;
+    offline_idle: IOfflineIdle[],
+    interpolate_joints: [number, number][]
+  };
+  reconnect_timeout: number;
+  reconnect_client_timeout: number;
+  config: {
+    background_img: string;
+    frame_rate: number;
+    look_name: string;
+    tts_vcn_id: string;
+    sta_face_id: string;
+    mp_service_id: string;
+    raw_audio: boolean;
+    resolution: {
+      width: number;
+      height: number;
+    },
+    init_events: [
+      {
+        type: string;
+        data: {
+          image: string;
+          axis_id: number;
+        }
+      }
+    ],
+    fx?: {
+      transform?: {
+        offsetX: number;
+        offsetY: number;
+        scaleX: number;
+        scaleY: number;
+      };
+      // 阴影效果
+      shadow?: {
+        // [x, y, z]，阴影投射的基准点
+        refPos: number[];
+        // 光源位置 
+        light: number[];
+        // 光源类型："point"（点光源）| "directional"（平行光）
+        lightType: string;
+        // 阴影模糊半径（越大越柔和）
+        blurRadius: number;
+        // 阴影颜色 
+        tint: number[];
+        // 阴影强度（0.0 = 无阴影，1.0 = 最深）
+        intensity: number;
+      };
+    };
+  };
+}
+export default class ResourceManager {
+  private TAG = "[ResourceManager]";
+  options: TOptions;
+  sdk: XmovAvatar;
+  session_id?: string;
+  mouthShapeLib: any;
+  offlineIdle: IOfflineIdle[] = []
+  offlineCache = new Map<string, {
+    data: ArrayBuffer;
+  }>();
+  networkInfos: INetworkInfo[] = [];
+  private bg: HTMLImageElement | null = null;
+  private destroyed = false;
+  public resource_pack: {
+    enable_robot_expression: boolean;
+    body_data_dir: string;
+    face_ani_char_data: string;
+    face_ani_preload_data: string;
+    blendshape_map?: number[][];
+    interpolate_joints: [number, number][]
+  }
+  progress = 0; // start session 以后之后资源下载进度
+
+  config: {
+    background_img: string;
+    frame_rate: number;
+    look_name: string;
+    tts_vcn_id: string;
+    sta_face_id: string;
+    mp_service_id: string;
+    raw_audio: boolean;
+    resolution: {
+      width: number;
+      height: number;
+    },
+    init_events: [
+      {
+        type: string;
+        "x_location"?: number;//控件锚点信息，控件左上角在屏幕上的横向位置。范围0-1
+        "y_location"?: number;//控件锚点信息，控件左上角在屏幕上的纵向位置。范围0-1
+        width?: number;//控件锚点信息，控件在屏幕上的宽度。范围0-1
+        height: number;//控件锚点信息，控件在屏幕上的高度。范围0-1
+        speech_id: number;
+        data?: {
+          image: string;
+          axis_id: number;
+        }
+      }
+    ],
+    framedata_proto_version: number;
+    layout: Layout;
+    walk_config: WalkConfig;
+    fx?: {
+      transform?: {
+        offsetX: number;
+        offsetY: number;
+        scaleX: number;
+        scaleY: number;
+      };
+      // 阴影效果
+      shadow?: {
+        // [x, y, z]，阴影投射的基准点
+        refPos: number[];
+        // 光源位置 
+        light: number[];
+        // 光源类型："point"（点光源）| "directional"（平行光）
+        lightType: string;
+        // 阴影模糊半径（越大越柔和）
+        blurRadius: number;
+        // 阴影颜色 
+        tint: number[];
+        // 阴影强度（0.0 = 无阴影，1.0 = 最深）
+        intensity: number;
+      };
+    };
+  };
+
+  // 视频缓存相关
+  private videoCache = new Map<string, {
+    data: ArrayBuffer;
+    lastAccessTime: number;
+    accessCount: number;
+  }>();
+  private maxCacheSize = 10 * 1024 * 1024; // 5MB 默认缓存大小
+  private maxCacheEntries = 20; // 最大缓存条目数
+  private cacheCleanupInterval: any = null;
+  private isProcessingVideo = false; // 防止在视频处理过程中清理缓存
+  private cacheServer?: CacheManager;
+  private startSessionTimer: any = null;
+
+  // 新增：正在下载的视频跟踪
+  private downloadingVideos = new Map<string, Promise<ArrayBuffer | undefined>>();
+  first_load = true;
+  constructor(options: TOptions) {
+    this.options = options;
+    this.sdk = options.sdkInstance as XmovAvatar;
+    this.mouthShapeLib = {
+      char_info: null,
+    };
+    this.config = options.config || {};
+    this.resource_pack = {
+      enable_robot_expression: false,
+      body_data_dir: "",
+      face_ani_char_data: "",
+      face_ani_preload_data: "",
+      interpolate_joints: [[4, 3]]
+    };
+
+    if (options.cacheServer) {
+      this.cacheServer = new CacheManager(options.cacheServer);
+    }
+    // 启动缓存清理定时器
+    this.startCacheCleanup();
+  }
+
+  public getAppInfo() {
+    return {
+      appId: this.options.appId
+    }
+  }
+
+  /**
+   * 加载背景图片
+   * @returns Promise<void>
+   */
+  getBackgroundImage(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const img = new Image();
+        // 设置跨域属性
+        img.crossOrigin = "anonymous";
+        img.src = this.config?.background_img || "";
+        if (!this.config?.background_img) return;
+        img.onload = () => {
+          this.bg = img;
+          resolve();
+        };
+
+        img.onerror = (error) => {
+          this.sdk.onMessage({
+            code: EErrorCode.BACKGROUND_IMAGE_LOAD_ERROR,
+            message: `Error: 背景图片加载失败`,
+            e: { error, img },
+          });
+          this.bg = null;
+          resolve();
+        };
+      } catch (error) {
+      }
+    });
+  }
+
+  getIsEnableRobotExpression() {
+    return this.resource_pack?.enable_robot_expression
+  }
+
+  /**
+   * 获取背景图片
+   * @returns HTMLImageElement | null
+   */
+  getBackgroundImageElement(): HTMLImageElement | null {
+    return this.bg;
+  }
+
+  getConfig() {
+    return this.config;
+  }
+
+  async load(onDownloadProgress?: TDownloadProgress) {
+    this.destroyed = false; // 重置销毁状态，允许重新加载
+    onDownloadProgress?.(this.progress);
+     if (this.startSessionTimer) {
+      clearInterval(this.startSessionTimer);
+      this.startSessionTimer = null;
+    }
+
+    this.startSessionTimer = setInterval(() => {
+      if (this.destroyed || this.progress >= 14) {
+        clearInterval(this.startSessionTimer);
+        this.startSessionTimer = null;
+        return;
+      }
+      this.progress += 1;
+      onDownloadProgress?.(this.progress);
+    }, 100);
+    // http 请求算 10 进度
+    const result = await this.startSession();
+    // 如果在 startSession 过程中被销毁了，直接返回，避免继续加载资源
+    if (this.destroyed) {
+      (window as any).avatarSDKLogger.warn(this.TAG, "sdk destroyed during load, aborting after startSession");
+      return null;
+    }
+    if (!result) {
+      clearInterval(this.startSessionTimer);
+      this.startSessionTimer = null;
+      return null;
+    }
+
+    clearInterval(this.startSessionTimer);
+    this.startSessionTimer = null;
+    this.progress = 15;
+    onDownloadProgress?.(this.progress);
+    const res = result as unknown as ISessionResponse;
+    this.session_id = res?.session_id;
+    this.resource_pack = res.resource_pack;
+    this.config = res.config as any;
+    this.offlineIdle = res.resource_pack?.offline_idle || []
+    if (this.resource_pack) {
+      await this.loadMouthShapeLib(onDownloadProgress);
+      this.getBackgroundImage();
+      if (!this.mouthShapeLib?.char_info && res?.resource_pack?.face_ani_char_data) {
+        return null
+      }
+    }
+    return res;
+  }
+
+  async startSession() {
+    try {
+      const result = await this._startSession();
+      if (result?.verify_res) {
+        this.options.onStartSessionWarning?.(result.verify_res);
+      }
+      return result;
+    } catch (error) {
+      return null;
+    }
+  }
+  _startSession() {
+    if (!navigator.onLine) {
+      this.sdk.onMessage({
+        code: EErrorCode.NETWORK_BREAK,
+        message: '没有网络，请联网后重试~',
+      });
+      return null;
+    }
+
+    const url = `${this.options.gatewayServer}`;
+
+
+    const data = {
+      tag: this.options.tag,
+      gateway_type: this.options.gateway_type,
+      ...(this.options.asr_id !== undefined ? { asr_id: this.options.asr_id } : {}),
+      ...(this.options.llm_id !== undefined ? { llm_id: this.options.llm_id } : {}),
+      ...(this.options.session_speak_req_id !== undefined
+        ? { session_speak_req_id: this.options.session_speak_req_id }
+        : {}),
+      ...(this.options.sessionRequestData ?? {}),
+      config: {
+        ...this.config,
+        framedata_proto_version: 2,
+        walk_version: 3,
+      }
+    }
+    const { headers, data: signedData } = headersNeedSign(this.options.appId, this.options.appSecret, "POST", url, data);
+    return request(url, { method: "POST", data: signedData, headers: { ...headers, ...this.options.headers } })
+      .then(response => response.json())
+      .then(res => {
+        if (!res?.data?.resource_pack) {
+          this.sdk.onMessage({
+            code: res?.error_code,
+            message: `Error: ${res?.error_code}, ${res?.error_reason}`,
+          });
+          return null;
+        }
+        return res?.data;
+      }).catch(error => {
+        this.sdk.onMessage({
+          code: EErrorCode.START_SESSION_ERROR,
+          message: `Error: 启动会话失败`,
+          e: error,
+        });
+        return null;
+      });
+  }
+
+  async stopSession(stop_reason: string) {
+    try {
+      const url = `${this.options.gatewayServer}`;
+      if (!this.session_id) {
+        return;
+      }
+      const data = {
+        session_id: this.session_id,
+        stop_reason,
+      }
+      const { headers, data: signedData } = headersNeedSign(this.options.appId, this.options.appSecret, "DELETE", url, data);
+      const response = await request(url, { method: "DELETE", data: signedData, headers: { ...headers, ...this.options.headers } });
+      return await response.json();
+    } catch (error) {
+      this.sdk.onMessage({
+        code: EErrorCode.STOP_SESSION_ERROR,
+        message: `Error: 停止会话失败`,
+        e: error,
+      });
+    }
+  }
+
+  /**
+   * 加载表情数据
+   */
+  async loadMouthShapeLib(onDownloadProgress?: TDownloadProgress) {
+    try {
+      if (!this.resource_pack.face_ani_char_data) {
+        this.progress += 60;
+        onDownloadProgress?.(this.progress);
+        return;
+      }
+      // 优先加载 .gz，失败则回退 bin
+      let char_data: ArrayBuffer | null = null;
+      let gzError: any = null;
+      let finalUrl = '';
+      let fileSize = 0;
+      let startTime = 0;
+      let preTime = 0;
+      let preLoaded = 0;
+
+      const createProgressHandler = () => (progress: number, e?: ProgressEvent) => {
+        if (!e) return;
+        const now = performance.now();
+        const deltaTime = now - preTime;
+        const deltaLoaded = e.loaded - preLoaded;
+
+        const speedMbps = (deltaTime > 0 && deltaLoaded > 0)
+          ? (deltaLoaded * 8) / (deltaTime / 1000) / 1000000
+          : 0;
+
+        this.options.onNetworkInfo?.({
+          rtt: deltaTime,
+          downlink: speedMbps,
+          networkStatus: navigator.onLine,
+        });
+
+        preLoaded = e.loaded;
+        preTime = now;
+        onDownloadProgress?.(this.progress + progress * 0.65);
+      };
+
+      try {
+        const gzUrl = `${this.resource_pack.face_ani_char_data}.gz`;
+        finalUrl = gzUrl;
+        startTime = performance.now();
+        preTime = startTime;
+        preLoaded = 0;
+
+        const [, gz_data] = await XMLRequest({
+          url: gzUrl,
+          onProgress: createProgressHandler(),
+        });
+
+        const decompressed = Pako.ungzip(new Uint8Array(gz_data as ArrayBuffer));
+        const ab = new ArrayBuffer(decompressed.byteLength);
+        new Uint8Array(ab).set(decompressed);
+        char_data = ab;
+      } catch (e) {
+        gzError = e;
+        char_data = null;
+      }
+
+      if (!char_data) {
+        try {
+          const binUrl = this.resource_pack.face_ani_char_data;
+          finalUrl = binUrl;
+          startTime = performance.now();
+          preTime = startTime;
+          preLoaded = 0;
+
+          const [, bin_data] = await XMLRequest({
+            url: binUrl,
+            onProgress: createProgressHandler(),
+          });
+
+          char_data = bin_data as ArrayBuffer;
+        } catch (e) {
+          if (this.first_load) {
+            this.first_load = false;
+            this.stopSession("char_bin_load_error");
+          }
+          this.sdk.onMessage?.({
+            code: EErrorCode.FACE_BIN_LOAD_ERROR,
+            message: "表情数据加载失败（.gz 和 bin 均失败）",
+            e: { gzError, binError: e },
+          });
+          return;
+        }
+      }
+
+      const totalCostMs = performance.now() - startTime;
+      const totalSpeedMbps = fileSize > 0 && totalCostMs > 0
+        ? (fileSize * 8) / (totalCostMs / 1000) / 1000000
+        : 0;
+
+      this.options.onNetworkInfo?.({
+        rtt: totalCostMs,
+        downlink: totalSpeedMbps,
+        networkStatus: navigator.onLine,
+      });
+
+      this.mouthShapeLib = {
+        char_info: new IBRAnimationGeneratorCharInfo_NN(char_data, {
+          blendshapeMap: this.resource_pack.blendshape_map || [],
+        }),
+      };
+      this.progress += 65;
+      onDownloadProgress?.(this.progress);
+    } catch (error) {
+      if (this.first_load) {
+        this.first_load = false;
+        this.stopSession("char_bin_load_error");
+      }
+      this.sdk.onMessage?.({
+        code: EErrorCode.FACE_BIN_LOAD_ERROR,
+        message: "表情数据加载失败，请检查文件是否正确",
+        e: error,
+      });
+    }
+  }
+
+  getMouthShapeLib() {
+    return this.mouthShapeLib;
+  }
+
+  getVideoUrl(name: string) {
+    if (!this.resource_pack.body_data_dir) {
+      return "";
+    }
+    if (!name) {
+      if (this.first_load) {
+        this.first_load = false;
+        this.stopSession("no_video_name_error");
+      }
+      this.sdk.onMessage({
+        code: EErrorCode.INVALID_BODY_NAME,
+        message: `Error: 视频地址获取失败`,
+        e: name,
+      });
+      return "";
+    }
+    const url = `${this.resource_pack.body_data_dir}${name}.mp4`
+    if (this.cacheServer) {
+      return this.cacheServer?.getVideo(url);
+    }
+    return url
+  }
+
+  /**
+   * 预加载视频
+   * @param name 视频名称
+   * @returns Promise<ArrayBuffer>
+   */
+  async preloadVideo(name: string) {
+    if (this.videoCache.has(name)) return;
+    return this.loadVideo(name);
+  }
+  /**
+   * 加载视频
+   * @param name 视频名称
+   * @returns Promise<ArrayBuffer>
+   */
+  async loadVideo(name: string) {
+    // 检查缓存
+    const cacheEntry = this.videoCache.get(name) || this.offlineCache.get(name);
+    if (cacheEntry) {
+      if (cacheEntry.data) {
+        this.updateCacheAccess(name);
+        return cacheEntry.data;
+      } else {
+        // 缓存条目存在但数据为空，删除这个无效条目
+        (window as any).avatarSDKLogger.warn(this.TAG, `发现无效缓存条目: ${name}，正在删除`);
+        this.videoCache.delete(name);
+      }
+    }
+
+    // 检查是否正在下载
+    if (this.downloadingVideos.has(name)) {
+      try {
+        const result = await this.downloadingVideos.get(name);
+        return result;
+      } catch (error) {
+        // 如果下载失败，从下载列表中移除
+        this.downloadingVideos.delete(name);
+        (window as any).avatarSDKLogger.warn(this.TAG, `${name} 视频下载失败，从下载列表移除`);
+        throw error;
+      }
+    }
+
+    // 开始下载
+    this.isProcessingVideo = true;
+    const downloadPromise = this.downloadVideo(name);
+    this.downloadingVideos.set(name, downloadPromise);
+    try {
+      const result = await downloadPromise;
+      return result;
+    } finally {
+      // 下载完成后从下载列表中移除
+      this.downloadingVideos.delete(name);
+      this.isProcessingVideo = false;
+    }
+  }
+
+  /**
+   * 实际下载视频的方法
+   * @param name 视频名称
+   * @returns Promise<ArrayBuffer>
+   */
+  private async downloadVideo(name: string): Promise<ArrayBuffer | undefined> {
+    const url = this.getVideoUrl(name);
+    if (!url) {
+      return;
+    }
+    try {
+      const { response, arrayBuffer } = await this._fetchVideo(url);
+      if (!response.ok) {
+        if (this.first_load) {
+          this.first_load = false;
+          this.stopSession("load_video_error");
+        }
+        this.sdk.onMessage({
+          code: EErrorCode.VIDEO_DOWNLOAD_ERROR,
+          message: `Error: ${name} 视频下载失败`,
+          e: { name, url, res: response },
+        });
+        return;
+      }
+
+      // 将下载的数据添加到缓存
+      this.addToCache(name, arrayBuffer);
+
+      return arrayBuffer;
+    } catch (error) {
+      this.sdk.onMessage({
+        code: EErrorCode.VIDEO_DOWNLOAD_ERROR,
+        message: `Error: ${name} 视频下载失败`,
+        e: { name, url, error },
+      });
+      return;
+    }
+  }
+
+  private async _fetchVideo(url: string) {
+    if (this.networkInfos.length >= 4) {
+      const avgRtt = this.networkInfos.reduce((sum, curr) => sum + curr.rtt, 0) / this.networkInfos.length;
+      const avgDownlink = this.networkInfos.reduce((sum, curr) => sum + curr.downlink, 0) / this.networkInfos.length;
+      this.options.onNetworkInfo?.({
+        rtt: avgRtt,
+        downlink: avgDownlink,
+        networkStatus: navigator.onLine,
+      })
+      this.networkInfos.length = 0
+    }
+    const startTime = performance.now();
+    const response = await fetch(url)
+    const totalSize = parseFloat(response.headers.get('Content-Length') || '0');
+    const endTime = performance.now();
+    const arrayBuffer = await response.arrayBuffer()
+    const rtt = endTime - startTime; // 毫秒
+    const downlink = (totalSize * 8) / (rtt / 1000 * 1000000); // Mbps
+
+    const networkInfo = {
+      rtt,
+      downlink,
+      networkStatus: navigator.onLine,
+    };
+    this.networkInfos.push(networkInfo)
+    return {
+      response,
+      arrayBuffer,
+    }
+  }
+
+  /**
+   * 添加数据到缓存
+   */
+  private addToCache(key: string, data: ArrayBuffer) {
+    const now = Date.now();
+
+    // 检查缓存大小限制
+    let totalSize = 0;
+    for (const value of this.videoCache.values()) {
+      totalSize += value.data.byteLength;
+    }
+
+    // 如果添加这个数据会超过限制，先清理一些缓存
+    if (totalSize + data.byteLength > this.maxCacheSize || this.videoCache.size >= this.maxCacheEntries) {
+      this.cleanupCache();
+
+      // 重新计算大小
+      totalSize = 0;
+      for (const value of this.videoCache.values()) {
+        totalSize += value.data.byteLength;
+      }
+
+      // 如果仍然超过限制，且单个文件太大，不缓存这个数据
+      if (totalSize + data.byteLength > this.maxCacheSize && data.byteLength > this.maxCacheSize * 0.5) {
+        (window as any).avatarSDKLogger.warn(this.TAG, `视频文件过大(${(data.byteLength / 1024 / 1024).toFixed(2)}MB)，跳过缓存: ${key}`);
+        return;
+      }
+
+      // 如果缓存空间仍然不足，清理更多缓存
+      if (totalSize + data.byteLength > this.maxCacheSize) {
+        // 强制清理到50%容量
+        const targetSize = this.maxCacheSize * 0.5;
+        const sortedEntries = Array.from(this.videoCache.entries())
+          .sort((a, b) => a[1].lastAccessTime - b[1].lastAccessTime);
+
+        for (const [cacheKey, cacheValue] of sortedEntries) {
+          if (totalSize <= targetSize) break;
+          this.videoCache.delete(cacheKey);
+          totalSize -= cacheValue.data.byteLength;
+        }
+      }
+    }
+
+    // 添加到缓存
+    this.videoCache.set(key, {
+      data: data,
+      lastAccessTime: now,
+      accessCount: 1
+    });
+  }
+
+  /**
+   * 启动缓存清理定时器
+   */
+  private startCacheCleanup() {
+    // 每5分钟清理一次缓存
+    this.cacheCleanupInterval = setInterval(() => {
+      this.cleanupCache();
+    }, 5 * 60 * 1000);
+  }
+
+  /**
+   * 清理缓存
+   */
+  private cleanupCache() {
+    // 如果正在处理视频，跳过清理
+    if (this.isProcessingVideo) {
+      return;
+    }
+
+    const now = Date.now();
+    const inactiveThreshold = 10 * 60 * 1000; // 10分钟不活跃的缓存将被清理
+
+    // 按最后访问时间排序
+    const sortedEntries = Array.from(this.videoCache.entries())
+      .sort((a, b) => a[1].lastAccessTime - b[1].lastAccessTime);
+
+    let totalSize = 0;
+    const entriesToRemove: string[] = [];
+
+    // 计算当前缓存总大小
+    for (const [_, value] of this.videoCache.entries()) {
+      totalSize += value.data.byteLength;
+    }
+
+
+    // 清理不活跃的缓存（但保留最近访问的）
+    for (const [key, value] of sortedEntries) {
+      if (now - value.lastAccessTime > inactiveThreshold) {
+        entriesToRemove.push(key);
+        totalSize -= value.data.byteLength;
+      }
+    }
+
+    // 如果缓存仍然过大，清理最旧的条目（但至少保留2个条目）
+    if (totalSize > this.maxCacheSize || this.videoCache.size > this.maxCacheEntries) {
+      for (const [key, value] of sortedEntries) {
+        if (!entriesToRemove.includes(key)) {
+          entriesToRemove.push(key);
+          totalSize -= value.data.byteLength;
+
+          // 确保至少保留2个缓存条目，防止完全清空
+          if ((this.videoCache.size - entriesToRemove.length <= 2) ||
+            (totalSize <= this.maxCacheSize * 0.8 && this.videoCache.size - entriesToRemove.length <= this.maxCacheEntries * 0.8)) {
+            break;
+          }
+        }
+      }
+    }
+
+    // 执行清理
+    for (const key of entriesToRemove) {
+      this.videoCache.delete(key);
+    }
+  }
+
+  /**
+   * 更新缓存访问信息
+   */
+  private updateCacheAccess(key: string) {
+    const cacheEntry = this.videoCache.get(key);
+    if (cacheEntry) {
+      cacheEntry.lastAccessTime = Date.now();
+      cacheEntry.accessCount++;
+    }
+  }
+
+  /**
+   * 清空所有缓存
+   */
+  clearAllCache() {
+    this.videoCache.clear();
+  }
+
+  /** 获取离线 idle */
+  _getOfflineIdle() {
+    return this.offlineIdle
+  }
+  /** 获取上一次 session_id */
+  _getSessionId() {
+    return this.session_id || ''
+  }
+
+  /** 离线重连 */
+  async _reload() {
+    const result = await this.startSession();
+    if (!result) {
+      return null;
+    }
+    const res = result as unknown as ISessionResponse;
+    this.session_id = res?.session_id;
+    this.resource_pack = res.resource_pack;
+    this.config = res.config as any;
+    this.offlineIdle = res.resource_pack?.offline_idle || []
+    if (this.resource_pack) {
+      this.getBackgroundImage();
+    }
+    return res;
+  }
+
+  public async _setOfflineCache() {
+    if (!this.offlineIdle || this.offlineIdle.length === 0) {
+      return
+    }
+    this.offlineCache.clear()
+    const names = this.offlineIdle.map($i => $i.n)
+    for (const name of names) {
+      try {
+        await this._runOfflineCache(name)
+      } catch (error) {
+      }
+    }
+  }
+  private async _runOfflineCache(name: string) {
+    const url = this.getVideoUrl(name)
+    if (!url) {
+      return;
+    }
+    return this._fetchVideo(url)
+      .then(({ arrayBuffer }) => {
+        this.offlineCache.set(name, {
+          data: arrayBuffer,
+        })
+      })
+  }
+
+  /**
+   * 销毁资源管理器
+   */
+  destroy() {
+    this.destroyed = true;
+    // 清理定时器
+    if (this.cacheCleanupInterval) {
+      clearInterval(this.cacheCleanupInterval);
+      this.cacheCleanupInterval = null;
+    }
+
+    // 清理缓存
+    this.clearAllCache();
+
+    // 清理下载跟踪
+    this.downloadingVideos.clear();
+
+    // 清理背景图片
+    if (this.bg) {
+      this.bg = null;
+    }
+    this.progress = 0
+  }
+}