Add core implementation of ui thread dispatcher

Author: techdigga

Runtime/Core/ActionQueueProcessor.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace ThreadDispatcher.Core
+{
+    /// <summary>
+    /// Handles thread-safe action queue processing.
+    /// </summary>
+    public class ActionQueueProcessor : IDisposable
+    {
+        private readonly Queue<Action> _queue = new Queue<Action>();
+        private readonly object _lock = new object();
+        private readonly ILogger _logger;
+
+        public ActionQueueProcessor(ILogger logger = null)
+        {
+            _logger = logger ?? new UnityLogger();
+        }
+
+        public int Count
+        {
+            get
+            {
+                lock (_lock)
+                {
+                    return _queue.Count;
+                }
+            }
+        }
+
+        public void Enqueue(Action action)
+        {
+            if (action == null)
+            {
+                _logger.LogWarning("Attempted to enqueue null action");
+                return;
+            }
+
+            lock (_lock)
+            {
+                _queue.Enqueue(action);
+            }
+        }
+
+        public void ProcessAll()
+        {
+            lock (_lock)
+            {
+                while (_queue.Count > 0)
+                {
+                    var action = _queue.Dequeue();
+                    try
+                    {
+                        action?.Invoke();
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError($"Error executing queued action: {ex}");
+                    }
+                }
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_lock)
+            {
+                _queue.Clear();
+            }
+        }
+
+        public void Dispose()
+        {
+            Clear();
+        }
+    }
+}

Runtime/Core/CoroutineRunner.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace ThreadDispatcher.Core
+{
+    /// <summary>
+    /// Handles coroutine-based delayed actions.
+    /// </summary>
+    public class CoroutineRunner : MonoBehaviour
+    {
+        public void RunDelayed(Action action, float delay)
+        {
+            if (action != null)
+            {
+                StartCoroutine(DelayedAction(action, delay));
+            }
+        }
+
+        public void RunEndOfFrame(Action action)
+        {
+            if (action != null)
+            {
+                StartCoroutine(EndOfFrameAction(action));
+            }
+        }
+
+        public void RunNextFrame(Action action)
+        {
+            if (action != null)
+            {
+                StartCoroutine(NextFrameAction(action));
+            }
+        }
+
+        private IEnumerator DelayedAction(Action action, float delay)
+        {
+            yield return new WaitForSeconds(delay);
+            action?.Invoke();
+        }
+
+        private IEnumerator EndOfFrameAction(Action action)
+        {
+            yield return new WaitForEndOfFrame();
+            action?.Invoke();
+        }
+
+        private IEnumerator NextFrameAction(Action action)
+        {
+            yield return null;
+            action?.Invoke();
+        }
+    }
+}

Runtime/Core/ThreadChecker.cs

@@ -0,0 +1,19 @@
+using System.Threading;
+
+namespace ThreadDispatcher.Core
+{
+    /// <summary>
+    /// Utility for checking thread identity.
+    /// </summary>
+    public class ThreadChecker
+    {
+        private readonly int _mainThreadId;
+
+        public ThreadChecker()
+        {
+            _mainThreadId = Thread.CurrentThread.ManagedThreadId;
+        }
+
+        public bool IsMainThread => Thread.CurrentThread.ManagedThreadId == _mainThreadId;
+    }
+}

Runtime/Extensions/UIThreadExtension.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace ThreadDispatcher.Extensions
+{
+    /// <summary>
+    /// Extension methods for async/await integration.
+    /// </summary>
+    public static class UIThreadExtensions
+    {
+        public static UIThreadAwaiter SwitchToMainThread()
+        {
+            return new UIThreadAwaiter();
+        }
+    }
+
+    /// <summary>
+    /// Custom awaiter for async/await pattern.
+    /// </summary>
+    public struct UIThreadAwaiter : INotifyCompletion
+    {
+        public bool IsCompleted => UIThreadDispatcher.Instance.IsMainThread;
+
+        public void OnCompleted(Action continuation)
+        {
+            UIThreadDispatcher.Instance.Enqueue(continuation);
+        }
+
+        public void GetResult() { }
+
+        public UIThreadAwaiter GetAwaiter() => this;
+    }
+}

Runtime/Interfaces/ILogger.cs

@@ -0,0 +1,13 @@
+
+namespace ThreadDispatcher
+{
+    /// <summary>
+    /// Logging interface for dependency injection.
+    /// </summary>
+    public interface ILogger
+    {
+        void Log(string message);
+        void LogWarning(string message);
+        void LogError(string message);
+    }
+}

