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

逃离我推掉我的手 2022-11-30 15:54 571阅读 0赞

![2020082510343941.png][]

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

**目录**

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

一、简单介绍

二、实现原理

三、注意事项

四、效果预览

五、实现步骤

Android 端：

Unity 端

六、关键代码

Android 端

Unity 端

--------------------

## 一、简单介绍 ##

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，就可以了）

## 四、效果预览 ##

![20200825104713447.gif][]

## 五、实现步骤 ##

### Android 端： ###

1、新建一个Android Library 模块，其他默认设置就好

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70][]

2、在模块中新建两个脚本，VoiceVolumnUtil 封装各个功能，VoiceVolumnChangedIntereface 一个接口函数，音量变化的接口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1][]

3、脚本编辑 OK，Build - Make Module ‘xxxx’，打包 aar

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2][]

4、打包成功，build 文件夹outputs/aar中就会 有对应的 aar 生成

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3][]

### Unity 端 ###

1、把 Android 打包的 aar 导入 Unity

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4][]

2、在场景中布局UI，slider 显示设置音量大小，Text 显示具体音量大小

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5][]

3、在 Unity工程中，新建脚本，编辑对应功能

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6][]

4、把 TestVoiceVolumnWrapper 挂载到场景中，并对应赋值

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7][]

5、运行场景，没有问题，即可打包到真机上测试

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9][]

6、真机上的测试效果如上

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10][]

## 六、关键代码 ##

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 11][]

[2020082510343941.png]: /images/20221123/516e55b5367247189ececcb23b4a8650.png
[20200825104713447.gif]: /images/20221123/91dcb1ace9ad4e9299b377ff884018fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70]: /images/20221123/4f96d2881b0f4bc58580f00125c19869.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 1]: /images/20221123/9792b55ba20e49a8a9d6b644d390df37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 2]: /images/20221123/a10547d386654ee68c0bc050eb6bd4dc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 3]: /images/20221123/4e865b11d0c847c08e2b5944e1dc4e14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 4]: /images/20221123/eadc0a52daa24b3186ce4cd7834c3ed2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 5]: /images/20221123/d22bc7a7e5ed4e6d98dffcbaf7f35624.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 6]: /images/20221123/d513fd458aa74d7285105bdc10d9dace.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 7]: /images/20221123/9f229cd237e74be9b89e90dd91a8802a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 8]: /images/20221123/950729e2cbd14c77b4031952572b70a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 9]: /images/20221123/000a64893b69477e9dc6ce5e994d64cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 10]: /images/20221123/911df9d6d5574b3ead3859bab7c62573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQzNjEyODA_size_16_color_FFFFFF_t_70 11]: /images/20221123/7994478e0358440081eb4e907a743b8b.png