update: 添加Loom工具， 保证逻辑都可以落在主线程

Runtime/GuruCore/Runtime/Adjust/AdjustService.cs

@@ -1,3 +1,5 @@
+using System.Threading;
+
 namespace Guru
 {
 	using UnityEngine;
@@ -55,11 +57,22 @@ namespace Guru
 			
 			// 缓存标准属性
 			StandardProperties.AdjustId = Adjust.getAdid(); // 获取AdjustID
-			Adjust.getGoogleAdId(gid =>
+
+			Loom.RunAsync(() =>
 			{
-				if (!string.IsNullOrEmpty(gid)) StandardProperties.GoogleAdId = gid; // 获取Google AD ID 
+				Adjust.getGoogleAdId(gid =>
+				{
+					if (!string.IsNullOrEmpty(gid))
+					{
+						Loom.QueueOnMainThread(() =>
+						{
+							StandardProperties.GoogleAdId = gid; // 获取Google AD ID 
+						});
+					}
+				});
 			});
 		}
+		
 
 		/// <summary>
 		/// 确保 Adjust 实例在场景中

Runtime/GuruRemote/Runtime/RemoteConfigManager.cs

@@ -10,6 +10,8 @@ namespace Guru
     using Firebase.RemoteConfig;
     using Firebase.Extensions;
     
+    
+    
     /// <summary>
     /// 运控配置管理器
     /// </summary>

Runtime/Loom.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 27b0011206f347d6869a8ff7e7a4d380
+timeCreated: 1704679689

Runtime/Loom/Loom.cs

@@ -0,0 +1,143 @@
+namespace Guru
+{
+    using UnityEngine;
+	using System.Collections.Generic;
+	using System;
+	using System.Threading;
+	using System.Linq;
+
+	public class Loom : MonoBehaviour
+	{
+		public static int maxThreads = 8;
+		static int numThreads;
+
+		private static Loom _current;
+		private int _count;
+		public static Loom Current
+		{
+			get
+			{
+				Initialize();
+				return _current;
+			}
+		}
+
+		void Awake()
+		{
+			_current = this;
+			initialized = true;
+		}
+
+		static bool initialized;
+
+		static void Initialize()
+		{
+			if (!initialized)
+			{
+				if (!Application.isPlaying)
+					return;
+				
+				initialized = true;
+				var g = new GameObject("Loom");
+				_current = g.AddComponent<Loom>();
+			}
+
+		}
+
+		private List<Action> _actions = new List<Action>();
+		public struct DelayedQueueItem
+		{
+			public float time;
+			public Action action;
+		}
+		private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();
+
+		List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();
+
+		public static void QueueOnMainThread(Action action)
+		{
+			QueueOnMainThread(action, 0f);
+		}
+		public static void QueueOnMainThread(Action action, float time)
+		{
+			if (time != 0)
+			{
+				lock (Current._delayed)
+				{
+					Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action });
+				}
+			}
+			else
+			{
+				lock (Current._actions)
+				{
+					Current._actions.Add(action);
+				}
+			}
+		}
+
+		public static Thread RunAsync(Action a)
+		{
+			Initialize();
+			while (numThreads >= maxThreads)
+			{
+				Thread.Sleep(1);
+			}
+			Interlocked.Increment(ref numThreads);
+			ThreadPool.QueueUserWorkItem(RunAction, a);
+			return null;
+		}
+
+		private static void RunAction(object action)
+		{
+			try
+			{
+				((Action)action)();
+			}
+			catch
+			{
+			}
+			finally
+			{
+				Interlocked.Decrement(ref numThreads);
+			}
+		}
+
+		void OnDisable()
+		{
+			if (_current == this)
+			{
+
+				_current = null;
+			}
+		}
+
+		List<Action> _currentActions = new List<Action>();
+
+		// Update is called once per frame
+		void Update()
+		{
+			lock (_actions)
+			{
+				_currentActions.Clear();
+				_currentActions.AddRange(_actions);
+				_actions.Clear();
+			}
+			foreach (var a in _currentActions)
+			{
+				a();
+			}
+			lock (_delayed)
+			{
+				_currentDelayed.Clear();
+				_currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
+				foreach (var item in _currentDelayed)
+					_delayed.Remove(item);
+			}
+			foreach (var delayed in _currentDelayed)
+			{
+				delayed.action();
+			}
+		}
+	}
+}

Runtime/Loom/Loom.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e34dba6b5d6c4191a581f9ba57588e37
+timeCreated: 1704679694