public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress <float> progress =
null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken =
default(CancellationToken))
{
if (cancellationToken.IsCancellationRequested)
{
return(UniTask.FromCanceled(cancellationToken));
}
if (!handle.IsValid())
{
// autoReleaseHandle:true handle is invalid(immediately internal handle == null) so return completed.
return(UniTask.CompletedTask);
}
if (handle.IsDone)
{
if (handle.Status == AsyncOperationStatus.Failed)
{
return(UniTask.FromException(handle.OperationException));
}
return(UniTask.CompletedTask);
}
return(new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, out var token), token));
}
public static UniTask <T> ToUniTask <T>(this AsyncOperationHandle <T> handle, IProgress <float> progress =
null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken =
default(CancellationToken))
{
if (cancellationToken.IsCancellationRequested)
{
return(UniTask.FromCanceled <T>(cancellationToken));
}
if (!handle.IsValid())
{
throw new Exception("Attempting to use an invalid operation handle");
}
if (handle.IsDone)
{
if (handle.Status == AsyncOperationStatus.Failed)
{
return(UniTask.FromException <T>(handle.OperationException));
}
return(UniTask.FromResult(handle.Result));
}
return(new UniTask <T>(AsyncOperationHandleConfiguredSource <T> .Create(handle, timing, progress, cancellationToken, out var token), token));
}
public static UniTask <T> WithCancellation <T>(this AsyncOperationHandle <T> handle, CancellationToken cancellationToken)
{
if (handle.IsDone)
{
if (handle.Status == AsyncOperationStatus.Failed)
{
return(UniTask.FromException <T>(handle.OperationException));
}
return(UniTask.FromResult(handle.Result));
}
return(new UniTask <T>(AsyncOperationHandleWithCancellationSource <T> .Create(handle, cancellationToken, out var token), token));
}
public static UniTask ToUniTask(this AsyncOperationHandle handle, IProgress <float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
{
if (handle.IsDone)
{
if (handle.Status == AsyncOperationStatus.Failed)
{
return(UniTask.FromException(handle.OperationException));
}
return(UniTask.CompletedTask);
}
return(new UniTask(AsyncOperationHandleConfiguredSource.Create(handle, timing, progress, cancellationToken, out var token), token));
}
public static UniTask WithCancellation(this AsyncOperationHandle handle, CancellationToken cancellationToken)
{
if (handle.IsDone)
{
if (handle.Status == AsyncOperationStatus.Failed)
{
return(UniTask.FromException(handle.OperationException));
}
return(UniTask.CompletedTask);
}
return(new UniTask(AsyncOperationHandleWithCancellationSource.Create(handle, cancellationToken, out var token), token));
}
public override bool TryComplete(Exception error = null)
{
bool waiting;
lock (parent.items)
{
if (parent.closed)
{
return(false);
}
parent.closed = true;
waiting = parent.readerSource.isWaiting;
if (parent.items.Count == 0)
{
if (error == null)
{
if (parent.completedTaskSource != null)
{
parent.completedTaskSource.TrySetResult();
}
else
{
parent.completedTask = UniTask.CompletedTask;
}
}
else
{
if (parent.completedTaskSource != null)
{
parent.completedTaskSource.TrySetException(error);
}
else
{
parent.completedTask = UniTask.FromException(error);
}
}
if (waiting)
{
parent.readerSource.SingalCompleted(error);
}
}
parent.completionError = error;
}
return(true);
}
public static UniTask <UnityWebRequest> ToUniTask(this UnityWebRequestAsyncOperation asyncOperation, IProgress <float> progress = null, PlayerLoopTiming timing = PlayerLoopTiming.Update, CancellationToken cancellationToken = default(CancellationToken))
{
Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
if (cancellationToken.IsCancellationRequested)
{
return(UniTask.FromCanceled <UnityWebRequest>(cancellationToken));
}
if (asyncOperation.isDone)
{
if (asyncOperation.webRequest.IsError())
{
return(UniTask.FromException <UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest)));
}
return(UniTask.FromResult(asyncOperation.webRequest));
}
return(new UniTask <UnityWebRequest>(UnityWebRequestAsyncOperationConfiguredSource.Create(asyncOperation, timing, progress, cancellationToken, out var token), token));
}
public static UniTask <UnityWebRequest> WithCancellation(this UnityWebRequestAsyncOperation asyncOperation, CancellationToken cancellationToken)
{
Error.ThrowArgumentNullException(asyncOperation, nameof(asyncOperation));
if (cancellationToken.IsCancellationRequested)
{
return(UniTask.FromCanceled <UnityWebRequest>(cancellationToken));
}
if (asyncOperation.isDone)
{
if (asyncOperation.webRequest.IsError())
{
return(UniTask.FromException <UnityWebRequest>(new UnityWebRequestException(asyncOperation.webRequest)));
}
return(UniTask.FromResult(asyncOperation.webRequest));
}
return(new UniTask <UnityWebRequest>(UnityWebRequestAsyncOperationWithCancellationSource.Create(asyncOperation, cancellationToken, out var token), token));
}
public override bool TryRead(out T item)
{
lock (parent.items)
{
if (parent.items.Count != 0)
{
item = parent.items.Dequeue();
// complete when all value was consumed.
if (parent.closed && parent.items.Count == 0)
{
if (parent.completionError != null)
{
if (parent.completedTaskSource != null)
{
parent.completedTaskSource.TrySetException(parent.completionError);
}
else
{
parent.completedTask = UniTask.FromException(parent.completionError);
}
}
else
{
if (parent.completedTaskSource != null)
{
parent.completedTaskSource.TrySetResult();
}
else
{
parent.completedTask = UniTask.CompletedTask;
}
}
}
}
else
{
item = default;
return(false);
}
}
return(true);
}
public override UniTask <bool> WaitToReadAsync(CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return(UniTask.FromCanceled <bool>(cancellationToken));
}
lock (parent.items) {
if (parent.items.Count != 0)
{
return(CompletedTasks.True);
}
if (parent.closed)
{
if (parent.completionError == null)
{
return(CompletedTasks.False);
}
else
{
return(UniTask.FromException <bool>(parent.completionError));
}
}
cancellationTokenRegistration.Dispose();
core.Reset();
isWaiting = true;
this.cancellationToken = cancellationToken;
if (this.cancellationToken.CanBeCanceled)
{
cancellationTokenRegistration =
this.cancellationToken.RegisterWithoutCaptureExecutionContext(CancellationCallbackDelegate,
this);
}
return(new UniTask <bool>(this, core.Version));
}
}
