@ives_xxz/framework 1.4.12 → 1.4.14

package/FW.d.ts

@@ -35,6 +35,7 @@ declare namespace FW {
     taskMgr: TaskManager;
     hotUpdateMgr: HotUpdateManager;
     promiseMgr: PromiseManager;
+    performanceMgr: PerformanceManager;
     scene: Scene;
     bundleName: string;
     getComponent<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T;
@@ -49,6 +50,8 @@ declare namespace FW {
     onDestroy(): void;
   };
 
+  type Manager = {};
+
   type PromiseManager = {
     execute<T = any>(
       executor: (
@@ -1611,6 +1614,12 @@ declare namespace FW {
     setEffectsMute(mute: boolean): void;
   };
 
+  type PerformanceManager = {
+    recordOperationMetric(manager: string, operation: string, duration: number): void;
+    getManagerReport(manager: string): PerformanceReport;
+    getAllReports(): Map<string, FW.PerformanceReport>;
+  };
+
   type Object = {
     /** 是否已经初始化 */
     initialize: boolean;
@@ -1779,7 +1788,7 @@ declare namespace FW {
    */
   type TaskFunction = () => TaskGenerator;
 
-  type PerformanceReport = {
+  type TaskPerformanceReport = {
     startTime: string;
     endTime: string;
     totalTasks: number;
@@ -1833,7 +1842,7 @@ declare namespace FW {
     /**
      * 获取任务性能报告
      */
-    getPerformanceReport(): PerformanceReport;
+    getPerformanceReport(): TaskPerformanceReport;
   };
 
   type FrameDetail = {
@@ -1928,6 +1937,49 @@ declare namespace FW {
 
   type PromiseStatus = 'pending' | 'fulfilled' | 'rejected' | 'cancelled';
 
+  /**
+   * 性能管理器配置
+   */
+  type PerformanceManagerOptions = {
+    /** 是否自动收集性能数据 */
+    autoCollect?: boolean;
+    /** 性能数据保留时间（毫秒） */
+    dataRetentionTime?: number;
+    /** 采样率（0-1） */
+    samplingRate?: number;
+    /** 性能警告阈值（毫秒） */
+    warningThreshold?: number;
+  };
+
+  /**
+   * 性能统计报告
+   */
+  type PerformanceReport = {
+    manager: string;
+    totalOperations: number;
+    averageDuration: number;
+    minDuration: number;
+    maxDuration: number;
+    recentMetrics: FWPerformanceMetric[];
+  };
+
+  /**
+   * 性能指标数据
+   */
+  type PerformanceMetric = {
+    manager: string;
+    operation: string;
+    duration: number;
+    timestamp: number;
+  };
+
+  type ManagerOptions = {
+    /** 是否启用调试日志 */
+    debug?: boolean;
+    /** 管理器名称（默认使用类名） */
+    name?: string;
+  };
+
   declare function timeScale(scale: number);
   declare let Entry: Entry;
 }

package/entry/FWEntry.ts

@@ -19,6 +19,7 @@ import FWTaskManager from '../manager/FWTaskManager';
 import FWEngineManager from '../manager/FWEngineManager';
 import FWHotUpdateManager from '../manager/FWHotUpdateManager';
 import FWPromiseManager from '../manager/FWPromiseManager';
+import { FWPerformanceManager } from '../manager/FWPerformanceManager';
 
 /**
  * 入口脚本
@@ -89,6 +90,10 @@ export default class FWEntry implements FW.Entry {
    * promise管理器
    */
   promiseMgr: FW.PromiseManager;
+  /**
+   * 性能管理器
+   */
+  performanceMgr: FW.PerformanceManager;
   /**
    * 当前Scene
    */
@@ -119,7 +124,7 @@ export default class FWEntry implements FW.Entry {
     this.languageMgr = new FWLanguageManager();
     this.hotUpdateMgr = new FWHotUpdateManager();
     this.promiseMgr = new FWPromiseManager();
-
+    this.performanceMgr = new FWPerformanceManager();
     this.resMgr.initialize();
     this.layerMgr.initialize();
     this.timeMgr.initialize();

package/manager/FWAssetManager.ts

@@ -131,43 +131,46 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
 
     assetData.loaded = false;
 
-    return FW.Entry.promiseMgr.execute(
-      (resolve, reject, signal) => {
-        const self = this;
-        bundle.load(
-          path,
-          type,
-          (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
-            progress?.(finish, total, item);
-          },
-          (err: Error, asset: cc.Asset) => {
-            if (err || !asset) {
-              reject(err);
-              return;
-            }
-
-            assetData.loaded = true;
-            assetData.dependentBundle = bundleName;
-            assetData.uuid = asset['_uuid'];
-            assetData.autoRelease = autoRelease;
-            assetData.asset = asset;
-            assetData.user = assetProperty.user;
-            assetData.refCount = 1;
-            assetData.assetProperty = assetProperty;
-
-            self.assetsMap.set(key, assetData);
-
-            cb?.(assetData);
-            resolve(assetData);
-          },
-        );
-      },
-      {
-        retryCount: 3,
-        retryInterval: 1,
-        timeout: 10,
-      },
-    ).promise;
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute(
+        (resolve, reject, signal) => {
+          const self = this;
+
+          bundle.load(
+            path,
+            type,
+            (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
+              progress?.(finish, total, item);
+            },
+            (err: Error, asset: cc.Asset) => {
+              if (err || !asset) {
+                reject(err);
+                return;
+              }
+              assetData.loaded = true;
+              assetData.dependentBundle = bundleName;
+              assetData.uuid = asset['_uuid'];
+              assetData.autoRelease = autoRelease;
+              assetData.asset = asset;
+              assetData.user = assetProperty.user;
+              assetData.refCount = 1;
+              assetData.assetProperty = assetProperty;
+
+              self.assetsMap.set(key, assetData);
+
+              cb?.(assetData);
+              resolve(assetData);
+            },
+          );
+        },
+        {
+          retryCount: 3,
+          retryInterval: 1,
+          timeout: 10,
+        },
+      ).promise,
+      `loadAssets -> ${assetProperty.path}`,
+    );
   }
   /**
    * 加载文件夹

package/manager/FWEngineManager.ts

@@ -3,7 +3,8 @@ import FWLog from '../log/FWLog';
 import { FWManager } from './FWManager';
 
 export default class FWEngineManager extends FWManager implements FW.EngineManager {
-  debug: boolean = CC_DEBUG;
+  debug: boolean = false;
+
   initialize() {
     this.registerCCCSystemEvent();
   }

package/manager/FWLayerManager.ts

@@ -7,6 +7,218 @@ import { FWQueue } from '../utils/FWQueue';
 
 const ADD_EXTERNAL_REFERENCE: string = 'addExternalReference';
 
+export class FWLayerManager extends FWManager implements FW.LayerManager {
+  private resourceManager: FWLayerResourceManager;
+  private dataManager: FWLayerDataManager;
+  private createManager: FWLayerCreateManager;
+  private stackManager: FWLayerStackManager;
+  private stateManager: FWLayerStateManager;
+  private queueManager: FWLayerQueueManager;
+  private openManager: FWLayerOpenManager;
+
+  public initialize(): void {
+    this.resourceManager = new FWLayerResourceManager();
+    this.dataManager = new FWLayerDataManager();
+    this.createManager = new FWLayerCreateManager();
+    this.stackManager = new FWLayerStackManager();
+    this.stateManager = new FWLayerStateManager();
+    this.queueManager = new FWLayerQueueManager();
+
+    this.openManager = new FWLayerOpenManager(
+      this.dataManager,
+      this.resourceManager,
+      this.createManager,
+      this.stackManager,
+      this.queueManager,
+    );
+  }
+
+  /**
+   * 异步打开Layer
+   */
+  async openAsync<Ctr extends FW.LayerController = FW.LayerController>(
+    data: FW.LayerOpenArgs,
+  ): Promise<Ctr> {
+    return this.openManager.openLayerAsync(data) as Promise<Ctr>;
+  }
+
+  /**
+   * 同步打开
+   */
+  openSync<Ctr extends FW.LayerController = FW.LayerController>(data: FW.LayerOpenArgs): Ctr {
+    return this.openManager.openLayerSync(data) as unknown as Ctr;
+  }
+
+  /**
+   * 显示layer并恢复所有节点事件
+   */
+  displayLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
+    const layerData = ctr.layerData;
+
+    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
+      FWLog.warn(`display layer failed,layer name : ${layerData.layerName}`);
+      return;
+    }
+    /** 非常驻layer不允许操作透明度显示 */
+    if (ctr.layerType != FWSystemDefine.FWLayerType.PERMANENT) return;
+
+    const node = ctr.layer.node;
+    node.opacity = 255;
+    node.resumeSystemEvents(true);
+
+    FW.Entry.evtMgr.targetResume(ctr);
+    FW.Entry.timeMgr.resumeSchedule(ctr);
+
+    return ctr;
+  }
+
+  /**
+   * 隐藏layer并隐藏所有节点事件
+   */
+  hideLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
+    const layerData = ctr.layerData;
+    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
+      FWLog.warn(`hide layer failed,layer name : ${layerData.layerName}`);
+      return;
+    }
+
+    /** 非常驻layer不允许操作透明度 */
+    if (ctr.layerType != FWSystemDefine.FWLayerType.PERMANENT) return;
+
+    const node = ctr.layer.node;
+    node.opacity = 0;
+    node.pauseSystemEvents(true);
+    FW.Entry.evtMgr.targetPause(ctr);
+    FW.Entry.timeMgr.pauseSchedule(ctr);
+
+    return ctr;
+  }
+
+  /**
+   * 通过layer名字关闭
+   */
+  closeFromLayerName(name: string | string[]): void {
+    this.dataManager.getLayerMap().forEach((v) => {
+      if (Array.isArray(name)) {
+        name.forEach((n) => {
+          if (n === v.layerName) {
+            this.close(v.controller);
+          }
+        });
+      } else {
+        if (v.layerName == name) {
+          this.close(v.controller);
+        }
+      }
+    });
+  }
+
+  /**
+   * 从栈关闭
+   */
+  closeFromStack(count?: number) {
+    count = count ? count : 1;
+    for (let i = 0; i < count; i++) {
+      let layerData = this.stackManager.pop();
+      let ctr = layerData.controller;
+      if (!this.dataManager.getLayerMap().has(layerData.controllerConstructor)) {
+        return;
+      }
+      if (cc.isValid(ctr.layer?.node)) {
+        ctr.layer.destroy?.();
+        if (ctr.autoRelease) {
+          FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
+        }
+        this.dataManager.notifyExternalRefUpdates(ctr.layerData);
+      }
+      this.dataManager.removeFromMap(layerData.controllerConstructor);
+    }
+  }
+  /**
+   * 移除指定Layer所有子Layer
+   * @param layer
+   * @returns
+   */
+  async removeAllChildren(node: cc.Node) {
+    if (!cc.isValid(node)) return;
+    const layers = node.getComponentsInChildren(FWLayer);
+    layers.forEach((v) => {
+      if (cc.isValid(v?.node)) {
+        v?.ctr?.close();
+      }
+    });
+  }
+
+  /**
+   * 关闭layer
+   */
+  async close<Ctr extends FW.LayerController = FW.LayerController>(
+    ctr: Ctr,
+  ): Promise<FW.LayerController> {
+    if (!ctr) return;
+
+    let layerData = ctr.layerData;
+
+    if (cc.isValid(ctr.layer?.node)) {
+      await ctr.onClose?.();
+      ctr.destroy?.();
+      if (ctr.autoRelease) {
+        FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
+      }
+      this.dataManager.notifyExternalRefUpdates(ctr.layerData);
+    }
+
+    this.dataManager.removeFromMap(layerData.controllerConstructor);
+    this.dataManager.removeFromRegistry(ctr.layerData.controllerConstructor);
+
+    const index = this.stackManager.getStack().findIndex((v) => {
+      v.controller == ctr;
+    });
+    if (index > -1) {
+      this.stackManager.getStack().splice(index, 1);
+    }
+
+    /** 如果队列中还有等待打开的layer */
+    if (!this.queueManager.isEmpty()) {
+      const nextLayerData = this.queueManager.getNextLayer();
+      /** 先尝试同步打开 */
+      const nextLayer = this.openSync({
+        parent: nextLayerData.layerParent,
+        position: nextLayerData.layerPosition,
+        type: nextLayerData.controllerConstructor,
+      });
+      /** 如果同步打开失败,再次尝试异步打开(可能由于资源所在bundle并未提前加载) */
+      if (!nextLayer) {
+        return this.openAsync({
+          parent: nextLayerData.layerParent,
+          position: nextLayerData.layerPosition,
+          type: nextLayerData.controllerConstructor,
+        });
+      } else {
+        return nextLayer;
+      }
+    } else {
+      return undefined;
+    }
+  }
+
+  getLayerMap(): Map<new () => FW.LayerController, FWLayerData> {
+    return this.dataManager.getLayerMap();
+  }
+
+  public clear() {
+    this.queueManager.clear();
+    this.stackManager.clear();
+    this.stateManager.clear();
+    this.dataManager.clear();
+    this.dataManager.getLayerMap().forEach((v) => this.close(v.controller));
+  }
+
+  public onDestroy(): void {
+    this.clear();
+  }
+}
+
 export class FWLayerData<T extends FW.LayerController = FW.LayerController>
   implements FW.LayerData
 {
@@ -240,41 +452,66 @@ class FWLayerOpenManager {
   /**
    * 统一的Layer打开方法
    */
-  async openLayer<Ctr extends FW.LayerController = FW.LayerController>(
+  async openLayerAsync<Ctr extends FW.LayerController = FW.LayerController>(
     data: FW.LayerOpenArgs,
-    isAsync: boolean,
   ): Promise<Ctr> {
     if (!this.validateOpenData(data)) {
-      return this.getUndefinedResult(isAsync);
+      return undefined;
     }
 
     const existingLayer = this.dataManager.getExistingLayer(data.type);
     if (existingLayer) {
-      return this.wrapResult(existingLayer, isAsync) as Ctr;
+      return existingLayer as Ctr;
     }
 
     const layerData = this.dataManager.createLayerData(data.type);
 
     if (!layerData) {
-      return this.getUndefinedResult(isAsync);
+      return undefined;
     }
 
     if (this.dataManager.addRegistry(data.type)) {
       const proxy = this.dataManager.getExistingProxy(data.type);
-      return this.wrapResult(proxy, isAsync) as Ctr;
+      return proxy as Ctr;
     }
 
     if (this.queueManager.handlePopupQueue(layerData, this.dataManager.getLayerMap())) {
-      return this.getUndefinedResult(isAsync);
+      return undefined;
     }
 
     this.dataManager.addLayerData(data.type, layerData);
 
-    if (isAsync) {
-      return this.asyncGenerationLayer(layerData, data);
-    } else {
-      return this.syncGenerationLayer(layerData, data) as Ctr;
+    return this.asyncGenerationLayer(layerData, data);
+  }
+
+  openLayerSync<Ctr extends FW.LayerController = FW.LayerController>(data: FW.LayerOpenArgs): Ctr {
+    if (!this.validateOpenData(data)) {
+      return undefined;
     }
+
+    const existingLayer = this.dataManager.getExistingLayer(data.type);
+    if (existingLayer) {
+      return existingLayer as Ctr;
+    }
+
+    const layerData = this.dataManager.createLayerData(data.type);
+
+    if (!layerData) {
+      return undefined;
+    }
+
+    if (this.dataManager.addRegistry(data.type)) {
+      const proxy = this.dataManager.getExistingProxy(data.type);
+      return proxy as Ctr;
+    }
+
+    if (this.queueManager.handlePopupQueue(layerData, this.dataManager.getLayerMap())) {
+      return undefined;
+    }
+
+    this.dataManager.addLayerData(data.type, layerData);
+
+    return this.syncGenerationLayer(layerData, data);
   }
 
   /**
@@ -311,7 +548,9 @@ class FWLayerOpenManager {
   ): Promise<Ctr> {
     try {
       const res = await this.resourceManager.loadLayerAsync(layerData);
-      return this.createLayer(layerData, res, data) as Ctr;
+      const ctr = this.createLayer(layerData, res, data) as Ctr;
+      this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+      return ctr;
     } catch (e) {
       FWLog.error(`asyncGenerationLayer failed:`, e);
       this.dataManager.clearFailedLayer(layerData);
@@ -328,7 +567,9 @@ class FWLayerOpenManager {
   ): Ctr {
     try {
       const res = this.resourceManager.loadLayerSync(layerData);
-      return this.createLayer(layerData, res, data);
+      const ctr = this.createLayer(layerData, res, data) as Ctr;
+      this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+      return ctr;
     } catch (e) {
       FWLog.error(`syncGenerationLayer failed:`, e);
       this.dataManager.clearFailedLayer(layerData);
@@ -547,215 +788,3 @@ class FWLayerLifecycleManager {
     };
   }
 }
-
-export class FWLayerManager extends FWManager implements FW.LayerManager {
-  private resourceManager: FWLayerResourceManager;
-  private dataManager: FWLayerDataManager;
-  private createManager: FWLayerCreateManager;
-  private stackManager: FWLayerStackManager;
-  private stateManager: FWLayerStateManager;
-  private queueManager: FWLayerQueueManager;
-  private openManager: FWLayerOpenManager;
-
-  public initialize(): void {
-    this.resourceManager = new FWLayerResourceManager();
-    this.dataManager = new FWLayerDataManager();
-    this.createManager = new FWLayerCreateManager();
-    this.stackManager = new FWLayerStackManager();
-    this.stateManager = new FWLayerStateManager();
-    this.queueManager = new FWLayerQueueManager();
-
-    this.openManager = new FWLayerOpenManager(
-      this.dataManager,
-      this.resourceManager,
-      this.createManager,
-      this.stackManager,
-      this.queueManager,
-    );
-  }
-
-  /**
-   * 异步打开Layer
-   */
-  async openAsync<Ctr extends FW.LayerController = FW.LayerController>(
-    data: FW.LayerOpenArgs,
-  ): Promise<Ctr> {
-    return this.openManager.openLayer(data, true) as Promise<Ctr>;
-  }
-
-  /**
-   * 同步打开
-   */
-  openSync<Ctr extends FW.LayerController = FW.LayerController>(data: FW.LayerOpenArgs): Ctr {
-    return this.openManager.openLayer(data, false) as unknown as Ctr;
-  }
-
-  /**
-   * 显示layer并恢复所有节点事件
-   */
-  displayLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
-    const layerData = ctr.layerData;
-
-    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
-      FWLog.warn(`display layer failed,layer name : ${layerData.layerName}`);
-      return;
-    }
-    /** 非常驻layer不允许操作透明度显示 */
-    if (ctr.layerType != FWSystemDefine.FWLayerType.PERMANENT) return;
-
-    const node = ctr.layer.node;
-    node.opacity = 255;
-    node.resumeSystemEvents(true);
-
-    FW.Entry.evtMgr.targetResume(ctr);
-    FW.Entry.timeMgr.resumeSchedule(ctr);
-
-    return ctr;
-  }
-
-  /**
-   * 隐藏layer并隐藏所有节点事件
-   */
-  hideLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
-    const layerData = ctr.layerData;
-    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
-      FWLog.warn(`hide layer failed,layer name : ${layerData.layerName}`);
-      return;
-    }
-
-    /** 非常驻layer不允许操作透明度 */
-    if (ctr.layerType != FWSystemDefine.FWLayerType.PERMANENT) return;
-
-    const node = ctr.layer.node;
-    node.opacity = 0;
-    node.pauseSystemEvents(true);
-    FW.Entry.evtMgr.targetPause(ctr);
-    FW.Entry.timeMgr.pauseSchedule(ctr);
-
-    return ctr;
-  }
-
-  /**
-   * 通过layer名字关闭
-   */
-  closeFromLayerName(name: string | string[]): void {
-    this.dataManager.getLayerMap().forEach((v) => {
-      if (Array.isArray(name)) {
-        name.forEach((n) => {
-          if (n === v.layerName) {
-            this.close(v.controller);
-          }
-        });
-      } else {
-        if (v.layerName == name) {
-          this.close(v.controller);
-        }
-      }
-    });
-  }
-
-  /**
-   * 从栈关闭
-   */
-  closeFromStack(count?: number) {
-    count = count ? count : 1;
-    for (let i = 0; i < count; i++) {
-      let layerData = this.stackManager.pop();
-      let ctr = layerData.controller;
-      if (!this.dataManager.getLayerMap().has(layerData.controllerConstructor)) {
-        return;
-      }
-      if (cc.isValid(ctr.layer?.node)) {
-        ctr.layer.destroy?.();
-        if (ctr.autoRelease) {
-          FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
-        }
-        this.dataManager.notifyExternalRefUpdates(ctr.layerData);
-      }
-      this.dataManager.removeFromMap(layerData.controllerConstructor);
-    }
-  }
-  /**
-   * 移除指定Layer所有子Layer
-   * @param layer
-   * @returns
-   */
-  async removeAllChildren(node: cc.Node) {
-    if (!cc.isValid(node)) return;
-    const layers = node.getComponentsInChildren(FWLayer);
-    layers.forEach((v) => {
-      if (cc.isValid(v?.node)) {
-        v?.ctr?.close();
-      }
-    });
-  }
-
-  /**
-   * 关闭layer
-   */
-  async close<Ctr extends FW.LayerController = FW.LayerController>(
-    ctr: Ctr,
-  ): Promise<FW.LayerController> {
-    if (!ctr) return;
-
-    let layerData = ctr.layerData;
-
-    if (cc.isValid(ctr.layer?.node)) {
-      await ctr.onClose?.();
-      ctr.destroy?.();
-      if (ctr.autoRelease) {
-        FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
-      }
-      this.dataManager.notifyExternalRefUpdates(ctr.layerData);
-    }
-
-    this.dataManager.removeFromMap(layerData.controllerConstructor);
-    this.dataManager.removeFromRegistry(ctr.layerData.controllerConstructor);
-
-    const index = this.stackManager.getStack().findIndex((v) => {
-      v.controller == ctr;
-    });
-    if (index > -1) {
-      this.stackManager.getStack().splice(index, 1);
-    }
-
-    /** 如果队列中还有等待打开的layer */
-    if (!this.queueManager.isEmpty()) {
-      const nextLayerData = this.queueManager.getNextLayer();
-      /** 先尝试同步打开 */
-      const nextLayer = this.openSync({
-        parent: nextLayerData.layerParent,
-        position: nextLayerData.layerPosition,
-        type: nextLayerData.controllerConstructor,
-      });
-      /** 如果同步打开失败,再次尝试异步打开(可能由于资源所在bundle并未提前加载) */
-      if (!nextLayer) {
-        return this.openAsync({
-          parent: nextLayerData.layerParent,
-          position: nextLayerData.layerPosition,
-          type: nextLayerData.controllerConstructor,
-        });
-      } else {
-        return nextLayer;
-      }
-    } else {
-      return undefined;
-    }
-  }
-
-  getLayerMap(): Map<new () => FW.LayerController, FWLayerData> {
-    return this.dataManager.getLayerMap();
-  }
-
-  public clear() {
-    this.queueManager.clear();
-    this.stackManager.clear();
-    this.stateManager.clear();
-    this.dataManager.clear();
-    this.dataManager.getLayerMap().forEach((v) => this.close(v.controller));
-  }
-
-  public onDestroy(): void {
-    this.clear();
-  }
-}

package/manager/FWManager.ts

@@ -1,8 +1,58 @@
-export abstract class FWManager {
+import FWLog from '../log/FWLog';
+
+export abstract class FWManager implements FW.Manager {
   public readonly entry: FW.Entry = FW.Entry;
+  public readonly managerName: string = this.constructor.name;
+
+  public abstract initialize(): void;
+  public abstract onDestroy(): void;
+
   constructor() {
     this.initialize();
   }
-  public abstract initialize(): void;
-  public abstract onDestroy(): void;
+
+  protected async invoke<T>(operation: Promise<T>, operationName: string = 'unknown'): Promise<T> {
+    const startTime = this.getCurrentTime();
+
+    try {
+      const result = await operation;
+      const duration = this.getCurrentTime() - startTime;
+
+      this.recordPerformanceMetric(operationName, duration);
+      return result;
+    } catch (error) {
+      this.handleError(operationName, error);
+      return undefined;
+    }
+  }
+
+  private recordPerformanceMetric(operationName: string, duration: number): void {
+    if (FW.Entry.performanceMgr) {
+      FW.Entry.performanceMgr.recordOperationMetric(this.managerName, operationName, duration);
+    }
+
+    if (duration > 1000) {
+      FWLog.warn(`Operation ${operationName} took ${duration}ms`);
+    } else if (FW.Entry.engineMgr.debug) {
+      FWLog.debug(`Operation ${operationName} took ${duration}ms`);
+    }
+  }
+
+  protected handleError(operation: string, error: any): void {
+    const errorInfo = {
+      manager: this.managerName,
+      operation,
+      error: error?.message || error,
+      stack: error?.stack,
+    };
+
+    FWLog.error(`Manager error in ${this.managerName}.${operation}:`, errorInfo);
+
+    if (CC_DEBUG && FW.Entry.engineMgr.debug) {
+    }
+  }
+
+  protected getCurrentTime(): number {
+    return Date.now();
+  }
 }

package/manager/FWPerformanceManager.ts

@@ -0,0 +1,206 @@
+// FWPerformanceManager.ts
+
+import FWLog from '../log/FWLog';
+import { FWManager } from './FWManager';
+
+/**
+ * 性能管理器
+ */
+export class FWPerformanceManager extends FWManager implements FW.PerformanceManager {
+  private metrics: FW.PerformanceMetric[] = [];
+  private managerStats: Map<
+    string,
+    {
+      totalDuration: number;
+      operationCount: number;
+      minDuration: number;
+      maxDuration: number;
+    }
+  > = new Map();
+
+  private performanceOptions: FW.PerformanceManagerOptions;
+
+  constructor() {
+    super();
+
+    this.performanceOptions = {
+      autoCollect: true,
+      dataRetentionTime: 5 * 60 * 1000,
+      samplingRate: 1.0,
+      warningThreshold: 1000,
+    };
+  }
+
+  public async initialize(): Promise<void> {
+    if (this.performanceOptions.autoCollect) {
+      this.startAutoCleanup();
+    }
+  }
+
+  public onDestroy(): void {
+    this.metrics = [];
+    this.managerStats.clear();
+  }
+
+  protected onCleanup(): void {}
+
+  /**
+   * 记录操作性能指标
+   */
+  public recordOperationMetric(manager: string, operation: string, duration: number): void {
+    if (Math.random() > this.performanceOptions.samplingRate!) {
+      return;
+    }
+    const metric: FW.PerformanceMetric = {
+      manager,
+      operation,
+      duration,
+      timestamp: Date.now(),
+    };
+
+    this.metrics.push(metric);
+    this.updateManagerStats(manager, duration);
+
+    if (duration > this.performanceOptions.warningThreshold!) {
+      FWLog.warn(`Performance warning: ${manager}.${operation} took ${duration}ms`);
+    }
+  }
+
+  /**
+   * 获取指定管理器的性能报告
+   */
+  public getManagerReport(manager: string): FW.PerformanceReport | null {
+    const stats = this.managerStats.get(manager);
+    if (!stats) {
+      return null;
+    }
+
+    const recentMetrics = this.metrics.filter((m) => m.manager === manager).slice(-500);
+
+    return {
+      manager,
+      totalOperations: stats.operationCount,
+      averageDuration: stats.totalDuration / stats.operationCount,
+      minDuration: stats.minDuration,
+      maxDuration: stats.maxDuration,
+      recentMetrics,
+    };
+  }
+
+  /**
+   * 获取所有管理器的性能报告
+   */
+  public getAllReports(): Map<string, FW.PerformanceReport> {
+    const reports = new Map<string, FW.PerformanceReport>();
+
+    this.managerStats.forEach((stats, manager) => {
+      const recentMetrics = this.metrics.filter((m) => m.manager === manager).slice(-500);
+      reports.set(manager, {
+        manager,
+        totalOperations: stats.operationCount,
+        averageDuration: stats.totalDuration / stats.operationCount,
+        minDuration: stats.minDuration,
+        maxDuration: stats.maxDuration,
+        recentMetrics,
+      });
+    });
+
+    return reports;
+  }
+
+  /**
+   * 获取性能摘要
+   */
+  public getPerformanceSummary(): {
+    totalOperations: number;
+    averageOperationTime: number;
+    slowestManager: string;
+    mostActiveManager: string;
+  } {
+    let totalOperations = 0;
+    let totalDuration = 0;
+    let slowestManager = '';
+    let maxAvgDuration = 0;
+    let mostActiveManager = '';
+    let maxOperations = 0;
+
+    this.managerStats.forEach((stats, manager) => {
+      totalOperations += stats.operationCount;
+      totalDuration += stats.totalDuration;
+
+      const avgDuration = stats.totalDuration / stats.operationCount;
+      if (avgDuration > maxAvgDuration) {
+        maxAvgDuration = avgDuration;
+        slowestManager = manager;
+      }
+
+      if (stats.operationCount > maxOperations) {
+        maxOperations = stats.operationCount;
+        mostActiveManager = manager;
+      }
+    });
+
+    return {
+      totalOperations,
+      averageOperationTime: totalOperations > 0 ? totalDuration / totalOperations : 0,
+      slowestManager,
+      mostActiveManager,
+    };
+  }
+
+  /**
+   * 清理数据
+   */
+  public clearPerformanceData(
+    retentionTime: number = this.performanceOptions.dataRetentionTime!,
+  ): number {
+    const cutoffTime = Date.now() - retentionTime;
+    const initialLength = this.metrics.length;
+
+    this.metrics = this.metrics.filter((metric) => metric.timestamp > cutoffTime);
+
+    const removedCount = initialLength - this.metrics.length;
+    if (removedCount > 0) {
+      FWLog.debug(`Cleaned up ${removedCount} old performance records`);
+    }
+
+    return removedCount;
+  }
+
+  /**
+   * 重置所有性能数据
+   */
+  public resetAllData(): void {
+    this.metrics = [];
+    this.managerStats.clear();
+  }
+
+  /**
+   * 更新管理器统计信息
+   */
+  private updateManagerStats(manager: string, duration: number): void {
+    if (!this.managerStats.has(manager)) {
+      this.managerStats.set(manager, {
+        totalDuration: 0,
+        operationCount: 0,
+        minDuration: Infinity,
+        maxDuration: -Infinity,
+      });
+    }
+
+    const stats = this.managerStats.get(manager)!;
+    stats.totalDuration += duration;
+    stats.operationCount++;
+    stats.minDuration = Math.min(stats.minDuration, duration);
+    stats.maxDuration = Math.max(stats.maxDuration, duration);
+  }
+
+  /**
+   * 启动自动清理任务
+   */
+  private startAutoCleanup(): void {
+    FW.Entry.timeMgr.schedule(() => {
+      this.clearPerformanceData();
+    }, 300);
+  }
+}

package/manager/FWPerformanceManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "a593b057-a7d5-4dd4-ac81-3c8a70694bd2",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ives_xxz/framework",
-  "version": "1.4.12",
+  "version": "1.4.14",
   "description": "cocoscreator 2.x mvc framework",
   "main": "index.js",
   "keywords": ["123456"],

package/service/FWService.ts

@@ -1,7 +1,54 @@
+import FWLog from '../log/FWLog';
+
 export default abstract class FWService {
   constructor() {
     this.initialize();
   }
   public abstract initialize(): void;
   public abstract destroy(): void;
+  public abstract readonly serviceName: string;
+
+  protected async invoke<T>(operation: Promise<T>, operationName: string = 'unknown'): Promise<T> {
+    const startTime = this.getCurrentTime();
+
+    try {
+      const result = await operation;
+      const duration = this.getCurrentTime() - startTime;
+
+      this.recordPerformanceMetric(operationName, duration);
+      return result;
+    } catch (error) {
+      this.handleError(operationName, error);
+      return undefined;
+    }
+  }
+
+  private recordPerformanceMetric(operationName: string, duration: number): void {
+    if (FW.Entry.performanceMgr) {
+      FW.Entry.performanceMgr.recordOperationMetric(this.serviceName, operationName, duration);
+    }
+
+    if (FW.Entry.engineMgr.debug) {
+      const log = duration > 1000 ? FWLog.warn : FWLog.debug;
+      log(`Operation ${operationName} took ${duration}ms`);
+    }
+  }
+
+  protected getCurrentTime(): number {
+    return Date.now();
+  }
+
+  protected handleError(operation: string, error: any): void {
+    const errorInfo = {
+      manager: this.serviceName,
+      operation,
+      error: error?.message || error,
+      stack: error?.stack,
+    };
+
+    FWLog.error(`Manager error in ${this.serviceName}.${operation}:`, errorInfo);
+
+    if (FW.Entry.engineMgr.debug) {
+    }
+  }
 }

package/service/http/FWHttp.ts

@@ -3,6 +3,7 @@ import FWLog from '../../log/FWLog';
 import FWService from '../FWService';
 
 export default class FWHttp extends FWService {
+  public serviceName: string = 'HTTP';
   public initialize(): void {}
   public destroy(): void {}
 
@@ -10,47 +11,62 @@ export default class FWHttp extends FWService {
     url: string,
     params?: string,
     cb?: (response: string) => void,
+    tag?: string,
   ): Promise<string> {
-    return this.dataProcessing(url, params, cb, FWSystemDefine.FWHttpRequestType.GET);
+    return this.dataProcessing(url, params, cb, tag, FWSystemDefine.FWHttpRequestType.GET);
   }
 
   protected async postMessage(
     url: string,
     params?: string,
     cb?: (response: string) => void,
+    tag?: string,
   ): Promise<string> {
-    return this.dataProcessing(url, params, cb, FWSystemDefine.FWHttpRequestType.POST);
+    return this.dataProcessing(url, params, cb, tag, FWSystemDefine.FWHttpRequestType.POST);
   }
 
-  private dataProcessing(
+  private async dataProcessing(
     url: string,
     params: string,
     cb: (response: any) => void,
+    tag: string,
     type: FWSystemDefine.FWHttpRequestType,
   ): Promise<string> {
-    return new Promise((resolve: (msg: string) => void, reject: (error: string) => void) => {
-      const xhr = new XMLHttpRequest();
-      xhr.onreadystatechange = () => {
-        if (xhr.readyState == 4 && xhr.status === 200) {
-          cb?.(xhr.response);
-          resolve(xhr.response);
-        }
-      };
-
-      xhr.onerror = (err: any) => {
-        FWLog.error(err);
-        this.onError(err);
-        reject(`http request error:${err}`);
-      };
-
-      xhr.ontimeout = () => {
-        this.onTimeout();
-        reject(`http request timeout!`);
-      };
-
-      xhr.open(type, url, true);
-      xhr.send(params);
-    });
+    let xhr: XMLHttpRequest;
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute<string>(
+        (resolve, reject) => {
+          xhr = new XMLHttpRequest();
+          xhr.onreadystatechange = () => {
+            if (xhr.readyState == 4 && xhr.status === 200) {
+              cb?.(xhr.response);
+              resolve(xhr.response);
+            }
+          };
+
+          xhr.onerror = (err: any) => {
+            FWLog.error(err);
+            this.onError(err);
+            reject(`http request error:${err}`);
+          };
+
+          xhr.ontimeout = () => {
+            this.onTimeout();
+            reject(`http request timeout!`);
+          };
+
+          xhr.open(type, url, true);
+          xhr.send(params);
+        },
+        {
+          retryCount: 3,
+          retryCondition(error, retryCount) {
+            return xhr.readyState != 4 || (xhr.status !== 200 && retryCount < 3);
+          },
+        },
+      ).promise,
+      tag ? `http request ->${tag}` : '',
+    );
   }
 
   onError?(err: any);

package/utils/FWTask.ts

@@ -182,7 +182,7 @@ export default class FWTask implements FW.Task {
     requestAnimationFrame(async () => await this.executeFrame());
   }
 
-  getPerformanceReport(): FW.PerformanceReport {
+  getPerformanceReport(): FW.TaskPerformanceReport {
     const frameTimes = this.performanceData.frameTimes;
     const avgFrameTime = frameTimes.reduce((sum, t) => sum + t, 0) / frameTimes.length || 0;