Try & Error

Unity 2021.3.47f1

----

Dynamic Font의 옵션에 Include Font Data가 체크 돼 있으면,  AssetBundle 빌드 시 Font도 번들에 포함 되는 것 같다.

[참조] https://codingstarter.tistory.com/37

AssetBundle 빌드는 스크립트로 하기 때문에 위 참조 링크의 내용대로

AssetBundle 빌드 전, IncludeFontData를 false로 하고,

AssetBundle 빌드 후, IncludeFontData를 true로 되돌리도록 처리했다.

기본적으로 Dynamic Font의 폴더를 지정은 해야되지만 폴더의 하위는 모두 훑어서 ttf파일은 모두 처리하도록 해뒀다.

        /// <summary>
        /// Dynamic Font Path
        /// 사용하는 Dynamic Font를 AssetBundle 빌드 할 때 포함 안되도록
        /// AssetBundle 빌드 시, false 했다가 되돌리기 위해 사용
        /// [주의] 실제 사용하는 다이나믹 폰트 Folder Path 체크 필요
        /// </summary>
        private static string m_strDynamicFontFolderPath = "Assets/Fonts/Dynamic";

        public static void ProcessIncludeFontData(string _strTargetDirectory, bool _bActive)
        {
            if (false == Directory.Exists(_strTargetDirectory))
                return;

            System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(_strTargetDirectory);
            foreach (System.IO.FileInfo fi in di.GetFiles())
            {

                if (fi.Extension.ToLower().CompareTo(".ttf") == 0)
                {
                    //string strFileNameOnly = fi.Name.Substring(0, fi.Name.Length - 4);
                    string strFullFilePath = fi.FullName.Replace("\\", "/");
                    Debug.LogWarningFormat("[strFullFilePath] {0}", strFullFilePath);

                    // 프로젝트 절대경로 제거하고 상대경로로 변경(Assets는 남기기)
                    string atrAssetPath = strFullFilePath.Replace(Application.dataPath, "Assets");
                    Debug.LogWarningFormat("[atrAssetPath] {0}", atrAssetPath);

                    TrueTypeFontImporter cImporter = AssetImporter.GetAtPath(atrAssetPath) as TrueTypeFontImporter;
                    if (null != cImporter)
                    {
                        cImporter.includeFontData = _bActive;
                        cImporter.SaveAndReimport();

                        Debug.LogWarningFormat("[atrAssetPath] {0} [cImporter.includeFontData] {1}", atrAssetPath, cImporter.includeFontData);
                    }
                }
            }

            foreach (System.IO.DirectoryInfo sdi in di.GetDirectories())
            {
                Debug.LogWarningFormat("[SubDirectory.FullName] {0}", sdi.FullName);
                ProcessIncludeFontData(sdi.FullName, _bActive);
            }
        }
        
        /// <summary>
        /// IncludeFontData 활성화
        /// </summary>
        public static void ActiveTrueTypeFont_IncludeFontData()
        {
            if (false == Directory.Exists(m_strDynamicFontFolderPath))
                return;

            ProcessIncludeFontData(m_strDynamicFontFolderPath, true);
        }

        /// <summary>
        /// IncludeFontData 비활성화
        /// </summary>
        public static void InActiveTrueTypeFont_IncludeFontData()
        {
            if (false == Directory.Exists(m_strDynamicFontFolderPath))
                return;

            ProcessIncludeFontData(m_strDynamicFontFolderPath, false);
        }

P.s. NGUI Font는 해당 옵션이 없어서 어떻게 처리해야될지 고민..

[링크] https://codingstarter.tistory.com/37

[수정] Unity 6000.2.9f1에서 Tilde(~)가 Android 빌드에서는 제외되지만, iOS 빌드에서는 제외되지 않는 버그를 확인해서 그냥 Import 되지 않는 다른곳(프로젝트 내 Assets 외부의 _Backup 폴더)으로 이동(Move) 시키도록 소스를 변경함.(2025-10-30)

----

[수정] Unity 6.2 에서 Dot(.)이 숨겨지긴 하지만 빌드에서 제외되지 않는 버그가 확인돼서 Dot(.)과 Tilde(~) 둘다 붙이도록 수정함(Tilde(~)는 빌드 제외 되는 것 확인함) [2025-08-28]

※ 아래 링크에서 설명을 보면 StreamingAssets 폴더 하위에서 dot(.) 정책이 변경 된 것 같다.

