@kkarum/framework 2.3.17

package/manager/FWResManager.ts

@@ -0,0 +1,299 @@
+import { FWLodash } from "../utils/FWLodash";
+import { FWAssetManager } from "./FWAssetManager";
+import { FWBundleManager } from "./FWBundleManager";
+import { FWManager } from "./FWManager";
+
+export class FWResManager extends FWManager implements FW.ResManager {
+  private bundleMgr: FW.BundleManager;
+  private assetMgr: FW.AssetManager;
+  private rejectHandlerListener: FW.ResRejectHandlerListener;
+  public initialize() {
+    this.bundleMgr = new FWBundleManager(this);
+    this.assetMgr = new FWAssetManager(this);
+  }
+
+  registerRejectHandler(listener: FW.ResRejectHandlerListener): void {
+    this.rejectHandlerListener = listener;
+  }
+  /**
+   * 加载bundle
+   * @param bundleName
+   * @returns
+   */
+  async loadBundle(bundleName: string): Promise<cc.AssetManager.Bundle> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const depends = FWLodash.cloneDeep(FW.Entry.getDepend(bundleName));
+        if (depends && depends.length > 0) {
+          for (const depend of depends) {
+            if (depend === undefined) continue;
+
+            if (this.bundleMgr.has(depend)) continue;
+
+            await this.loadBundle(depend);
+
+            const config = FW.Entry.getComponent<FW.AssetConfig>(
+              `${depend}${FW.SystemDefine.FWBindTag.CONFIG}`,
+            );
+            if (!config) continue;
+            const preLoad = config.preLoad;
+            const keys = Object.keys(preLoad);
+
+            if (keys.length > 0) {
+              const preloadRecursive = async (
+                obj: FW.LoadConfig | FW.AssetProperty,
+              ) => {
+                for (const key of Object.keys(obj)) {
+                  const value: any = (obj as any)[key];
+
+                  if (value && typeof value.path === "string") {
+                    const path: string = value.path;
+                    const type: string = value.type;
+                    const d: string = value.bundle || depend;
+                    const priorityLoaded = value.priorityLoaded || false;
+
+                    if (path && priorityLoaded) {
+                      await this.assetMgr.load({
+                        path,
+                        bundle: d,
+                        type,
+                      });
+                    }
+                  } else if (value && typeof value === "object") {
+                    await preloadRecursive(value);
+                  }
+                }
+              };
+              await preloadRecursive(config.preLoad);
+            }
+          }
+        }
+
+        const bundle = await this.bundleMgr.load(bundleName);
+
+        resolve(bundle);
+      } catch (e) {
+        this.rejectHandlerListener?.loadBundleHandler?.(e, bundleName);
+        reject(e);
+      }
+    });
+  }
+  /**
+   * 从远程加载spine动画
+   * @param data
+   * @returns sp.skeletonData
+   */
+  async loadSpineDataFromRemote(data: {
+    img: string;
+    ske: string;
+    atlas: string;
+    bin?: boolean;
+  }): Promise<sp.SkeletonData> {
+    try {
+      return await this.assetMgr.loadSpineDataFromRemote(data);
+    } catch (e) {
+      this.rejectHandlerListener?.loadResHandler?.(e, data.ske);
+      throw e;
+    }
+  }
+
+  async loadRemote<T extends cc.Asset = cc.Asset>(
+    url: string,
+    options?: {
+      ext?: string;
+      enableCache?: boolean;
+      maxRetryCount?: number;
+      texture?: boolean;
+      cb?: (asset: T) => void;
+    },
+  ): Promise<T> {
+    try {
+      const asset = await this.assetMgr.loadRemote(url, options);
+      if (!options?.texture) {
+        return asset as T;
+      } else {
+        if (asset instanceof cc.Texture2D) {
+          return new cc.SpriteFrame(asset) as unknown as T;
+        } else {
+          return asset as T;
+        }
+      }
+    } catch (e) {
+      this.rejectHandlerListener?.loadResHandler?.(e, url);
+      throw e;
+    }
+  }
+
+  /**
+   * 获取bundle
+   * @param bundleName
+   * @returns
+   */
+  getBundle(bundleName: string): cc.AssetManager.Bundle {
+    return this.bundleMgr.get(bundleName);
+  }
+
+  getBundleMap(): Map<string, cc.AssetManager.Bundle> {
+    return this.bundleMgr.getBundleMap();
+  }
+
+  initializeRemoteBundleConfig(config: FW.RemoteBundleConfig) {
+    return this.bundleMgr.initializeRemoteBundleConfig(config);
+  }
+  /**
+   * 释放bundle
+   * @param bundleName
+   * @returns
+   */
+  releaseBundle(bundleName: string): void {
+    this.bundleMgr.release(bundleName);
+  }
+
+  /**
+   * 加载资源数据
+   * @param bundleName
+   * @returns
+   */
+  async loadAssetData<T extends cc.Asset>(assetProperty: FW.AssetProperty) {
+    try {
+      return this.process<T>(await this.assetMgr.load(assetProperty));
+    } catch (e) {
+      this.rejectHandlerListener?.loadResHandler?.(e, assetProperty.path);
+      throw e;
+    }
+  }
+  /**
+   * 加载资源
+   * @param assetProperty
+   * @returns
+   */
+  async loadAsset<T extends cc.Asset>(
+    assetProperty: FW.AssetProperty,
+    texture?: boolean,
+  ): Promise<T> {
+    try {
+      const res = await this.assetMgr.load(assetProperty);
+      if (texture) {
+        return res.asset as T;
+      }
+      return this.process<T>(res).asset as T;
+    } catch (e) {
+      this.rejectHandlerListener?.loadResHandler?.(e, assetProperty.path);
+      throw e;
+    }
+  }
+
+  async preLoad(assetProperty: FW.AssetProperty | FW.AssetProperty[]) {
+    try {
+      return this.assetMgr.preLoad(assetProperty);
+    } catch (e) {
+      const arr = Array.isArray(assetProperty)
+        ? assetProperty
+        : [assetProperty];
+      arr.forEach((item) => {
+        this.rejectHandlerListener?.loadResHandler?.(e, item.path);
+      });
+      throw e;
+    }
+  }
+
+  /**
+   * 加载文件夹
+   */
+  async loadDir(assetProperty: FW.AssetProperty) {
+    try {
+      const res = await this.assetMgr.loadDir(assetProperty);
+      return res;
+    } catch (e) {
+      this.rejectHandlerListener?.loadResHandler?.(e, assetProperty.path);
+      throw e;
+    }
+  }
+
+  /**
+   * 获取资源数据
+   * @param bundleName
+   * @returns
+   */
+  getAssetData<T extends cc.Asset>(
+    assetProperty: FW.AssetProperty,
+    texture?: boolean,
+  ) {
+    const res = this.assetMgr.get(assetProperty);
+    if (texture) {
+      return res;
+    }
+    return this.process<T>(res);
+  }
+  /**
+   * 获取资源
+   * @param assetProperty
+   * @returns
+   */
+  getAsset<T extends cc.Asset>(
+    assetProperty: FW.AssetProperty,
+    texture?: boolean,
+  ): T {
+    const res = this.assetMgr.get(assetProperty);
+    if (texture) {
+      return res.asset as T;
+    }
+    return this.process<T>(res).asset as T;
+  }
+
+  /**
+   * 释放资源
+   * @param bundleName
+   * @returns
+   */
+  releaseAsset(assetProperty: FW.AssetProperty): void {
+    this.assetMgr.release(assetProperty);
+  }
+  /**
+   * 包是否存在
+   * @param bundleName
+   */
+  hasBundle(bundleName: string): boolean {
+    return this.bundleMgr.has(bundleName);
+  }
+  /**
+   * 资源是否存在
+   * @param assetProperty
+   */
+  hasAsset(assetProperty: FW.AssetProperty): boolean {
+    return this.assetMgr.has(assetProperty);
+  }
+
+  /**
+   * 数据处理
+   * @param res
+   * @returns
+   */
+  private process<T extends cc.Asset>(res: FW.AssetData) {
+    let asset: cc.Asset;
+
+    if (res.asset instanceof cc.Texture2D) {
+      asset = new cc.SpriteFrame(res.asset);
+    } else {
+      asset = res.asset as T;
+    }
+
+    return {
+      asset: asset,
+      uuid: res.uuid,
+      user: res.user,
+      depend: res.depend,
+      reference: res.reference,
+      type: res.type,
+      dependentBundle: res.dependentBundle,
+      autoRelease: res.autoRelease,
+      loaded: res.loaded,
+      assetProperty: res.assetProperty,
+    };
+  }
+
+  public onDestroy(): void {
+    this.assetMgr.onDestroy();
+    this.bundleMgr.onDestroy();
+  }
+}

