@ives_xxz/framework 1.4.15 → 1.5.0

package/manager/FWBundleManager.ts

@@ -1,6 +1,7 @@
 import { FWManager } from './FWManager';
 import FWLog from '../log/FWLog';
 import Framework from '../Framework';
+import { FWSystemConfig } from '../config/FWSystemConfig';
 
 export class FWBundleManager extends FWManager implements FW.BundleManager {
   bundleMap: Map<string, cc.AssetManager.Bundle>;
@@ -31,11 +32,8 @@ export class FWBundleManager extends FWManager implements FW.BundleManager {
     if (!bundleName) return;
     if (this.bundleMap.has(bundleName)) return this.bundleMap.get(bundleName);
 
-    return new Promise(
-      (
-        resolve: (value: cc.AssetManager.Bundle | PromiseLike<cc.AssetManager.Bundle>) => void,
-        reject: (reason?: any) => void,
-      ) => {
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
         const remote = this.remoteBundleConfigMap.get(bundleName);
         const url = remote ? remote.url : '';
         const path = `${url}${bundleName}`;
@@ -54,7 +52,8 @@ export class FWBundleManager extends FWManager implements FW.BundleManager {
             resolve(bundle);
           },
         );
-      },
+      }, FWSystemConfig.PromiseConfig.loadBundle).promise,
+      `loadBundle -> ${bundleName}`,
     );
   }
 
@@ -93,7 +92,7 @@ export class FWBundleManager extends FWManager implements FW.BundleManager {
 
   public onDestroy(): void {
     this.bundleMap.forEach((bundle) => {
-      this.release(bundle.name);
+      cc.assetManager.removeBundle(bundle);
     });
     this.bundleMap.clear();
   }

package/manager/FWEngineManager.ts

@@ -1,4 +1,6 @@
+import { FWEventDefine } from '../define/FWEventDefine';
 import { FWSystemDefine } from '../define/FWSystemDefine';
+import Framework from '../Framework';
 import FWLog from '../log/FWLog';
 import { FWManager } from './FWManager';
 
@@ -14,6 +16,12 @@ export default class FWEngineManager extends FWManager implements FW.EngineManag
     cc.game.off(cc.game.EVENT_HIDE, this.onAppHide, this);
   }
 
