com.amanotes.gdk 0.2.68 → 0.2.70

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.2.70 - 2024-08-02]
+- [Fix] onAdResult call multiple times
+- [Dev] Show SQLite analytics in GDK Inspector
+- [Dev] Reduce GC by reuse StringBuilders
+
+## [0.2.69 - 2024-07-26]
+- [Fix] disable Max adapter
+- [Dev] Update OnAdResult callback
+- [Fix] Waiting for ad callback
+- [Feature] AdEventTracking for Max ad network
+- [Fix] Wait until the application regains focus after showing ads
+- [Fix] Add OnAdReward callback for Max adapter
+- [Fix] Wrong coverage report for unity 2021
+- [Dev] Multiple AdAdapters is not supported
+- [Fix] Do not register disabled adapter
+- [Fix] add logic ad isSuccess
+- [Fix] Force-close ad when OnAdClose callback is missing
+- [Feature] Consent module: ATT + CMP
+- [Fix] Warning in RevenueCat Adapter
+- [Dev] Clean up timeout override for adapters
+- [Fix] Do not init disabled Adapters
+- [Dev] Remove AmaGDKManager
+- [Fix] Max Mediation not show up in AmaGDK Inspector
+- [Fix] iOS build process hang
+- [Feature] Add Max Ad Network Adapter
+- [Dev] Add option force clean up
+- [Fix] Warning FPS Module
+- [Dev] Config timeout for each adapter
+- [Fix] GDKSymbolDefine Log methods should not require context object
+- [Fix] Do not automatically reimport adapters in dev mode (for LegacyGDKUpdateHelper)
+- [Dev] Add GDK Symbol Define
+- Also: Option to generate a custom logger
+- [Dev] Improve GDK inspector UI with tooltip & logo
+- [Fix] Warnings for AutoUpdate module in dev mode
+- [Fix] Do not automatically reimport adapters in dev mode
+- [Dev] Display module flags in AmaGDK inspector
+- [Dev] Enable AudioModule by default
+- [Dev] Standardize variable names
+
 ## [0.2.68 - 2024-07-08]
 - [Dev] Add IronSource setting to pause game during ad
 - [Fix] Support Android API Version 24 and below

package/Editor/AmaGDKEditor.cs

@@ -51,7 +51,9 @@ namespace Amanotes.Editor
             FIREBASE_REMOTE_CONFIG,
             APPSFLYER,
             IRONSOURCE,
-            REVENUECAT
+            MAX,
+            REVENUECAT,
+            SQLITE_ANALYTICS,
         };
 
         public void OnEnable()
@@ -235,26 +237,67 @@ namespace Amanotes.Editor
         //     Debug.Log($"Content of version_info.tsv copied to clipboard!\n\n{tsv}\n\n");
         // }
 
