com.amanotes.gdk 0.2.65-2 → 0.2.65-4

package/Editor/Extra/GDKLocalBuild.cs

@@ -148,34 +148,7 @@ namespace Amanotes.Editor
         {
             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();
 
@@ -322,9 +295,9 @@ namespace Amanotes.Editor
             public Texture2D buildIcon;
             public BuildTarget target;
 
-            public bool isAAB;
-            public bool splitAPK = true;
-            public bool overwrite = true;
+            // public bool isAAB;
+            // public bool splitAPK = true;
+            // public bool overwrite = true;
             public string buildVersion;
             public int buildNumber;
 
@@ -348,10 +321,10 @@ namespace Amanotes.Editor
                 if (isAndroid)
                 {
                     PlayerSettings.Android.bundleVersionCode = buildNumber;
-                    PlayerSettings.Android.buildApkPerCpuArchitecture = splitAPK;
+                    PlayerSettings.Android.buildApkPerCpuArchitecture = false;//splitAPK;
                     PlayerSettings.Android.targetArchitectures = AndroidArchitecture.ARM64 | AndroidArchitecture.ARMv7;
-                    
-                    EditorUserBuildSettings.buildAppBundle = isAAB;
+
+                    EditorUserBuildSettings.buildAppBundle = false;//isAAB;
                     EditorUserBuildSettings.exportAsGoogleAndroidProject = false;
                     
                     #if UNITY_2021_1_OR_NEWER
@@ -368,7 +341,7 @@ namespace Amanotes.Editor
                         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);
+                        if (File.Exists(apkName)) File.Delete(apkName);
                     }
 
                     return;
@@ -377,8 +350,6 @@ namespace Amanotes.Editor
                 if (isIOS)
                 {
                     PlayerSettings.iOS.buildNumber = buildNumber.ToString();
-                    if (!overwrite) return;
-
                     string path = fullBuildPath(buildFolder);
                     if (Directory.Exists(path)) Directory.Delete(path, true);
                     return;
@@ -392,17 +363,17 @@ namespace Amanotes.Editor
                 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")
-                    };
+                // 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[]
                 {
@@ -413,7 +384,7 @@ namespace Amanotes.Editor
             public void PostProcessBuild(string buildFolder)
             {
                 if (target != BuildTarget.Android) return;
-                if (isAAB) return;
+                // if (isAAB) return;
 
                 // var productName = Application.productName;
                 string[] listAPKNames = GetAPKNames(buildFolder);
@@ -439,8 +410,8 @@ namespace Amanotes.Editor
 
                 if (isAndroid)
                 {
-                    if (isAAB) return Path.Combine(buildDir.FullName, buildName + ".aab");
-                    if (splitAPK) return buildDir.FullName;
+                    // if (isAAB) return Path.Combine(buildDir.FullName, buildName + ".aab");
+                    // if (splitAPK) return buildDir.FullName;
                     return Path.Combine(buildDir.FullName, buildName + ".apk");
                 }
 
@@ -737,15 +708,11 @@ namespace Amanotes.Editor
                     {
                         new GDKLocalBuild.BuildInfo
                         {
-                            target = BuildTarget.Android, isAAB = false, splitAPK = true
-                        }.Read(),
-                        new GDKLocalBuild.BuildInfo
-                        {
-                            target = BuildTarget.Android, isAAB = true, splitAPK = true
+                            target = BuildTarget.Android
                         }.Read(),
                         new GDKLocalBuild.BuildInfo
                         {
-                            target = BuildTarget.iOS, isAAB = true, splitAPK = true
+                            target = BuildTarget.iOS
                         }.Read()
                     };
                 }

package/Runtime/AmaGDK.Analytics.cs

@@ -1100,8 +1100,14 @@ namespace Amanotes.Core.Internal
         [HideInNormalInspector] public bool checkMigrationIntegrity = true;
         [HideInNormalInspector] public bool migrateAccumulatedCount = true;
         [HideInNormalInspector] public bool enableEventStat;
-        [HideInNormalInspector] public List<string> immediatelyLoggedEvents = new List<string>(){"ad_impression", "ad_impression_ama"};
-        public AnalyticQualityConfig quality;
+        [HideInInspector] public List<string> immediatelyLoggedEvents = new List<string>()
+        {
+            "ad_impression",
+            "ad_impression_ama",
+            "fullads_impression",
+            "videoads_impression",
+        };
+        public AnalyticQualityConfig quality = new AnalyticQualityConfig();
     }
     
     [Serializable]
