com.amanotes.gdk 0.1.9 → 0.1.11

package/Editor/Utils/AmaGDKEditor.GUI.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.Editor
+{
+    public static class GUI
+    {
+        static Color LIGHT_BLUE = new Color(0.25f, 0.5f, 1f);
+        
+        static GUIStyle BIG_LABEL = null;
+
+        public static void SectionLabel(string text)
+        {
+            if (BIG_LABEL == null)
+            {
+                BIG_LABEL = new GUIStyle(UnityEngine.GUI.skin.label)
+                {
+                    fontSize = 18,
+                    alignment = TextAnchor.MiddleCenter,
+                    richText = true
+                };
+
+                BIG_LABEL.normal.textColor = Color.white;
+            }
+            
+            Rect rect = GUILayoutUtility.GetRect(Screen.width, 32);
+            rect.xMin -= 16f;
+            EditorGUI.DrawRect(rect, LIGHT_BLUE);
+            EditorGUI.LabelField(rect, text, BIG_LABEL);
+        }
+
+        public static bool BigButton(string label, float height = 16f, Color? color = null, float colorMod = 0.5f)
+        {
+            var bgColor = UnityEngine.GUI.backgroundColor;
+
+            bool result;
+            if (color != null)
+            {
+                var c = (colorMod < 0f) ? Color.Lerp(color.Value, Color.black, -colorMod)
+                        : (colorMod > 0f) ? Color.Lerp(color.Value, Color.white, colorMod) : color.Value;
+                UnityEngine.GUI.backgroundColor = c;
+            }
+            {
+                result = GUILayout.Button(label, GUILayout.Height(height));
+            }
+            if (color != null) UnityEngine.GUI.backgroundColor = bgColor;
+            return result;
+        }
+
+        public static bool Toggle(string label, ref bool value)
+        {
+            var newValue = EditorGUILayout.Toggle(label, value);
+            if (newValue == value) return false;
+
+            value = newValue;
+            return true;
+        }
+
+        public static bool ToggleGroup(string label, ref bool isOpen, Action drawFunc, Action titleFunc = null){
+            GUILayout.BeginHorizontal();
+            var newValue = EditorGUILayout.Foldout(isOpen, label);
+            var changed = newValue != isOpen;
+            titleFunc?.Invoke();
+            GUILayout.EndHorizontal();
+
+            if (isOpen)
+            {
+                EditorGUI.indentLevel++;
+                drawFunc();
+                EditorGUI.indentLevel--;
+            }
+
+            if (!changed) return false;
+
+            isOpen = newValue;
+            return true;
+        }
+    }
+}

package/Editor/Utils/AmaGDKEditor.GUI.cs.meta

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

