使用SoundPool实现网络音频的即时播放

以下是完整的实现方案，包括下载网络音频、使用URI加载到SoundPool，以及支持每次点击即时播放。

完整代码示例

import { media } from '@kit.MediaKit';
import { audio } from '@kit.AudioKit';
import { request } from '@kit.BasicServicesKit';
import { fileIo } from '@kit.CoreFileKit';
import { common } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';

// 定义全局变量
let soundPool: media.SoundPool | null = null;
let soundIds: number[] = []; // 存储多个soundId以实现并行播放
let currentIndex: number = 0;
let context: common.UIAbilityContext;

@Component
struct Index {
  private soundPoolManager: SoundPoolManager = new SoundPoolManager();

  aboutToAppear() {
    // 获取UIAbilityContext
    context = this.getUIContext().getHostContext() as common.UIAbilityContext;
    // 初始化SoundPool并加载网络音频
    this.soundPoolManager.initializeSoundPool(context, ' https://example.com/audio/short_audio.mp3 ');
  }

  build() {
    Column() {
      Button('播放音频')
        .onClick(() => {
          // 每次点击都会立即播放音频
          this.soundPoolManager.playSound();
        })
        .margin(20)
        .width('80%')
        .height(50)
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

// SoundPool管理类
class SoundPoolManager {
  private context: common.UIAbilityContext | null = null;
  private audioFileFd: number | null = null;
  private readonly MAX_INSTANCES = 5; // 预加载的音频实例数量

  // 初始化SoundPool并加载网络音频
  async initializeSoundPool(context: common.UIAbilityContext, networkUrl: string) {
    this.context = context;
    
    try {
      // 1. 下载网络音频到本地
      const localFilePath = await this.downloadAudio(networkUrl);
      
      // 2. 创建SoundPool实例
      const audioRendererInfo: audio.AudioRendererInfo = {
        usage: audio.StreamUsage.STREAM_USAGE_MUSIC,
        rendererFlags: 0
      };
      
      soundPool = await media.createSoundPool(this.MAX_INSTANCES, audioRendererInfo);
      console.info('SoundPool创建成功');
      
      // 3. 获取文件描述符并生成URI
      const file = await fileIo.open(localFilePath, fileIo.OpenMode.READ_ONLY);
      this.audioFileFd = file.fd;
      const uri = `fd://${this.audioFileFd}`;
      
      // 4. 预加载多个音频实例（用于并行播放）
      for (let i = 0; i < this.MAX_INSTANCES; i++) {
        try {
          const soundId = await soundPool.load(uri);
          soundIds.push(soundId);
          console.info(`音频加载成功，soundId: ${soundId}`);
        } catch (loadError) {
          console.error(`加载音频实例失败: ${(loadError as BusinessError).message}`);
        }
      }
    } catch (error) {
      console.error(`初始化SoundPool失败: ${(error as BusinessError).message}`);
    }
  }

  // 下载网络音频到本地沙箱
  private async downloadAudio(url: string): Promise<string> {
    if (!this.context) {
      throw new Error('Context未初始化');
    }

    const localFileName = 'cached_audio.mp3';
    const dir = this.context.filesDir;
    const localPath = `${dir}/${localFileName}`;

    return new Promise<string>((resolve, reject) => {
      const config: request.agent.Config = {
        action: request.agent.Action.DOWNLOAD,
        url: url,
        saveas: localPath,
        overwrite: true,
        gauge: true
      };

      request.agent.create(this.context, (err, agent) => {
        if (err) {
          reject(err);
          return;
        }

        agent.request(config, (err, response) => {
          if (err) {
            reject(err);
            return;
          }
          console.info('音频下载完成，路径: ' + localPath);
          resolve(localPath);
        });
      });
    });
  }

  // 播放音频
  playSound() {
    if (!soundPool || soundIds.length === 0) {
      console.error('SoundPool未初始化或音频未加载');
      return;
    }

    // 轮流使用不同的soundId以实现并行播放
    const soundId = soundIds[currentIndex];
    currentIndex = (currentIndex + 1) % soundIds.length;

    const playParameters: media.PlayParameters = {
      loop: 0, // 不循环
      rate: 1.0, // 正常速度
      leftVolume: 1.0, // 左声道音量
      rightVolume: 1.0, // 右声道音量
      priority: 0 // 优先级
    };

    soundPool.play(soundId, playParameters, (error: BusinessError | null, streamId: number) => {
      if (error) {
        console.error(`播放失败: ${error.code}, ${error.message}`);
      } else {
        console.info(`播放成功, streamId: ${streamId}`);
      }
    });
  }

  // 释放资源
  async release() {
    if (soundPool) {
      try {
        // 释放所有音频资源
        for (const soundId of soundIds) {
          await soundPool.unload(soundId);
        }
        soundIds = [];
        
        // 释放SoundPool
        await soundPool.release();
        soundPool = null;
        
        // 关闭文件描述符
        if (this.audioFileFd !== null) {
          await fileIo.close(this.audioFileFd);
          this.audioFileFd = null;
        }
        
        console.info('资源已释放');
      } catch (error) {
        console.error(`释放资源失败: ${(error as BusinessError).message}`);
      }
    }
  }
}

配置权限

在项目的module.json5文件中添加以下权限：

{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.INTERNET",
        "reason": "需要访问网络下载音频文件"
      },
      {
        "name": "ohos.permission.WRITE_USER_STORAGE",
        "reason": "需要将音频文件保存到本地"
      },
      {
        "name": "ohos.permission.READ_USER_STORAGE",
        "reason": "需要读取本地音频文件"
      }
    ]
  }
}

实现原理

1. 网络音频下载：使用request.agent下载网络音频到应用沙箱目录
2. URI生成：通过fileIo.open获取文件描述符(fd)，生成fd://格式的URI
3. SoundPool初始化：创建SoundPool实例并预加载多个音频实例
4. 并行播放：通过轮流使用不同的soundId实现同时播放多个音频实例

注意事项

1. 音频格式支持：SoundPool支持MP3、WAV、OGG等格式，但建议使用压缩比较高的短音频
2. 内存管理：预加载多个实例会占用更多内存，请根据实际需要调整MAX_INSTANCES值
3. 资源释放：在页面销毁或不再需要时调用release()方法释放资源
4. 错误处理：添加了完整的错误处理机制，确保应用稳定性

优化建议

1. 对于极短音频(1-2秒)，可以适当增加预加载实例数量(如10个)
2. 可以考虑添加加载状态提示，提升用户体验
3. 如果音频内容可能变化，可以添加缓存机制和定期更新策略