@ives_xxz/framework 1.4.15 → 1.5.0

package/FW.d.ts

@@ -47,7 +47,7 @@ declare namespace FW {
     getDepend(bundleName: string): string[];
     update(dt: number): void;
     initialize(): void;
-    onDestroy(): void;
+    restart(): void;
   };
 
   type Manager = {};
@@ -57,7 +57,8 @@ declare namespace FW {
       executor: (
         resolve: (value: T | PromiseLike<T>) => void,
         reject: (reason?: any) => void,
-        signal: AbortSignal,
+        signal?: AbortSignal,
+        reason?: any,
       ) => void = PromiseExcutor,
       options: PromiseExecuteOptions = {},
     ): PromiseProxy<T>;
@@ -180,6 +181,10 @@ declare namespace FW {
 
     /** 销毁一个对象池 */
     destroyObjectPool(tag: string): void;
+    /** 获取对象池状态 */
+    getPoolStats(): { total: number; tags: string[] };
+    /** 清理所有对象池 */
+    clearAllPools(): void;
   };
 
   type ObjectPool = {
@@ -317,6 +322,7 @@ declare namespace FW {
   type Observer = {
     priority: number;
     intercept: boolean;
+    once: boolean;
     /**
      * 事件通知
      */
@@ -452,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
@@ -972,6 +1017,7 @@ declare namespace FW {
   type EngineManager = {
     debug: boolean;
     getMemory(): void;
+    restart(): void;
   };
 
   type Layer = {
@@ -1162,6 +1208,8 @@ declare namespace FW {
      * 获取所有任务
      */
     getAllTasks(): FW.Task[];
+
+    onDestroy();
   };
 
   type StateManager = {
@@ -1575,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>;
   };
 
@@ -1839,6 +1850,10 @@ declare namespace FW {
      * 重置
      */
     reset(): void;
+    /**
+     * 停止任务
+     */
+    stop(): void;
     /**
      * 获取任务性能报告
      */
@@ -1918,9 +1933,11 @@ declare namespace FW {
     resolve: (value: T | PromiseLike<T>) => void,
     reject: (reason?: any) => void,
     signal: AbortSignal,
+    reason?: any,
   ) => void;
 
   type PromiseExecuteOptions = {
+    reason?: any;
     timeout?: number;
     retryCount?: number;
     retryInterval?: number;
@@ -1940,7 +1957,7 @@ declare namespace FW {
   /**
    * 性能管理器配置
    */
-  type PerformanceManagerOptions = {
+  type PerformanceModuleOptions = {
     /** 是否自动收集性能数据 */
     autoCollect?: boolean;
     /** 性能数据保留时间（毫秒） */
@@ -1955,7 +1972,7 @@ declare namespace FW {
    * 性能统计报告
    */
   type PerformanceReport = {
-    manager: string;
+    module: string;
     totalOperations: number;
     averageDuration: number;
     minDuration: number;
@@ -1967,7 +1984,7 @@ declare namespace FW {
    * 性能指标数据
    */
   type PerformanceMetric = {
-    manager: string;
+    module: string;
     operation: string;
     duration: number;
     timestamp: number;

package/Framework.ts

@@ -1,10 +1,13 @@
 import 'reflect-metadata';
 import { Container, interfaces } from 'inversify';
 import { FWSystemDefine } from './define/FWSystemDefine';
+import FWLog from './log/FWLog';
+import { FWEventDefine } from './define/FWEventDefine';
 
 class Framework {
   private container: Container;
   private registry: Map<string, new () => FW.Registry>;
+  private registeredComponents: Map<string, FW.RegisterFramework[]> = new Map();
   private static instance: Framework;
   private constructor() {}
 
@@ -14,6 +17,7 @@ class Framework {
       autoBindInjectable: true,
     });
     this.registry = new Map<string, new () => FW.Registry>();
+    this.registeredComponents.clear();
   }
 
   public static getInstance() {
@@ -63,6 +67,7 @@ class Framework {
       return this.getComponents(serviceIdentifier)[0];
     }
   }
+
   /** 获取所有组件 */
   public getComponents<T>(serviceIdentifier: FW.ServiceIdentifier<T>): T[] {
     const binder = (this.container as any)._bindingDictionary;
@@ -112,7 +117,10 @@ class Framework {
    * @param bundleName
    */
   getRegistry(bundleName: string): FW.Registry {
-    return this.container.get(this.registry.get(bundleName));
+    if (this.registry.has(bundleName)) {
+      return this.container.get(this.registry.get(bundleName));
+    }
+    return undefined;
   }
 
   /**
@@ -145,7 +153,10 @@ class Framework {
         this.container.bind(this.getKey(data.bundleName, index)).toService(cls);
       }
     });
+
+    this.recordRegistration(data);
   }
+
   /**
    * 注销数据
    * @param data
@@ -156,14 +167,95 @@ class Framework {
     classes.forEach((cls, index) => {
       const key = this.getKey(data.bundleName, index);
       if (cls && this.container.isBound(cls)) {
-        this.container.get(key)['onDestroy']?.();
+        this.container.get(key)?.['onDestroy']?.();
         this.container.unbind(cls);
       }
       if (this.container.isBound(key)) {
-        this.container.get(key)['onDestroy']?.();
+        this.container.get(key)?.['onDestroy']?.();
         this.container.unbind(this.getKey(data.bundleName, index));
       }
     });
+
+    this.removeRegistration(data);
+  }
+
+  private recordRegistration(data: FW.RegisterFramework) {
+    const bundleName = data.bundleName;
+    if (!this.registeredComponents.has(bundleName)) {
+      this.registeredComponents.set(bundleName, []);
+    }
+
+    const registrations = this.registeredComponents.get(bundleName)!;
+    const exists = registrations.some(
+      (reg) => reg.logic === data.logic && reg.data === data.data && reg.config === data.config,
+    );
+
+    if (!exists) {
+      registrations.push({ ...data });
+    }
+  }
+
+  private removeRegistration(data: FW.RegisterFramework) {
+    const bundleName = data.bundleName;
+    if (this.registeredComponents.has(bundleName)) {
+      const registrations = this.registeredComponents.get(bundleName)!;
+      const index = registrations.findIndex(
+        (reg) => reg.logic === data.logic && reg.data === data.data && reg.config === data.config,
+      );
+
+      if (index !== -1) {
+        registrations.splice(index, 1);
+      }
+
+      if (registrations.length === 0) {
+        this.registeredComponents.delete(bundleName);
+      }
+    }
+  }
+
+  public restart(): void {
+    this.destroyAllComponents();
+    this.container.unbindAll();
+    this.container = new Container({
+      defaultScope: 'Singleton',
+      autoBindInjectable: true,
+    });
+
+    this.reregisterAllComponents();
+  }
+
+  private destroyAllComponents(): void {
+    const binder = (this.container as any)._bindingDictionary;
+    const map = binder._map;
+
+    for (const [key, bindings] of map.entries()) {
+      for (const binding of bindings) {
+        try {
+          if (this.container.isBound(binding.serviceIdentifier)) {
+            const instance = this.container.get(binding.serviceIdentifier);
+            instance?.['onDestroy']?.();
+          }
+        } catch (e) {
+          FWLog.warn(`Error destroying component ${key}:`, e);
+        }
+      }
+    }
+  }
+
+  private reregisterAllComponents(): void {
+    for (const [bundleName, registrations] of this.registeredComponents.entries()) {
+      for (const data of registrations) {
+        try {
+          this.register(data);
+        } catch (e) {
+          console.error(`Error re-registering component for bundle ${bundleName}:`, e);
+        }
+      }
+    }
+  }
+
+  public getRegisteredComponents(): Map<string, FW.RegisterFramework[]> {
+    return new Map(this.registeredComponents);
   }
 
   private getKey(bundleName: string, tag: FWSystemDefine.FWBindTag) {

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/FWEventDefine.ts

@@ -17,4 +17,8 @@ export namespace FWEventDefine {
     ALL_COMPLETE = 'ALL_COMPLETE',
     ERROR = 'ERROR',
   }
+
+  export enum SystemEvent {
+    SYSTEM_RESTART,
+  }
 }

package/define/FWSystemDefine.ts

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

package/entry/FWEntry.ts

@@ -108,9 +108,9 @@ export default class FWEntry implements FW.Entry {
    * */
   initialize() {
     this.map = new Map<string, FW.RegisterBundle>();
+    this.evtMgr = new FWEventManager();
     this.engineMgr = new FWEngineManager();
     this.taskMgr = new FWTaskManager();
-    this.evtMgr = new FWEventManager();
     this.resMgr = new FWResManager();
     this.layerMgr = new FWLayerManager();
     this.timeMgr = new FWTimeManager();
@@ -140,6 +140,10 @@ export default class FWEntry implements FW.Entry {
   @FWSocketAutoProcessPause()
   launchScene(name: string): void {
     FW.Entry.layerMgr.clear();
+    if (this.bundleAutoRelease(this.bundleName)) {
+      this.releaseBundle(this.bundleName);
+    }
+
     if (!this.hasSceneName(name)) {
       try {
         cc.director.loadScene(name);
@@ -148,13 +152,14 @@ export default class FWEntry implements FW.Entry {
         FWLog.error('launchScene failed:', name);
       }
     }
-    if (this.bundleAutoRelease(this.bundleName)) {
-      this.releaseBundle(this.bundleName);
-    }
     this.bundleName = name;
     cc.director.loadScene(this.getSceneName());
   }
 
+  restart() {
+    this.engineMgr?.restart();
+  }
+
   releaseBundle(bundleName: string) {
     this.resMgr.releaseBundle(bundleName);
     const depend = this.getDepend(bundleName);
@@ -207,20 +212,6 @@ export default class FWEntry implements FW.Entry {
   getComponents: <T>(serviceIdentifier?: FW.ServiceIdentifier<T>) => T[] = (serviceIdentifier) =>
     Framework.getComponents(serviceIdentifier);
 
-  onDestroy() {
-    this.resMgr.onDestroy();
-    this.layerMgr.onDestroy();
-    this.timeMgr.onDestroy();
-    this.animationMgr.onDestroy();
-    this.stateMgr.onDestroy();
-
-    this.resMgr = null;
-    this.layerMgr = null;
-    this.timeMgr = null;
-    this.animationMgr = null;
-    this.stateMgr = null;
-  }
-
   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?();
 }