com.amanotes.gdk 0.2.50 → 0.2.52

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.2.52 - 2024-02-27]
+- Change post processing order
+- Remove GDKInstaller after installed
+- Enable pipeline execution for branches with active merge requests
+- [Fix] Non-fatal exceptions relate to Analytics and Ads
+- Update Google Sheet Id default
+- Optimize GC for Analytics
+
+## [0.2.51 - 2024-02-20]
+- Change Google Mobile Ads SDK version , iosPod 10.5.0
+
 ## [0.2.50 - 2024-02-20]
 - New feature: Modify Android post processor
 - [Fix] remove installer should be skipped in DEV mode

package/Editor/Extra/GDKCIBuildCommand.cs

@@ -0,0 +1,312 @@
+using UnityEditor;
+using System.Linq;
+using System;
+using System.IO;
+
+namespace Amanotes.Core
+{
+    public static class GDKCIBuildCommand
+    {
+        private const string KEYSTORE_PASS = "KEYSTORE_PASS";
+        private const string KEY_ALIAS_PASS = "KEY_ALIAS_PASS";
+        private const string KEY_ALIAS_NAME = "KEY_ALIAS_NAME";
+        private const string KEYSTORE = "keystore.keystore";
+        private const string BUILD_OPTIONS_ENV_VAR = "BuildOptions";
+        private const string ANDROID_BUNDLE_VERSION_CODE = "VERSION_BUILD_VAR";
+        private const string ANDROID_APP_BUNDLE = "BUILD_APP_BUNDLE";
+        private const string SCRIPTING_BACKEND_ENV_VAR = "SCRIPTING_BACKEND";
+        private const string VERSION_NUMBER_VAR = "VERSION_NUMBER_VAR";
+        private const string VERSION_iOS = "VERSION_BUILD_VAR";
+
+        static string GetArgument(string name)
+        {
+            string[] args = Environment.GetCommandLineArgs();
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (args[i].Contains(name))
+                {
+                    return args[i + 1];
+                }
+            }
+            return null;
+        }
+
+        static string[] GetEnabledScenes()
+        {
+            return (
+                from scene in EditorBuildSettings.scenes
+                where scene.enabled
+                where !string.IsNullOrEmpty(scene.path)
+                select scene.path
+            ).ToArray();
+        }
+
+        static BuildTarget GetBuildTarget()
+        {
+            string buildTargetName = GetArgument("customBuildTarget");
+            Console.WriteLine(":: Received customBuildTarget " + buildTargetName);
+
+            if (buildTargetName.ToLower() == "android")
+            {
+#if !UNITY_5_6_OR_NEWER
+			// https://issuetracker.unity3d.com/issues/buildoptions-dot-acceptexternalmodificationstoplayer-causes-unityexception-unknown-project-type-0
+			// Fixed in Unity 5.6.0
+			// side effect to fix android build system:
+			EditorUserBuildSettings.androidBuildSystem = AndroidBuildSystem.Internal;
+#endif
+            }
+
+            if (buildTargetName.TryConvertToEnum(out BuildTarget target))
+                return target;
+
+            Console.WriteLine($":: {nameof(buildTargetName)} \"{buildTargetName}\" not defined on enum {nameof(BuildTarget)}, using {nameof(BuildTarget.NoTarget)} enum to build");
+
+            return BuildTarget.NoTarget;
+        }
+
+        static string GetBuildPath()
+        {
+            string buildPath = GetArgument("customBuildPath");
+            Console.WriteLine(":: Received customBuildPath " + buildPath);
+            if (buildPath == "")
+            {
+                throw new Exception("customBuildPath argument is missing");
+            }
+            return buildPath;
+        }
+
+        static string GetBuildName()
+        {
+            string buildName = GetArgument("customBuildName");
+            Console.WriteLine(":: Received customBuildName " + buildName);
+            if (buildName == "")
+            {
+                throw new Exception("customBuildName argument is missing");
+            }
+            return buildName;
+        }
+
+        static string GetFixedBuildPath(BuildTarget buildTarget, string buildPath, string buildName)
+        {
+            if (buildTarget.ToString().ToLower().Contains("windows"))
+            {
+                buildName += ".exe";
+            }
+            else if (buildTarget == BuildTarget.Android)
+            {
+#if UNITY_2018_3_OR_NEWER
+                buildName += EditorUserBuildSettings.buildAppBundle ? ".aab" : ".apk";
+#else
+            buildName += ".apk";
+#endif
+            }
+            return buildPath + buildName;
+        }
+
+        static BuildOptions GetBuildOptions()
+        {
+            if (TryGetEnv(BUILD_OPTIONS_ENV_VAR, out string envVar))
+            {
+                string[] allOptionVars = envVar.Split(',');
+                BuildOptions allOptions = BuildOptions.None;
+                BuildOptions option;
+                string optionVar;
+                int length = allOptionVars.Length;
+
+                Console.WriteLine($":: Detecting {BUILD_OPTIONS_ENV_VAR} env var with {length} elements ({envVar})");
+
+                for (int i = 0; i < length; i++)
+                {
+                    optionVar = allOptionVars[i];
+
+                    if (optionVar.TryConvertToEnum(out option))
+                    {
+                        allOptions |= option;
+                    }
+                    else
+                    {
+                        Console.WriteLine($":: Cannot convert {optionVar} to {nameof(BuildOptions)} enum, skipping it.");
+                    }
+                }
+
+                return allOptions;
+            }
+
+            return BuildOptions.None;
+        }
+
+        // https://stackoverflow.com/questions/1082532/how-to-tryparse-for-enum-value
+        static bool TryConvertToEnum<TEnum>(this string strEnumValue, out TEnum value)
+        {
+            if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
+            {
+                value = default;
+                return false;
+            }
+
+            value = (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
+            return true;
+        }
+
+        static bool TryGetEnv(string key, out string value)
+        {
+            value = Environment.GetEnvironmentVariable(key);
+            return !string.IsNullOrEmpty(value);
+        }
+
+        static void SetScriptingBackendFromEnv(BuildTarget platform)
+        {
+            var targetGroup = BuildPipeline.GetBuildTargetGroup(platform);
+            if (TryGetEnv(SCRIPTING_BACKEND_ENV_VAR, out string scriptingBackend))
+            {
+                if (scriptingBackend.TryConvertToEnum(out ScriptingImplementation backend))
+                {
+                    Console.WriteLine($":: Setting ScriptingBackend to {backend}");
+                    PlayerSettings.SetScriptingBackend(targetGroup, backend);
+                }
+                else
+                {
+                    string possibleValues = string.Join(", ", Enum.GetValues(typeof(ScriptingImplementation)).Cast<ScriptingImplementation>());
+                    throw new Exception($"Could not find '{scriptingBackend}' in ScriptingImplementation enum. Possible values are: {possibleValues}");
+                }
+            }
+            else
+            {
+                var defaultBackend = PlayerSettings.GetDefaultScriptingBackend(targetGroup);
+                Console.WriteLine($":: Using project's configured ScriptingBackend (should be {defaultBackend} for targetGroup {targetGroup}");
+            }
+        }
+
+        public static void PerformBuild()
+        {
+            var buildTarget = GetBuildTarget();
+
+            Console.WriteLine(":: Performing build");
+            if (TryGetEnv(VERSION_NUMBER_VAR, out var bundleVersionNumber))
+            {
+                if (buildTarget == BuildTarget.iOS)
+                {
+                    bundleVersionNumber = GetIosVersion();
+                }
+                Console.WriteLine($":: Setting bundleVersionNumber to '{bundleVersionNumber}' (Length: {bundleVersionNumber.Length})");
+                PlayerSettings.bundleVersion = bundleVersionNumber;
+            }
+
+            if (buildTarget == BuildTarget.Android)
+            {
+                HandleAndroidAppBundle();
+                HandleAndroidBundleVersionCode();
+                HandleAndroidKeystore();
+            }
+
+            var buildPath = GetBuildPath();
+            var buildName = GetBuildName();
+            var buildOptions = GetBuildOptions();
+            var fixedBuildPath = GetFixedBuildPath(buildTarget, buildPath, buildName);
+
+            SetScriptingBackendFromEnv(buildTarget);
+
+            var buildReport = BuildPipeline.BuildPlayer(GetEnabledScenes(), fixedBuildPath, buildTarget, buildOptions);
+
+            if (buildReport.summary.result != UnityEditor.Build.Reporting.BuildResult.Succeeded)
+                throw new Exception($"Build ended with {buildReport.summary.result} status");
+
+            Console.WriteLine(":: Done with build");
+        }
+
+        private static void HandleAndroidAppBundle()
+        {
+            if (TryGetEnv(ANDROID_APP_BUNDLE, out string value))
+            {
+#if UNITY_2018_3_OR_NEWER
+                if (bool.TryParse(value, out bool buildAppBundle))
+                {
+                    EditorUserBuildSettings.buildAppBundle = buildAppBundle;
+                    Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected, set buildAppBundle to {value}.");
+                }
+                else
+                {
+                    Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but the value \"{value}\" is not a boolean.");
+                }
+#else
+            Console.WriteLine($":: {ANDROID_APP_BUNDLE} env var detected but does not work with lower Unity version than 2018.3");
+#endif
+            }
+        }
+
+        private static void HandleAndroidBundleVersionCode()
+        {
+            if (TryGetEnv(ANDROID_BUNDLE_VERSION_CODE, out string value))
+            {
+                if (int.TryParse(value, out int version))
+                {
+                    PlayerSettings.Android.bundleVersionCode = version;
+                    Console.WriteLine($":: {ANDROID_BUNDLE_VERSION_CODE} env var detected, set the bundle version code to {value}.");
+                }
+                else
+                    Console.WriteLine($":: {ANDROID_BUNDLE_VERSION_CODE} env var detected but the version value \"{value}\" is not an integer.");
+            }
+        }
+
+        private static string GetIosVersion()
+        {
+            if (TryGetEnv(VERSION_iOS, out string value))
+            {
+                if (int.TryParse(value, out int version))
+                {
+                    Console.WriteLine($":: {VERSION_iOS} env var detected, set the version to {value}.");
+                    return version.ToString();
+                }
+                else
+                    Console.WriteLine($":: {VERSION_iOS} env var detected but the version value \"{value}\" is not an integer.");
+            }
+
+            throw new ArgumentNullException(nameof(value), $":: Error finding {VERSION_iOS} env var");
+        }
+
+        private static void HandleAndroidKeystore()
+        {
+#if UNITY_2019_1_OR_NEWER
+            PlayerSettings.Android.useCustomKeystore = false;
+#endif
+
+            if (!File.Exists(KEYSTORE))
+            {
+                Console.WriteLine($":: {KEYSTORE} not found, skipping setup, using Unity's default keystore");
+                return;
+            }
+
+            PlayerSettings.Android.keystoreName = KEYSTORE;
+
+            string keystorePass;
+            string keystoreAliasPass;
+
+            if (TryGetEnv(KEY_ALIAS_NAME, out string keyaliasName))
+            {
+                PlayerSettings.Android.keyaliasName = keyaliasName;
+                Console.WriteLine($":: using ${KEY_ALIAS_NAME} env var on PlayerSettings");
+            }
+            else
+            {
+                Console.WriteLine($":: ${KEY_ALIAS_NAME} env var not set, using Project's PlayerSettings");
+            }
+
+            if (!TryGetEnv(KEYSTORE_PASS, out keystorePass))
+            {
+                Console.WriteLine($":: ${KEYSTORE_PASS} env var not set, skipping setup, using Unity's default keystore");
+                return;
+            }
+
+            if (!TryGetEnv(KEY_ALIAS_PASS, out keystoreAliasPass))
+            {
+                Console.WriteLine($":: ${KEY_ALIAS_PASS} env var not set, skipping setup, using Unity's default keystore");
+                return;
+            }
+#if UNITY_2019_1_OR_NEWER
+            PlayerSettings.Android.useCustomKeystore = true;
+#endif
+            PlayerSettings.Android.keystorePass = keystorePass;
+            PlayerSettings.Android.keyaliasPass = keystoreAliasPass;
+        }
+    }
+}

