@ives_xxz/framework 1.4.15 → 1.5.0

package/manager/FWAssetManager.ts

@@ -1,3 +1,4 @@
+import { FWSystemConfig } from '../config/FWSystemConfig';
 import FWLog from '../log/FWLog';
 import { FWManager } from './FWManager';
 
@@ -41,19 +42,20 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
     bin?: boolean;
   }): Promise<sp.SkeletonData> {
     try {
-      return new Promise((resolve) => {
-        const bin = data.bin === undefined ? false : data.bin;
-        const img = data.img;
-        const ske = data.ske;
-        const atlas = data.atlas;
-        const type = bin ? '.bin' : '.txt';
-        cc.assetManager.loadAny(
-          [
-            { url: atlas, ext: type },
-            { url: ske, ext: type },
-          ],
-          (error, assets) => {
-            cc.assetManager.loadRemote(img, (error, texture: cc.Texture2D) => {
+      return await this.invoke(
+        FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+          const bin = data.bin === undefined ? false : data.bin;
+          const img = data.img;
+          const ske = data.ske;
+          const atlas = data.atlas;
+          const type = bin ? '.bin' : '.txt';
+          cc.assetManager.loadAny(
+            [
+              { url: atlas, ext: type },
+              { url: ske, ext: type },
+            ],
+            async (error, assets) => {
+              const texture: cc.Texture2D = await this.loadRemote();
               var asset = new sp.SkeletonData();
               asset.skeletonJson = assets[1];
               asset.atlasText = assets[0];
@@ -61,29 +63,32 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
               asset['textureNames'] = [`${img}.png`];
               asset['_uuid'] = ske;
               resolve(asset);
-            });
-          },
-        );
-      });
+            },
+          );
+        }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      );
     } catch (e) {
       FWLog.error('从远程加载spine动画资源失败!');
     }
   }
 
   /** 加载远程资源 */