[Hidden assets] https://docs.unity3d.com/Manual/SpecialFolders.html

- Files and folders which start with ., except for those under StreamingAssets where this pattern is not ignored.

----

[수정] Rename 방식으로 변경 [2024-07-04]

----

[빌드 시, Builtin AssetBundles에서 해당 Platform 에셋번들만 빌드 되도록 하기 위한 PreProcessor 추가]

기본적으로 에셋번들은 플랫폼 별로 모두 가지고 있는데 해당 플랫폼에 맞는 에셋번들만 빌드 되도록 하기 위해서

빌드 전(Preprocessor) 해당 안되는 AssetBundle을 Hidden 폴더(예: .Android / .iOS)로 Rename 했다가, 빌드 후(Postprocessor) 되돌려 놓음.

빌드 전(Preprocessor) 해당 안되는 AssetBundle을 Hidden 폴더(예: .Android~ / .iOS~)로 Rename 했다가, 빌드 후(Postprocessor) 되돌려 놓음.

빌드 전(Preprocessor) 해당 안되는 AssetBundle을 _Backup 폴더로 Move 했다가, 빌드 후(Postprocessor) 되돌려 놓음.

using System;
using UnityEngine;
using UnityEditor;
using UnityEditor.Build;
using System.IO;
using System.Collections.Generic;
#if UNITY_2018_1_OR_NEWER
using UnityEditor.Build.Reporting;
#endif
using UnityEditor.Callbacks;

