2.1.1

Unity 2020.2 changed order of the PlayerLoop subsystem list (should fix #208)

.github/workflows/build-debug.yml

@@ -3,7 +3,7 @@ name: Build-Debug
 on:
   push:
     branches:
-      - "**"
+      - "master"
     tags:
       - "!*" # not a tag push
   pull_request:
@@ -22,7 +22,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 3.1.101
+          dotnet-version: 3.1.x
       - run: dotnet test -c Debug ./src/UniTask.NetCoreTests/UniTask.NetCoreTests.csproj
 
   build-unity:

.github/workflows/build-release.yml

@@ -16,9 +16,9 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-dotnet@v1
         with:
-          dotnet-version: 3.1.101
+          dotnet-version: 3.1.x
       # set release tag(*.*.*) to env.GIT_TAG
-      - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+      - run: echo "GIT_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
 
       # build and pack
       - run: dotnet build -c Release -p:Version=${{ env.GIT_TAG }}
@@ -34,7 +34,7 @@ jobs:
   build-unity:
     strategy:
       matrix:
-        unity: ['2019.3.9f1']
+        unity: ["2019.3.9f1"]
         include:
           - unity: 2019.3.9f1
             license: UNITY_2019_3
@@ -51,14 +51,14 @@ jobs:
       - run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -manualLicenseFile .Unity.ulf || exit 0
 
       # set release tag(*.*.*) to env.GIT_TAG
-      - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+      - run: echo "GIT_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
 
       # Execute scripts: Export Package
       - name: Export unitypackage
         run: /opt/Unity/Editor/Unity -quit -batchmode -nographics -silent-crashes -logFile -projectPath . -executeMethod PackageExporter.Export
         working-directory: src/UniTask
 
-      # Store artifacts.      
+      # Store artifacts.
       - uses: actions/upload-artifact@v2
         with:
           name: UniTask.${{ env.GIT_TAG }}.unitypackage
@@ -72,34 +72,34 @@ jobs:
       DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1
       NUGET_XMLDOC_MODE: skip
     steps:
-    # setup dotnet for nuget push
-    - uses: actions/setup-dotnet@v1
-      with:
-        dotnet-version: 3.1.101
-    # set release tag(*.*.*) to env.GIT_TAG
-    - run: echo ::set-env name=GIT_TAG::${GITHUB_REF#refs/tags/}
+      # setup dotnet for nuget push
+      - uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 3.1.x
+      # set release tag(*.*.*) to env.GIT_TAG
+      - run: echo "GIT_TAG=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
 
-    # Create Releases
-    - uses: actions/create-release@v1
-      id: create_release
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        tag_name: ${{ github.ref }}
-        release_name: Ver.${{ github.ref }}
+      # Create Releases
+      - uses: actions/create-release@v1
+        id: create_release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Ver.${{ github.ref }}
 
-    # Download(All) Artifacts to current directory
-    - uses: actions/download-artifact@v2-preview
+      # Download(All) Artifacts to current directory
+      - uses: actions/download-artifact@v2-preview
 
-    # Upload to NuGet
-    - run: dotnet nuget push "./nuget/*.nupkg" -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
+      # Upload to NuGet
+      - run: dotnet nuget push "./nuget/*.nupkg" -s https://www.nuget.org/api/v2/package -k ${{ secrets.NUGET_KEY }}
 
-    # Upload to Releases(unitypackage)
-    - uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./UniTask.${{ env.GIT_TAG }}.unitypackage/UniTask.${{ env.GIT_TAG }}.unitypackage
-        asset_name: UniTask.${{ env.GIT_TAG }}.unitypackage
-        asset_content_type: application/octet-stream
+      # Upload to Releases(unitypackage)
+      - uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./UniTask.${{ env.GIT_TAG }}.unitypackage/UniTask.${{ env.GIT_TAG }}.unitypackage
+          asset_name: UniTask.${{ env.GIT_TAG }}.unitypackage
+          asset_content_type: application/octet-stream

.github/workflows/stale.yml

@@ -0,0 +1,24 @@
+name: "Close stale issues"
+
+on:
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/stale@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          # enable issue
+          stale-issue-message: "This issue is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 7 days."
+          stale-issue-label: "stale"
+          # enable pr
+          stale-pr-message: "This PR is stale because it has been open 90 days with no activity. Remove stale label or comment or this will be closed in 7 days."
+          stale-pr-label: "stale"
+          days-before-stale: 90
+          days-before-close: 7
+          exempt-issue-labels: "wip"
+          exempt-pr-labels: "wip"
+          remove-stale-when-updated: true

.gitignore

@@ -255,3 +255,7 @@ src/UniTask/DOTween.Modules.Player.csproj
 src/UniTask/Assembly-CSharp.Player.csproj
 
 src/UniTask/Unity.EditorCoroutines.Editor.csproj
+
+src/UniTask/.vsconfig
+
+src/UniTask/Logs/ApiUpdaterCheck.txt

README.md

@@ -215,6 +215,8 @@ await task; // NG, throws Exception
 
 Store to the class field, you can use `UniTask.Lazy` that gurantee call multipletimes. `.Preserve()` allows for multiple calls (internally cached results). This is useful when multiple calls in a function scope.
 
+Also `UniTaskCompletionSource` can await multipletimes and await from many caller.
+
 Cancellation and Exception handling
 ---
 Some UniTask factory methods have `CancellationToken cancellationToken = default` parameter. Andalso some async operation for unity have `WithCancellation(CancellationToken)` and `ToUniTask(..., CancellationToken cancellation = default)` extension methods. 
@@ -344,6 +346,11 @@ public enum PlayerLoopTiming
 
     PostLateUpdate = 12,
     LastPostLateUpdate = 13
+    
+#if UNITY_2020_2_OR_NEWER
+    TimeUpdate = 14,
+    LastTimeUpdate = 15,
+#endif
 }
 ```
 
@@ -351,6 +358,8 @@ It indicates when to run, you can check [PlayerLoopList.md](https://gist.github.
 
 `PlayerLoopTiming.Update` is similar as `yield return null` in coroutine, but it is called before Update(Update and uGUI events(button.onClick, etc...) are called on `ScriptRunBehaviourUpdate`, yield return null is called on `ScriptRunDelayedDynamicFrameRate`). `PlayerLoopTiming.FixedUpdate` is similar as `WaitForFixedUpdate`, `PlayerLoopTiming.LastPostLateUpdate` is similar as `WaitForEndOfFrame` in coroutine.
 
+> `await UniTask.WaitForEndOfFrame()` is not equilavelnt to coroutine's `yield return new WaitForEndOfFrame()`. Coroutine's WaitForEndOfFrame seems to run after the PlayerLoop is done. Some methods that require coroutine's end of frame(`ScreenCapture.CaptureScreenshotAsTexture`, `CommandBuffer`, etc) does not work correctly when replace to async/await. In that case, use a coroutine.
+
 `yield return null` and `UniTask.Yield` is similar but different. `yield return null` always return next frame but `UniTask.Yield` return next called, that is, call `UniTask.Yield(PlayerLoopTiming.Update)` on `PreUpdate`, it returns same frame. `UniTask.NextFrame()` gurantees return next frame, this would be expected to behave exactly the same as `yield return null`.
 
 > UniTask.Yield(without CancellationToken) is a special type, returns `YieldAwaitable` and run on YieldRunner. It is most lightweight and faster.
@@ -497,10 +506,10 @@ DOTween support's default behaviour(`await`, `WithCancellation`, `ToUniTask`) aw
 
 AsyncEnumerable and Async LINQ
 ---
-Unity 2020.2.0a12 supports C# 8.0 so you can use `await foreach`. This is the new Update notation in async era.
+Unity 2020.2 supports C# 8.0 so you can use `await foreach`. This is the new Update notation in async era.
 
 ```csharp
-// Unity 2020.2.0a12, C# 8.0
+// Unity 2020.2, C# 8.0
 await foreach (var _ in UniTaskAsyncEnumerable.EveryUpdate(token))
 {
     Debug.Log("Update() " + Time.frameCount);
@@ -794,9 +803,11 @@ IEnumerator.ToUniTask limitation
 ---
 You can convert coroutine(IEnumerator) to UniTask(or await directly) but has some limitations.
 
-* `WaitForEndOfFrame`/`WaitForFixedUpdate` is not supported, used `yield return null` instead.
+* `WaitForEndOfFrame`/`WaitForFixedUpdate`/`Coroutine` is not supported.
 * Consuming loop timing is not same as StartCoroutine, it is used specified PlayerLoopTiming, and default's `PlayerLoopTiming.Update` is run before MonoBehaviour's Update and StartCoroutine's loop.
 
+If you want to convert fully compatible from coroutine to async, use `IEnumerator.ToUniTask(MonoBehaviour coroutineRunner)` overload. It executes StartCoroutine on an instance of the argument MonoBehaviour and waits for it to complete in UniTask.
+
 For UnityEditor
 ---
 UniTask can run on Unity Edtitor like Editor Coroutine. However, there are some limitations.
@@ -852,7 +863,7 @@ Use UniTask type.
 
 Pooling Configuration
 ---
-UniTask is aggressively caching async promise object to achive zero allocation. In default, cache all promises but you can configure `TaskPool.SetMaxPoolSize` to your value, the value indicates cache size per type. `TaskPool.GetCacheSizeInfo` returns current cached object in pool.
+UniTask is aggressively caching async promise object to achive zero allocation(technical details, see blog post [UniTask v2 — Zero Allocation async/await for Unity, with Asynchronous LINQ](https://medium.com/@neuecc/unitask-v2-zero-allocation-async-await-for-unity-with-asynchronous-linq-1aa9c96aa7dd)). In default, cache all promises but you can configure `TaskPool.SetMaxPoolSize` to your value, the value indicates cache size per type. `TaskPool.GetCacheSizeInfo` returns current cached object in pool.
 
 ```csharp
 foreach (var (type, size) in TaskPool.GetCacheSizeInfo())
@@ -906,7 +917,7 @@ After Unity 2019.3.4f1, Unity 2020.1a21, that support path query parameter of gi
 
 or add `"com.cysharp.unitask": "https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask"` to `Packages/manifest.json`.
 
-If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.0.34`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.0.34`.
+If you want to set a target version, UniTask is using `*.*.*` release tag so you can specify a version like `#2.1.0`. For example `https://github.com/Cysharp/UniTask.git?path=src/UniTask/Assets/Plugins/UniTask#2.1.0`.
 
 ### Install via OpenUPM
 

src/UniTask/Assets/Plugins/UniTask/Runtime/EnumeratorAsyncExtensions.cs

@@ -32,6 +32,19 @@ namespace Cysharp.Threading.Tasks
             return new UniTask(EnumeratorPromise.Create(enumerator, timing, cancellationToken, out var token), token);
         }
 
+        public static UniTask ToUniTask(this IEnumerator enumerator, MonoBehaviour coroutineRunner)
+        {
+            var source = AutoResetUniTaskCompletionSource.Create();
+            coroutineRunner.StartCoroutine(Core(enumerator, coroutineRunner, source));
+            return source.Task;
+        }
+
+        static IEnumerator Core(IEnumerator inner, MonoBehaviour coroutineRunner, AutoResetUniTaskCompletionSource source)
+        {
+            yield return coroutineRunner.StartCoroutine(inner);
+            source.TrySetResult();
+        }
+
         sealed class EnumeratorPromise : IUniTaskSource, IPlayerLoopItem, ITaskPoolNode<EnumeratorPromise>
         {
             static TaskPool<EnumeratorPromise> pool;
@@ -74,11 +87,14 @@ namespace Cysharp.Threading.Tasks
                 result.calledGetResult = false;
                 result.initialFrame = -1;
 
-                PlayerLoopHelper.AddAction(timing, result);
-
                 token = result.core.Version;
 
-                result.MoveNext(); // run immediately.
+                // run immediately.
+                if (result.MoveNext())
+                {
+                    PlayerLoopHelper.AddAction(timing, result);
+                }
+                
                 return result;
             }
 
@@ -172,6 +188,7 @@ namespace Cysharp.Threading.Tasks
                 core.Reset();
                 innerEnumerator = default;
                 cancellationToken = default;
+
                 return pool.TryPush(this);
             }
 
@@ -215,7 +232,7 @@ namespace Cysharp.Threading.Tasks
                         }
                         else
                         {
-                            yield return null;
+                            goto WARN;
                         }
                     }
                     else if (current is IEnumerator e3)
