2024年鸿蒙最新【Android 】SoundPool使用_android soundpool(5)，学HarmonyOS鸿蒙开发的网站

2401_84851494

于 2024-05-16 01:14:26 发布

阅读量402

点赞数 3

文章标签：鸿蒙面试学习

本文链接：https://blog.csdn.net/2401_84851494/article/details/138930511

版权

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

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

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

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(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
}


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

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


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

class LoadNumSource : ILoadSource {
override fun loadSource() : List {
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
//通过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) {
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)
}



![img](https://img-blog.csdnimg.cn/img_convert/b98282ba40fe3f1b36fdb59098ea48ed.png)
![img](https://img-blog.csdnimg.cn/img_convert/41a69669798fc355a43a3f8c8390d830.png)

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

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


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

mNextRunnable)
}

[外链图片转存中…(img-H5TnAZA0-1715793246031)]
[外链图片转存中…(img-rOJBdcsv-1715793246032)]

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

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