package/Editor/Extra/GDKCIBuildCommand.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bfe10a860d56457f86c6bb3931b972a5
+timeCreated: 1706775850

package/Editor/Extra/{GDKAutoBuild.cs → GDKLocalBuild.cs}

@@ -11,13 +11,25 @@ using UnityObject = UnityEngine.Object;
 
 namespace Amanotes.Editor
 {
-    [CreateAssetMenu(menuName = "AmaGDK/Build Config")]
-    public class GDKAutoBuild : ScriptableObject
+    [CreateAssetMenu(menuName = "Ama GDK/Build Config", fileName = "LocalBuild")]
+    public class GDKLocalBuild : ScriptableObject
     {
         private const string DEFAULT_BUILD_FOLDER = "../../_Build";
 
         public KeystoreInfo keystore;
-        public string buildFolder = DEFAULT_BUILD_FOLDER;
+        [SerializeField] private string relativeBuildFolder = DEFAULT_BUILD_FOLDER;
+
+        private string _buildFolder;
+        public string buildFolder
+        {
+            get
+            {
+                if (!string.IsNullOrEmpty(_buildFolder)) return _buildFolder;
+                _buildFolder = new DirectoryInfo(Path.Combine(Application.dataPath, relativeBuildFolder ?? DEFAULT_BUILD_FOLDER)).FullName;
+                return _buildFolder;
+            }
+        } 
+            
         public Texture2D icon;
 
         public List<BuildInfo> listBuild = new List<BuildInfo>();
@@ -135,8 +147,6 @@ namespace Amanotes.Editor
 
         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);
 
@@ -344,8 +354,13 @@ namespace Amanotes.Editor
 
                     EditorUserBuildSettings.buildAppBundle = isAAB;
                     EditorUserBuildSettings.exportAsGoogleAndroidProject = false;
+                    
+                    #if UNITY_2021_1_OR_NEWER
                     EditorUserBuildSettings.androidCreateSymbols = AndroidCreateSymbols.Disabled;
-
+                    #else
+                    EditorUserBuildSettings.androidCreateSymbolsZip = false;
+                    #endif
+                    
                     string[] listAPKNames = GetAPKNames(buildFolder);
 
                     for (var i = 0; i < listAPKNames.Length; i++)
@@ -508,10 +523,10 @@ namespace Amanotes.Editor
 
 
     [InitializeOnLoad]
-    internal class GDKAutoBuildHelper
+    internal class GDKLocalBuildHelper
     {
-        private static GDKAutoBuild build;
-        static GDKAutoBuildHelper()
+        private static GDKLocalBuild build;
+        static GDKLocalBuildHelper()
         {
             EditorApplication.update -= Update;
             EditorApplication.update += Update;
@@ -530,7 +545,7 @@ namespace Amanotes.Editor
 
             if (build == null)
             {
-                string[] guids = AssetDatabase.FindAssets("t:" + nameof(GDKAutoBuild)); //FindAssets uses tags check documentation for more info
+                string[] guids = AssetDatabase.FindAssets("t:" + nameof(GDKLocalBuild)); //FindAssets uses tags check documentation for more info
                 if (guids.Length == 0)
                 {
                     EditorApplication.update -= Update;
@@ -538,7 +553,7 @@ namespace Amanotes.Editor
                 }
 
                 string path = AssetDatabase.GUIDToAssetPath(guids[0]);
-                build = AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path);
+                build = AssetDatabase.LoadAssetAtPath<GDKLocalBuild>(path);
                 if (build == null)
                 {
                     EditorApplication.update -= Update;
@@ -558,7 +573,7 @@ namespace Amanotes.Editor
         // [MenuItem("Window/AmaGDK/Build/Select Build Asset &#b", false, 10)]
         public static void SelectBuild()
         {
-            string[] arr = AssetDatabase.FindAssets("t:" + nameof(GDKAutoBuild));
+            string[] arr = AssetDatabase.FindAssets("t:" + nameof(GDKLocalBuild));
 
             if (arr.Length == 0)
             {
@@ -577,9 +592,9 @@ namespace Amanotes.Editor
             EditorGUIUtility.PingObject(obj);
         }
 
-        private static GDKAutoBuild FindAutoBuildAssets(string name = null, bool allowFallback = false)
+        private static GDKLocalBuild FindLocalBuildAssets(string name = null, bool allowFallback = false)
         {
-            string[] arr = AssetDatabase.FindAssets("t:" + nameof(GDKAutoBuild));
+            string[] arr = AssetDatabase.FindAssets("t:" + nameof(GDKLocalBuild));
             if (arr.Length == 0)
             {
                 Debug.LogWarning("There are no Build asset in the project!");
@@ -589,17 +604,17 @@ namespace Amanotes.Editor
             for (var i = 0; i < arr.Length; i++)
             {
                 string path = AssetDatabase.GUIDToAssetPath(arr[i]).Replace("\\", "/");
-                if (string.IsNullOrEmpty(name)) return AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path);
+                if (string.IsNullOrEmpty(name)) return AssetDatabase.LoadAssetAtPath<GDKLocalBuild>(path);
 
                 string fileName = Path.GetFileName(path);
-                if (fileName.ToLower().Contains(name.ToLower())) return AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path);
+                if (fileName.ToLower().Contains(name.ToLower())) return AssetDatabase.LoadAssetAtPath<GDKLocalBuild>(path);
             }
 
             if (!allowFallback) return null;
 
             // Fall back to the first one
             string path0 = AssetDatabase.GUIDToAssetPath(arr[0]).Replace("\\", "/");
-            return AssetDatabase.LoadAssetAtPath<GDKAutoBuild>(path0);
+            return AssetDatabase.LoadAssetAtPath<GDKLocalBuild>(path0);
         }
 
         // [MenuItem("Window/AmaGDK/Build/Android", false, 50)] public static void BuildAndroid() { BuildAndroid(false); }
@@ -610,7 +625,7 @@ namespace Amanotes.Editor
 
         private static void BuildAndroid(bool isRelease)
         {
-            GDKAutoBuild buildAsset = FindAutoBuildAssets("android");
+            GDKLocalBuild buildAsset = FindLocalBuildAssets("android");
             if (buildAsset == null)
             {
                 Debug.LogWarning("Build Asset for Android not found!");
@@ -618,26 +633,26 @@ namespace Amanotes.Editor
             }
 
             buildAsset.EnableBuildForTarget(BuildTarget.Android);
-            buildAsset.buildRQ = GDKAutoBuild.BuildRequestTS.Generate();// isRelease
+            buildAsset.buildRQ = GDKLocalBuild.BuildRequestTS.Generate();// isRelease
             buildAsset.ProcessBuild();
         }
 
         private static void BuildIOS(bool isRelease)
         {
-            GDKAutoBuild buildAsset = FindAutoBuildAssets("ios");
+            GDKLocalBuild buildAsset = FindLocalBuildAssets("ios");
             if (buildAsset == null)
             {
                 Debug.LogWarning("Build Asset for iOS not found!");
                 return;
             }
             buildAsset.EnableBuildForTarget(BuildTarget.iOS);
-            buildAsset.buildRQ = GDKAutoBuild.BuildRequestTS.Generate(); //isRelease
+            buildAsset.buildRQ = GDKLocalBuild.BuildRequestTS.Generate(); //isRelease
             buildAsset.ProcessBuild();
         }
     }
 
-    [CustomEditor(typeof(GDKAutoBuild))]
-    public class GDKAutoBuildEditor : UnityEditor.Editor
+    [CustomEditor(typeof(GDKLocalBuild))]
+    public class GDKLocalBuildEditor : UnityEditor.Editor
     {
         public int bIndex;
         public string path;
@@ -671,7 +686,7 @@ namespace Amanotes.Editor
         }
         public override void OnInspectorGUI()
         {
-            var ab = (GDKAutoBuild)target;
+            var ab = (GDKLocalBuild)target;
             if (ab == null) return;
 
             if (productNameStyle == null) Init();
@@ -681,7 +696,7 @@ namespace Amanotes.Editor
             Rect r0 = GUILayoutUtility.GetRect(0, Screen.width, 16f, 16f);
             r0.xMin = 0;
             r0.xMax += 16f;
-            GDKAutoBuild.DrawRect(r0, new Color32(20, 20, 20, 255));
+            GDKLocalBuild.DrawRect(r0, new Color32(20, 20, 20, 255));
 
             if ((Event.current.type == EventType.MouseUp) && r0.Contains(Event.current.mousePosition))
             {
@@ -715,19 +730,19 @@ namespace Amanotes.Editor
 
                 if (GUILayout.Button("Create Default"))
                 {
-                    new GDKAutoBuild.BuildInfo().Read();
+                    new GDKLocalBuild.BuildInfo().Read();
 
-                    ab.listBuild = new List<GDKAutoBuild.BuildInfo>
+                    ab.listBuild = new List<GDKLocalBuild.BuildInfo>
                     {
-                        new GDKAutoBuild.BuildInfo
+                        new GDKLocalBuild.BuildInfo
                         {
                             target = BuildTarget.Android, isAAB = false, splitAPK = true
                         }.Read(),
-                        new GDKAutoBuild.BuildInfo
+                        new GDKLocalBuild.BuildInfo
                         {
                             target = BuildTarget.Android, isAAB = true, splitAPK = true
                         }.Read(),
-                        new GDKAutoBuild.BuildInfo
+                        new GDKLocalBuild.BuildInfo
                         {
                             target = BuildTarget.iOS, isAAB = true, splitAPK = true
                         }.Read()
@@ -740,7 +755,7 @@ namespace Amanotes.Editor
             SerializedProperty prop = serializedObject.FindProperty($"listBuild.Array.data[{bIndex}]");
             prop.isExpanded = true;
 
-            GDKAutoBuild.BuildInfo info = ab.listBuild[bIndex];
+            GDKLocalBuild.BuildInfo info = ab.listBuild[bIndex];
 
             EditorGUI.BeginChangeCheck();
             {
@@ -753,7 +768,7 @@ namespace Amanotes.Editor
             r.width = Screen.width;
             r.height = 16f;
 
-            GDKAutoBuild.DrawRect(r, new Color32(20, 20, 20, 255));
+            GDKLocalBuild.DrawRect(r, new Color32(20, 20, 20, 255));
 
             r.xMin += 12f;
             GUI.Label(r, info.buildName);
@@ -782,7 +797,7 @@ namespace Amanotes.Editor
             var nBuilds = 0;
             for (var i = 0; i < ab.listBuild.Count; i++)
             {
-                GDKAutoBuild.BuildInfo item = ab.listBuild[i];
+                GDKLocalBuild.BuildInfo item = ab.listBuild[i];
 
                 if (!item.enable) continue;
                 nBuilds++;
@@ -800,7 +815,7 @@ namespace Amanotes.Editor
             {
                 if (GUILayout.Button("Build"))
                 {
-                    ab.buildRQ = GDKAutoBuild.BuildRequestTS.Generate(); //ab.runGitPostBuild
+                    ab.buildRQ = GDKLocalBuild.BuildRequestTS.Generate(); //ab.runGitPostBuild
                     ab.ProcessBuild();
                 }
 

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

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

package/Runtime/AmaGDK.Adapters.cs

@@ -13,7 +13,7 @@ namespace Amanotes.Core.Internal
         [HideInInspector] [SerializeField] internal bool enabled = true;
         [NonSerialized] internal string adapterId;
         [NonSerialized] internal string adapterVersion;
-        [NonSerialized] internal protected Status status = Status.None;
+        [NonSerialized] protected internal Status status = Status.None;
         
         protected abstract void Init(Action<bool> onComplete);