private void Decrement(AsyncToken token)
{
lock (_gate)
{
_counter--;
if (_counter == 0)
{
foreach (var task in _pendingTasks)
{
task.SetResult(true);
}
_pendingTasks.Clear();
}
if (_trackActiveTokens)
{
var diagnosticAsyncToken = token as DiagnosticAsyncToken;
if (diagnosticAsyncToken != null)
{
_activeDiagnosticTokens.Remove(diagnosticAsyncToken);
}
}
}
}
private void Decrement_NoLock(AsyncToken token)
{
Contract.ThrowIfFalse(_gate.LockHeldByMe());
_counter--;
if (_counter == 0)
{
foreach (var task in _pendingTasks)
{
task.SetResult(true);
}
_pendingTasks.Clear();
}
if (_trackActiveTokens)
{
int i = 0;
bool removed = false;
while (i < _diagnosticTokenList.Count)
{
if (_diagnosticTokenList[i] == token)
{
_diagnosticTokenList.RemoveAt(i);
removed = true;
break;
}
i++;
}
Debug.Assert(removed, "IAsyncToken and Listener mismatch");
}
}
private void Decrement(AsyncToken token)
{
lock (_gate)
{
_counter--;
if (_counter == 0)
{
foreach (var task in _pendingTasks)
{
task.SetResult(true);
}
_pendingTasks.Clear();
}
if (_trackActiveTokens)
{
var diagnosticAsyncToken = token as DiagnosticAsyncToken;
if (diagnosticAsyncToken != null)
{
_activeDiagnosticTokens.Remove(diagnosticAsyncToken);
}
}
}
}
/// <inheritdoc cref="IStorageWorker"/>
public IAsyncToken <KvModel> Create(object value)
{
var token = new AsyncToken <KvModel>();
_http
.Post <CreateKvResponse>(
_http.UrlBuilder.Url(ENDPOINT_KVS),
new CreateKvRequest
{
value = value
})
.OnSuccess(response =>
{
if (!response.Payload.success)
{
token.Fail(new Exception(response.Payload.error));
return;
}
token.Succeed(response.Payload.body);
})
.OnFailure(token.Fail);
return(token);
}
/// <inheritdoc cref="IStorageWorker"/>
public IAsyncToken <Void> Save(string key, object value, string tags, int version)
{
var token = new AsyncToken <Void>();
_http
.Put <UpdateKvResponse>(
_http.UrlBuilder.Url($"{ENDPOINT_KVS}/{key}"),
new UpdateKvRequest
{
value = value,
version = version
})
.OnSuccess(response =>
{
if (response.Payload.success)
{
token.Succeed(Void.Instance);
}
else
{
token.Fail(new Exception(response.Payload.error));
}
})
.OnFailure(token.Fail);
return(token);
}
public static async UniTask SetHourAsync(float hour, float duration, AsyncToken token = default)
{
if (tweener.Running)
{
tweener.CompleteInstantly();
}
var tween = new FloatTween(CurrentHour, hour, duration, SetHour);
await tweener.RunAsync(tween, token, target : instance);
}
/// <summary>
/// Sycnhronously process response.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="request">WWW request.</param>
/// <param name="token">Token to resolve.</param>
private IEnumerator Wait <T>(
WWW request,
AsyncToken <HttpResponse <T> > token)
{
while (!request.isDone)
{
yield return(null);
}
var httpResponse = new HttpResponse <T>
{
StatusCode = GetStatusCode(request),
Headers = null == request.responseHeaders
? new List <Tuple <string, string> >()
: request
.responseHeaders
.Select(pair => Tuple.Create(pair.Key, pair.Value))
.ToList(),
Raw = request.bytes
};
var bytes = request.bytes;
object value = null;
if (typeof(T) != typeof(byte[]))
{
try
{
_serializer.Deserialize(typeof(T), ref bytes, out value);
}
catch (Exception exception)
{
httpResponse.NetworkSuccess = false;
httpResponse.NetworkError = string.Format("Could not deserialize : {0}.", exception.Message);
}
}
else
{
value = bytes;
}
httpResponse.Payload = (T)value;
if (Successful((int)httpResponse.StatusCode))
{
httpResponse.NetworkSuccess = true;
}
else
{
httpResponse.NetworkSuccess = false;
httpResponse.NetworkError = Encoding.UTF8.GetString(bytes);
}
token.Succeed(httpResponse);
}
/// <inheritdoc cref="IHttpService"/>
public IAsyncToken <HttpResponse <byte[]> > Download(string url)
{
var token = new AsyncToken <HttpResponse <byte[]> >();
var request = UnityWebRequest.Get(url);
_requestsOut.Add(request);
ApplyHeaders(Headers, request);
_bootstrapper.BootstrapCoroutine(Wait(
request,
token,
SerializationType.Raw));
return(token);
}
/// <summary>
/// Waits on the request and resolves the token.
/// </summary>
/// <typeparam name="T">The type to deserialize the response to.</typeparam>
/// <param name="request">The UnityWebRequest to send and wait on.</param>
/// <param name="token">The token to resolve.</param>
/// <param name="serialization"></param>
/// <returns>The coroutines IEnumerator.</returns>
protected IEnumerator Wait <T>(
UnityWebRequest request,
AsyncToken <HttpResponse <T> > token,
SerializationType serialization = SerializationType.Json)
{
var start = DateTime.Now;
request.Send();
while (!request.isDone)
{
if (TimeoutMs > 0 && DateTime.Now.Subtract(start).TotalMilliseconds > TimeoutMs)
{
// request timed out
request.Dispose();
token.Fail(new Exception("Request timed out."));
yield break;
}
yield return(null);
}
var response = new HttpResponse <T>
{
Headers = FormatHeaders(request.GetResponseHeaders()),
StatusCode = request.responseCode
};
ProcessResponse(request, response, serialization);
// must kill the request
request.Dispose();
_requestsOut.Remove(request);
if (response.NetworkSuccess)
{
token.Succeed(response);
}
else
{
token.Fail(new Exception(response.NetworkError));
}
}
/// <summary>
/// Initializes download
/// </summary>
/// <param name="path">The path to load from</param>
/// <param name="callback">Fires when resource is loaded</param>
/// <returns></returns>
public AsyncToken Load(string path, ResultHandler callback)
{
//Debug.Log(string.Format(@"*** Loading texture ""{0}""", textureName));
AsyncToken httpToken;
if (_finished.ContainsKey(path)) // texture already loaded
{
/**
* Return null to signalize there's nothing for async loading
* */
return(null);
}
/**
* The texture not yet loaded, but loading
* We need to return token (for displaying progress)
* */
if (_active.ContainsKey(path))
{
/**
* The token collection for this texture already exists
* We should grab the first token and clone it
* */
httpToken = _active[path];
}
else
{
//Debug.Log("*** Downloading texture: " + texturePath);
httpToken = _connector.Send("~" + path, LoadCompleteHandler);
httpToken.Data = path;
_active.Add(path, httpToken);
_tokenToTokens.Add(httpToken, new List <AsyncToken>());
}
AsyncToken token = (AsyncToken)httpToken.Clone();
_tokenToTokens[httpToken].Add(token);
_callbacks.Add(token, callback);
return(token);
}
/// <inheritdoc cref="IStorageService"/>
public IAsyncToken <StorageService> Refresh()
{
if (null != _refreshToken)
{
return(_refreshToken.Token());
}
// keep local reference
var token = _refreshToken = new AsyncToken <StorageService>();
_worker
.GetAll()
.OnSuccess(models =>
{
for (int i = 0, len = models.Length; i < len; i++)
{
var model = models[i];
var bucket = Get(model.key);
if (null == bucket)
{
bucket = new StorageBucket(
null,
model.key,
model.tags,
model.version);
_buckets.Add(bucket);
}
bucket.VersionUpdate(model.version);
}
token.Succeed(this);
})
.OnFailure(exception =>
{
// null out class reference first
_refreshToken = null;
token.Fail(exception);
});
return(token);
}
public IAsyncToken BeginAsyncOperation(string name, object tag = null, [CallerFilePath] string filePath = "", [CallerLineNumber] int lineNumber = 0)
{
lock (_gate)
{
IAsyncToken asyncToken;
if (_trackActiveTokens)
{
var token = new DiagnosticAsyncToken(this, name, tag, filePath, lineNumber);
_diagnosticTokenList.Add(token);
asyncToken = token;
}
else
{
asyncToken = new AsyncToken(this);
}
return(asyncToken);
}
}
/// <inheritdoc cref="IStorageWorker"/>
public IAsyncToken <KvModel[]> GetAll()
{
var token = new AsyncToken <KvModel[]>();
_http
.Get <GetAllKvsResponse>(_http.UrlBuilder.Url(ENDPOINT_KVS))
.OnSuccess(response =>
{
if (!response.Payload.success)
{
token.Fail(new Exception(response.Payload.error));
return;
}
token.Succeed(response.Payload.body);
})
.OnFailure(token.Fail);
return(token);
}
/// <inheritdoc />
public IAsyncToken <HttpResponse <byte[]> > Download(string url)
{
var token = new AsyncToken <HttpResponse <byte[]> >();
var request = UnityWebRequest.Get(url);
_requestsOut.Add(request);
var service = Services.Process(request);
// Log after Processing
Log("GET", url, service);
_bootstrapper.BootstrapCoroutine(Wait(
request,
token,
SerializationType.Raw));
return(token);
}
/// <inheritdoc cref="IStorageService"/>
public IAsyncToken <StorageBucket> Create <T>(T value)
{
var token = new AsyncToken <StorageBucket>();
_worker
.Create(value)
.OnSuccess(model =>
{
var bucket = new StorageBucket(
_worker,
model.key,
model.tags,
model.version);
_buckets.Add(bucket);
token.Succeed(bucket);
})
.OnFailure(token.Fail);
return(token);
}
/// <inheritdoc cref="IStorageWorker"/>
public IAsyncToken <Void> Delete(string key)
{
var token = new AsyncToken <Void>();
_http
.Delete <CreateKvResponse>(_http.UrlBuilder.Url($"{ENDPOINT_KVS}/{key}"))
.OnSuccess(response =>
{
if (!response.Payload.success)
{
token.Fail(new Exception(response.Payload.error));
return;
}
OnDelete?.Invoke(key);
token.Succeed(Void.Instance);
})
.OnFailure(token.Fail);
return(token);
}
private void Decrement_NoLock(AsyncToken token)
{
Contract.ThrowIfFalse(_gate.LockHeldByMe());
_counter--;
if (_counter == 0)
{
foreach (var task in _pendingTasks)
{
task.SetResult(true);
}
_pendingTasks.Clear();
// Replace the cancellation source used for expediting waits.
var oldSource = Interlocked.Exchange(ref _expeditedDelayCancellationTokenSource, new CancellationTokenSource());
oldSource.Dispose();
}
if (_trackActiveTokens)
{
int i = 0;
bool removed = false;
while (i < _diagnosticTokenList.Count)
{
if (_diagnosticTokenList[i] == token)
{
_diagnosticTokenList.RemoveAt(i);
removed = true;
break;
}
i++;
}
Debug.Assert(removed, "IAsyncToken and Listener mismatch");
}
}
/// <summary>
/// Loads the bucket's value. Subsequent Value() calls will be cached.
///
/// If StorageService::Refresh returns a version higher than the cached
/// version, the next call to Value() will fetch the updated value.
/// </summary>
/// <typeparam name="T">The type to deserialize the object to.</typeparam>
/// <returns></returns>
public IAsyncToken <T> Value <T>()
{
var token = new AsyncToken <T>();
if (_version == _manifestVersion && null != _value)
{
token.Succeed((T)_value);
}
else
{
_worker
.Load(Key, typeof(T))
.OnSuccess(response =>
{
_value = (T)response;
token.Succeed((T)_value);
})
.OnFailure(exception => token.Fail(exception));
}
return(token);
}
/// <summary>
/// Sends a json request.
/// </summary>
/// <typeparam name="T">The type of response we expect.</typeparam>
/// <param name="verb">The http verb to use.</param>
/// <param name="url">The url to send the request to.</param>
/// <param name="payload">The object that will be serialized into json.</param>
/// <returns>An IAsyncToken to listen to.</returns>
/// <exception cref="NullReferenceException"></exception>
protected IAsyncToken <HttpResponse <T> > SendJsonRequest <T>(
HttpVerb verb,
string url,
object payload)
{
var token = new AsyncToken <HttpResponse <T> >();
var request = new UnityWebRequest(
url,
verb.ToString().ToUpperInvariant())
{
downloadHandler = new DownloadHandlerBuffer(),
disposeDownloadHandlerOnDispose = true,
disposeUploadHandlerOnDispose = true
};
ApplyHeaders(Headers, request);
ApplyJsonPayload(payload, request);
_bootstrapper.BootstrapCoroutine(Wait(request, token));
return(token);
}
public override async UniTask ExecuteAsync(AsyncToken asyncToken = default)
{
// 1. Disable Naninovel input.
var inputManager = Engine.GetService <IInputManager>();
inputManager.ProcessInput = false;
// 2. Stop script player.
var scriptPlayer = Engine.GetService <IScriptPlayer>();
scriptPlayer.Stop();
// 3. Hide text printer.
var hidePrinter = new HidePrinter();
hidePrinter.ExecuteAsync(asyncToken).Forget();
// 4. Reset state (if required).
if (ResetState)
{
var stateManager = Engine.GetService <IStateManager>();
await stateManager.ResetStateAsync();
}
// 5. Switch cameras.
var advCamera = GameObject.Find("AdventureModeCamera").GetComponent <Camera>();
advCamera.enabled = true;
var naniCamera = Engine.GetService <ICameraManager>().Camera;
naniCamera.enabled = false;
// 6. Enable character control.
var controller = Object.FindObjectOfType <CharacterController3D>();
controller.IsInputBlocked = false;
}
/// <summary>
/// Sends a file!
/// </summary>
/// <typeparam name="T">The type of response we expect.</typeparam>
/// <param name="verb">The http verb to use.</param>
/// <param name="url">The url to send the request to.</param>
/// <param name="fields">Optional fields that will _precede_ the file.</param>
/// <param name="file">The file, which will be named "file".</param>
/// <param name="service">Optional parameter which uses headers for a specific service instead of defaults.</param>
/// <returns></returns>
private IAsyncToken <HttpResponse <T> > SendFile <T>(
HttpVerb verb,
string url,
IEnumerable <Tuple <string, string> > fields,
ref byte[] file)
{
var token = new AsyncToken <HttpResponse <T> >();
var form = new WWWForm();
foreach (var tuple in fields)
{
form.AddField(tuple.Item1, tuple.Item2);
}
form.AddBinaryData("file", file);
var request = UnityWebRequest.Post(
url,
form);
request.method = verb.ToString().ToUpperInvariant();
request.useHttpContinue = false;
request.downloadHandler = new DownloadHandlerBuffer();
request.disposeDownloadHandlerOnDispose = true;
request.disposeUploadHandlerOnDispose = true;
var service = Services.Process(request);
// Log after Processing
Log(verb.ToString(), url, service);
_bootstrapper.BootstrapCoroutine(Wait(request, token));
return(token);
}
/// <summary>
/// Deletes the KV. Disallows delete if latest version has not been
/// loaded.
/// </summary>
/// <returns></returns>
public IAsyncToken <Void> Delete()
{
var token = new AsyncToken <Void>();
if (_manifestVersion > _version)
{
token.Fail(new Exception("Cannot delete without version update."));
}
else
{
_worker
.Delete(Key)
.OnSuccess(_ =>
{
// TODO: To think about: we have to trust the worker to
// TODO: tell the service.
token.Succeed(Void.Instance);
})
.OnFailure(token.Fail);
}
return(token);
}
/// <summary>
/// Executed after the download is finished
/// </summary>
/// <param name="data"></param>
private void LoadCompleteHandler(object data)
{
//Debug.Log("LoadCompleteHandler");
AsyncToken httpToken = (AsyncToken)data;
string path = (string)httpToken.Data;
T output = ResponseExtractor(httpToken.Response);
_finished.Add(path, output);
_tokenToTokens[httpToken].ForEach(delegate(AsyncToken token)
{
token.Response = httpToken.Response;
if (null != _tokenUpdater)
{
TokenUpdater(token, output);
}
/**
* Execute callback function
* */
if (_callbacks.ContainsKey(token))
{
ResultHandler resultHandler = _callbacks[token];
_callbacks.Remove(token);
resultHandler(token);
}
});
_tokenToTokens.Remove(httpToken);
_active.Remove(path);
}
/// <inheritdoc cref="IStorageWorker"/>
public IAsyncToken <object> Load(string key, Type type)
{
var token = new AsyncToken <object>();
_http
.Get <GetKvResponse>(_http.UrlBuilder.Url($"{ENDPOINT_KVS}/{key}"))
.OnSuccess(response =>
{
if (!response.Payload.success)
{
token.Fail(new Exception(response.Payload.error));
return;
}
var bytes = Encoding.UTF8.GetBytes(response.Payload.body.value);
object value;
_json.Deserialize(type, ref bytes, out value);
token.Succeed(value);
})
.OnFailure(token.Fail);
return(token);
}
public override async UniTask ExecuteAsync(AsyncToken token = default)
{
await TimeOfDay.SetHourAsync(Hour, Duration, token);
}
/// <summary>
/// Cancels the current download
/// </summary>
/// <param name="token"></param>
public void Cancel(AsyncToken token)
{
_connector.Cancel(token);
}
/// <summary>
/// Sycnhronously process response.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="request">WWW request.</param>
/// <param name="token">Token to resolve.</param>
private IEnumerator Wait <T>(
WWW request,
AsyncToken <HttpResponse <T> > token)
{
var start = DateTime.Now;
while (!request.isDone)
{
if (TimeoutMs > 0 && DateTime.Now.Subtract(start).TotalMilliseconds > TimeoutMs)
{
// request timed out
request.Dispose();
token.Fail(new Exception("Request timed out."));
yield break;
}
yield return(null);
}
var httpResponse = new HttpResponse <T>
{
StatusCode = GetStatusCode(request),
Headers = null == request.responseHeaders
? new List <Tuple <string, string> >()
: request
.responseHeaders
.Select(pair => Tuple.Create(pair.Key, pair.Value))
.ToList(),
Raw = request.bytes
};
var bytes = request.bytes;
object value = null;
if (typeof(T) != typeof(byte[]))
{
try
{
_serializer.Deserialize(typeof(T), ref bytes, out value);
}
catch (Exception exception)
{
httpResponse.NetworkSuccess = false;
httpResponse.NetworkError = string.Format("Could not deserialize : {0}.", exception.Message);
}
}
else
{
value = bytes;
}
httpResponse.Payload = (T)value;
if (Successful((int)httpResponse.StatusCode))
{
httpResponse.NetworkSuccess = true;
}
else
{
httpResponse.NetworkSuccess = false;
httpResponse.NetworkError = Encoding.UTF8.GetString(bytes);
}
token.Succeed(httpResponse);
}