package/Editor/Utils/AmaGDKEditor.Utils.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections;
+using UnityEditor;
+using UnityEngine;
+
+namespace Amanotes.Editor
+{
+    public static class Utils
+    {
+        public static void StartEditorCoroutine(this IEnumerator update, Action end = null)
+        {
+            EditorApplication.CallbackFunction closureCallback = null;
+
+            closureCallback = () =>
+            {
+                try
+                {
+                    if (update.MoveNext() == false)
+                    {
+                        end?.Invoke();
+                        EditorApplication.update -= closureCallback;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    end?.Invoke();
+                    Debug.LogException(ex);
+                    EditorApplication.update -= closureCallback;
+                }
+            };
+
+            EditorApplication.update += closureCallback;
+        }
+    }
+}

package/Editor/Utils/AmaGDKEditor.Utils.cs.meta

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

package/{Runtime/Interfaces/Analytics.meta → Editor/Utils.meta}

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: d1a686515ec7946df9492f35e9638fea
+guid: 61beaa5df6bc4435b9a397f7bdd79ab7
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

package/Packages/AmaGDKExample.unitypackage.meta

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

package/Packages/AppsflyerAdapter_v6.5.4.unitypackage.meta

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

package/Packages/IronsourceAdapter_v7.2.6.unitypackage

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:313276bb7dcfb6c5dc1a760945f89b413282c7329d1b4856e777c6aee75cc22e
+size 1635

package/Packages/IronsourceAdapter_v7.2.6.unitypackage.meta

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

package/Runtime/AmaGDK.Ads.cs

@@ -0,0 +1,235 @@
+using System;
+using System.Collections;
+
+using UnityEngine;
+
+using Amanotes.Core.Internal;
+using static Amanotes.Core.Internal.Logging;
+
+namespace Amanotes.Core
+{
+    public interface IAds
+    {
+        bool IsAdReady(AdType Type);
+
+        #region Interstitial   
+        event Action InterstitialShowSucceededCallback;
+        event Action InterstitialShowFailedCallback;
+        event Action InterstitialClickedCallback;
+        void RequestInterstitial();
+        void ShowInterstitial();
+        void ShowInterstitial(string placementName);
+        #endregion FullAds
+
+        #region VideoAds     
+        event Action RewardedVideoShowFailedCallback;
+        event Action RewardedVideoClosedCallback;
+        event Action RewardedCallback;
+        event Action RewardedVideoClickCallback;
+        void RequestRewardedVideo();
+        void ShowRewardedVideo();
+        void ShowRewardedVideo(string placementName);
+        #endregion VideoAds
+
+        #region Banner
+        event Action BannerAdsClickCallback;
+        event Action BannerShowCallback;        
+        void RequestBanner(BannerPosition position = BannerPosition.TOP);
+        void RequestBanner(BannerPosition position, string placementName);
+        void ShowBanner();
+        void HideBanner();
+        #endregion Banner
+    }
+
+    public enum BannerPosition
+    {
+        TOP = 1,
+        BOTTOM = 2
+    };
+
+    public enum AdType : byte
+    {
+        Interstitial,
+        Reward,
+        Banner
+    };
+
+    public partial class AmaGDK // IAds module
+    {
+        public static class Ads
+        {
+            internal static IAds adsModule;
+            public static Action<string> OnInterstitalFailCallback;
+            public static Action<string> OnRewardedVideoFailCallback;
+
+            public static void Init()
+            {
+                var adsModules = Adapter.FindAll<IAds>();
+
+                if (adsModules == null || adsModules.Count < 1)
+                {
+                    LogError("Ads module not found!");
+                    return;
+                }
+                
+                if (adsModules.Count > 1)
+                {
+                    LogError("Multiple Ads modules is not supported!");
+                    return;
+                }
+                
+                adsModule = adsModules[0].GetAdapterApi<IAds>();
+            }
+
+            public static void RequestBanner(BannerPosition position)
+            {
+                if (adsModule == null)
+                {
+                    LogWarning("Ads module is not initialized");
+                    return;
+                }
+                adsModule.RequestBanner(position);
+            }
+
+            public static void ShowBanner()
+            {
+                adsModule.ShowBanner();
+            }
+
+            public static void HideBanner()
+            {
+                if (!adsModule.IsAdReady(AdType.Banner))
+                {
+                    LogWarning("Banner is not ready");
+                    return;
+                }
+
+                adsModule.HideBanner();
+            }
+
+            public static void RequestInterstitial()
+            {
+                if (adsModule == null)
+                {
+                    LogWarning("Ads module is not initialized");
+                    return;
+                }
+                adsModule.RequestInterstitial();
+            }
+
+            public static void ShowInterstitial()
+            {
+                if (!adsModule.IsAdReady(AdType.Interstitial))
+                {
+                    LogWarning("Interstitial is not ready");
+                    BeginCoroutine(IWaitShowInterstitial());
+                    return;
+                }
+                adsModule.ShowInterstitial();
+            }
+
+            public static void RequestRewardedVideo()
+            {
+                if (adsModule == null)
+                {
+                    LogWarning("Ads module is not initialized");
+                    return;
+                }
+                adsModule.RequestRewardedVideo();
+            }
+
+            public static void ShowRewardedVideo()
+            {
+                if (!adsModule.IsAdReady(AdType.Reward))
+                {
+                    LogWarning("Reward is not ready");
+                    BeginCoroutine(IWaitShowRewardedVideo());
+                    return;
+                }
+                adsModule.ShowRewardedVideo();
+            }
+
+            private static IEnumerator IWaitShowRewardedVideo()
+            {
+                LogWarning("Wait Show Rewarded Video");
+                if (adsModule == null)
+                {
+                    OnRewardedVideoFailCallback?.Invoke("Not found ads module");
+                    OnRewardedVideoFailCallback = null;
+                    yield break;
+                }
+
+                var startTime = Time.time;
+                float timeout = 5;
+                string error = null;
+                while (!adsModule.IsAdReady(AdType.Reward))
+                {
+                    if (Application.internetReachability == NetworkReachability.NotReachable)
+                    {
+                        error = Application.internetReachability.ToString();
+                        break;
+                    }
+
+                    if ((Time.time - startTime) > timeout)
+                    {
+                        error = "Timeout";
+                        break;
+                    }
+
+                    yield return null;
+                }
+
+                if (adsModule.IsAdReady(AdType.Reward))
+                {
+                    adsModule.ShowRewardedVideo();
+                }
+                else
+                {
+                    OnRewardedVideoFailCallback?.Invoke(error);
+                    OnRewardedVideoFailCallback = null;
+                }
+            }
+
+            private static IEnumerator IWaitShowInterstitial()
+            {
+                LogWarning("Wait Show Interstitial");
+                if (adsModule == null)
+                {
+                    OnInterstitalFailCallback?.Invoke("Not found ads module");
+                    OnInterstitalFailCallback = null;
+                    yield break;
+                }
+
+                var startTime = Time.time;
+                float timeout = 5;
+                string error = null;
+                while (!adsModule.IsAdReady(AdType.Interstitial))
+                {
+                    if (Application.internetReachability == NetworkReachability.NotReachable)
+                    {
+                        error = Application.internetReachability.ToString();
+                        break;
+                    }
+
+                    if ((Time.time - startTime) > timeout)
+                    {
+                        error = "Timeout";
+                        break;
+                    }
+
+                    yield return null;
+                }
+
+                if (adsModule.IsAdReady(AdType.Interstitial))
+                {
+                    adsModule.ShowInterstitial();
+                }
+                else
+                {
+                    OnInterstitalFailCallback?.Invoke(error);
+                    OnInterstitalFailCallback = null;
+                }
+            }
+        }
+    }
+}

package/Runtime/AmaGDK.Ads.cs.meta

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

package/Runtime/AmaGDK.Analytics.cs

@@ -8,7 +8,22 @@ using IEventParamsBuilder = Amanotes.Core.AmaGDK.Analytics.IEventParamsBuilder;
 using EventParams = Amanotes.Core.AmaGDK.Analytics.EventParams;
 
 namespace Amanotes.Core
-{    
+{
+    [Serializable]
+    public class AnalyticsAdapterBaseConfig
+    {
+        public bool SendEventByDefault;
+        public List<string> NeverSend;
+        public List<string> AlwaysSend;
+
+        public bool AllowSend(string eventName)
+        {
+            return SendEventByDefault
+                ? !NeverSend.Contains(eventName)
+                : AlwaysSend.Contains(eventName);
+        }
+    }
+
     partial class AmaGDK
     {
         //PUBLIC APIS
@@ -22,6 +37,7 @@ namespace Amanotes.Core
                 public Dictionary<string, object> parameters = new Dictionary<string, object>();
                 public string funnelSignature;
                 public bool accumulated;
+                public bool withinSession;
                 public HashSet<string> ignoreAnalyticIds = new HashSet<string>();
                 public HashSet<string> allowAnalyticIds = new HashSet<string>();
 
@@ -51,15 +67,36 @@ namespace Amanotes.Core
                 return result;
             }
 
+            public static IEventParamsBuilder LogEvent(string eventName, params (string, object)[] parameters)
+            {
+                var result = new EventParams(eventName);
+                for (var i = 0;i < parameters.Length; i++)
+                {
+                    result.AddParam(parameters[i].Item1, parameters[i].Item2);
+                }
+                eventQueue.Enqueue(result);
+                return result;
+            }
+
             public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "")
             {
                 return LogEvent(eventName).SetAsFunnel(signature);
             }
 
-            public static int GetAccumulatedCount(string eventName)
+            public static IEventParamsBuilder LogFunnelEvent(string eventName, Dictionary<string, object> parameters, string signature = "")
+            {
+                return LogEvent(eventName, parameters).SetAsFunnel(signature);
+            }
+
+            public static IEventParamsBuilder LogFunnelEvent(string eventName, string signature = "", params (string, object)[] parameters)
+            {
+                return LogEvent(eventName, parameters).SetAsFunnel(signature);
+            }
+
+            public static int GetAccumulatedCount(string eventName, bool withinSession = false)
             {
                 var eventDetail = localData.GetEventDetail(eventName);
-                return eventDetail != null ? eventDetail.count : 0;
+                return eventDetail != null ? (withinSession ? eventDetail.countInSession : eventDetail.totalCount) : 0;
             }
 
             public static void SetLogEventCondition(Predicate<EventDetail> condition)
@@ -116,20 +153,20 @@ namespace Amanotes.Core
                         localData.eventDetails.Add(new EventDetail
                         {
                             eventName = e.Key,
-                            count = e.Value
+                            totalCount = e.Value
                         });
                         flag |= IntegrityFlag.NewEvent;
                         continue;
                     }
 
-                    if (eventDetail.count != e.Value)
+                    if (eventDetail.totalCount != e.Value)
                     {
                         flag |= IntegrityFlag.DifferentCount;
                     }
 
                     if (sumEventCount)
                     {
-                        eventDetail.count += e.Value;
+                        eventDetail.totalCount += e.Value;
                     }
                 }
 
