Unity Android 之 获取各个音量的最大值、最小值、以及当前音量值,并设置音量值,监听音量变化的方法整理
Unity Android 之 获取各个音量的最大值、最小值、以及当前音量值,并设置音量值,监听音量变化的方法整理
目录
Unity Android 之 获取各个音量的最大值、最小值、以及当前音量值,并设置音量值,监听音量变化的方法整理
一、简单介绍
Unity Android 开发上会用到的技术简单整理,方便自己日后查看,能帮助到大家就更好了。
本节介绍,把 Android 端获取各个音量的最大值、最小值、以及当前音量值,并设置音量值,监听音量变化的方法 整理封装给 Unity 调用的方法。
二、实现原理
1、 getSystemService(Context.AUDIO_SERVICE) 获得音频管理 AudioManager
2、根据 AudioManager.getStreamMaxVolume(AudioManager.STREAM_XXX) 得到各种音量的最大值
3、根据 AudioManager.getStreamMinVolume(AudioManager.STREAM_XXX) 得到各种音量的最小值
4、根据 AudioManager.getStreamVolume(AudioManager.STREAM_XXX) 得到各种音量的当前值
5、根据 AudioManager.setStreamVolume(AudioManager.STREAM_XXX,Value,AudioManager.FLAG_XXX) 设置各个音量值
6、intent.getAction().equals(ACTION_VOLUME_CHANGED) 广播监听音量变化
7、打包成 aar ,Unity 调用 aar 的封装好的接口
三、注意事项
1、AudioManager.getStreamMinVolume(AudioManager.STREAM_XXX) 得到各种音量的最小值,好像 minSdkVersion 需要 minSdkVersion 28 (建议不用,局限性太大了,一般默认最小值为 0,就可以了)
四、效果预览
五、实现步骤
Android 端:
1、新建一个Android Library 模块,其他默认设置就好
2、在模块中新建两个脚本,VoiceVolumnUtil 封装各个功能,VoiceVolumnChangedIntereface 一个接口函数,音量变化的接口
3、脚本编辑 OK,Build - Make Module ‘xxxx’,打包 aar
4、打包成功,build 文件夹outputs/aar中就会 有对应的 aar 生成
Unity 端
1、把 Android 打包的 aar 导入 Unity
2、在场景中布局UI,slider 显示设置音量大小,Text 显示具体音量大小
3、在 Unity工程中,新建脚本,编辑对应功能
4、把 TestVoiceVolumnWrapper 挂载到场景中,并对应赋值
5、运行场景,没有问题,即可打包到真机上测试
6、真机上的测试效果如上
六、关键代码
Android 端
1、VoiceVolumnUtil
package com.example.voicevolumnwrapper;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.media.AudioManager;
import android.util.Log;
import android.widget.Toast;
/**
* 获取设置系统(音乐)音量的封装类
*/
public class VoiceVolumnUtil {
private static final String TAG = "Main_VoiceVolumnUtil";
private AudioManager _AudioManager;
private Context _Context;
private static final String ACTION_VOLUME_CHANGED = "android.media.VOLUME_CHANGED_ACTION";
private static final String EXTRA_VOLUME_STREAM_TYPE = "android.media.EXTRA_VOLUME_STREAM_TYPE";
// 音量广播监听
private MyVolumeReceiver mVolumeReceiver;
// 音量变化监听触发事件
private VoiceVolumnChangedIntereface _VoiceVolumnChangedIntereface;
/**
* 初始化
* @param voiceVolumnChangedIntereface
*/
public void Init(VoiceVolumnChangedIntereface voiceVolumnChangedIntereface){
_Context = getActivity();
_AudioManager =(AudioManager) _Context.getSystemService(Context.AUDIO_SERVICE);
_VoiceVolumnChangedIntereface = voiceVolumnChangedIntereface;
}
/**
* // 通话音量
* @return
*/
public int GetCallVoiceMax(){
return _AudioManager.getStreamMaxVolume(AudioManager.STREAM_VOICE_CALL) ;
}
/**
* // 通话音量
* @return
*/
public int GetCallVoiceMin(){
// AudioManager.getStreamMinVolume要求 API 28,要求太高,先注掉,返回 0
//return _AudioManager.getStreamMinVolume(AudioManager.STREAM_VOICE_CALL) ;
return 0;
}
/**
* // 通话音量
* @return
*/
public int GetCallVoiceCurrentValue(){
return _AudioManager.getStreamVolume(AudioManager.STREAM_VOICE_CALL) ;
}
/**
* // 系统音量
* @return
*/
public int GetSystemVoiceMax(){
return _AudioManager.getStreamMaxVolume(AudioManager.STREAM_SYSTEM) ;
}
/**
* // 系统音量
* @return
*/
public int GetSystemVoiceMin(){
// AudioManager.getStreamMinVolume要求 API 28,要求太高,先注掉,返回 0
//return _AudioManager.getStreamMinVolume(AudioManager.STREAM_SYSTEM) ;
return 0;
}
/**
* // 系统音量
* @return
*/
public int GetSystemVoiceCurrentValue(){
return _AudioManager.getStreamVolume(AudioManager.STREAM_SYSTEM) ;
}
/**
* // 铃声音量
* @return
*/
public int GetRingVoiceMax(){
return _AudioManager.getStreamMaxVolume(AudioManager.STREAM_RING) ;
}
/**
* // 铃声音量
* @return
*/
public int GetRingVoiceMin(){
// AudioManager.getStreamMinVolume要求 API 28,要求太高,先注掉,返回 0
//return _AudioManager.getStreamMinVolume(AudioManager.STREAM_RING) ;
return 0;
}
/**
* // 铃声音量
* @return
*/
public int GetRingVoiceCurrentValue(){
return _AudioManager.getStreamVolume(AudioManager.STREAM_RING) ;
}
/**
* // 音乐音量
* @return
*/
public int GetMusicVoiceMax(){
return _AudioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) ;
}
/**
* // 音乐音量
* @return
*/
public int GetMusicVoiceMin(){
// AudioManager.getStreamMinVolume要求 API 28,要求太高,先注掉,返回 0
//return _AudioManager.getStreamMinVolume(AudioManager.STREAM_MUSIC) ;
return 0;
}
/**
* // 音乐音量
* @return
*/
public int GetMusicVoiceCurrentValue(){
return _AudioManager.getStreamVolume(AudioManager.STREAM_MUSIC) ;
}
/**
* 增加音乐音量
* @param value
*/
public void AddMusicVoiceVolumn(int value){
int addValue = (GetMusicVoiceCurrentValue() + value) ;
// 防止音量值越界
addValue = addValue > GetMusicVoiceMax() ? GetMusicVoiceMax():addValue;
_AudioManager.setStreamVolume(AudioManager.STREAM_MUSIC,addValue,AudioManager.FLAG_PLAY_SOUND);
}
/**
* 减少音乐音量
* @param value
*/
public void ReduceMusicVoiceVolumn(int value){
int reduceValue = (GetMusicVoiceCurrentValue() - value) ;
// 防止音量值越界
reduceValue = reduceValue < GetMusicVoiceMin() ?GetMusicVoiceMin():reduceValue;
_AudioManager.setStreamVolume(AudioManager.STREAM_MUSIC,reduceValue,AudioManager.FLAG_PLAY_SOUND);
}
/**
* 设置音乐音量大小
* @param value
*/
public void SetMusicVoiceVolumn(int value){
// 防止越界
if(value<GetMusicVoiceMin())value = GetMusicVoiceMin();
if(value>GetMusicVoiceMax())value = GetMusicVoiceMax();
_AudioManager.setStreamVolume(AudioManager.STREAM_MUSIC,value,AudioManager.FLAG_PLAY_SOUND);
}
/**
* 注册广播监听
*/
public void registerVolumeReceiver() {
mVolumeReceiver = new MyVolumeReceiver();
IntentFilter filter = new IntentFilter();
filter.addAction("android.media.VOLUME_CHANGED_ACTION");
_Context.registerReceiver(mVolumeReceiver, filter);
}
/**
* 取消注册广播监听
*/
public void unregisterVolumeReceiver() {
if (mVolumeReceiver != null) _Context.unregisterReceiver(mVolumeReceiver);
}
/**
* 音量变化广播类
*/
private class MyVolumeReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if (isReceiveVolumeChange(intent) == true) {
int currVolume = _AudioManager.getStreamVolume(AudioManager.STREAM_MUSIC);
//Toast.makeText(context, currVolume + " ", Toast.LENGTH_SHORT).show();
Log.i(TAG, "onReceive:isReceiveVolumeChange currVolume "+currVolume);
if (_VoiceVolumnChangedIntereface != null){
_VoiceVolumnChangedIntereface.VoiceVolumnChanged(currVolume);
}
}
}
}
/**
* 判断是否是音乐音量变化(音量键改变的音量)
* @param intent
* @return
*/
private boolean isReceiveVolumeChange(Intent intent) {
return intent.getAction() != null
&& intent.getAction().equals(ACTION_VOLUME_CHANGED)
&& intent.getIntExtra(EXTRA_VOLUME_STREAM_TYPE, -1) == AudioManager.STREAM_MUSIC
;
}
// 设置一个 Activity 参数
private Activity _unityActivity;
// 通过反射获取 Unity 的 Activity 的上下文
Activity getActivity(){
if(null == _unityActivity){
try{
Class<?> classtype = Class.forName("com.unity3d.player.UnityPlayer");
Activity activity = (Activity) classtype.getDeclaredField("currentActivity").get(classtype);
_unityActivity = activity;
}catch (ClassNotFoundException e){
e.printStackTrace();
}catch (IllegalAccessException e){
e.printStackTrace();
}catch (NoSuchFieldException e){
e.printStackTrace();
}
}
return _unityActivity;
}
}
2、VoiceVolumnChangedIntereface
package com.example.voicevolumnwrapper;
public interface VoiceVolumnChangedIntereface {
void VoiceVolumnChanged(int currentValue);
}
Unity 端
1、VoiceVolumnWrapper
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace AndroidWrapper
{
/// <summary>
/// 音量相关封装
/// 使用说明:
/// 1、首先初始化 Init,设置监听事件
/// 2、后面即可获取设置音量值
/// 3、监听音量变化
/// </summary>
public class VoiceVolumnWrapper : MonoSingleton<VoiceVolumnWrapper>
{
/// <summary>
/// 初始化
/// </summary>
/// <param name="VoiceVolumnChangedListener"></param>
public void Init(Action<int> VoiceVolumnChangedListener)
{
#if UNITY_EDITOR
#else
MAndroidJavaObject.Call("Init",new VoiceVolumnChangedIntereface(VoiceVolumnChangedListener));
registerVolumeReceiver();
#endif
}
/// <summary>
/// 获取音量的当前值
/// </summary>
/// <returns></returns>
public int GetMusicVoiceCurrentValue()
{
return MAndroidJavaObject.Call<int>("GetMusicVoiceCurrentValue");
}
/// <summary>
/// 设置音量值
/// </summary>
/// <param name="value"></param>
public void SetMusicVoiceVolumn(int value)
{
MAndroidJavaObject.Call("SetMusicVoiceVolumn", value);
}
/// <summary>
/// 获取音量的最大值
/// </summary>
/// <returns></returns>
public int GetMusicVoiceMax()
{
return MAndroidJavaObject.Call<int>("GetMusicVoiceMax");
}
/// <summary>
/// 获取音量的最小值
/// </summary>
/// <returns></returns>
public int GetMusicVoiceMin()
{
return MAndroidJavaObject.Call<int>("GetMusicVoiceMin");
}
#region 私有方法
/// <summary>
/// 注册音量监听
/// </summary>
void registerVolumeReceiver() {
MAndroidJavaObject.Call("registerVolumeReceiver");
}
/// <summary>
/// 取消注册音量监听
/// </summary>
void unregisterVolumeReceiver()
{
MAndroidJavaObject.Call("unregisterVolumeReceiver");
}
protected override void OnDestroy()
{
unregisterVolumeReceiver();
base.OnDestroy();
}
#endregion
#region 私有变量
/// <summary>
/// 音量变化委托事件
/// </summary>
Action<int> _mVoiceVolumnChanged;
AndroidJavaObject _mAndroidJavaObject;
public AndroidJavaObject MAndroidJavaObject {
get
{
if (_mAndroidJavaObject == null)
{
_mAndroidJavaObject = new AndroidJavaObject("com.example.voicevolumnwrapper.VoiceVolumnUtil");
}
return _mAndroidJavaObject;
}
}
#endregion
}
}
2、VoiceVolumnChangedIntereface
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace AndroidWrapper {
/// <summary>
/// 监听音量变化的监听接口
/// </summary>
public class VoiceVolumnChangedIntereface : AndroidJavaProxy
{
/// <summary>
/// 音量变化委托事件
/// </summary>
Action<int> _mVoiceVolumnChanged;
public VoiceVolumnChangedIntereface(Action<int> VoiceVolumnChanged):base("com.example.voicevolumnwrapper.VoiceVolumnChangedIntereface")
{
_mVoiceVolumnChanged = VoiceVolumnChanged;
}
/// <summary>
/// 监听音量变化的接口
/// </summary>
/// <param name="currentValue"></param>
public void VoiceVolumnChanged(int currentValue) {
if (_mVoiceVolumnChanged != null)
{
_mVoiceVolumnChanged(currentValue);
}
Debug.Log(GetType()+ "/VoiceVolumnChanged()/ 监听音量变化的接口函数执行");
}
}
}
3、TestVoiceVolumnWrapper
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using AndroidWrapper;
public class TestVoiceVolumnWrapper : MonoBehaviour
{
public Slider Volumn_Slider;
public Text Volumn_Text;
// Start is called before the first frame update
void Start()
{
VoiceVolumnWrapper.Instance.Init(SetVolumnListener);
InitSlider();
}
// Update is called once per frame
void Update()
{
}
/// <summary>
/// Slider 属性
/// </summary>
void InitSlider() {
#if UNITY_EDITOR
// 设置最大值
Volumn_Slider.maxValue = Random.Range(30,31);
// 设置最小值
Volumn_Slider.minValue = Random.Range(0, 1);
// 设置整数变化
Volumn_Slider.wholeNumbers = true;
// 设置当前值
Volumn_Slider.value = Random.Range(0, 30);
// 设置 Slider 监听事件
Volumn_Slider.onValueChanged.AddListener((value) => {
SetTextValue((int)value);
});
// 设置 Text
SetTextValue((int)Volumn_Slider.value);
#else
// 设置最大值
Volumn_Slider.maxValue = VoiceVolumnWrapper.Instance.GetMusicVoiceMax();
// 设置最小值
Volumn_Slider.minValue = VoiceVolumnWrapper.Instance.GetMusicVoiceMin();
// 设置整数变化
Volumn_Slider.wholeNumbers = true;
// 设置当前值
Volumn_Slider.value = VoiceVolumnWrapper.Instance.GetMusicVoiceCurrentValue();
// 设置 Slider 监听事件
Volumn_Slider.onValueChanged.AddListener((value)=>{
VoiceVolumnWrapper.Instance.SetMusicVoiceVolumn((int)value);
});
// 设置 Text
SetTextValue(VoiceVolumnWrapper.Instance.GetMusicVoiceCurrentValue());
#endif
}
void SetVolumnListener(int value) {
SetSliderValue(value);
SetTextValue(value);
}
void SetSliderValue(int value) {
Volumn_Slider.value = value;
}
void SetTextValue(int value) {
Volumn_Text.text = value.ToString();
}
}
4、MonoSingleton
using UnityEngine;
public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoBehaviour
{
private static T instance = null;
private static readonly object locker = new object();
private static bool bAppQuitting;
public static T Instance
{
get
{
if (bAppQuitting)
{
instance = null;
return instance;
}
lock (locker)
{
if (instance == null)
{
instance = FindObjectOfType<T>();
if (FindObjectsOfType<T>().Length > 1)
{
Debug.LogError("不应该存在多个单例!");
return instance;
}
if (instance == null)
{
var singleton = new GameObject();
instance = singleton.AddComponent<T>();
singleton.name = "(singleton)" + typeof(T);
singleton.hideFlags = HideFlags.None;
DontDestroyOnLoad(singleton);
}
else
DontDestroyOnLoad(instance.gameObject);
}
instance.hideFlags = HideFlags.None;
return instance;
}
}
}
protected virtual void Awake()
{
bAppQuitting = false;
}
protected virtual void OnDestroy()
{
bAppQuitting = true;
}
}
上一篇: 天窗是专为这发型开的吧
下一篇: 网红经济背后的营销套路