/// <summary>
/// Syncs with DB. returns newest.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public UnityTask <T> Sync <T>(T entity) where T : class
{
var task = new UnityTask <T>(TaskStrategy.Custom);
Sync(entity, task.FromResponse());
return(task);
}
IEnumerator DiablePresenceAsync(UnityTask <string> task)
{
var btask = BalancerClient.GetServerUrl(Url, IsCluster, ApplicationKey);
yield return(TaskManager.StartRoutine(btask.WaitRoutine()));
if (btask.IsFaulted)
{
task.Exception = btask.Exception;
task.Status = TaskStatus.Faulted;
yield break;
}
var server = btask.Result;
var presenceUrl = String.IsNullOrEmpty(server) ? server : server[server.Length - 1] == '/' ? server : server + "/";
presenceUrl = String.Format("{0}presence/disable/{1}/{2}", presenceUrl, ApplicationKey, Channel);
var content = String.Format("privatekey={0}", PrivateKey);
var htask = HttpClient.PostAsync(presenceUrl, content);
yield return(TaskManager.StartRoutine(htask.WaitRoutine()));
if (htask.IsFaulted)
{
task.Exception = htask.Exception;
task.Status = TaskStatus.Faulted;
yield break;
}
task.Result = htask.Content;
}
public void CreateAndRun()
{
UnityTask.Run(() =>
{
var result = FindPrimeNumber(1000);
});
}
/// <summary>
/// Tells the server to send out an recovery email. This email will contain a reset token.
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public UnityTask Reset(string email)
{
var task = new UnityTask(TaskStrategy.Custom);
Reset(email, task.FromResponse());
return(task);
}
IEnumerator TaskAsync(UnityTask task, bool hault = true)
{
yield return(1);
yield return(task);
if (task.IsFaulted)
{
if (task.Exception is HttpException)
{
var hte = task.Exception as HttpException;
foreach (var error in hte.GetErrors())
{
Debug.LogError(error);
}
}
else
{
Debug.LogError(task.Exception.Message);
}
if (hault)
{
Debug.LogError("Haulting");
StopAllCoroutines();
while (true)
{
yield return(1);
}
}
}
yield return(1);
}
IEnumerator GetUrlFromCluster(UnityTask task)
{
if (PrototypeUri.IsCluster)
{
var request = new Uri(PrototypeUri.IsSecure ? "https://" + PrototypeUri.Url + "/server/ssl/1.0" : "http://" + PrototypeUri.Url + "/server/1.0");
var www = Client.GetAsync(request.ToString());
yield return(TaskManager.StartRoutine(www.WaitRoutine()));
if (www.IsFaulted)
{
task.Status = TaskStatus.Faulted;
task.Exception = www.Exception;
yield break;
}
var response = JsonMapper.ToObject <ClusterResponse>(www.Content).url;
EnpointUri = new Uri(response);
//var request = new Uri(PrototypeUri.IsSecure ? "https://" + PrototypeUri.Url + "/server/ssl/1.0" : "http://" + PrototypeUri.Url + "/server/1.0");
//var response = ClusterClient.GetClusterServer(request.ToString(), ApplicationKey);
//EnpointUri = new Uri(response);
}
else
{
EnpointUri = new Uri(PrototypeUri.IsSecure ? "https://" + PrototypeUri.Url : "http://" + PrototypeUri.Url);
//EnpointUri = new Uri(PrototypeUri.IsSecure ? "https://" + PrototypeUri.Url + "/server/ssl/1.0" : "http://" + PrototypeUri.Url + "/server/1.0");
}
}
/// <summary>
/// Requests a new guest account. Use for 'Skip Sign In' option.
/// </summary>
/// <returns></returns>
public UnityTask Guest()
{
var task = new UnityTask(TaskStrategy.Custom);
Guest(task.FromResponse());
return(task);
}
public static void runInUnityThread(UnityTask task)
{
lock (taskList)
{
taskList.Add(task);
}
}
IEnumerator Test5(UnityTask UnityTask)
{
yield return(1);
Counter++;
Debug.Log("5 Coroutine with UnityTask");
}
/// <summary>
/// Deletes the entity serverside
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public UnityTask Delete <T>(T entity) where T : class
{
var task = new UnityTask(TaskStrategy.Custom);
Delete(entity, task.FromResponse());
return(task);
}
IEnumerator DemoCoroutineWithResult(UnityTask <string> task)
{
yield return(1);
Counter++;
task.Result = "Hello";
}
/// <summary>
/// Increments / Decrements a single property.
/// </summary>
/// <param name="id">ObjectId</param>
/// <param name="propertyName"></param>
/// <param name="delta">change</param>
/// <returns></returns>
public UnityTask UpdateDelta(string id, string propertyName, int delta = 1)
{
var task = new UnityTask(TaskStrategy.Custom);
UpdateDelta(id, propertyName, delta, task.FromResponse());
return(task);
}
/// <summary>
/// Updates a single property on an existing object
/// </summary>
/// <param name="id">ObjectId</param>
/// <param name="propertyName"></param>
/// <param name="propertyValue"></param>
/// <returns></returns>
public UnityTask UpdateProperty(string id, string propertyName, string propertyValue)
{
var task = new UnityTask(TaskStrategy.Custom);
UpdateProperty(id, propertyName, propertyValue, task.FromResponse());
return(task);
}
/// <summary>
/// Saves an existing object set serverside
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entities"></param>
/// <returns></returns>
public UnityTask UpdateSet <T>(T[] entities) where T : class
{
var task = new UnityTask(TaskStrategy.Custom);
UpdateSet(entities, task.FromResponse());
return(task);
}
private void DrawElementCallback(Rect rect, int index, bool isActive, bool isFocused)
{
Rect labelRect = new Rect(rect.x, rect.y, rect.xMax - 45f, 15f);
Rect plusRect = new Rect(rect.xMax - 8f - 25f, rect.y, 25f, 13f);
string str = _fileList[index].Title;
GUI.Label(labelRect, str);
if (GUI.Button(plusRect, iconToolbarPlus, preButton))
{
UnityTask.Run(async() =>
{
try
{
bool res = await CloudFileWatcher.DownloadFileAsync(SettingsDrawer.UserID, _fileList[index]);
if (!res)
{
Debug.LogWarning($"Could not download the file [{_fileList[index].Title}]");
}
}
catch (Exception e)
{
Debug.LogError("Exception thrown while downloading the file: " + e.Message + "\nInner Message: " + e.InnerException?.Message);
}
});
}
if (index + 1 < _list.count)
{
DrawingHelper.Separator(new Rect(labelRect.x, labelRect.y + EditorGUIUtility.singleLineHeight + 1.5f, rect.width, 1.2f));
}
}
IEnumerator Test8(UnityTask <string> UnityTask)
{
yield return(1);
Counter++;
UnityTask.Result = "8 Coroutine With Result";
}
/// <summary>
/// 分配座位
/// </summary>
private UnityTask InitSeat()
{
//假设目前是进入的一个房间，房间中是已经有其它玩家的，此时需要先根据情况分配他们的座位在自己客户端上
var players = _netComponent.WebClient.Room.PlayerList;
List <UnityTask> tasks = (players.Select(player =>
{
player.CustomProperties.TryGetString("Seat", out var seat);
return(new { player, seat });
})
.Where(@t1 => !string.IsNullOrEmpty(@t1.seat))
.Select(@t1 => new AVQuery <Player>()
.WhereEqualTo(_netComponent.GetProperty <Player>(p => p.UserId), @t1.player.UserId)
.FirstOrDefaultAsync()
.ContinueToForeground(t =>
{
_seats[int.Parse(@t1.seat)].Item2.text = t.Result.PetName;
//_playerToggle.transform.GetChild(int.Parse(@t1.seat)).GetComponentInChildren<Text>().text =
// t.Result.PetName;
return(0);
}))).Cast <UnityTask>()
.ToList();
return(UnityTask.WhenAll(tasks));
}
IEnumerator Test9(UnityTask <string> UnityTask)
{
yield return(1);
UnityTask.Result = ("9 Coroutine with UnityTask State Complete");
Counter++;
}
IEnumerator PostAsync <T>(UnityTask <StorageResponse <T> > task, string operation, string body)
{
// Confirm Endpoint URI
if (EnpointUri == null)
{
var urlTask = new UnityTask(TaskStrategy.Custom);
yield return(TaskManager.StartRoutine(GetUrlFromCluster(urlTask)));
if (EnpointUri == null)
{
task.Exception = new Exception("Failed to get cluster url");
task.Status = TaskStatus.Faulted;
yield break;
}
}
var url = EnpointUri.ToString().EndsWith("/") ? EnpointUri + operation : EnpointUri + "/" + operation;
var www = Client.PostAsync(url, body);
yield return(TaskManager.StartRoutine(www.WaitRoutine()));
if (www.IsFaulted)
{
task.Exception = www.Exception;
task.Status = TaskStatus.Faulted;
yield break;
}
Log(www.Content);
task.Result = JsonMapper.ToObject <StorageResponse <T> >(www.Content);
task.Status = TaskStatus.Success;
}
void BackgroundToBackgroundException()
{
var task1 = UnityTask.Run(() =>
{
Debug.Log("1 Go");
var task2 = UnityTask.Run(() =>
{
UnityTask.Delay(100);
Debug.Log("2 Go");
throw new Exception("2 Fail");
});
task2.Wait();
if (task2.IsFaulted)
{
throw task2.Exception;
}
});
task1.Wait();
Debug.Log(task1.Status + " " + task1.Exception.Message);
}
/// <summary>
/// Update account details
/// </summary>
/// <param name="email"></param>
/// <param name="password"></param>
/// <returns></returns>
public UnityTask Update(string email, string password)
{
var task = new UnityTask(TaskStrategy.Custom);
Update(email, password, task.FromResponse());
return(task);
}
/// <summary>
/// Saves the authentication token channels permissions in the ORTC server.
/// </summary>
public UnityTask <bool> PostAuthentication()
{
#region Sanity Checks
if (String.IsNullOrEmpty(Url))
{
return(UnityTask.FailedTask <bool>(new OrtcException(OrtcExceptionReason.InvalidArguments, "URL is null or empty.")));
}
if (String.IsNullOrEmpty(ApplicationKey))
{
return(UnityTask.FailedTask <bool>(new OrtcException(OrtcExceptionReason.InvalidArguments, "Application Key is null or empty.")));
}
if (String.IsNullOrEmpty(AuthenticationToken))
{
return(UnityTask.FailedTask <bool>(new OrtcException(OrtcExceptionReason.InvalidArguments, "Authentication Token is null or empty.")));
}
if (String.IsNullOrEmpty(PrivateKey))
{
return(UnityTask.FailedTask <bool>(new OrtcException(OrtcExceptionReason.InvalidArguments, "Private Key is null or empty.")));
}
if (Permissions != null && Permissions.Count == 0)
{
return(UnityTask.FailedTask <bool>(new OrtcException(OrtcExceptionReason.InvalidArguments, "No permissions set.")));
}
#endregion
return(UnityTask.RunCoroutine <bool>(PostAuthenticationAsync));
}
/// <summary>
/// Deletes the current account
/// </summary>
/// <param name="password"></param>
/// <returns></returns>
public UnityTask Delete(string password)
{
var task = new UnityTask(TaskStrategy.Custom);
Delete(password, task.FromResponse());
return(task);
}
public void TaskDoesEndOnResolveAndReject()
{
bool value = false;
bool targetValue = true;
UnityTask t = new UnityTask();
t.Then(onEnd: () => value = targetValue);
t.Resolve(null);
Assert.AreEqual(value, targetValue);
value = false;
t = new UnityTask();
t.Then(onEnd: () => value = targetValue);
t.Reject(null);
Assert.AreEqual(value, targetValue);
value = false;
t = new UnityTask();
t.Then(onEnd: () => value = targetValue);
t.Notify(0f);
Assert.AreNotEqual(value, targetValue);
}
IEnumerator GetPresenceAsync(UnityTask <Presence> task)
{
var btask = BalancerClient.GetServerUrl(Url, IsCluster, ApplicationKey);
yield return(TaskManager.StartRoutine(btask.WaitRoutine()));
if (btask.IsFaulted)
{
task.Exception = btask.Exception;
task.Status = TaskStatus.Faulted;
yield break;
}
var server = btask.Result;
var presenceUrl = String.IsNullOrEmpty(server) ? server : server[server.Length - 1] == '/' ? server : server + "/";
presenceUrl = String.Format("{0}presence/{1}/{2}/{3}", presenceUrl, ApplicationKey, AuthenticationToken, Channel);
var htask = HttpClient.GetAsync(presenceUrl);
yield return(TaskManager.StartRoutine(htask.WaitRoutine()));
if (htask.IsFaulted)
{
task.Exception = htask.Exception;
task.Status = TaskStatus.Faulted;
yield break;
}
task.Result = Deserialize(htask.Content);
}
IEnumerator GetClusterServerWithRetryAsync(UnityTask <string> task)
{
int currentAttempts;
for (currentAttempts = 0; currentAttempts <= MaxConnectionAttempts; currentAttempts++)
{
var innerTask = GetClusterServer();
yield return(TaskManager.StartRoutine(innerTask.WaitRoutine()));
task.Result = innerTask.Result;
if (innerTask.IsSuccess && !String.IsNullOrEmpty(task.Result))
{
yield break;
}
currentAttempts++;
if (currentAttempts > MaxConnectionAttempts)
{
task.Exception = new OrtcException(OrtcExceptionReason.ConnectionError, "Unable to connect to the authentication server.");
task.Status = TaskStatus.Faulted;
yield break;
}
yield return(TaskManager.WaitForSeconds(RetryThreadSleep));
}
}
public UnityTask <List <CharacterResult> > GetUserCharacters(bool forceUpdate = false)
{
if (forceUpdate)
{
this.characterCache = null;
}
if (this.characterCache != null)
{
return(UnityTask <List <CharacterResult> > .Empty(this.characterCache));
}
else
{
return(UnityTask <List <CharacterResult> > .Run(FetchCharacters()));
}
IEnumerator <List <CharacterResult> > FetchCharacters()
{
var getCharacters = this.playfabManager.Do <ListUsersCharactersRequest, ListUsersCharactersResult>(new ListUsersCharactersRequest(), PlayFabClientAPI.GetAllUsersCharactersAsync);
while (getCharacters.IsDone == false)
{
yield return(null);
}
this.characterCache = getCharacters.Value.Characters;
yield return(this.characterCache);
}
}
void Update()
{
// Starting more than one (1) Task per update seems to slow down the UI
// This ensures that only one(1) Task is started per frame (as long as maxTasksPerUpdate=1)
int tasksEnqueuedThisUpdate = 0;
for (int i = 0; i < scheduledTasks.Count; i++)
{
if (tasksEnqueuedThisUpdate < maxTasksPerUpdate)
{
UnityTask task = scheduledTasks.Dequeue();
runningTasks.Enqueue(task);
task.task.Start();
tasksEnqueuedThisUpdate++;
}
else
{
break;
}
}
// Executing callbacks on more than one (1) Task per update slows down the UI
// This ensures that only one(1) Task callback is executed per frame
for (int i = 0; i < runningTasks.Count; i++)
{
if (runningTasks.Peek().task.IsCompleted)
{
runningTasks.Dequeue().OnTaskCompleted();
break;
}
}
}
/// <summary>
/// New account created in memory
/// </summary>
/// <returns>Realtime Authentication Token to use</returns>
public UnityTask <RealtimeToken> SignIn(Dictionary <string, string[]> channels = null)
{
var task = new UnityTask <RealtimeToken>(TaskStrategy.Custom);
SignIn(channels, task.FromResponse());
return(task);
}
/// <summary>
/// Saves a new object serverside. Includes write protection (AVL).
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="acl">protection group</param>
/// <param name="param">User name</param>
/// <returns></returns>
public UnityTask Create <T>(T entity, StorageACL acl, string param) where T : class
{
var task = new UnityTask(TaskStrategy.Custom);
Create(entity, acl, param, task.FromResponse());
return(task);
}