-  loadRemote<T extends cc.Asset = cc.Asset>(
+  async loadRemote<T extends cc.Asset = cc.Asset>(
     url?: string,
     cb?: (asset: cc.Asset) => void,
   ): Promise<T> {
-    return new Promise((resolve, reject) => {
-      cc.assetManager.loadRemote(url, { cacheEnabled: true, maxRetryCount: 0 }, (err, asset) => {
-        if (err || !asset) {
-          reject(err);
-        }
-        cb?.(asset as T);
-        resolve(asset as T);
-      });
-    });
+    return await this.invoke(
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+        cc.assetManager.loadRemote(url, { cacheEnabled: true, maxRetryCount: 3 }, (err, asset) => {
+          if (err || !asset) {
+            reject(err);
+          }
+          cb?.(asset as T);
+          resolve(asset as T);
+        });
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
+      `loadAssets -> ${url}`,
+    );
   }
 
   /**
@@ -132,43 +137,36 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
     assetData.loaded = false;
 
     return await this.invoke(
-      FW.Entry.promiseMgr.execute(
-        (resolve, reject, signal) => {
-          const self = this;
-
-          bundle.load(
-            path,
-            type,
-            (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
-              progress?.(finish, total, item);
-            },
-            (err: Error, asset: cc.Asset) => {
-              if (err || !asset) {
-                reject(err);
-                return;
-              }
-              assetData.loaded = true;
-              assetData.dependentBundle = bundleName;
-              assetData.uuid = asset['_uuid'];
-              assetData.autoRelease = autoRelease;
-              assetData.asset = asset;
-              assetData.user = assetProperty.user;
-              assetData.refCount = 1;
-              assetData.assetProperty = assetProperty;
-
-              self.assetsMap.set(key, assetData);
-
-              cb?.(assetData);
-              resolve(assetData);
-            },
-          );
-        },
-        {
-          retryCount: 3,
-          retryInterval: 1,
-          timeout: 10,
-        },
-      ).promise,
+      FW.Entry.promiseMgr.execute((resolve, reject, signal) => {
+        const self = this;
+
+        bundle.load(
+          path,
+          type,
+          (finish: number, total: number, item: cc.AssetManager.RequestItem) => {
+            progress?.(finish, total, item);
+          },
+          (err: Error, asset: cc.Asset) => {
+            if (err || !asset) {
+              reject(err);
+              return;
+            }
+            assetData.loaded = true;
+            assetData.dependentBundle = bundleName;
+            assetData.uuid = asset['_uuid'];
+            assetData.autoRelease = autoRelease;
+            assetData.asset = asset;
+            assetData.user = assetProperty.user;
+            assetData.refCount = 1;
+            assetData.assetProperty = assetProperty;
+
+            self.assetsMap.set(key, assetData);
+
+            cb?.(assetData);
+            resolve(assetData);
+          },
+        );
+      }, FWSystemConfig.PromiseConfig.loadAsset).promise,
       `loadAssets -> ${assetProperty.path}`,
     );
   }
@@ -322,9 +320,6 @@ export class FWAssetManager extends FWManager implements FW.AssetManager {
    * @returns
    */
   public getReferenceCount(assetProperty: FW.AssetProperty): number {
-    const bundleName = assetProperty.bundle || FW.Entry.bundleName;
-    const path = assetProperty.path;
-    const type = assetProperty.type;
     const key = this.createAssetMapKey(assetProperty);
     return this.assetsMap.get(key)?.refCount || 0;
   }

package/manager/FWAudioManager.ts

@@ -1,29 +1,54 @@
 import { FWManager } from './FWManager';
-import Framework from '../Framework';
 import FWLog from '../log/FWLog';
+import { FWSystemDefine } from '../define/FWSystemDefine';
+
+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;
 
-  public initialize(): void {}
+  private audioPool: Map<number, FWAudioPoolItem> = new Map();
+  private maxConcurrentAudio: number = 10;
+  private cleanupInterval: number = 5;
 
-  playMusic(path: string, volume?: number, loop?: boolean);
-  playMusic(music: cc.AudioClip, volume?: number, loop?: boolean);
-  playMusic(assetProperty: FW.AssetProperty, volume?: number, loop?: boolean);
-  async playMusic() {
+  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 data = await this.dataProcessing(arguments[0], arguments[1], arguments[2]);
-      if (!data) return;
-      const clip = data.clip;
-      const volume = data.volume === undefined ? this.musicVolume : arguments[1];
-      const loop = data.loop === undefined ? true : arguments[2];
-      const id = cc.audioEngine.playMusic(clip, loop);
+      const audioData = await this.processAudioArguments(
+        arguments,
+        FWSystemDefine.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);
+
+      FWLog.debug(`播放背景音乐: ${this.getAudioName(audioData.clip)}`);
     } catch (e) {
       FWLog.error('播放音乐失败:', e);
     }
@@ -32,255 +57,275 @@ export default class FWAudioManager extends FWManager implements FW.AudioManager
   stopMusic(): void {
     cc.audioEngine.stopMusic();
   }
+
   pauseMusic(): void {
     cc.audioEngine.pauseMusic();
   }
+
   resumeMusic(): void {
     cc.audioEngine.resumeMusic();
   }
-  /**设置背景音效是否静音 */
+
+  /** 设置背景音效是否静音 */
   setMusicMute(mute: boolean): void {
-    if (mute) {
-      this.musicVolume = 1;
-    } else {
-      this.musicVolume = 0;
-    }
+    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> {
     try {
-      const data = await this.dataProcessing(
-        arguments[0],
-        arguments[1],
-        arguments[2],
-        arguments[3],
+      if (this.audioPool.size >= this.maxConcurrentAudio) {
+        this.clearFinishedAudio();
+        if (this.audioPool.size >= this.maxConcurrentAudio) {
+          FWLog.warn('音频池已满，无法播放新音频');
+          return -1;
+        }
+      }
+
+      const audioData = await this.processAudioArguments(
+        arguments,
+        FWSystemDefine.FWAudioType.SOUND,
       );
-      if (!data) return;
-      const clip = data.clip;
-      const volume = data.volume === undefined ? this.soundVolume : data.volume;
-      const loop = data.loop === undefined ? false : data.loop;
-      const id = cc.audioEngine.play(clip, loop, volume);
+      if (!audioData.clip) return -1;
+
+      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, () => {
-        data.cb?.(id);
+        audioData.cb?.(id);
+        this.audioPool.delete(id);
       });
+
       return id;
     } catch (e) {
       FWLog.error('播放音效失败:', e);
+      return -1;
     }
   }
+
   /**
-   *
-   * @param id 停止
+   * 停止指定音效
    */
-  public stop(id: number) {
-    cc.audioEngine.stop(id);
+  stop(id: number): void {
+    if (this.audioPool.has(id)) {
+      cc.audioEngine.stop(id);
+      this.audioPool.delete(id);
+      FWLog.debug(`停止音效: ID ${id}`);
+    }
   }
+
   pauseAll(): void {
     cc.audioEngine.pauseAll();
+    FWLog.debug('暂停所有音效');
   }
+
   resumeAll(): void {
     cc.audioEngine.resumeAll();
+    FWLog.debug('恢复所有音效');
   }
+
   stopAll(): void {
     cc.audioEngine.stopAll();
+    this.audioPool.clear();
+    FWLog.debug('停止所有音效');
   }
-  /**设置播放音效是否静音 */
+
+  /** 设置播放音效是否静音 */
   setSoundMute(mute: boolean): void {
-    if (mute) {
-      this.soundVolume = 1;
-    } else {
-      this.soundVolume = 0;
-    }
+    this.soundVolume = mute ? 0 : 1;
+    FWLog.debug(`音效${mute ? '静音' : '取消静音'}`);
   }
 
-  /**播放音效 */
-  async playEffect(path: string, loop?: boolean): Promise<number>;
-  async playEffect(audio: cc.AudioClip, loop?: boolean): Promise<number>;
-  async playEffect(assetProperty: FW.AssetProperty, loop?: boolean): Promise<number>;
-  async playEffect(): Promise<number> {
+  /**
+   * 预加载音频资源
+   */
+  async preloadAudio(assetProperty: FW.AssetProperty): Promise<cc.AudioClip> {
     try {
-      const data = await this.dataProcessing(arguments[0], arguments[1]);
-      if (!data) return;
-      const clip = data.clip;
-      const loop = data.loop === undefined ? false : arguments[1];
-      const id = cc.audioEngine.playEffect(clip, loop);
-      return id;
+      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) {
-      FWLog.error('播放音效失败:', e);
+      return null;
     }
   }
 
   /**
-   * 停止音效
-   * @param effectName 声音文件名
-   * @returns
+   * 释放音频资源
    */
-  stopEffect(audioID: number): void {
-    if (!audioID) return;
-    return cc.audioEngine.stopEffect(audioID);
+  releaseAudio(assetProperty: FW.AssetProperty): void {
+    FW.Entry.resMgr.releaseAsset(assetProperty);
   }
+
   /**
-   * 设置音效音量
-   * @param volume 音量
+   * 获取音频池信息
    */
-  setEffectsVolume(volume: number): void {
-    cc.audioEngine.setEffectsVolume(volume);
+  getAudioPoolInfo(): { playing: number; maxConcurrent: number } {
+    return {
+      playing: this.audioPool.size,
+      maxConcurrent: this.maxConcurrentAudio,
+    };
   }
+
   /**
-   * 停止播放所有音效
+   * 设置最大并发音频数
    */
-  stopAllEffects(): void {
-    cc.audioEngine.stopAllEffects();
+  setMaxConcurrentAudio(max: number): void {
+    this.maxConcurrentAudio = Math.max(1, max);
   }
-  /**设置音效是否静音 */
-  setEffectsMute(mute: boolean): void {
-    if (mute) {
-      this.effectsVolume = 1;
-    } else {
-      this.effectsVolume = 0;
-    }
-    cc.audioEngine.setEffectsVolume(this.effectsVolume);
+
+  /**
+   * 根据标签停止音效
+   */
+  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 dataProcessing(
-    path: string,
-    cb?: (id: number) => void,
-    volume?: number,
-    loop?: boolean,
-  ): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }>;
-
-  private async dataProcessing(
-    audio: cc.AudioClip,
-    cb?: (id: number) => void,
-    volume?: number,
-    loop?: boolean,
-  ): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }>;
-
-  private async dataProcessing(
-    assetProperty: FW.AssetProperty,
-    cb?: (id: number) => void,
-    volume?: number,
-    loop?: boolean,
-  ): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }>;
-
-  private async dataProcessing(
-    path: string,
-    volume?: number,
-    loop?: boolean,
-  ): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }>;
-  private async dataProcessing(
-    music: cc.AudioClip,
-    volume?: number,
-    loop?: boolean,
-  ): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }>;
-  private async dataProcessing(
-    assetProperty: FW.AssetProperty,
-    volume?: number,
-    loop?: boolean,
-  ): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }>;
-  private async dataProcessing(): Promise<{
-    clip: cc.AudioClip;
-    volume: number;
-    loop: boolean;
-    cb: (id: number) => void;
-  }> {
-    let clip: cc.AudioClip;
-    if (typeof arguments[0] === 'string') {
-      const bundle = FW.Entry.bundleName;
-      const path = arguments[0];
-      clip = await FW.Entry.resMgr.loadAsset<cc.AudioClip>(<FW.AssetProperty>{
-        path: path,
-        bundle: bundle,
-      });
-    } else if (typeof arguments[0] === 'object') {
-      const bundle = (arguments[0] as FW.AssetProperty).bundle || FW.Entry.bundleName;
-      const path = (arguments[0] as FW.AssetProperty).path;
-      clip = await FW.Entry.resMgr.loadAsset<cc.AudioClip>(<FW.AssetProperty>{
-        path: path,
-        bundle: bundle,
-      });
-    } else if (arguments[0] instanceof cc.AudioClip) {
-      clip = arguments[0];
+  /**
+   * 处理音频参数
+   */
+  private async processAudioArguments(
+    args: IArguments,
+    type: FWSystemDefine.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);
     }
 
-    let volume: number;
+    if (type === FWSystemDefine.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];
+    }
 
-    let loop: boolean;
+    return audioData;
+  }
 
-    let cb: (id: number) => void;
-    if (typeof arguments[1] === 'function') {
-      cb = arguments[1];
-    } else if (typeof arguments[1] === 'number') {
-      volume = arguments[1];
-    } else if (typeof arguments[1] === 'boolean') {
-      loop = arguments[1];
+  /**
+   * 标准化资源属性
+   */
+  private normalizeAssetProperty(input: any): FW.AssetProperty {
+    if (typeof input === 'string') {
+      return {
+        path: input,
+        bundle: FW.Entry.bundleName,
+      };
     }
+    return input;
+  }
 
-    if (typeof arguments[2] === 'boolean') {
-      loop = arguments[2];
-    } else if (typeof arguments[2] === 'number') {
-      volume = arguments[2];
+  /**
+   * 加载音频片段
+   */
+  private async loadAudioClip(assetProperty: FW.AssetProperty): Promise<cc.AudioClip> {
+    try {
+      return await FW.Entry.resMgr.loadAsset<cc.AudioClip>(assetProperty);
+    } catch (e) {
+      return null;
     }
+  }
 
-    if (arguments.length == 4) {
-      loop = arguments[3];
+  /**
+   * 生成缓存键
+   */
+  private getCacheKey(assetProperty: FW.AssetProperty): string {
+    if (typeof assetProperty === 'string') {
+      return `${FW.Entry.bundleName}_${assetProperty}`;
     }
+    return `${assetProperty.bundle || FW.Entry.bundleName}_${assetProperty.path}`;
+  }
 
-    return {
-      clip: clip,
-      volume: volume,
-      loop: loop,
-      cb: cb,
-    };
+  /**
+   * 获取音频名称
+   */
+  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) {
+        FWLog.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 {