HarmonyOS鸿蒙最新【Android 】SoundPool使用_android soundpool(4)，2024年最新面试官英语

2401_84862079

于 2024-05-17 02:21:40 发布

阅读量576

点赞数 10

文章标签：鸿蒙面试学习

本文链接：https://blog.csdn.net/2401_84862079/article/details/138983074

版权

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

将音频源文件引入到res/raw目录下；
根据需求定制SoundPool，加入语音队列；
实例化SoundPool并通过play进行播放。

2.基本构建参数

public SoundPool(int maxStreams, int streamType, int srcQuality) {
this(maxStreams,
  new AudioAttributes.Builder().setInternalLegacyStreamType(streamType).build());
        PlayerBase.deprecateStreamTypeForPlayback(streamType, "SoundPool", "SoundPool()");
}

private SoundPool(int maxStreams, AudioAttributes attributes) {
 super(attributes, AudioPlaybackConfiguration.PLAYER_TYPE_JAM_SOUNDPOOL);
 //do native setup
   if (native_setup(new WeakReference<SoundPool>(this), maxStreams, attributes) != 0) {
    throw new RuntimeException("Native setup failed");
 }
 mAttributes = attributes;
 baseRegisterPlayer();
}

public static class Builder {
  private int mMaxStreams = 1;
  private AudioAttributes mAudioAttributes;
  //...
}

maxStreams：最大同时支持音频播放数；
streamType：音频流类型，一般为AudioManager.STREAM_MUSIC；
srcQuality：采样的转换的质量，目前没有作用，以0为默认值。
在版本为21以上时，推荐使用Builder去构建SoundPool，默认的构造方法已经过时。

3.加载资源文件

public int load(Context context, int resId, int priority) {
  AssetFileDescriptor afd = context.getResources().openRawResourceFd(resId);
  int id = 0;
  if (afd != null) {
      id = _load(afd.getFileDescriptor(), afd.getStartOffset(), afd.getLength(), priority);
      try {
         afd.close();
      } catch (java.io.IOException ex) {
        //Log.d(TAG, "close failed:", ex);
    }
  }
 return id;
}

context：应用上下文；
resId：资源的id，一般就是res/raw目录下的文件，R.raw.test；
priority：音频文件的优先级，没有实际意义，默认是1，为了兼容与扩展。

4.播放配置

public final int play(int soundID, float leftVolume, float rightVolume,
  int priority, int loop, float rate) {
  baseStart();
  return _play(soundID, leftVolume, rightVolume, priority, loop, rate);
}

soundID：load函数中返回的资源ID；
leftVolume：左声道音量，范围为 [0.0 - 1.0]；
rightVolume：右声道音量，范围为 [0.0 - 1.0]；
priority：音频流的优先级，0为最低优先级；
loop：播放的循环模式，0表示播放一次，大于0的数，则对应相应的循环次数，-1则表示无限循环；
rate：播放速率，1.0为正常播放速度，取值范围为 [0.5 - 2.0]。

音量的设置一般做法需要AudioManager来做一次计算：

AudioManager audioManager = (AudioManager) this.getSystemService(AUDIO_SERVICE);
//获取最大音量(当前媒体类型，这里使用的是STREAM_MUSIC)
int maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
//获取当前音量(当前媒体类型，这里使用的是STREAM_MUSIC)
int currentVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
//声音音量比值
float volumeRatio = (float) (currentVolume / maxVolume);

四、以SoundPool实现播放组件

一般都会设计成aar引入的形式，原因主要有：

1.更加通用，可以复用组件，易于扩展；

2.本地的音频文件过多的话，占用包体积就比较大，不利用于Apk体积优化；

3.按需加载音频文件。

现在思考一下设计成简单SDK的功能，应该包含哪些需求，首先对应不同的播放支持，有的需要很多资源文件，而有的模块需要的音频文件很少。那么按照需要应提供load策略按需下载对应的音频文件到本地。存在不需要拼接的音频，那么理想的是可以直接播放，那么就需要通用的播放util。对于拼接的音频，需要搭配handlerThread来处理连续播放，不过这属于具体的实现细节了。另外最重要的就是需要AIDL支持(将aar的文件导入到本地项目)。大概思路有了，那么就是技术方案的制定了。以播放金额为例，主要音频应该包含数字 [0 - 9]，小数点 .、成功以及失败音频等。

音频工具类，主要梳理对应关系，例如数字0对应字符串 “0”，以及音频对应的时长

object SourceUtil {
  //数字0到9
  const val NUM_0 = "0"
  const val NUM_1 = "1"
  const val NUM_2 = "2"
  const val NUM_3 = "3"
  //....
  const val SUCCESS = "success"
  //...
  
  //音频对应播放的时长
  val SOURCE_TO_DURATION = mapOf(
  	NUM_0 to 300L,
    NUM_1 to 300L,
    //...
    SUCCESS to 1000L
  )
}

加载对应音频资源策略接口

interface ILoadSource {
  fun loadSource(): List<String>
}

默认的加载实现，加载全部资源

class DefaultLoadAllSource : ILoadSource {
  override fun loadSource() : List<String> {
    return listOf(
      SourceUtil.NUM_0,
      SourceUtil.NUM_1,
      SourceUtil.NUM_2,
      //....
      SourceUtil.SUCCESS
    )
  }
}

按需加载资源，例如只加载数字

