一、语音播放

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 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 {
  mSoundPool.stop(mCurrentSourceId)
  playNext()
}

private fun stopPlay() {
  mPlaying = false
  mSourceQueue.clear()
  mSoundPool.stop(mCurrentSourceId)
  mHandler.removeCallbacks(mNextRunnable)
} 

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

er.android.com%2Freference%2Fandroid%2Fmedia%2FSoundPool "https://developer.android.com/reference/android/media/SoundPool")