@ives_xxz/framework 1.0.0

package/manager/FWEventManager.ts

@@ -0,0 +1,275 @@
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLog from '../log/FWLog';
+
+/**
+ * 观察者
+ */
+class FWObserver implements FW.Observer {
+  private pause: boolean;
+  /**
+   * 构造函数
+   * @param eventName 事件名字
+   * @param cb 回调函数
+   * @param target 观察目标
+   */
+  constructor(
+    private readonly eventName: string | number,
+    private readonly cb: () => void,
+    private readonly target: FW.TargetType,
+    public readonly priority: number,
+    public readonly intercept: boolean,
+  ) {
+    this.cb = cb;
+    this.target = target;
+    this.pause = false;
+  }
+
+  /**
+   * 消息通知
+   * @param args
+   */
+  public notify(
+    args1?: FW.EventManagerArgs,
+    args2?: FW.EventManagerArgs,
+    args3?: FW.EventManagerArgs,
+    args4?: FW.EventManagerArgs,
+    args5?: FW.EventManagerArgs,
+    args6?: FW.EventManagerArgs,
+    args7?: FW.EventManagerArgs,
+    args8?: FW.EventManagerArgs,
+    args9?: FW.EventManagerArgs,
+    args10?: FW.EventManagerArgs,
+  ) {
+    if (this.pause) return;
+    this.cb.call(
+      this.target,
+      args1,
+      args2,
+      args3,
+      args4,
+      args5,
+      args6,
+      args7,
+      args8,
+      args9,
+      args10,
+    );
+  }
+  /**
+   * 目标比较
+   * @param target 目标对象
+   * @returns
+   */
+  public compar(target: FW.TargetType) {
+    return (
+      this.target === target || (this.target.uuid && target.uuid && this.target.uuid == target.uuid)
+    );
+  }
+
+  /**
+   * 获取当前绑定事件名字
+   * @returns
+   */
+  public getEventName() {
+    return this.eventName;
+  }
+
+  /** 暂停观察 */
+  public pauseObserver() {
+    this.pause = true;
+  }
+  /** 恢复观察 */
+  public resumeObserver() {
+    this.pause = false;
+  }
+}
+
+/**
+ * 事件管理器
+ */
+export default class FWEventManager implements FW.EventManager {
+  private listeners: { [key: string]: FW.Observer[] } = cc.js.createMap();
+
+  public initialize(): void {
+    this.listeners = cc.js.createMap();
+  }
+
+  /**
+   * 事件派发
+   * @param eventName 事件名
+   * @param args 参数列表
+   * @returns
+   */
+  public dispatch(
+    eventName: string | number,
+    args1?: FW.EventManagerArgs,
+    args2?: FW.EventManagerArgs,
+    args3?: FW.EventManagerArgs,
+    args4?: FW.EventManagerArgs,
+    args5?: FW.EventManagerArgs,
+    args6?: FW.EventManagerArgs,
+    args7?: FW.EventManagerArgs,
+    args8?: FW.EventManagerArgs,
+    args9?: FW.EventManagerArgs,
+    args10?: FW.EventManagerArgs,
+  ) {
+    const observers = this.listeners[eventName];
+    if (!observers) return;
+    let shouldStopPropagation = false;
+    for (const observer of observers) {
+      if (shouldStopPropagation) break;
+      observer.notify(args1, args2, args3, args4, args5, args6, args7, args8, args9, args10);
+      if (observer.intercept) {
+        shouldStopPropagation = true;
+      }
+    }
+  }
+
+  /**
+   * 事件注册
+   * @param eventName 事件名
+   * @param cb 回调函数
+   * @param target 事件回调绑定目标
+   */
+  public register(
+    eventName: string | number,
+    cb: (
+      args1?: FW.EventManagerArgs,
+      args2?: FW.EventManagerArgs,
+      args3?: FW.EventManagerArgs,
+      args4?: FW.EventManagerArgs,
+      args5?: FW.EventManagerArgs,
+      args6?: FW.EventManagerArgs,
+      args7?: FW.EventManagerArgs,
+      args8?: FW.EventManagerArgs,
+      args9?: FW.EventManagerArgs,
+      args10?: FW.EventManagerArgs,
+    ) => void,
+    target: FW.TargetType,
+    options?: {
+      priority?: FWSystemDefine.FWPriorityOrder;
+      intercept?: boolean;
+    },
+  ) {
+    const observers = this.listeners[eventName];
+    const define = FWSystemDefine.FWPriorityOrder;
+    const priority = options?.priority === undefined ? define.NORMAL : options.priority;
+    const intercept = options?.intercept === undefined ? false : options.intercept;
+    const observer = new FWObserver(eventName, cb, target, priority, intercept);
+    if (!observers) {
+      this.listeners[eventName] = [];
+    }
+    const order = Object.values(define);
+    const insertIndex = this.listeners[eventName].findIndex(
+      (o) => order[o.priority] > order[priority],
+    );
+    if (insertIndex === -1) {
+      this.listeners[eventName].push(observer);
+    } else {
+      this.listeners[eventName].splice(insertIndex, 0, observer);
+    }
+  }
+
+  /**
+   * 注销事件
+   * @param eventName
+   * @param target
+   * @returns
+   */
+  public unRegister(eventName: string, target: Comment | Object) {
+    const observers = this.listeners[eventName];
+    if (!observers) return;
+    for (const observer of observers) {
+      if (observer.getEventName() === eventName && observer.compar(target)) {
+        observers.splice(observers.indexOf(observer), 1);
+        if (observers.length == 0) {
+          delete this.listeners[eventName];
+        }
+      }
+    }
+  }
+
+  /**
+   * 目标对象是否注册了指定事件
+   * @param eventName
+   * @param target
+   * @returns
+   */
+  has(eventName: string | number, target: Comment | Object): boolean {
+    const observers = this.listeners[eventName];
+    if (!observers) return false;
+    for (const observer of observers) {
+      if (observer.getEventName() === eventName && observer.compar(target)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /** 关闭事件 */
+  public eventOff(eventName: string | number) {
+    const observers = this.listeners[eventName];
+    if (!observers) return;
+    for (const observer of observers) {
+      if (observer.getEventName() === eventName) {
+        observers.splice(observers.indexOf(observer), 1);
+        if (observers.length == 0) {
+          delete this.listeners[eventName];
+        }
+      }
+    }
+  }
+
+  /**
+   * 注销对象身上所有事件
+   * @param target
+   */
+  public targetOff(target: FW.TargetType) {
+    Object.keys(this.listeners).forEach((eventName) => {
+      const observers = this.listeners[eventName];
+      for (const observer of observers) {
+        if (observer.compar(target)) {
+          observers.splice(observers.indexOf(observer), 1);
+          if (observers.length == 0) {
+            delete this.listeners[eventName];
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * 暂停所有已注册事件
+   * @param target
+   */
+  public targetPause(target: Comment | Object | Node) {
+    Object.keys(this.listeners).forEach((eventName) => {
+      const observers = this.listeners[eventName];
+      for (const observer of observers) {
+        if (observer.compar(target)) {
+          observer.pauseObserver();
+        }
+      }
+    });
+  }
+
+  /**
+   * 恢复所有已注册事件
+   * @param target
+   */
+  public targetResume(target: Comment | Object | Node) {
+    Object.keys(this.listeners).forEach((eventName) => {
+      const observers = this.listeners[eventName];
+      for (const observer of observers) {
+        if (observer.compar(target)) {
+          observer.resumeObserver();
+        }
+      }
+    });
+  }
+
+  /** 销毁 */
+  public onDestroy(): void {
+    this.listeners = cc.js.createMap();
+  }
+}

package/manager/FWEventManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "38cc4633-8a5d-4f6f-ab3e-33a8202c65ad",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWHotUpdateManager.ts

@@ -0,0 +1,213 @@
+import FWLog from '../log/FWLog';
+import { FWManager } from './FWManager';
+
+export default class FWHotUpdateManager extends FWManager implements FW.HotUpdateManager {
+  private listener: FW.HotUpdateListener;
+  private assetMgr: any;
+  private storePath: string;
+  private isUpdate: boolean;
+  private localManifest: cc.Asset;
+  private isRetry: boolean;
+
+  setListener(listener: FW.HotUpdateListener): void {
+    this.listener = listener;
+  }
+
+  public update(localManifest: cc.Asset) {
+    if (!localManifest) {
+      FWLog.error('没有找到本地Manifest文件!');
+      return;
+    }
+    this.localManifest = localManifest;
+    this.assetMgr = new jsb.AssetsManager('', this.storePath, this.versionCompareHandle);
+    this.assetMgr.setVerifyCallback(function (path: string, asset: any) {
+      const compressed = asset.compressed;
+      const expectedMD5 = asset.md5;
+      const relativePath = asset.path;
+      const size = asset.size;
+      if (compressed) {
+        return true;
+      } else {
+        return true;
+      }
+    });
+    this.checkHotUpdate();
+  }
+
+  private versionCompareHandle(currentVersion: string, newVersion: string): number {
+    this.listener.versionCompareHandle(currentVersion, newVersion);
+    var vA = currentVersion.split('.');
+    var vB = newVersion.split('.');
+    for (var i = 0; i < vA.length; ++i) {
+      var a = parseInt(vA[i]);
+      var b = parseInt(vB[i] || '0');
+      if (a === b) {
+        continue;
+      } else {
+        return a - b;
+      }
+    }
+    if (vB.length > vA.length) {
+      return -1;
+    } else {
+      return 0;
+    }
+  }
+
+  private retry() {
+    if (!this.isUpdate && this.isRetry) {
+      this.isRetry = false;
+      this.assetMgr.downloadFailedAssets();
+      this.listener.retryHandle?.();
+    }
+  }
+
+  private checkHotUpdate() {
+    if (this.isUpdate) {
+      return;
+    }
+    if (this.assetMgr.getState() === jsb.AssetsManager.State.UNINITED) {
+      this.assetMgr.loadLocalManifest(this.localManifest.nativeUrl);
+    }
+    if (!this.assetMgr.getLocalManifest() || !this.assetMgr.getLocalManifest().isLoaded()) {
+      return;
+    }
+    this.assetMgr.setEventCallback(this.checkEventHandle.bind(this));
+    this.assetMgr.checkUpdate();
+    this.isUpdate = true;
+  }
+
+  private checkEventHandle(event: any) {
+    const code = event.getEventCode();
+    FWLog.debug('getEventCode -> ', code);
+    switch (code) {
+      case jsb.EventAssetsManager.ERROR_NO_LOCAL_MANIFEST:
+        FWLog.debug('getEventCode -> ', 'ERROR_NO_LOCAL_MANIFEST');
+        break;
+      case jsb.EventAssetsManager.ERROR_DOWNLOAD_MANIFEST:
+        FWLog.debug('getEventCode -> ', 'ERROR_DOWNLOAD_MANIFEST');
+        break;
+      case jsb.EventAssetsManager.ERROR_PARSE_MANIFEST:
+        FWLog.debug('getEventCode -> ', 'ERROR_PARSE_MANIFEST');
+        break;
+      case jsb.EventAssetsManager.ALREADY_UP_TO_DATE:
+        FWLog.debug('getEventCode -> ', 'ALREADY_UP_TO_DATE');
+        break;
+      case jsb.EventAssetsManager.NEW_VERSION_FOUND:
+        FWLog.debug('getEventCode -> ', 'NEW_VERSION_FOUND');
+        break;
+      default:
+        return;
+    }
+
+    this.listener.checkHotUpdateHandle?.(code);
+    this.assetMgr.setEventCallback(null!);
+    this.isUpdate = false;
+
+    if (event.getEventCode() == jsb.EventAssetsManager.NEW_VERSION_FOUND) {
+      this.hotUpdate();
+    }
+  }
+
+  private hotUpdate() {
+    if (this.assetMgr && !this.isUpdate) {
+      this.assetMgr.setEventCallback(this.updateEventHandle.bind(this));
+
+      if (this.assetMgr.getState() === jsb.AssetsManager.State.UNINITED) {
+        this.assetMgr.loadLocalManifest(this.localManifest.nativeUrl);
+      }
+      this.isUpdate = true;
+      this.assetMgr.update();
+    }
+  }
+
+  private updateEventHandle(event: any) {
+    let needRestart = false;
+    let failed = false;
+    let percent: number = 0;
+    let downloadedFiles: number = 0;
+    let totalFiles: number = 0;
+    let downloadedBytes: number = 0;
+    let totalBytes: number = 0;
+    let convertDownloadedBytes: string = '';
+    let convertTotalBytes: string = '';
+    const code = event.getEventCode();
+    const msg = event.getMessage();
+    switch (code) {
+      case jsb.EventAssetsManager.ERROR_NO_LOCAL_MANIFEST:
+        failed = true;
+        break;
+      case jsb.EventAssetsManager.UPDATE_PROGRESSION:
+        if (event.getPercent() > 0) {
+          downloadedFiles = event.getDownloadedFiles();
+          totalFiles = event.getTotalFiles();
+          downloadedBytes = event.getDownloadedBytes();
+          totalBytes = event.getTotalBytes();
+          convertDownloadedBytes = this.convertBytes(downloadedBytes);
+          convertTotalBytes = this.convertBytes(totalBytes);
+          percent = event.getPercent();
+        }
+        break;
+      case jsb.EventAssetsManager.ERROR_DOWNLOAD_MANIFEST:
+        break;
+      case jsb.EventAssetsManager.ERROR_PARSE_MANIFEST:
+        failed = true;
+        break;
+      case jsb.EventAssetsManager.ALREADY_UP_TO_DATE:
+        failed = true;
+        break;
+      case jsb.EventAssetsManager.UPDATE_FINISHED:
+        needRestart = true;
+        break;
+      case jsb.EventAssetsManager.UPDATE_FAILED:
+        this.isUpdate = false;
+        this.isRetry = true;
+        break;
+      case jsb.EventAssetsManager.ERROR_UPDATING:
+        break;
+      case jsb.EventAssetsManager.ERROR_DECOMPRESS:
+        break;
+      default:
+        break;
+    }
+
+    this.listener.hotUpdatingHandle?.(code, {
+      percent: percent,
+      downloadedFiles: downloadedFiles,
+      totalFiles: totalFiles,
+      downloadedBytes: downloadedBytes,
+      totalBytes: totalBytes,
+      convertDownloadedBytes: convertDownloadedBytes,
+      convertTotalBytes: convertTotalBytes,
+    });
+
+    if (failed) {
+      this.assetMgr.setEventCallback(null!);
+      this.isUpdate = false;
+      this.retry();
+    }
+
+    if (needRestart) {
+      this.assetMgr.setEventCallback(null!);
+      var searchPaths = jsb.fileUtils.getSearchPaths();
+      var newPaths = this.assetMgr.getLocalManifest().getSearchPaths();
+      Array.prototype.unshift.apply(searchPaths, newPaths);
+      jsb.fileUtils.setSearchPaths(searchPaths);
+      this.listener.completedHandle?.();
+    }
+  }
+
+  private convertBytes(bytes: number) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes,
+      unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    return `${size.toFixed(size < 10 ? 2 : 1)} ${units[unitIndex]}`;
+  }
+
+  public initialize(): void {}
+  public onDestroy(): void {}
+}

package/manager/FWHotUpdateManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "571aa683-820e-439a-8fa7-dcf218f0fe42",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWLanguageManager.ts

@@ -0,0 +1,116 @@
+import FWLog from '../log/FWLog';
+import { FWEventDefine } from '../define/FWEventDefine';
+import { FWManager } from './FWManager';
+
+export default class FWLanguageManager extends FWManager implements FW.LanguageManager {
+  public initialize(): void {
+    this.bundles = [];
+    this.language = '';
+    this.languagePackageEnum = {};
+    this.languagePackageGetters = {};
+    this.supportedLanguages = [];
+  }
+  public onDestroy(): void {}
+  /** 语言包枚举 */
+  private languagePackageEnum: Record<string, any>;
+  /** 语言包获取的映射方法 */
+  private languagePackageGetters: Record<string, (key: string, language?: string) => string>;
+  /** 当前语言 */
+  private language: string;
+  /** 注册了语言包的bundle */
+  private bundles: string[];
+  /** 支持的所有语言代码数组 */
+  private supportedLanguages: string[];
+
+  /**
+   * 获取当前语言
+   * @returns
+   */
+  getLanguage(): string {
+    return this.language;
+  }
+
+  /**
+   * 获取语言包
+   * @param bundleName
+   * @returns
+   */
+  getLanguagePackageEnum<K extends keyof FW.ILanguageBundleAccessor>(
+    bundleName: K,
+  ): FW.ILanguageBundleAccessor[K] {
+    return this.languagePackageEnum[bundleName as string];
+  }
+
+  getBundles(): string[] {
+    return this.bundles;
+  }
+
+  /**
+   * 注册语言包
+   * @param bundleName
+   * @param language
+   */
+  registerLanguagePackageEnum(
+    bundleName: string,
+    languagePackage: any,
+    getter: (key: string, language?: string) => string,
+  ): void {
+    const languageEnum = cc.Enum(languagePackage);
+    this.languagePackageEnum[bundleName] = languageEnum;
+    this.languagePackageGetters[bundleName] = getter;
+    !this.bundles.includes(bundleName) && this.bundles.push(bundleName);
+  }
+
+  public getLanguagePackageValue(bundleName: string, key: string, language?: string): string {
+    const getter = this.languagePackageGetters[bundleName];
+    if (getter) {
+      return getter(key, language);
+    }
+    if (CC_DEBUG) {
+      return key;
+    } else {
+      return '';
+    }
+  }
+
+  getLanguagePackageEnumKeys(bundleName: string) {
+    const languageEnum = this.languagePackageEnum[bundleName];
+    if (languageEnum) {
+      return Object.keys(languageEnum) as string[];
+    }
+    return [];
+  }
+
+  getLanguagePackageEnumValues(bundleName: string) {
+    const languageEnum = this.languagePackageEnum[bundleName];
+    if (languageEnum) {
+      return Object.values(languageEnum) as string[];
+    }
+    return [];
+  }
+
+  async initializeLanguage(language: string) {
+    if (this.language == language) return;
+    this.language = language;
+    FW.Entry.evtMgr.dispatch(FWEventDefine.LanguageEvent.LANGUAGE_CHANGE);
+  }
+
+  getLanguageIndex() {
+    return ['', ...this.getSupportedLanguages()].indexOf(this.language);
+  }
+
+  /**
+   * 获取支持的所有语言
+   */
+  getSupportedLanguages(): string[] {
+    return [...this.supportedLanguages]; // 返回副本
+  }
+
+  /**
+   * 设置支持的语言
+   * @param languages 语言代码数组
+   */
+  setSupportedLanguages(languages: string[]): void {
+    this.supportedLanguages = [...new Set(languages)];
+  }
+}

package/manager/FWLanguageManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "f49eb371-9e22-4f44-927b-8e102cc92242",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}