/// <summary>
/// Creates TexturedMesh of the head for a given avatar.
/// If required files (mesh and texture) don't exist on disk, it downloads them from the cloud.
/// </summary>
/// <param name="avatarCode">code of the loaded avatar</param>
/// <param name="withBlendshapes">blendshapes will be added to mesh</param>
public AsyncRequest <TexturedMesh> GetHeadMeshAsync(string avatarCode, bool withBlendshapes, int detailsLevel = 0)
{
var request = new AsyncRequest <TexturedMesh>(AvatarSdkMgr.Str(Strings.GettingHeadMesh));
AvatarSdkMgr.SpawnCoroutine(GetHeadMeshFunc(avatarCode, withBlendshapes, detailsLevel, request));
return(request);
}
/// <summary> Build a async request for a one-shot clip. This request handles creation, downloading, notifications and deletion. </summary>
public static AsyncRequest Make(string body, string voice, string savePath)
{
//Build request
AsyncRequest request = new AsyncRequest();
request.status = Status.BuildRequest;
request.saveDirectory = Path.GetDirectoryName(savePath);
request.fileName = Path.GetFileName(savePath);
request.deleteClipAtEnd = true;
request.requestName = "OneShot > " + request.fileName.Remove(request.fileName.Length - 4);
//Generate placeholder
request.status = Status.GeneratePlaceHolder;
request.GeneratePlaceHolder();
//Send request
request.status = Status.SendDataToAPI;
ClipPatch.Data data = new ClipPatch.Data(GetTemporaryName(), body, voice);
request.currentTask = APIBridge.CreateClip(data, false, (ClipStatus status, Error error) =>
{ request.clipUUID = status.id; RegisterRequestToPool(request); });
//Add request to the pending pool
Resources.instance.requests.Add(request);
EditorUtility.SetDirty(Resources.instance);
Resemble_Window.RefreshPoolList();
//Return the request
return(request);
}
private IEnumerator GetAllAvatarsRoutine(int maxItems, AsyncRequest <GalleryAvatar[]> request)
{
var avatarsRequest = avatarProvider.GetAllAvatarsAsync(maxItems);
yield return(AwaitRoutine(avatarsRequest, null));
if (avatarsRequest.IsError)
{
yield break;
}
GalleryAvatar[] avatars = new GalleryAvatar[avatarsRequest.Result.Length];
for (int i = 0; i < avatars.Length; i++)
{
string avatarCode = avatarsRequest.Result[i];
string avatarName = ReadAvatarNameByCode(avatarCode);
avatars[i] = new GalleryAvatar()
{
name = avatarName, code = avatarCode, state = GetAvatarState(avatarCode)
};
}
request.Result = avatars;
request.IsDone = true;
}
protected AsyncRequest <GalleryAvatar[]> GetAllAvatarsAsync(int maxItems)
{
var request = new AsyncRequest <GalleryAvatar[]>(AvatarSdkMgr.Str(Strings.GettingAvatarState));
EditorRunner.instance.Run(GetAllAvatarsRoutine(maxItems, request));
return(request);
}
protected override AsyncRequest <GalleryAvatar[]> GetAllAvatarsAsync(int maxItems)
{
var request = new AsyncRequest <GalleryAvatar[]>(AvatarSdkMgr.Str(Strings.GettingAvatarState));
AvatarSdkMgr.SpawnCoroutine(GetAllAvatarsFunc(maxItems, request));
return(request);
}
/// <summary>
/// Requests all created avatars that created by current user and determinates states for them
/// </summary>
private IEnumerator GetAllAvatarsFunc(int maxItems, AsyncRequest <GalleryAvatar[]> request)
{
Connection connection = (avatarProvider as CloudAvatarProvider).Connection;
var avatarsRequest = connection.GetAvatarsAsync(maxItems);
yield return(Await(avatarsRequest, null));
if (avatarsRequest.IsError)
{
yield break;
}
GalleryAvatar[] avatars = new GalleryAvatar[avatarsRequest.Result.Length];
for (int i = 0; i < avatars.Length; i++)
{
AvatarData avatarData = avatarsRequest.Result[i];
avatars[i] = new GalleryAvatarCloud()
{
code = avatarData.code, state = GetAvatarState(avatarData), avatarData = avatarData
};
}
request.Result = avatars;
request.IsDone = true;
}
/// <summary>
/// Requests haircuts identities from the server or takes them from the cache
/// </summary>
private AsyncRequest <string[]> GetHaircutsIdsAsync(string avatarCode)
{
var request = new AsyncRequest <string[]>();
StartCoroutine(GetHaircutsIdsFunc(avatarCode, request));
return(request);
}
/// <summary>
/// Returns identities of all haircuts available for the avatar
/// </summary>
public AsyncRequest <string[]> GetHaircutsIdAsync(string avatarCode)
{
var request = new AsyncRequest <string[]>(AvatarSdkMgr.Str(Strings.GettingAvailableHaircuts));
AvatarSdkMgr.SpawnCoroutine(GetHaircutsIdFunc(avatarCode, request));
return(request);
}
/// <summary>
/// Waits while the avatar is being calulated. Calculations start automatically after the photo was loaded to the server.
/// </summary>
public AsyncRequest StartAndAwaitAvatarCalculationAsync(string avatarCode)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.GeneratingAvatar));
AvatarSdkMgr.SpawnCoroutine(StartAndAwaitAvatarCalculationFunc(avatarCode, request));
return(request);
}
protected override IEnumerator LoadAssetAsync()
{
AsyncRequest request = m_Pool.LoadBundleAsyn(m_LoadPath, true);
yield return(request);
SEUResources bundleRes = request.resource;
if (bundleRes != null)
{
AddDependenceResources(bundleRes);
AssetBundle bundle = bundleRes.asset as AssetBundle;
if (bundle != null)
{
AssetBundleRequest bdRequest = bundle.LoadAssetAsync(System.IO.Path.GetFileName(m_LoadPath), m_Type);
yield return(bdRequest);
if (m_Asset == null)
{
m_Asset = bdRequest.asset;
}
}
}
LogResult();
}
public void DownloadDataAsync(Uri url, object state)
{
if (this.DownloadDataCompleted == null)
return;
var request = new AsyncRequest(url, state);
ThreadPool.QueueUserWorkItem(this.DownloadDataWithTimeout, request);
}
/// <summary>
/// Creates TexturedMesh of the haircut.
/// If any of the required files doesn't exist it downloads them from the cloud and saves on the disk.
/// </summary>
/// <param name="avatarCode">Avatar code</param>
/// <param name="haircutName">Haircut identity</param>
public AsyncRequest <TexturedMesh> GetHaircutMeshAsync(string avatarCode, string haircutId)
{
var request = new AsyncRequest <TexturedMesh>(AvatarSdkMgr.Str(Strings.GettingHaircutMesh));
AvatarSdkMgr.SpawnCoroutine(GetHaircutMeshFunc(avatarCode, haircutId, request));
return(request);
}
/// <summary>
/// Requests server to delete all data permanently and deletes local avatar files.
/// </summary>
public AsyncRequest DeleteAvatarAsync(string avatarCode)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.DeletingAvatarFiles));
AvatarSdkMgr.SpawnCoroutine(DeleteAvatarFunc(avatarCode, request));
return(request);
}
/// <summary>
/// GetAvatarAsync implementation
/// </summary>
private IEnumerator GetAvatarFunc(string avatarCode, AsyncRequest <AvatarData> request)
{
if (UseCache && avatarsDataCache.ContainsKey(avatarCode))
{
request.Result = avatarsDataCache[avatarCode];
request.IsDone = true;
yield break;
}
var avatarRequest = connection.GetAvatarAsync(avatarCode);
yield return(avatarRequest);
if (avatarRequest.IsError)
{
request.SetError(avatarRequest.ErrorMessage);
yield break;
}
if (UseCache && string.Compare(avatarRequest.Result.status.ToLower(), "Completed") == 0)
{
avatarsDataCache[avatarCode] = avatarRequest.Result;
}
request.Result = avatarRequest.Result;
request.IsDone = true;
}
/// <summary>
/// Get avatar information by code. Firstly finds data in cache. If there is no data in cache, requests it from the server
/// </summary>
private AsyncRequest <AvatarData> GetAvatarAsync(string avatarCode)
{
var request = new AsyncRequest <AvatarData>();
AvatarSdkMgr.SpawnCoroutine(GetAvatarFunc(avatarCode, request));
return(request);
}
/// <summary>
/// Downloads avatar files and stores them on disk.
/// </summary>
/// <param name="avatarCode">Avatar code</param>
/// <param name="withHaircutPointClouds">If True, haircut point clouds will be downloaded.</param>
/// <param name="withBlendshapes">If true, blendshapes will be downloaded.</param>
/// <returns></returns>
public AsyncRequest MoveAvatarModelToLocalStorageAsync(string avatarCode, bool withHaircutPointClouds, bool withBlendshapes)
{
var request = new AsyncRequest <AvatarData>(AvatarSdkMgr.Str(Strings.DownloadingAvatar));
AvatarSdkMgr.SpawnCoroutine(MoveAvatarModelToLocalStorage(avatarCode, withHaircutPointClouds, withBlendshapes, request));
return(request);
}
private AsyncRequest DownloadAvatarAsync(AvatarData avatar, PipelineType pipelineType)
{
var request = new AsyncRequest();
AvatarSdkMgr.SpawnCoroutine(DownloadAvatarFunc(avatar, pipelineType, request));
return(request);
}
/// <summary>
/// Downloads from the server haircut preview image and saves it locally.
/// Note: this method isn't implemented yet.
/// </summary>
/// <param name="haircutId">Haircut identity</param>
public AsyncRequest <byte[]> GetHaircutPreviewAsync(string avatarCode, string haircutId)
{
var request = new AsyncRequest <byte[]>(AvatarSdkMgr.Str(Strings.GettingHaircutPreview));
AvatarSdkMgr.SpawnCoroutine(GetHaircutPreviewFunc(avatarCode, haircutId, request));
return(request);
}
/// <summary>
/// DeleteAvatarAsync implementation
/// </summary>
private IEnumerator DeleteAvatarFunc(string avatarCode, AsyncRequest request)
{
var avatarRequest = GetAvatarAsync(avatarCode);
yield return(avatarRequest);
if (avatarRequest.IsError)
{
request.SetError(avatarRequest.ErrorMessage);
yield break;
}
var deleteRequest = connection.DeleteAvatarAsync(avatarRequest.Result);
yield return(request.AwaitSubrequest(deleteRequest, 0.5f));
if (request.IsError)
{
yield break;
}
CoreTools.DeleteAvatarFiles(avatarCode);
request.IsDone = true;
}
private AsyncRequest <AvatarData> GenerateAvatarAsync(byte[] selectedImageBytes, PipelineType pipelineType)
{
var request = new AsyncRequest <AvatarData>();
AvatarSdkMgr.SpawnCoroutine(GenerateAvatarFunc(selectedImageBytes, pipelineType, request));
return(request);
}
/// <summary>
/// Requests from the server identities of the latest "maxItems" avatars.
/// </summary>
public AsyncRequest <string[]> GetAllAvatarsAsync(int maxItems)
{
var request = new AsyncRequest <string[]>(AvatarSdkMgr.Str(Strings.GettingAvatarList));
AvatarSdkMgr.SpawnCoroutine(GetAllAvatarsFunc(maxItems, request));
return(request);
}
/// <summary>
/// Download haircut preview and save it to disk
/// </summary>
public AsyncRequest DownloadAndSaveHaircutPreviewAsync(AvatarHaircutData haircutData)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.GettingHaircutPreview));
AvatarSdkMgr.SpawnCoroutine(DownloadAndSaveHaircutPreviewFunc(haircutData, request));
return(request);
}
/// <summary>
/// StartAndAwaitAvatarCalculationAsync implementation
/// </summary>
private IEnumerator StartAndAwaitAvatarCalculationFunc(string avatarCode, AsyncRequest request)
{
var avatarRequest = GetAvatarAsync(avatarCode);
yield return(avatarRequest.Await());
if (avatarRequest.IsError)
{
request.SetError(avatarRequest.ErrorMessage);
yield break;
}
var awaitCalculations = connection.AwaitAvatarCalculationsAsync(avatarRequest.Result);
yield return(request.AwaitSubrequest(awaitCalculations, finalProgress: 1.0f));
if (request.IsError)
{
yield break;
}
if (Strings.BadFinalStates.Contains(awaitCalculations.Result.status))
{
request.SetError(string.Format("Avatar {0} calculation finished with status: {1}", awaitCalculations.Result.code, awaitCalculations.Result.status));
yield break;
}
request.IsDone = true;
}
/// <summary>
/// Get haircut info
/// </summary>
/// <param name="avatarCode">Avatar code</param>
/// <param name="haircutId">Haircut identity</param>
public AsyncRequest <AvatarHaircutData> GetHaircutDataAsync(string avatarCode, string haircutId)
{
var request = new AsyncRequest <AvatarHaircutData>(AvatarSdkMgr.Str(Strings.GettingHaircutInfo));
AvatarSdkMgr.SpawnCoroutine(GetHaircutDataFunc(avatarCode, haircutId, request));
return(request);
}
/// <summary>
/// Download haircut points and save them to disk
/// </summary>
public AsyncRequest DownloadAndSaveHaircutPointsAsync(string avatarCode, AvatarHaircutData haircutData)
{
var request = new AsyncRequest(AvatarSdkMgr.Str(Strings.GettingHaircutPointCloud));
AvatarSdkMgr.SpawnCoroutine(DownloadAndSaveHaircutPointsFunc(avatarCode, haircutData, request));
return(request);
}
/// <summary> Build a async request for import a clip. This request handles downloading and notifications. </summary>
public static AsyncRequest Make(string url, string savePath)
{
//Build request
AsyncRequest request = new AsyncRequest();
request.status = Status.BuildRequest;
request.saveDirectory = Path.GetDirectoryName(savePath);
request.fileName = Path.GetFileName(savePath);
request.deleteClipAtEnd = false;
request.requestName = "Import > " + request.fileName.Remove(request.fileName.Length - 4);
//Generate placeholder
request.status = Status.GeneratePlaceHolder;
request.GeneratePlaceHolder();
//Send request
DownloadClip(request, url);
//Register request into pool
Resources.instance.requests.Add(request);
EditorUtility.SetDirty(Resources.instance);
//Return the request
return(request);
}
/// <summary>
/// Download all avatar files, unzip and save to disk.
/// </summary>
/// <param name="connection">Connection session.</param>
/// <param name="avatar">Avatar to download.</param>
/// <param name="withHaircutPointClouds">If set to true, download all haircut point clouds too.</param>
/// <param name="withBlendshapes">If set to true, download blendshapes too.</param>
public AsyncRequest DownloadAndSaveAvatarModelAsync(AvatarData avatar, bool withHaircutPointClouds, bool withBlendshapes)
{
var request = new AsyncRequest <AvatarData>(AvatarSdkMgr.Str(Strings.DownloadingAvatar));
AvatarSdkMgr.SpawnCoroutine(DownloadAndSaveAvatarModel(avatar, withHaircutPointClouds, withBlendshapes, request));
return(request);
}
private IEnumerator Await(AsyncRequest r, PipelineType pipelineType)
{
while (!r.IsDone)
{
yield return(null);
if (r.IsError)
{
Debug.LogError(r.ErrorMessage);
yield break;
}
if (pipelineType == PipelineType.HEAD)
{
var progress = new List <string>();
AsyncRequest request = r;
while (request != null)
{
progress.Add(string.Format("{0}: {1}%", request.State, request.ProgressPercent.ToString("0.0")));
request = request.CurrentSubrequest;
}
progressText.text = string.Join("\n", progress.ToArray());
}
}
if (pipelineType == PipelineType.HEAD)
{
progressText.text = string.Empty;
}
}
/// <summary>
/// Checks is queue contains request in loop and process request
/// </summary>
/// <param name="notUsed">Not used</param>
private void ProcessRequests(Object notUsed)
{
// Execute while object is not disposed
while (!this.disposed)
{
AsyncRequest task = null;
// Lock task queue
lock (this.taskQueueLocker)
{
// If no requests is queue wait for task
if (this.tasksQueue.Count == 0)
{
Monitor.Wait(this.taskQueueLocker);
}
// Get task from queue
task = this.tasksQueue.Dequeue();
}
if (task != null)
{
// If task exist process him
ProcessAsyncRequest(task);
}
else
{
// Empty task instruct for stop working
return;
}
}
}
/// <summary>
/// Helper function that allows to yield on multiple async requests in a coroutine.
/// It also tracks progress on the current request(s) and updates it in UI.
/// </summary>
protected IEnumerator Await(params AsyncRequest[] requests)
{
foreach (var r in requests)
{
while (!r.IsDone)
{
// yield null to wait until next frame (to avoid blocking the main thread)
yield return(null);
// This function will throw on any error. Such primitive error handling only provided as
// an example, the production app probably should be more clever about it.
if (r.IsError)
{
Debug.LogError(r.ErrorMessage);
throw new Exception(r.ErrorMessage);
}
// Each requests may or may not contain "subrequests" - the asynchronous subtasks needed to
// complete the request. The progress for the requests can be tracked overall, as well as for
// every subtask. The code below shows how to recursively iterate over current subtasks
// to display progress for them.
var progress = new List <string>();
AsyncRequest request = r;
while (request != null)
{
progress.Add(string.Format("{0}: {1}%", request.State, request.ProgressPercent.ToString("0.0")));
request = request.CurrentSubrequest;
}
progressText.text = string.Join("\n", progress.ToArray());
}
}
}
//
// methods
//
/// <summary>
/// If instance can process request execute success callback
/// otherwise execute failure callback
/// </summary>
/// <param name="object">AsyncRequest</param>
private void ProcessRequest(Object @object)
{
AsyncRequest request = @object as AsyncRequest;
lock (this.dataLocker)
{
// If instance waits for the new data
if (this.state == FileLinesCheckerState.Pending)
{
//Wait new data
Monitor.Wait(this.dataLocker);
}
// If instance can return the answer
if (this.state == FileLinesCheckerState.Ready)
{
// Execite success callback
request.SuccessCallback(this.data.Contains(request.Line));
}
else
{
// Execute failure callback
request.FailureCallback(this.state.ToString());
}
}
}
public byte[] DownloadData(Uri url)
{
var request = new AsyncRequest(url, null);
this.DownloadDataWithTimeout(request);
if (request.DataResult.Error != null)
throw request.DataResult.Error;
return request.DataResult.Result;
}
public string DownloadString(Uri url)
{
var request = new AsyncRequest(url, null);
this.DownloadStringWithTimeout(request);
if (request.StringResult.Error != null)
throw request.StringResult.Error;
return request.StringResult.Result;
}
private void BeginRequest(string method, HttpWebRequest httpRequest, AsyncRequest rawRequestData)
{
if (method == "PUT" || method == "POST")
{
httpRequest.BeginGetRequestStream(WriteStream, rawRequestData);
}
else
{
httpRequest.BeginGetResponse(ReadCallback, rawRequestData);
}
}
public void Execute(CreateTagRequest request, Action<CreateTagResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/tags/" + request.Tag);
webRequest.Method = "PUT";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = o => responseCallback(new CreateTagResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(DeleteTagRequest request, Action<DeleteTagResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/tags/" + request.Tag);
webRequest.Method = "DELETE";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = o => responseCallback(new DeleteTagResponse()),
ExceptionCallback = exceptionCallback,
RequestContentType = "application/json"
};
asyncRequest.Execute();
}
public void Execute(AddTagToDeviceRequest request, Action<AddTagToDeviceResponse> responseCallback, Action<Exception> exceptionCallback)
{
var url = string.Format("https://go.urbanairship.com/api/device_tokens/{0}/tags/{1}", request.DeviceToken, request.Tag);
var webRequest = RequestBuilder.Build(url);
webRequest.Method = "PUT";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = o => responseCallback(new AddTagToDeviceResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(Action<GetTagsResponse> responseCallback, Action<Exception> exceptionCallback)
{
var request = RequestBuilder.Build("https://go.urbanairship.com/api/tags/");
request.Method = "GET";
request.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
ReadFromResponse = stream => responseCallback(new GetTagsResponse { Tags = TagDeSerializer.DeSerialize(stream).ToList() }),
Request = request,
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(AddRegistrationRequest registrationRequest, Action<AddRegistrationResponse> responseCallback, Action<Exception> exceptionCallback)
{
var request = RequestBuilder.Build("https://go.urbanairship.com/api/apids/" + registrationRequest.PushId);
request.Method = "PUT";
var asyncRequest = new AsyncRequest
{
Request = request,
ReadFromResponse = o => responseCallback(new AddRegistrationResponse()),
ExceptionCallback = exceptionCallback,
WriteToRequest = stream => stream.WriteToStream(registrationRequest.Serialize),
RequestContentType = "application/json"
};
asyncRequest.Execute();
}
public void Execute(GetRegistrationRequest request, Action<GetRegistrationResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/apids/" + request.PushId);
webRequest.Method = "Get";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = stream => responseCallback(GetRegistrationResponseDeSerializer.DeSerialize(stream)),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(GetTagsForDeviceRequest request, Action<GetTagsForDeviceResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build(string.Format("https://go.urbanairship.com/api/device_tokens/{0}/tags/", request.DeviceToken));
webRequest.Method = "GET";
var asyncRequest = new AsyncRequest
{
ReadFromResponse = stream => responseCallback(new GetTagsForDeviceResponse { Tags = TagDeSerializer.DeSerialize(stream).ToList() }),
Request = webRequest,
ExceptionCallback = exceptionCallback,
RequestContentType = "application/json"
};
asyncRequest.Execute();
}
public void Execute(Action<GetAllFeedsResponse> responseCallback, Action<Exception> exceptionCallback)
{
var request = RequestBuilder.Build("https://go.urbanairship.com/api/feeds/");
request.Method = "Get";
request.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
ReadFromResponse = stream => responseCallback(FeedDeSerializer.DeSerializeMultiple(stream)),
Request = request,
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(PushNotificationRequest notification, Action<PushNotificationResponse> responseCallback, Action<Exception> exceptionCallback)
{
var request = RequestBuilder.Build("https://go.urbanairship.com/api/push/");
request.Method = "POST";
request.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
Request = request,
ReadFromResponse = o => responseCallback(new PushNotificationResponse()),
ExceptionCallback = exceptionCallback,
WriteToRequest = stream => stream.WriteToStream(notification.Serialize),
};
asyncRequest.Execute();
}
public void Execute(ModifyTagRequest request, Action<ModifyTagResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/tags/" + request.Tag);
webRequest.Method = "POST";
var asyncRequest = new AsyncRequest
{
WriteToRequest = stream => stream.WriteToStream(request.Serialize),
Request = webRequest,
ReadFromResponse = o => responseCallback(new ModifyTagResponse()),
ExceptionCallback = exceptionCallback,
RequestContentType = "application/json"
};
asyncRequest.Execute();
}
public void Execute(FeedbackRequest request, Action<FeedbackResponse> responseCallback, Action<Exception> exceptionCallback)
{
var url = "https://go.urbanairship.com/api/device_tokens/feedback/?since=" + request.Since.ToIso8601();
var webRequest = RequestBuilder.Build(url);
webRequest.Method = "GET";
var asyncRequest = new AsyncRequest
{
ReadFromResponse = stream => responseCallback(FeedbackResponseDeSerializer.DeSerialize(stream)),
Request = webRequest,
ExceptionCallback = exceptionCallback,
RequestContentType = "application/json"
};
asyncRequest.Execute();
}
public void Execute(GetRegistrationsRequest request, Action<GetRegistrationsResponse> responseCallback, Action<Exception> exceptionCallback)
{
var url = string.Format("https://go.urbanairship.com/api/device_tokens/?Limit={0}&start={1}", request.Limit, request.Start);
var webRequest = RequestBuilder.Build(url);
webRequest.Method = "GET";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
ReadFromResponse = stream => responseCallback(GetRegistrationsResponseDeSerializer.DeSerialize(stream)),
Request = webRequest,
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(RemoveTagFromDeviceRequest request, Action<RemoveTagFromDeviceResponse> responseCallback, Action<Exception> exceptionCallback)
{
var url = string.Format("https://go.urbanairship.com/api/device_tokens/{0}/tags/{1}", request.DeviceToken, request.TagToRemove);
var webRequest = RequestBuilder.Build(url);
webRequest.Method = "DELETE";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = o => responseCallback(new RemoveTagFromDeviceResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(ModifyFeedRequest newFeed, Action<ModifyFeedResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/feeds/" + newFeed.FeedId);
webRequest.Method = "PUT";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
WriteToRequest = stream => stream.WriteToStream(newFeed.Serialize),
Request = webRequest,
ReadFromResponse = o => responseCallback(new ModifyFeedResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(DeleteRegistrationRequest request, Action<DeleteRegistrationResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/device_tokens/" + request.DeviceToken);
webRequest.Method = "Delete";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = o => responseCallback(new DeleteRegistrationResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(DeleteRegistrationRequest request, Action<DeleteRegistrationResponse> responseCallback, Action<Exception> exceptionCallback)
{
//TODO: validate args
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/apids/" + request.PushId);
webRequest.Method = "Delete";
var asyncRequest = new AsyncRequest
{
Request = webRequest,
ReadFromResponse = o => responseCallback(new DeleteRegistrationResponse()),
ExceptionCallback = exceptionCallback,
RequestContentType = "application/json"
};
asyncRequest.Execute();
}
public void Execute(BroadcastNotificationRequest request, Action<BroadcastNotificationResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/push/broadcast/");
webRequest.Method = "POST";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
WriteToRequest = stream => stream.WriteToStream(request.Serialize),
Request = webRequest,
ReadFromResponse = o => responseCallback(new BroadcastNotificationResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(CreateFeedRequest request, Action<CreateFeedResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/feeds/");
webRequest.Method = "POST";
webRequest.ContentType = "application/json";
var asyncRequest = new AsyncRequest
{
WriteToRequest = stream => stream.WriteToStream(request.Serialize),
Request = webRequest,
ReadFromResponse = stream => responseCallback(CreateFeedResponseDeSerializer.DeSerialize(stream)),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public void Execute(PushNotificationRequest request, Action<PushNotificationResponse> responseCallback, Action<Exception> exceptionCallback)
{
var webRequest = RequestBuilder.Build("https://go.urbanairship.com/api/push/");
webRequest.Method = "POST";
webRequest.ContentType = "application/json";
//TODO: must have tags or tokens... validate
var asyncRequest = new AsyncRequest
{
WriteToRequest = stream => stream.WriteToStream(request.Serialize),
Request = webRequest,
ReadFromResponse = o => responseCallback(new PushNotificationResponse()),
ExceptionCallback = exceptionCallback,
};
asyncRequest.Execute();
}
public override IAsyncResult BeginRead(Byte[] buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state)
{
if (!fBufferedAsync)
return IntBeginRead(buffer, offset, count, callback, state);
AsyncRequest lRequest = new AsyncRequest();
lRequest.AsyncBuffer = buffer;
lRequest.AsyncOffset = offset;
lRequest.AsyncCount = count;
lRequest.AsyncRest = count;
lRequest.AsyncCallback = callback;
lRequest.AsyncState = state;
try
{
IntBeginRead(buffer, offset, count, new AsyncCallback(IntReadCallback), lRequest);
}
catch (ObjectDisposedException) // disconnect from this side
{
TriggerAsyncDisconnect();
throw;
}
catch (SocketException) // disconnect
{
TriggerAsyncDisconnect();
throw;
}
return lRequest;
}
public void SendAsync(string method, Uri uri, DataPackets.HttpContent postData, Action<DataPackets.HttpResponseMessage> httpClientCallback)
{
var httpRequestMessage = new HttpRequestMessage(method, uri, HttpContent.Create(postData.Content, postData.ContentType)) { Headers = { ContentType = postData.ContentType } };
var rawRequestData = new AsyncRequest { PostData = postData, HttpClientCallback = httpClientCallback };
_httpClient.BeginSend(httpRequestMessage, SendAsyncEnd, rawRequestData);
}
/// <summary>
/// Send an async request
/// </summary>
protected void SendAsyncRequest()
{
AsyncRequest oRequest;
do
{
oRequest = new AsyncRequest();
oRequest.m_bValid = false;
// --- Safety try/catch so that a thread will not terminate, and not clean itself up ---
try
{
oRequest = (AsyncRequest)m_oAsyncQueue.Dequeue();
if (oRequest.m_eType == AsyncRequestType.GetCatalogHierarchy)
{
GetCatalogHierarchy();
GetCatalogCount();
}
else if (oRequest.m_eType == AsyncRequestType.GetDatasetList)
{
GetDatasetList((string)oRequest.m_oParam1, (int)oRequest.m_oParam2);
}
else if (oRequest.m_eType == AsyncRequestType.FilterChanged)
{
FilterChanged((SearchModeEnum)oRequest.m_oParam1, (BoundingBox)oRequest.m_oParam2, (string)oRequest.m_oParam3, (bool)oRequest.m_oParam4, (bool)oRequest.m_oParam5);
GetCatalogCount();
}
}
catch (Exception e)
{
if (oRequest.m_bValid)
GetDapError.Instance.Write("Failed to send request " + oRequest.m_eType.ToString() + " - " + e.Message);
}
} while (!oRequest.m_bValid || oRequest.m_eType != AsyncRequestType.Stop);
}
/// <summary>
/// Enqueue a request onto the queue
/// </summary>
/// <param name="eRequest"></param>
internal void EnqueueRequest(AsyncRequestType eRequest)
{
AsyncRequest oRequest = new AsyncRequest();
oRequest.m_bValid = true;
oRequest.m_eType = eRequest;
oRequest.m_oParam1 = null;
oRequest.m_oParam2 = null;
oRequest.m_oParam3 = null;
oRequest.m_oParam4 = null;
oRequest.m_oParam5 = null;
m_oAsyncQueue.Enqueue(oRequest);
}
/// <summary>
/// Enqueue a request onto the queue
/// </summary>
/// <param name="eRequest"></param>
/// <param name="oParam1"></param>
/// <param name="oParam2"></param>
/// <param name="oParam3"></param>
/// <param name="oParam4"></param>
/// <param name="oParam5"></param>
internal void EnqueueRequest(AsyncRequestType eRequest, object oParam1, object oParam2, object oParam3, object oParam4, object oParam5)
{
AsyncRequest oRequest = new AsyncRequest();
oRequest.m_bValid = true;
oRequest.m_eType = eRequest;
oRequest.m_oParam1 = oParam1;
oRequest.m_oParam2 = oParam2;
oRequest.m_oParam3 = oParam3;
oRequest.m_oParam4 = oParam4;
oRequest.m_oParam5 = oParam5;
m_oAsyncQueue.Enqueue(oRequest);
}
private void ProcessAsyncRequest(AsyncRequest request)
{
request.Error = null;
try
{
request.Result = request.Method();
}
catch (Exception ex)
{
_log.Error("Call to requested method failed with exception.", ex);
request.Result = null;
request.Error = ex;
// do nothing here we will send error info when invoking callback
}
try
{
if (_synchronizationContext == SynchronizationContext.Current)
{
// Execute callback on the current thread
request.Callback(request.Result, request.Error);
}
else
{
// Post the callback on the creator thread
_synchronizationContext.Post(new SendOrPostCallback(delegate(object state)
{
var r = state as AsyncRequest;
r.Callback(r.Result, r.Error);
}), request);
}
}
catch (Exception ex)
{
_log.Error("Unable to invoke callback method.", ex);
}
}
public void SendAsync(string method, Uri uri, HttpContent postData, Action<HttpResponseMessage> httpClientCallback)
{
var httpRequest = ConfigureWebRequest(uri, method);
var rawRequestData = new AsyncRequest { PostData = postData, HttpClientCallback = httpClientCallback, WebRequest = httpRequest };
BeginRequest(method, httpRequest, rawRequestData);
}