@@ -228,9 +245,15 @@ namespace Cysharp.Threading.Tasks
                     }
                     else
                     {
-                        // WaitForEndOfFrame, WaitForFixedUpdate, others.
-                        yield return null;
+                        goto WARN;
                     }
+
+                    continue;
+
+                    WARN:
+                    // WaitForEndOfFrame, WaitForFixedUpdate, others.
+                    UnityEngine.Debug.LogWarning($"yield {current.GetType().Name} is not supported on await IEnumerator or IEnumerator.ToUniTask(), please use ToUniTask(MonoBehaviour coroutineRunner) instead.");
+                    yield return null;
                 }
             }
 
@@ -261,5 +284,4 @@ namespace Cysharp.Threading.Tasks
             }
         }
     }
-}
-
+}

src/UniTask/Assets/Plugins/UniTask/Runtime/External/DOTween/DOTweenAsyncExtensions.cs

@@ -223,6 +223,17 @@ namespace Cysharp.Threading.Tasks
 
             void OnCompleteCallbackDelegate()
             {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    if (this.cancelBehaviour == TweenCancelBehaviour.KillAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.KillWithCompleteCallbackAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.CompleteAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.CompleteWithSeqeunceCallbackAndCancelAwait
+                        || this.cancelBehaviour == TweenCancelBehaviour.CancelAwait)
+                    {
+                        canceled = true;
+                    }
+                }
                 if (canceled)
                 {
                     core.TrySetCanceled(cancellationToken);

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ContinuationQueue.cs

@@ -12,7 +12,7 @@ namespace Cysharp.Threading.Tasks.Internal
 
         readonly PlayerLoopTiming timing;
 
-        SpinLock gate = new SpinLock();
+        SpinLock gate = new SpinLock(false);
         bool dequing = false;
 
         int actionListCount = 0;
@@ -70,13 +70,17 @@ namespace Cysharp.Threading.Tasks.Internal
             }
         }
 
-        public void Clear()
+        public int Clear()
         {
+            var rest = actionListCount + waitingListCount;
+
             actionListCount = 0;
             actionList = new Action[InitialSize];
 
             waitingListCount = 0;
             waitingList = new Action[InitialSize];
+
+            return rest;
         }
 
         // delegate entrypoint.
@@ -128,6 +132,14 @@ namespace Cysharp.Threading.Tasks.Internal
                 case PlayerLoopTiming.LastPostLateUpdate:
                     LastPostLateUpdate();
                     break;
+#if UNITY_2020_2_OR_NEWER
+                case PlayerLoopTiming.TimeUpdate:
+                    TimeUpdate();
+                    break;
+                case PlayerLoopTiming.LastTimeUpdate:
+                    LastTimeUpdate();
+                    break;
+#endif
                 default:
                     break;
             }
@@ -150,6 +162,10 @@ namespace Cysharp.Threading.Tasks.Internal
         void LastPreLateUpdate() => RunCore();
         void PostLateUpdate() => RunCore();
         void LastPostLateUpdate() => RunCore();
+#if UNITY_2020_2_OR_NEWER
+        void TimeUpdate() => RunCore();
+        void LastTimeUpdate() => RunCore();
+#endif
 
         [System.Diagnostics.DebuggerHidden]
         void RunCore()

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/PlayerLoopRunner.cs

@@ -48,14 +48,24 @@ namespace Cysharp.Threading.Tasks.Internal
             }
         }
 
-        public void Clear()
+        public int Clear()
         {
             lock (arrayLock)
             {
+                var rest = 0;
+
                 for (var index = 0; index < loopItems.Length; index++)
                 {
+                    if (loopItems[index] != null)
+                    {
+                        rest++;
+                    }
+
                     loopItems[index] = null;
                 }
+
+                tail = 0;
+                return rest;
             }
         }
 
@@ -108,6 +118,14 @@ namespace Cysharp.Threading.Tasks.Internal
                 case PlayerLoopTiming.LastPostLateUpdate:
                     LastPostLateUpdate();
                     break;
