Unity Android 之获取各个音量的最大值、最小值、以及当前音量值，并设置音量值，监听音量变化的方法整理

最新推荐文章于 2022-10-13 13:19:12 发布

仙魁XAN

最新推荐文章于 2022-10-13 13:19:12 发布

阅读量1.7k

点赞数 3

分类专栏： Unity Android Unity 文章标签： Unity Android 音量设置获取监听

本文链接：https://blog.csdn.net/u014361280/article/details/108216525

版权

Unity 同时被 2 个专栏收录

211 篇文章 92 订阅

订阅专栏

Unity Android

17 篇文章 7 订阅

订阅专栏

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

仙魁XAN

关注

3
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
Unity Android 之获取各个音量的最大值、最小值、以及当前音量值，并设置音量值，监听音量变化的方法整理

Unity Android 之获取各个音量的最大值、最小值、以及当前音量值，并设置音量值，监听音量变化的方法整理目录Unity Android 之获取各个音量的最大值、最小值、以及当前音量值，并设置音量值，监听音量变化的方法整理一、简单介绍二、实现原理三、注意事项四、效果预览五、实现步骤Android 端：Unity 端六、关键代码Android 端Unity 端一、简单介绍Unity Android 开发上会用到的技术...
复制链接

扫一扫