MojSadUnity/Assets/Code/Infrastructure/Audio/AudioFactory.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using Code.Infrastructure.Configs;
using Code.Infrastructure.EventBus;
using Cysharp.Threading.Tasks;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;

namespace Code.Infrastructure.Audio
{
    public interface IAudioFactory
    {
        UniTaskVoid LoadAudioClips(AudioNames groupName);
        void ReleaseAudios(AudioNames groupName);
    }

    public class AudioFactory : IAudioFactory, IDisposable
    {
        private string _label;
        private Dictionary<AudioNames, Dictionary<int, AssetReference>> _audioInfos = new();

        private Dictionary<AudioNames, Dictionary<int, AsyncOperationHandle<AudioClip>>> _clipsHandles = new();
        private AsyncOperationHandle<IList<AudioInfoConfig>> _configsHandle;
        private EventBus.EventBus _eventBus;

        public AudioFactory(IConfigLocator configLocator, EventBus.EventBus eventBus)
        {
            _eventBus = eventBus;
            _label = configLocator.TryGetManyConfigAssetReferences<AudioInfoConfig>();
            
            for (var i = 0; i < typeof(AudioNames).GetEnumValues().Length; i++)
            {
                _audioInfos.Add((AudioNames)i, new Dictionary<int, AssetReference>());
                _clipsHandles.Add((AudioNames)i, new Dictionary<int, AsyncOperationHandle<AudioClip>>());
            }

            LoadConfigs().Forget();
        }
        
        private async UniTaskVoid LoadConfigs()
        {
            _configsHandle = Addressables.LoadAssetsAsync<AudioInfoConfig>(_label);

            await _configsHandle.ToUniTask();

            foreach (AudioInfoConfig config in _configsHandle.Result) 
                _audioInfos[config.GroupName].Add(config.id, config.fileReference);

            _eventBus.RaiseEvent<IAudioConfigsLoadedHandle>(ui => ui.AudioConfigsLoaded());
        }

        public async UniTaskVoid LoadAudioClips(AudioNames groupName)
        {
            UnityEngine.Debug.LogWarning($"Audios loaded {groupName}");
            
            foreach (var audioInfo in _audioInfos[groupName])
                if (!_clipsHandles[groupName].ContainsKey(audioInfo.Key))
                    _clipsHandles[groupName].Add(audioInfo.Key, Addressables.LoadAssetAsync<AudioClip>(audioInfo.Value));
                else
                    _clipsHandles[groupName][audioInfo.Key] = Addressables.LoadAssetAsync<AudioClip>(audioInfo.Value);

            foreach (var handle in _clipsHandles[groupName]) 
                await handle.Value.ToUniTask();

            _eventBus.RaiseEvent<IAudioClipsEventHandle>(ui =>
                ui.AudioClipsLoaded(groupName, _clipsHandles[groupName].ToDictionary(
                    x => x.Key,
                    x => x.Value.Result)));
        }

        public void ReleaseAudios(AudioNames groupName)
        {
            UnityEngine.Debug.LogWarning($"Audios unloaded {groupName}");
            _eventBus.RaiseEvent<IAudioClipsEventHandle>(x=> x.AudioClipsUnLoaded(groupName));
            
            foreach (var handle in _clipsHandles) 
                Addressables.Release(handle.Value);
        }
        public void Dispose()
        {
            foreach (var handles in _clipsHandles)
            {
                foreach (var handle in handles.Value)
                {
                    handle.Value.Release();
                }
            }

            _configsHandle.Release();
        }
    }

    internal interface IAudioConfigsLoadedHandle : IGlobalSubscriber
    {
        void AudioConfigsLoaded();
    }

    internal interface IAudioClipsEventHandle : IGlobalSubscriber
    {
        void AudioClipsLoaded(AudioNames groupName, Dictionary<int, AudioClip> toDictionary);
        void AudioClipsUnLoaded(AudioNames groupName);
    }
}