「Android - SoundPool使用」

一、语音播放

Android开发过程中或多或少的都会接触到一些音效的播放，自带组件就有MediaPlayer与SoundPool，MediaPlayer有着自身的不足，资源占用大，并不能支持多音频同时播放等。

而SoundPool则更适合短时、急促、密集的提示音播放。如支付收款的到账通知的，SoundPool支持异步初始化，可以导入本地音频文件并解码。而这也同样伴随一个缺点，如果资源未加载完全时播放则不全。

二、HandlerThread

在使用SoundPool之前有必要了解一下HandlerThread，以游戏中音效为例。主线程不占用，但是音效的播放是较为密集的，HandlerThread是个不错的选择。为什么不普通的Thread？如果使用普通的Thread，则需要自己去实现线程的唤醒，等待以及通知主线程更新等操作。繁琐也不容易管理。

1.HandlerThread是什么？

顾名思义，它是Handler同时也是Thread，熟悉Handler机制的一定不会很陌生，线程切换，消息处理、更新UI等。而Thread类无非就是开启子线程处理耗时任务。来看看HandlerThread具体实现源码。

继承自Thread

public class HandlerThread extends Thread {int mPriority;int mTid = -1;Looper mLooper;private @Nullable Handler mHandler;
}

1.可以看到内部包含Looper、Handler实例

构造函数

public HandlerThread(String name) {super(name);mPriority = Process.THREAD_PRIORITY_DEFAULT;
}public HandlerThread(String name, int priority) {super(name);mPriority = priority;
}
Process.THREAD_PRIORITY_DEFAULT = 0；

1.线程的默认优先级为0，当然这里要区别Java的线程优先级，在Java中线程的优先级范围为[1-10]，值越大优先级越高。在Android开发过程可以通过Process来指定线程的优先级[-20-19]，具体可以在Process类中查看。当然Google还是比较推荐使用第二种方式来确定优先级。-20为最高优先级。

关键方法run()

@Override
public void run() {mTid = Process.myTid();Looper.prepare();synchronized (this) {mLooper = Looper.myLooper();notifyAll();}Process.setThreadPriority(mPriority);onLooperPrepared();Looper.loop();mTid = -1;
}

1.实现很简单，仅仅是自己维护一套消息循环，简单的理解就是那个经典的面试题(子线程中如何创建Handler)的具体实现。

比较疑惑的地方就是同步机制notifyAll()，这里为什么会这么写？稍微思考一下，既然是HandlerThread，那么第一反应是可以支持Handler的能力的，拿到这个Handler对象就可以处理一些UI更新的能力。在源码中提供了获取当前线程Handler实例对象的方法：

@NonNull
public Handler getThreadHandler() {if (mHandler == null) {mHandler = new Handler(getLooper());}return mHandler;
}

在线程存活的前提下，要使mHandler对象不为空那么Looper对象必须不为空，看getLooper():

public Looper getLooper() {if (!isAlive()) {return null;}synchronized (this) {while (isAlive() && mLooper == null) {try {wait();} catch (InterruptedException e) {}}}return mLooper;
}

在线程已经启动的情况下，mLooper的初始化是在run() 方法中：

public void run() {....synchronized (this) {mLooper = Looper.myLooper();notifyAll();}....
}

如果不使用等待唤醒机制，那么在外部调用getThreadHandler时是无法保证同步的问题的，因此这里就解释通了，使用等待唤醒机制来处理同步的问题。

安全退出

public boolean quitSafely() {Looper looper = getLooper();if (looper != null) {looper.quitSafely();return true;}return false;
}

等到消息队列中所有的消息处理完全后，才会退出循环。这里需要注意的是，quitSafely同样会清除队列里的延迟消息，而处理非延迟消息。quit则是清除所有的消息。

2.HandlerThread能干嘛？

首先可以明确的是，这是一个单线程且具有Handler能力的类，那么它能干什么呢？单线程+异步操作，很明显能想到这个模型。对于小文件的下载、较为简单的I/O操作，简单数据库内容读取并刷新UI，这些场景都是很适合。但是它并不适合大文件的下载，为什么？因为是单个线程，较大文件的下载显然是不合适的。当然在这里要讨论另外的场景，搭配SoundPool进行密集型语音播报。

三、SoundPool

1.使用基本流程

以播报收款金额为例，金额的构成很简单，无非就是数字加上小数点外加一个中文字符“元”，而我们需要做的就是将目标的金额分解为一个个数字(单个小数点)加上“元”，通过SoundPool循环播放出每个音节即可以满足需求，而SoundPool的一般使用流程为：

将音频源文件引入到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 setupif (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到9const 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//当前正在播放的资源idprivate var mCurrentSourceId = -1//根据加载策略加载的资源文件alis与durationprivate 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 = 5private 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 = falseif (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 {mSoundPool.stop(mCurrentSourceId)playNext()
}private fun stopPlay() {mPlaying = falsemSourceQueue.clear()mSoundPool.stop(mCurrentSourceId)mHandler.removeCallbacks(mNextRunnable)
}

对于资源的加载，通过不同的加载策略比对alias并构建SoundDTO对象存入map容器中即可，具体实现比较简单，就不贴代码了，当然还包括AIDL的定义，基本上主要实现播放组件的开启与关闭等根据具体业务来实现。

五、文档

AudioManager

SoundPool

HandlerThread