Monobehaviour-less coroutines. Fixed tests.

Author: coryleach

Runtime/Awaiters.cs

@@ -1,19 +1,33 @@
-using System.Collections;
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Gameframe.Async.Coroutines;
 using UnityEngine;
 
 namespace Gameframe.Async
 {
     public static class Awaiters
     {
         private static readonly WaitForBackground _waitForBackground = new WaitForBackground();
-        private static readonly WaitForUnityThread _waitForUnityThread = new WaitForUnityThread();
-        
+        private static readonly WaitForUnityThread WaitForUnityUnityThread = new WaitForUnityThread();
+
+        /// <summary>
+        /// Await this property to migrate an async method to a background thread
+        /// </summary>
         public static WaitForBackground BackgroundThread => _waitForBackground;
-        public static WaitForUnityThread MainThread => _waitForUnityThread;
+        
+        /// <summary>
+        /// Await this property to migrate to the Unity main thread.
+        /// </summary>
+        public static WaitForUnityThread MainUnityThread => WaitForUnityUnityThread;
+        
+        /// <summary>
+        /// Await this property will resume on the same context after the game has advanced a frame
+        /// </summary>
+        public static YieldAwaitable NextFrame => Task.Yield();
     }
 
     public class WaitForBackground
@@ -24,18 +38,48 @@ public ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter()
         }
     }
 
-    public class WaitForUpdate : CustomYieldInstruction
-    {
-        public override bool keepWaiting => false;
-    }
-
     public class WaitForUnityThread
-    {
-        public ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter()
+    {       
+        private class MainThreadJoinAwaiter : IAwaitable
         {
-            var task = Task.Factory.StartNew(() => {}, CancellationToken.None, TaskCreationOptions.None, UnityTaskUtil.UnityTaskScheduler);
-            return task.ConfigureAwait(false).GetAwaiter();
+            private Action _continuation = null;
+            private bool isCompleted = false;
+            public bool IsCompleted => isCompleted;
+
+            public void Complete()
+            {
+                isCompleted = true;
+                _continuation?.Invoke();
+            }
+
+            public void GetResult()
+            {
+                do
+                {
+                } while (!isCompleted);
+            }
+
+            void INotifyCompletion.OnCompleted(Action continuation)
+            {
+                _continuation = continuation;
+            }
         }
+        
+        public IAwaitable GetAwaiter()
+        {
+            var awaiter = new MainThreadJoinAwaiter();
+            UnityTaskUtil.UnitySynchronizationContext.Post(state=>awaiter.Complete(),null);
+            return awaiter;
+        }
+    }
+    
+    /// <summary>
+    /// Interface that implements all the properties needed to make an object awaitable
+    /// </summary>
+    public interface IAwaitable : INotifyCompletion
+    {
+        bool IsCompleted { get; }
+        void GetResult();
     }
 
 }

Runtime/Coroutines/CoroutineRunner.cs

