Merge branch 'master' of github.com:Cysharp/UniTask

Assets/Tests/AsyncTest.cs

@@ -395,6 +395,40 @@ namespace UniRx.AsyncTests
             yield return new WaitForSeconds(3);
         }
 
+        [UnityTest]
+        public IEnumerator ToObservable() => UniTask.ToCoroutine(async () =>
+        {
+            var completedTaskObserver = new ToObservableObserver<AsyncUnit>();
+            completedTaskObserver.OnNextCalled.Should().BeFalse();
+            completedTaskObserver.OnCompletedCalled.Should().BeFalse();
+            completedTaskObserver.OnErrorCalled.Should().BeFalse();
+            UniTask.CompletedTask.ToObservable().Subscribe(completedTaskObserver);
+            completedTaskObserver.OnNextCalled.Should().BeTrue();
+            completedTaskObserver.OnCompletedCalled.Should().BeTrue();
+            completedTaskObserver.OnErrorCalled.Should().BeFalse();
+
+            var delayFrameTaskObserver = new ToObservableObserver<int>();
+            UniTask.DelayFrame(1).ToObservable().Subscribe(delayFrameTaskObserver);
+            delayFrameTaskObserver.OnNextCalled.Should().BeFalse();
+            delayFrameTaskObserver.OnCompletedCalled.Should().BeFalse();
+            delayFrameTaskObserver.OnErrorCalled.Should().BeFalse();
+            await UniTask.DelayFrame(1);
+            delayFrameTaskObserver.OnNextCalled.Should().BeTrue();
+            delayFrameTaskObserver.OnCompletedCalled.Should().BeTrue();
+            delayFrameTaskObserver.OnErrorCalled.Should().BeFalse();
+        });
+
+        class ToObservableObserver<T> : IObserver<T>
+        {
+            public bool OnNextCalled { get; private set; }
+            public bool OnCompletedCalled { get; private set; }
+            public bool OnErrorCalled { get; private set; }
+
+            public void OnNext(T value) => OnNextCalled = true;
+            public void OnCompleted() => OnCompletedCalled = true;
+            public void OnError(Exception error) => OnErrorCalled = true;
+        }
+
 #endif
 #endif
     }

Assets/UniRx.Async/Internal/ReusablePromise.cs

@@ -391,5 +391,5 @@ namespace UniRx.Async.Internal
         public abstract bool MoveNext();
     }
 
-#endif
 }
+#endif