+#if UNITY_2020_2_OR_NEWER
+                case PlayerLoopTiming.TimeUpdate:
+                    TimeUpdate();
+                    break;
+                case PlayerLoopTiming.LastTimeUpdate:
+                    LastTimeUpdate();
+                    break;
+#endif
                 default:
                     break;
             }
@@ -130,6 +148,10 @@ namespace Cysharp.Threading.Tasks.Internal
         void LastPreLateUpdate() => RunCore();
         void PostLateUpdate() => RunCore();
         void LastPostLateUpdate() => RunCore();
+#if UNITY_2020_2_OR_NEWER
+        void TimeUpdate() => RunCore();
+        void LastTimeUpdate() => RunCore();
+#endif
 
         [System.Diagnostics.DebuggerHidden]
         void RunCore()
@@ -143,8 +165,6 @@ namespace Cysharp.Threading.Tasks.Internal
             {
                 var j = tail - 1;
 
-                var loopItems = this.loopItems;
-                // eliminate array-bound check for i
                 for (int i = 0; i < loopItems.Length; i++)
                 {
                     var action = loopItems[i];

src/UniTask/Assets/Plugins/UniTask/Runtime/Internal/ValueStopwatch.cs

@@ -18,6 +18,8 @@ namespace Cysharp.Threading.Tasks.Internal
 
         public TimeSpan Elapsed => TimeSpan.FromTicks(this.ElapsedTicks);
 
+        public bool IsInvalid => startTimestamp == 0;
+
         public long ElapsedTicks
         {
             get

src/UniTask/Assets/Plugins/UniTask/Runtime/PlayerLoopHelper.cs

@@ -8,8 +8,10 @@ using System.Threading;
 
 #if UNITY_2019_3_OR_NEWER
 using UnityEngine.LowLevel;
+using PlayerLoopType = UnityEngine.PlayerLoop;
 #else
 using UnityEngine.Experimental.LowLevel;
+using PlayerLoopType = UnityEngine.Experimental.PlayerLoop;
 #endif
 
 #if UNITY_EDITOR
@@ -57,6 +59,13 @@ namespace Cysharp.Threading.Tasks
         public struct UniTaskLoopRunnerLastYieldUpdate { };
         public struct UniTaskLoopRunnerLastYieldPreLateUpdate { };
         public struct UniTaskLoopRunnerLastYieldPostLateUpdate { };
+
+#if UNITY_2020_2_OR_NEWER
+        public struct UniTaskLoopRunnerTimeUpdate { };
+        public struct UniTaskLoopRunnerLastTimeUpdate { };
+        public struct UniTaskLoopRunnerYieldTimeUpdate { };
+        public struct UniTaskLoopRunnerLastYieldTimeUpdate { };
+#endif
     }
 
     public enum PlayerLoopTiming
@@ -80,7 +89,13 @@ namespace Cysharp.Threading.Tasks
         LastPreLateUpdate = 11,
 
         PostLateUpdate = 12,
-        LastPostLateUpdate = 13
+        LastPostLateUpdate = 13,
+
+#if UNITY_2020_2_OR_NEWER
+        // Unity 2020.2 added TimeUpdate https://docs.unity3d.com/2020.2/Documentation/ScriptReference/PlayerLoop.TimeUpdate.html
+        TimeUpdate = 14,
+        LastTimeUpdate = 15,
+#endif
     }
 
     public interface IPlayerLoopItem
@@ -101,7 +116,7 @@ namespace Cysharp.Threading.Tasks
         static SynchronizationContext unitySynchronizationContetext;
         static ContinuationQueue[] yielders;
         static PlayerLoopRunner[] runners;
-
+        internal static bool IsEditorApplicationQuitting { get; private set; }
         static PlayerLoopSystem[] InsertRunner(PlayerLoopSystem loopSystem,
             Type loopRunnerYieldType, ContinuationQueue cq, Type lastLoopRunnerYieldType, ContinuationQueue lastCq,
             Type loopRunnerType, PlayerLoopRunner runner, Type lastLoopRunnerType, PlayerLoopRunner lastRunner)
@@ -110,27 +125,32 @@ namespace Cysharp.Threading.Tasks
 #if UNITY_EDITOR
             EditorApplication.playModeStateChanged += (state) =>
             {
-                if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.EnteredPlayMode)
+                if (state == PlayModeStateChange.EnteredEditMode || state == PlayModeStateChange.ExitingEditMode)
                 {
-                    return;
-                }
+                    IsEditorApplicationQuitting = true;
+                    // run rest action before clear.
+                    if (runner != null)
+                    {
+                        runner.Run();
+                        runner.Clear();
+                    }
+                    if (lastRunner != null)
+                    {
+                        lastRunner.Run();
+                        lastRunner.Clear();
+                    }
 
-                if (runner != null)
-                {
-                    runner.Clear();
-                }
-                if (lastRunner != null)
-                {
-                    lastRunner.Clear();
-                }
-
-                if (cq != null)
-                {
-                    cq.Clear();
-                }
-                if (lastCq != null)
-                {
-                    lastCq.Clear();
+                    if (cq != null)
+                    {
+                        cq.Run();
+                        cq.Clear();
+                    }
+                    if (lastCq != null)
+                    {
+                        lastCq.Run();
+                        lastCq.Clear();
+                    }
+                    IsEditorApplicationQuitting = false;
                 }
             };
 #endif
@@ -278,51 +298,84 @@ namespace Cysharp.Threading.Tasks
 
 #endif
 
+        private static int FindLoopSystemIndex(PlayerLoopSystem[] playerLoopList, Type systemType)
+        {
+            for (int i = 0; i < playerLoopList.Length; i++)
+            {
+                if (playerLoopList[i].type == systemType)
+                {
+                    return i;
+                }
+            }
+
+            throw new Exception("Target PlayerLoopSystem does not found. Type:" + systemType.FullName);
+        }
+
         public static void Initialize(ref PlayerLoopSystem playerLoop)
         {
+#if UNITY_2020_2_OR_NEWER
+            yielders = new ContinuationQueue[16];
+            runners = new PlayerLoopRunner[16];
+#else
             yielders = new ContinuationQueue[14];
             runners = new PlayerLoopRunner[14];
+#endif
 
             var copyList = playerLoop.subSystemList.ToArray();
 
-            // Initialization
-            copyList[0].subSystemList = InsertRunner(copyList[0], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(PlayerLoopTiming.Initialization),
+            var i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Initialization));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldInitialization), yielders[0] = new ContinuationQueue(PlayerLoopTiming.Initialization),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldInitialization), yielders[1] = new ContinuationQueue(PlayerLoopTiming.LastInitialization),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerInitialization), runners[0] = new PlayerLoopRunner(PlayerLoopTiming.Initialization),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastInitialization), runners[1] = new PlayerLoopRunner(PlayerLoopTiming.LastInitialization));
             // EarlyUpdate
-            copyList[1].subSystemList = InsertRunner(copyList[1], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[2] = new ContinuationQueue(PlayerLoopTiming.EarlyUpdate),
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.EarlyUpdate));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldEarlyUpdate), yielders[2] = new ContinuationQueue(PlayerLoopTiming.EarlyUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldEarlyUpdate), yielders[3] = new ContinuationQueue(PlayerLoopTiming.LastEarlyUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerEarlyUpdate), runners[2] = new PlayerLoopRunner(PlayerLoopTiming.EarlyUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastEarlyUpdate), runners[3] = new PlayerLoopRunner(PlayerLoopTiming.LastEarlyUpdate));
             // FixedUpdate
-            copyList[2].subSystemList = InsertRunner(copyList[2], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[4] = new ContinuationQueue(PlayerLoopTiming.FixedUpdate),
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.FixedUpdate));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldFixedUpdate), yielders[4] = new ContinuationQueue(PlayerLoopTiming.FixedUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldFixedUpdate), yielders[5] = new ContinuationQueue(PlayerLoopTiming.LastFixedUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerFixedUpdate), runners[4] = new PlayerLoopRunner(PlayerLoopTiming.FixedUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastFixedUpdate), runners[5] = new PlayerLoopRunner(PlayerLoopTiming.LastFixedUpdate));
             // PreUpdate
