com.amanotes.gdk 0.2.49 → 0.2.50

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.2.50 - 2024-02-20]
+- New feature: Modify Android post processor
+- [Fix] remove installer should be skipped in DEV mode
+- New feature: Check Disk Space
+- Update version tracking: Add SkAdnetwork count
+- Add check internet option for Ad module
+
 ## [0.2.49 - 2024-01-29]
 - New feature: SDK version tracking
 - New feature: Google Consent Management (CMP)

package/Editor/AmaGDKEditor.cs

@@ -31,11 +31,14 @@ namespace Amanotes.Editor
         private static bool showConfigDetail;
         private static bool showAdapterInstaller;
         private static bool showExampleDetail;
-        private static bool showVersionTracking;
+        private static bool showExtra;
 
         // DO NOT PUT [NonSerialized]
         private static bool adapterScanned = false;
         private static bool searchedForConfig = false;
+        
+        private static bool extraScanned = false;
+        private static readonly List<string> extraPackages = new List<string>();
 
         private static readonly List<string> adapterPackages = new List<string>();
 
@@ -145,17 +148,18 @@ namespace Amanotes.Editor
                 adapterPackages.Add(Path.GetFileName(adapterPath[i]));
             }
         }
-
-        private void DrawGUI_VersionTracking()
+        
+        private void ScanForExtraPackages()
         {
-            if (GUILayout.Button("SDK Version Tracking"))
+            extraScanned = true;
+            extraPackages.Clear();
+            string[] extraPath = Directory.GetFiles(Res.EXTRA_PATH, "*.unitypackage", SearchOption.AllDirectories);
+            for (var i = 0; i < extraPath.Length; i++)
             {
-                var package = $"{Res.PACKAGE_PATH}SDKVersionTracking.unitypackage";
-                AssetDatabase.ImportPackage(package, true);
+                extraPackages.Add(Path.GetFileName(extraPath[i]));
             }
         }
 
-
         private void DrawGUI_AdapterList()
         {
             if (!adapterScanned) ScanForAdapterPackages();
@@ -168,6 +172,19 @@ namespace Amanotes.Editor
                 }
             }
         }