+        void ShowAmaGDKContext()
+        {
+            var menu = new GenericMenu();
+            menu.AddDisabledItem(new GUIContent("AmaGDK"));
+            menu.AddSeparator("");
+            menu.AddItem(new GUIContent("Auto Init"), sdk.autoInit, () =>
+            {
+                sdk.autoInit = !sdk.autoInit;
+                EditorUtility.SetDirty(sdk);
+            });
+            menu.AddItem(new GUIContent("Clear Cache"), false, () =>
+            {
+                GDKFileUtils.ClearCacheData();
+            });
+            menu.AddSeparator("");
+            menu.AddItem(new GUIContent("Change Log"), false, () =>
+            {
+                Application.OpenURL("https://amagdk.notion.site/Change-Log-6dfd4b67d64f496bbd9eb04ccb4ef95a");
+            });
+            menu.AddItem(new GUIContent("Documentation"), false, () =>
+            {
+                Application.OpenURL("https://amagdk.notion.site/Ama-GDK-a73596617ab247b6a43c8f12a1581415?pvs=4");
+            });
+            menu.ShowAsContext();
+            UnityEvent.current.Use();
+        }
+        
+        private static GUIContent hamburgerIcon;
+        private static readonly Lazy<Texture2D> logo = new Lazy<Texture2D>(() =>
+        {
+            const string logoBase64 =
+                "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";
+            var tex = new Texture2D(2, 2, TextureFormat.RGBA32, false, true);
+            tex.LoadImage(Convert.FromBase64String(logoBase64), true);
+            return tex;
+        });
+        
+        [NonSerialized] private static GUIContent bannerTitle;
+        
         void DrawGUI_AmaGDKBanner()
         {
-            AmaGUI.SectionLabel($"<b>AmaGDK</b> <size=12><color=gray>v{AmaGDK.VERSION}</color></size>");
+            bannerTitle ??= new GUIContent()
+            {
+                image = logo.Value,
+                text = $"<b>AmaGDK</b> <size=12><color=gray>v{AmaGDK.VERSION}</color></size>"
+            };
+            AmaGUI.SectionLabel(bannerTitle);
             var rect = GUILayoutUtility.GetLastRect();
-            if (UnityEvent.current.isMouse && UnityEvent.current.button == 1 && rect.Contains(UnityEvent.current.mousePosition))
+            var btnRect = rect;
+            
+            // btnRect.x = 4f;
+            // btnRect.width = 24f; //btnRect.xMax - 
+            // btnRect.yMin = btnRect.yMax - 32f;
+            
+            btnRect.xMin = btnRect.xMax - 24f; 
+            btnRect.yMin = btnRect.yMax - 32f;
+            
+            if (hamburgerIcon == null) hamburgerIcon = EditorGUIUtility.IconContent("d__Menu@2X");
+            if (GUI.Button(btnRect, hamburgerIcon.image, EditorStyles.label))
             {
-                var menu = new GenericMenu();
-                menu.AddDisabledItem(new GUIContent("AmaGDK"));
-                menu.AddSeparator("");
-                menu.AddItem(new GUIContent("Auto Init"), sdk.autoInit, () =>
-                {
-                    sdk.autoInit = !sdk.autoInit;
-                    EditorUtility.SetDirty(sdk);
-                });
-                menu.AddItem(new GUIContent("Clear Cache"), false, () =>
-                {
-                    GDKFileUtils.ClearCacheData();
-                });
-                menu.ShowAsContext();
-                UnityEvent.current.Use();
+                ShowAmaGDKContext();
             }
         }
 
@@ -306,8 +349,10 @@ namespace Amanotes.Editor
 
             configSO = new SerializedObject(configAsset);
             configSO.Update();
-            DrawProperty(configSO, "common");
-            EditorGUILayout.ObjectField("Config", configAsset, typeof(ScriptableObject), false);
+            DrawProperty(configSO, "common", true);
+            DrawProperty(configSO, "enableAudioModule", false);
+            DrawProperty(configSO, "enableServerTime", false);
+            DrawProperty(configSO, "enableGeoLocation", false);
             GUILayout.Space(8f);
             for (var i = 0; i < allAdapters.Count; i++)
             {
@@ -318,6 +363,7 @@ namespace Amanotes.Editor
             
             AmaGUI.Foldout("Adapters", ref showAdapterInstaller, DrawGUI_AdapterList);
             AmaGUI.Foldout("Extras", ref showExtra, DrawGUI_ExtraList);
+            EditorGUILayout.ObjectField("Config", configAsset, typeof(ScriptableObject), false);
             Profiler.EndSample();
         }
 