-            copyList[3].subSystemList = InsertRunner(copyList[3], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[6] = new ContinuationQueue(PlayerLoopTiming.PreUpdate),
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.PreUpdate));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreUpdate), yielders[6] = new ContinuationQueue(PlayerLoopTiming.PreUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreUpdate), yielders[7] = new ContinuationQueue(PlayerLoopTiming.LastPreUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreUpdate), runners[6] = new PlayerLoopRunner(PlayerLoopTiming.PreUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreUpdate), runners[7] = new PlayerLoopRunner(PlayerLoopTiming.LastPreUpdate));
             // Update
-            copyList[4].subSystemList = InsertRunner(copyList[4], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[8] = new ContinuationQueue(PlayerLoopTiming.Update),
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Update));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldUpdate), yielders[8] = new ContinuationQueue(PlayerLoopTiming.Update),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldUpdate), yielders[9] = new ContinuationQueue(PlayerLoopTiming.LastUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerUpdate), runners[8] = new PlayerLoopRunner(PlayerLoopTiming.Update),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastUpdate), runners[9] = new PlayerLoopRunner(PlayerLoopTiming.LastUpdate));
             // PreLateUpdate
-            copyList[5].subSystemList = InsertRunner(copyList[5], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[10] = new ContinuationQueue(PlayerLoopTiming.PreLateUpdate),
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.PreLateUpdate));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPreLateUpdate), yielders[10] = new ContinuationQueue(PlayerLoopTiming.PreLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPreLateUpdate), yielders[11] = new ContinuationQueue(PlayerLoopTiming.LastPreLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerPreLateUpdate), runners[10] = new PlayerLoopRunner(PlayerLoopTiming.PreLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPreLateUpdate), runners[11] = new PlayerLoopRunner(PlayerLoopTiming.LastPreLateUpdate));
             // PostLateUpdate
-            copyList[6].subSystemList = InsertRunner(copyList[6], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[12] = new ContinuationQueue(PlayerLoopTiming.PostLateUpdate),
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.PostLateUpdate));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldPostLateUpdate), yielders[12] = new ContinuationQueue(PlayerLoopTiming.PostLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldPostLateUpdate), yielders[13] = new ContinuationQueue(PlayerLoopTiming.LastPostLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerPostLateUpdate), runners[12] = new PlayerLoopRunner(PlayerLoopTiming.PostLateUpdate),
                                                                   typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastPostLateUpdate), runners[13] = new PlayerLoopRunner(PlayerLoopTiming.LastPostLateUpdate));
+#if UNITY_2020_2_OR_NEWER
+            // TimeUpdate
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.TimeUpdate));
+            copyList[i].subSystemList = InsertRunner(copyList[i], typeof(UniTaskLoopRunners.UniTaskLoopRunnerYieldTimeUpdate), yielders[14] = new ContinuationQueue(PlayerLoopTiming.TimeUpdate),
+                                                                    typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastYieldTimeUpdate), yielders[15] = new ContinuationQueue(PlayerLoopTiming.LastTimeUpdate),
+                                                                    typeof(UniTaskLoopRunners.UniTaskLoopRunnerTimeUpdate), runners[14] = new PlayerLoopRunner(PlayerLoopTiming.TimeUpdate),
+                                                                    typeof(UniTaskLoopRunners.UniTaskLoopRunnerLastTimeUpdate), runners[15] = new PlayerLoopRunner(PlayerLoopTiming.LastTimeUpdate));
+#endif
 
             // Insert UniTaskSynchronizationContext to Update loop
-            copyList[4].subSystemList = InsertUniTaskSynchronizationContext(copyList[4]);
+            i = FindLoopSystemIndex(copyList, typeof(PlayerLoopType.Update));
+            copyList[i].subSystemList = InsertUniTaskSynchronizationContext(copyList[i]);
 
             playerLoop.subSystemList = copyList;
             PlayerLoop.SetPlayerLoop(playerLoop);

src/UniTask/Assets/Plugins/UniTask/Runtime/TaskPool.cs

@@ -12,7 +12,9 @@ namespace Cysharp.Threading.Tasks
     public static class TaskPool
     {
         internal static int MaxPoolSize;
-        static ConcurrentDictionary<Type, Func<int>> sizes = new ConcurrentDictionary<Type, Func<int>>();
+
+        // avoid to use ConcurrentDictionary for safety of WebGL build.
+        static Dictionary<Type, Func<int>> sizes = new Dictionary<Type, Func<int>>();
 
         static TaskPool()
         {
@@ -40,19 +42,24 @@ namespace Cysharp.Threading.Tasks
 
         public static IEnumerable<(Type, int)> GetCacheSizeInfo()
         {
-            foreach (var item in sizes)
+            lock (sizes)
             {
-                yield return (item.Key, item.Value());
+                foreach (var item in sizes)
+                {
+                    yield return (item.Key, item.Value());
+                }
             }
         }
 
         public static void RegisterSizeGetter(Type type, Func<int> getSize)
         {
-            sizes[type] = getSize;
+            lock (sizes)
+            {
+                sizes[type] = getSize;
+            }
         }
     }
 
-
     public interface ITaskPoolNode<T>
     {
         ref T NextNode { get; }

src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.cs

@@ -1541,6 +1541,7 @@ namespace Cysharp.Threading.Tasks.Triggers
 #endregion
 
 #region MouseDown
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseDownHandler
     {
@@ -1597,9 +1598,11 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseDownHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseDownAsync();
         }
     }
+#endif
 #endregion
 
 #region MouseDrag
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseDragHandler
     {
@@ -1656,9 +1659,11 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseDragHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseDragAsync();
         }
     }
+#endif
 #endregion
 
 #region MouseEnter
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseEnterHandler
     {
@@ -1715,9 +1720,11 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseEnterHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseEnterAsync();
         }
     }
+#endif
 #endregion
 
 #region MouseExit
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseExitHandler
     {
@@ -1774,9 +1781,11 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseExitHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseExitAsync();
         }
     }
+#endif
 #endregion
 
 #region MouseOver
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseOverHandler
     {
@@ -1833,9 +1842,11 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseOverHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseOverAsync();
         }
     }
+#endif
 #endregion
 
 #region MouseUp
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseUpHandler
     {
@@ -1892,9 +1903,11 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseUpHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseUpAsync();
         }
     }
+#endif
 #endregion
 
 #region MouseUpAsButton
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 
     public interface IAsyncOnMouseUpAsButtonHandler
     {
@@ -1951,6 +1964,7 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((IAsyncOnMouseUpAsButtonHandler)new AsyncTriggerHandler<AsyncUnit>(this, cancellationToken, true)).OnMouseUpAsButtonAsync();
         }
     }
+#endif
 #endregion
 
 #region ParticleCollision

src/UniTask/Assets/Plugins/UniTask/Runtime/Triggers/MonoBehaviourMessagesTriggers.tt

@@ -25,13 +25,7 @@
         ("Update", "Update", "AsyncUnit", null, empty),
         ("FixedUpdate", "FixedUpdate", "AsyncUnit", null, empty),
         ("LateUpdate", "LateUpdate", "AsyncUnit", null, empty),
-        ("MouseDown", "OnMouseDown", "AsyncUnit", null, empty),
-        ("MouseDrag", "OnMouseDrag", "AsyncUnit", null, empty),
-        ("MouseEnter", "OnMouseEnter", "AsyncUnit", null, empty),
-        ("MouseExit", "OnMouseExit", "AsyncUnit", null, empty),
-        ("MouseOver", "OnMouseOver", "AsyncUnit", null, empty),
-        ("MouseUp", "OnMouseUp", "AsyncUnit", null, empty),
-        ("MouseUpAsButton", "OnMouseUpAsButton", "AsyncUnit", null, empty),
+        
         ("ParticleCollision", "OnParticleCollision", "GameObject", null, new []{ ("GameObject", "other") }),
         ("RectTransformDimensionsChange", "OnRectTransformDimensionsChange", "AsyncUnit", null, empty),
         ("RectTransformRemoved", "OnRectTransformRemoved", "AsyncUnit", null, empty),
@@ -47,6 +41,15 @@
         ("BecameInvisible", "OnBecameInvisible", "AsyncUnit", null, empty),
         ("BecameVisible", "OnBecameVisible", "AsyncUnit", null, empty),
         