package/manager/FWResManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "fcb5dbc8-82ed-473e-bc81-c3b9b11a6ac6",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWSocketManager.ts

@@ -0,0 +1,93 @@
+import FWSocket from '../service/socket/FWSocket';
+import { FWManager } from './FWManager';
+
+/**
+ * socket管理器
+ */
+export default class FWSocketManager extends FWManager implements FW.SocketManager {
+  protected socketMap: Map<string, FW.Socket>;
+
+  public initialize(): void {
+    this.socketMap = new Map<string, FW.Socket>();
+  }
+  public onDestroy(): void {}
+
+  /**
+   * 创建一个socket
+   * @param address
+   * heartTimeout：number 毫秒
+   * heartWeakTime: number 毫秒
+   * heartInternal: number 毫秒
+   */
+  async createSocket(
+    tag: string,
+    address: string,
+    sender: FW.Sender,
+    handle: FW.Handle,
+    config: FW.SocketConfig,
+  ): Promise<FW.Socket> {
+    const proxy = new FWSocket().createSocket(address, tag, sender, handle, {
+      heartTimeout: config.heartTimeout,
+      heartWeakTime: config.heartWeakTime,
+      heartInternal: config.heartInternal,
+      maxReconnectTimes: config.maxReconnectTimes,
+      reconnectInternal: config.reconnectInternal,
+      protocolSymbol: config.protocolSymbol,
+      protocolPollingTime: config.protocolPollingTime,
+      certificate: config.certificate,
+    });
+    this.socketMap.set(tag, proxy.socket);
+
+    await proxy.promise;
+
+    return proxy.socket;
+  }
+  /**
+   * 获取socket
+   * @param type
+   * @returns
+   */
+  getSocket(tag?: string) {
+    if (!this.socketMap.has(tag)) {
+      for (const [key, value] of this.socketMap) {
+        return value;
+      }
+    }
+    return this.socketMap.get(tag);
+  }
+
+  getSocketMap() {
+    return this.socketMap;
+  }
+  /** 暂停消息处理 */
+  pauseMessageHandle() {
+    for (const [key, socket] of this.socketMap) {
+      socket.pauseMessageHandle();
+    }
+  }
+
+  closeAll(): void {
+    for (const [key, socket] of this.socketMap) {
+      this.closeSocket(socket);
+    }
+    this.socketMap.clear();
+  }
+
+  /** 恢复消息处理 */
+  resumeMessageHandle() {
+    for (const [key, socket] of this.socketMap) {
+      socket.resumeMessageHandle();
+    }
+  }
+
+  /**
+   * 关闭
+   * @param fs
+   * @returns
+   */
+  closeSocket(fs: FW.Socket) {
+    FW.Log.debug('主动关闭socket!');
+    fs.close();
+    this.socketMap.delete(fs.getTag());
+  }
+}