@@ -169,10 +206,13 @@ namespace Amanotes.Core
             internal static readonly List<AdapterInfo> listAdapters = new List<AdapterInfo>();
             internal static readonly AnalyticsData localData = new AnalyticsData().LoadJsonFromFile();
 
-            internal static void GetAnalyticAdapters()
+            internal static void Init()
             {
                 listAdapters.Clear();
                 listAdapters.AddRange(Adapter.FindAll<IAnalyticAdapter>());
+
+                _frameUpdate -= ProcessEventQueue;
+                _frameUpdate += ProcessEventQueue;
             }
 
             internal static void ProcessEventQueue()
@@ -187,22 +227,24 @@ namespace Amanotes.Core
                     if (!NormalizeEventName(ref eventData.eventName))
                         continue;
 
-                    var counter = localData.IncreaseCounter(eventData.eventName);
+                    var (countInSession, totalCount) = localData.IncreaseCounter(eventData.eventName);
 
                     if (!ShouldSendEvent(eventData))
                         continue;
 
                     if (eventData.accumulated)
                     {
-                        eventData.AddParam("accumulated_count", counter);
+                        eventData.AddParam("accumulated_count", eventData.withinSession ? countInSession : totalCount);
                     }
 
                     foreach (var m in listAdapters)
                     {
+                        if (!eventData.allowAnalyticIds.Contains(m.id))
+                            continue;
                         if (eventData.ignoreAnalyticIds.Contains(m.id))
                             continue;
                         m.GetAdapterApi<IAnalyticAdapter>().LogEvent(eventData);
-                        if (showAnalyticsLog) Debug.Log($"[{m.id}] Sent event <{eventData.eventName}> ({counter})");
+                        if (showAnalyticsLog) Debug.Log($"[{m.id}] Sent event <{eventData.eventName}> (in session: {countInSession}, total: {totalCount})");
                     }
                 }
 