+        // Mouse... #if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
+        ("MouseDown", "OnMouseDown", "AsyncUnit", null, empty),
+        ("MouseDrag", "OnMouseDrag", "AsyncUnit", null, empty),
+        ("MouseEnter", "OnMouseEnter", "AsyncUnit", null, empty),
+        ("MouseExit", "OnMouseExit", "AsyncUnit", null, empty),
+        ("MouseOver", "OnMouseOver", "AsyncUnit", null, empty),
+        ("MouseUp", "OnMouseUp", "AsyncUnit", null, empty),
+        ("MouseUpAsButton", "OnMouseUpAsButton", "AsyncUnit", null, empty),
+
         // new in v2
         ("ApplicationFocus", "OnApplicationFocus", "bool", null, new []{("bool", "hasFocus") }),
         ("ApplicationPause", "OnApplicationPause", "bool", null, new []{("bool", "pauseStatus") }),
@@ -104,6 +107,7 @@
     Func<(string argType, string argName)[], string> BuildResultParameter = x => x.Length == 0 ? "AsyncUnit.Default" : "(" + string.Join(", ", x.Select(y => y.argName)) + ")";
 
     Func<string, bool> Is2019_3 = x => x == "ParticleUpdateJobScheduled";
+    Func<string, bool> IsMouseTrigger = x => x.StartsWith("Mouse");
 #>
 #pragma warning disable CS1591 // Missing XML comment for publicly visible type or member
 
@@ -117,6 +121,9 @@ namespace Cysharp.Threading.Tasks.Triggers
 #region <#= t.triggerName #>
 <# if(Is2019_3(t.triggerName)) { #>
 #if UNITY_2019_3_OR_NEWER
+<# } #>
+<# if(IsMouseTrigger(t.triggerName)) { #>
+#if !(UNITY_IPHONE || UNITY_ANDROID || UNITY_METRO)
 <# } #>
 
     public interface <#= ToInterfaceName(t.methodName) #>
@@ -174,7 +181,7 @@ namespace Cysharp.Threading.Tasks.Triggers
             return ((<#= ToInterfaceName(t.methodName) #>)new AsyncTriggerHandler<<#= t.returnType #>>(this, cancellationToken, true)).<#= t.methodName #>Async();
         }
     }
-<# if(Is2019_3(t.triggerName)) { #>
+<# if(Is2019_3(t.triggerName) || IsMouseTrigger(t.triggerName)) { #>
 #endif
 <# } #>
 #endregion

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Delay.cs

@@ -726,6 +726,12 @@ namespace Cysharp.Threading.Tasks
                     return false;
                 }
 
+                if (stopwatch.IsInvalid)
+                {
+                    core.TrySetResult(AsyncUnit.Default);
+                    return false;
+                }
+
                 if (stopwatch.ElapsedTicks >= delayTimeSpanTicks)
                 {
                     core.TrySetResult(AsyncUnit.Default);

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.Factory.cs

@@ -341,10 +341,12 @@ namespace Cysharp.Threading.Tasks
             public UniTaskStatus GetStatus(short token)
             {
                 var f = Interlocked.Exchange(ref factory, null);
-                if (f == null) throw new InvalidOperationException("Can't call twice.");
+                if (f != null)
+                {
+                    task = f();
+                    awaiter = task.GetAwaiter();
+                }
 
-                task = f();
-                awaiter = task.GetAwaiter();
                 return task.Status;
             }
 
@@ -383,10 +385,12 @@ namespace Cysharp.Threading.Tasks
             public UniTaskStatus GetStatus(short token)
             {
                 var f = Interlocked.Exchange(ref factory, null);
-                if (f == null) throw new InvalidOperationException("Can't call twice.");
+                if (f != null)
+                {
+                    task = f();
+                    awaiter = task.GetAwaiter();
+                }
 
-                task = f();
-                awaiter = task.GetAwaiter();
                 return task.Status;
             }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTask.cs

@@ -115,8 +115,13 @@ namespace Cysharp.Threading.Tasks
             var status = this.source.GetStatus(this.token);
             if (status.IsCompletedSuccessfully())
             {
+                this.source.GetResult(this.token);
                 return CompletedTasks.AsyncUnit;
             }
+            else if(this.source is IUniTaskSource<AsyncUnit> asyncUnitSource)
+            {
+                return new UniTask<AsyncUnit>(asyncUnitSource, this.token);
+            }
 
             return new UniTask<AsyncUnit>(new AsyncUnitSource(this.source), this.token);
         }
@@ -422,6 +427,7 @@ namespace Cysharp.Threading.Tasks
             var status = this.source.GetStatus(this.token);
             if (status.IsCompletedSuccessfully())
             {
+                this.source.GetResult(this.token);
                 return UniTask.CompletedTask;
             }
 

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskExtensions.cs

@@ -561,21 +561,23 @@ namespace Cysharp.Threading.Tasks
                     UniTaskScheduler.PublishUnobservedTaskException(ex);
                 }
             }
-
-            awaiter.SourceOnCompleted(state =>
+            else
             {
-                using (var t = (StateTuple<UniTask.Awaiter>)state)
+                awaiter.SourceOnCompleted(state =>
                 {
-                    try
+                    using (var t = (StateTuple<UniTask.Awaiter>)state)
                     {
-                        t.Item1.GetResult();
+                        try
+                        {
+                            t.Item1.GetResult();
+                        }
+                        catch (Exception ex)
+                        {
+                            UniTaskScheduler.PublishUnobservedTaskException(ex);
+                        }
                     }
-                    catch (Exception ex)
-                    {
-                        UniTaskScheduler.PublishUnobservedTaskException(ex);
-                    }
-                }
-            }, StateTuple.Create(awaiter));
+                }, StateTuple.Create(awaiter));
+            }
         }
 
         public static void Forget(this UniTask task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread = true)
@@ -629,21 +631,23 @@ namespace Cysharp.Threading.Tasks
                     UniTaskScheduler.PublishUnobservedTaskException(ex);
                 }
             }
-
-            awaiter.SourceOnCompleted(state =>
+            else
             {
-                using (var t = (StateTuple<UniTask<T>.Awaiter>)state)
+                awaiter.SourceOnCompleted(state =>
                 {
-                    try
+                    using (var t = (StateTuple<UniTask<T>.Awaiter>)state)
                     {
-                        t.Item1.GetResult();
+                        try
+                        {
+                            t.Item1.GetResult();
+                        }
+                        catch (Exception ex)
+                        {
+                            UniTaskScheduler.PublishUnobservedTaskException(ex);
+                        }
                     }
-                    catch (Exception ex)
-                    {
-                        UniTaskScheduler.PublishUnobservedTaskException(ex);
-                    }
-                }
-            }, StateTuple.Create(awaiter));
+                }, StateTuple.Create(awaiter));
+            }
         }
 
         public static void Forget<T>(this UniTask<T> task, Action<Exception> exceptionHandler, bool handleExceptionOnMainThread = true)
@@ -736,12 +740,12 @@ namespace Cysharp.Threading.Tasks
         {
             await await task;
         }
-        
+
         public static async UniTask<T> Unwrap<T>(this Task<UniTask<T>> task)
         {
             return await await task;
         }
