@ives_xxz/framework 1.4.16 → 1.5.0

package/FW.d.ts

@@ -181,6 +181,10 @@ declare namespace FW {
 
     /** 销毁一个对象池 */
     destroyObjectPool(tag: string): void;
+    /** 获取对象池状态 */
+    getPoolStats(): { total: number; tags: string[] };
+    /** 清理所有对象池 */
+    clearAllPools(): void;
   };
 
   type ObjectPool = {
@@ -318,6 +322,7 @@ declare namespace FW {
   type Observer = {
     priority: number;
     intercept: boolean;
+    once: boolean;
     /**
      * 事件通知
      */
@@ -453,13 +458,52 @@ declare namespace FW {
      */
     register(
       eventName: string | number,
-      cb: (any) => void,
+      cb: (
+        args1?: EventManagerArgs,
+        args2?: EventManagerArgs,
+        args3?: EventManagerArgs,
+        args4?: EventManagerArgs,
+        args5?: EventManagerArgs,
+        args6?: EventManagerArgs,
+        args7?: EventManagerArgs,
+        args8?: EventManagerArgs,
+        args9?: EventManagerArgs,
+        args10?: EventManagerArgs,
+      ) => void,
       target: TargetType,
       options?: {
         priority?: FWSystemDefine.FWPriorityOrder;
         intercept?: boolean;
       },
     );
+
+    registerOnce(
+      eventName: string | number,
+      cb: (
+        args1?: EventManagerArgs,
+        args2?: EventManagerArgs,
+        args3?: EventManagerArgs,
+        args4?: EventManagerArgs,
+        args5?: EventManagerArgs,
+        args6?: EventManagerArgs,
+        args7?: EventManagerArgs,
+        args8?: EventManagerArgs,
+        args9?: EventManagerArgs,
+        args10?: EventManagerArgs,
+      ) => void,
+      target: TargetType,
+      options?: {
+        priority?: number;
+        intercept?: boolean;
+      },
+    ): void;
+
+    /**
+     * 获取事件监听器数量
+     * @param eventName 事件名
+     * @returns 监听器数量
+     */
+    getListenerCount(eventName: string | number): number;
     /**
      * 派发事件
      * @param eventName
@@ -1579,48 +1623,11 @@ declare namespace FW {
      * @param mute
      */
     setSoundMute(mute: boolean): void;
-    /**
-     * 播放音效
-     * @param path
-     * @param loop
-     */
-    playEffect(path: string, loop?: boolean): Promise<number>;
-    /**
-     * 播放音效
-     * @param audio
-     * @param loop
-     */
-    playEffect(audio: cc.AudioClip, loop?: boolean): Promise<number>;
-    /**
-     * 播放音效
-     * @param assetProperty
-     * @param loop
-     */
-    playEffect(assetProperty: FW.AssetProperty, loop?: boolean): Promise<number>;
-    /**
-     * 停止音效
-     * @param audioID
-     */
-    stopEffect(audioID: number): void;
-    /**
-     * 设置音效音量
-     * @param volume
-     */
-    setEffectsVolume(volume: number): void;
-    /**
-     * 停止全部音效
-     */
-    stopAllEffects(): void;
-    /**
-     * 设置音效是否静音
-     * @param mute
-     */
-    setEffectsMute(mute: boolean): void;
   };
 
   type PerformanceManager = {
     recordOperationMetric(manager: string, operation: string, duration: number): void;
-    getManagerReport(manager: string): PerformanceReport;
+    getModuleReport(manager: string): PerformanceReport;
     getAllReports(): Map<string, FW.PerformanceReport>;
   };
 
@@ -1950,7 +1957,7 @@ declare namespace FW {
   /**
    * 性能管理器配置
    */
-  type PerformanceManagerOptions = {
+  type PerformanceModuleOptions = {
     /** 是否自动收集性能数据 */
     autoCollect?: boolean;
     /** 性能数据保留时间（毫秒） */
@@ -1965,7 +1972,7 @@ declare namespace FW {
    * 性能统计报告
    */
   type PerformanceReport = {
-    manager: string;
+    module: string;
     totalOperations: number;
     averageDuration: number;
     minDuration: number;
@@ -1977,7 +1984,7 @@ declare namespace FW {
    * 性能指标数据
    */
   type PerformanceMetric = {
-    manager: string;
+    module: string;
     operation: string;
     duration: number;
     timestamp: number;

package/FrameworkBase.ts

@@ -0,0 +1,62 @@
+import { FWEventDefine } from './define/FWEventDefine';
+import FWLog from './log/FWLog';
+
+export abstract class FrameworkBase {
+  public readonly entry: FW.Entry = FW.Entry;
+
+  constructor() {
+    this.initialize();
+
+    this.entry.evtMgr.register(FWEventDefine.SystemEvent.SYSTEM_RESTART, this.onRestart, this);
+  }
+
+  public abstract initialize?(): void;
+  public abstract onDestroy?(): void;
+
+  protected get moduleName(): string {
+    return this.constructor.name;
+  }
+  protected onRestart?(): 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.moduleName, operationName, duration);
+    }
+
+    const shouldWarn = duration > 1000;
+
+    if (FW.Entry.engineMgr.debug || shouldWarn) {
+      const log = shouldWarn ? FWLog.warn : FWLog.debug;
+      log(`[${this.moduleName?.toUpperCase()}] Operation ${operationName} took ${duration}ms`);
+    }
+  }
+
+  protected handleError(operation: string, error: any): void {
+    const errorInfo = {
+      type: this.moduleName,
+      operation,
+      error: error?.message || error,
+      stack: error?.stack,
+    };
+
+    FWLog.error(`Error in ${this.moduleName}.${operation}:`, errorInfo);
+  }
+
+  protected getCurrentTime(): number {
+    return Date.now();
+  }
+}

package/FrameworkBase.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "abc42759-95e6-4156-a144-7ef424305eb6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/config/FWSystemConfig.ts

@@ -8,4 +8,22 @@ export namespace FWSystemConfig {
     protocolSymbol: null,
     protocolPollingTime: 10,
   };
+
+  export const PromiseConfig = {
+    loadAsset: {
+      retryCount: 3,
+      retryInterval: 5,
+      timeout: 10,
+    },
+    loadBundle: {
+      retryCount: 3,
+      retryInterval: 5,
+      timeout: 10,
+    },
+    http: {
+      retryCount: 3,
+      retryInterval: 5,
+      timeout: 10,
+    },
+  };
 }

package/controller/FWLayerController.ts

@@ -2,7 +2,8 @@ import { FWSystemDefine } from '../define/FWSystemDefine';
 import FWLayer from '../layer/FWLayer';
 import { FWLayerData } from '../manager/FWLayerManager';
 import FWLog from '../log/FWLog';
-export abstract class FWLayerController implements FW.LayerController {
+import { FrameworkBase } from '../FrameworkBase';
+export abstract class FWLayerController extends FrameworkBase implements FW.LayerController {
   readonly entry: FW.Entry = FW.Entry;
   /** layer数据 */
   layerData: FWLayerData;
@@ -33,8 +34,8 @@ export abstract class FWLayerController implements FW.LayerController {
   onEnable?();
   onDisable?();
   onDestroy?();
-  async onClose?();
   initialize() {}
+  async onClose?();
 
   async destroy() {
     FW.Entry.timeMgr?.unSchedule(this);

package/data/FWData.ts

@@ -1,10 +1,7 @@
 import { injectable } from 'inversify';
+import { FrameworkBase } from '../FrameworkBase';
 @injectable()
-export default class FWData implements FW.Data {
-  constructor() {
-    this.initialize?.();
-  }
-  public readonly entry: FW.Entry = FW.Entry;
+export default class FWData extends FrameworkBase implements FW.Data {
   public initialize?(): void;
   public onDestroy?(): void;
 }

package/define/FWSystemDefine.ts

@@ -144,4 +144,9 @@ export namespace FWSystemDefine {
     OPENED = 'opened',
     CLOSING = 'closing',
   }
+
+  export enum FWAudioType {
+    MUSIC,
+    SOUND,
+  }
 }

package/entry/FWEntry.ts

@@ -156,6 +156,10 @@ export default class FWEntry implements FW.Entry {
     cc.director.loadScene(this.getSceneName());
   }
 
+  restart() {
+    this.engineMgr?.restart();
+  }
+
   releaseBundle(bundleName: string) {
     this.resMgr.releaseBundle(bundleName);
     const depend = this.getDepend(bundleName);
@@ -208,10 +212,6 @@ export default class FWEntry implements FW.Entry {
   getComponents: <T>(serviceIdentifier?: FW.ServiceIdentifier<T>) => T[] = (serviceIdentifier) =>
     Framework.getComponents(serviceIdentifier);
 
-  restart() {
-    this.engineMgr?.restart();
-  }
-
   update(dt: number) {
     this.timeMgr?.onUpdate(dt);
   }

package/logic/FWLogic.ts

@@ -1,10 +1,7 @@
 import { injectable } from 'inversify';
+import { FrameworkBase } from '../FrameworkBase';
 @injectable()
-export default class FWLogic implements FW.Logic {
-  constructor() {
-    this.initialize?.();
-  }
-  public readonly entry: FW.Entry = FW.Entry;
-  public initialize?();
-  public onDestroy?();
+export default class FWLogic extends FrameworkBase implements FW.Logic {
+  initialize?();
+  onDestroy?();
 }

package/manager/FWAssetManager.ts

@@ -1,3 +1,4 @@
+import { FWSystemConfig } from '../config/FWSystemConfig';
 import FWLog from '../log/FWLog';
 import { FWManager } from './FWManager';
 
@@ -41,19 +42,20 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
     bin?: boolean;
   }): Promise<sp.SkeletonData> {
     try {
-      return new Promise((resolve) => {
-        const bin = data.bin === undefined ? false : data.bin;
-        const img = data.img;
-        const ske = data.ske;
-        const atlas = data.atlas;
-        const type = bin ? '.bin' : '.txt';
-        cc.assetManager.loadAny(
-          [
-            { url: atlas, ext: type },
-            { url: ske, ext: type },
-          ],
-          (error, assets) => {
-            cc.assetManager.loadRemote(img, (error, texture: cc.Texture2D) => {
+      return await this.invoke(
+        FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+          const bin = data.bin === undefined ? false : data.bin;
+          const img = data.img;
+          const ske = data.ske;
+          const atlas = data.atlas;
+          const type = bin ? '.bin' : '.txt';
+          cc.assetManager.loadAny(
+            [
+              { url: atlas, ext: type },
+              { url: ske, ext: type },
+            ],
+            async (error, assets) => {
+              const texture: cc.Texture2D = await this.loadRemote();
               var asset = new sp.SkeletonData();
               asset.skeletonJson = assets[1];
               asset.atlasText = assets[0];
@@ -61,29 +63,32 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
               asset['textureNames'] = [`${img}.png`];
               asset['_uuid'] = ske;
               resolve(asset);
-            });
-          },
-        );
-      });
+            },
+          );
+        }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      );
     } catch (e) {
       FWLog.error('从远程加载spine动画资源失败!');
     }
   }
 
   /** 加载远程资源 */
-  loadRemote<T extends cc.Asset = cc.Asset>(
+  async loadRemote<T extends cc.Asset = cc.Asset>(
     url?: string,
     cb?: (asset: cc.Asset) => void,
   ): Promise<T> {
-    return new Promise((resolve, reject) => {
-      cc.assetManager.loadRemote(url, { cacheEnabled: true, maxRetryCount: 0 }, (err, asset) => {
-        if (err || !asset) {
-          reject(err);
-        }
-        cb?.(asset as T);
-        resolve(asset as T);
-      });
-    });
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+        cc.assetManager.loadRemote(url, { cacheEnabled: true, maxRetryCount: 3 }, (err, asset) => {
+          if (err || !asset) {
+            reject(err);
+          }
+          cb?.(asset as T);
+          resolve(asset as T);
+        });
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      `loadAssets -> ${url}`,
+    );
   }
 
   /**
@@ -132,43 +137,36 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
     assetData.loaded = false;
 
     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,
+      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);
+          },
+        );
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
       `loadAssets -> ${assetProperty.path}`,
     );
   }
@@ -322,9 +320,6 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
    * @returns
    */
   public getReferenceCount(assetProperty: FW.AssetProperty): number {
-    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
-    const path = assetProperty.path;
-    const type = assetProperty.type;
     const key = this.createAssetMapKey(assetProperty);
     return this.assetsMap.get(key)?.refCount || 0;
   }