package/manager/FWSocketManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "0100af82-a0d2-4359-b2b7-3a384f150ce1",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWStateManager.ts

@@ -0,0 +1,100 @@
+import { FWManager } from './FWManager';
+import FWStateMachine from '../machine/FWStateMachine';
+
+export class FWStateManager extends FWManager implements FW.StateManager {
+  private stateMap: Map<string, FWStateMachine>;
+
+  public initialize(): void {
+    this.stateMap = new Map<string, FWStateMachine>();
+  }
+
+  /**
+   * 注册状态进指定状态机
+   * @param stateMachineName
+   * @param state
+   * @returns
+   */
+  register(
+    state: FW.StateMachineRegisterArgs | FW.StateMachineRegisterArgs[],
+    stateMachineName?: string,
+  ) {
+    stateMachineName = stateMachineName || FW.Entry.bundleName;
+
+    if (!this.stateMap.has(stateMachineName)) {
+      FW.Log.warn('stateMachine is not register!');
+      return;
+    }
+    const machine = this.stateMap.get(stateMachineName);
+
+    if (Array.isArray(state)) {
+      state.forEach((v) => machine.register(v));
+    } else {
+      machine.register(state);
+    }
+  }
+  /**
+   * 注销指定状态机的某个状态
+   * @param stateMachineName
+   * @param stateType
+   */
+  unRegister(stateType: number, stateMachineName?: string) {
+    stateMachineName = stateMachineName || FW.Entry.bundleName;
+    if (!this.stateMap.has(stateMachineName)) {
+      FW.Log.warn('stateMachine is not register!');
+      return;
+    }
+    this.stateMap.get(stateMachineName).unRegister(stateType);
+  }
+
+  /**
+   * 创建一个状态机
+   * @param stateMachineName
+   */
+  createStateMachine(stateMachineName?: string): FW.StateMachine {
+    stateMachineName = stateMachineName || FW.Entry.bundleName;
+    if (this.stateMap.has(stateMachineName)) {
+      this.stateMap.delete(stateMachineName);
+    }
+    const machine = new FWStateMachine();
+    this.stateMap.set(stateMachineName, machine);
+    return machine;
+  }
+  /**
+   * 移除一个状态机
+   * @param stateMachineName
+   * @returns
+   */
+  removeStateMachine(stateMachineName?: string) {
+    stateMachineName = stateMachineName || FW.Entry.bundleName;
+    if (!this.stateMap.has(stateMachineName)) {
+      return;
+    }
+    this.stateMap.delete(stateMachineName);
+  }
+  /**
+   * 暂停一个状态机
+   * @param stateMachineName
+   * @returns
+   */
+  pauseStateMachine(stateMachineName?: string) {
+    stateMachineName = stateMachineName || FW.Entry.bundleName;
+    if (!this.stateMap.has(stateMachineName)) {
+      return;
+    }
+    this.stateMap.get(stateMachineName).pause();
+  }
+  /**
+   * 恢复状态机
+   * @param stateMachineName
+   * @returns
+   */
+  resumeStateMachine(stateMachineName?: string) {
+    stateMachineName = stateMachineName || FW.Entry.bundleName;
+    if (!this.stateMap.has(stateMachineName)) {
+      this.createStateMachine(stateMachineName);
+    }
+    this.stateMap.get(stateMachineName).resume();
+  }
+
+  public onDestroy(): void {}
+}