Runtime/Interfaces/IThreadDispatcher.cs

@@ -0,0 +1,14 @@
+{
+    "name": "ThreadDispatcher.Runtime",
+    "rootNamespace": "ThreadDispatcher",
+    "references": [],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Runtime/ThreadDispatcher.Runtime.asmdef

@@ -0,0 +1,131 @@
+using System;
+using UnityEngine;
+using ThreadDispatcher.Core;
+
+namespace ThreadDispatcher
+{
+    /// <summary>
+    /// Main dispatcher for marshalling calls to Unity's main thread.
+    /// </summary>
+    public class UIThreadDispatcher : MonoBehaviour, IThreadDispatcher
+    {
+        private static UIThreadDispatcher _instance;
+        private static readonly object _lock = new object();
+
+        private ActionQueueProcessor _queueProcessor;
+        private ThreadChecker _threadChecker;
+        private CoroutineRunner _coroutineRunner;
+        private ILogger _logger;
+
+        public static UIThreadDispatcher Instance
+        {
+            get
+            {
+                if (_instance == null)
+                {
+                    lock (_lock)
+                    {
+                        if (_instance == null)
+                        {
+                            Initialize();
+                        }
+                    }
+                }
+                return _instance;
+            }
+        }
+
+        public static IThreadDispatcher Dispatcher => Instance;
+
+        public bool IsMainThread => _threadChecker?.IsMainThread ?? true;
+        public int QueueSize => _queueProcessor?.Count ?? 0;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void Initialize()
+        {
+            if (_instance != null) return;
+
+            var go = new GameObject("[UIThreadDispatcher]");
+            _instance = go.AddComponent<UIThreadDispatcher>();
+            DontDestroyOnLoad(go);
+        }
+
+        void Awake()
+        {
+            if (_instance != null && _instance != this)
+            {
+                Destroy(gameObject);
+                return;
+            }
+
+            InitializeComponents();
+        }
+
+        private void InitializeComponents()
+        {
+            _logger = new UnityLogger();
+            _threadChecker = new ThreadChecker();
+            _queueProcessor = new ActionQueueProcessor(_logger);
+            _coroutineRunner = gameObject.AddComponent<CoroutineRunner>();
+        }
+
+        void Update()
+        {
+            _queueProcessor?.ProcessAll();
+        }
+
+        public void Enqueue(Action action)
+        {
+            _queueProcessor?.Enqueue(action);
+        }
+
+        public void RunOnMainThread(Action action)
+        {
+            if (action == null)
+            {
+                _logger?.LogWarning("Attempted to run null action");
+                return;
+            }
+
+            if (IsMainThread)
+            {
+                action();
+            }
+            else
+            {
+                Enqueue(action);
+            }
+        }
+
+        public void EnqueueDelayed(Action action, float delay)
+        {
+            _coroutineRunner?.RunDelayed(action, delay);
+        }
+
+        public void EnqueueEndOfFrame(Action action)
+        {
+            _coroutineRunner?.RunEndOfFrame(action);
+        }
+
+        public void EnqueueNextFrame(Action action)
+        {
+            _coroutineRunner?.RunNextFrame(action);
+        }
+
+        void OnDestroy()
+        {
+            if (_instance == this)
+            {
+                _queueProcessor?.Dispose();
+                _instance = null;
+            }
+        }
+
+        // Static convenience methods
+        public static void EnqueueAction(Action action) => Instance.Enqueue(action);
+        public static void RunOnMain(Action action) => Instance.RunOnMainThread(action);
+        public static void EnqueueWithDelay(Action action, float delay) => Instance.EnqueueDelayed(action, delay);
+        public static void EnqueueAtEndOfFrame(Action action) => Instance.EnqueueEndOfFrame(action);
+        public static void EnqueueForNextFrame(Action action) => Instance.EnqueueNextFrame(action);
+    }
+}

Runtime/UIThreadDispatcher.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace ThreadDispatcher
+{
+    /// <summary>
+    /// Default Unity logger implementation.
+    /// </summary>
+    public class UnityLogger : ILogger
+    {
+        public void Log(string message) => UnityEngine.Debug.Log(message);
+        public void LogWarning(string message) => UnityEngine.Debug.LogWarning(message);
+        public void LogError(string message) => UnityEngine.Debug.LogError(message);
+    }
+}