/// <summary>
/// After recreation, the host activity call this method to executes all pending ui operation.
/// </summary>
/// <returns><c>true</c>, if one or more pending ui operation was executed, <c>false</c> otherwise.</returns>
/// <param name="currentActiviy">Current activiy.</param>
public bool ExecutePendingUIOperation(IAsyncTaskActivity currentActiviy)
{
bool hasPendingUIOp = false;
pendingUIOperationList.RemoveAll(opItem =>
{
if (!IsCurrentUserOperation(opItem))
{
// The task is not belong to current user,
// just remove it.
return(true);
}
bool match = opItem.Item1 != null &&
opItem.Item1.AsyncTaskActivityGUID == currentActiviy.AsyncTaskActivityGUID;
if (!match && opItem.Item3 != null)
{
match = opItem.Item3(currentActiviy);
}
if (match)
{
Application.SynchronizationContext.Post(_ =>
opItem.Item2(currentActiviy), null);
hasPendingUIOp = true;
return(true);
}
return(false);
});
return(hasPendingUIOp);
}
/*
* public async Task<DownloadResult> DownloadPublicationByBookId(int bookId, CancellationToken cancelToken, DownloadProgressEventHandler downloadHandler, bool checkNetLimitation = true)
* {
* return await Task.Run(delegate{
* for(int i = 0; i < 100; ++i)
* {
* if(cancelToken.IsCancellationRequested)
* {
* return new DownloadResult(){
* DownloadStatus = DownLoadEnum.Canceled,
* Publication = GetPublication(bookId).Value,
* };
* }
*
* Thread.Sleep(100);
* if(cancelToken.IsCancellationRequested)
* {
* return new DownloadResult(){
* DownloadStatus = DownLoadEnum.Canceled,
* Publication = GetPublication(bookId).Value,
* };
* }
*
* downloadHandler(i, 100);
* }
*
* return new DownloadResult(){
* DownloadStatus = DownLoadEnum.Success,
* Publication = GetPublication(bookId).Value,
* };
* });
* }
*/
private void OnPublicationDownloadProgress(IAsyncTaskActivity currentActivity, int bookId, int progress)
{
var foundPub = PublicationList.Find(p => p.Value.BookId == bookId);
if (foundPub == null)
{
return;
}
var foundExtInfo = publicationExtInfoList.Find(p => bookId == p.BookId);
if (foundExtInfo == null)
{
return;
}
if (progress != 100 && progress - foundExtInfo.DownloadingProgress < 2)
{
return;
}
foundExtInfo.DownloadingProgress = progress;
((IDownloadPublicationTaskListener)currentActivity).UpdatePublicationDownloadingProgress(bookId);
}
public void UnregisterAsyncTaskActivity(IAsyncTaskActivity activity)
{
if (!currentResponsibleActivityList.Remove(activity))
{
throw new ArgumentException("Unable to find IAsyncTaskActivity which should be remove.", "activity");
}
}
/// <summary>
/// Submits an async ui operation to AsyncUIOperationRepeater;
/// The AsyncUIOperationRepeater will check the status of host activity to
/// decide if execute the ui operation immediately. If the ui operation can
/// execute now, the AsyncUIOperationRepeater will cache the ui operation.
/// After recreation, the activity can call ExecutePendingUIOperation in OnCreate
/// to execute all pending ui operation.
/// </summary>
/// <param name="currentActiviy">Current activiy</param>
/// <param name="op">UI operation</param>
/// <param name="discardable">If set to <c>true</c>, the ui operation will be discarded if
/// the operation can't be execute immediately.</param>
/// <param name = "addtionalMatch">Addtional critrial</param>
public void SubmitAsyncUIOperation(
IAsyncTaskActivity currentActiviy,
Action <IAsyncTaskActivity> op,
bool discardable = false,
Predicate <IAsyncTaskActivity> addtionalMatch = null)
{
var found = currentResponsibleActivityList.Find(a =>
{
if (currentActiviy != null &&
a.AsyncTaskActivityGUID == currentActiviy.AsyncTaskActivityGUID)
{
return(true);
}
else if (addtionalMatch != null)
{
return(addtionalMatch(a));
}
return(false);
});
if (found != null)
{
Application.SynchronizationContext.Post(_ => {
if (currentResponsibleActivityList.Contains(found))
{
op(found);
}
else if (!discardable)
{
pendingUIOperationList.Add(
new Tuple <IAsyncTaskActivity,
Action <IAsyncTaskActivity>,
Predicate <IAsyncTaskActivity>,
string, string>(
currentActiviy, op, addtionalMatch,
GetCurrentUserEmail(),
GetCurrentUserCountryCode()));
}
}, null);
return;
}
if (!discardable)
{
pendingUIOperationList.Add(
new Tuple <IAsyncTaskActivity,
Action <IAsyncTaskActivity>,
Predicate <IAsyncTaskActivity>,
string, string>(
currentActiviy, op, addtionalMatch,
GetCurrentUserEmail(),
GetCurrentUserCountryCode()));
}
}
public void DiscardActivitySpecificUIOperation(IAsyncTaskActivity currentActiviy)
{
pendingUIOperationList.RemoveAll(opItem =>
{
if (!IsCurrentUserOperation(opItem))
{
// The task is not belong to current user,
// just remove it.
return(true);
}
return(opItem.Item3 == null && opItem.Item1 != null &&
opItem.Item1.AsyncTaskActivityGUID == currentActiviy.AsyncTaskActivityGUID);
});
}
public bool HavePendingUIOperation(IAsyncTaskActivity currentActiviy)
{
return(null != pendingUIOperationList.Find(opItem =>
{
if (!IsCurrentUserOperation(opItem))
{
return false;
}
bool match = opItem.Item1 != null &&
opItem.Item1.AsyncTaskActivityGUID == currentActiviy.AsyncTaskActivityGUID;
if (!match && opItem.Item3 != null)
{
match = opItem.Item3(currentActiviy);
}
return match;
}));
}
public void RegisterAsyncTaskActivity(IAsyncTaskActivity activity)
{
var found = currentResponsibleActivityList.Find(a =>
a.AsyncTaskActivityGUID == activity.AsyncTaskActivityGUID);
if (found != null)
{
if (found == activity)
{
return;
}
else
{
throw new ArgumentException("2 IAsyncTaskActivity has same guid.", "activity");
}
}
currentResponsibleActivityList.Add(activity);
}
public async void DownloadPublication(IAsyncTaskActivity activity, int bookId, bool force)
{
if (IsDownloading(bookId))
{
throw new ArgumentException("The required book is downloading.", "bookId");
}
var extInfo = publicationExtInfoList.Find(p => bookId == p.BookId);
extInfo.CancellationSource = new CancellationTokenSource();
extInfo.DownloadingProgress = 0;
var downloadTask = PublicationUtil.Instance.DownloadPublicationByBookId(
bookId,
extInfo.CancellationSource.Token,
(int progress, long downloadSize) =>
AsyncUIOperationRepeater.INSTATNCE.SubmitAsyncUIOperation(
activity,
currentActivity => OnPublicationDownloadProgress(currentActivity, bookId, progress),
true,
currentActivity => currentActivity is IDownloadPublicationTaskListener),
!force);
AsyncTaskManager.INSTATNCE.RegisterTask(downloadTask, PublicationExtInfo.DOWNLOAD_PUBLICATION_TASK, bookId);
((IDownloadPublicationTaskListener)activity).UpdatePublicationDownloadingProgress(bookId);
var result = await downloadTask;
if (!AsyncTaskManager.INSTATNCE.IsBelongToCurrentUser(downloadTask))
{
// The task owner has logged off
return;
}
// The CancellationSource is useless now.
extInfo.CancellationSource.Dispose();
extInfo.CancellationSource = null;
// All status about download publication should be update here;
// Because the AsyncUIOperation will be set as discardable;
// If the download result is coming and the Activity is not
// showing on the screen, the all status about the result will be lost;
// Like the bug: http://wiki.lexiscn.com/issues/13206.
if (result.DownloadStatus == DownLoadEnum.Success)
{
DataCache.INSTATNCE.PublicationManager.UpdatePublication(result.Publication);
DataCache.INSTATNCE.PublicationManager.SetDownloadProgress(result.Publication.BookId, 100);
}
else if (result.DownloadStatus == DownLoadEnum.Canceled ||
result.DownloadStatus == DownLoadEnum.Failure ||
result.DownloadStatus == DownLoadEnum.NetDisconnected)
{
DataCache.INSTATNCE.PublicationManager.SetDownloadFailed(bookId);
}
/*
* else if(result.DownloadStatus == DownLoadEnum.NetDisconnected)
* {
* DataCache.INSTATNCE.PublicationManager.SetDownloadProgress(bookId, 0);
* }
*/
AsyncTaskManager.INSTATNCE.UnregisterTask(downloadTask);
AsyncUIOperationRepeater.INSTATNCE.SubmitAsyncUIOperation(
activity,
currentActivity =>
{
var pub = DataCache.INSTATNCE.PublicationManager.GetPublication(bookId);
if (pub == null)
{
return;
}
if (pub.Value.PublicationStatus == PublicationStatusEnum.Downloaded)
{
// to fix the download status due to unknown reason.
// releated bug: http://wiki.lexiscn.com/issues/12947
result.DownloadStatus = DownLoadEnum.Success;
}
((IDownloadPublicationTaskListener)currentActivity).ProcessDownloadResult(result, bookId);
},
true,
currentActivity => currentActivity is IDownloadPublicationTaskListener
);
}
public bool IsActivityActive(IAsyncTaskActivity activity)
{
return(currentResponsibleActivityList.Contains(activity));
}