@@ -1126,8 +1132,8 @@ namespace Amanotes.Core.Internal
     
     public abstract class AnalyticsAdapter : Adapter2
     {
-        [HideInNormalInspector] public List<string> NeverSend = new List<string>();
-        [HideInNormalInspector] public List<string> AlwaysSend = new List<string>();
+        [HideInInspector] public List<string> NeverSend = new List<string>();
+        [HideInInspector] public List<string> AlwaysSend = new List<string>();
         protected abstract bool SendEventByDefault { get; }
         
         public bool IsForbidden(string eventName)

package/Runtime/AmaGDK.Mono.cs

@@ -17,8 +17,6 @@ namespace Amanotes.Core
         
         private void Update()
         {
-            if (!isReady) return;
-            
             time = Time.time;
             realtimeSinceStartup = Time.realtimeSinceStartup;
 

package/Runtime/AmaGDK.UserProfile.cs

@@ -158,7 +158,7 @@ namespace Amanotes.Core
                 set
                 {
                     var pattern = ALPHANUMERIC_HYPHEN_PATTERN;
-#if UNITY_ANDROID && !UNITY_EDITOR
+#if UNITY_ANDROID && !UNITY_EDITOR_OSX
                     pattern = ALPHANUMERIC_PATTERN;
 #endif
                     if (!ValidateId(value, pattern))

package/Runtime/AmaGDK.cs

@@ -17,7 +17,7 @@ namespace Amanotes.Core
 {
     public partial class AmaGDK : MonoBehaviour
     {
-        public const string VERSION = "0.2.65-2";
+        public const string VERSION = "0.2.65-4";
         
         internal static Status _status = Status.None;
         private static ConfigAsset _config = null;
@@ -102,6 +102,7 @@ namespace Amanotes.Core
                 Ads.InitModule();
                 IAP.InitModule();
                 RemoteConfig.InitModule();
+                Audio.InitModule();
             }
             Profiler.EndSample();
         }

package/Runtime/AudioToolkit/AmaGDK.Audio.Latency.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections;
+using Amanotes.Core.Internal;
+using UnityEngine;
+
+namespace Amanotes.Core
+{
+    internal class DeviceLatency
+    {
+        internal string deviceName;
+        internal int latencyIOS;
+        internal int latencyAndroid;
+
+        private DeviceLatency(string deviceName, int latencyIOS, int latencyAndroid)
+        {
+            this.deviceName = deviceName;
+            this.latencyIOS = latencyIOS;
+            this.latencyAndroid = latencyAndroid;
+        }
+
+        internal static DeviceLatency FromTSVString(string tsvLine)
+        {
+            string[] cols = tsvLine.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
+
+            string name = cols.Length > 0 ? cols[0] : "";
+            int iosLatency = ParseLatency(cols, 1);
+            int androidLatency = ParseLatency(cols, 2);
+
+            return new DeviceLatency(name, iosLatency, androidLatency);
+        }
+
+        internal int GetSimilarityScore(string[] token)
+        {
+            int result = 0;
+            string lowerLongString = deviceName.ToLower();
+            for (int i = 0, n = token.Length; i < n; i++)
+            {
+                string word = token[i];
+                if (word.Length < 2) continue;
+                if (lowerLongString.Contains(word))
+                {
+                    result++;
+                }
+            }
+
+            return result;
+        }
+
+        private static int ParseLatency(string[] cols, int index)
+        {
+            int latency = 0;
+            if (cols.Length > index)
+            {
+                int.TryParse(cols[index], out latency);
+            }
+
+            return latency;
+        }
+    }
+    public partial class AmaGDK
+    {
+        public partial class Audio
+        {
+            private const string PREF_AUDIO_LATENCY = "AUDIO_LATENCY_";
+            private const int ANDROID_DEFAULT_LATENCY_FOR_HEADSET = 400;
+            private const int IOS_DEFAULT_LATENCY_FOR_HEADSET = 200;
+            private const int DEFAULT_FOR_SPEAKER = 30;
+
+            private static DeviceLatency[] _deviceLatency;
+
+            private static int GetAudioDeviceLatency()
+            {
+                if (!IsConnectingBluetoothHeadset())
+                {
+                    return DEFAULT_FOR_SPEAKER;
+                }
+
+                string deviceName = DeviceInfo.Name;
+                int savedLatency = PlayerPrefs.GetInt(PREF_AUDIO_LATENCY + deviceName, -1);
+
+                if (savedLatency >= 0)
+                {
+                    return savedLatency;
+                }
+
+                int result = GetLatencyByDevice(deviceName);
+
+                if (result <= 0)
+                {
+                    return GetDefaultLatency();
+                }
+
+                SaveLatencyValue(deviceName, result);
+                return result;
+            }
+
+            private static int GetDefaultLatency()
+            {
+                int result = DEFAULT_FOR_SPEAKER;
+#if UNITY_ANDROID
+                result = ANDROID_DEFAULT_LATENCY_FOR_HEADSET;
+#else
+                result = IOS_DEFAULT_LATENCY_FOR_HEADSET;
+#endif
+                return result;
+            }
+
+            private static void SaveLatencyValue(string deviceName, int latency)
+            {
+                PlayerPrefs.SetInt(PREF_AUDIO_LATENCY + deviceName, latency);
+                PlayerPrefs.Save();
+            }
+
+            private static void Initialize()
+            {
+                if (_deviceLatency != null) return;
+                _deviceLatency = LoadDeviceLatencyData();
+            }
+
+            private static DeviceLatency[] LoadDeviceLatencyData()
+            {
+                DeviceLatency[] result = Array.Empty<DeviceLatency>();
+
+                TextAsset textAsset = Resources.Load<TextAsset>("device-latency");
+                if (textAsset == null)
+                    return result;
+
+                string[] lines = textAsset.text.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                result = new DeviceLatency[lines.Length - 1];
+
+                for (int i = 1; i < lines.Length; i++)
+                {
+                    DeviceLatency device = DeviceLatency.FromTSVString(lines[i]);
+                    result[i - 1] = device;
+                }
+
+                return result;
+            }
+
+            private static int GetLatencyByDevice(string deviceName)
+            {
+                Initialize();
+                int result = 0;
+                int maxSimilar = 0;
+                string[] tokens = deviceName.Trim().ToLower()
+                    .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
+                for (int i = 0, n = _deviceLatency.Length; i < n; i++)
+                {
+                    DeviceLatency device = _deviceLatency[i];
+                    int similar = device.GetSimilarityScore(tokens);
+                    if (similar <= maxSimilar)
+                        continue;
+                    maxSimilar = similar;
+#if UNITY_ANDROID
+                    result = device.latencyAndroid;
+#else
+                    result = device.latencyIOS;
+#endif
+                }
+
+                return result;
+            }
+        }
+    }
+}

package/Runtime/AudioToolkit/AmaGDK.Audio.Latency.cs.meta

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

package/Runtime/AudioToolkit/AmaGDK.Audio.cs

@@ -0,0 +1,158 @@
+using UnityEngine;
+using System;
+using System.Collections;
+using System.Text;
+using Amanotes.Core.Internal;
+
+namespace Amanotes.Core
+{
+    public partial class AmaGDK
+    {
+        internal static partial class Event
+        {
+            public const string GDK_AUDIO_INFO_CHANGE = nameof(GDK_AUDIO_INFO_CHANGE);
+            public const string GDK_AUDIO_INTERRUPT_BEGIN = nameof(GDK_AUDIO_INTERRUPT_BEGIN);
+            public const string GDK_AUDIO_INTERRUPT_END = nameof(GDK_AUDIO_INTERRUPT_END);
+        }
+        public class AudioDeviceInfo
+        {
+            internal AudioDeviceType Type;
+            internal string RawType;
+            public string Name;
+            public int LatencyMs;
+        }
+        // Public Usage
+        public partial class Audio
+        {
+            public static AudioDeviceInfo DeviceInfo;
+
+            private static readonly AudioDeviceInfo NO_DEVICE = new AudioDeviceInfo()
+            {
+                LatencyMs = DEFAULT_FOR_SPEAKER
+            };
+
+            /// <remarks>
+            /// The <paramref name="onAudioDeviceChange"/> action takes two parameters:
+            /// <list type="bullet">
+            /// <item><term><c>bool</c></term><description> :  <c>True</c> indicates that an audio device has been added - <c>False</c> indicates that an audio device has been removed.</description></item>
+            /// <item><term><c>string</c> : the name of the audio device.</term></item>
+            /// </list>
+            /// </remarks>
+            public static void SetOnAudioDeviceChangeCallback(Action<AudioDeviceInfo> onAudioDeviceChange)
+            {
+                if (onAudioDeviceChange == null)
+                {
+                    Logging.LogWarning("Cannot add a null callback!");
+                    return;
+                }
+
+                dispatcher.AddListener(Event.GDK_AUDIO_INFO_CHANGE, onAudioDeviceChange, false);
+            }
+
+            public static void SetOnAudioInterruptedCallback(Action beginCallback, Action endCallback)
+            {
+                if (beginCallback != null)
+                {
+                    dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_BEGIN, beginCallback, false);
+                }
+
+                if (endCallback != null)
+                {
+                    dispatcher.AddListener(Event.GDK_AUDIO_INTERRUPT_END, endCallback, false);
+                }
+            }
+        }
+
+        // Detector
+        public partial class Audio
+        {
+            private static AudioDeviceDetector _audioDeviceDetector;
+
+            internal static void InitModule()
+            {
+                _audioDeviceDetector = _instance.gameObject.AddComponent<AudioDeviceDetector>();
+                _audioDeviceDetector.RegisterEvents();
+                RegisterCallbacks();
+
+                DeviceInfo = DetectAudioInfo();
+                DeviceInfo.LatencyMs = GetAudioDeviceLatency();
+            }
+
+            private static AudioDeviceInfo DetectAudioInfo()
+            {
+                if (_audioDeviceDetector == null)
+                {
+                    Logging.LogWarning("AmaGDK | [Audio] Module has not been initialized!");
+                    return NO_DEVICE;
+                }
+
+                var info = _audioDeviceDetector.GetInfo();
+                return new AudioDeviceInfo
+                {
+                    Type = info.AudioDeviceType,
+                    RawType = info.RawType,
+                    Name = info.Name
+                };
+            }
+        }
+
+        // Event Handler
+        public partial class Audio
+        {
+            private static void RegisterCallbacks()
+            {
+                _audioDeviceDetector.onChanged -= OnAudioDeviceChanged;
+                _audioDeviceDetector.onChanged += OnAudioDeviceChanged;
+
+                _audioDeviceDetector.onInterrupted -= OnAudioInterrupted;
+                _audioDeviceDetector.onInterrupted += OnAudioInterrupted;
+            }
+
+            private static void OnAudioDeviceChanged(string param)
+            {
+                GDKUtils.DelayCall(1f, () =>
+                {
+                    DeviceInfo = DetectAudioInfo();
+                    DeviceInfo.LatencyMs = GetAudioDeviceLatency();
+                    dispatcher.Dispatch(Event.GDK_AUDIO_INFO_CHANGE, DeviceInfo);
+                });
+            }
+
+            private static void OnAudioInterrupted(string param)
+            {
+                dispatcher.Dispatch(param == "began" ? Event.GDK_AUDIO_INTERRUPT_BEGIN : Event.GDK_AUDIO_INTERRUPT_END);
+            }
+        }
+
+        // Util
+        public partial class Audio
+        {
+            public static bool IsConnectingBluetoothHeadset()
+            {
+                return DeviceInfo != null
+                       && (DeviceInfo.RawType == "AVAudioSessionPortBluetoothA2DP"
+                           || DeviceInfo.RawType == "TYPE_BLUETOOTH_A2DP"
+                           || DeviceInfo.RawType == "AVAudioSessionPortBluetoothHFP");
+            }
+
+            private static string GetCurrentRouteInputs()
+            {
+#if !UNITY_EDITOR
+                return _audioDeviceDetector.GetCurrentRouteInputs();
+#else
+                return string.Empty;
+#endif
+            }
+
+            public static bool IsRecordingWithMicrophone()
+            {
+#if UNITY_IOS
+                string currentAudioInputs = GetCurrentRouteInputs();
+                return string.IsNullOrWhiteSpace(currentAudioInputs) == false;
+#else
+                return false;
+#endif
+            }
+        }
+    }
+}

package/Runtime/AudioToolkit/AmaGDK.Audio.cs.meta

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