-        
+
         public static async UniTask<T> Unwrap<T>(this Task<UniTask<T>> task, bool continueOnCapturedContext)
         {
             return await await task.ConfigureAwait(continueOnCapturedContext);
@@ -756,12 +760,12 @@ namespace Cysharp.Threading.Tasks
         {
             await await task.ConfigureAwait(continueOnCapturedContext);
         }
-        
+
         public static async UniTask<T> Unwrap<T>(this UniTask<Task<T>> task)
         {
             return await await task;
         }
-        
+
         public static async UniTask<T> Unwrap<T>(this UniTask<Task<T>> task, bool continueOnCapturedContext)
         {
             return await (await task).ConfigureAwait(continueOnCapturedContext);

src/UniTask/Assets/Plugins/UniTask/Runtime/UniTaskSynchronizationContext.cs

@@ -9,7 +9,7 @@ namespace Cysharp.Threading.Tasks
         const int MaxArrayLength = 0X7FEFFFFF;
         const int InitialSize = 16;
 
-        static SpinLock gate = new SpinLock();
+        static SpinLock gate = new SpinLock(false);
         static bool dequing = false;
 
         static int actionListCount = 0;

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityAsyncExtensions.Jobs.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Threading;
 using Unity.Jobs;
+using UnityEngine;
 
 namespace Cysharp.Threading.Tasks
 {
@@ -85,7 +86,7 @@ namespace Cysharp.Threading.Tasks
 
             public bool MoveNext()
             {
-                if (jobHandle.IsCompleted)
+                if (jobHandle.IsCompleted | PlayerLoopHelper.IsEditorApplicationQuitting)
                 {
                     jobHandle.Complete();
                     core.TrySetResult(AsyncUnit.Default);

src/UniTask/Assets/Plugins/UniTask/Runtime/UnityWebRequestException.cs

@@ -1,6 +1,7 @@
 #if ENABLE_UNITYWEBREQUEST
 
 using System;
+using System.Collections.Generic;
 using UnityEngine.Networking;
 
 namespace Cysharp.Threading.Tasks
@@ -17,6 +18,7 @@ namespace Cysharp.Threading.Tasks
         public string Error { get; }
         public string Text { get; }
         public long ResponseCode { get; }
+        public Dictionary<string, string> ResponseHeaders { get; }
 
         string msg;
 
@@ -38,6 +40,7 @@ namespace Cysharp.Threading.Tasks
                     this.Text = dhb.text;
                 }
             }
+            this.ResponseHeaders = unityWebRequest.GetResponseHeaders();
         }
 
         public override string Message

src/UniTask/Assets/Plugins/UniTask/package.json

@@ -1,7 +1,7 @@
 {
     "name": "com.cysharp.unitask",
     "displayName": "UniTask",
-    "version": "2.0.34",
+    "version": "2.1.1",
     "unity": "2018.4",
     "description": "Provides an efficient async/await integration to Unity.",
     "keywords": [ "async/await", "async", "Task", "UniTask" ],

src/UniTask/Assets/Scenes/EditorTest1.cs

@@ -0,0 +1,41 @@
+#if UNITY_EDITOR
+
+using System;
+using Cysharp.Threading.Tasks;
+using UnityEditor;
+using UnityEngine;
+
+public class Test1
+{
+    [MenuItem("Test/Test1")]
+    public static async UniTaskVoid TestFunc()
+    {
+        await DoSomeThing();
+        string[] scenes = new string[]
+        {
+            "Assets/Scenes/SandboxMain.unity",
+        };
+
+        try
+        {
+            Debug.Log("Build Begin");
+            BuildPipeline.BuildPlayer(scenes, Application.dataPath + "../target", BuildTarget.StandaloneWindows, BuildOptions.CompressWithLz4);
+            Debug.Log("Build After");
+        }
+        catch (Exception e)
+        {
+            Debug.LogError(e.Message);
+        }
+    }
+
+    public static async UniTask DoSomeThing()
+    {
+        Debug.Log("Dosomething");
+        await UniTask.Delay(1500, DelayType.Realtime);
+        Debug.Log("Dosomething 2");
+        await UniTask.Delay(1000, DelayType.Realtime);
+        Debug.Log("Dosomething 3");
+    }
+}
+
+#endif

src/UniTask/Assets/Scenes/EditorTest1.cs.meta

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

src/UniTask/Assets/Scenes/MiddlewareSample.cs

@@ -145,50 +145,50 @@ namespace Cysharp.Threading.Tasks.Sample
         }
     }
 
-    public class LoggingDecorator : IAsyncDecorator
-    {
-        public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
-        {
-            var sw = Stopwatch.StartNew();
-            try
-            {
-                UnityEngine.Debug.Log("Start Network Request:" + context.Path);
+    //public class LoggingDecorator : IAsyncDecorator
+    //{
+    //    public async UniTask<ResponseContext> SendAsync(RequestContext context, CancellationToken cancellationToken, Func<RequestContext, CancellationToken, UniTask<ResponseContext>> next)
+    //    {
+    //        var sw = Stopwatch.StartNew();
+    //        try
+    //        {
+    //            UnityEngine.Debug.Log("Start Network Request:" + context.Path);
 
-                var response = await next(context, cancellationToken);
+    //            var response = await next(context, cancellationToken);
 
-                UnityEngine.Debug.Log($"Complete Network Request: {context.Path} , Elapsed: {sw.Elapsed}, Size: {response.GetRawData().Length}");
+    //            UnityEngine.Debug.Log($"Complete Network Request: {context.Path} , Elapsed: {sw.Elapsed}, Size: {response.GetRawData().Length}");
 
-                return response;
-            }
-            catch (Exception ex)
-            {
-                if (ex is OperationCanceledException)
-                {
-                    UnityEngine.Debug.Log("Request Canceled:" + context.Path);
-                }
-                else if (ex is TimeoutException)
-                {
-                    UnityEngine.Debug.Log("Request Timeout:" + context.Path);
-                }
-                else if (ex is UnityWebRequestException webex)
-                {
-                    if (webex.IsHttpError)
-                    {
-                        UnityEngine.Debug.Log($"Request HttpError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
-                    }
-                    else if (webex.IsNetworkError)
-                    {
-                        UnityEngine.Debug.Log($"Request NetworkError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
-                    }
-                }
-                throw;
-            }
-            finally
-            {
-                /* log other */
-            }
-        }
-    }
+    //            return response;
+    //        }
+    //        catch (Exception ex)
+    //        {
+    //            if (ex is OperationCanceledException)
+    //            {
+    //                UnityEngine.Debug.Log("Request Canceled:" + context.Path);
+    //            }
+    //            else if (ex is TimeoutException)
+    //            {
+    //                UnityEngine.Debug.Log("Request Timeout:" + context.Path);
+    //            }
+    //            else if (ex is UnityWebRequestException webex)
+    //            {
+    //                if (webex.IsHttpError)
+    //                {
+    //                    UnityEngine.Debug.Log($"Request HttpError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
+    //                }
+    //                else if (webex.IsNetworkError)
+    //                {
+    //                    UnityEngine.Debug.Log($"Request NetworkError: {context.Path} Code:{webex.ResponseCode} Message:{webex.Message}");
+    //                }
+    //            }
+    //            throw;
+    //        }
+    //        finally
+    //        {
+    //            /* log other */
+    //        }
+    //    }
+    //}
 
     public class SetupHeaderDecorator : IAsyncDecorator
     {

src/UniTask/Assets/Scenes/SandboxMain.cs

@@ -428,15 +428,15 @@ public class SandboxMain : MonoBehaviour
         Debug.Log("after");
     }
 
-    private async UniTaskVoid ExecuteAsync()
-    {
-        var req = UnityWebRequest.Get("https://google.com/");
+    //private async UniTaskVoid ExecuteAsync()
+    //{
+    //    var req = UnityWebRequest.Get("https://google.com/");
 
-        var v = await req.SendWebRequest().ToUniTask();
-        // req.Dispose();
-        Debug.Log($"{v.isDone} {v.isHttpError} {v.isNetworkError}");
-        Debug.Log(v.downloadHandler.text);
-    }
+    //    var v = await req.SendWebRequest().ToUniTask();
+    //    // req.Dispose();
+    //    Debug.Log($"{v.isDone} {v.isHttpError} {v.isNetworkError}");
+    //    Debug.Log(v.downloadHandler.text);
+    //}
     private async void Go()
     {
         await UniTask.DelayFrame(0);
@@ -492,248 +492,74 @@ public class SandboxMain : MonoBehaviour
         Debug.Log("Current SyncContext:" + SynchronizationContext.Current.GetType().FullName);
     }
 
+
+    async UniTask QuitCheck()
+    {
+        try
+        {
+            await UniTask.Delay(TimeSpan.FromMinutes(1), cancellationToken: quitSource.Token);
+        }
+        finally
+        {
+            Debug.Log("End QuitCheck async");
+        }
+    }
+
+    CancellationTokenSource quitSource = new CancellationTokenSource();
+
+
+    IEnumerator TestCor()
+    {
+        Debug.Log("start cor");
+        yield return null;
+        yield return new WaitForEndOfFrame();
+        Debug.Log("end cor");
+    }
+
+    IEnumerator LastYieldCore()
+    {
+        Debug.Log("YieldBegin:" + Time.frameCount);
+        yield return new WaitForEndOfFrame();
+        Debug.Log("YieldEnd:" + Time.frameCount);
+    }
+
+    private static async UniTask TestAsync(CancellationToken ct)
+    {
+        Debug.Log("TestAsync Start.");
+        var count = 0;
+        while (!ct.IsCancellationRequested)
+        {
+            try
+            {
+                Debug.Log($"TestAsync try count:{++count}");
+                var task1 = new WaitUntil(() => UnityEngine.Random.Range(0, 10) == 0).ToUniTask();
+                var task2 = new WaitUntil(() => UnityEngine.Random.Range(0, 10) == 0).ToUniTask();
+                var task3 = new WaitUntil(() => UnityEngine.Random.Range(0, 10) == 0).ToUniTask();
+
+                await UniTask.WhenAny(task1, task2, task3);
+            }
+            catch (Exception e)
+            {
+                Debug.LogError(e);
+                return;
+            }
+        }
+        Debug.Log("TestAsync Finished.");
+    }
+
     async UniTaskVoid Start()
     {
-        //Expression.Lambda<Func<int>>(null).Compile(true);
-
-        //RunStandardTaskAsync();
-
-        //UnityEngine.Debug.Log("UniTaskPlayerLoop ready? " + PlayerLoopHelper.IsInjectedUniTaskPlayerLoop());
-
-        //var url =  "http://google.com/404";
-        //var webRequestAsyncOperation = UnityWebRequest.Get(url).SendWebRequest();
-        //await webRequestAsyncOperation.ToUniTask();
-
-        //PlayerLoopInfo.Inject();
-
-        //_ = AsyncFixedUpdate();
-        //StartCoroutine(CoroutineFixedUpdate());
-
-        //StartCoroutine(TestCoroutine().ToCoroutine());
-
-        // Application.logMessageReceived += Application_logMessageReceived;
-
-        // var rp = new AsyncReactiveProperty<int>();
-
-
-        // rp.AddTo(this.GetCancellationTokenOnDestroy());
-        //var cts = new CancellationTokenSource();
-
-
-        // UniTask.Post(
-
-        // CancellationToken.
-
-        //UniTask.Delay(TimeSpan.FromSeconds(3)).
-
-
+        var cts = new CancellationTokenSource();
 
+        TestAsync(cts.Token).Forget();
 
         okButton.onClick.AddListener(UniTask.UnityAction(async () =>
         {
-
-            var client = new NetworkClient("http://localhost:5000", TimeSpan.FromSeconds(2),
-                new QueueRequestDecorator(),
-                new LoggingDecorator());
-            //new AppendTokenDecorator(),
-            //new SetupHeaderDecorator());
-
-
-            await client.PostAsync("", new { Id = 100 });
-
-
+            cts.Cancel();
+            await UniTask.Yield();
         }));
 
-        //    _ = ExecuteAsync();
-
-        //    await UniTask.Yield();
-
-        //    //await DelayCheck();
-        //    /*
-        //    UnityEngine.Debug.Log("click:" + PlayerLoopInfo.CurrentLoopType);
-        //    StartCoroutine(CoroutineRun());
-        //    StartCoroutine(CoroutineRun2());
-        //    _ = AsyncRun();
-        //    _ = AsyncLastUpdate();
-        //    _ = AsyncLastLast();
-        //    */
-        //    //await UniTask.Yield();
-        //    //_ = Test2();
-        //    // EarlyUpdate.ExecuteMainThreadJobs
-        //    // _ = Test2();
-
-        //    //var t = await Resources.LoadAsync<TextAsset>(Application.streamingAssetsPath + "test.txt");
-        //    //Debug.Log("LoadEnd" + PlayerLoopInfo.CurrentLoopType + ", " + (t != null));
-        //    //Debug.Log("LoadEnd" + PlayerLoopInfo.CurrentLoopType + ", " + ((TextAsset)t).text);
-
-
-        //    //await UniTask.Yield(PlayerLoopTiming.LastUpdate);
-        //    //UnityEngine.Debug.Log("after update:" + Time.frameCount);
-        //    ////await UniTask.NextFrame();
-        //    ////await UniTask.Yield();
-        //    ////UnityEngine.Debug.Log("after update nextframe:" + Time.frameCount);
-
-        //    //StartCoroutine(CoroutineRun2());
-        //    ////StartCoroutine(CoroutineRun());
-        //    //UnityEngine.Debug.Log("FOO?");
-
-        //    //_ = DelayFrame3_Pre();
-        //    //await UniTask.Yield();
-
-        //}));
-
-        //cancelButton.onClick.AddListener(UniTask.UnityAction(async () =>
-        //{
-        //    _ = DelayFrame3_Post();
-        //    await UniTask.Yield();
-
-        //    //await UniTask.Yield(PlayerLoopTiming.LastPreUpdate);
-        //    //UnityEngine.Debug.Log("before update:" + Time.frameCount);
-        //    //await UniTask.NextFrame();
-        //    //await UniTask.Yield();
-        //    //UnityEngine.Debug.Log("before update nextframe:" + Time.frameCount);
-
-        //    //StartCoroutine(CoroutineRun());
-
-        //    //UnityEngine.Debug.Log("click:" + PlayerLoopInfo.CurrentLoopType);
-        //    //_ = Yieldding();
-
-        //    //var cts = new CancellationTokenSource();
-
-        //    //UnityEngine.Debug.Log("click:" + PlayerLoopInfo.CurrentLoopType + ":" + Time.frameCount);
-        //    //var la = SceneManager.LoadSceneAsync("Scenes/ExceptionExamples").WithCancellation(cts.Token);
-        //    ////cts.Cancel();
-        //    //await la;
-        //    //UnityEngine.Debug.Log("End LoadSceneAsync" + PlayerLoopInfo.CurrentLoopType + ":" + Time.frameCount);
-        //}));
-
-        //return;
-        //await UniTask.SwitchToMainThread();
-
-        //UniTaskAsyncEnumerable.EveryValueChanged(mcc, x => x.MyProperty)
-        //    .Do(_ => { }, () => Debug.Log("COMPLETED"))
-        //    .ForEachAsync(x =>
-        //    {
-        //        Debug.Log("VALUE_CHANGED:" + x);
-        //    })
-        //    .Forget();
-
-        //_ = Test1();
-        //Test2().Forget();
-        //StartCoroutine(Test3("https://bing.com/"));
-
-
-
-
-
-        //bool flip = false;
-        //var rect = cancelButton.GetComponent<RectTransform>();
-        //var cts = new CancellationTokenSource();
-        //var ct = cts.Token;
-        //okButton.onClick.AddListener(UniTask.UnityAction(async () =>
-        //{
-        //    await rect.DOMoveX(10f * (flip ? -1 : 1), 3).OnUpdate(() => { Debug.Log("UPDATE YEAH"); }).WithCancellation(ct);
-        //    flip = !flip;
-        //    // ok.
-        //}));
-        //cancelButton.onClick.AddListener(() =>
-        //{
-        //    cts.Cancel();
-        //});
-
-
-        // DG.Tweening.Core.TweenerCore<int>
-        //Debug.Log("GO MOVEX");
-        //await okButton.GetComponent<RectTransform>().DOMoveX(-10.2f, 3).WithCancellation(CancellationToken.None);
-        //Debug.Log("END MOVEX");
-
-
-        //Debug.Log("AGAIN MOVE");
-        //await okButton.GetComponent<RectTransform>().DOMoveY(10.2f, 3).WithCancellation(CancellationToken.None);
-        //Debug.Log("AGAIN END MOVE");
-
-        //Debug.Log(Test().GetType().FullName);
-
-
-
-        // check stacktrace
-        // await UniTaskAsyncEnumerable.EveryUpdate().Where((x, i) => i % 2 == 0).Select(x => x).DistinctUntilChanged().ForEachAsync(x =>
-        //{
-        // Debug.Log("test");
-        //});
-
-
-
-
-        //// DOTween.To(
-
-        //var cts = new CancellationTokenSource();
-
-        ////var tween = okButton.GetComponent<RectTransform>().DOLocalMoveX(100, 5.0f);
-
-        //cancelButton.OnClickAsAsyncEnumerable().ForEachAsync(_ =>
-        //{
-        //    cts.Cancel();
-        //}).Forget();
-
-
-        //// await tween.ToUniTask(TweenCancelBehaviour.KillAndCancelAwait, cts.Token);
-
-        ////tween.SetRecyclable(true);
-
-        //Debug.Log("END");
-
-        //// tween.Play();
-
-        //// DOTween.
-
-        //// DOVirtual.Float(0, 1, 1, x => { }).ToUniTask();
-
-
-        //await foreach (var _ in UniTaskAsyncEnumerable.EveryUpdate())
-        //{
-        //    Debug.Log("Update() " + Time.frameCount);
-        //}
-
-
-
-        //await okButton.OnClickAsAsyncEnumerable().Where((x, i) => i % 2 == 0).ForEachAsync(_ =>
-        //{
-        //});
-
-
-        //okButton.OnClickAsAsyncEnumerable().ForEachAsync(_ =>
-        //{
-
-
-        //foreach (var (type, size) in TaskPool.GetCacheSizeInfo())
-        //{
-        //    Debug.Log(type + ":" + size);
-        //}
-
-
-        //}).Forget();
-
-        //CloseAsync(this.GetCancellationTokenOnDestroy()).Forget();
-
-        //okButton.onClick.AddListener(UniTask.UnityAction(async () => await UniTask.Yield()));
-
-
-
-        //UpdateUniTask().Forget();
-
-        //StartCoroutine(Coroutine());
-
-        // PlayerLoopInfo.Inject();
-        await UniTask.Delay(TimeSpan.FromSeconds(1));
-        PlayerLoopInfo.DumpPlayerLoop("current", PlayerLoop.GetCurrentPlayerLoop());
-
-
-        // _ = ReturnToMainThreadTest();
-
-        //GameObject.Destroy(this.gameObject);
-
-
+        await UniTask.Yield();
     }
 
     private void Application_logMessageReceived2(string condition, string stackTrace, LogType type)

src/UniTask/Assets/Tests/AsyncTest.cs

@@ -55,6 +55,8 @@ namespace Cysharp.Threading.TasksTests
             }
         }
 
+#if !UNITY_WEBGL
+
         [UnityTest]
         public IEnumerator DelayAnd() => UniTask.ToCoroutine(async () =>
         {
@@ -76,6 +78,8 @@ namespace Cysharp.Threading.TasksTests
             }
         });
 
