@ives_xxz/framework 1.4.7 → 1.4.9

package/manager/FWLayerManager.ts

@@ -18,7 +18,7 @@ export class FWLayerData<T extends FW.LayerController = FW.LayerController>
   layerRenderOrder: FWSystemDefine.FWLayerRenderOrder;
   layerType: FWSystemDefine.FWLayerType;
   layerParent?: cc.Node;
-  layerPosition?: cc.Vec3;
+  layerPosition?: FW.Vec3;
   controllerName: string;
   controller: FW.LayerController;
   loaded: boolean;
@@ -26,282 +26,570 @@ export class FWLayerData<T extends FW.LayerController = FW.LayerController>
   externalReference?: Set<(ref: FW.LayerController | null) => void>;
 }
 
-export class FWLayerManager extends FWManager implements FW.LayerManager {
+class FWLayerDataManager {
+  private layerMap: Map<new () => FW.LayerController, FWLayerData> = new Map();
+  private layerRegistry: Set<new () => FW.LayerController> = new Set();
+
   /**
-   * 当前待打开的layer队列
+   * 获取已存在的Layer
    */
-  private layerQueue: FWQueue<FW.LayerData>;
+  getExistingLayer<Ctr extends FW.LayerController = FW.LayerController>(
+    type: new () => Ctr,
+  ): Ctr | undefined {
+    for (const [key, value] of this.layerMap) {
+      if (value.controllerConstructor === type) {
+        return value.controllerProxy as Ctr;
+      }
+    }
+    return undefined;
+  }
+
   /**
-   * 当前已经打开的layer缓存容器
+   * 从类型创建Layer数据
    */
-  private layerMap: Map<new () => FW.LayerController, FW.LayerData>;
+  createLayerDataFromType<Ctr extends FW.LayerController = FW.LayerController>(
+    type: new () => Ctr,
+  ): FWLayerData | undefined {
+    const ctr = new type();
+    const ctrName = cc.js.getClassName(ctr);
+    const layerData = this.createBaseLayerData(ctr);
+
+    layerData.controllerConstructor = type;
+    layerData.controller = ctr;
+    layerData.controllerName = ctrName;
+
+    this.layerMap.set(type, layerData);
+    return layerData;
+  }
 
   /**
-   * 当前所有打开Layer注册表
+   * 创建基础Layer数据
    */
-  private layerRegistry: Set<new () => FW.LayerController>;
+  private createBaseLayerData(ctr: FW.LayerController): FWLayerData {
+    const layerData = new FWLayerData();
+    const layerType = ctr.layerType;
+
+    layerData.layerRenderOrder = ctr.renderOrder;
+    layerData.layerAssetProperty = ctr.layerAssetProperty;
+    layerData.layerType = layerType;
+    layerData.controller = ctr;
+    layerData.loaded = false;
+    layerData.externalReference = new Set();
+
+    return layerData;
+  }
+
   /**
-   * layer栈队列
+   * 检查注册状态并添加
    */
-  private layerStack: FWLayerData[];
+  checkRegistryAndAdd(type: new () => FW.LayerController): boolean {
+    if (this.layerRegistry.has(type)) {
+      return true;
+    }
+    this.layerRegistry.add(type);
+    return false;
+  }
 
-  public initialize(): void {
-    this.layerQueue = new FWQueue<FW.LayerData>();
-    this.layerMap = new Map<new () => FW.LayerController, FW.LayerData>();
-    this.layerRegistry = new Set<new () => FW.LayerController>();
-    this.layerStack = [];
+  /**
+   * 获取已存在的代理
+   */
+  getExistingProxy<Ctr extends FW.LayerController = FW.LayerController>(
+    type: new () => Ctr,
+  ): Ctr | undefined {
+    return this.layerMap.get(type)?.controllerProxy as Ctr;
   }
 
   /**
-   * 异步打开layer
-   * @param layerData
-   * @returns
+   * 设置Layer数据
    */
-  protected async openLayerAsync(layerData: FWLayerData) {
-    try {
-      const res = await FW.Entry.resMgr.loadAssetData<cc.Prefab>(layerData.layerAssetProperty);
+  setupLayerData(
+    layerData: FWLayerData,
+    res: { asset: cc.Prefab; uuid: string },
+    layer: FWLayer,
+    layerName: string,
+  ): void {
+    layerData.loaded = true;
+    layerData.layer = layer;
+    layerData.layerName = layerName;
+    layerData.uuid = res.uuid;
 
-      /** 保存资源数据 */
-      res.user = layerData.layerName;
-      res.autoRelease = layerData.controller.autoRelease;
-      res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+    layerData.controller.layerData = layerData;
+    layerData.controller.layer = layer;
+    layerData.controller.uuid = res.uuid;
 
-      return res;
-    } catch (e) {
-      FWLog.error(`openLayerAsync failed : `, e);
-    }
+    layer.ctr = layerData.controller;
   }
+
   /**
-   * 同步打开layer
-   * @param layerData
-   * @returns
+   * 创建控制器代理
    */
-  protected openLayerSync(layerData: FWLayerData) {
-    layerData.layerAssetProperty.bundle =
-      layerData.layerAssetProperty.bundle || FW.Entry.bundleName;
-    const res = FW.Entry.resMgr.getAssetData<cc.Prefab>(layerData.layerAssetProperty);
-    /** 保存资源数据 */
-    res.user = layerData.layerName;
-    res.autoRelease = layerData.controller.autoRelease;
-    res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+  createControllerProxy(layerData: FWLayerData): FW.LayerController {
+    return new Proxy(layerData.controller, {
+      get: (target, prop) => {
+        if (prop === ADD_EXTERNAL_REFERENCE) {
+          return (cb: (ref: FW.LayerController | null) => void) => {
+            layerData.externalReference.add(cb);
+          };
+        }
+        return target[prop];
+      },
+    });
+  }
 
-    layerData.uuid = res.uuid;
+  /**
+   * 清理失败的Layer
+   */
+  cleanupFailedLayer(layerData: FWLayerData): void {
+    this.layerMap.delete(layerData.controllerConstructor);
+    this.layerRegistry.delete(layerData.controllerConstructor);
+  }
 
-    return res;
+  /**
+   * 通知外部引用更新
+   */
+  notifyExternalRefUpdates(layerData: FWLayerData): void {
+    layerData.externalReference.forEach((cb) => {
+      try {
+        cb?.(null);
+      } catch (e) {
+        FWLog.error('External ref update callback error:', e);
+      }
+    });
+    layerData.externalReference.clear();
+  }
+
+  getLayerMap(): Map<new () => FW.LayerController, FWLayerData> {
+    return this.layerMap;
+  }
+
+  removeFromRegistry(type: new () => FW.LayerController): void {
+    this.layerRegistry.delete(type);
+  }
+
+  removeFromMap(type: new () => FW.LayerController): void {
+    this.layerMap.delete(type);
+  }
+
+  clear(): void {
+    this.layerMap.clear();
+    this.layerRegistry.clear();
   }
+}
+
+class FWLayerCreateManager {
+  private lifecycleManager: FWLayerLifecycleManager = new FWLayerLifecycleManager();
 
   /**
-   * 创建layer数据
-   * @param ctr
-   * @returns
+   * 创建Layer节点
    */
-  protected createLayerData(ctr: FW.LayerController) {
-    const layerData = new FWLayerData();
-    const layerType = ctr.layerType;
+  createLayer(
+    prefab: cc.Prefab,
+    layerComponent: string,
+    renderOrder: number,
+    parent: cc.Node,
+    position: FW.Vec3,
+  ): FWLayer {
+    parent = parent || FW.Entry.scene?.node;
+    position = position || cc.Vec3.ZERO;
 
-    /** 记录layer数据 */
-    layerData.layerRenderOrder = ctr.renderOrder;
-    layerData.layerAssetProperty = ctr.layerAssetProperty;
-    layerData.layerType = layerType;
-    layerData.controller = ctr;
-    layerData.loaded = false;
-    layerData.externalReference = new Set();
+    if (!parent.activeInHierarchy || !cc.isValid(parent)) {
+      FWLog.error(`createLayer failed , parent : ${parent}`);
+      return;
+    }
 
-    return layerData;
+    const node = cc.instantiate(prefab);
+    const p = cc.v3(position.x, position.y);
+    node.setParent(parent);
+    node.setPosition(p);
+    node.zIndex = renderOrder;
+
+    !node.getComponent(layerComponent) && node.addComponent(layerComponent);
+    return node.getComponent(FWLayer);
   }
 
   /**
-   * 异步打开layer
-   * @param data
-   * @returns
+   * 设置Layer生命周期
    */
-  async openAsync<Ctr extends FW.LayerController = FW.LayerController>(
+  setupLayerLifecycle(layer: FWLayer, ctr: FW.LayerController): void {
+    this.lifecycleManager.setupLifecycleHooks(layer, ctr);
+  }
+
+  /**
+   * 初始化控制器
+   */
+  initializeController(ctr: FW.LayerController, data: any): void {
+    ctr.initialize();
+    ctr.onInit?.(data);
+  }
+}
+
+class FWLayerOpenManager {
+  constructor(
+    private dataManager: FWLayerDataManager,
+    private resourceManager: FWLayerResourceManager,
+    private createManager: FWLayerCreateManager,
+    private stackManager: FWLayerStackManager,
+    private queueManager: FWLayerQueueManager,
+  ) {}
+
+  /**
+   * 统一的Layer打开方法
+   */
+  async openLayer<Ctr extends FW.LayerController = FW.LayerController>(
     data: FW.LayerOpenArgs,
+    isAsync: boolean,
   ): Promise<Ctr> {
-    if (!data) {
-      FWLog.error(`打开Layer失败:${data},请检查参数!`);
-      return undefined;
+    if (!this.validateOpenData(data)) {
+      return this.getUndefinedResult(isAsync);
     }
 
-    for (const [key, value] of this.layerMap) {
-      if (value.controllerConstructor == data.type) {
-        return value.controllerProxy as Ctr;
-      }
+    const existingLayer = this.dataManager.getExistingLayer(data.type);
+    if (existingLayer) {
+      return this.wrapResult(existingLayer, isAsync) as Ctr;
     }
 
-    const ctr = new data.type();
-    const ctrName = cc.js.getClassName(ctr);
-    const layerData = this.createLayerData(ctr);
+    const layerData = this.dataManager.createLayerDataFromType(data.type);
+    if (!layerData) {
+      return this.getUndefinedResult(isAsync);
+    }
 
-    layerData.controllerConstructor = data.type;
-    layerData.controller = ctr;
-    layerData.controllerName = ctrName;
+    if (this.dataManager.checkRegistryAndAdd(data.type)) {
+      const proxy = this.dataManager.getExistingProxy(data.type);
+      return this.wrapResult(proxy, isAsync) as Ctr;
+    }
 
-    this.layerMap.set(data.type, layerData);
+    if (this.queueManager.handlePopupQueue(layerData, this.dataManager.getLayerMap())) {
+      return this.getUndefinedResult(isAsync);
+    }
+
+    if (isAsync) {
+      return this.loadAndCreateLayerAsync(layerData, data);
+    } else {
+      return this.loadAndCreateLayerSync(layerData, data) as Ctr;
+    }
+  }
 
-    if (this.layerRegistry.has(data.type)) {
-      return this.layerMap.get(data.type).controllerProxy as Ctr;
+  /**
+   * 验证打开数据
+   */
+  private validateOpenData(data: FW.LayerOpenArgs): boolean {
+    if (!data) {
+      FWLog.error(`打开Layer失败:${data},请检查参数!`);
+      return false;
     }
+    return true;
+  }
 
-    this.layerRegistry.add(data.type);
+  /**
+   * 获取undefined结果
+   */
+  private getUndefinedResult<Ctr>(isAsync: boolean): Promise<Ctr> | Ctr {
+    return isAsync ? Promise.resolve(undefined) : undefined;
+  }
 
-    if (ctr.layerType == FWSystemDefine.FWLayerType.POPUP_QUEUE) {
-      if (this.layerRegistry.size == 0) {
-        let unclose = true;
-        for (const [key, value] of this.layerMap) {
-          if (value.layerType != FWSystemDefine.FWLayerType.PERMANENT) {
-            unclose = false;
-          }
-        }
-        if (!unclose) {
-          this.layerQueue.add(ctr.layerData);
-          return;
-        }
-      }
+  /**
+   * 包装结果
+   */
+  private wrapResult<Ctr>(result: Ctr, isAsync: boolean): Promise<Ctr> | Ctr {
+    return isAsync ? Promise.resolve(result) : result;
+  }
+
+  /**
+   * 异步加载资源并创建Layer
+   */
+  private async loadAndCreateLayerAsync<Ctr extends FW.LayerController = FW.LayerController>(
+    layerData: FWLayerData,
+    data: FW.LayerOpenArgs,
+  ): Promise<Ctr> {
+    try {
+      const res = await this.resourceManager.loadLayerAsync(layerData);
+      return this.createLayerAndSetup(layerData, res, data) as Ctr;
+    } catch (e) {
+      FWLog.error(`loadAndCreateLayerAsync failed:`, e);
+      this.dataManager.cleanupFailedLayer(layerData);
+      throw e;
     }
+  }
 
-    ctr.initialize();
+  /**
+   * 同步加载资源并创建Layer
+   */
+  private loadAndCreateLayerSync<Ctr extends FW.LayerController = FW.LayerController>(
+    layerData: FWLayerData,
+    data: FW.LayerOpenArgs,
+  ): Ctr {
+    try {
+      const res = this.resourceManager.loadLayerSync(layerData);
+      return this.createLayerAndSetup(layerData, res, data);
+    } catch (e) {
+      FWLog.error(`loadAndCreateLayerSync failed:`, e);
+      this.dataManager.cleanupFailedLayer(layerData);
+      return undefined;
+    }
+  }
 
-    const res = await this.openLayerAsync(layerData);
-    const layer = await this.createLayer(
+  /**
+   * 创建Layer并进行设置
+   */
+  private createLayerAndSetup<Ctr extends FW.LayerController = FW.LayerController>(
+    layerData: FWLayerData,
+    res: { asset: cc.Prefab; uuid: string },
+    data: FW.LayerOpenArgs,
+  ): Ctr {
+    const layer = this.createManager.createLayer(
       res.asset,
       res.asset.name,
-      ctr.renderOrder,
+      layerData.controller.renderOrder,
       data.parent,
       data.position,
     );
-
     const layerName = cc.js.getClassName(layer);
 
-    ctr.layerData = layerData;
-    ctr.layerData.loaded = true;
-    ctr.layer = layer;
-    ctr.layerData.layerName = layerName;
-    ctr.layerData.uuid = res.uuid;
-    ctr.uuid = res.uuid;
-    ctr.onInit?.(data.args);
+    this.dataManager.setupLayerData(layerData, res, layer, layerName);
 
-    this.lifecycleProcessing(ctr);
+    this.createManager.initializeController(layerData.controller, data.args);
 
-    if (ctr.layerType !== FWSystemDefine.FWLayerType.PERMANENT) {
-      this.layerStack.push(layerData);
+    this.createManager.setupLayerLifecycle(layer, layerData.controller);
+
+    if (layerData.controller.layerType !== FWSystemDefine.FWLayerType.PERMANENT) {
+      this.stackManager.push(layerData);
     }
 
-    this.layerRegistry.delete(data.type);
+    this.dataManager.removeFromRegistry(layerData.controllerConstructor);
+
+    const proxy = this.dataManager.createControllerProxy(layerData);
+    layerData.controllerProxy = proxy;
 
-    const proxy = new Proxy(ctr, {
-      get: (target, prop) => {
-        if (prop === ADD_EXTERNAL_REFERENCE) {
-          return (cb: (ref: FW.LayerController | null) => void) => {
-            layerData.externalReference.add(cb);
-          };
-        }
-        return target[prop];
-      },
-    });
-    ctr.layerData.controllerProxy = proxy;
     return proxy as Ctr;
   }
+}
 
-  /**
-   * 同步打开
-   * @param data
-   * @returns
-   */
-  openSync<Ctr extends FW.LayerController = FW.LayerController>(data: FW.LayerOpenArgs): Ctr {
-    if (!data) {
-      FWLog.error(`open layer failed:${data},please check param!`);
-      return undefined;
+class FWLayerResourceManager {
+  async loadLayerAsync(layerData: FWLayerData): Promise<{ asset: cc.Prefab; uuid: string }> {
+    try {
+      const res = await FW.Entry.resMgr.loadAssetData<cc.Prefab>(layerData.layerAssetProperty);
+      res.user = layerData.layerName;
+      res.autoRelease = layerData.controller.autoRelease;
+      res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+      return { asset: res.asset as cc.Prefab, uuid: res.uuid };
+    } catch (e) {
+      FWLog.error(`loadLayerAsync failed:`, e);
+      throw e;
     }
+  }
 
-    for (const [key, value] of this.layerMap) {
-      if (value.controllerConstructor == data.type) {
-        return value.controllerProxy as Ctr;
-      }
-    }
+  loadLayerSync(layerData: FWLayerData): { asset: cc.Prefab; uuid: string } {
+    layerData.layerAssetProperty.bundle =
+      layerData.layerAssetProperty.bundle || FW.Entry.bundleName;
+    const res = FW.Entry.resMgr.getAssetData<cc.Prefab>(layerData.layerAssetProperty);
+    res.user = layerData.layerName;
+    res.autoRelease = layerData.controller.autoRelease;
+    res.dependentBundle = layerData.controller.layerAssetProperty.bundle;
+    return { asset: res.asset as cc.Prefab, uuid: res.uuid };
+  }
+}
 
-    const ctr = new data.type();
-    const ctrName = cc.js.getClassName(ctr);
-    const layerData = this.createLayerData(ctr);
+class FWLayerStackManager {
+  private layerStack: FWLayerData[] = [];
 
-    layerData.controllerConstructor = data.type;
-    layerData.controller = ctr;
-    layerData.controllerName = ctrName;
+  push(layerData: FWLayerData): void {
+    if (layerData.controller.layerType !== FWSystemDefine.FWLayerType.PERMANENT) {
+      this.layerStack.push(layerData);
+    }
+  }
 
-    this.layerMap.set(data.type, layerData);
+  pop(): FWLayerData | undefined {
+    return this.layerStack.pop();
+  }
 
-    if (this.layerRegistry.has(data.type)) {
-      return this.layerMap.get(data.type).controllerProxy as Ctr;
+  remove(layerData: FWLayerData): void {
+    const index = this.layerStack.findIndex((v) => v.controller === layerData.controller);
+    if (index > -1) {
+      this.layerStack.splice(index, 1);
     }
+  }
 
-    this.layerRegistry.add(data.type);
+  getStack(): FWLayerData[] {
+    return [...this.layerStack];
+  }
 
-    if (ctr.layerType == FWSystemDefine.FWLayerType.POPUP_QUEUE) {
-      if (this.layerRegistry.size == 0) {
-        let unclose = true;
-        for (const [key, value] of this.layerMap) {
-          if (value.layerType != FWSystemDefine.FWLayerType.PERMANENT) {
-            unclose = false;
-          }
-        }
-        if (!unclose) {
-          this.layerQueue.add(ctr.layerData);
-          return;
-        }
+  clear(): void {
+    this.layerStack = [];
+  }
+}
+
+class FWLayerStateManager {
+  private layerStates = new Map<new () => FW.LayerController, FWSystemDefine.FWLayerState>();
+
+  setState(ctrType: new () => FW.LayerController, state: FWSystemDefine.FWLayerState): void {
+    this.layerStates.set(ctrType, state);
+  }
+
+  getState(ctrType: new () => FW.LayerController): FWSystemDefine.FWLayerState {
+    return this.layerStates.get(ctrType) || FWSystemDefine.FWLayerState.CLOSED;
+  }
+
+  isOpening(ctrType: new () => FW.LayerController): boolean {
+    return this.getState(ctrType) === FWSystemDefine.FWLayerState.OPENING;
+  }
+
+  isOpened(ctrType: new () => FW.LayerController): boolean {
+    return this.getState(ctrType) === FWSystemDefine.FWLayerState.OPENED;
+  }
+
+  isClosing(ctrType: new () => FW.LayerController): boolean {
+    return this.getState(ctrType) === FWSystemDefine.FWLayerState.CLOSING;
+  }
+
+  removeState(ctrType: new () => FW.LayerController): void {
+    this.layerStates.delete(ctrType);
+  }
+
+  clear(): void {
+    this.layerStates.clear();
+  }
+}
+
+class FWLayerQueueManager {
+  private layerQueue: FWQueue<FWLayerData> = new FWQueue<FWLayerData>();
+
+  handlePopupQueue(
+    layerData: FWLayerData,
+    layerMap: Map<new () => FW.LayerController, FWLayerData>,
+  ): boolean {
+    if (layerData.controller.layerType === FWSystemDefine.FWLayerType.POPUP_QUEUE) {
+      const hasNonPermanentLayers = Array.from(layerMap.values()).some(
+        (value) => value.layerType !== FWSystemDefine.FWLayerType.PERMANENT,
+      );
+
+      if (hasNonPermanentLayers) {
+        this.add(layerData);
+        return true;
       }
     }
+    return false;
+  }
 
-    ctr.initialize();
+  getNextLayer(): FWLayerData | undefined {
+    return this.shift();
+  }
 
-    const res = this.openLayerSync(layerData);
-    const layer = this.createLayer(
-      res.asset,
-      res.asset.name,
-      layerData.layerRenderOrder,
-      layerData.layerParent,
-      layerData.layerPosition,
-    );
-    const layerName = cc.js.getClassName(layer);
+  add(layerData: FWLayerData): void {
+    this.layerQueue.add(layerData);
+  }
 
-    ctr.layerData = layerData;
-    ctr.layerData.loaded = true;
-    ctr.layer = layer;
-    ctr.layerData.layerName = layerName;
-    ctr.layerData.uuid = res.uuid;
-    ctr.uuid = res.uuid;
-    ctr.onInit?.(data.args);
+  shift(): FWLayerData | undefined {
+    return this.layerQueue.shift();
+  }
 
-    this.lifecycleProcessing(ctr);
+  isEmpty(): boolean {
+    return this.layerQueue.isEmpty();
+  }
 
-    if (ctr.layerType !== FWSystemDefine.FWLayerType.PERMANENT) {
-      this.layerStack.push(layerData);
-    }
+  clear(): void {
+    this.layerQueue.clear();
+  }
 
-    this.layerRegistry.delete(data.type);
+  getQueue(): FWLayerData[] {
+    return this.layerQueue.getQueue();
+  }
+}
 
-    const proxy = new Proxy(ctr, {
-      get: (target, prop) => {
-        if (prop === 'addExternalReference') {
-          return (cb: (ref: FW.LayerController | null) => void) => {
-            layerData.externalReference.add(cb);
-          };
-        }
-        return target[prop];
-      },
-    });
-    ctr.layerData.controllerProxy = proxy;
-    return proxy as Ctr;
+class FWLayerLifecycleManager {
+  setupLifecycleHooks(layer: FWLayer, ctr: FW.LayerController): void {
+    const originalOnLoad = layer['onLoad'];
+    layer['onLoad'] = function () {
+      originalOnLoad?.call(this);
+      ctr.onLoad?.();
+    };
+
+    const originalStart = layer['start'];
+    layer['start'] = function () {
+      originalStart?.call(this);
+      ctr.onStart?.();
+    };
+
+    const originalOnEnable = layer['onEnable'];
+    layer['onEnable'] = function () {
+      originalOnEnable?.call(this);
+      ctr.onEnable?.();
+    };
+
+    const originalOnDisable = layer['onDisable'];
+    layer['onDisable'] = function () {
+      originalOnDisable?.call(this);
+      ctr.onDisable?.();
+    };
+
+    const originalOnDestroy = layer['onDestroy'];
+    layer['onDestroy'] = function () {
+      originalOnDestroy?.call(this);
+      ctr.onDestroy?.();
+    };
+
+    const originalUpdate = layer['update'];
+    layer['update'] = function (dt: number) {
+      originalUpdate?.call(this, dt);
+      ctr.onUpdate?.(dt);
+    };
+
+    const originalLateUpdate = layer['lateUpdate'];
+    layer['lateUpdate'] = function () {
+      originalLateUpdate?.call(this);
+      ctr.onLateUpdate?.();
+    };
+  }
+}
+
+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并恢复所有节点事件
-   * @param ctr
-   * @returns
    */
   displayLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
     const layerData = ctr.layerData;
 
-    if (!this.layerMap.has(ctr.layerData.controllerConstructor)) {
+    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
       FWLog.warn(`display layer failed,layer name : ${layerData.layerName}`);
       return;
     }
@@ -313,17 +601,17 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
     node.resumeSystemEvents(true);
 
     FW.Entry.evtMgr.targetResume(ctr);
-    FW.Entry.timeMgr.pauseSchedule(ctr);
+    FW.Entry.timeMgr.resumeSchedule(ctr);
+
+    return ctr;
   }
 
   /**
    * 隐藏layer并隐藏所有节点事件
-   * @param ctr
-   * @returns
    */
   hideLayer<Ctr extends FW.LayerController = FW.LayerController>(ctr: Ctr): Ctr {
     const layerData = ctr.layerData;
-    if (!this.layerMap.has(ctr.layerData.controllerConstructor)) {
+    if (!this.dataManager.getLayerMap().has(ctr.layerData.controllerConstructor)) {
       FWLog.warn(`hide layer failed,layer name : ${layerData.layerName}`);
       return;
     }
@@ -335,15 +623,16 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
     node.opacity = 0;
     node.pauseSystemEvents(true);
     FW.Entry.evtMgr.targetPause(ctr);
-    FW.Entry.timeMgr.resumeSchedule(ctr);
+    FW.Entry.timeMgr.pauseSchedule(ctr);
+
+    return ctr;
   }
 
   /**
    * 通过layer名字关闭
-   * @param name
    */
   closeFromLayerName(name: string | string[]): void {
-    this.layerMap.forEach((v) => {
+    this.dataManager.getLayerMap().forEach((v) => {
       if (Array.isArray(name)) {
         name.forEach((n) => {
           if (n === v.layerName) {
@@ -357,15 +646,16 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
       }
     });
   }
+
   /**
    * 从栈关闭
    */
   closeFromStack(count?: number) {
     count = count ? count : 1;
     for (let i = 0; i < count; i++) {
-      let layerData = this.layerStack.pop();
+      let layerData = this.stackManager.pop();
       let ctr = layerData.controller;
-      if (!this.layerMap.has(layerData.controllerConstructor)) {
+      if (!this.dataManager.getLayerMap().has(layerData.controllerConstructor)) {
         return;
       }
       if (cc.isValid(ctr.layer?.node)) {
@@ -373,15 +663,28 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
         if (ctr.autoRelease) {
           FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
         }
-        this.notifyExternalRefUpdates(ctr.layerData);
+        this.dataManager.notifyExternalRefUpdates(ctr.layerData);
       }
-      this.layerMap.delete(layerData.controllerConstructor);
+      this.dataManager.removeFromMap(layerData.controllerConstructor);
     }
   }
+  /**
+   * 移除指定Layer所有子Layer
+   * @param layer
+   * @returns
+   */
+  async removeAllChildren(layer: FW.Layer) {
+    if (cc.isValid(!layer?.node)) return;
+    const layers = layer.node.getComponentsInChildren(FWLayer);
+    layers.forEach((v) => {
+      if (cc.isValid(v?.node)) {
+        v?.ctr?.close();
+      }
+    });
+  }
 
   /**
    * 关闭layer
-   * @param ctr
    */
   async close<Ctr extends FW.LayerController = FW.LayerController>(
     ctr: Ctr,
@@ -397,20 +700,22 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
       if (ctr.autoRelease) {
         FW.Entry.resMgr.releaseAsset(ctr.layerData.layerAssetProperty);
       }
-      this.notifyExternalRefUpdates(ctr.layerData);
+      this.dataManager.notifyExternalRefUpdates(ctr.layerData);
     }
 
-    this.layerMap.delete(layerData.controllerConstructor);
-    this.layerRegistry.delete(ctr.layerData.controllerConstructor);
+    this.dataManager.removeFromMap(layerData.controllerConstructor);
+    this.dataManager.removeFromRegistry(ctr.layerData.controllerConstructor);
 
-    const index = this.layerStack.findIndex((v) => {
+    const index = this.stackManager.getStack().findIndex((v) => {
       v.controller == ctr;
     });
-    this.layerStack.slice(index, 1);
+    if (index > -1) {
+      this.stackManager.getStack().splice(index, 1);
+    }
 
     /** 如果队列中还有等待打开的layer */
-    if (!this.layerQueue.isEmpty()) {
-      const nextLayerData = this.layerQueue.shift();
+    if (!this.queueManager.isEmpty()) {
+      const nextLayerData = this.queueManager.getNextLayer();
       /** 先尝试同步打开 */
       const nextLayer = this.openSync({
         parent: nextLayerData.layerParent,
@@ -432,102 +737,19 @@ export class FWLayerManager extends FWManager implements FW.LayerManager {
     }
   }
 
-  private notifyExternalRefUpdates(layerData: FW.LayerData) {
-    layerData.externalReference.forEach((cb) => {
-      try {
-        cb?.(null);
-      } catch (e) {
-        FWLog.error('External ref update callback error:', e);
-      }
-    });
-    layerData.externalReference.clear();
-  }
-  /** 创建layer */
-  private createLayer(
-    prefab: cc.Prefab,
-    layerComponent: string,
-    renderOrder: number,
-    parent: cc.Node,
-    position: FW.Vec3,
-  ) {
-    parent = parent || FW.Entry.scene?.node;
-
-    position = position || cc.Vec3.ZERO;
-
-    if (!parent.activeInHierarchy || !cc.isValid(parent)) {
-      FWLog.error(`createLayer failed , parent : ${parent}`);
-      return;
-    }
-    const node = cc.instantiate(prefab);
-    const p = cc.v3(position.x, position.y);
-    node.setParent(parent);
-    node.setPosition(p);
-    node.zIndex = renderOrder;
-    !node.getComponent(layerComponent) && node.addComponent(layerComponent);
-    return node.getComponent(FWLayer);
-  }
-
-  private lifecycleProcessing(ctr: FW.LayerController) {
-    const layer = ctr.layer;
-
-    const onLoad = layer['onLoad'];
-    layer['onLoad'] = () => {
-      onLoad?.call(layer);
-      ctr.onLoad?.();
-    };
-
-    const onStart = layer['start'];
-    layer['start'] = () => {
-      onStart?.call(layer);
-      ctr.onStart?.();
-    };
-
-    const onEnable = layer['onEnable'];
-    layer['onEnable'] = () => {
-      onEnable?.call(layer);
-      ctr.onEnable?.();
-    };
-
-    const onDisable = layer['onDisable'];
-    layer['onDisable'] = () => {
-      onDisable?.call(layer);
-      ctr.onDisable?.();
-    };
-
-    const onDestroy = layer['onDestroy'];
-    layer['onDestroy'] = () => {
-      onDestroy?.call(layer);
-      ctr.onDestroy?.();
-    };
-
-    const onUpdate = layer['update'];
-    layer['update'] = (dt?: number) => {
-      onUpdate?.call(layer);
-      ctr.onUpdate?.(dt);
-    };
-
-    const onLateUpdate = layer['lateUpdate'];
-    layer['lateUpdate'] = () => {
-      onLateUpdate?.call(layer);
-      ctr.onLateUpdate?.();
-    };
-  }
-
-  getLayerMap(): Map<new () => FW.LayerController, FW.LayerData> {
-    return this.layerMap;
+  getLayerMap(): Map<new () => FW.LayerController, FWLayerData> {
+    return this.dataManager.getLayerMap();
   }
 
   public clear() {
-    this.layerQueue = new FWQueue();
-    this.layerStack = [];
-    this.layerRegistry = new Set<new () => FW.LayerController>();
-    this.layerMap.forEach((v) => this.close(v.controller));
-    this.layerMap.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.layerMap.clear();
-    this.layerMap = null;
-    this.layerQueue = null;
+    this.clear();
   }
 }