public void Complete(Exception exception)
{
_exception = exception;
isCompleted = true;
if (_continuation != null)
{
UnityTaskUtil.RunOnUnityThread(_continuation);
}
}
private static async Task <bool> TestAwaitCoroutineAsync()
{
var hostBehaviour = new GameObject("Test").AddComponent <TestHostBehaviour>();
bool result = false;
await UnityTaskUtil.StartCoroutineAsync(LongRunningCoroutine(() => { result = true; }), hostBehaviour);
//If we don't await till the coroutine is fully complete result will still be false here
return(result);
}
public IEnumerator CanStartCoroutineFromBackgroundThread()
{
var hostBehaviour = new GameObject("Test").AddComponent <TestHostBehaviour>();
var result = false;
var task = Task.Run(() =>
{
//Start coroutine and block task thread until coroutine is complete
Assert.IsFalse(UnityTaskUtil.CurrentThreadIsUnityThread);
UnityTaskUtil.StartCoroutineAsync(LongRunningCoroutine(() => { result = true; }), hostBehaviour).GetAwaiter().GetResult();
});
yield return(new WaitUntil(() => task.IsCompleted));
Assert.IsTrue(result);
}
public IEnumerator InstantiateAsync()
{
var prefab = new GameObject();
GameObject clone = null;
//Call instantiate from background thread
var task = Task.Run(() =>
{
clone = UnityTaskUtil.InstantiateAsync(prefab).Result;
});
yield return(new WaitUntil(() => task.IsCompleted));
Assert.IsTrue(clone != null);
}
public IEnumerator InstantiateAsync_WithParent()
{
var prefab = new GameObject();
var parent = new GameObject().transform;
GameObject clone = null;
//Call instantiate from background thread
var task = Task.Run(() =>
{
clone = UnityTaskUtil.InstantiateAsync(prefab, parent).Result;
});
yield return(new WaitUntil(() => task.IsCompleted));
Assert.IsTrue(clone != null && clone.transform.parent == parent);
}
public IEnumerator RunOnUnityThreadAsync()
{
var task1 = UnityTaskUtil.RunOnUnityThreadAsync(() => UnityTaskUtil.CurrentThreadIsUnityThread);
Assert.IsTrue(task1.Result);
var task2 = Task.Run(() =>
{
return(UnityTaskUtil.RunOnUnityThreadAsync(() => UnityTaskUtil.CurrentThreadIsUnityThread).Result);
});
//Need to do a coroutine here because task2 waits on the result of the thing running on the main thread
//so we can't block the main thread till it's done
yield return(new WaitUntil(() => task2.IsCompleted));
Assert.IsTrue(task2.Result);
}
public IEnumerator StartCoroutineAsync()
{
var testHost = new GameObject().AddComponent <TestHostBehaviour>();
int count = 0;
int countTo = 3;
var task = Task.Run(() =>
{
var coroutine = UnityTaskUtil.StartCoroutineAsync(TestCoroutine(() =>
{
count++;
return(count < countTo);
}), testHost);
//Wait for coroutine to finish
coroutine.GetAwaiter().GetResult();
});
yield return(new WaitUntil(() => task.IsCompleted));
Assert.IsTrue(count >= countTo);
}
public IEnumerator StartCancelableCoroutine()
{
var testHost = new GameObject().AddComponent <TestHostBehaviour>();
var cancelTokenSource = new CancellationTokenSource();
var token = cancelTokenSource.Token;
var task = Task.Run(() =>
{
var coroutine = UnityTaskUtil.StartCancelableCoroutineAsync(TestForeverCoroutine(), testHost, token);
coroutine.GetAwaiter().GetResult();
});
yield return(null);
Assert.IsFalse(task.IsCompleted);
cancelTokenSource.Cancel();
yield return(null);
Assert.IsTrue(task.IsCompleted);
}
public IEnumerator RunOnUnityThread()
{
bool checkOne = false;
bool checkTwo = false;
//Post the first check to the context
UnityTaskUtil.RunOnUnityThread(() => { checkOne = UnityTaskUtil.CurrentThreadIsUnityThread; });
//Wait a frame so it has a chance to run
yield return(null);
var task = Task.Run(() =>
{
UnityTaskUtil.RunOnUnityThread(() => { checkTwo = UnityTaskUtil.CurrentThreadIsUnityThread; });
});
//Wait for the task to run and post the function to the context
task.Wait();
//Wait a frame for the posted function to get called on the unity context
yield return(null);
Assert.IsTrue(checkOne);
Assert.IsTrue(checkTwo);
}
/// <summary>
/// Use this method to start a coroutine from any thread.
/// Coroutines themselves always run on the main thread
/// </summary>
/// <param name="enumerator">coroutine to run</param>
public static void Start(IEnumerator enumerator)
{
UnityTaskUtil.RunOnUnityThread(() => Run(enumerator, cancellationTokenSource.Token));
}
/// <summary>
/// Use this method when you want to await coroutine completion.
/// Coroutine itself will always run on the main thread.
/// </summary>
/// <param name="routine">coroutine to run</param>
/// <returns>awaitable task</returns>
public static async Task RunAsync(IEnumerator routine)
{
await UnityTaskUtil.RunOnUnityThreadAsync(() => Run(routine, cancellationTokenSource.Token));
}
/// <summary>
/// Use this method to start a coroutine from any thread.
/// Coroutines themselves always run on the main thread
/// </summary>
/// <param name="enumerator">coroutine to run</param>
public static void Start(IEnumerator enumerator)
{
UnityTaskUtil.RunOnUnityThread(async() => await RunAsync(enumerator, cancellationTokenSource.Token).ConfigureAwait(false));
}
/// <summary>
/// Use this method when you want to await coroutine completion.
/// Coroutine itself will always run on the main thread.
/// </summary>
/// <param name="routine">coroutine to run</param>
/// <returns>awaitable task</returns>
public static async Task RunAsync(IEnumerator routine)
{
await UnityTaskUtil.RunOnUnityThreadAsync(async() => await RunAsync(routine, cancellationTokenSource.Token).ConfigureAwait(false));
}