class LoadNumSource : ILoadSource {
  override fun loadSource() : List<String> {
    return listOf(
      SourceUtil.NUM_0,
      SourceUtil.NUM_1,
      SourceUtil.NUM_2,
      //....
    )
  }
}

播放核心类SoundPlayer

1.需要根据资源别名加载指定的文件；

2.支持循环播放单个音节(金额拼接)；

3.load资源，以及unload资源

class SoundPlayer {
  //SoundPool播放组件
  private lateinit var mSoundPool : SoundPool
  //播放音量
  private var mVolume : Float? = 0f
  //是否正在播放
  private var mPlaying = false
  //当前正在播放的资源id
  private var mCurrentSourceId = -1
  //根据加载策略加载的资源文件alis与duration
  private val mSourcePoolMap = mutableMapOf<String, SoundDTO>()
  //播放队列
  private val mSourceQueue = LinkedList<String>
  //通过HandlerThread控制循环播放
  private val mHandler : Handler 
  	get() {
      val handlerThread = HandlerThread("coustom handlerThread name")
      //启动线程
      handlerThread.start()
      return Handler(handlerThread.looper)
    }

  //数据DTO，仅包含名称alis，与播放时长
  private data class SoundDTO(val sourceId: Int, val duration: Long)
}

初始化操作，需要兼容低版本的情况，并且在初始化操作时应根据对应的加载策略将音频的资源文件load到本地。

companion object {
  private const val AUDIO_PREFIX = "tts_"
  private const val MAX_STREAMS = 5
  private const val STREAM_TYPE = AudioManager.STREAM_MUSIC
}

fun initSoundPlayer(context: Context, iLoadSource: ILoadSource) {
  //高版本
  mSoundPool = if(Build.VERSION.SDK_INT >= 21) {
    SoundPool.Builder()
    				 .setMaxStreams(MAX_STREAMS)
    		     .setAudioAttributes(
             			AudioAttributes.Builder()
                                 .setLegacyStreamType(STREAM_TYPE)
                                 .build()
             )
    				.build()
  } else {
    SoundPool(MAX_STREAMS, STREAM_TYPE, 0)
  }
  mPlaying = false
  if (mSourcePoolMap.isNotEmpty()) {
     mSourcePoolMap.clear()
  }
  calculateVolume(context)
}

private fun calculateVolume(context: Context) {
 val audioManager: AudioManager? = (context.getSystemService(AUDIO_SERVICE) as   AudioManager?)
 val maxVolume = audioManager?.getStreamMaxVolume(STREAM_TYPE)
 val currentVolume = audioManager?.getStreamVolume(STREAM_TYPE)
 mVolume = if (currentVolume != null) {
    maxVolume?.let { currentVolume.div(it).toFloat() }
 } else {
    0.8f
 }
}

要想实现对队列的音频逐一播放，那么需要借助Handler来告诉当前的播放结果，也即是当前播放结束，并队列中仍然有待播放文件，则继续下一个音频播放。

fun playSource(sourceList: MutableList<String>) {
  sourceList.forEach {
    //添加到播放对列,添加前缀并拼接
    mSourceQueue.add("$AUDIO_PREFIX$it")
  }
  takeIf {!mPlaying}?.let {
    playNext()
  }
}

fun playNext() {
  takeIf {mSourceQueue.isNotEmpty()} ?.let {
    val sourceAlias = mSourceQueue.poll()
    val soundDTO = sourceAlias?.let {
      mSourcePoolMap[sourceAlias]
    }
    soundDTO?.let { _soundDTO ->
      mCurrentSourceId = mSoundPool.play(_soundDTO.id, mVolume, mVolume, 1, 0, 1.0f)           
      mPlaying = true
      //当前播放完毕，通过handler发送消息播放下一条，延迟duration则为当前音频的时长
      mHandler.postDelayed(mNextRunnable, _soundDTO.duration)
    }? : run{
      mHandler.postDelayed(mNextRunnable, 0)
    }
  }?: run {
    stopPlay()
  }
}

private val mNextRunnable = Runnable {


**深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

![](https://img-blog.csdnimg.cn/direct/743b668910224b259a5ffe804fa6d0db.png)
![img](https://img-blog.csdnimg.cn/img_convert/63544f5168e7246644c3e9fa57f95f78.png)
![img](https://img-blog.csdnimg.cn/img_convert/bc1cd194772bcbb212cc3135ccc06a71.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618636735)**

og.csdnimg.cn/direct/743b668910224b259a5ffe804fa6d0db.png)
[外链图片转存中...(img-fQsbqDiW-1715883679963)]
[外链图片转存中...(img-TGeidsbk-1715883679964)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上鸿蒙开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化的资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618636735)**

2401_84862079

关注

10
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
HarmonyOS鸿蒙最新【Android 】SoundPool使用_android soundpool(4)，2024年最新面试官英语

的功能，应该包含哪些需求，首先对应不同的播放支持，有的需要很多资源文件，而有的模块需要的音频文件很少。存在不需要拼接的音频，那么理想的是可以直接播放，那么就需要通用的播放。来告诉当前的播放结果，也即是当前播放结束，并队列中仍然有待播放文件，则继续下一个音频播放。初始化操作，需要兼容低版本的情况，并且在初始化操作时应根据对应的加载策略将音频的资源文件。来处理连续播放，不过这属于具体的实现细节了。2.本地的音频文件过多的话，占用包体积就比较大，不利用于。要想实现对队列的音频逐一播放，那么需要借助。
复制链接

扫一扫