@kkarum/framework 2.3.17

package/manager/FWAudioManager.ts

@@ -0,0 +1,339 @@
+import { FWManager } from './FWManager';
+
+class FWAudioData {
+  clip: cc.AudioClip;
+  volume: number = 1;
+  loop: boolean = false;
+  cb?: (id: number) => void;
+  tag?: string;
+}
+
+class FWAudioPoolItem {
+  constructor(
+    public audioId: number,
+    public startTime: number,
+    public tag?: string,
+  ) {}
+}
+
+export default class FWAudioManager extends FWManager implements FW.AudioManager {
+  musicVolume: number = 1;
+  effectsVolume: number = 1;
+  soundVolume: number = 1;
+
+  private audioPool: Map<number, FWAudioPoolItem> = new Map();
+  private maxConcurrentAudio: number = 1000;
+  private cleanupInterval: number = 5;
+
+  public initialize(): void {
+    this.autoClear();
+  }
+
+  /**
+   * 播放背景音乐
+   */
+  async playMusic(path: string, volume?: number, loop?: boolean): Promise<void>;
+  async playMusic(music: cc.AudioClip, volume?: number, loop?: boolean): Promise<void>;
+  async playMusic(assetProperty: FW.AssetProperty, volume?: number, loop?: boolean): Promise<void>;
+  async playMusic(): Promise<void> {
+    try {
+      const audioData = await this.processAudioArguments(
+        arguments,
+        FW.SystemDefine.FWAudioType.MUSIC,
+      );
+      if (!audioData.clip) return;
+
+      const volume = audioData.volume ?? this.musicVolume;
+      const loop = audioData.loop ?? true;
+
+      cc.audioEngine.stopMusic();
+      const id = cc.audioEngine.playMusic(audioData.clip, loop);
+      cc.audioEngine.setVolume(id, volume);
+
+      FW.Log.debug(`播放背景音乐: ${this.getAudioName(audioData.clip)}`);
+    } catch (e) {
+      FW.Log.error('播放音乐失败:', e);
+    }
+  }
+
+  stopMusic(): void {
+    cc.audioEngine.stopMusic();
+  }
+
+  pauseMusic(): void {
+    cc.audioEngine.pauseMusic();
+  }
+
+  resumeMusic(): void {
+    cc.audioEngine.resumeMusic();
+  }
+
+  /** 设置背景音效是否静音 */
+  setMusicMute(mute: boolean): void {
+    this.musicVolume = mute ? 0 : 1;
+    cc.audioEngine.setMusicVolume(this.musicVolume);
+  }
+
+  /**
+   * 播放音效
+   */
+  async play(
+    path: string,
+    cb?: (id: number) => void,
+    volume?: number,
+    loop?: boolean,
+    tag?: string,
+  ): Promise<number>;
+  async play(
+    audio: cc.AudioClip,
+    cb?: (id: number) => void,
+    volume?: number,
+    loop?: boolean,
+    tag?: string,
+  ): Promise<number>;
+  async play(
+    assetProperty: FW.AssetProperty,
+    cb?: (id: number) => void,
+    volume?: number,
+    loop?: boolean,
+    tag?: string,
+  ): Promise<number>;
+  async play(): Promise<number> {
+    if (this.audioPool.size >= this.maxConcurrentAudio) {
+      this.clearFinishedAudio();
+      if (this.audioPool.size >= this.maxConcurrentAudio) {
+        FW.Log.warn('音频池已满，无法播放新音频');
+        return -1;
+      }
+    }
+
+    const audioData = await this.processAudioArguments(
+      arguments,
+      FW.SystemDefine.FWAudioType.SOUND,
+    );
+    if (!audioData.clip) return -1;
+
+    try {
+      return new Promise<number>(async (resolve, reject) => {
+        const volume = (audioData.volume ?? this.soundVolume) * this.effectsVolume;
+        const loop = audioData.loop ?? false;
+        const tag = audioData.tag;
+
+        const id = cc.audioEngine.play(audioData.clip, loop, volume);
+
+        this.audioPool.set(id, new FWAudioPoolItem(id, Date.now(), tag));
+
+        cc.audioEngine.setFinishCallback(id, () => {
+          audioData.cb?.(id);
+          resolve(id);
+          this.audioPool.delete(id);
+        });
+
+        return id;
+      });
+    } catch (e) {
+      FW.Log.error('播放音效失败:', e);
+      return -1;
+    }
+  }
+
+  /**
+   * 停止指定音效
+   */
+  stop(id: number): void {
+    if (this.audioPool.has(id)) {
+      cc.audioEngine.stop(id);
+      this.audioPool.delete(id);
+      FW.Log.debug(`停止音效: ID ${id}`);
+    }
+  }
+
+  pauseAll(): void {
+    cc.audioEngine.pauseAll();
+    FW.Log.debug('暂停所有音效');
+  }
+
+  resumeAll(): void {
+    cc.audioEngine.resumeAll();
+    FW.Log.debug('恢复所有音效');
+  }
+
+  stopAll(): void {
+    cc.audioEngine.stopAll();
+    this.audioPool.clear();
+    FW.Log.debug('停止所有音效');
+  }
+
+  /** 设置播放音效是否静音 */
+  setSoundMute(mute: boolean): void {
+    this.soundVolume = mute ? 0 : 1;
+    FW.Log.debug(`音效${mute ? '静音' : '取消静音'}`);
+  }
+
+  /**
+   * 预加载音频资源
+   */
+  async preloadAudio(assetProperty: FW.AssetProperty): Promise<cc.AudioClip> {
+    try {
+      let clip: cc.AudioClip;
+
+      if (typeof assetProperty === 'string') {
+        clip = await FW.Entry.resMgr.loadAsset<cc.AudioClip>({
+          path: assetProperty,
+          bundle: FW.Entry.bundleName,
+        });
+      } else {
+        clip = await FW.Entry.resMgr.loadAsset<cc.AudioClip>(assetProperty);
+      }
+
+      return clip;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * 释放音频资源
+   */
+  releaseAudio(assetProperty: FW.AssetProperty): void {
+    FW.Entry.resMgr.releaseAsset(assetProperty);
+  }
+
+  /**
+   * 获取音频池信息
+   */
+  getAudioPoolInfo(): { playing: number; maxConcurrent: number } {
+    return {
+      playing: this.audioPool.size,
+      maxConcurrent: this.maxConcurrentAudio,
+    };
+  }
+
+  /**
+   * 设置最大并发音频数
+   */
+  setMaxConcurrentAudio(max: number): void {
+    this.maxConcurrentAudio = Math.max(1, max);
+  }
+
+  /**
+   * 根据标签停止音效
+   */
+  stopByTag(tag: string): void {
+    const arr: number[] = [];
+
+    this.audioPool.forEach((item, id) => {
+      if (item.tag === tag) {
+        arr.push(id);
+      }
+    });
+
+    arr.forEach((id) => {
+      this.stop(id);
+    });
+  }
+
+  /**
+   * 处理音频参数
+   */
+  private async processAudioArguments(
+    args: IArguments,
+    type: FW.SystemDefine.FWAudioType,
+  ): Promise<FWAudioData> {
+    const audioData = new FWAudioData();
+    const argsArray = Array.from(args);
+
+    if (argsArray[0] instanceof cc.AudioClip) {
+      audioData.clip = argsArray[0];
+    } else {
+      const assetProperty = this.normalizeAssetProperty(argsArray[0]);
+      audioData.clip = await this.loadAudioClip(assetProperty);
+    }
+
+    if (type === FW.SystemDefine.FWAudioType.MUSIC) {
+      audioData.volume = argsArray[1];
+      audioData.loop = argsArray[2];
+    } else {
+      audioData.cb = argsArray[1];
+      audioData.volume = argsArray[2];
+      audioData.loop = argsArray[3];
+      audioData.tag = argsArray[4];
+    }
+
+    return audioData;
+  }
+
+  /**
+   * 标准化资源属性
+   */
+  private normalizeAssetProperty(input: any): FW.AssetProperty {
+    if (typeof input === 'string') {
+      return {
+        path: input,
+        bundle: FW.Entry.bundleName,
+      };
+    }
+    return input;
+  }
+
+  /**
+   * 加载音频片段
+   */
+  private async loadAudioClip(assetProperty: FW.AssetProperty): Promise<cc.AudioClip> {
+    try {
+      return await FW.Entry.resMgr.loadAsset<cc.AudioClip>(assetProperty);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  /**
+   * 生成缓存键
+   */
+  private getCacheKey(assetProperty: FW.AssetProperty): string {
+    if (typeof assetProperty === 'string') {
+      return `${FW.Entry.bundleName}_${assetProperty}`;
+    }
+    return `${assetProperty.bundle || FW.Entry.bundleName}_${assetProperty.path}`;
+  }
+
+  /**
+   * 获取音频名称
+   */
+  private getAudioName(clip: cc.AudioClip): string {
+    return clip.name || '未知音频';
+  }
+
+  /**
+   * 清理已完成的音频
+   */
+  private clearFinishedAudio(): void {
+    const currentTime = Date.now();
+    const maxAge = 30000;
+
+    this.audioPool.forEach((item, id) => {
+      if (!cc.audioEngine.getState(id)) {
+        this.audioPool.delete(id);
+      } else if (currentTime - item.startTime > maxAge) {
+        FW.Log.warn(`强制停止超时音频: ID ${id}`);
+        this.stop(id);
+      }
+    });
+  }
+
+  /**
+   * 启动自动清理
+   */
+  private autoClear(): void {
+    FW.Entry.timeMgr.schedule(
+      this.clearFinishedAudio,
+      this.cleanupInterval,
+      cc.macro.REPEAT_FOREVER,
+      this,
+    );
+  }
+
+  public onDestroy(): void {
+    this.stopAll();
+  }
+}

package/manager/FWAudioManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "c7cec874-a219-4fc7-aadf-c1e7a95d3fa0",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWBundleManager.ts

@@ -0,0 +1,97 @@
+import { FWManager } from "./FWManager";
+import { FWSystemConfig } from "../config/FWSystemConfig";
+
+export class FWBundleManager extends FWManager implements FW.BundleManager {
+  bundleMap: Map<string, cc.AssetManager.Bundle>;
+  remoteBundleConfigMap: Map<string, FW.RemoteBundleConfig>;
+
+  constructor(protected readonly resMgr: FW.ResManager) {
+    super();
+  }
+
+  public initialize() {
+    this.bundleMap = new Map<string, cc.AssetManager.Bundle>();
+    this.remoteBundleConfigMap = new Map<string, FW.RemoteBundleConfig>();
+  }
+
+  public getBundleMap() {
+    return this.bundleMap;
+  }
+
+  public getRemoteBundleConfigMap() {
+    return this.remoteBundleConfigMap;
+  }
+
+  initializeRemoteBundleConfig(config: FW.RemoteBundleConfig): void {
+    this.remoteBundleConfigMap.set(config.bundleName, config);
+  }
+
+  async load(bundleName: string): Promise<cc.AssetManager.Bundle> {
+    if (!bundleName) return;
+    if (this.bundleMap.has(bundleName)) return this.bundleMap.get(bundleName);
+
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+        const remote = this.remoteBundleConfigMap.get(bundleName);
+        const url = remote ? remote.url : "";
+        const path = `${url}${bundleName}`;
+        cc.assetManager.loadBundle(
+          path,
+          {
+            version: this.remoteBundleConfigMap.get(bundleName)?.version || "",
+          },
+          async (err: Error, bundle: cc.AssetManager.Bundle) => {
+            if (err || !bundle) {
+              FW.Log.error(`"加载bundle失败:"${bundleName}!`);
+              reject(err);
+            }
+
+            FW.Framework.createRegistry(bundleName)?.register();
+
+            this.bundleMap.set(bundleName, bundle);
+
+            resolve(bundle);
+          }
+        );
+      }, FWSystemConfig.PromiseConfig.loadBundle).promise,
+      `loadBundle -> ${bundleName}`
+    );
+  }
+
+  /**
+   * 获取bundle
+   * @param bundleName
+   * @returns
+   */
+  get(bundleName: string): cc.AssetManager.Bundle {
+    if (!this.has(bundleName)) {
+      FW.Log.error("获取bundle失败,请先加载!");
+      return undefined;
+    }
+    return this.bundleMap.get(bundleName);
+  }
+
+  /** 释放bundle */
+  release(bundleName: string): void {
+    if (!this.has(bundleName)) {
+      return;
+    }
+    cc.assetManager.removeBundle(this.bundleMap.get(bundleName));
+    this.bundleMap.delete(bundleName);
+    FW.Framework.getRegistry(bundleName)?.unRegister();
+    FW.Framework.destroyRegistry(bundleName);
+  }
+
+  /**
+   * 是否已经加载某个bundle
+   * @param bundleName
+   * @returns
+   */
+  has(bundleName: string): boolean {
+    return this.bundleMap.has(bundleName);
+  }
+
+  public onDestroy(): void {
+    this.bundleMap.clear();
+  }
+}

package/manager/FWBundleManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "8f7a5533-19cf-4b9f-a152-ae94b65d3042",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWComponentManager.ts

@@ -0,0 +1,24 @@
+import { FWManager } from './FWManager';
+
+export default class FWComponentManager extends FWManager implements FW.ComponentManager {
+  public initialize(): void {}
+  public onDestroy(): void {}
+
+  /**
+   * 绑定虚拟视图列表
+   */
+  bindVirtualViewComponent(args: FW.VirtualViewComponentArgs) {
+    args.virtualView.onRender = args.onRender?.bind(args.target);
+    args.virtualView.onSelected = args.onSelected?.bind(args.target);
+    args.virtualView.onPageChange = args.onPageChange?.bind(args.target);
+    args.virtualView.count = args.count;
+
+    if (args.templatePrefab) {
+      args.virtualView.templatePrefab = args.templatePrefab;
+    }
+
+    if (args.templateNode) {
+      args.virtualView.templateNode = args.templateNode;
+    }
+  }
+}

package/manager/FWComponentManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "8a40e7b7-9eb6-4236-96fb-afe4d9429a8a",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/manager/FWEngineManager.ts

@@ -0,0 +1,74 @@
+import { FWManager } from './FWManager';
+
+export default class FWEngineManager extends FWManager implements FW.EngineManager {
+  debug: boolean = false;
+
+  initialize() {
+    this.registerCCCSystemEvent();
+  }
+
+  onDestroy(): void {
+    cc.game.off(cc.game.EVENT_SHOW, this.onAppShow, this);
+    cc.game.off(cc.game.EVENT_HIDE, this.onAppHide, this);
+  }
+
+  restart() {
+    if (!launchScene) {
+      FW.Log.error('请设置启动场景');
+      return;
+    }
+    FW.Entry.evtMgr.dispatch(FW.EventDefine.SystemEvent.SYSTEM_RESTART);
+    FW.Entry.initialize();
+    FW.Framework.restart();
+    FW.Entry.launchScene(launchScene);
+  }
+
+  getMemory() {
+    if (!this.debug) return;
+    if (window.performance && window.performance['memory']) {
+      FW.Log.debug(
+        '浏览器允许的最大内存:',
+        this.formatBytes(window.performance['memory'].jsHeapSizeLimit),
+      );
+      FW.Log.debug(
+        '浏览器已分配内存:',
+        this.formatBytes(window.performance['memory'].totalJSHeapSize),
+      );
+      FW.Log.debug(
+        '浏览器已使用内存:',
+        this.formatBytes(window.performance['memory'].usedJSHeapSize),
+      );
+    } else {
+      FW.Log.debug('当前浏览器不支持 performance.memory');
+    }
+  }
+  /**
+   * 注册cocos系统事件
+   */
+  private registerCCCSystemEvent() {
+    cc.game.on(cc.game.EVENT_SHOW, this.onAppShow, this);
+    cc.game.on(cc.game.EVENT_HIDE, this.onAppHide, this);
+  }
+
+  /** 应用切换到前台 */
+  private onAppShow() {
+    FW.Log.debug('game on show!');
+    FW.Entry.evtMgr?.dispatch(FW.EventDefine.CCEvent.ON_SHOW);
+  }
+
+  /** 应用切换到后台 */
+  private onAppHide() {
+    FW.Log.debug('game on hide!');
+    FW.Entry.evtMgr?.dispatch(FW.EventDefine.CCEvent.ON_HIDE);
+  }
+
+  private formatBytes(bytes: number) {
+    if (bytes < 1024 * 1024) {
+      return (bytes / 1024).toFixed(2) + ' KB';
+    } else if (bytes < 1024 * 1024 * 1024) {
+      return (bytes / 1024 / 1024).toFixed(2) + ' MB';
+    } else {
+      return (bytes / 1024 / 1024 / 1024).toFixed(2) + ' GB';
+    }
+  }
+}

package/manager/FWEngineManager.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "dcaa0ad6-aa1c-4103-9705-2777da3e2e83",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}