@@ -263,8 +305,10 @@ namespace Amanotes.Core
             [Serializable]
             public class EventDetail
             {
-                public string eventName;
-                public int count;
+                public string eventName;                
+                [NonSerialized]
+                public int countInSession;
+                public int totalCount;
             }
 
             [Flags]
@@ -330,12 +374,13 @@ namespace Amanotes.Core
                     return true;
                 }
 
-                internal int IncreaseCounter(string eventName)
+                internal (int countInSession, int totalCount) IncreaseCounter(string eventName)
                 {
                     var result = GetEventDetail(eventName, true);
-                    result.count++;
+                    result.countInSession++;
+                    result.totalCount++;                    
                     _dirty = true;
-                    return result.count;
+                    return (result.countInSession, result.totalCount);
                 }
 
                 internal void SaveIfDirty()
@@ -383,11 +428,13 @@ namespace Amanotes.Core
             data.funnelSignature = string.IsNullOrEmpty(signature) ? data.eventName : signature;
             return ap;
         }
-        public static IEventParamsBuilder SetAsAccumulated(this IEventParamsBuilder ap)
+        public static IEventParamsBuilder SetAsAccumulated(this IEventParamsBuilder ap, bool withinSession = false)
         {
             if (ap == null) return null;
 
-            (ap as EventParams).accumulated = true;
+            EventParams data = ap as EventParams;
+            data.accumulated = true;
+            data.withinSession = withinSession;
             return ap;
         }
 