+#endif
+
         [UnityTest]
         public IEnumerator DelayIgnore() => UniTask.ToCoroutine(async () =>
         {
@@ -183,6 +187,8 @@ namespace Cysharp.Threading.TasksTests
             diff.Should().Be(11);
         });
 
+#if !UNITY_WEBGL
+
         [UnityTest]
         public IEnumerator SwitchTo() => UniTask.ToCoroutine(async () =>
         {
@@ -215,6 +221,8 @@ namespace Cysharp.Threading.TasksTests
             currentThreadId.Should().Be(switchedThreadId2);
         });
 
+#endif
+
         //[UnityTest]
         //public IEnumerator ObservableConversion() => UniTask.ToCoroutine(async () =>
         //{

src/UniTask/Assets/Tests/CoroutineToUniTaskTest.cs

@@ -135,6 +135,8 @@ namespace Cysharp.Threading.TasksTests
             l.Add(30);
         }
 
+#if !UNITY_WEBGL
+
         [UnityTest]
         public IEnumerator WaitForSecondsTest() => UniTask.ToCoroutine(async () =>
         {
@@ -162,6 +164,8 @@ namespace Cysharp.Threading.TasksTests
             yield return new WaitForSeconds(3.0f);
         }
 
+#endif
+
         IEnumerator Worker(List<(int, int)> l)
         {
             l.Add((0, Time.frameCount));

src/UniTask/Assets/Tests/DelayTest.cs

@@ -175,6 +175,7 @@ namespace Cysharp.Threading.TasksTests
             }
         });
 