+        
+        private void DrawGUI_ExtraList()
+        {
+            if (!extraScanned) ScanForExtraPackages();
+            foreach (string extra in extraPackages)
+            {
+                if (GUILayout.Button(ObjectNames.NicifyVariableName(extra)))
+                {
+                    var package = $"{Res.PACKAGE_PATH}{extra}";
+                    AssetDatabase.ImportPackage(package, false);
+                }
+            }
+        }
 
         private void DrawGUI_ExampleScene()
         {
@@ -272,6 +289,7 @@ namespace Amanotes.Editor
 
             if (!searchedForConfig) TryLoadConfigAsset();
             if (!adapterScanned) ScanForAdapterPackages();
+            if (!extraScanned) ScanForAdapterPackages();
 
             if (configAsset == null)
             {
@@ -295,7 +313,7 @@ namespace Amanotes.Editor
             EditorGUILayout.Space();
             AmaGUI.Foldout("Config", ref showConfigDetail, DrawGUI_ConfigDetail, DrawGUI_ConfigAsset);
             AmaGUI.Foldout("Adapters", ref showAdapterInstaller, DrawGUI_AdapterList);
-            AmaGUI.Foldout("SDK Version Tracking", ref showVersionTracking, DrawGUI_VersionTracking);
+            AmaGUI.Foldout("Extras", ref showExtra, DrawGUI_ExtraList);
             Profiler.EndSample();
         }
 

package/Editor/Extra/GDKAutoBuild.cs

@@ -0,0 +1,891 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Events;
+using Debug = UnityEngine.Debug;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Editor
+{
+    [CreateAssetMenu(menuName = "AmaGDK/Build Config")]
+    public class GDKAutoBuild : ScriptableObject
+    {
+        private const string DEFAULT_BUILD_FOLDER = "../../_Build";
+
+        public KeystoreInfo keystore;
+        public string buildFolder = DEFAULT_BUILD_FOLDER;
+        public Texture2D icon;
+
+        public List<BuildInfo> listBuild = new List<BuildInfo>();
+
+        public List<UnityObject> listUnused;
+        public BuildRequestTS buildRQ;
+        public UnityEvent beforeBuild;
+        public TextAsset shTemplate;
+        
+        [NonSerialized] private BuildInfo _buildInfo;
+        [NonSerialized] private int _lockCount;
+
+        public int nBuildPending
+        {
+            get
+            {
+                if ((buildRQ != null) && !buildRQ.isDifferentSession) return listBuild.Count(t => t.enable);
+
+                StopBuild();
+                return 0;
+            }
+        }
+
+        internal static int SecondsTS => (int)(DateTime.Now - new DateTime(2010, 1, 1)).TotalSeconds;
+        public void Lock()
+        {
+            _lockCount++;
+        }
+        public void Unlock()
+        {
+            _lockCount--;
+            if ((_lockCount == 0) && (_buildInfo != null)) ExportBuild(_buildInfo);
+        }
+
+        public void StopBuild()
+        {
+            for (var i = 0; i < listBuild.Count; i++)
+            {
+                listBuild[i].enable = false;
+            }
+        }
+
+        public void ProcessBuild()
+        {
+            BuildTarget cTarget = EditorUserBuildSettings.activeBuildTarget;
+
+            for (var i = 0; i < listBuild.Count; i++)
+            {
+                BuildInfo item = listBuild[i];
+                if (!item.enable) continue;
+
+                if (item.target != cTarget) continue;
+
+                item.enable = false; // already build
+                Build(item);
+                return; // only do one build at a time
+            }
+
+            for (var i = 0; i < listBuild.Count; i++)
+            {
+                BuildInfo item = listBuild[i];
+                if (!item.enable) continue;
+
+                switch (item.target)
+                {
+                case BuildTarget.Android:
+                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.Android, BuildTarget.Android);
+                    return; // only do one build at a time
+
+                case BuildTarget.iOS:
+                    EditorUserBuildSettings.SwitchActiveBuildTarget(BuildTargetGroup.iOS, BuildTarget.iOS);
+                    return; // only do one build at a time
+                }
+
+            }
+        }
+
+        private void RemoveUnusedAssets()
+        {
+            AssetDatabase.StartAssetEditing();
+            for (var i = 0; i < listUnused.Count; i++)
+            {
+                if (listUnused[i] == null) continue;
+                string path = AssetDatabase.GetAssetPath(listUnused[i]);
+                AssetDatabase.DeleteAsset(path);
+            }
+            AssetDatabase.StopAssetEditing();
+        }
+
+        public void Build(BuildInfo info)
+        {
+            DryRun(info);
+
+            if (_lockCount == 0)
+            {
+                ExportBuild(info);
+                return;
+            }
+
+            _buildInfo = info;
+        }
+
+        public void EnableBuildForTarget(BuildTarget target, bool updateBuildNumber = true)
+        {
+            for (var i = 0; i < listBuild.Count; i++)
+            {
+                BuildInfo b = listBuild[i];
+                b.enable = b.target == target;
+
+                if (updateBuildNumber && (b.target == target)) b.buildNumber++;
+            }
+
+            EditorUtility.SetDirty(this);
+        }
+
+        public void DryRun(BuildInfo info)
+        {
+            if (string.IsNullOrEmpty(buildFolder)) buildFolder = DEFAULT_BUILD_FOLDER;
+
+            var buildDir = new DirectoryInfo(buildFolder);
+            if (!buildDir.Exists) Directory.CreateDirectory(buildDir.FullName);
+
+            // Check for existed build with the same name
+            if (info.overwrite == false)
+            {
+                if (info.target == BuildTarget.Android)
+                {
+                    string[] apkNames = info.GetAPKNames(buildFolder);
+                    for (var i = 0; i < apkNames.Length; i++)
+                    {
+                        string item = apkNames[i];
+                        if (!File.Exists(item)) continue;
+                        Debug.LogWarning("Exporting file existed! " + item);
+
+                        // return;
+                    }
+                } else
+                {
+                    string fullBuildPath = info.fullBuildPath(buildFolder);
+                    if (Directory.Exists(fullBuildPath))
+                    {
+                        Debug.LogWarning("Exporting target existed! " + fullBuildPath);
+                        EditorUtility.RevealInFinder(fullBuildPath);
+
+                        // return;
+                    }
+                }
+            }
+
+            RemoveUnusedAssets();
+            if (info.target == BuildTarget.Android) keystore.Write();
+
+            info.Write();
+            info.PreprocessBuild(buildFolder);
+
+            // write customized icon, if any
+            if ((icon != null) && (info.buildIcon != null) && (info.buildIcon != icon))
+            {
+                string p1 = AssetDatabase.GetAssetPath(info.buildIcon);
+                string p2 = AssetDatabase.GetAssetPath(icon);
+                byte[] bytes = File.ReadAllBytes(p1);
+                File.WriteAllBytes(p2, bytes);
+
+                // force refresh
+                AssetDatabase.ImportAsset(p2, ImportAssetOptions.ForceSynchronousImport);
+                RepaintAll();
+            }
+
+            _lockCount = 0;
+            if (beforeBuild != null) beforeBuild.Invoke();
+        }
+
+        private static void RepaintAll()
+        {
+            UnityObject[] windows = Resources.FindObjectsOfTypeAll(typeof(EditorWindow));
+            if (windows == null || windows.Length <= 0) return;
+
+            for (var i = 0; i < windows.Length; i++)
+            {
+                var w = windows[i] as EditorWindow;
+                if (w != null) w.Repaint();
+            }
+        }
+
+        private void RunPostBuild()
+        {
+            listBuild[0].buildNumber++;
+            EditorUtility.SetDirty(this);
+            AssetDatabase.SaveAssets();
+            // RunPostBuildSH(listBuild[0]);
+        }
+
+        // private void RunPostBuildSH(BuildInfo info)
+        // {
+        //     if (shTemplate == null) return;
+        //
+        //     string shPath = ExternalProcessUtils.FileFromTemplate(
+        //         "git-post-build.sh", shTemplate.text,
+        //         "{{TEMPLATE_PROJECT_PATH}}", Application.dataPath.Replace("/Assets", string.Empty),
+        //         "{{TEMPLATE_TAG}}", $"{info.projectId}/v{info.buildVersion}_b{info.buildNumber}",
+        //         "{{TEMPLATE_BRANCH}}", $"build/v{info.buildVersion}_b{info.buildNumber}",
+        //         "{{TEMPLATE_BUILD_ASSET}}", $"{AssetDatabase.GetAssetPath(this)}"
+        //     );
+        //
+        //     // Run & Lock Unity until git finish
+        //     ExternalProcessUtils.Run(shPath, true);
+        // }
+
+        private void ExportBuild(BuildInfo info)
+        {
+            string fullBuildPath = info.fullBuildPath(buildFolder);
+            BuildPipeline.BuildPlayer(GetScenes(), fullBuildPath, info.target, BuildOptions.None);
+            info.PostProcessBuild(buildFolder);
+
+            // if (buildRQ.willRunSHPostBuild)
+            // {
+            //     // Run once per build request
+            //     buildRQ.willRunSHPostBuild = false;
+            //     RunPostBuildSH(info);
+            // }
+
+            if (nBuildPending > 0)
+            {
+                ProcessBuild();
+                return;
+            }
+
+            EditorUtility.RevealInFinder(fullBuildPath);
+        }
+
+        internal static string[] GetScenes()
+        {
+            return EditorBuildSettings.scenes.Where(s => s.enabled).Select(s => s.path).ToArray();
+        }
+
+        internal static void DrawRect(Rect rect, Color c)
+        {
+            Color bgColor = GUI.color;
+            GUI.color = c;
+            GUI.DrawTexture(rect, Texture2D.whiteTexture, ScaleMode.StretchToFill, false);
+            GUI.color = bgColor;
+        }
+        [Serializable] public class BuildRequestTS
+        {
+            public int processId;
+            public string machineId;
+            public string projectPath;
+            public bool willRunSHPostBuild = true;
+
+            public bool isDifferentSession
+            {
+                get
+                {
+                    if (machineId != SystemInfo.deviceUniqueIdentifier)
+
+                        //Debug.LogWarning("Different device");
+                        return true;
+
+                    var currentProcess = Process.GetCurrentProcess();
+                    if (processId != currentProcess.Id)
+
+                        //Debug.LogWarning("Different process ID");
+                        return true; // Changed process id
+
+                    if (projectPath != Application.dataPath)
+
+                        //Debug.LogWarning("Different project path");
+                        return true; // Changed project
+
+                    return false;
+                }
+            }
+
+            public static BuildRequestTS Generate() //bool runGit
+            {
+                var currentProcess = Process.GetCurrentProcess();
+
+                return new BuildRequestTS
+                {
+                    machineId = SystemInfo.deviceUniqueIdentifier,
+                    processId = currentProcess.Id,
+                    projectPath = Application.dataPath,
+                    // willRunSHPostBuild = runGit
+                };
+            }
+        }
+        [Serializable] public class BuildInfo
+        {
+            public string projectId;
+            public string productName;
+            public string packageName;
+
+            public Texture2D buildIcon;
+            public BuildTarget target;
+
+            public bool isAAB;
+            public bool splitAPK = true;
+            public bool overwrite = true;
+            public string buildVersion;
+            public int buildNumber;
+
+            // Android options
+            public bool enable;
+
+            public bool isAndroid => target == BuildTarget.Android;
+            public bool isIOS => target == BuildTarget.iOS;
+
+            public string buildName => $"{projectId}_v{buildVersion}_b{buildNumber}";
+
+            public void PreprocessBuild(string buildFolder)
+            {
+                AssetDatabase.SaveAssets();
+                GC.Collect();
+                Resources.UnloadUnusedAssets();
+                EditorUtility.UnloadUnusedAssetsImmediate();
+
+                PlayerSettings.bundleVersion = buildVersion;
+
+                if (isAndroid)
+                {
+                    PlayerSettings.Android.bundleVersionCode = buildNumber;
+                    PlayerSettings.Android.buildApkPerCpuArchitecture = splitAPK;
+                    PlayerSettings.Android.targetArchitectures = AndroidArchitecture.All;
+
+                    EditorUserBuildSettings.buildAppBundle = isAAB;
+                    EditorUserBuildSettings.exportAsGoogleAndroidProject = false;
+                    EditorUserBuildSettings.androidCreateSymbols = AndroidCreateSymbols.Disabled;
+
+                    string[] listAPKNames = GetAPKNames(buildFolder);
+
+                    for (var i = 0; i < listAPKNames.Length; i++)
+                    {
+                        string apkName = listAPKNames[i];
+                        string tempName = apkName.Replace(buildName, Application.productName);
+
+                        if (File.Exists(tempName)) File.Delete(tempName); // always delete temp file no matter what
+                        if (overwrite && File.Exists(apkName)) File.Delete(apkName);
+                    }
+
+                    return;
+                }
+
+                if (isIOS)
+                {
+                    PlayerSettings.iOS.buildNumber = buildNumber.ToString();
+                    if (!overwrite) return;
+
+                    string path = fullBuildPath(buildFolder);
+                    if (Directory.Exists(path)) Directory.Delete(path, true);
+                    return;
+                }
+
+                Debug.LogWarning("Unsupported platform: " + target);
+            }
+
+            public string[] GetAPKNames(string buildFolder)
+            {
+                var buildDir = new DirectoryInfo(buildFolder);
+                string fullName = buildDir.FullName;
+
+                if (isAAB)
+                    return new[]
+                    {
+                        Path.Combine(fullName, buildName + ".aab")
+                    };
+
+                if (splitAPK)
+                    return new[]
+                    {
+                        Path.Combine(fullName, buildName + ".arm64-v8a.apk"), Path.Combine(fullName, buildName + ".armeabi-v7a.apk")
+                    };
+
+                return new[]
+                {
+                    Path.Combine(fullName, buildName + ".apk")
+                };
+            }
+
+            public void PostProcessBuild(string buildFolder)
+            {
+                if (target != BuildTarget.Android) return;
+                if (isAAB) return;
+
+                // var productName = Application.productName;
+                string[] listAPKNames = GetAPKNames(buildFolder);
+
+                for (var i = 0; i < listAPKNames.Length; i++)
+                {
+                    string apkName = listAPKNames[i];
+                    string tempName = apkName.Replace(buildName, productName);
+
+                    if (!File.Exists(tempName)) continue;
+                    File.Move(tempName, apkName);
+                }
+            }
+
+            public string fullBuildPath(string buildFolder)
+            {
+                if (buildFolder.EndsWith("/"))
+
+                    // remove last slash
+                    buildFolder = buildFolder.Substring(0, buildFolder.Length - 1);
+
+                var buildDir = new DirectoryInfo(buildFolder);
+
+                if (isAndroid)
+                {
+                    if (isAAB) return Path.Combine(buildDir.FullName, buildName + ".aab");
+                    if (splitAPK) return buildDir.FullName;
+                    return Path.Combine(buildDir.FullName, buildName + ".apk");
+                }
+
+                return Path.Combine(buildDir.FullName, "XCode_" + buildName);
+            }
+
+            public BuildInfo Read()
+            {
+                buildVersion = PlayerSettings.bundleVersion;
+                productName = PlayerSettings.productName;
+
+                if (isAndroid)
+                {
+                    buildNumber = PlayerSettings.Android.bundleVersionCode;
+                    packageName = PlayerSettings.GetApplicationIdentifier(BuildTargetGroup.Android);
+                }
+
+                if (isIOS)
+                {
+                    int.TryParse(PlayerSettings.iOS.buildNumber, out buildNumber);
+                    packageName = PlayerSettings.GetApplicationIdentifier(BuildTargetGroup.iOS);
+                }
+
+                return this;
+            }
+
+            public void Write()
+            {
+                PlayerSettings.bundleVersion = buildVersion;
+                PlayerSettings.productName = productName;
+
+                if (isAndroid)
+                {
+                    PlayerSettings.Android.bundleVersionCode = buildNumber;
+                    PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.Android, packageName);
+                }
+
+                if (isIOS)
+                {
+                    PlayerSettings.iOS.buildNumber = buildNumber.ToString();
+                    PlayerSettings.SetApplicationIdentifier(BuildTargetGroup.iOS, packageName);
+                }
+
+                EditorApplication.RepaintProjectWindow();
+            }
+
+            public void IncreaseVersion()
+            {
+                buildNumber++;
+                if (string.IsNullOrEmpty(buildVersion)) buildVersion = "1.0.0";
+
+                string[] arr = buildVersion.Split('.');
+                int last = int.Parse(arr[2]);
+                last++;
+
+                arr[2] = last.ToString();
+                buildVersion = string.Join(".", arr);
+            }
+        }
+
+        [Serializable] public class KeystoreInfo
+        {
+            public string path = "AmaGDK/Store/project.keystore";
+            public string alias = "alias";
+            public string keystorePassword = "123456789";
+            public string aliasPassword = "123456789";
+
+            public void Write()
+            {
+                // Must use absolute path or else gradle build fail
+                var keystoreFI = new FileInfo(path);
+                PlayerSettings.Android.keystoreName = keystoreFI.FullName;
+                PlayerSettings.keystorePass = keystorePassword;
+                PlayerSettings.Android.keyaliasPass = aliasPassword;
+                PlayerSettings.Android.keyaliasName = alias;
+            }
+        }
+    }
+
+
+    [InitializeOnLoad]
+    internal class GDKAutoBuildHelper
+    {
+        private static GDKAutoBuild build;
+        static GDKAutoBuildHelper()
+        {
+            EditorApplication.update -= Update;
+            EditorApplication.update += Update;
+        }
+
+        private static void Update()
+        {
+            if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
+
+            if (EditorApplication.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                if (build != null) build.StopBuild();
+                EditorApplication.update -= Update;
+                return;
+            }
+
+            if (build == null)
+            {
+                string[] guids = AssetDatabase.FindAssets("t:" + nameof(GDKAutoBuild)); //FindAssets uses tags check documentation for more info
+                if (guids.Length == 0)
+                {
+                    EditorApplication.update -= Update;
+                    return;
+                }
+
+                string path = AssetDatabase.GUIDToAssetPath(guids[0]);
+                build = AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path);
+                if (build == null)
+                {
+                    EditorApplication.update -= Update;
+                    return;
+                }
+            }
+
+            EditorApplication.update -= Update;
+
+            //check if timeStamp is valid
+            if (build.nBuildPending == 0) return;
+
+            build.ProcessBuild();
+        }
+
+
+        // [MenuItem("Window/AmaGDK/Build/Select Build Asset &#b", false, 10)]
+        public static void SelectBuild()
+        {
+            string[] arr = AssetDatabase.FindAssets("t:" + nameof(GDKAutoBuild));
+
+            if (arr.Length == 0)
+            {
+                Debug.LogWarning("There are no Build asset in the project!");
+                return;
+            }
+
+            // if (arr.Length > 1)
+            // {
+            //     Debug.LogWarning("There are [" + arr.Length + "] Build assets in the project!");
+            // }
+
+            string path = AssetDatabase.GUIDToAssetPath(arr[0]);
+            var obj = AssetDatabase.LoadAssetAtPath<UnityObject>(path);
+            Selection.activeObject = obj;
+            EditorGUIUtility.PingObject(obj);
+        }
+
+        private static GDKAutoBuild FindAutoBuildAssets(string name = null, bool allowFallback = false)
+        {
+            string[] arr = AssetDatabase.FindAssets("t:" + nameof(GDKAutoBuild));
+            if (arr.Length == 0)
+            {
+                Debug.LogWarning("There are no Build asset in the project!");
+                return null;
+            }
+
+            for (var i = 0; i < arr.Length; i++)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(arr[i]).Replace("\\", "/");
+                if (string.IsNullOrEmpty(name)) return AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path);
+
+                string fileName = Path.GetFileName(path);
+                if (fileName.ToLower().Contains(name.ToLower())) return AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path);
+            }
+
+            if (!allowFallback) return null;
+
+            // Fall back to the first one
+            string path0 = AssetDatabase.GUIDToAssetPath(arr[0]).Replace("\\", "/");
+            return AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path0);
+        }
+
+        // [MenuItem("Window/AmaGDK/Build/Android", false, 50)] public static void BuildAndroid() { BuildAndroid(false); }
+        // [MenuItem("Window/AmaGDK/Build/iOS", false, 51)] public static void BuildIOS() { BuildIOS(false); }
+        // [MenuItem("Window/AmaGDK/Build/Android - Release", false, 90)] public static void BuildAndroidRelease() { BuildAndroid(true); }
+        // [MenuItem("Window/AmaGDK/Build/iOS - Release", false, 91)] public static void BuildIOSRelease() { BuildIOS(true); }
+
+
+        private static void BuildAndroid(bool isRelease)
+        {
+            GDKAutoBuild buildAsset = FindAutoBuildAssets("android");
+            if (buildAsset == null)
+            {
+                Debug.LogWarning("Build Asset for Android not found!");
+                return;
+            }
+
+            buildAsset.EnableBuildForTarget(BuildTarget.Android);
+            buildAsset.buildRQ = GDKAutoBuild.BuildRequestTS.Generate();// isRelease
+            buildAsset.ProcessBuild();
+        }
+
+        private static void BuildIOS(bool isRelease)
+        {
+            GDKAutoBuild buildAsset = FindAutoBuildAssets("ios");
+            if (buildAsset == null)
+            {
+                Debug.LogWarning("Build Asset for iOS not found!");
+                return;
+            }
+            buildAsset.EnableBuildForTarget(BuildTarget.iOS);
+            buildAsset.buildRQ = GDKAutoBuild.BuildRequestTS.Generate(); //isRelease
+            buildAsset.ProcessBuild();
+        }
+    }
+
+    [CustomEditor(typeof(GDKAutoBuild))]
+    public class GDKAutoBuildEditor : UnityEditor.Editor
+    {
+        public int bIndex;
+        public string path;
+        public bool drawDefault;
+
+        public GUIStyle productNameStyle;
+        public GUIStyle projectStyle;
+
+        private string helpInfo;
+
+        private void Init()
+        {
+            productNameStyle = new GUIStyle(EditorStyles.largeLabel)
+            {
+                alignment = TextAnchor.MiddleCenter,
+                fontSize = 32
+            };
+
+            projectStyle = new GUIStyle(EditorStyles.miniLabel)
+            {
+                alignment = TextAnchor.MiddleCenter
+            };
+
+            path = Application.dataPath;
+            List<string> arr = path.Split('/').ToList();
+            arr.RemoveAt(arr.Count - 1);
+
+            if (arr.Count > 3) arr.RemoveRange(0, arr.Count - 3);
+
+            path = string.Join("/", arr);
+        }
+        public override void OnInspectorGUI()
+        {
+            var ab = (GDKAutoBuild)target;
+            if (ab == null) return;
+
+            if (productNameStyle == null) Init();
+
+            GUILayout.Label(PlayerSettings.productName, productNameStyle);
+
+            Rect r0 = GUILayoutUtility.GetRect(0, Screen.width, 16f, 16f);
+            r0.xMin = 0;
+            r0.xMax += 16f;
+            GDKAutoBuild.DrawRect(r0, new Color32(20, 20, 20, 255));
+
+            if ((Event.current.type == EventType.MouseUp) && r0.Contains(Event.current.mousePosition))
+            {
+                var fullPath = new DirectoryInfo(ab.buildFolder);
+                EditorUtility.RevealInFinder(fullPath.FullName);
+                Event.current.Use();
+            }
+
+            GUI.Label(r0, path, projectStyle);
+            EditorGUILayout.Space();
+
+            if (string.IsNullOrEmpty(helpInfo)) helpInfo = $"\nPackageName:\t{PlayerSettings.applicationIdentifier}\nTargetPlatform:\t{EditorUserBuildSettings.activeBuildTarget}\n";
+            EditorGUILayout.HelpBox(helpInfo, MessageType.Info);
+            Rect rect = GUILayoutUtility.GetLastRect();
+            if ((Event.current.type == EventType.MouseUp) && rect.Contains(Event.current.mousePosition))
+            {
+                Event.current.Use();
+                helpInfo = null;
+                Repaint();
+            }
+
+            drawDefault = GUILayout.Toggle(drawDefault, "Draw default");
+            if (drawDefault) DrawDefaultInspector();
+
+            EditorGUILayout.Space();
+
+            int max = ab.listBuild.Count;
+            if (max == 0)
+            {
+                EditorGUILayout.HelpBox("No BuildInfo!", MessageType.Warning);
+
+                if (GUILayout.Button("Create Default"))
+                {
+                    new GDKAutoBuild.BuildInfo().Read();
+
+                    ab.listBuild = new List<GDKAutoBuild.BuildInfo>
+                    {
+                        new GDKAutoBuild.BuildInfo
+                        {
+                            target = BuildTarget.Android, isAAB = false, splitAPK = true
+                        }.Read(),
+                        new GDKAutoBuild.BuildInfo
+                        {
+                            target = BuildTarget.Android, isAAB = true, splitAPK = true
+                        }.Read(),
+                        new GDKAutoBuild.BuildInfo
+                        {
+                            target = BuildTarget.iOS, isAAB = true, splitAPK = true
+                        }.Read()
+                    };
+                }
+                return;
+            }
+
+            serializedObject.Update();
+            SerializedProperty prop = serializedObject.FindProperty($"listBuild.Array.data[{bIndex}]");
+            prop.isExpanded = true;
+
+            GDKAutoBuild.BuildInfo info = ab.listBuild[bIndex];
+
+            EditorGUI.BeginChangeCheck();
+            {
+                EditorGUILayout.PropertyField(prop, true);
+            }
+            if (EditorGUI.EndChangeCheck()) serializedObject.ApplyModifiedProperties();
+
+            Rect r = GUILayoutUtility.GetLastRect();
+            r.x = 0;
+            r.width = Screen.width;
+            r.height = 16f;
+
+            GDKAutoBuild.DrawRect(r, new Color32(20, 20, 20, 255));
+
+            r.xMin += 12f;
+            GUI.Label(r, info.buildName);
+
+            if ((ab.icon != null) && (ab.icon == info.buildIcon)) EditorGUILayout.HelpBox("Build Icon must be different with the template icon (which will be overwritten)", MessageType.Error);
+
+            GUILayout.BeginHorizontal();
+            {
+                if (GUILayout.Button("Read")) info.Read();
+
+                if (GUILayout.Button("Write")) info.Write();
+
+                if (GUILayout.Button("+")) info.IncreaseVersion();
+            }
+            GUILayout.EndHorizontal();
+
+            if (GUILayout.Button("Dry Run"))
+            {
+                ab.DryRun(info);
+                helpInfo = null;
+                Repaint();
+            }
+
+            bIndex = EditorGUILayout.IntSlider(bIndex, 0, max - 1);
+
+            var nBuilds = 0;
+            for (var i = 0; i < ab.listBuild.Count; i++)
+            {
+                GDKAutoBuild.BuildInfo item = ab.listBuild[i];
+
+                if (!item.enable) continue;
+                nBuilds++;
+
+                string hint = item.target == BuildTarget.Android
+                    ? $"{string.Join("\n", item.GetAPKNames(ab.buildFolder))}"
+                    : item.fullBuildPath(ab.buildFolder);
+
+                EditorGUILayout.HelpBox(hint, MessageType.Info);
+            }
+
+            if (nBuilds == 0) return;
+
+            GUILayout.BeginHorizontal();
+            {
+                if (GUILayout.Button("Build"))
+                {
+                    ab.buildRQ = GDKAutoBuild.BuildRequestTS.Generate(); //ab.runGitPostBuild
+                    ab.ProcessBuild();
+                }
+
+                if (GUILayout.Button("Stop")) ab.StopBuild();
+            }
+            GUILayout.EndHorizontal();
+        }
+    }
+
+
+    public class ExternalProcessUtils
+    {
+        public static string FileFromTemplate(string fileName, string source, params string[] tokens)
+        {
+            for (var i = 0; i < tokens.Length; i += 2)
+            {
+                source = source.Replace(tokens[i], tokens[i + 1]);
+            }
+
+            string filePath = Application.dataPath.Replace("/Assets", "/" + fileName);
+
+            // Debug.LogWarning("FilePath: " + filePath);
+            File.WriteAllText(filePath, source);
+            return filePath;
+        }
+
+        // public static void GitResetRepo()
+        // {
+        // 	RunCMD("git reset --hard | git clean -df");
+        // }
+
+        public static void RunCMD(string cmd)
+        {
+            try
+            {
+                var startInfo = new ProcessStartInfo
+                {
+                    FileName = "/bin/bash",
+                    Arguments = $"-c \" {cmd} \" ",
+                    CreateNoWindow = true
+                };
+
+                var proc = new Process
+                {
+                    StartInfo = startInfo
+                };
+
+                proc.Start();
+                proc.WaitForExit();
+            } catch (Exception e)
+            {
+                Debug.LogWarning(e);
+            }
+        }
+
+        public static void ChmodX(string filePath)
+        {
+            RunCMD($"chmod +x  {filePath}");
+        }
+
+        public static void Run(string filePath, bool waitExit = false)
+        {
+            ChmodX(filePath);
+
+            try
+            {
+                var process = new Process
+                {
+                    EnableRaisingEvents = false,
+                    StartInfo =
+                    {
+                        FileName = filePath,
+                        UseShellExecute = false,
+                        RedirectStandardOutput = true,
+                        RedirectStandardInput = true,
+                        RedirectStandardError = true
+                    }
+                };
+
+                process.Start();
+                if (waitExit) process.WaitForExit();
+            } catch (Exception e)
+            {
+                Debug.LogWarning(e);
+            }
+        }
+    }
+}

