com.amanotes.gdk 0.2.68 → 0.2.70-1

package/Editor/Extra/GDKSymbolDefine.cs

@@ -0,0 +1,372 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Serialization;
+using UnityObject = UnityEngine.Object;
+
+namespace Amanotes.Core
+{
+    [CreateAssetMenu(fileName = "GDKSymbolDefine", menuName = "Ama GDK/GDK Symbol Define", order = 100)]
+    internal partial class GDKSymbolDefine : ScriptableObject
+    {
+        private static readonly string cscRspFilePath = "Assets/csc.rsp";
+        public List<SymbolInfo> symbols = new List<SymbolInfo>();
+        public LoggerConfig loggerConfig = new LoggerConfig();
+        
+
+        [ContextMenu("Read")]
+        public void Read()
+        {
+            if (!File.Exists(cscRspFilePath)) return;
+            
+            var enabledSymbols = new HashSet<string>(ReadCSC());
+            AddSymbol(enabledSymbols, true);
+            SetEnableSymbols(enabledSymbols, true);
+        }
+        
+        private void Write()
+        {
+            var list = symbols
+                .Union(this.loggerConfig.tags)
+                .Where(item=>item.enabled)
+                .Select(item => item.name)
+                .Distinct()
+                .ToArray();
+
+            string content = list.Length > 0 ? $"-define:{string.Join(";", list)}" : string.Empty;
+            File.WriteAllText(cscRspFilePath, content);   
+            AssetDatabase.Refresh();
+        }
+        
+        [ContextMenu("Apply")]
+        public void Apply()
+        {
+            Write();
+            loggerConfig.GenerateLogger();
+            
+            #if UNITY_EDITOR
+            EditorUtility.SetDirty((this));
+            AssetDatabase.Refresh();
+            #endif
+        }
+        
+        private void SetEnableSymbols(HashSet<string> enabledSymbols, bool enabled)
+        {
+            for (var i = 0; i < symbols.Count; i++)
+            {
+                symbols[i].enabled = enabledSymbols.Contains(symbols[i].name);
+            }
+            
+            for (var i = 0; i < loggerConfig.tags.Count; i++)
+            {
+                loggerConfig.tags[i].enabled = enabledSymbols.Contains(loggerConfig.tags[i].name);
+            }
+        }
+        
+        private void AddSymbol(IEnumerable<string> newSymbols, bool enabled)
+        {
+            var dict = symbols
+                .Union(loggerConfig.tags)
+                .Distinct()
+                .ToDictionary(item => item.name);
+            
+            foreach (string symbol in newSymbols)
+            {
+                if (dict.TryGetValue(symbol, out var info)) continue;
+                info = new SymbolInfo() { name = symbol, enabled = enabled };
+                symbols.Add(info);
+            }
+            
+            #if UNITY_EDITOR
+            EditorUtility.SetDirty(this);
+            #endif
+        }
+        
+        private List<string> ReadCSC()
+        {
+            var result = new List<string>();
+            if (!File.Exists(cscRspFilePath)) return result;
+            string[] rspLines = File.ReadAllLines(cscRspFilePath);
+
+            foreach (string line in rspLines)
+            {
+                string line2 = line.Trim();
+                if (!line2.StartsWith("-define:")) continue;
+
+                // Extract existing symbols from -define:
+                result.AddRange(line2.Substring(8).Split(';'));
+            }
+
+            return result;
+        }
+    }
+
+    internal partial class GDKSymbolDefine
+    {
+        [Serializable] internal class SymbolInfo
+        {
+            [FormerlySerializedAs("symbol")] public string name;
+            public bool enabled;
+        }
+        
+        [Serializable] internal class LoggerConfig
+        {
+            public bool enabled;
+            public bool forceCleanUp;
+            public UnityObject codeGenerateFolder;
+            public string codeGeneratePath
+            {
+                get
+                {
+                    string path = AssetDatabase.GetAssetPath(codeGenerateFolder);
+                    if (AssetDatabase.IsValidFolder(path)) return path;
+
+                    var defaultPath = "Assets/AmaGDK/LogV2";
+                    var asset = AssetDatabase.LoadAssetAtPath<UnityObject>(defaultPath);
+                    if (asset != null) codeGenerateFolder = asset;
+                    return defaultPath;
+                }
+            }
+            public string className = "LogV2";
+            
+            [HideInInspector][SerializeField] private string classTemplate = $@"using Debug = UnityEngine.Debug;
+using UnityObject = UnityEngine.Object;
+
+public partial class $$CLASS_NAME$$
+{{
+    private static void Log(string tag, string message, UnityObject context)
+    {{
+        Debug.Log($""[{{tag}}] {{message}}"", context);
+    }}
+
+    private static void LogWarning(string tag, string message, UnityObject context)
+    {{
+        Debug.LogWarning($""[{{tag}}] {{message}}"", context);
+    }} 
+
+    private static void LogError(string tag, string message, UnityObject context)
+    {{
+        Debug.LogError($""[{{tag}}] {{message}}"", context);
+    }}
+}}";
+            
+            public List<SymbolInfo> tags = new List<SymbolInfo>();
+            
+            public void GenerateLogger()
+            {
+                if (!enabled) return;
+
+                bool hasFolder = Directory.Exists(codeGeneratePath); 
+                if (hasFolder)
+                {
+                    if (forceCleanUp)
+                    {
+                        Directory.Delete(codeGeneratePath, true);
+                        hasFolder = false;
+                    }
+                }
+                
+                if (!hasFolder) Directory.CreateDirectory(codeGeneratePath);
+                
+                // Generate main logger class
+                string filePath = Path.Combine(codeGeneratePath, $"{className}.cs");
+                string classContent;
+                
+                if (!File.Exists(filePath))
+                {
+                    classContent = classTemplate.Replace("$$CLASS_NAME$$", className);
+                    File.WriteAllText(filePath, classContent);
+                    AssetDatabase.ImportAsset(filePath);
+                }
+                
+                // Generate derived logger classes
+                for (var i = 0; i < tags.Count; i++)
+                {
+                    string tag = tags[i].name;
+                    classContent = GenerateTagClassContent(tag);
+                    filePath = Path.Combine(codeGeneratePath, $"{className}.{tag}.cs");
+                    File.WriteAllText(filePath, classContent);
+                    AssetDatabase.ImportAsset(filePath);
+                }
+            }
+            
+            private string GenerateTagClassContent(string tag)
+            {
+                return $@"using System.Diagnostics;
+using UnityObject = UnityEngine.Object;
+
+public partial class {className}
+{{
+    public static class {tag}
+    {{
+        [Conditional(nameof({tag}))]
+        public static void Log(string message, UnityObject context = null) => {className}.Log(nameof({tag}), message, context);
+
+        [Conditional(nameof({tag}))]
+        public static void LogWarning(string message, UnityObject context = null) => {className}.LogWarning(nameof({tag}),message, context);
+
+        [Conditional(nameof({tag}))]
+        public static void LogError(string message, UnityObject context = null) => {className}.LogError(nameof({tag}), message, context);
+    }}
+}}";
+            }
+        }
+    }
+
+
+    // INSPECTOR
+
+    [CustomPropertyDrawer(typeof(GDKSymbolDefine.SymbolInfo))]
+    internal class SymbolInfoDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            // Begin property drawing
+            EditorGUI.BeginProperty(position, label, property);
+
+            // Calculate rects
+            var toggleRect = new Rect(position.x, position.y, 20, position.height);
+            var labelRect = new Rect(position.x + 25, position.y, position.width - 25, position.height);
+
+            // Draw fields
+            SerializedProperty symbolProperty = property.FindPropertyRelative("name");
+            SerializedProperty enabledProperty = property.FindPropertyRelative("enabled");
+
+            // Draw the enabled toggle
+            enabledProperty.boolValue = EditorGUI.Toggle(toggleRect, enabledProperty.boolValue);
+
+            // Draw the symbol name field
+            symbolProperty.stringValue = EditorGUI.TextField(labelRect, symbolProperty.stringValue, EditorStyles.label);
+
+            // End property drawing
+            EditorGUI.EndProperty();
+        }
+    }
+
+    [CustomEditor(typeof(GDKSymbolDefine))]
+    public class GDKSymbolDefineEditor : UnityEditor.Editor
+    {
+        private SerializedProperty symbolsProp;
+        private SerializedProperty loggerConfigProp;
+        private int selectedTab = 0;
+        private GDKSymbolDefine define;
+        
+        
+        private readonly GUIContent[] tabTitles = new GUIContent[]
+        {
+            new GUIContent("Symbols"),
+            new GUIContent("Logger Config")
+        };
+
+        private void OnEnable()
+        {
+            define = (GDKSymbolDefine)target;
+            symbolsProp = serializedObject.FindProperty("symbols");
+            loggerConfigProp = serializedObject.FindProperty("loggerConfig");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (Application.isPlaying || EditorApplication.isPlayingOrWillChangePlaymode)
+            {
+                EditorGUILayout.HelpBox("Disabled in play mode!", MessageType.Info);
+                Repaint();
+                return;
+            }
+            
+            if (EditorApplication.isUpdating)
+            {
+                EditorGUILayout.HelpBox("Please wait for Unity Editor to finish importing!", MessageType.Info);
+                Repaint();
+                return;
+            }
+
+            if (EditorApplication.isCompiling)
+            {
+                EditorGUILayout.HelpBox("Please wait for Unity Editor to finish compiling!", MessageType.Info);
+                Repaint();
+                return;
+            }
+
+            if (define == null) return;
+            
+            serializedObject.Update();
+            selectedTab = GUILayout.Toolbar(selectedTab, tabTitles, GUILayout.Height(32f));
+
+            switch (selectedTab)
+            {
+            case 0:
+                DrawSymbolsTab();
+                break;
+            case 1:
+                DrawLoggerConfigTab();
+                break;
+            default:
+                DrawSymbolsTab();
+                break;
+            }
+            
+            GUILayout.Space(24f);
+            if (GUILayout.Button("Apply", GUILayout.Height(30f)))
+            {
+                define.Apply();
+                Repaint();
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawSymbolsTab()
+        {
+            EditorGUILayout.PropertyField(symbolsProp, new GUIContent("DEFINE SYMBOLS"), true);
+            if (define.loggerConfig.enabled)
+            {
+                EditorGUILayout.PropertyField(loggerConfigProp.FindPropertyRelative("tags"), new GUIContent("LOGGER TAGS"), true);    
+            }
+        }
+        
+        private static bool showTemplate = false;
+        private void DrawLoggerConfigTab()
+        {
+            // EditorGUILayout.PropertyField(loggerConfigProp, GUIContent.none, true);
+            DrawProperty(serializedObject, "loggerConfig", true);
+            showTemplate = GUILayout.Toggle(showTemplate, "Logger class template", EditorStyles.foldout);
+            if (showTemplate)
+            {
+                var prop = serializedObject
+                    .FindProperty("loggerConfig")
+                    .FindPropertyRelative("classTemplate");
+                EditorGUILayout.PropertyField(prop, GUIContent.none, false, GUILayout.Height(16 * 20));
+            }
+        }
+        
+        private static void DrawProperty(SerializedObject so, string propertyField, bool childrenOnly)
+        {
+            SerializedProperty property = so.FindProperty(propertyField);
+            if (property == null)
+            {
+                EditorGUILayout.HelpBox($"Property not found <{propertyField}>!", MessageType.Warning);
+                return;
+            }
+
+            if (!childrenOnly)
+            {
+                EditorGUILayout.PropertyField(property);
+            }
+            
+            string basePath = property.propertyPath;
+            var first = true;
+            while (property.NextVisible(first))
+            {
+                first = false;
+                if (!property.propertyPath.Contains(basePath)) break;
+                EditorGUILayout.PropertyField(property);
+            }
+
+            so.ApplyModifiedProperties();
+        }
+    }
+}

package/Editor/{AmaGDKManager.cs.meta → Extra/GDKSymbolDefine.cs.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 44c77ba58d5d742d68829b3d5b04a3bf
+guid: ac69671f3a58f434a83023380f963e8b
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

package/Editor/Utils/AmaGDKEditor.ExtractVersion.cs

@@ -5,11 +5,14 @@ using System.Linq;
 using System.Reflection;
 using System.Xml;
 using Amanotes.Core.Internal;
+using System.Text.RegularExpressions;
+
 #if !UNITY_2021_1_OR_NEWER
-using UnityEditor;
 using UnityEditor.PackageManager;
 using UnityEditor.PackageManager.Requests;
 #endif
+
+using UnityEditor;
 using UnityEngine;
 using static Amanotes.Core.AmaGDK.AdapterID;
 
@@ -179,8 +182,10 @@ namespace Amanotes.Editor
                 case FIREBASE_ANALYTICS: return FirebaseAnalytics();
                 case FIREBASE_REMOTE_CONFIG: return FirebaseRemoteConfig();
                 case APPSFLYER: return AppsFlyer();
-                case IRONSOURCE: return Ironsource();
+                case IRONSOURCE: return IronSource();
+                case MAX: return Max();
                 case REVENUECAT: return RevenueCat();
+                case SQLITE_ANALYTICS: return SqliteAnalytics();
                 default:
                     Debug.LogWarning($"Unsupported sdkID <{sdkId}>");
                     break;
@@ -261,7 +266,35 @@ namespace Amanotes.Editor
             return version.Trim();
         }
 
-        internal static string Ironsource()
+        internal static string Max()
+        {
+            string[] guids = AssetDatabase.FindAssets("t:monoscript MaxSdk");
+            if (guids.Length == 0) return string.Empty;
+
+            foreach (string guid in guids)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+                if (!path.EndsWith("MaxSdk.cs")) continue;
+                
+                try
+                {
+                    string fileContent = File.ReadAllText(path);
+                    const string pattern = @"private const string _version = ""(?<version>[\d\.]+)"";";
+                    var regex = new Regex(pattern);
+                    Match match = regex.Match(fileContent);
+                    return match.Success ? match.Groups["version"].Value : string.Empty;
+                }
+                catch (IOException ex)
+                {
+                    Debug.LogWarning($"Can not get Max Version : {ex}");
+                    return string.Empty;
+                }
+            }
+            
+            return string.Empty;
+        }
+
+        internal static string IronSource()
         {
             var version = "";
             string[] issdk = Directory.GetFiles("Assets", "IronSourceSDKDependencies.xml", SearchOption.AllDirectories);
@@ -297,6 +330,11 @@ namespace Amanotes.Editor
             return version?.Trim();
         }
 