@@ -450,6 +497,23 @@ namespace Amanotes.Core
             return ap;
         }
 
+        public static IEventParamsBuilder AddParam(this IEventParamsBuilder ap, params (string key, object value)[] parameters)
+        {
+            if (ap == null) return null;
+            if (parameters.Length == 0)
+            {
+                LogWarning($"Param tuple is null. Event name: {(ap as EventParams).eventName}!");
+                return ap;
+            }
+
+            foreach (var kvp in parameters)
+            {
+                if (IsValidKeyValue(ap, kvp.key, kvp.value))
+                    ap.AddParam(kvp.key, kvp.value);
+            }
+            return ap;
+        }
+
         static bool IsValidKeyValue(IEventParamsBuilder ap, string key, object value)
         {
             string eventName = (ap as EventParams).eventName;

package/Runtime/AmaGDK.Internal.cs

@@ -5,6 +5,10 @@ using System.Collections.Generic;
 using UnityEngine;
 using UnityObject = UnityEngine.Object;
 
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
 namespace Amanotes.Core.Internal
 {
     public enum Status
@@ -38,8 +42,29 @@ namespace Amanotes.Core.Internal
         public static readonly string[] AMAGDK_ADAPTERS = new string[]
         {
             "FirebaseAnalyticsAdapter_v9.1.0",
-            //"AppsflyerAdapter_v6.5.4",
+            "AppsflyerAdapter_v6.5.4",
+            // "IronsourceAdapter_v7.2.6",
         };
+
+#if UNITY_EDITOR
+
+        [MenuItem("GameObject/AmaGDK/Add AmaGDK Prefab", false, 10)]
+        private static void AddAmaGDKPrefab()
+        {
+            GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(AMAGDK_PREFAB);
+            if (prefab == null)
+            {
+                Debug.LogWarning($"Prefab [AmaGDK] not found at: {AMAGDK_PREFAB}");
+                return;
+            }
+
+            GameObject newPrefab = PrefabUtility.InstantiatePrefab(prefab) as GameObject;
+            newPrefab.name = "AmaGDK";
+            newPrefab.transform.SetAsLastSibling();
+            Selection.activeObject = null;
+            Selection.activeObject = newPrefab;
+        }
+#endif
     }