@ives_xxz/framework 1.0.0

package/manager/FWResManager.ts

@@ -0,0 +1,171 @@
+import { FWAssetManager } from './FWAssetManager';
+import { FWBundleManager } from './FWBundleManager';
+import { FWManager } from './FWManager';
+
+export class FWResManager extends FWManager implements FW.ResManager {
+  bundleMgr: FW.BundleManager;
+  assetMgr: FW.AssetManager;
+
+  public initialize() {
+    this.bundleMgr = new FWBundleManager(this);
+    this.assetMgr = new FWAssetManager(this);
+    this.bundleMgr.initialize();
+    this.assetMgr.initialize();
+  }
+
+  /**
+   * 加载bundle
+   * @param bundleName
+   * @returns
+   */
+  async loadBundle(bundleName: string): Promise<cc.AssetManager.Bundle> {
+    return this.bundleMgr.load(bundleName);
+  }
+  /**
+   * 从远程加载spine动画
+   * @param data
+   * @returns sp.skeletonData
+   */
+  async loadSpineDataFromRemote(data: {
+    img: string;
+    ske: string;
+    atlas: string;
+    bin?: boolean;
+  }): Promise<sp.SkeletonData> {
+    return await this.assetMgr.loadSpineDataFromRemote(data);
+  }
+
+  async loadRemote<T extends cc.Asset = cc.Asset>(url: string, cb: (asset: any) => T): Promise<T> {
+    const asset = await this.assetMgr.loadRemote(url);
+    if (asset instanceof cc.Texture2D) {
+      return new cc.SpriteFrame(asset) as unknown as T;
+    } else {
+      return asset as T;
+    }
+  }
+
+  /**
+   * 获取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) {
+    return this.dataProcessing<T>(await this.assetMgr.load(assetProperty));
+  }
+  /**
+   * 加载资源
+   * @param assetProperty
+   * @returns
+   */
+  async loadAsset<T extends cc.Asset>(assetProperty: FW.AssetProperty): Promise<T> {
+    const res = await this.assetMgr.load(assetProperty);
+    return this.dataProcessing<T>(res).asset as T;
+  }
+
+  /**
+   * 加载文件夹
+   */
+  async loadDir(assetProperty: FW.AssetProperty) {
+    const res = await this.assetMgr.loadDir(assetProperty);
+
+    return res;
+  }
+
+  /**
+   * 获取资源数据
+   * @param bundleName
+   * @returns
+   */
+  getAssetData<T extends cc.Asset>(assetProperty: FW.AssetProperty) {
+    return this.dataProcessing<T>(this.assetMgr.get(assetProperty));
+  }
+  /**
+   * 获取资源
+   * @param assetProperty
+   * @returns
+   */
+  getAsset<T extends cc.Asset>(assetProperty: FW.AssetProperty): T {
+    return this.dataProcessing<T>(this.assetMgr.get(assetProperty)).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 dataProcessing<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,
+      refCount: res.refCount,
+    };
+  }
+
+  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,94 @@
+import FWLog from '../log/FWLog';
+import FWSocket from '../service/socket/FWSocket';
+import FWSocketHandle from '../service/socket/FWSocketHandle';
+import FWSocketSender from '../service/socket/FWSocketSender';
+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: FWSocketSender,
+    handle: FWSocketHandle,
+    config: {
+      heartTimeout: number;
+      heartWeakTime: number;
+      heartInternal: number;
+      maxReconnectTimes: number;
+      reconnectInternal: number;
+    },
+  ) {
+    const proxy = new FWSocket().createSocket(address, tag, sender, handle, {
+      heartTimeout: config?.heartTimeout,
+      heartWeakTime: config?.heartWeakTime,
+      heartInternal: config?.heartInternal,
+      maxReconnectTimes: config?.maxReconnectTimes,
+      reconnectInternal: config?.reconnectInternal,
+    });
+    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();
+    }
+  }
+
+  /** 恢复消息处理 */
+  resumeMessageHandle() {
+    for (const [key, socket] of this.socketMap) {
+      socket.resumeMessageHandle();
+    }
+  }
+
+  /**
+   * 关闭
+   * @param fs
+   * @returns
+   */
+  closeSocket(fs: FWSocket) {
+    FWLog.debug('主动关闭socket!');
+    const tag = fs.getTag();
+    fs.socket.close();
+    fs.socket = null;
+    this.socketMap.delete(tag);
+  }
+}

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,102 @@
+import { FWManager } from './FWManager';
+import Framework from '../Framework';
+import FWLog from '../log/FWLog';
+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)) {
+      FWLog.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)) {
+      FWLog.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,38 @@
+import FWTask from '../utils/FWTask';
+import { FWManager } from './FWManager';
+
+export default class FWTaskManager extends FWManager implements FW.TaskManager {
+  public initialize(): void {}
+  public onDestroy(): void {}
+  /**
+   * 任务合集
+   */
+  private tasks: Map<number, FWTask> = new Map();
+  /**
+   * 任务id
+   */
+  private taskId = 0;
+
+  createTask(options: 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);
+  }
+
+  removeTask(taskId: number): void {
+    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": {}
+}