+#if !UNITY_WEBGL
 
         [UnityTest]
         public IEnumerator DelayInThreadPool() => UniTask.ToCoroutine(async () =>
@@ -185,6 +186,8 @@ namespace Cysharp.Threading.TasksTests
             });
         });
 
+#endif
+
         [UnityTest]
         public IEnumerator DelayRealtime() => UniTask.ToCoroutine(async () =>
         {
@@ -200,5 +203,16 @@ namespace Cysharp.Threading.TasksTests
             okay1.Should().Be(true);
             okay2.Should().Be(true);
         });
+
+
+        [UnityTest]
+        public IEnumerator LoopTest() => UniTask.ToCoroutine(async () =>
+        {
+            for (int i = 0; i < 20; ++i)
+            {
+                UniTask.DelayFrame(100).Forget();
+                await UniTask.DelayFrame(1);
+            }
+        });
     }
 }

src/UniTask/Assets/Tests/RunTest.cs

@@ -37,6 +37,7 @@ namespace Cysharp.Threading.TasksTests
     {
 #if CSHARP_7_OR_LATER || (UNITY_2018_3_OR_NEWER && (NET_STANDARD_2_0 || NET_4_6))
 #if !UNITY_WSA
+#if !UNITY_WEBGL
 
         //[UnityTest]
         //public IEnumerator RunThread() => UniTask.ToCoroutine(async () =>
@@ -88,7 +89,7 @@ namespace Cysharp.Threading.TasksTests
             }
         });
 
-
+#endif
 #endif
 #endif
     }

src/UniTask/ProjectSettings/PackageManagerSettings.asset

@@ -0,0 +1,43 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &1
+MonoBehaviour:
+  m_ObjectHideFlags: 61
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 13964, guid: 0000000000000000e000000000000000, type: 0}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_EnablePreviewPackages: 0
+  m_EnablePackageDependencies: 0
+  m_AdvancedSettingsExpanded: 1
+  m_ScopedRegistriesSettingsExpanded: 1
+  oneTimeWarningShown: 0
+  m_Registries:
+  - m_Id: main
+    m_Name: 
+    m_Url: https://packages.unity.com
+    m_Scopes: []
+    m_IsDefault: 1
+    m_Capabilities: 7
+  m_UserSelectedRegistryName: 
+  m_UserAddingNewScopedRegistry: 0
+  m_RegistryInfoDraft:
+    m_ErrorMessage: 
+    m_Original:
+      m_Id: 
+      m_Name: 
+      m_Url: 
+      m_Scopes: []
+      m_IsDefault: 0
+      m_Capabilities: 0
+    m_Modified: 0
+    m_Name: 
+    m_Url: 
+    m_Scopes:
+    - 
+    m_SelectedScopeIndex: 0

src/UniTask/ProjectSettings/ProjectSettings.asset

@@ -543,7 +543,7 @@ PlayerSettings:
   platformArchitecture: {}
   scriptingBackend:
     Android: 1
-    Standalone: 0
+    Standalone: 1
   il2cppCompilerConfiguration: {}
   managedStrippingLevel: {}
   incrementalIl2cppBuild: {}

src/UniTask/ProjectSettings/ProjectVersion.txt

@@ -1,2 +1,2 @@
-m_EditorVersion: 2019.4.5f1
-m_EditorVersionWithRevision: 2019.4.5f1 (81610f64359c)
+m_EditorVersion: 2020.2.1f1
+m_EditorVersionWithRevision: 2020.2.1f1 (270dd8c3da1c)

src/UniTask/ProjectSettings/VersionControlSettings.asset

@@ -0,0 +1,8 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!890905787 &1
+VersionControlSettings:
+  m_ObjectHideFlags: 0
+  m_Mode: Visible Meta Files
+  m_CollabEditorSettings:
+    inProgressEnabled: 1

src/UniTask/UserSettings/EditorUserSettings.asset

@@ -0,0 +1,24 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!162 &1
+EditorUserSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 4
+  m_ConfigSettings:
+    RecentlyUsedScenePath-0:
+      value: 22424703114646680e0b0227036c6c1118131a25340527392367083debf42d
+      flags: 0
+    vcSharedLogLevel:
+      value: 0d5e400f0650
+      flags: 0
+  m_VCAutomaticAdd: 1
+  m_VCDebugCom: 0
+  m_VCDebugCmd: 0
+  m_VCDebugOut: 0
+  m_SemanticMergeMode: 2
+  m_VCShowFailedCheckout: 1
+  m_VCOverwriteFailedCheckoutAssets: 1
+  m_VCProjectOverlayIcons: 1
+  m_VCHierarchyOverlayIcons: 1
+  m_VCOtherOverlayIcons: 1
+  m_VCAllowAsyncUpdate: 0