package/manager/FWStateManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "23fb111f-4904-4335-9433-f24147af47c9",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWTaskManager.ts

@@ -0,0 +1,41 @@
+import FWTask from '../utils/FWTask';
+import { FWManager } from './FWManager';
+
+export default class FWTaskManager extends FWManager implements FW.TaskManager {
+  public initialize(): void {}
+  public onDestroy(): void {
+    this.tasks.forEach((task) => task.stop());
+  }
+  /**
+   * 任务合集
+   */
+  private tasks: Map<number, FWTask> = new Map<number, FWTask>();
+  /**
+   * 任务id
+   */
+  private taskId = 0;
+
+  createTask(options?: Partial<FW.TaskOptions>): FW.Task {
+    const task = new FWTask({
+      tasksFrameCount: options?.tasksFrameCount,
+      frameBudget: options?.frameBudget,
+      taskId: options?.taskId || ++this.taskId,
+      log: options?.log,
+    });
+    this.tasks.set(task.id, task); 
+    return task;
+  }
+
+  getTask(taskId: number): FW.Task | undefined {
+    return this.tasks.get(taskId);
+  }
+ 
+  stopTask(taskId: number): void {
+    this.tasks.get(taskId)?.stop();
+    this.tasks.delete(taskId);
+  }
+
+  getAllTasks(): FW.Task[] {
+    return Array.from(this.tasks.values());
+  }
+}

package/manager/FWTaskManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "cd43dfbe-fd5d-4f6b-94de-01bc5c0a8368",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}