< Summary

Class:EnqueuedThumbnail
Assembly:ThumbnailsManager
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Helpers/ThumbnailsManager/ThumbnailsManager.cs
Covered lines:0
Uncovered lines:3
Coverable lines:3
Total lines:177
Line coverage:0% (0 of 3)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
EnqueuedThumbnail(...)0%2100%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Helpers/ThumbnailsManager/ThumbnailsManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Generic;
 3using UnityEngine;
 4using DCL;
 5using Object = UnityEngine.Object;
 6
 7//In the future the AssetManager will do this
 8public static class ThumbnailsManager
 9{
 10#if UNITY_EDITOR
 11    public static bool bypassRequests = false;
 12#endif
 13    private static readonly Queue<EnqueuedThumbnail> promiseQueue = new Queue<EnqueuedThumbnail>();
 14    private static readonly List<AssetPromise_Texture> progressList = new List<AssetPromise_Texture>();
 15    private static readonly Dictionary<Texture2D, Sprite> spriteCache = new Dictionary<Texture2D, Sprite>();
 16    private static readonly Dictionary<string, AssetPromise_Texture> promiseCache = new Dictionary<string, AssetPromise_
 17    private const int CONCURRENT_LIMIT = 10;
 18
 19    public static void Clear()
 20    {
 21        foreach (EnqueuedThumbnail thumbnail in promiseQueue)
 22        {
 23            AssetPromiseKeeper_Texture.i.Forget(thumbnail.Promise);
 24        }
 25        promiseQueue.Clear();
 26
 27        foreach (AssetPromise_Texture promiseTexture in progressList)
 28        {
 29            AssetPromiseKeeper_Texture.i.Forget(promiseTexture);
 30        }
 31        progressList.Clear();
 32
 33        foreach (KeyValuePair<string,AssetPromise_Texture> assetPromiseTexture in promiseCache)
 34        {
 35            AssetPromiseKeeper_Texture.i.Forget(assetPromiseTexture.Value);
 36        }
 37        promiseCache.Clear();
 38
 39        foreach (KeyValuePair<Texture2D,Sprite> sprite in spriteCache)
 40        {
 41            Object.DestroyImmediate(sprite.Value);
 42        }
 43        spriteCache.Clear();
 44    }
 45
 46    public static AssetPromise_Texture PreloadThumbnail(string url)
 47    {
 48#if UNITY_EDITOR
 49        if (bypassRequests)
 50            return null;
 51#endif
 52        if (string.IsNullOrEmpty(url))
 53            return null;
 54
 55        var promise = new AssetPromise_Texture(url);
 56        AssetPromiseKeeper_Texture.i.Keep(promise);
 57
 58        return promise;
 59    }
 60
 61    public static void ForgetThumbnail(AssetPromise_Texture promise)
 62    {
 63        if (promise == null)
 64            return;
 65
 66        //Debug.Log("Forget thumbnail " + promise.asset.id);
 67        AssetPromiseKeeper_Texture.i.Forget(promise);
 68    }
 69
 70    public static void GetThumbnail(string url, Action<Asset_Texture> OnComplete)
 71    {
 72#if UNITY_EDITOR
 73        if (bypassRequests)
 74            return;
 75#endif
 76        if (string.IsNullOrEmpty(url))
 77            return;
 78
 79        if (promiseCache.ContainsKey(url))
 80        {
 81            var promise = promiseCache[url];
 82
 83            if (promise.state == AssetPromiseState.FINISHED)
 84            {
 85                OnComplete(promise.asset);
 86            }
 87            else
 88            {
 89                promise.OnSuccessEvent += OnComplete;
 90            }
 91
 92            return;
 93        }
 94
 95        var newPromise = new AssetPromise_Texture(url);
 96        promiseCache.Add(url, newPromise);
 97
 98        AddToQueue(new EnqueuedThumbnail(newPromise, OnComplete));
 99        CheckQueue();
 100    }
 101    private static void CheckQueue()
 102    {
 103        var availableSlots = Mathf.Max(CONCURRENT_LIMIT - progressList.Count, 0);
 104
 105        for (int i = progressList.Count - 1; i >= 0 ; i--)
 106        {
 107            if (progressList[i].state == AssetPromiseState.IDLE_AND_EMPTY)
 108            {
 109                progressList.RemoveAt(i);
 110            }
 111        }
 112
 113        if (availableSlots > 0)
 114        {
 115            var availableDownloads = Mathf.Min(availableSlots, promiseQueue.Count);
 116
 117            if (availableDownloads > 0)
 118            {
 119                for (int i = 0; i < availableDownloads; i++)
 120                {
 121                    if (promiseQueue.Count == 0)
 122                        break;
 123
 124                    var promise = promiseQueue.Dequeue();
 125                    AssetPromise_Texture assetPromiseTexture = promise.Promise;
 126                    BeginDownload(assetPromiseTexture, promise.OnComplete);
 127                }
 128            }
 129        }
 130    }
 131    private static void AddToQueue(EnqueuedThumbnail enqueuedThumbnail)
 132    {
 133        promiseQueue.Enqueue(enqueuedThumbnail);
 134    }
 135    private static void BeginDownload(AssetPromise_Texture promise, Action<Asset_Texture> OnComplete)
 136    {
 137        progressList.Add(promise);
 138
 139        promise.OnSuccessEvent += t =>
 140        {
 141            progressList.Remove(promise);
 142            OnComplete(t);
 143            CheckQueue();
 144        };
 145
 146        promise.OnFailEvent += (x, error) =>
 147        {
 148            progressList.Remove(promise);
 149            Debug.Log($"Error downloading: {promise.url}, Exception: {error}");
 150            CheckQueue();
 151        };
 152
 153        AssetPromiseKeeper_Texture.i.Keep(promise);
 154    }
 155
 156    public static Sprite GetOrCreateSpriteFromTexture(Texture2D texture, out bool wasCreated)
 157    {
 158        wasCreated = false;
 159        if (!spriteCache.ContainsKey(texture))
 160        {
 161            spriteCache[texture] = Sprite.Create(texture, new Rect(0, 0, texture.width, texture.height), Vector2.zero);
 162            wasCreated = true;
 163        }
 164        return spriteCache[texture];
 165    }
 166}
 167
 168public struct EnqueuedThumbnail
 169{
 170    public readonly AssetPromise_Texture Promise;
 171    public readonly Action<Asset_Texture> OnComplete;
 172    public EnqueuedThumbnail(AssetPromise_Texture promise, Action<Asset_Texture> complete)
 173    {
 0174        this.Promise = promise;
 0175        OnComplete = complete;
 0176    }
 177}
Generated by: ReportGenerator 4.8.9.0
09/09/2022 - 13:27:14
GitHub | www.palmmedia.de

Methods/Properties

EnqueuedThumbnail(DCL.AssetPromise_Texture, System.Action[Asset_Texture])