+  restart() {
+    FW.Entry.evtMgr.dispatch(FWEventDefine.SystemEvent.SYSTEM_RESTART);
+    Framework.restart();
+    cc.game.restart();
+  }
+
   getMemory() {
     if (!this.debug) return;
     if (window.performance && window.performance['memory']) {

package/manager/FWEventManager.ts

@@ -18,6 +18,7 @@ class FWObserver implements FW.Observer {
     private readonly target: FW.TargetType,
     public readonly priority: number,
     public readonly intercept: boolean,
+    public readonly once: boolean = false,
   ) {
     this.cb = cb;
     this.target = target;
@@ -55,6 +56,7 @@ class FWObserver implements FW.Observer {
       args10,
     );
   }
+
   /**
    * 目标比较
    * @param target 目标对象
@@ -115,14 +117,31 @@ export default class FWEventManager implements FW.EventManager {
   ) {
     const observers = this.listeners[eventName];
     if (!observers) return;
+
     let shouldStopPropagation = false;
-    for (const observer of observers) {
+    const observersToRemove: FW.Observer[] = [];
+
+    const observersCopy = [...observers];
+
+    for (const observer of observersCopy) {
       if (shouldStopPropagation) break;
+
+      if (observers.indexOf(observer) === -1) continue;
+
       observer.notify(args1, args2, args3, args4, args5, args6, args7, args8, args9, args10);
+
+      if (observer.once) {
+        observersToRemove.push(observer);
+      }
+
       if (observer.intercept) {
         shouldStopPropagation = true;
       }
     }
+
+    if (observersToRemove.length > 0) {
+      this.removeObservers(eventName, observersToRemove);
+    }
   }
 
   /**
@@ -149,20 +168,26 @@ export default class FWEventManager implements FW.EventManager {
     options?: {
       priority?: FWSystemDefine.FWPriorityOrder;
       intercept?: boolean;
+      once?: boolean;
     },
   ) {
     const observers = this.listeners[eventName];
     const define = FWSystemDefine.FWPriorityOrder;
     const priority = options?.priority === undefined ? define.NORMAL : options.priority;
     const intercept = options?.intercept === undefined ? false : options.intercept;
-    const observer = new FWObserver(eventName, cb, target, priority, intercept);
+    const once = options?.once === undefined ? false : options.once;
+
+    const observer = new FWObserver(eventName, cb, target, priority, intercept, once);
+
     if (!observers) {
       this.listeners[eventName] = [];
     }
+
     const order = Object.values(define);
     const insertIndex = this.listeners[eventName].findIndex(
       (o) => order[o.priority] > order[priority],
     );
+
     if (insertIndex === -1) {
       this.listeners[eventName].push(observer);
     } else {
@@ -170,6 +195,39 @@ export default class FWEventManager implements FW.EventManager {
     }
   }
 
+  /**
+   * 注册一次性事件
+   * @param eventName 事件名
+   * @param cb 回调函数
+   * @param target 事件回调绑定目标
+   * @param options 选项
+   */
+  public registerOnce(
+    eventName: string | number,
+    cb: (
+      args1?: FW.EventManagerArgs,
+      args2?: FW.EventManagerArgs,
+      args3?: FW.EventManagerArgs,
+      args4?: FW.EventManagerArgs,
+      args5?: FW.EventManagerArgs,
+      args6?: FW.EventManagerArgs,
+      args7?: FW.EventManagerArgs,
+      args8?: FW.EventManagerArgs,
+      args9?: FW.EventManagerArgs,
+      args10?: FW.EventManagerArgs,
+    ) => void,
+    target: FW.TargetType,
+    options?: {
+      priority?: FWSystemDefine.FWPriorityOrder;
+      intercept?: boolean;
+    },
+  ) {
+    this.register(eventName, cb, target, {
+      ...options,
+      once: true, // 强制设置为一次性事件
+    });
+  }
+
   /**
    * 注销事件
    * @param eventName
@@ -268,6 +326,37 @@ export default class FWEventManager implements FW.EventManager {
     });
   }
 
+  /**
+   * 移除指定的观察者列表
+   * @param eventName 事件名
+   * @param observersToRemove 待移除的观察者列表
+   */
+  private removeObservers(eventName: string | number, observersToRemove: FW.Observer[]): void {
+    const observers = this.listeners[eventName];
+    if (!observers) return;
+
+    for (const observerToRemove of observersToRemove) {
+      const index = observers.indexOf(observerToRemove);
+      if (index !== -1) {
+        observers.splice(index, 1);
+      }
+    }
+
+    if (observers.length === 0) {
+      delete this.listeners[eventName];
+    }
+  }
+
+  /**
+   * 获取事件监听器数量
+   * @param eventName 事件名
+   * @returns 监听器数量
+   */
+  public getListenerCount(eventName: string | number): number {
+    const observers = this.listeners[eventName];
+    return observers ? observers.length : 0;
+  }
+
   /** 销毁 */
   public onDestroy(): void {
     this.listeners = cc.js.createMap();

package/manager/FWLayerManager.ts

@@ -168,8 +168,8 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
       this.dataManager.notifyExternalRefUpdates(ctr.layerData);
     }
 
-    this.dataManager.removeFromMap(layerData.controllerConstructor);
-    this.dataManager.removeFromRegistry(ctr.layerData.controllerConstructor);
+    this.dataManager.removeFromMap(layerData?.controllerConstructor);
+    this.dataManager.removeFromRegistry(ctr.layerData?.controllerConstructor);
 
     const index = this.stackManager.getStack().findIndex((v) => {
       v.controller == ctr;

package/manager/FWManager.ts

@@ -1,58 +1,11 @@
-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;
+import { FrameworkBase } from '../FrameworkBase';
 
+export abstract class FWManager extends FrameworkBase implements FW.Manager {
   public abstract initialize(): void;
   public abstract onDestroy(): void;
 
-  constructor() {
+  protected onRestart() {
+    this.onDestroy();
     this.initialize();
   }
-
-  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/FWObjectManager.ts

@@ -1,17 +1,29 @@
 import { FWSystemDefine } from '../define/FWSystemDefine';
-import Framework from '../Framework';
 import FWObject from '../utils/FWObject';
 import { FWObjectPool } from '../utils/FWObjectPool';
 import { FWManager } from './FWManager';
+import FWLog from '../log/FWLog';
 
 export default class FWObjectManager extends FWManager implements FW.ObjectManager {
   public initialize(): void {
     this.poolMap = new Map<string, FWObjectPool>();
+    this.poolIdCounter = 0;
   }
-  public onDestroy(): void {}
+
+  public onDestroy(): void {
+    this.poolMap.forEach((pool, tag) => {
+      try {
+        pool.onDestroy();
+      } catch (error) {
+        FWLog.error(`销毁对象池失败: ${tag}`, error);
+      }
+    });
+    this.poolMap.clear();
+  }
+
   private poolMap: Map<string, FWObjectPool>;
+  private poolIdCounter: number = 0;
 
-  /** 创建一个对象池 */
   async createObjectPool<T extends FWObject = FWObject>(
     node: cc.Node,
     parent: cc.Node,
@@ -43,49 +55,104 @@ export default class FWObjectManager extends FWManager implements FW.ObjectManag
     type?: number,
   ): Promise<FWObjectPool>;
   async createObjectPool<T extends FWObject = FWObject>(): Promise<FWObjectPool> {
+    if (arguments.length < 2 || arguments.length > 3) {
+      FWLog.error('createObjectPool 参数数量错误,需要2-3个参数');
+      throw new Error('Invalid arguments count');
+    }
+
     let objectNode: cc.Node = null;
     let objectPrefab: cc.Prefab = null;
     let objectAssetProperty: FW.AssetProperty = null;
     let objectParent: cc.Node;
     let objectTag: string;
     let objectType: FWSystemDefine.FWObjectType;
-    if (arguments.length > 3) return;
-    if (arguments[0] instanceof cc.Node) {
-      objectNode = arguments[0];
-    } else if (arguments[0] instanceof cc.Prefab) {
-      objectPrefab = arguments[0];
-      objectNode = cc.instantiate(objectPrefab);
-    } else {
-      objectAssetProperty = arguments[0];
-      objectPrefab = await FW.Entry.resMgr.loadAsset<cc.Prefab>(objectAssetProperty);
-      objectNode = cc.instantiate(objectPrefab);
-    }
-    objectParent = arguments[1];
-    if (arguments[2] && typeof arguments[2] === 'string') {
-      objectTag = arguments[2];
-      objectType = FWSystemDefine.FWObjectType.OPACITY;
-    } else {
-      objectTag = this.poolMap.size?.toString() || '';
-      objectType = arguments[2];
-    }
 
-    const pool = new FWObjectPool<T>(objectNode, objectParent, objectType);
+    try {
+      const resources = arguments[0];
+      if (resources instanceof cc.Node) {
+        objectNode = resources;
+      } else if (resources instanceof cc.Prefab) {
+        objectPrefab = resources;
+        objectNode = cc.instantiate(objectPrefab);
+      } else {
+        objectAssetProperty = resources;
+        objectPrefab = await FW.Entry.resMgr.loadAsset<cc.Prefab>(objectAssetProperty);
+        if (!objectPrefab) {
+          throw new Error(`加载预制体失败: ${objectAssetProperty.path}`);
+        }
+        objectNode = cc.instantiate(objectPrefab);
+      }
+
+      objectParent = arguments[1];
+      if (!(objectParent instanceof cc.Node)) {
+        throw new Error('第二个参数必须是 cc.Node 类型');
+      }
+
+      const arg = arguments[2];
+      if (typeof arg === 'string') {
+        objectTag = arg;
+        objectType = FWSystemDefine.FWObjectType.OPACITY;
+      } else if (typeof arg === 'number') {
+        objectTag = `pool_${this.poolIdCounter++}`;
+        objectType = arg;
+      } else {
+        objectTag = `pool_${this.poolIdCounter++}`;
+        objectType = FWSystemDefine.FWObjectType.OPACITY;
+      }
+
+      if (this.poolMap.has(objectTag)) {
+        this.destroyObjectPool(objectTag);
+      }
+
+      const pool = new FWObjectPool<T>(objectNode, objectParent, objectType);
+      this.poolMap.set(objectTag, pool);
 
-    this.poolMap.set(objectTag, pool);
+      return pool;
+    } catch (error) {
+      FWLog.error('创建对象池失败:', error);
 
-    return pool;
+      if (objectNode && objectNode.isValid) {
+        objectNode.destroy();
+      }
+
+      throw error;
+    }
   }
 
-  /** 获取已经创建的对象池 */
-  getObjectPool(tag: string) {
-    if (!this.poolMap.has(tag)) return undefined;
+  getObjectPool(tag: string): FWObjectPool | undefined {
+    if (!this.poolMap.has(tag)) {
+      FWLog.warn(`对象池不存在: ${tag}`);
+      return undefined;
+    }
     return this.poolMap.get(tag);
   }
 
-  /** 销毁一个对象池 */
-  destroyObjectPool(tag: string) {
-    if (!this.poolMap.has(tag)) return;
-    this.poolMap.get(tag).onDestroy();
-    this.poolMap.delete(tag);
+  destroyObjectPool(tag: string): boolean {
+    if (!this.poolMap.has(tag)) {
+      return false;
+    }
+
+    try {
+      const pool = this.poolMap.get(tag);
+      pool.onDestroy();
+      this.poolMap.delete(tag);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  getPoolStats(): { total: number; tags: string[] } {
+    return {
+      total: this.poolMap.size,
+      tags: Array.from(this.poolMap.keys()),
+    };
+  }
+
+  clearAllPools(): void {
+    const tags = Array.from(this.poolMap.keys());
+    tags.forEach((tag) => {
+      this.destroyObjectPool(tag);
+    });
   }
 }

package/manager/FWPerformanceManager.ts

@@ -1,5 +1,3 @@
-// FWPerformanceManager.ts
-
 import FWLog from '../log/FWLog';
 import { FWManager } from './FWManager';
 
@@ -8,7 +6,7 @@ import { FWManager } from './FWManager';
  */
 export class FWPerformanceManager extends FWManager implements FW.PerformanceManager {
   private metrics: FW.PerformanceMetric[] = [];
-  private managerStats: Map<
+  private moduleStats: Map<
     string,
     {
       totalDuration: number;
@@ -18,7 +16,7 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
     }
   > = new Map();
 
-  private performanceOptions: FW.PerformanceManagerOptions;
+  private performanceOptions: FW.PerformanceModuleOptions;
 
   public async initialize(): Promise<void> {
     this.performanceOptions = {
@@ -28,13 +26,13 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
       warningThreshold: 1000,
     };
     if (this.performanceOptions.autoCollect) {
-      this.startAutoCleanup();
+      this.autoClear();
     }
   }
 
   public onDestroy(): void {
     this.metrics = [];
-    this.managerStats.clear();
+    this.moduleStats.clear();
   }
 
   protected onCleanup(): void {}
@@ -42,38 +40,38 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
   /**
    * 记录操作性能指标
    */
-  public recordOperationMetric(manager: string, operation: string, duration: number): void {
+  public recordOperationMetric(module: string, operation: string, duration: number): void {
     if (Math.random() > this.performanceOptions.samplingRate!) {
       return;
     }
     const metric: FW.PerformanceMetric = {
-      manager,
+      module,
       operation,
       duration,
       timestamp: Date.now(),
     };
 
     this.metrics.push(metric);
-    this.updateManagerStats(manager, duration);
+    this.updateModuleStats(module, duration);
 
     if (duration > this.performanceOptions.warningThreshold!) {
-      FWLog.warn(`Performance warning: ${manager}.${operation} took ${duration}ms`);
+      FWLog.warn(`Performance warning: ${module}.${operation} took ${duration}ms`);
     }
   }
 
   /**
-   * 获取指定管理器的性能报告
+   * 获取指定模块的性能报告
    */
-  public getManagerReport(manager: string): FW.PerformanceReport | null {
-    const stats = this.managerStats.get(manager);
+  public getModuleReport(module: string): FW.PerformanceReport | null {
+    const stats = this.moduleStats.get(module);
     if (!stats) {
       return null;
     }
 
-    const recentMetrics = this.metrics.filter((m) => m.manager === manager).slice(-500);
+    const recentMetrics = this.metrics.filter((m) => m.module === module).slice(-500);
 
     return {
-      manager,
+      module,
       totalOperations: stats.operationCount,
       averageDuration: stats.totalDuration / stats.operationCount,
       minDuration: stats.minDuration,
@@ -88,10 +86,10 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
   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,
+    this.moduleStats.forEach((stats, module) => {
+      const recentMetrics = this.metrics.filter((m) => m.module === module).slice(-500);
+      reports.set(module, {
+        module,
         totalOperations: stats.operationCount,
         averageDuration: stats.totalDuration / stats.operationCount,
         minDuration: stats.minDuration,
@@ -109,37 +107,37 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
   public getPerformanceSummary(): {
     totalOperations: number;
     averageOperationTime: number;
-    slowestManager: string;
-    mostActiveManager: string;
+    slowestModule: string;
+    mostActiveModule: string;
   } {
     let totalOperations = 0;
     let totalDuration = 0;
-    let slowestManager = '';
+    let slowestModule = '';
     let maxAvgDuration = 0;
-    let mostActiveManager = '';
+    let mostActiveModule = '';
     let maxOperations = 0;
 
-    this.managerStats.forEach((stats, manager) => {
+    this.moduleStats.forEach((stats, module) => {
       totalOperations += stats.operationCount;
       totalDuration += stats.totalDuration;
 
       const avgDuration = stats.totalDuration / stats.operationCount;
       if (avgDuration > maxAvgDuration) {
         maxAvgDuration = avgDuration;
-        slowestManager = manager;
+        slowestModule = module;
       }
 
       if (stats.operationCount > maxOperations) {
         maxOperations = stats.operationCount;
-        mostActiveManager = manager;
+        mostActiveModule = module;
       }
     });
 
     return {
       totalOperations,
       averageOperationTime: totalOperations > 0 ? totalDuration / totalOperations : 0,
-      slowestManager,
-      mostActiveManager,
+      slowestModule: slowestModule,
+      mostActiveModule: mostActiveModule,
     };
   }
 
@@ -167,15 +165,15 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
    */
   public resetAllData(): void {
     this.metrics = [];
-    this.managerStats.clear();
+    this.moduleStats.clear();
   }
 
   /**
    * 更新管理器统计信息
    */
-  private updateManagerStats(manager: string, duration: number): void {
-    if (!this.managerStats.has(manager)) {
-      this.managerStats.set(manager, {
+  private updateModuleStats(module: string, duration: number): void {
+    if (!this.moduleStats.has(module)) {
+      this.moduleStats.set(module, {
         totalDuration: 0,
         operationCount: 0,
         minDuration: Infinity,
@@ -183,7 +181,7 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
       });
     }
 
-    const stats = this.managerStats.get(manager)!;
+    const stats = this.moduleStats.get(module)!;
     stats.totalDuration += duration;
     stats.operationCount++;
     stats.minDuration = Math.min(stats.minDuration, duration);
@@ -193,7 +191,7 @@ export class FWPerformanceManager extends FWManager implements FW.PerformanceMan
   /**
    * 启动自动清理任务
    */
-  private startAutoCleanup(): void {
+  private autoClear(): void {
     FW.Entry.timeMgr.schedule(() => {
       this.clearPerformanceData();
     }, 300);