namespace blueasa
{
    /// <summary>
    /// 빌드 시, Built-in AssetBundle에서 해당 Platform AssetBundle만 빌드 되도록 하기 위한 Preprocessor
    /// 빌드 전(Preprocessor) 해당 안되는 AssetBundle을 Hidden 폴더(예: .Android~ / .iOS~)로 Rename 했다가, 빌드 후(Postprocessor) 되돌려 놓음
    /// [Hidden(./~) 참조] https://docs.unity3d.com/Manual/SpecialFolders.html
    /// [수정] Unity6 이상에서 dot(.)이 안먹혀서, tilde(~)도 함께 붙이도록 함(예: .Android~ / .iOS~)
    /// </summary>
#if UNITY_2018_1_OR_NEWER
    public class BuildPreprocessor_BuiltinResourceInStreamingAssets : IPreprocessBuildWithReport, IPostprocessBuildWithReport
#else
    public class BuildPreprocessor_BuiltinResourceInStreamingAssets : IPreprocessBuild, IPostprocessBuild
#endif
    {
        private static readonly string m_strDataPath = Application.dataPath;
        private static readonly string m_strStreamingAssetsPath = Application.streamingAssetsPath;

        private static readonly string m_strAssets = "Assets";
        private static readonly string m_strBackup = "_Backup";
        private static readonly string m_strStreamingAssets = "StreamingAssets";

        private static readonly string m_strRaw = "Raw";
        private static readonly string m_strDot_Raw_Tilde = ".Raw~";
        private static readonly string m_strAndroid = "Android";
        private static readonly string m_strDot_Android_Tilde = ".Android~";
        private static readonly string m_striOS = "iOS";
        private static readonly string m_strDot_iOS_Tilde = ".iOS~";
        private static readonly string m_strDotMeta = ".meta";
        private static readonly string m_strAssetBundles = "AssetBundles";

        private static readonly string m_strStreamingAssetsPath_Builtin_Raw = string.Format("{0}/{1}/{2}/", m_strAssets, m_strStreamingAssets, m_strRaw);
        private static readonly string m_strBackupPath_Builtin_Raw = string.Format("{0}/{1}/", m_strBackup, m_strRaw);
        private static readonly string m_strStreamingAssetsPath_Builtin_Android = string.Format("{0}/{1}/{2}/{3}/", m_strAssets, m_strStreamingAssets, m_strAssetBundles, m_strAndroid);
        private static readonly string m_strBackupPath_Builtin_Android = string.Format("{0}/{1}/", m_strBackup, m_strAndroid);
        private static readonly string m_strStreamingAssetsPath_Builtin_iOS = string.Format("{0}/{1}/{2}/{3}/", m_strAssets, m_strStreamingAssets, m_strAssetBundles, m_striOS);
        private static readonly string m_strBackupPath_Builtin_iOS = string.Format("{0}/{1}/", m_strBackup, m_striOS);

        /// 
        private static readonly string m_strStreamingAssetsPath_Builtin_Raw_FullPath = string.Format("{0}/{1}", m_strStreamingAssetsPath, m_strRaw);
        private static readonly string m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath = string.Format("{0}/{1}", m_strStreamingAssetsPath, m_strDot_Raw_Tilde);

        private static readonly string m_strAssetBundlesPath_Builtin_FullPath = string.Format("{0}/{1}", m_strStreamingAssetsPath, m_strAssetBundles);
        private static readonly string m_strAssetBundlesPath_Builtin_Android_FullPath = string.Format("{0}/{1}", m_strAssetBundlesPath_Builtin_FullPath, m_strAndroid);
        private static readonly string m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath = string.Format("{0}/{1}", m_strAssetBundlesPath_Builtin_FullPath, m_strDot_Android_Tilde);
        private static readonly string m_strAssetBundlesPath_Builtin_iOS_FullPath = string.Format("{0}/{1}", m_strAssetBundlesPath_Builtin_FullPath, m_striOS);
        private static readonly string m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath = string.Format("{0}/{1}", m_strAssetBundlesPath_Builtin_FullPath, m_strDot_iOS_Tilde);

        public int callbackOrder { get { return 0; } }

        private static void Refresh()
        {
            System.Threading.Thread.Sleep(100);
            AssetDatabase.Refresh();
            System.Threading.Thread.Sleep(100);
        }

#if UNITY_2018_1_OR_NEWER
        public void OnPreprocessBuild(BuildReport report)
#else
        public void OnPreprocessBuild(BuildTarget target, string path)
#endif
        {
            Debug.LogWarning($"[OnPreprocessBuild] {this}");

            // [빌드 전] 사용되지 않는 폴더 임시 제외
            Move_StreamingAssetsUnusedFolders();
            //Rename_StreamingAssetsUnusedFolders();

            // Start listening for errors when build starts
            Application.logMessageReceived += OnBuildError;
        }

        // CALLED DURING BUILD TO CHECK FOR ERRORS
        private void OnBuildError(string condition, string stacktrace, LogType type)
        {
            Debug.LogWarning($"[OnBuildError] {condition} {stacktrace} {type}");

            if (type == LogType.Error)
            {
                // FAILED TO BUILD, STOP LISTENING FOR ERRORS
                Application.logMessageReceived -= OnBuildError;

                // 빌드 에러 시에도 이동된 폴더 되돌리기
                Restore_StreamingAssetsUnusedFolders();
                //Restore_Rename_StreamingAssetsUnusedFolders();
            }
        }

#if UNITY_2018_1_OR_NEWER
        public void OnPostprocessBuild(BuildReport report)
#else
        public void OnPostprocessBuild(BuildTarget target, string path)
#endif
        {
            Debug.LogWarning($"[OnPostprocessBuild] {this}");

            // [빌드 후] 제외 됐던 다른 폴더 되돌리기
            Restore_StreamingAssetsUnusedFolders();
            //Restore_Rename_StreamingAssetsUnusedFolders();

            // IF BUILD FINISHED AND SUCCEEDED, STOP LOOKING FOR ERRORS
            Application.logMessageReceived -= OnBuildError;
        }

        //////////////////////////////////////////////////////////////////

        #region Move
        public static void Move_StreamingAssetsUnusedFolders()
        {
            Debug.LogWarning($"[Move_StreamingAssetsUnusedFolders]");
            // [빌드 전] 다른 플랫폼 AssetBundle 폴더 임시 제외

            switch (GuitarGirl.ClientSettings.ResourceLoadType)
            {
                case eResourceLoadType.Local_Resource:
                    {
                        // AssetBundles 폴더 모두 제거
                        Move_StreamingAssetsUnusedFolder_iOS();
                        Move_StreamingAssetsUnusedFolder_Android();
                    }
                    break;

                case eResourceLoadType.Local_AssetBundle:
                case eResourceLoadType.Server_AssetBundle:
                    {
                        // Raw / 해당 안되는 플랫폼 폴더 제거
                        Move_StreamingAssetsUnusedFolder_Raw();
#if UNITY_ANDROID
                        Move_StreamingAssetsUnusedFolder_iOS();
#elif UNITY_IOS
                        Move_StreamingAssetsUnusedFolder_Android();
#endif
                    }
                    break;
            }

            Refresh();
        }

        public static void Move_StreamingAssetsUnusedFolder_Raw()
        {
            // [Move]
            if (MoveFolder(m_strStreamingAssetsPath_Builtin_Raw, m_strBackupPath_Builtin_Raw))
            {
                // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
                if (true == File.Exists(m_strStreamingAssetsPath_Builtin_Raw_FullPath + m_strDotMeta))
                {
                    File.Delete(m_strStreamingAssetsPath_Builtin_Raw_FullPath + m_strDotMeta);
                }

                AssetDatabase.Refresh();
            }

            //if (true == Directory.Exists(m_strStreamingAssetsPath_Builtin_Raw_FullPath)
            //    && false == Directory.Exists(m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath))
            //{
            //    Debug.LogWarning("[OnPreprocessBuild] Move 'Raw' Folder to '.Raw'");
            //    Directory.Move(m_strStreamingAssetsPath_Builtin_Raw_FullPath, m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath);
            //    // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
            //    if (true == File.Exists(m_strStreamingAssetsPath_Builtin_Raw_FullPath + m_strDotMeta))
            //    {
            //        File.Delete(m_strStreamingAssetsPath_Builtin_Raw_FullPath + m_strDotMeta);
            //    }
            //}
        }

        public static void Move_StreamingAssetsUnusedFolder_iOS()
        {
            // [Move]
            if (MoveFolder(m_strStreamingAssetsPath_Builtin_iOS, m_strBackupPath_Builtin_iOS))
            {
                // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
                if (true == File.Exists(m_strAssetBundlesPath_Builtin_iOS_FullPath + m_strDotMeta))
                {
                    File.Delete(m_strAssetBundlesPath_Builtin_iOS_FullPath + m_strDotMeta);
                }

                AssetDatabase.Refresh();
            }

            //if (true == Directory.Exists(m_strAssetBundlesPath_Builtin_iOS_FullPath)
            //    && false == Directory.Exists(m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath))
            //{
            //    Debug.LogWarning("[OnPreprocessBuild] Move 'iOS' Folder to '.iOS~'");
            //    Directory.Move(m_strAssetBundlesPath_Builtin_iOS_FullPath, m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath);
            //    // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
            //    if (true == File.Exists(m_strAssetBundlesPath_Builtin_iOS_FullPath + m_strDotMeta))
            //    {
            //        File.Delete(m_strAssetBundlesPath_Builtin_iOS_FullPath + m_strDotMeta);
            //    }
            //}
        }

        public static void Move_StreamingAssetsUnusedFolder_Android()
        {
            // [Move]
            if (MoveFolder(m_strStreamingAssetsPath_Builtin_Android, m_strBackupPath_Builtin_Android))
            {
                // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
                if (true == File.Exists(m_strAssetBundlesPath_Builtin_Android_FullPath + m_strDotMeta))
                {
                    File.Delete(m_strAssetBundlesPath_Builtin_Android_FullPath + m_strDotMeta);
                }

                AssetDatabase.Refresh();
            }

            //if (true == Directory.Exists(m_strAssetBundlesPath_Builtin_Android_FullPath)
            //    && false == Directory.Exists(m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath))
            //{
            //    Debug.LogWarning("[OnPreprocessBuild] Move 'Android' Folder to '.Android~'");
            //    Directory.Move(m_strAssetBundlesPath_Builtin_Android_FullPath, m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath);
            //    // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
            //    if (true == File.Exists(m_strAssetBundlesPath_Builtin_Android_FullPath + m_strDotMeta))
            //    {
            //        File.Delete(m_strAssetBundlesPath_Builtin_Android_FullPath + m_strDotMeta);
            //    }
            //}
        }

        /// <summary>
        /// 숨겨진 폴더 되돌리기
        /// Move : 이동시켜 놨던게 있다면 다 되돌리기
        /// Rename : 옮겨진게(./~찍힌게) 있다면 다 되돌리기
        /// </summary>
        public static void Restore_StreamingAssetsUnusedFolders()
        {
            Debug.LogWarning($"[Restore_StreamingAssetsUnusedFolders]");

            // [Move] 이동 시켰던 폴더 되돌리기
            Restore_Move_StreamingAssetsUnusedFolders();

            // [Rename] 제외 됐던(./~) 폴더 되돌리기
            //Restore_Rename_StreamingAssetsUnusedFolders();
        }

        public static void Restore_Move_StreamingAssetsUnusedFolders()
        {
            // [Restore] 이동 시켰던 폴더 되돌리기

            bool bExcute = false;

            // [Move] Raw
            if (MoveFolder(m_strBackupPath_Builtin_Raw, m_strStreamingAssetsPath_Builtin_Raw))
            {
                bExcute = true;
            }

            // [Move] iOS
            if (MoveFolder(m_strBackupPath_Builtin_iOS, m_strStreamingAssetsPath_Builtin_iOS))
            {
                bExcute = true;
            }

            // [Move] Android
            if (MoveFolder(m_strBackupPath_Builtin_Android, m_strStreamingAssetsPath_Builtin_Android))
            {
                bExcute = true;
            }

            if (true == bExcute)
            {
                Refresh();
            }
        }

        private static bool MoveFolder(string _strPath_Src, string _strPath_Dest)
        {
            AssetDatabase.Refresh();
            bool isSuccess = false;
            if (System.IO.Directory.Exists(_strPath_Src))
            {

                System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(_strPath_Src);
                var files = di.GetFiles();

                if (files != null && files.Length > 0)
                {
                    if (System.IO.Directory.Exists(_strPath_Dest))
                    {
                        UnityEditor.FileUtil.DeleteFileOrDirectory(_strPath_Dest);
                    }
                    else
                    {
                        string[] arrKeys = _strPath_Dest.Split(new string[] { "/" }, System.StringSplitOptions.RemoveEmptyEntries);
                        string strPath = "";
                        for (int i = 0; i < arrKeys.Length - 1; i++)
                        {
                            strPath += arrKeys[i] + "/";
                            if (!System.IO.Directory.Exists(strPath))
                            {
                                Directory.CreateDirectory(strPath);
                            }
                        }

                    }
                    AssetDatabase.Refresh();
                    UnityEditor.FileUtil.MoveFileOrDirectory(_strPath_Src, _strPath_Dest);
                    //FileUtil.ReplaceDirectory(_sPath, _sNewPath);
                    isSuccess = true;
                }
                else
                {
                    Debug.LogWarning("Files Empty! Can't move files - " + _strPath_Src);
                }
            }
            else
            {
                Debug.LogWarning(_strPath_Src + " Not Exist");
            }

            return isSuccess;
        }

        #endregion

        //////////////////////////////////////////////////////////////////

        #region Rename

        public static void Rename_StreamingAssetsUnusedFolders()
        {
            Debug.LogWarning($"[Rename_StreamingAssetsUnusedFolders]");
            // [빌드 전] 다른 플랫폼 AssetBundle 폴더 임시 제외

            switch (GuitarGirl.ClientSettings.ResourceLoadType)
            {
                case eResourceLoadType.Local_Resource:
                    {
                        // AssetBundles 폴더 모두 제거
                        Rename_StreamingAssetsUnusedFolder_iOS();
                        Rename_StreamingAssetsUnusedFolder_Android();
                    }
                    break;

                case eResourceLoadType.Local_AssetBundle:
                case eResourceLoadType.Server_AssetBundle:
                    {
                        // Raw / 해당 안되는 플랫폼 폴더 제거
                        Rename_StreamingAssetsUnusedFolder_Raw();
#if UNITY_ANDROID
                        Rename_StreamingAssetsUnusedFolder_iOS();
#elif UNITY_IOS
                        Rename_StreamingAssetsUnusedFolder_Android();
#endif
                    }
                    break;
            }

            Refresh();
        }

        public static void Rename_StreamingAssetsUnusedFolder_Raw()
        {
            // [Rename]
            if (true == Directory.Exists(m_strStreamingAssetsPath_Builtin_Raw_FullPath)
                && false == Directory.Exists(m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath))
            {
                Debug.LogWarning("[OnPreprocessBuild] Rename 'Raw' Folder to '.Raw'");
                Directory.Move(m_strStreamingAssetsPath_Builtin_Raw_FullPath, m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath);
                // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
                if (true == File.Exists(m_strStreamingAssetsPath_Builtin_Raw_FullPath + m_strDotMeta))
                {
                    File.Delete(m_strStreamingAssetsPath_Builtin_Raw_FullPath + m_strDotMeta);
                }
            }
        }

        public static void Rename_StreamingAssetsUnusedFolder_iOS()
        {
            // [Rename]
            if (true == Directory.Exists(m_strAssetBundlesPath_Builtin_iOS_FullPath)
                && false == Directory.Exists(m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath))
            {
                Debug.LogWarning("[OnPreprocessBuild] Rename 'iOS' Folder to '.iOS~'");
                Directory.Move(m_strAssetBundlesPath_Builtin_iOS_FullPath, m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath);
                // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
                if (true == File.Exists(m_strAssetBundlesPath_Builtin_iOS_FullPath + m_strDotMeta))
                {
                    File.Delete(m_strAssetBundlesPath_Builtin_iOS_FullPath + m_strDotMeta);
                }
            }
        }

        public static void Rename_StreamingAssetsUnusedFolder_Android()
        {
            // [Rename]
            if (true == Directory.Exists(m_strAssetBundlesPath_Builtin_Android_FullPath)
                && false == Directory.Exists(m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath))
            {
                Debug.LogWarning("[OnPreprocessBuild] Rename 'Android' Folder to '.Android~'");
                Directory.Move(m_strAssetBundlesPath_Builtin_Android_FullPath, m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath);
                // 빈(Empty) 폴더 생성을 방지하기 위해서 폴더의 meta 파일도 함께 삭제
                if (true == File.Exists(m_strAssetBundlesPath_Builtin_Android_FullPath + m_strDotMeta))
                {
                    File.Delete(m_strAssetBundlesPath_Builtin_Android_FullPath + m_strDotMeta);
                }
            }
        }

        /// <summary>
        /// 숨겨진 폴더 되돌리기
        /// (옮겨진게(.찍힌게) 있다면 다 되돌리기)
        /// </summary>
        public static void Restore_Rename_StreamingAssetsUnusedFolders()
        {
            Debug.LogWarning($"[Restore_Rename_StreamingAssetsUnusedFolders]");

            // [Restore] 제외 됐던(.) 폴더 되돌리기

            bool bExcute = false;

            // [Rename] Raw
            if (true == Directory.Exists(m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath)
                && false == Directory.Exists(m_strStreamingAssetsPath_Builtin_Raw_FullPath))
            {
                Debug.LogWarning("[OnPostprocessBuild] Rename '.Raw~' Folder to 'Raw'");
                Directory.Move(m_strStreamingAssetsPath_Builtin_Dot_Raw_Tilde_FullPath, m_strStreamingAssetsPath_Builtin_Raw_FullPath);
                bExcute = true;
            }

            // [Rename] iOS
            if (true == Directory.Exists(m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath)
                && false == Directory.Exists(m_strAssetBundlesPath_Builtin_iOS_FullPath))
            {
                Debug.LogWarning("[OnPostprocessBuild] Rename '.iOS~' Folder to 'iOS'");
                Directory.Move(m_strAssetBundlesPath_Builtin_Dot_iOS_Tilde_FullPath, m_strAssetBundlesPath_Builtin_iOS_FullPath);
                bExcute = true;
            }

            // [Rename] Android
            if (true == Directory.Exists(m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath)
                && false == Directory.Exists(m_strAssetBundlesPath_Builtin_Android_FullPath))
            {
                Debug.LogWarning("[OnPostprocessBuild] Rename '.Android~' Folder to 'Android'");
                Directory.Move(m_strAssetBundlesPath_Builtin_Dot_Android_Tilde_FullPath, m_strAssetBundlesPath_Builtin_Android_FullPath);
                bExcute = true;
            }

            if (true == bExcute)
            {
                Refresh();
            }
        }

        #endregion

    }
}