@@ -401,7 +447,7 @@ namespace Amanotes.Editor
 
             }, () =>
             {
-                if (icon != null)
+                if (icon != null && adapter != null && adapter.enabled)
                 {
                     Rect rect = GUILayoutUtility.GetRect(6f, 6f, 16f, 16f);
                     rect.xMin -= 10f;
@@ -487,7 +533,7 @@ namespace Amanotes.Editor
             EditorGUI.BeginDisabledGroup(!adapter.enabled);
             EditorGUIUtility.labelWidth += 70;
             {
-                DrawProperty(configSO, adapterId);
+                DrawProperty(configSO, adapterId, true);
                 GUILayout.Space(8f);
 
                 if (adapterId == IRONSOURCE)
@@ -515,11 +561,20 @@ namespace Amanotes.Editor
             EditorGUI.EndDisabledGroup();
         }
 
-        private static void DrawProperty(SerializedObject so, string propertyField)
+        private static void DrawProperty(SerializedObject so, string propertyField, bool childrenOnly)
         {
             SerializedProperty property = so.FindProperty(propertyField);
-            if (property == null) return;
+            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))

package/Editor/AmaGDKExtra.cs

@@ -7,20 +7,21 @@ namespace Amanotes.Editor
     {
         public static Dictionary<string, object> GetThirdPartyVersions()
         {
-            Dictionary<string, object> dicThirdParty = new Dictionary<string, object>();
-            List<GDKModule> listModule = VersionHelper.LoadLocalModuleInfo();
-            foreach (var module in listModule)
+            var dicThirdParty = new Dictionary<string, object>
             {
-                VersionHelper.UpdateListVersions(module);
-                dicThirdParty.Add(module.id, ExtractVersion.ThirdParty(module.id));
-            }
-
-            dicThirdParty["Firebase"] =  AmaGDKExtra.FirebaseVersion();
-            dicThirdParty["AmaGDK"] = AmaGDK.VERSION;
-            dicThirdParty["AdQuality"] = ExtractVersion.IronSourceAdQuality();
-            dicThirdParty["AdRevenue"] = ExtractVersion.AppsFlyerAdRevenue();
-            dicThirdParty["ACM"] = ExtractVersion.Acm();
-            dicThirdParty["FacebookSDK"] = ExtractVersion.Facebook();
+                ["FirebaseAnalytics"] = ExtractVersion.FirebaseAnalytics(),
+                ["FirebaseRemoteConfig"] = ExtractVersion.FirebaseRemoteConfig(),
+                ["AppsFlyer"] = ExtractVersion.AppsFlyer(),
+                ["IronSource"] = ExtractVersion.IronSource(),
+                ["Max"] = ExtractVersion.Max(),
+                ["RevenueCat"] = ExtractVersion.RevenueCat(),
+                ["Firebase"] = AmaGDKExtra.FirebaseVersion(),
+                ["AmaGDK"] = AmaGDK.VERSION,
+                ["AdQuality"] = ExtractVersion.IronSourceAdQuality(),
+                ["AdRevenue"] = ExtractVersion.AppsFlyerAdRevenue(),
+                ["ACM"] = ExtractVersion.Acm(),
+                ["FacebookSDK"] = ExtractVersion.Facebook()
+            };
             
             return dicThirdParty;
         }

package/Editor/Extra/GDKAutoUpdateAdapter.cs

@@ -23,11 +23,23 @@ namespace Amanotes.Editor
             // Extra packages
             { "DiskSpacePopup", $"{Res.EXTRA_PATH}CheckDiskSpace.unitypackage" },
             { "ForceUpdatePopup", $"{Res.EXTRA_PATH}ForceUpdate.unitypackage" },
-            { "GoogleCMPSupport", $"{Res.EXTRA_PATH}GoogleCMP.unitypackage" },
+            { "Consent.ATTSupport", $"{Res.EXTRA_PATH}Consent.unitypackage" },
+            { "Consent.GoogleCMPSupport", $"{Res.EXTRA_PATH}Consent.unitypackage" },
             { "AndroidPostProcessor", $"{Res.EXTRA_PATH}PostProcessor.unitypackage" }
         };
         
         private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            #if AMAGDK_DEV
+            return;
+            #endif
+            
+            #pragma warning disable CS0162
+            CheckImportedAssets(importedAssets);
+            #pragma warning restore CS0162
+        }
+
+        private static void CheckImportedAssets(string[] importedAssets)
         {
             if (importedAssets.Length == 0) return;
             // Debug.LogWarning($"importedAssets: {string.Join("\n", importedAssets)}");
@@ -53,6 +65,7 @@ namespace Amanotes.Editor
                     continue;
                 }
                 
+                if (packages.Contains(kvp.Value)) continue;
                 packages.Add(kvp.Value);
             }   
             

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