protected virtual void OnToastChanged(UploadToast toast)
{
base.ExecuteMethod("OnToastChanged", delegate()
{
var evnt = this.ToastChanged;
if (evnt != null)
{
evnt(this, new ToastChangedEventArgs(toast));
}
});
}
public virtual void EnqueueRequest(UploadRequest request)
{
base.ExecuteMethod("EnqueueRequest", delegate()
{
Task taskToStart = null;
UploadToast toastToNotify = null;
lock (_RequestSyncRoot)
{
this.FailedRequests.Remove(request); //jic
this.Requests.Add(request);
if (this.UploadTask == null || this.UploadTask.IsCompleted)
{
this.UploadTaskCancellationToken = new CancellationTokenSource();
taskToStart = new Task(DoUploads, UploadTaskCancellationToken.Token);
this.UploadTask = taskToStart;
}
else
{
this.CurrentTotal++;
toastToNotify = this.CurrentToast;
}
}
if (toastToNotify != null && toastToNotify.IsProcessing)
{
string format = this.UploadingFormat;
if (this.CurrentTotal == 1)
{
format = this.UploadingSingleFormat;
}
if (toastToNotify.Attempt > 1)
{
format = this.RetryingFormat;
}
if (request.IsPhoto)
{
toastToNotify.Message = string.Format(format, this.PhotoCaption, toastToNotify.CurrentIndex, this.CurrentTotal);
}
else
{
toastToNotify.Message = string.Format(format, this.VideoCaption, toastToNotify.CurrentIndex, this.CurrentTotal);
}
this.CurrentToast = toastToNotify;
}
if (taskToStart != null)
{
taskToStart.Start(TaskScheduler.Default);
}
});
}
protected virtual Task <bool> DoUploadItem(UploadRequest request, UploadToast uploadToast)
{
return(base.ExecuteFunctionAsync("DoUploadItem", async delegate()
{
bool success = false;
request.UploadAttempt = 1;
while (!success && !request.CancelRequested && (request.UploadAttempt < this.MaxUploadAttempts))
{
request.UploadAttempt++;
if (uploadToast != null)
{
uploadToast.Attempt = request.UploadAttempt;
}
request.InvokeProcessingActions();
if (request.IsPhoto)
{
success = await UploadPhotoItem(request);
}
else
{
success = await UploadVideoItem(request);
}
}
request.Succeeded = success;
request.InvokeProcessingActions();
if (request.StrongCallbackAction != null)
{
await request.StrongCallbackAction(request);
}
if (request.WeakCallbackAction != null)
{
Func <UploadRequest, Task> action = null;
request.WeakCallbackAction.TryGetTarget(out action);
if (action != null)
{
await action(request);
}
}
request.StrongCallbackAction = null;
request.WeakCallbackAction = null;
return success;
}));
}
public void ForceStop()
{
base.ExecuteMethod("ForceStop", delegate()
{
if (this.UploadTask != null && this.UploadTaskCancellationToken != null)
{
this.UploadTaskCancellationToken.Cancel();
}
UploadToast finishedToast = new UploadToast()
{
TimeOutSeconds = 2,
IsProcessing = false,
IsComplete = true,
Message = this.UploadCancelledCaption
};
this.CurrentToast = finishedToast;
lock (_RequestSyncRoot)
{
this.Requests.Clear();
}
});
}
public ToastChangedEventArgs(UploadToast toast)
{
Toast = toast;
}
protected virtual void DoUploads()
{
try
{
base.ExecuteMethod("DoUploads", delegate()
{
// Get First
UploadRequest nextRequest = null;
CurrentTotal = 0;
int current = 0;
lock (_RequestSyncRoot)
{
if (this.Requests.Count > 0)
{
CurrentTotal = this.Requests.Count;
nextRequest = this.Requests[0];
this.Requests.RemoveAt(0);
current++;
}
}
if (nextRequest == null)
{
return;
}
try
{
this.OnStarted();
bool hadError = false;
string latestCachePrefix = "";
UploadToast lastToast = null;
// Iterate
while (nextRequest != null)
{
UploadRequest request = nextRequest;
nextRequest = null; // while breaker
this.CurrentToastRequest = request;
latestCachePrefix = request.DataCachePrefix;
// Notify About Process
UploadToast uploadToast = new UploadToast()
{
TimeOutSeconds = 0,
CurrentIndex = current,
IsProcessing = true,
NativeImagePreview = request.NativeImagePreview
};
request.RelatedToast = uploadToast;
string format = this.UploadingFormat;
if (this.CurrentTotal == 1)
{
format = this.UploadingSingleFormat;
}
if (uploadToast.Attempt > 1)
{
format = RetryingFormat;
}
if (request.IsPhoto)
{
uploadToast.Message = string.Format(format, this.PhotoCaption, current, CurrentTotal);
}
else
{
uploadToast.Message = string.Format(format, this.VideoCaption, current, CurrentTotal);
}
this.CurrentToast = uploadToast;
lastToast = uploadToast;
// Process
Task <bool> uploadTask = this.DoUploadItem(request, uploadToast);
Task.WaitAll(new Task[] { uploadTask });
bool success = uploadTask.Result;
if (!success)
{
hadError = true;
}
// Get Next
lock (_RequestSyncRoot)
{
if (!success)
{
this.FailedRequests.Add(request);
}
if (this.Requests.Count > 0)
{
nextRequest = this.Requests[0];
this.Requests.RemoveAt(0);
current++;
}
else
{
this.UploadTask = null; // weird, we clear our own reference so that new ones can be spawned
}
}
}
this.CurrentToastRequest = null;
// Notify complete
UploadToast finishedToast = lastToast;
if (finishedToast == null)
{
finishedToast = new UploadToast();
}
finishedToast.IsProcessing = false;
finishedToast.Message = this.UploadCompleteCaption;
if (hadError)
{
finishedToast.IsError = true;
finishedToast.Message = this.UploadErrorCaption;
}
else
{
finishedToast.IsComplete = true;
finishedToast.TimeOutSeconds = 4;
}
this.CurrentToast = finishedToast;
if (!string.IsNullOrEmpty(latestCachePrefix))
{
this.InvalidateCacheForPrefix(latestCachePrefix);
}
}
finally
{
this.OnStopped();
}
});
}
catch (OperationCanceledException)
{
//gulp
}
}
public void DebugSetCurrentToast(UploadToast toast)
{
this.CurrentToast = toast;
}