[TroubleShooting]

[에러메시지]

NotSupportedException: .... System.Net.WebRequest.GetCreator (System.String prefix) System.Net.WebRequest.Create (System.Uri requestUri)

PC/iOS에서는 잘 되는데 Android에서 위와 같은 NotSupportedException이 난다.(현재 Unity v5.6.5f1)

검색해보니 게임코디에 아래와 같은 답변을 해주신 분이 있다.

비회원:  kimsama

NotSupportedException: .... System.Net.WebRequest.GetCreator (System.String prefix) System.Net.WebRequest.Create (System.Uri requestUri) 모바일에서 위의 에러로 인해 HttpWebReaquest 를 사용하지 못하는 경우라면 여기 링크의 내용 참고하시기 바랍니다. http://www.vovchik.org/blog/13001 간단하게 우회하는 방법이 나와 있습니다.

[출처] http://lab.gamecodi.com/board/zboard.php?id=GAMECODILAB_QnA_etc&page=2&sn1=&divpage=1&sn=off&ss=on&sc=on&select_arrange=headnum&desc=asc&no=2617

그래서 링크(http://www.vovchik.org/blog/13001)에서 말해준 대로 Wrapping을 해서 Android에서 돌려보니 잘된다!!

(kimsama님 감사합니다!)

내가 추가 및 수정한 소스는 아래와 같다.

// Wrapper Class
using System;
using System.Net;

public class HttpRequestCreator : IWebRequestCreate 
{
	public WebRequest Create(Uri uri)
	{
		return new HttpWebRequest(uri);	
	}
}

    //Get size of the asset
    HttpRequestCreator cHttpRequestCreator = new HttpRequestCreator();            // modify
    System.Net.WebRequest req = cHttpRequestCreator.Create(new Uri(assetURL));    // modify
    req.Method = "HEAD";

    float ContentLength;
    using (System.Net.WebResponse resp = req.GetResponse())
    {
        float.TryParse(resp.ContentLength.ToString(), out ContentLength);
    }

    while (!download.isDone)
    {
        if (progressBar != null)
	    {
            progressBar.LabelInformations = "Downloading Assets";
            progressBar.Progress = download.progress;
            progressBar.AssetSize = ContentLength / 1000000; //(Mb)
	    }
	    yield return null;
    }

- CDN에 있는 파일 사이즈를 어떻게 알 수 없나 하고 찾다가 테스트 해보고 잘 되길래 올려 놓음.

  (PC/iOS는 잘되는데 Android가 에러나서 위와 같이 고침)

1.                      //Get size of the asset
                        System.Net.WebRequest req = System.Net.HttpWebRequest.Create(assetURL);
                        req.Method = "HEAD";
                        float ContentLength;
                        using (System.Net.WebResponse resp = req.GetResponse())
                        {
                            float.TryParse(resp.ContentLength.ToString(), out ContentLength);
                        }
    
                        while (!download.isDone)
                        {
                            if (progressBar != null)
                            {
                                progressBar.LabelInformations = "Downloading Assets";
                                progressBar.Progress = download.progress;
                                progressBar.AssetSize = ContentLength / 1000000; //(Mb)
                            }
                            yield return null;
                        }
   

[출처] https://answers.unity.com/questions/1035361/get-size-of-an-online-assetbundle-and-progress-in.html

[링크] https://bitbucket.org/Unity-Technologies/assetbundledemo

[링크] https://assetstore.unity.com/packages/tools/utilities/assetbundle-manager-example-scenes-45836

5.2 이후 바뀐 에셋번들을 처음 접해봤는데 이전보다는 심플해져서 사용하긴 쉬운 것 같다.

근데 서버에서 외부(앱 내 저장 가능한 공간 : Application.persistentDataPath 사용)에 다운로드를 받고 로드 할 때 삽질한 내용을 간단하게 올려 놓는다.

지금은 바빠서..

간단하게 올리고 나중에 퇴고를 해야겠다..

[삽질_1]

- PC에서는 잘되는데 Android에서 Application.persistentDataPath로만 접근 하는데,

  Write 할 때 Path가 mnt로 시작하는 외부 저장소 Path로 저장 됨.

  AssetBundle을 로드 하기 위해 Read 하려고 접근하니 Stroage로 시작하는 내부 저장소 Path를 줌.

[처리_1]

- 우선 강제로 내부 저장소만 사용하도록 프로젝트 셋팅에서 변경

   (Project Settings-Android-Configuration-Write Permission 을 Internal로 변경)

[삽질_2]

- 빈번하게 에셋번들 로컬 로드 시, 무한루프에 빠짐

[처리_2]

- 처리하기 편하려고 BundleName과 AssetName을 같게 했는데 유니티가 헷갈려하면서 뭔가 문제가 생기는 것 같아서

  BundleName 셋팅에 확장자를 추가(인스펙터에서 셋팅)하니 잘 됨.

[삽질_3]

- 제대로 다하고 올린 것 같은데 이전에 잘 로드 되던 파일이 에러가 나서 당황함.

[처리_3]

- 파일질라로 에셋번들 파일을 업로드 할 때 Binary로 올리지 않으면 문제가 생긴다고 함.

  파일질라 셋팅을 수정하고 다시 업로드 해서 해결

  (전송-전송 유형-바이너리 로 변경)

- [참조] http://blueasa.tistory.com/2110

[링크] http://unitylist.com/r/6js/unity-5-assert-bundle

[링크] https://github.com/kimsama/Unity5-AssetBundleSetting