@@ -1,38 +1,92 @@
-using System.Collections;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using UnityEngine;
 
 namespace Gameframe.Async.Coroutines
 {
-    public class CoroutineRunner : MonoBehaviour
+    public class CoroutineRunner
     {
-        static CoroutineRunner _instance;
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
+        private static void Install()
+        {
+            UnitySynchronizationContext = SynchronizationContext.Current;
+            Application.quitting += OnApplicationQuitting;
+        }
+    
+        private static SynchronizationContext UnitySynchronizationContext { get; set; }
+        private static CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 
         public static async Task RunAsync(IEnumerator routine)
         {
-            if (_instance == null)
+            await UnityTaskUtil.RunOnUnityThreadAsync(() => Run(routine,cancellationTokenSource.Token) );
+        }
+        
+        public static void Start(IEnumerator enumerator)
+        {
+            UnityTaskUtil.RunOnUnityThread(() => Run(enumerator,cancellationTokenSource.Token));
+        }
+    
+        public static void StopAll()
+        {
+            cancellationTokenSource.Cancel();
+            cancellationTokenSource = new CancellationTokenSource();
+        }
+        
+        private static void OnApplicationQuitting()
+        {
+            StopAll();
+        }
+    
+        private static async void Run(IEnumerator routine, CancellationToken token)
+        {
+            var coroutine = RunCoroutine(routine);
+            while (!token.IsCancellationRequested && coroutine.MoveNext())
             {
-                await InstantiateAsync();
+                //Task.Yield() on the Unity sync context appears to yield for one frame
+                await Task.Yield();
             }
-            await UnityTaskUtil.StartCoroutineAsync(routine, _instance);
         }
-
-        private static async Task InstantiateAsync()
+        
+        private static IEnumerator RunCoroutine(object state)
         {
-            await UnityTaskUtil.RunOnUnityThreadAsync(() =>
+            var processStack = new Stack<IEnumerator>();
+            processStack.Push((IEnumerator)state);
+    
+            while ( processStack.Count > 0)
             {
-                if (_instance != null)
+                var currentCoroutine = processStack.Peek();
+                var done = false;
+    
+                try
                 {
-                    return;
+                    done = !currentCoroutine.MoveNext();
                 }
-                _instance = new GameObject("CoroutineRunner").AddComponent<CoroutineRunner>();
-            });
-        }
-        
-        void Awake()
-        {
-            gameObject.hideFlags = HideFlags.HideAndDontSave;
-            DontDestroyOnLoad(gameObject);
+                catch (Exception e)
+                {
+                    Debug.LogException(e);
+                    yield break;
+                }
+    
+                if (done)
+                {
+                    processStack.Pop();
+                }
+                else
+                {
+                    if (currentCoroutine.Current is IEnumerator innerCoroutine)
+                    {
+                        processStack.Push(innerCoroutine);
+                    }
+                    else
+                    {
+                        yield return currentCoroutine.Current;
+                    }
+                }
+                    
+            }
         }
 
     }

Tests/Runtime/AwaitersTests.cs

@@ -1,11 +1,8 @@
 using System.Collections;
-using System.Collections.Generic;
 using System.Threading.Tasks;
-using Gameframe.Async;
 using NUnit.Framework;
 using UnityEngine;
 using UnityEngine.TestTools;
-using UnityEngine.UI;
 
 namespace Gameframe.Async.Tests
 {
@@ -17,16 +14,36 @@ public IEnumerator TestBackgroundAndMainThreadAwaiters()
             var task = DoTest();
             yield return task.AsIEnumerator();
         }
-
+        
         private async Task DoTest()
         {
             //Start on unity thread
             Assert.IsTrue(UnityTaskUtil.CurrentThreadIsUnityThread);
-            await Awaiters.BackgroundThread;
+            
+            //Migrate to background thread
+            await Awaiters.BackgroundThread;            
             Assert.IsFalse(UnityTaskUtil.CurrentThreadIsUnityThread);
-            await Awaiters.MainThread;
+            
+            //Migrate back to main thread
+            await Awaiters.MainUnityThread;
+            Assert.IsTrue(UnityTaskUtil.CurrentThreadIsUnityThread);
+            
+            //Await the main thread when already on the main thread should do nothing
+            await Awaiters.MainUnityThread;
             Assert.IsTrue(UnityTaskUtil.CurrentThreadIsUnityThread);
+            
+            //Await the next frame
+            int frame = Time.frameCount;
+            await Task.Yield();
+            Assert.IsTrue(UnityTaskUtil.CurrentThreadIsUnityThread);
+            Assert.IsTrue(Time.frameCount == frame+1);
+            
+            //Test can await next frame from background thread and then resume on background thread
+            await Awaiters.BackgroundThread;
+            Assert.IsFalse(UnityTaskUtil.CurrentThreadIsUnityThread);
+            await Awaiters.NextFrame;
+            Assert.IsFalse(UnityTaskUtil.CurrentThreadIsUnityThread);
         }
 
     }
-}
+}