XiuXianGame/Assets/Scripts/Core/Audio/AudioManager.cs

using System.Collections.Generic;
using Fort23.Core;
using Fort23.UTool;
using UnityEngine;
using UnityEngine.Audio;
using Utility;

namespace Core.Audio
{
    public class AudioManager : Singleton<AudioManager>
    {
        private GameObject _root;
        public AudioMixerGroup AudioMixerGroup;
        private Map<string, AudioBundleInfo> _allAduionBundleInfos = new Map<string, AudioBundleInfo>();

        private Queue<AudioSourcePool> _audioSourcePools = new Queue<AudioSourcePool>();
        private Map<string, List<AudioSourcePool>> _currPlayAudio = new Map<string, List<AudioSourcePool>>();

        private List<string> _bgmQueue = new List<string>();
        private AudioSourcePool _currBgm;

        private List<string> _audion = new List<string>();

        public float AudionVolume
        {
            get => _audionVolume;
        }

        public float BgmVolume
        {
            get => _bgmVolume;
        }

        private float _audionVolume = 1;
        private float _bgmVolume = 1;

        public AudioManager()
        {
            // UIAudio.AudioPlayManager = this;
            _root = new GameObject();
            _root.name = "audio";
            AudioListener audioListener = GameObject.FindObjectOfType<AudioListener>();
            if (audioListener == null)
            {
                _root.AddComponent<AudioListener>();
            }

            Object.DontDestroyOnLoad(_root);
        }

        /// <summary>
        /// 设置音效音量
        /// </summary>
        /// <param name="value"></param>
        public void SetAudioValue(float value)
        {
            _audionVolume = value;
            for (_currPlayAudio.Begin(); _currPlayAudio.Next();)
            {
                for (int i = 0; i < _currPlayAudio.Value.Count; i++)
                {
                    _currPlayAudio.Value[i].Setvolume();
                }
            }
        }

        /// <summary>
        /// 设置背景音乐音量
        /// </summary>
        /// <param name="value"></param>
        public void SetBgmValue(float value)
        {
            _bgmVolume = value;
            for (_currPlayAudio.Begin(); _currPlayAudio.Next();)
            {
                for (int i = 0; i < _currPlayAudio.Value.Count; i++)
                {
                    _currPlayAudio.Value[i].Setvolume();
                }
            }

            _currBgm?.Setvolume();
        }

        public async CTask Init()
        {
        }

        public async CTask InitMainAudio()
        {
            string config = "MainAudio.asset";
            AssetHandle assetHandle =
                await AssetBundleLoadManager.Instance.LoadAssetAsyncTask<AudionSettingConfig>(config);
            await LoadAudio(assetHandle.AssetObject<AudionSettingConfig>());
        }

        public async CTask LoadAudio(AudionSettingConfig audionSettingConfig)
        {
            CTaskAwaitBuffer cTaskAwaitBuffer = new CTaskAwaitBuffer();
            for (int i = 0; i < audionSettingConfig.configs.Count; i++)
            {
                CTask cTask = LoadAudio(audionSettingConfig.configs[i]);
                cTaskAwaitBuffer.AddTask(cTask);
            }

            await cTaskAwaitBuffer.WaitAll();
        }

        public void RemoveAudio(AudionSettingConfig audionSettingConfig)
        {
            for (int i = 0; i < audionSettingConfig.configs.Count; i++)
            {
                AudionSettingConfig.AudionConfig audionConfig = audionSettingConfig.configs[i];
                if (_allAduionBundleInfos.TryGetValue(audionConfig.audionClipName, out AudioBundleInfo abi))
                {
                    if (_currPlayAudio.TryGetValue(audionConfig.audionClipName,
                            out List<AudioSourcePool> audioSourcePool))
                    {
                        for (int j = 0; j < audioSourcePool.Count; j++)
                        {
                            audioSourcePool[i].Finish();
                        }
                    }

                    abi.Dispose();
                    _allAduionBundleInfos.Remove(audionConfig.audionClipName);
                }
            }
        }

        public async CTask LoadAudio(AudionSettingConfig.AudionConfig audionConfig)
        {
            await GetAduionBundleInfo(audionConfig.audionClipName, audionConfig.volume);
        }

        public async CTask<AudioBundleInfo> GetAduionBundleInfo(string audionName, float volume = 1)
        {
            // if (audionName.Contains('.'))
            // {
            //     audionName = audionName.Split('.')[0];
            // }

            if (_allAduionBundleInfos.TryGetValue(audionName, out AudioBundleInfo abi))
            {
                return abi;
            }

            AudioBundleInfo audioBundleInfo = new AudioBundleInfo(audionName, volume);
            _allAduionBundleInfos.Add(audionName, audioBundleInfo);
            await audioBundleInfo.GetAudioClip();
            return audioBundleInfo;
        }


