Add project files.

Assets/Davinci/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 80c7be556956649f59a566705e1e5deb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Davinci/Scripts/Davinci.cs

@@ -0,0 +1,659 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.UI;
+#if UNITY_2018_3_OR_NEWER
+using UnityEngine.Networking;
+#endif
+
+/// <summary>
+/// Davinci - A powerful, esay-to-use image downloading and caching library for Unity in Run-Time
+/// v 1.2
+/// Developed by ShamsDEV.com
+/// copyright (c) ShamsDEV.com All Rights Reserved.
+/// Licensed under the MIT License.
+/// https://github.com/shamsdev/davinci
+/// </summary>
+public class Davinci : MonoBehaviour
+{
+    private static bool ENABLE_GLOBAL_LOGS = true;
+
+    private bool enableLog = false;
+    private float fadeTime = 1;
+    private bool cached = true;
+
+    private enum RendererType
+    {
+        none,
+        uiImage,
+        renderer,
+        sprite
+    }
+
+    private RendererType rendererType = RendererType.none;
+    private GameObject targetObj;
+    private string url = null;
+
+    private Texture2D loadingPlaceholder, errorPlaceholder;
+
+    private UnityAction onStartAction,
+        onDownloadedAction,
+        OnLoadedAction,
+        onEndAction;
+
+    private UnityAction<int> onDownloadProgressChange;
+    private UnityAction<string> onErrorAction;
+
+    private static Dictionary<string, Davinci> underProcessDavincies
+        = new Dictionary<string, Davinci>();
+
+    private string uniqueHash;
+    private int progress;
+
+    private bool success = false;
+
+    static string filePath = Application.persistentDataPath + "/" +
+            "davinci" + "/";
+
+
+    /// <summary>
+    /// Get instance of davinci class
+    /// </summary>
+    public static Davinci get()
+    {
+        return new GameObject("Davinci").AddComponent<Davinci>();
+    }
+
+    /// <summary>
+    /// Set image url for download.
+    /// </summary>
+    /// <param name="url">Image Url</param>
+    /// <returns></returns>
+    public Davinci load(string url)
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Url set : " + url);
+
+        this.url = url;
+        return this;
+    }
+
+    /// <summary>
+    /// Set fading animation time.
+    /// </summary>
+    /// <param name="fadeTime">Fade animation time. Set 0 for disable fading.</param>
+    /// <returns></returns>
+    public Davinci setFadeTime(float fadeTime)
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Fading time set : " + fadeTime);
+
+        this.fadeTime = fadeTime;
+        return this;
+    }
+
+    /// <summary>
+    /// Set target Image component.
+    /// </summary>
+    /// <param name="image">target Unity UI image component</param>
+    /// <returns></returns>
+    public Davinci into(Image image)
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Target as UIImage set : " + image);
+
+        rendererType = RendererType.uiImage;
+        this.targetObj = image.gameObject;
+        return this;
+    }
+
+    /// <summary>
+    /// Set target Renderer component.
+    /// </summary>
+    /// <param name="renderer">target renderer component</param>
+    /// <returns></returns>
+    public Davinci into(Renderer renderer)
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Target as Renderer set : " + renderer);
+
+        rendererType = RendererType.renderer;
+        this.targetObj = renderer.gameObject;
+        return this;
+    }
+
+    public Davinci into(SpriteRenderer spriteRenderer)
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Target as SpriteRenderer set : " + spriteRenderer);
+
+        rendererType = RendererType.sprite;
+        this.targetObj = spriteRenderer.gameObject;
+        return this;
+    }
+
+    #region Actions
+    public Davinci withStartAction(UnityAction action)
+    {
+        this.onStartAction = action;
+
+        if (enableLog)
+            Debug.Log("[Davinci] On start action set : " + action);
+
+        return this;
+    }
+
+    public Davinci withDownloadedAction(UnityAction action)
+    {
+        this.onDownloadedAction = action;
+
+        if (enableLog)
+            Debug.Log("[Davinci] On downloaded action set : " + action);
+
+        return this;
+    }
+
+    public Davinci withDownloadProgressChangedAction(UnityAction<int> action)
+    {
+        this.onDownloadProgressChange = action;
+
+        if (enableLog)
+            Debug.Log("[Davinci] On download progress changed action set : " + action);
+
+        return this;
+    }
+
+    public Davinci withLoadedAction(UnityAction action)
+    {
+        this.OnLoadedAction = action;
+
+        if (enableLog)
+            Debug.Log("[Davinci] On loaded action set : " + action);
+
+        return this;
+    }
+
+    public Davinci withErrorAction(UnityAction<string> action)
+    {
+        this.onErrorAction = action;
+
+        if (enableLog)
+            Debug.Log("[Davinci] On error action set : " + action);
+
+        return this;
+    }
+
+    public Davinci withEndAction(UnityAction action)
+    {
+        this.onEndAction = action;
+
+        if (enableLog)
+            Debug.Log("[Davinci] On end action set : " + action);
+
+        return this;
+    }
+    #endregion
+
+    /// <summary>
+    /// Show or hide logs in console.
+    /// </summary>
+    /// <param name="enable">'true' for show logs in console.</param>
+    /// <returns></returns>
+    public Davinci setEnableLog(bool enableLog)
+    {
+        this.enableLog = enableLog;
+
+        if (enableLog)
+            Debug.Log("[Davinci] Logging enabled : " + enableLog);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Set the sprite of image when davinci is downloading and loading image
+    /// </summary>
+    /// <param name="loadingPlaceholder">loading texture</param>
+    /// <returns></returns>
+    public Davinci setLoadingPlaceholder(Texture2D loadingPlaceholder)
+    {
+        this.loadingPlaceholder = loadingPlaceholder;
+
+        if (enableLog)
+            Debug.Log("[Davinci] Loading placeholder has been set.");
+
+        return this;
+    }
+
+    /// <summary>
+    /// Set image sprite when some error occurred during downloading or loading image
+    /// </summary>
+    /// <param name="errorPlaceholder">error texture</param>
+    /// <returns></returns>
+    public Davinci setErrorPlaceholder(Texture2D errorPlaceholder)
+    {
+        this.errorPlaceholder = errorPlaceholder;
+
+        if (enableLog)
+            Debug.Log("[Davinci] Error placeholder has been set.");
+
+        return this;
+    }
+
+    /// <summary>
+    /// Enable cache
+    /// </summary>
+    /// <returns></returns>
+    public Davinci setCached(bool cached)
+    {
+        this.cached = cached;
+
+        if (enableLog)
+            Debug.Log("[Davinci] Cache enabled : " + cached);
+
+        return this;
+    }
+
+    /// <summary>
+    /// Start davinci process.
+    /// </summary>
+    public void start()
+    {
+        if (url == null)
+        {
+            error("Url has not been set. Use 'load' funtion to set image url.");
+            return;
+        }
+
+        try
+        {
+            Uri uri = new Uri(url);
+            this.url = uri.AbsoluteUri;
+        }
+        catch (Exception ex)
+        {
+            error("Url is not correct.");
+            return;
+        }
+
+        if (rendererType == RendererType.none || targetObj == null)
+        {
+            error("Target has not been set. Use 'into' function to set target component.");
+            return;
+        }
+
+        if (enableLog)
+            Debug.Log("[Davinci] Start Working.");
+
+        if (loadingPlaceholder != null)
+            SetLoadingImage();
+
+        if (onStartAction != null)
+            onStartAction.Invoke();
+
+        if (!Directory.Exists(filePath))
+        {
+            Directory.CreateDirectory(filePath);
+        }
+
+        uniqueHash = CreateMD5(url);
+
+        if (underProcessDavincies.ContainsKey(uniqueHash))
+        {
+            Davinci sameProcess = underProcessDavincies[uniqueHash];
+            sameProcess.onDownloadedAction += () =>
+            {
+                if (onDownloadedAction != null)
+                    onDownloadedAction.Invoke();
+
+                loadSpriteToImage();
+            };
+        }
+        else
+        {
+            if (File.Exists(filePath + uniqueHash))
+            {
+                if (onDownloadedAction != null)
+                    onDownloadedAction.Invoke();
+
+                loadSpriteToImage();
+            }
+            else
+            {
+                underProcessDavincies.Add(uniqueHash, this);
+                StopAllCoroutines();
+                StartCoroutine("Downloader");
+            }
+        }
+    }
+
+    private IEnumerator Downloader()
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Download started.");
+
+#if UNITY_2018_3_OR_NEWER
+        UnityWebRequest www = UnityWebRequestTexture.GetTexture(url);
+        yield return www.SendWebRequest();
+#else
+        var www = new WWW(url);
+#endif
+
+        while (!www.isDone)
+        {
+            if (www.error != null)
+            {
+                error("Error while downloading the image : " + www.error);
+                yield break;
+            }
+
+#if UNITY_2018_3_OR_NEWER
+            progress = Mathf.FloorToInt(www.downloadProgress * 100);
+#else
+            progress = Mathf.FloorToInt(www.progress * 100);
+#endif
+            if (onDownloadProgressChange != null)
+                onDownloadProgressChange.Invoke(progress);
+
+            if (enableLog)
+                Debug.Log("[Davinci] Downloading progress : " + progress + "%");
+
+            yield return null;
+        }
+
+#if UNITY_2018_3_OR_NEWER
+        if (www.error == null)
+            File.WriteAllBytes(filePath + uniqueHash, www.downloadHandler.data);
+#else
+        if (www.error == null)
+            File.WriteAllBytes(filePath + uniqueHash, www.bytes);
+#endif
+
+        www.Dispose();
+        www = null;
+
+        if (onDownloadedAction != null)
+            onDownloadedAction.Invoke();
+
+        loadSpriteToImage();
+
+        underProcessDavincies.Remove(uniqueHash);
+    }
+
+    private void loadSpriteToImage()
+    {
+        progress = 100;
+        if (onDownloadProgressChange != null)
+            onDownloadProgressChange.Invoke(progress);
+
+        if (enableLog)
+            Debug.Log("[Davinci] Downloading progress : " + progress + "%");
+
+        if (!File.Exists(filePath + uniqueHash))
+        {
+            error("Loading image file has been failed.");
+            return;
+        }
+
+        StopAllCoroutines();
+        StartCoroutine(ImageLoader());
+    }
+
+    private void SetLoadingImage()
+    {
+        switch (rendererType)
+        {
+            case RendererType.renderer:
+                Renderer renderer = targetObj.GetComponent<Renderer>();
+                renderer.material.mainTexture = loadingPlaceholder;
+                break;
+
+            case RendererType.uiImage:
+                Image image = targetObj.GetComponent<Image>();
+                Sprite sprite = Sprite.Create(loadingPlaceholder,
+                    new Rect(0, 0, loadingPlaceholder.width, loadingPlaceholder.height),
+                    new Vector2(0.5f, 0.5f));
+                image.sprite = sprite;
+
+                break;
+
+            case RendererType.sprite:
+                SpriteRenderer spriteRenderer = targetObj.GetComponent<SpriteRenderer>();
+                Sprite spriteImage = Sprite.Create(loadingPlaceholder,
+                    new Rect(0, 0, loadingPlaceholder.width, loadingPlaceholder.height),
+                    new Vector2(0.5f, 0.5f));
+
+                spriteRenderer.sprite = spriteImage;
+                break;
+        }
+
+    }
+
+    private IEnumerator ImageLoader(Texture2D texture = null)
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Start loading image.");
+
+        if (texture == null)
+        {
+            byte[] fileData;
+            fileData = File.ReadAllBytes(filePath + uniqueHash);
+            texture = new Texture2D(2, 2);
+            //ImageConversion.LoadImage(texture, fileData);
+            texture.LoadImage(fileData); //..this will auto-resize the texture dimensions.
+        }
+
+        Color color;
+
+        if (targetObj != null)
+            switch (rendererType)
+            {
+                case RendererType.renderer:
+                    Renderer renderer = targetObj.GetComponent<Renderer>();
+
+                    if (renderer == null || renderer.material == null)
+                        break;
+
+                    renderer.material.mainTexture = texture;
+                    float maxAlpha;
+
+                    if (fadeTime > 0 && renderer.material.HasProperty("_Color"))
+                    {
+                        color = renderer.material.color;
+                        maxAlpha = color.a;
+
+                        color.a = 0;
+
+                        renderer.material.color = color;
+                        float time = Time.time;
+                        while (color.a < maxAlpha)
+                        {
+                            color.a = Mathf.Lerp(0, maxAlpha, (Time.time - time) / fadeTime);
+
+                            if (renderer != null)
+                                renderer.material.color = color;
+
+                            yield return null;
+                        }
+                    }
+
+                    break;
+
+                case RendererType.uiImage:
+                    Image image = targetObj.GetComponent<Image>();
+
+                    if (image == null)
+                        break;
+
+                    Sprite sprite = Sprite.Create(texture,
+                        new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
+
+                    image.sprite = sprite;
+                    color = image.color;
+                    maxAlpha = color.a;
+
+                    if (fadeTime > 0)
+                    {
+                        color.a = 0;
+                        image.color = color;
+
+                        float time = Time.time;
+                        while (color.a < maxAlpha)
+                        {
+                            color.a = Mathf.Lerp(0, maxAlpha, (Time.time - time) / fadeTime);
+
+                            if (image != null)
+                                image.color = color;
+                            yield return null;
+                        }
+                    }
+                    break;
+
+                case RendererType.sprite:
+                    SpriteRenderer spriteRenderer = targetObj.GetComponent<SpriteRenderer>();
+
+                    if (spriteRenderer == null)
+                        break;
+
+                    Sprite spriteImage = Sprite.Create(texture,
+                        new Rect(0, 0, texture.width, texture.height), new Vector2(0.5f, 0.5f));
+
+                    spriteRenderer.sprite = spriteImage;
+                    color = spriteRenderer.color;
+                    maxAlpha = color.a;
+
+                    if (fadeTime > 0)
+                    {
+                        color.a = 0;
+                        spriteRenderer.color = color;
+
+                        float time = Time.time;
+                        while (color.a < maxAlpha)
+                        {
+                            color.a = Mathf.Lerp(0, maxAlpha, (Time.time - time) / fadeTime);
+
+                            if (spriteRenderer != null)
+                                spriteRenderer.color = color;
+                            yield return null;
+                        }
+                    }
+                    break;
+            }
+
+        if (OnLoadedAction != null)
+            OnLoadedAction.Invoke();
+
+        if (enableLog)
+            Debug.Log("[Davinci] Image has been loaded.");
+
+        success = true;
+        finish();
+    }
+
+    public static string CreateMD5(string input)
+    {
+        // Use input string to calculate MD5 hash
+        using (System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create())
+        {
+            byte[] inputBytes = Encoding.ASCII.GetBytes(input);
+            byte[] hashBytes = md5.ComputeHash(inputBytes);
+
+            // Convert the byte array to hexadecimal string
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < hashBytes.Length; i++)
+            {
+                sb.Append(hashBytes[i].ToString("X2"));
+            }
+            return sb.ToString();
+        }
+    }
+
+    private void error(string message)
+    {
+        success = false;
+
+        if (enableLog)
+            Debug.LogError("[Davinci] Error : " + message);
+
+        if (onErrorAction != null)
+            onErrorAction.Invoke(message);
+
+        if (errorPlaceholder != null)
+            StartCoroutine(ImageLoader(errorPlaceholder));
+        else finish();
+    }
+
+    private void finish()
+    {
+        if (enableLog)
+            Debug.Log("[Davinci] Operation has been finished.");
+
+        if (!cached)
+        {
+            try
+            {
+                File.Delete(filePath + uniqueHash);
+            }
+            catch (Exception ex)
+            {
+                if (enableLog)
+                    Debug.LogError($"[Davinci] Error while removing cached file: {ex.Message}");
+            }
+        }
+
+        if (onEndAction != null)
+            onEndAction.Invoke();
+
+        Invoke("destroyer", 0.5f);
+    }
+
+    private void destroyer()
+    {
+        Destroy(gameObject);
+    }
+
+
+    /// <summary>
+    /// Clear a certain cached file with its url
+    /// </summary>
+    /// <param name="url">Cached file url.</param>
+    /// <returns></returns>
+    public static void ClearCache(string url)
+    {
+        try
+        {
+            File.Delete(filePath + CreateMD5(url));
+
+            if (ENABLE_GLOBAL_LOGS)
+                Debug.Log($"[Davinci] Cached file has been cleared: {url}");
+        }
+        catch (Exception ex)
+        {
+            if (ENABLE_GLOBAL_LOGS)
+                Debug.LogError($"[Davinci] Error while removing cached file: {ex.Message}");
+        }
+    }
+
+    /// <summary>
+    /// Clear all davinci cached files
+    /// </summary>
+    /// <returns></returns>
+    public static void ClearAllCachedFiles()
+    {
+        try
+        {
+            Directory.Delete(filePath, true);
+
+            if (ENABLE_GLOBAL_LOGS)
+                Debug.Log("[Davinci] All Davinci cached files has been cleared.");
+        }
+        catch (Exception ex)
+        {
+            if (ENABLE_GLOBAL_LOGS)
+                Debug.LogError($"[Davinci] Error while removing cached file: {ex.Message}");
+        }
+    }
+}

Assets/Davinci/Scripts/Davinci.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0bdb01a2c8c314f3aa67316e12ee5c83
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: