Unity2018 Assetbundle (어셋번들 + 암호화 + 패치)

AssetBundle ?

- 유니티에서 사용되는 Asset들을 하나로 묶는 기능 

(LZMA 압축 알고리즘 사용)

LZMA(Lempel–Ziv–Markov chain algorithm)는 데이터 압축에 쓰이는 알고리즘이다. 1998년 이후로 계속 개발 중이며 7-zip 압축 프로그램의 7z 형식에 쓰인다.

UnityEditor 라이브러리의 BuildPipeline 클래스를 이용해서 생성 

BuildPipeline.BuildAssetBundle : 일반 에셋 

BuildPipeline.BuildStreamedSceneAssetBundle : 씬 

AssetBundle 간의 호환성 : 각각 전용 에셋번들을 제작 해야 함 (BuildTarget옵션 사용)

	스탠드얼론	웹플레이어	아이폰	안드로이드
에디터	예	예	예	예
스텐드얼론	예	예	아니오	아니오
웹플레이어	예	예	아니오	아니오
아이폰	아니오	아니오	예	아니오
안드로이드	아니오	아니오	아니오	예

Caching (캐싱)

다운로드한 AssetBundle을 디스크에 저장하고 차후 재사용 가능 하게 함 

버전 관리 

LoadFromCacheOrDownload함수 이용 

Caching Capacity (캐싱 허용량)

- Mobile, PC, Console : 4G

- Web : 50MB

- Caching.maximumAvailableDiskSpace를 이용해 사이즈 조절 가능 

- 캐싱 용량이 부족할 경우 마지막 사용된 날짜가 오래된것부터 삭제됨.

- 디스크 용량이 부족하거나 캐쉬가 사용중이면 디스크 저장 없이 바로 메모리에 어셋번들을 올림 

don’t forget to unload all loaded assetbundles before call Caching.

public static void CleanAssetBundleCache(){

   Debug.Log(Caching.CleanCache () ? "Successfully removed Cache" ? "Cache in use")=

}




assetbundle cache path

windows
Users\name\AppData\LocalLow\Unity\WebPlayer\Cache

Mac
~/Library/Caches/Unity/

Android (should be)
/sdcard/Android/data/com.yourapp.id/files/UnityCache/Shared

암호화 

- 유니티는 암호화를 지원하지 않음 

- Open SSL을 이용해서 암호화 하여 사용함 

OpenSSL은 네트워크를 통한 데이터 통신에 쓰이는 프로토콜인 TLS와 SSL의 오픈 소스 구현판이다. C 언어로 작성되어 있는 중심 라이브러리 안에는, 기본적인 암호화 기능 및 여러 유틸리티 함수들이 구현되어 있다.

- 복호화시에 시간이 필요하기 때문에 모든 에셋을 암호화 하기보다는 중요한 일부 

에셋을 보호 하는 용도로 사용하는것이 좋음 

1. OpenSSL을 이용해 암호화 

2. 암호화된 에셋번들을 텍스트로 변환 

2. 전달방법 선택 : Application내에 포함 또는 서버 다운로드 

4. 암호화된 에셋번들을 메모리에서 복호화 

5. AssetBundle.CreateFromMemory(byte[])를 이용해 에셋번들 로드 

   # 변경 사항

[예제] 에셋번들 암호화 

사전준비 1 : OpenSSL 다운로드 및 설치, HOME Path 잡기 

사전 준비 2 : 에셋번들 생성 

AssetBundles-Browser-master 패키지 인스톨 

에셋번들 암호화 시작 

1. openssl rc2 -nosalt -p -in {파일명} -out {파일명}.bin

2. openssl base64 -in {파일명}.bin -out {파일명}.txt

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using UnityEngine;
 
public class DeCryptoAssetBundle : MonoBehaviour {
    
    private string gainedKey = "E10ADC3949BA59ABBE56E057F20F883E";
    private string gaineIv = "65B4AD270B3B9809";
 
    // Use this for initialization
    void Start () {
 
        //C:\Users\Administrator\AppData\LocalLow\DefaultCompany\AssetbundleTest\AssetBundles
        string path = Path.Combine(Application.persistentDataPath + "/AssetBundles/", "character.txt");
 
        //Read the text from directly from the test.txt file
        StreamReader reader = new StreamReader(path);
        var cryptedBundleText = reader.ReadToEnd();
        reader.Close();
 
        byte[] bytes = Convert.FromBase64String(cryptedBundleText);
        byte[] key = StringToByteArray(gainedKey);
        byte[] iv = StringToByteArray(gaineIv);
 
        //복호화 
        RC2 rc2 = new RC2CryptoServiceProvider();
        rc2.Mode = CipherMode.CBC;
        ICryptoTransform xform = rc2.CreateDecryptor(key, iv);
        byte[] decrypted = xform.TransformFinalBlock(bytes, 0, bytes.Length);
 
        StartCoroutine(AssetBundleLoad(decrypted));
 
    }
 
    IEnumerator AssetBundleLoad(byte[] data) {
                                                //AssetBundle.CreateFromMemory
        AssetBundleCreateRequest bundleRequst = AssetBundle.LoadFromMemoryAsync(data);
 
        yield return bundleRequst;
 
        var bundle = bundleRequst.assetBundle;
        var prefab = bundle.LoadAsset<GameObject>("ch_02_01");
        Instantiate(prefab);
    }
 
    public static byte[] StringToByteArray(string hex) {
        int numChars = hex.Length;
        byte[] bytes = new byte[ numChars / 2];
        for (int i = 0; i < numChars; i += 2) {
            bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
        }
        return bytes;
    }
    
    // Update is called once per frame
    void Update () {
        
    }
}
 

[예제] 에셋번들 패치

1. 서버로부터 에셋을 다운로드 하여 로컬에 저장

2. 로컬 에셋과 서버 에셋의 버전을 비교 해서 변화 했다면 다운받고 로컬 저장

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text;
using UnityEngine;
using UnityEngine.Networking;
using Newtonsoft.Json;
using System.Linq;
 
 
public class LoadFromFileExample : MonoBehaviour
{
    public class AssetbundleInfo {
        public string bundle { get; private set; }
        public Hash128 hash128 { get; private set; }
 
        public AssetbundleInfo(string bundle, Hash128 hash128) {
            this.bundle = bundle;
            this.hash128 = hash128;
        }
    }
    private string assetBundleBaseUrl = "ftp://121.161.123.7:2122/";
    private int version = 2;
    private List<AssetbundleInfo> oldAsset = new List<AssetbundleInfo>();
    private List<AssetbundleInfo> newAsset = new List<AssetbundleInfo>();
 
    public static void CleanAssetBundleCache()
    {
        Debug.Log(Caching.ClearCache() ? "Successfully removed Cache" : "Cache in use");
    }
 
    void Start() {
 
        //CleanAssetBundleCache(); return;
 
        //신규유저일경우 로드 후 로컬 저장 
        //StartCoroutine(this.SaveAndDownload(assetBundleBaseUrl + "StandaloneWindows", Application.persistentDataPath + "/AssetBundles/", "StandaloneWindows.unity3d"));
        //StartCoroutine(this.SaveAndDownload(assetBundleBaseUrl + "character", Application.persistentDataPath + "/AssetBundles/", "character.unity3d"));
        //StartCoroutine(this.SaveAndDownload(assetBundleBaseUrl + "hat", Application.persistentDataPath + "/AssetBundles/", "hat.unity3d"));
        //StartCoroutine(this.SaveAndDownload(assetBundleBaseUrl + "weapon", Application.persistentDataPath + "/AssetBundles/", "weapon.unity3d"));
 
 
 
        
        //로컬
        StartCoroutine(this.LoadFromLocal("StandaloneWindows.unity3d"));
 
        //서버 
        
        StartCoroutine(LoadFromCacheOrDownload(assetBundleBaseUrl + "StandaloneWindows", (manifest) => {
 
            int i = 0;
            foreach (var old in this.oldAsset) {
 
                //Debug.LogFormat("<color=red>{0}, {1}\t{2}, {3}</color>", old.bundle, old.hash128, this.newAsset[i].bundle, this.newAsset[i].hash128);
 
                if (old.hash128 != this.newAsset[i].hash128)
                {
                    Debug.LogFormat("<color=red>{0}, {1}</color>", this.newAsset[i].bundle, this.newAsset[i].hash128);
 
                    StartCoroutine(this.SaveAndDownload(assetBundleBaseUrl + this.newAsset[i].bundle, Application.persistentDataPath + "/AssetBundles/", this.newAsset[i].bundle + ".unity3d"));
 
                    StartCoroutine(this.SaveAndDownload(assetBundleBaseUrl + "StandaloneWindows", Application.persistentDataPath + "/AssetBundles/", "StandaloneWindows.unity3d"));
 
                }
 
                i++;
            }
        }));
        
        
 
 
    }
    
 
    IEnumerator LoadFromLocal(string assetName) {
        var path = Path.Combine(Application.persistentDataPath + "/AssetBundles/", assetName);
        Debug.Log(path);
 
        AssetBundleCreateRequest req = AssetBundle.LoadFromFileAsync(path);
        yield return req;
 
        var assetBundle = req.assetBundle;
 
        if (assetBundle == null)
        {
            Debug.Log("Failed to load AssetBundle!");
            yield break;
        }
 
        Debug.Log(assetBundle);
 
        AssetBundleManifest manifest = assetBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
 
        Debug.Log("manifest: " + manifest);
 
        foreach (var bundle in manifest.GetAllAssetBundles())
        {
            this.oldAsset.Add(new AssetbundleInfo(bundle, manifest.GetAssetBundleHash(bundle)));
 
            Debug.LogFormat("{0}, {1}", bundle, manifest.GetAssetBundleHash(bundle));
        }
 
        assetBundle.Unload(true);
        //var prefab = myLoadedAssetBundle.LoadAsset<GameObject>("ch_02_01");
        //Instantiate(prefab);
    }
 
    
 
    IEnumerator LoadAssetBundle(string uri, System.Action onComplete)
    {
        
        UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(uri, 0);
        //var request = UnityWebRequest.Get(uri);
        yield return request.SendWebRequest();
 
        //Debug.LogFormat("{0}, {1}", request.isHttpError, request.isNetworkError);
 
        AssetBundle assetBundle = DownloadHandlerAssetBundle.GetContent(request);
 
        Debug.Log(assetBundle);
 
        Debug.Log("assetBundle: " + assetBundle);
 
        AssetBundleManifest manifest = assetBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
 
 
        foreach (var bundle in manifest.GetAllAssetBundles())
        {
            Debug.LogFormat("{0}", manifest.GetAssetBundleHash(bundle));
 
            
            this.newAsset.Add(new AssetbundleInfo(bundle, manifest.GetAssetBundleHash(bundle)));
        }
 
 
 
        assetBundle.Unload(false);
 
        onComplete();
    }
 
    public IEnumerator LoadFromCacheOrDownload(string uri, System.Action<AssetBundleManifest> onComplete)
    {
        using (WWW www = WWW.LoadFromCacheOrDownload(uri, version))
        {
            yield return www;
 
            AssetBundle assetBundle = www.assetBundle;
 
            Debug.Log("assetBundle: " + assetBundle);
 
            AssetBundleManifest manifest = assetBundle.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
 
 
            Debug.Log("manifest: " + manifest);
 
            foreach (var bundle in manifest.GetAllAssetBundles()) {
                this.newAsset.Add(new AssetbundleInfo(bundle, manifest.GetAssetBundleHash(bundle)));
                Debug.Log(manifest.GetAssetBundleHash(bundle));
            }
            
 
            assetBundle.Unload(false);
 
            onComplete(manifest);
        }
    }
    IEnumerator SaveAndDownload(string url, string localPath, string fileName)
    {
        WWW www = new WWW(url);
 
        Debug.Log(url);
 
        yield return www;
 
        //yield return www;
        byte[] bytes = www.bytes;
 
        Debug.Log("<color=red>" + bytes.Length + "</color>");
 
        // Create the directory if it doesn't already exist
        if (!Directory.Exists(localPath))
        {
            Directory.CreateDirectory(localPath);
        }
 
        Debug.Log(localPath);
 
        File.WriteAllBytes(localPath + fileName, bytes);
    }
    
 
}