+        internal static string SqliteAnalytics()
+        {
+            return "1.0.0";
+        }
+
         internal static string RevenueCat()
         {
             string[] files = Directory.GetFiles("Assets", "PurchasesWrapper.java", SearchOption.AllDirectories);

package/Extra/{GoogleCMP.unitypackage.meta → Consent.unitypackage.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 4e220bd58ce0646bcbbb209dc8451d25
+guid: c76a726b63046449ab0d11191aa3980b
 DefaultImporter:
   externalObjects: {}
   userData: 

package/{Editor/Resources.meta → Packages/MaxAdNetworkAdapter.unitypackage.meta}

@@ -1,6 +1,5 @@
 fileFormatVersion: 2
-guid: aa56aa5c6656f415ebac7089cf7cf7dc
-folderAsset: yes
+guid: 4d9f3e2a9be574df390eff5ef9f11fa9
 DefaultImporter:
   externalObjects: {}
   userData: 

package/Runtime/Ad/AdExtension.cs

@@ -76,10 +76,12 @@ namespace Amanotes.Core
             AmaGDK.Ads.context.onAdShowReadyStatus += callback;
             return ad;
         }
+        
         /// <summary>
         /// The finalize callback that will always trigger to mark an end for the AdShowRoutine
         /// 
         /// </summary>
+        [Obsolete("OnAdResult is obsolete. Please use the onAdResult callback in AmaGDK.Ads.ShowInterstitial(Action<bool> onAdResult) or AmaGDK.Ads.ShowRewardedVideo(Action<bool> onAdResult) instead.")]
         public static IAdCallback OnAdResult(this IAdCallback ad, Action<bool> callback)
         {
             if (!MakeSureAdNotNull(ad)) return null;