package/Editor/Extra/GDKAutoBuild.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7f55e6986cd4437685e4bff21bf6ae7a
+timeCreated: 1706774721

package/Editor/Extra/GDKProjectCP.cs

@@ -0,0 +1,158 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.Linq;
+using UnityEditor.SceneManagement;
+
+namespace Amanotes
+{
+	internal class GDKProjectCP : EditorWindow
+	{
+		private static GDKProjectCP _window;
+		static Texture2D iconScene;
+		static Texture2D iconPlay;
+		static Texture2D iconFolder;
+		static GUIStyle productNameStyle;
+		static string projectPath;
+
+		private static int activeSceneIndex;
+
+
+		[MenuItem("Window/AmaGDK/Project Control Panel")]
+		private static void ShowWindow()
+		{
+			if (_window != null) return;
+			
+			iconScene = AssetPreview.GetMiniTypeThumbnail(typeof(SceneAsset));
+			_window = CreateInstance<GDKProjectCP>();
+			_window.titleContent = new GUIContent("Project CP", iconScene, "GDK Project Control Panel");
+			_window.Show();
+		}
+
+		void Init()
+		{
+			if (iconScene == null) iconScene = AssetPreview.GetMiniTypeThumbnail(typeof(SceneAsset));
+			iconPlay = EditorGUIUtility.FindTexture("PlayButton");
+			iconFolder = EditorGUIUtility.FindTexture("Folder Icon");
+
+
+			productNameStyle = new GUIStyle(EditorStyles.largeLabel)
+			{
+				alignment = TextAnchor.MiddleCenter,
+				fontSize = 32
+			};
+
+			projectPath = Application.dataPath;
+			List<string> arr = projectPath.Split('/').ToList();
+			arr.RemoveAt(arr.Count - 1);
+
+			if (arr.Count > 3)
+			{
+				arr.RemoveRange(0, arr.Count - 3);
+			}
+
+			projectPath = string.Join("/", arr);
+		}
+
+		static void DrawBigPlayButton()
+		{
+			EditorBuildSettingsScene[] scenes = EditorBuildSettings.scenes;
+			if (scenes.Length == 0)
+			{
+				EditorGUILayout.HelpBox("No scene in Build Setting!", MessageType.Warning);
+				return;
+			}
+			
+			EditorBuildSettingsScene scene = scenes[activeSceneIndex];
+
+			GUILayout.BeginHorizontal();
+			{
+				EditorGUILayout.Space();
+				GUILayout.BeginVertical();
+				{
+					GUILayout.Space(16);
+					GUILayout.Label(scene.path);
+					activeSceneIndex = EditorGUILayout.IntSlider(activeSceneIndex, 0, scenes.Length - 1);
+				}
+				GUILayout.EndVertical();
+				if (GUILayout.Button(iconPlay, GUILayout.Width(64f), GUILayout.Height(64f)))
+				{
+					OpenScene(scene.path, true);
+				}
+			}
+			GUILayout.EndHorizontal();
+		}
+
+		static void OpenScene(string scenePath, bool play)
+		{
+			if (EditorApplication.isPlaying)
+			{
+				EditorApplication.isPlaying = false;
+			} 
+			else
+			{
+				EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo();
+				EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
+				if (play) EditorApplication.isPlaying = true;	
+			}
+		}
+		
+		static void DrawProjectInfo()
+		{
+			GUILayout.Label(PlayerSettings.productName, productNameStyle);
+
+			var projectPathContent = new GUIContent(projectPath, iconFolder, "click to open folder");
+
+			if (GUILayout.Button(projectPathContent, EditorStyles.toolbarButton))
+			{
+				EditorUtility.RevealInFinder(Application.dataPath);
+			}
+		}
+
+		static void DrawListScenes()
+		{
+			EditorBuildSettingsScene[] listScenes = EditorBuildSettings.scenes;
+			int n = Mathf.Min(listScenes.Length, listScenes.Length);
+
+			GUILayout.BeginVertical();
+			{
+				for (var i = 0; i < n; i++)
+				{
+					EditorBuildSettingsScene scene = listScenes[i];
+					if (!scene.enabled) continue;
+
+					GUILayout.BeginHorizontal();
+					{
+						var asset = AssetDatabase.LoadAssetAtPath<SceneAsset>(scene.path);
+
+						if (GUILayout.Button(iconScene, EditorStyles.toolbarButton, GUILayout.Width(25f)))
+						{
+							OpenScene(scene.path, false);
+						}
+
+						EditorGUILayout.ObjectField(asset, typeof(SceneAsset), false);
+
+						if (GUILayout.Button(iconPlay, EditorStyles.toolbarButton, GUILayout.Width(25f)))
+						{
+							OpenScene(scene.path, true);
+						}
+					}
+					GUILayout.EndHorizontal();
+				}
+			}
+			GUILayout.EndVertical();
+		}
+
+
+		public void OnGUI()
+		{
+			if (productNameStyle == null) Init();
+
+			DrawProjectInfo();
+			EditorGUILayout.Space();
+			DrawBigPlayButton();
+			EditorGUILayout.Space();
+			DrawListScenes();
+		}
+	}
+}

