Merge pull request #9870 from MaxWang-MS/async_fix

Fix some AsyncCoroutineRunner related issues

Author: MaxWang-MS

Assets/MRTK/Core/Utilities/Async/AwaiterExtensions.cs

@@ -145,6 +145,14 @@ private static void RunOnUnityScheduler(Action action)
             }
             else
             {
+                // Make sure there is a running instance of AsyncCoroutineRunner before calling AsyncCoroutineRunner.Post
+                // If not warn the user. Note we cannot call AsyncCoroutineRunner.Instance here as that getter contains
+                // calls to Unity functions that can only be run on the Unity thread
+                if (!AsyncCoroutineRunner.IsInstanceRunning)
+                {
+                    Debug.LogWarning("There is no active AsyncCoroutineRunner when an action is posted. Place a GameObject " +
+                        "at the root of the scene and attach the AsyncCoroutineRunner script to make it function properly.");
+                }
                 AsyncCoroutineRunner.Post(action);
             }
         }

Assets/MRTK/Core/Utilities/Async/Internal/AsyncCoroutineRunner.cs

@@ -43,6 +43,8 @@ internal sealed class AsyncCoroutineRunner : MonoBehaviour
     {
         private static AsyncCoroutineRunner instance;
 
+        private static bool isInstanceRunning = false;
+
         private static readonly Queue<Action> Actions = new Queue<Action>();
 
         internal static AsyncCoroutineRunner Instance
@@ -51,9 +53,18 @@ internal static AsyncCoroutineRunner Instance
             {
                 if (instance == null)
                 {
-                    instance = FindObjectOfType<AsyncCoroutineRunner>();
+                    AsyncCoroutineRunner[] instances = FindObjectsOfType<AsyncCoroutineRunner>();
+                    Debug.Assert(instances.Length <= 1, "[AsyncCoroutineRunner] There should only be one AsyncCoroutineRunner in the scene.");
+                    instance = instances.Length == 1 ? instances[0] : null;
+                    if (instance != null && !instance.enabled)
+                    {
+                        Debug.LogWarning("[AsyncCoroutineRunner] Found a disabled AsyncCoroutineRunner component. Enabling the component.");
+                        instance.enabled = true;
+                    }
                 }
 
+                // FindObjectOfType() only search for objects attached to active GameObjects. The FindObjectOfType(bool includeInactive) variant is not available to Unity 2019.4 and earlier so cannot be used.
+                // We instead search for GameObject called AsyncCoroutineRunner and see if it has the component attached.
                 if (instance == null)
                 {
                     var instanceGameObject = GameObject.Find("AsyncCoroutineRunner");
@@ -64,22 +75,28 @@ internal static AsyncCoroutineRunner Instance
 
                         if (instance == null)
                         {
-                            Debug.Log("[AsyncCoroutineRunner] Found GameObject but didn't have component");
-
-                            if (Application.isPlaying)
+                            Debug.Log("[AsyncCoroutineRunner] Found a \"AsyncCoroutineRunner\" GameObject but didn't have the AsyncCoroutineRunner component attached. Attaching the script.");
+                            instance = instanceGameObject.AddComponent<AsyncCoroutineRunner>();
+                        }
+                        else
+                        {
+                            if (!instance.enabled)
                             {
-                                Destroy(instanceGameObject);
+                                Debug.LogWarning("[AsyncCoroutineRunner] Found a disabled AsyncCoroutineRunner component. Enabling the component.");
+                                instance.enabled = true;
                             }
-                            else
+                            if (!instanceGameObject.activeSelf)
                             {
-                                DestroyImmediate(instanceGameObject);
+                                Debug.LogWarning("[AsyncCoroutineRunner] Found an AsyncCoroutineRunner attached to an inactive GameObject. Setting the GameObject active.");
+                                instanceGameObject.SetActive(true);
                             }
                         }
                     }
                 }
 
                 if (instance == null)
                 {
+                    Debug.Log("[AsyncCoroutineRunner] There is no AsyncCoroutineRunner in the scene. Adding a GameObject with AsyncCoroutineRunner attached at the root of the scene.");
                     instance = new GameObject("AsyncCoroutineRunner").AddComponent<AsyncCoroutineRunner>();
                 }
 
@@ -89,15 +106,14 @@ internal static AsyncCoroutineRunner Instance
                 // This is ultimately to ensure that it persists across scene loads/unloads.
                 if (instance.transform.parent != null)
                 {
-                    Debug.LogWarning($"AsyncCoroutineRunner was found as a child of another GameObject {instance.transform.parent}, " +
+                    Debug.LogWarning($"[AsyncCoroutineRunner] AsyncCoroutineRunner was found as a child of another GameObject {instance.transform.parent}, " +
                         "it must be a root object in the scene. Moving the AsyncCoroutineRunner to the root.");
                     instance.transform.parent = null;
                 }
 
 #if !UNITY_EDITOR
                 DontDestroyOnLoad(instance);
 #endif
-
                 return instance;
             }
         }
@@ -110,9 +126,12 @@ internal static void Post(Action task)
             }
         }
 
+        internal static bool IsInstanceRunning => isInstanceRunning;
+
         private void Update()
         {
-            Debug.Assert(Instance != null);
+            Debug.Assert(Instance == this, "[AsyncCoroutineRunner] There should only be one AsyncCoroutineRunner in the scene.");
+            isInstanceRunning = true;
 
             int actionCount;
 
@@ -133,5 +152,19 @@ private void Update()
                 next();
             }
         }
+
+        private void OnDisable()
+        {
+            if (instance == this)
+            {
+                isInstanceRunning = false;
+            }
+        }
+
+        private void OnEnable()
+        {
+            Debug.Assert(Instance == this, "[AsyncCoroutineRunner] There should only be one AsyncCoroutineRunner in the scene.");
+            isInstanceRunning = true;
+        }
     }
 }