/// <summary>
/// Creates an asynchronous Task object that executes the given critical phase and optional phases in a background thread
/// and invokes all other callbacks on the UI thread.
/// </summary>
/// <param name="cancellationToken"></param>
/// <param name="beforeStart">Invoked on UI thread</param>
/// <param name="criticalPhase">First phase to run. Must succeed (by returning <c>true</c> and not throwing an exception) for the optional phases to run. Invoked on the background thread.</param>
/// <param name="optionalPhases">Collection of phases that can fail (by throwing an exception) without preventing subsequent phases from running. Invoked on the background thread.</param>
/// <param name="fail">Called if the operation is canceled or the critical phase throws an exception. Invoked on the UI thread.</param>
/// <param name="succeed">Called if the operation completes successfully without being canceled. Invoked on the UI thread.</param>
/// <returns>
/// Task object that returns <c>false</c> if the operation was canceled by the user or
/// the critical phase threw an exception; otherwise <c>true</c>.
/// </returns>
private IPromise <bool> CreateStageTask(CancellationToken cancellationToken, BeforePromiseHandler <bool> beforeStart, CriticalPhase criticalPhase, IEnumerable <OptionalPhase> optionalPhases, FailurePromiseHandler <bool> fail, SuccessPromiseHandler <bool> succeed)
{
return(new SimplePromise(_uiContext)
.CancelWith(cancellationToken)
.Before(beforeStart)
.Fail(fail)
.Canceled(promise => fail(promise)) // TODO: Fix warning
.Work(delegate(IPromise <bool> promise)
{
cancellationToken.Register(() => Logger.Warn("User canceled current operation"));
if (criticalPhase())
{
foreach (var phase in optionalPhases.TakeWhile(phase => CanContinue(promise)))
{
phase();
}
if (CanContinue(promise))
{
_uiInvoker.InvokeAsync(() => succeed(promise));
return;
}
}
// TODO: How should we handle exceptions here?
// The rest of the code assumes exceptions are being handled by the plugin runner.
_uiInvoker.InvokeAsync(() => fail(promise));
})
);
}
/// <summary>
///
/// </summary>
/// <param name="action"></param>
/// <param name="request"></param>
/// <param name="argumentType"></param>
/// <param name="returnType"></param>
/// <returns></returns>
protected Task <TResult> GetResponseAsync <TResult>(string action, object request, Type argumentType, Type returnType)
{
if (Formatter == null)
{
throw new ServiceException("Formatter can't be null");
}
var actionInfo = _actionManager.GetAction(action);
var monitor = AppHost?.Monitor?.GetClientSession();
var context = new ClientContext
{
Action = actionInfo,
Request = request,
Formatter = Formatter,
Monitor = monitor,
};
monitor?.OnInvoking(context);
ApplyOnInvokingFilter(context);
var task = Invoker.InvokeAsync(context);
return(task.ContinueWith(tsk =>
{
ApplyOnInvokedFilter(context);
monitor?.OnInvoked(context);
if (tsk.Exception != null)
{
throw tsk.Exception.InnerException;
}
return context.Result == null
? default(TResult)
: (TResult)context.Result;
}));
}