package/Editor/Extra/GDKProjectCP.cs.meta

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

package/Editor/Extra.meta

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

package/Extra/{AmaGDKProject.unitypackage.meta → AndroidPostProcessor.unitypackage.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 26e42be832082494fb3eb94a4d9cd300
+guid: e331d1b8f5c1d49bc8ef6ea5239e4ca4
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Extra/CheckDiskSpace.unitypackage.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 9de8b88fa236d49ecb6065f03cc91fc1
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/AmaGDK.Ads.cs

@@ -373,6 +373,7 @@ namespace Amanotes.Core.Internal
         public int adShowTimeoutInSecs = 5;
         public BannerPosition bannerPosition = BannerPosition.BOTTOM;
         public bool autoLogEvent = true;
+        public bool checkInternet = true;
 
         public bool enableInterstitial = true;
         public bool enableRewarded = true;
@@ -710,7 +711,7 @@ namespace Amanotes.Core.Internal
                 if (_loadState != LoadAdsState.Requesting) StartLoadAd();
                 var counter = 0;
                 bool? hasInternet = null;
-                _instance.StartCoroutine(WebUtils.CheckInternet(result => hasInternet = result));
+                if (adConfig.checkInternet) _instance.StartCoroutine(WebUtils.CheckInternet(result => hasInternet = result));
 
                 var wait1Sec = new WaitForSecondsRealtime(1f);
                 while (counter < timeout || timeout == -1)
@@ -719,7 +720,7 @@ namespace Amanotes.Core.Internal
                     counter++;
 
                     // finish checking internet & result is false
-                    if (hasInternet == false)
+                    if (adConfig.checkInternet && hasInternet == false)
                     {
                         Log("[Ad] Stop WaitForAd : No internet!");
                         _showState = ShowAdsState.ShowFail;

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.49";
+        public const string VERSION = "0.2.50";
 
         internal static AmaGDK _instance;
         internal static Status _status = Status.None;

package/Runtime/Internal/AmaGDK.Internal.cs

@@ -39,6 +39,7 @@ namespace Amanotes.Core.Internal
 #endif
 
         public const string PACKAGE_PATH = BASE_PATH + "Packages/";
+        public const string EXTRA_PATH = BASE_PATH + "Extra/";
         public const string AMAGDK_PREFAB = BASE_PATH + "Runtime/AmaGDK.prefab";
         public const string AMAGDK_CONFIG_PACKAGE = PACKAGE_PATH + "AmaGDKConfig.unitypackage";
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "com.amanotes.gdk",
-    "version": "0.2.49",
+    "version": "0.2.50",
     "displayName": "AmaGDK",
     "description": "Amanotes Game Development Kit",
     "unity": "2019.4",