Assets/UniRx.Async/Triggers/AsyncBeginDragTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncBeginDragTrigger : AsyncTriggerBase
+    public class AsyncBeginDragTrigger : AsyncTriggerBase, IBeginDragHandler
     {
         AsyncTriggerPromise<PointerEventData> onBeginDrag;
         AsyncTriggerPromiseDictionary<PointerEventData> onBeginDrags;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnBeginDrag(PointerEventData eventData)
+        void IBeginDragHandler.OnBeginDrag(PointerEventData eventData)
         {
             TrySetResult(onBeginDrag, onBeginDrags, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncCancelTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncCancelTrigger : AsyncTriggerBase
+    public class AsyncCancelTrigger : AsyncTriggerBase, ICancelHandler
     {
         AsyncTriggerPromise<BaseEventData> onCancel;
         AsyncTriggerPromiseDictionary<BaseEventData> onCancels;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnCancel(BaseEventData eventData)
+        void ICancelHandler.OnCancel(BaseEventData eventData)
         {
             TrySetResult(onCancel, onCancels, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncDeselectTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncDeselectTrigger : AsyncTriggerBase
+    public class AsyncDeselectTrigger : AsyncTriggerBase, IDeselectHandler
     {
         AsyncTriggerPromise<BaseEventData> onDeselect;
         AsyncTriggerPromiseDictionary<BaseEventData> onDeselects;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnDeselect(BaseEventData eventData)
+        void IDeselectHandler.OnDeselect(BaseEventData eventData)
         {
             TrySetResult(onDeselect, onDeselects, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncDragTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncDragTrigger : AsyncTriggerBase
+    public class AsyncDragTrigger : AsyncTriggerBase, IDragHandler
     {
         AsyncTriggerPromise<PointerEventData> onDrag;
         AsyncTriggerPromiseDictionary<PointerEventData> onDrags;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnDrag(PointerEventData eventData)
+        void IDragHandler.OnDrag(PointerEventData eventData)
         {
             TrySetResult(onDrag, onDrags, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncDropTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncDropTrigger : AsyncTriggerBase
+    public class AsyncDropTrigger : AsyncTriggerBase, IDropHandler
     {
         AsyncTriggerPromise<PointerEventData> onDrop;
         AsyncTriggerPromiseDictionary<PointerEventData> onDrops;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnDrop(PointerEventData eventData)
+        void IDropHandler.OnDrop(PointerEventData eventData)
         {
             TrySetResult(onDrop, onDrops, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncEndDragTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncEndDragTrigger : AsyncTriggerBase
+    public class AsyncEndDragTrigger : AsyncTriggerBase, IEndDragHandler
     {
         AsyncTriggerPromise<PointerEventData> onEndDrag;
         AsyncTriggerPromiseDictionary<PointerEventData> onEndDrags;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnEndDrag(PointerEventData eventData)
+        void IEndDragHandler.OnEndDrag(PointerEventData eventData)
         {
             TrySetResult(onEndDrag, onEndDrags, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncInitializePotentialDragTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncInitializePotentialDragTrigger : AsyncTriggerBase
+    public class AsyncInitializePotentialDragTrigger : AsyncTriggerBase, IInitializePotentialDragHandler
     {
         AsyncTriggerPromise<PointerEventData> onInitializePotentialDrag;
         AsyncTriggerPromiseDictionary<PointerEventData> onInitializePotentialDrags;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnInitializePotentialDrag(PointerEventData eventData)
+        void IInitializePotentialDragHandler.OnInitializePotentialDrag(PointerEventData eventData)
         {
             TrySetResult(onInitializePotentialDrag, onInitializePotentialDrags, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncMoveTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncMoveTrigger : AsyncTriggerBase
+    public class AsyncMoveTrigger : AsyncTriggerBase, IMoveHandler
     {
         AsyncTriggerPromise<AxisEventData> onMove;
         AsyncTriggerPromiseDictionary<AxisEventData> onMoves;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnMove(AxisEventData eventData)
+        void IMoveHandler.OnMove(AxisEventData eventData)
         {
             TrySetResult(onMove, onMoves, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncPointerClickTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncPointerClickTrigger : AsyncTriggerBase
+    public class AsyncPointerClickTrigger : AsyncTriggerBase, IPointerClickHandler
     {
         AsyncTriggerPromise<PointerEventData> onPointerClick;
         AsyncTriggerPromiseDictionary<PointerEventData> onPointerClicks;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnPointerClick(PointerEventData eventData)
+        void IPointerClickHandler.OnPointerClick(PointerEventData eventData)
         {
             TrySetResult(onPointerClick, onPointerClicks, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncPointerDownTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncPointerDownTrigger : AsyncTriggerBase
+    public class AsyncPointerDownTrigger : AsyncTriggerBase, IPointerDownHandler
     {
         AsyncTriggerPromise<PointerEventData> onPointerDown;
         AsyncTriggerPromiseDictionary<PointerEventData> onPointerDowns;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnPointerDown(PointerEventData eventData)
+        void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
         {
             TrySetResult(onPointerDown, onPointerDowns, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncPointerEnterTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncPointerEnterTrigger : AsyncTriggerBase
+    public class AsyncPointerEnterTrigger : AsyncTriggerBase, IPointerEnterHandler
     {
         AsyncTriggerPromise<PointerEventData> onPointerEnter;
         AsyncTriggerPromiseDictionary<PointerEventData> onPointerEnters;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnPointerEnter(PointerEventData eventData)
+        void IPointerEnterHandler.OnPointerEnter(PointerEventData eventData)
         {
             TrySetResult(onPointerEnter, onPointerEnters, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncPointerExitTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncPointerExitTrigger : AsyncTriggerBase
+    public class AsyncPointerExitTrigger : AsyncTriggerBase, IPointerExitHandler
     {
         AsyncTriggerPromise<PointerEventData> onPointerExit;
         AsyncTriggerPromiseDictionary<PointerEventData> onPointerExits;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnPointerExit(PointerEventData eventData)
+        void IPointerExitHandler.OnPointerExit(PointerEventData eventData)
         {
             TrySetResult(onPointerExit, onPointerExits, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncPointerUpTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncPointerUpTrigger : AsyncTriggerBase
+    public class AsyncPointerUpTrigger : AsyncTriggerBase, IPointerUpHandler
     {
         AsyncTriggerPromise<PointerEventData> onPointerUp;
         AsyncTriggerPromiseDictionary<PointerEventData> onPointerUps;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnPointerUp(PointerEventData eventData)
+        void IPointerUpHandler.OnPointerUp(PointerEventData eventData)
         {
             TrySetResult(onPointerUp, onPointerUps, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncScrollTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncScrollTrigger : AsyncTriggerBase
+    public class AsyncScrollTrigger : AsyncTriggerBase, IScrollHandler
     {
         AsyncTriggerPromise<PointerEventData> onScroll;
         AsyncTriggerPromiseDictionary<PointerEventData> onScrolls;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnScroll(PointerEventData eventData)
+        void IScrollHandler.OnScroll(PointerEventData eventData)
         {
             TrySetResult(onScroll, onScrolls, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncSelectTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncSelectTrigger : AsyncTriggerBase
+    public class AsyncSelectTrigger : AsyncTriggerBase, ISelectHandler
     {
         AsyncTriggerPromise<BaseEventData> onSelect;
         AsyncTriggerPromiseDictionary<BaseEventData> onSelects;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnSelect(BaseEventData eventData)
+        void ISelectHandler.OnSelect(BaseEventData eventData)
         {
             TrySetResult(onSelect, onSelects, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncSubmitTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncSubmitTrigger : AsyncTriggerBase
+    public class AsyncSubmitTrigger : AsyncTriggerBase, ISubmitHandler
     {
         AsyncTriggerPromise<BaseEventData> onSubmit;
         AsyncTriggerPromiseDictionary<BaseEventData> onSubmits;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnSubmit(BaseEventData eventData)
+        void ISubmitHandler.OnSubmit(BaseEventData eventData)
         {
             TrySetResult(onSubmit, onSubmits, eventData);
         }

Assets/UniRx.Async/Triggers/AsyncUpdateSelectedTrigger.cs

@@ -10,7 +10,7 @@ using UnityEngine.EventSystems;
 namespace UniRx.Async.Triggers
 {
     [DisallowMultipleComponent]
-    public class AsyncUpdateSelectedTrigger : AsyncTriggerBase
+    public class AsyncUpdateSelectedTrigger : AsyncTriggerBase, IUpdateSelectedHandler
     {
         AsyncTriggerPromise<BaseEventData> onUpdateSelected;
         AsyncTriggerPromiseDictionary<BaseEventData> onUpdateSelecteds;
@@ -22,7 +22,7 @@ namespace UniRx.Async.Triggers
         }
 
 
-        void OnUpdateSelected(BaseEventData eventData)
+        void IUpdateSelectedHandler.OnUpdateSelected(BaseEventData eventData)
         {
             TrySetResult(onUpdateSelected, onUpdateSelecteds, eventData);
         }

Assets/UniRx.Async/UniTaskObservableExtensions.cs

@@ -257,6 +257,7 @@ namespace UniRx.Async
             public IDisposable Subscribe(IObserver<T> observer)
             {
                 observer.OnNext(value);
+                observer.OnCompleted();
                 return EmptyDisposable.Instance;
             }
         }

Assets/UniRx.Async/UnityAsyncExtensions.cs

@@ -59,6 +59,30 @@ namespace UniRx.Async
             return new UniTask<UnityEngine.Object>(awaiter);
         }
 
+        public static AssetBundleRequestAwaiter GetAwaiter(this AssetBundleRequest resourceRequest)
+        {
+            Error.ThrowArgumentNullException(resourceRequest, nameof(resourceRequest));
+            return new AssetBundleRequestAwaiter(resourceRequest);
+        }
+
+        public static UniTask<UnityEngine.Object> ToUniTask(this AssetBundleRequest resourceRequest)
+        {
+            Error.ThrowArgumentNullException(resourceRequest, nameof(resourceRequest));
+            return new UniTask<UnityEngine.Object>(new AssetBundleRequestAwaiter(resourceRequest));
+        }
+
+        public static UniTask<UnityEngine.Object> ConfigureAwait(this AssetBundleRequest resourceRequest, IProgress<float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellation = default(CancellationToken))
+        {
+            Error.ThrowArgumentNullException(resourceRequest, nameof(resourceRequest));
+
+            var awaiter = new AssetBundleRequestConfiguredAwaiter(resourceRequest, progress, cancellation);
+            if (!awaiter.IsCompleted)
+            {
+                PlayerLoopHelper.AddAction(timing, awaiter);
+            }
+            return new UniTask<UnityEngine.Object>(awaiter);
+        }
+
 #if ENABLE_WWW
 
 #if UNITY_2018_3_OR_NEWER
@@ -443,6 +467,166 @@ namespace UniRx.Async
             }
         }
 
+        public struct AssetBundleRequestAwaiter : IAwaiter<UnityEngine.Object>
+        {
+            AssetBundleRequest asyncOperation;
+            Action<AsyncOperation> continuationAction;
+            AwaiterStatus status;
+            UnityEngine.Object result;
+
+            public AssetBundleRequestAwaiter(AssetBundleRequest asyncOperation)
+            {
+                this.status = asyncOperation.isDone ? AwaiterStatus.Succeeded : AwaiterStatus.Pending;
+                this.asyncOperation = (this.status.IsCompleted()) ? null : asyncOperation;
+                this.result = (this.status.IsCompletedSuccessfully()) ? asyncOperation.asset : null;
+                this.continuationAction = null;
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+
+            public UnityEngine.Object GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return this.result;
+
+                if (status == AwaiterStatus.Pending)
+                {
+                    // first timing of call
+                    if (asyncOperation.isDone)
+                    {
+                        status = AwaiterStatus.Succeeded;
+                    }
+                    else
+                    {
+                        Error.ThrowNotYetCompleted();
+                    }
+                }
+
+                this.result = asyncOperation.asset;
+
+                if (continuationAction != null)
+                {
+                    asyncOperation.completed -= continuationAction;
+                    asyncOperation = null; // remove reference.
+                    continuationAction = null;
+                }
+                else
+                {
+                    asyncOperation = null; // remove reference.
+                }
+
+                return this.result;
+            }
+
+            void IAwaiter.GetResult() => GetResult();
+
+            public void OnCompleted(Action continuation)
+            {
+                UnsafeOnCompleted(continuation);
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(continuationAction);
+                continuationAction = continuation.AsFuncOfT<AsyncOperation>();
+                asyncOperation.completed += continuationAction;
+            }
+        }
+
+        class AssetBundleRequestConfiguredAwaiter : IAwaiter<UnityEngine.Object>, IPlayerLoopItem
+        {
+            AssetBundleRequest asyncOperation;
+            IProgress<float> progress;
+            CancellationToken cancellationToken;
+            AwaiterStatus status;
+            Action continuation;
+            UnityEngine.Object result;
+
+            public AssetBundleRequestConfiguredAwaiter(AssetBundleRequest asyncOperation, IProgress<float> progress, CancellationToken cancellationToken)
+            {
+                this.status = cancellationToken.IsCancellationRequested ? AwaiterStatus.Canceled
+                            : asyncOperation.isDone ? AwaiterStatus.Succeeded
+                            : AwaiterStatus.Pending;
+
+                if (this.status.IsCompletedSuccessfully()) this.result = asyncOperation.asset;
+                if (this.status.IsCompleted()) return;
+
+                this.asyncOperation = asyncOperation;
+                this.progress = progress;
+                this.cancellationToken = cancellationToken;
+                this.continuation = null;
+                this.result = null;
+
+                TaskTracker.TrackActiveTask(this, 2);
+            }
+
+            public bool IsCompleted => status.IsCompleted();
+            public AwaiterStatus Status => status;
+            void IAwaiter.GetResult() => GetResult();
+
+            public UnityEngine.Object GetResult()
+            {
+                if (status == AwaiterStatus.Succeeded) return this.result;
+
+                if (status == AwaiterStatus.Canceled)
+                {
+                    Error.ThrowOperationCanceledException();
+                }
+
+                return Error.ThrowNotYetCompleted<UnityEngine.Object>();
+            }
+
+            public bool MoveNext()
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    InvokeContinuation(AwaiterStatus.Canceled);
+                    return false;
+                }
+
+                if (progress != null)
+                {
+                    progress.Report(asyncOperation.progress);
+                }
+
+                if (asyncOperation.isDone)
+                {
+                    this.result = asyncOperation.asset;
+                    InvokeContinuation(AwaiterStatus.Succeeded);
+                    return false;
+                }
+
+                return true;
+            }
+
+            void InvokeContinuation(AwaiterStatus status)
+            {
+                this.status = status;
+                var cont = this.continuation;
+
+                // cleanup
+                TaskTracker.RemoveTracking(this);
+                this.continuation = null;
+                this.cancellationToken = CancellationToken.None;
+                this.progress = null;
+                this.asyncOperation = null;
+
+                if (cont != null) cont.Invoke();
+            }
+
+            public void OnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+
+            public void UnsafeOnCompleted(Action continuation)
+            {
+                Error.ThrowWhenContinuationIsAlreadyRegistered(this.continuation);
+                this.continuation = continuation;
+            }
+        }
+
 #if ENABLE_WWW
 
 #if UNITY_2018_3_OR_NEWER