@ives_xxz/framework 1.4.15 → 1.4.16

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>;
@@ -972,6 +973,7 @@ declare namespace FW {
   type EngineManager = {
     debug: boolean;
     getMemory(): void;
+    restart(): void;
   };
 
   type Layer = {
@@ -1162,6 +1164,8 @@ declare namespace FW {
      * 获取所有任务
      */
     getAllTasks(): FW.Task[];
+
+    onDestroy();
   };
 
   type StateManager = {
@@ -1839,6 +1843,10 @@ declare namespace FW {
      * 重置
      */
     reset(): void;
+    /**
+     * 停止任务
+     */
+    stop(): void;
     /**
      * 获取任务性能报告
      */
@@ -1918,9 +1926,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;

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

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

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,9 +152,6 @@ 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());
   }
@@ -207,18 +208,8 @@ 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;
+  restart() {
+    this.engineMgr?.restart();
   }
 
   update(dt: number) {

package/manager/FWBundleManager.ts

@@ -93,7 +93,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/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,3 +1,4 @@
+import { FWEventDefine } from '../define/FWEventDefine';
 import FWLog from '../log/FWLog';
 
 export abstract class FWManager implements FW.Manager {
@@ -9,6 +10,12 @@ export abstract class FWManager implements FW.Manager {
 
   constructor() {
     this.initialize();
+    this.entry.evtMgr.register(FWEventDefine.SystemEvent.SYSTEM_RESTART, this.onRestart, this);
+  }
+
+  protected onRestart() {
+    this.onDestroy();
+    this.initialize();
   }
 
   protected async invoke<T>(operation: Promise<T>, operationName: string = 'unknown'): Promise<T> {

package/manager/FWPromiseManager.ts

@@ -5,16 +5,14 @@ import { FWManager } from './FWManager';
 export default class FWPromiseManager extends FWManager implements FW.PromiseManager {
   private promiseRegistry: Map<number, FW.PromiseProxy>;
   private uniqueId: number = 0;
-  private timerSchedule: FW.TimerSchedule;
 
   public initialize(): void {
     this.promiseRegistry = new Map<number, FW.PromiseProxy>();
   }
 
   public onDestroy(): void {
-    this.cancelAll('Manager destroyed');
+    this.cancelAll();
     this.promiseRegistry.clear();
-    this.promiseRegistry = null;
   }
 
   /** 创建Promise执行器 */
@@ -24,15 +22,14 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
   ): FW.PromiseProxy<T> {
     const id = this.uniqueId++;
     const abortController = new AbortController();
-    let retryCount = 0;
     const maxRetryTimes = options.retryCount || 0;
     const retryInterval = options.retryInterval || 0;
-
+    let retryCount = 0;
+    let timerSchedule: FW.TimerSchedule;
     const createPromise = (): Promise<T> => {
       return new Promise<T>((resolve, reject) => {
         if (options.timeout && options.timeout > 0) {
-          this.timerSchedule?.unSchedule();
-          this.timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
+          timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
             const timeoutError = new Error(`Promise ${id} timeout after ${options.timeout} s`);
             if (
               retryCount < maxRetryTimes &&
@@ -49,13 +46,13 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
               }
             } else {
               abortController.abort(timeoutError.message);
-              this.timerSchedule?.unSchedule();
+              timerSchedule?.unSchedule();
             }
           }, options.timeout);
         }
 
         const onAbort = () => {
-          this.timerSchedule?.unSchedule();
+          timerSchedule?.unSchedule();
           if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
             promiseProxy.status = FWSystemDefine.FWPromiseStatus.CANCELLED;
             this.removePromise(id);
@@ -73,12 +70,12 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
           promiseProxy.status = FWSystemDefine.FWPromiseStatus.FULFILLED;
           abortController.signal.removeEventListener('abort', onAbort);
           this.removePromise(id);
-          this.timerSchedule?.unSchedule();
+          timerSchedule?.unSchedule();
           resolve(value);
         };
 
         const wrappedReject = (reason?: any) => {
-          this.timerSchedule?.unSchedule();
+          timerSchedule?.unSchedule();
           if (
             retryCount < maxRetryTimes &&
             (!options.retryCondition || options.retryCondition(reason, retryCount))
@@ -102,7 +99,7 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
           }
         };
         try {
-          executor(wrappedResolve, wrappedReject, abortController.signal);
+          executor(wrappedResolve, wrappedReject, abortController.signal, options.reason);
         } catch (error) {
           wrappedReject(error);
         }
@@ -121,6 +118,7 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
           abortController.abort(reason);
         }
       },
+
       addAbortEventListener: (
         listener: (this: AbortSignal, ev: Event) => any,
         options?: boolean | AddEventListenerOptions,
@@ -140,15 +138,16 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
   ): FW.PromiseProxy<FW.PromiseResult<T>> {
     const id = this.uniqueId++;
     const abortController = new AbortController();
-    let retryCount = 0;
     const maxRetryTimes = options.retryCount || 0;
     const retryInterval = options.retryInterval || 0;
+    let timerSchedule: FW.TimerSchedule;
+    let retryCount = 0;
 
     const createPromise = (): Promise<FW.PromiseResult<T>> => {
       return new Promise<FW.PromiseResult<T>>((resolve, reject) => {
         if (options.timeout && options.timeout > 0) {
-          this.timerSchedule?.unSchedule();
-          this.timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
+          timerSchedule?.unSchedule();
+          timerSchedule = FW.Entry.timeMgr.scheduleOnce(() => {
             const timeoutError = new Error(`All Promise ${id} timeout after ${options.timeout} s`);
             if (
               retryCount < maxRetryTimes &&
@@ -165,13 +164,13 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
               }
             } else {
               abortController.abort(timeoutError.message);
-              this.timerSchedule?.unSchedule();
+              timerSchedule?.unSchedule();
             }
           }, options.timeout);
         }
 
         const onAbort = () => {
-          this.timerSchedule?.unSchedule();
+          timerSchedule?.unSchedule();
           if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
             promiseProxy.status = FWSystemDefine.FWPromiseStatus.CANCELLED;
             this.removePromise(id);
@@ -230,11 +229,11 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
             promiseProxy.status = FWSystemDefine.FWPromiseStatus.FULFILLED;
             abortController.signal.removeEventListener('abort', onAbort);
             this.removePromise(id);
-            this.timerSchedule?.unSchedule();
+            timerSchedule?.unSchedule();
             resolve(result);
           })
           .catch((error) => {
-            this.timerSchedule?.unSchedule();
+            timerSchedule?.unSchedule();
             if (
               retryCount < maxRetryTimes &&
               (!options.retryCondition || options.retryCondition(error, retryCount))
@@ -312,11 +311,10 @@ export default class FWPromiseManager extends FWManager implements FW.PromiseMan
   public cancelAll(reason?: any): number[] {
     const cancelled: number[] = [];
     this.promiseRegistry.forEach((promiseProxy, id) => {
-      if (promiseProxy.status === FWSystemDefine.FWPromiseStatus.PENDING) {
-        promiseProxy.abort(reason);
-        cancelled.push(id);
-      }
+      promiseProxy.abort(reason);
+      cancelled.push(id);
     });
+    FWLog.error(cancelled);
     return cancelled;
   }
 

package/manager/FWTaskManager.ts

@@ -3,7 +3,9 @@ import { FWManager } from './FWManager';
 
 export default class FWTaskManager extends FWManager implements FW.TaskManager {
   public initialize(): void {}
-  public onDestroy(): void {}
+  public onDestroy(): void {
+    this.tasks.forEach((task) => task.stop());
+  }
   /**
    * 任务合集
    */

package/package.json

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

package/service/FWService.ts

@@ -1,11 +1,14 @@
+import { FWEventDefine } from '../define/FWEventDefine';
 import FWLog from '../log/FWLog';
 
 export default abstract class FWService {
   constructor() {
     this.initialize();
+    this.entry.evtMgr.register(FWEventDefine.SystemEvent.SYSTEM_RESTART, this.onDestroy, this);
   }
+  public entry: FW.Entry = FW.Entry;
   public abstract initialize(): void;
-  public abstract destroy(): void;
+  public abstract onDestroy(): void;
   public abstract readonly serviceName: string;
 
   protected async invoke<T>(operation: Promise<T>, operationName: string = 'unknown'): Promise<T> {

package/service/http/FWHttp.ts

@@ -3,9 +3,9 @@ import FWLog from '../../log/FWLog';
 import FWService from '../FWService';
 
 export default class FWHttp extends FWService {
-  public serviceName: string = 'HTTP';
+  public serviceName: string = 'http';
   public initialize(): void {}
-  public destroy(): void {}
+  public onDestroy(): void {}
 
   protected async getMessage(
     url: string,
@@ -33,40 +33,45 @@ export default class FWHttp extends FWService {
     type: FWSystemDefine.FWHttpRequestType,
   ): Promise<string> {
     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}`);
-          };
+    const promiseProxy: FW.PromiseProxy<string> = FW.Entry.promiseMgr.execute<string>(
+      (resolve, reject, signal, reason) => {
+        xhr = new XMLHttpRequest();
 
-          xhr.ontimeout = () => {
-            this.onTimeout();
-            reject(`http request timeout!`);
-          };
+        xhr.onreadystatechange = () => {
+          if (xhr.readyState == 4 && xhr.status === 200) {
+            cb?.(xhr.response);
+            resolve(xhr.response);
+          }
+        };
 
-          xhr.open(type, url, true);
-          xhr.send(params);
-        },
-        {
-          retryCount: 3,
-          retryCondition(error, retryCount) {
-            return xhr.readyState != 4 || (xhr.status !== 200 && retryCount < 3);
-          },
+        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}` : '',
+      },
     );
+
+    promiseProxy.addAbortEventListener(() => {
+      xhr.abort();
+    });
+
+    return await this.invoke(promiseProxy.promise, tag ? `http request ->${tag}` : '');
   }
 
   onError?(err: any);

package/service/socket/FWSocket.ts

@@ -1,12 +1,14 @@
 import { FWSystemConfig } from '../../config/FWSystemConfig';
 import FWLog from '../../log/FWLog';
+import FWService from '../FWService';
 import FWSocketHandle from './FWSocketHandle';
 import FWSocketSender from './FWSocketSender';
 
 /**
  * TODO 犹豫socket没有改版暂时已老的cmd字符串映射方式做,后期优化
  */
-export default class FWSocket implements FW.Socket {
+export default class FWSocket extends FWService implements FW.Socket {
+  public serviceName: string = 'socket';
   /** 发送心跳时间抽 */
   private sendHeartTimestamp: number;
   /** 接收心跳时间戳 */
@@ -54,10 +56,6 @@ export default class FWSocket implements FW.Socket {
    */
   protected messageEvents: { [key: string]: (msg: any) => void };
 
-  constructor() {
-    this.initialize();
-  }
-
   public initialize(): void {
     this.messageEvents = cc.js.createMap();
     this.protocolContainer = new Map<Symbol, FW.ProtocolPolling>();
@@ -102,8 +100,6 @@ export default class FWSocket implements FW.Socket {
         }
       }
 
-
-
       this.socket.onopen = this.onSocketOpen.bind(this);
       this.socket.onclose = this.onSocketClose.bind(this);
       this.socket.onerror = this.onSocketError.bind(this);
@@ -147,6 +143,7 @@ export default class FWSocket implements FW.Socket {
 
   public onDestroy(): void {
     this.messageEvents = cc.js.createMap();
+    this.socket.close();
     this.socket = null;
   }
 
@@ -310,9 +307,9 @@ export default class FWSocket implements FW.Socket {
   /** 消息处理 */
   private async onSocketMessage(originalMsg: any) {
     const msg = await this.handle.onBeforeReceivingMessage(originalMsg);
-    
-    if(msg.error){
-      this.onSocketError(msg)
+
+    if (msg.error) {
+      this.onSocketError(msg);
       return;
     }
 
@@ -320,7 +317,7 @@ export default class FWSocket implements FW.Socket {
       this.receiveTimeStamp = new Date().getTime();
       return;
     }
-    
+
     this.remoteProtocol(msg);
 
     if (this.isPausedMessageHandle) return;