        public void Recycle(AudioSourcePool audioSourcePool)
        {
            if (!_audioSourcePools.Contains(audioSourcePool))
            {
                _audioSourcePools.Enqueue(audioSourcePool);
            }

            if (_currPlayAudio.TryGetValue(audioSourcePool.CurrPlayName, out List<AudioSourcePool> audioSourcePools))
            {
                audioSourcePools.Remove(audioSourcePool);
            }
        }

        private AudioSourcePool GetAudioSourcePool()
        {
            if (_audioSourcePools.Count <= 0)
            {
                AudioSourcePool audioSourcePool = new AudioSourcePool();
                audioSourcePool.Init(_root.transform);
                return audioSourcePool;
            }

            AudioSourcePool asp = _audioSourcePools.Dequeue();
            return asp;
        }

        public void Stop(string audionName)
        {
            if (_currPlayAudio.TryGetValue(audionName, out List<AudioSourcePool> asp))
            {
                for (int i = 0; i < asp.Count; i++)
                {
                    AudioSourcePool a = asp[i];
                    a.Finish();
                    i--;
                }
            }
        }

        public async void PlayBGM(string bgmName)
        {
            if (_currBgm != null && _currBgm.CurrPlayName != null && _currBgm.CurrPlayName.Equals(bgmName))
            {
                return;
            }

            if (_currBgm != null && _currBgm.IsPlay)
            {
                _bgmQueue.Add(_currBgm.CurrPlayName);
            }

            AudioBundleInfo audioBundleInfo = await GetAduionBundleInfo(bgmName);

            AssetHandle audioClip = await audioBundleInfo.GetAudioClip();
            if (_currBgm == null)
            {
                _currBgm = GetAudioSourcePool();
            }

            _currBgm.Play(bgmName, true, audioClip, true, audioBundleInfo._volume);
        }

        public void PauseBGM()
        {
            if (_currBgm != null)
            {
                _currBgm.Pause();
            }
        }

        public void UnPauseBGM()
        {
            if (_currBgm != null)
            {
                _currBgm.UnPause();
            }
        }

        public async void StopBGM(string bgmName)
        {
            if (_currBgm == null || _currBgm._currPlayName == null)
            {
                return;
            }

            if (_currBgm.CurrPlayName.Equals(bgmName))
            {
                _currBgm.Stop();
                if (_bgmQueue.Count > 0)
                {
                    string nextBgmName = _bgmQueue[^1];
                    _bgmQueue.RemoveAt(_bgmQueue.Count - 1);
                    PlayBGM(nextBgmName);
                }

                return;
            }

            if (_bgmQueue.Count > 0)
            {
                for (int i = _bgmQueue.Count - 1; i >= 0; i--)
                {
                    if (_bgmQueue[i].Equals(bgmName))
                    {
                        _bgmQueue.RemoveAt(i);
                    }
                }
            }
        }

        public async CTask<AudioSourcePool> PlayAudio(string audionName, bool isLoop = false, float speed = 1)
        {
            if (string.IsNullOrEmpty(audionName))
            {
                return null;
            }

            using (await CoroutineLockComponent.Instance.Wait(audionName))
            {
                if (_currPlayAudio.TryGetValue(audionName, out List<AudioSourcePool> asp))
                {
                    for (int i = 0; i < asp.Count; i++)
                    {
                        AudioSourcePool a = asp[i];
                        float t = a.GetPlayTime();
                        if (t > 0 && t < 0.05f)
                        {
                            return null;
                        }

                        a.Setvolume(a.AudioVolume - 0.33f);
                        if (a.AudioVolume <= 0)
                        {
                            a.Finish();
                            i--;
                        }
                    }
                    // if (asp.Progress() < 0.2)
                    // {
                    //     return null;
                    // }
                    //
                    // asp.Finish();
                }
                else
                {
                    asp = new List<AudioSourcePool>();
                    _currPlayAudio.Add(audionName, asp);
                }

                AudioBundleInfo audioBundleInfo = await GetAduionBundleInfo(audionName);

                AssetHandle audioClip = await audioBundleInfo.GetAudioClip();
                if (audioClip == null)
                {
                    return null;
                }

                AudioSourcePool audioSourcePool = GetAudioSourcePool();
                audioSourcePool.Play(audionName, false, audioClip, isLoop, audioBundleInfo._volume, speed);
                asp.Add(audioSourcePool);
                return audioSourcePool;
            }
        }

        public void Play(string audionName, bool isLoop)
        {
            PlayAudio(audionName, isLoop);
        }

        public void TimeLinePlayAudio(string audioName, bool isLoop, float speed)
        {
            PlayAudio(audioName, isLoop);
        }
    }
}