private async Task <Uri> HandleDownload(DownloadOperation download, bool alreadyStarted)
{
var bindableDownload = new BindableDownloadOperation(download);
try {
ActiveDownloads.Add(bindableDownload);
var callback = new Progress <DownloadOperation>(OnDownloadStatusUpdate);
IAsyncOperationWithProgress <DownloadOperation, DownloadOperation> op = null;
if (alreadyStarted)
{
var d = download.AttachAsync();
op = download.AttachAsync();
}
else
{
op = download.StartAsync();
}
op.Progress = (a, p) => {
OnBindableStatusUpdate(bindableDownload);
};
// awaits completion of download
DownloadOperation completedDownload = await op.AsTask(Cts.Token, callback);
return(FileUtils.UriFor(completedDownload.ResultFile));
} finally {
// download complete
ActiveDownloads.Remove(bindableDownload);
}
}
private async Task Handel(DownloadOperation downloadOperation, CancellationTokenSource cancellationTokenSource)
{
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (cancellationTokenSource != null)
{
await downloadOperation.AttachAsync().AsTask(cancellationTokenSource.Token, progressCallback);
}
else
{
await downloadOperation.AttachAsync().AsTask(progressCallback);
}
//var ls = list_Downing.ItemsSource as ObservableCollection<DisplayModel>;
GetDowned();
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
if (ex.Message.Contains("0x80072EF1") || ex.Message.Contains("0x80070002") || ex.Message.Contains("0x80004004"))
{
return;
}
await new MessageDialog(ex.Message).ShowAsync();
}
finally
{
RemoveItem(downloadOperation.Guid.ToString());
}
}
private async Task HandleDownloadAsync(DownloadOperation download, DownloadInfo info, bool start)
{
try
{
_activeDownloads[info.ChannelId] = download;
_cts[info.ChannelId] = new CancellationTokenSource();
var progressCallback = new Progress <DownloadOperation>(downOperation =>
{
DownloadProgress(downOperation, info);
});
if (start)
{
await download.StartAsync().AsTask(_cts[info.ChannelId].Token, progressCallback);
}
else
{
await download.AttachAsync().AsTask(_cts[info.ChannelId].Token, progressCallback);
}
_activeDownloads.Remove(info.ChannelId);
_cts.Remove(info.ChannelId);
var response = download.GetResponseInformation();
_isDownloading = false;
DownloadCompleted(info);
}
catch (System.Threading.Tasks.TaskCanceledException) { }
catch (Exception ex)
{
_isDownloading = false;
DownloadFailture(info, ex.Message);
}
}
private async Task HandleDownload(DownloadOperation download, bool start)
{
try
{
activeDownloads.Add(download);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
string statusCode = response != null?response.StatusCode.ToString() : string.Empty;
}
catch (Exception ex)
{
}
finally
{
activeDownloads.Remove(download);
}
}
public async void AttachDownloadOperation(DownloadOperation download, bool IsForResuming = false)
{
cts = new CancellationTokenSource();
Progress <DownloadOperation> progress = new Progress <DownloadOperation>(progressChanged);
if (IsForResuming)
{
try
{
await download.AttachAsync().AsTask(cts.Token, progress);
}
catch (Exception ex)
{
this.SetStatusText = ex.Message;
}
}
else
{
try
{
await download.StartAsync().AsTask(cts.Token, progress);
}
catch (Exception ex)
{
this.SetStatusText = ex.Message;
}
}
}
private async Task Run()
{
if (_downloadOperation != null)
{
_cancellationToken = new CancellationTokenSource();
await _downloadOperation.AttachAsync().AsTask(_cancellationToken.Token);
}
else
{
string fullPath = AddBackslash(RemoteFile.Path);
fullPath += RemoteFile.Name;
BackgroundDownloader downloader = new BackgroundDownloader();
downloader.SetRequestHeader("Authorization", "Bearer " + RemoteFile.Account.Token);
_downloadOperation =
downloader.CreateDownload(new Uri("https://graph.microsoft.com/v1.0/me" + fullPath + ":/content"),
_loсalFile);
_cancellationToken = new CancellationTokenSource();
_proccessId = _downloadOperation.Guid.GetHashCode();
await _downloadOperation.StartAsync().AsTask(_cancellationToken.Token);
}
try
{
StorageApplicationPermissions.FutureAccessList.Remove(_localFileToken);
}
catch (Exception e)
{
}
}
//处理正在下载的任务
private async Task HandleDownloadAsync(DownloadOperation download, bool v)
{
try
{
TransferModel transfer = new TransferModel();
transfer.DownloadOperation = download;
transfer.Source = download.RequestedUri.ToString();
transfer.Destination = download.ResultFile.Path;
transfer.BytesReceived = download.Progress.BytesReceived;
transfer.TotalBytesToReceive = download.Progress.TotalBytesToReceive;
transfer.Progress = 0;
transfers.Add(transfer);
//当下载进度发生变化时的回调函数
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(downloadprogressAsync);
//监听已存在的后台下载任务
await download.AttachAsync().AsTask(cancelToken.Token, progressCallback);
ResponseInformation response = download.GetResponseInformation();
}
catch (TaskCanceledException)
{
await new MessageDialog("任务取消：").ShowAsync();
}
catch (Exception ex)
{
await new MessageDialog("处理下载任务失败：" + ex).ShowAsync();
}
finally
{
transfers.Remove(transfers.First(p => p.DownloadOperation == download));
DownloadList.Remove(download);
NoTask.Visibility = Visibility.Visible;
}
}
private async void Page_Loaded(object sender, RoutedEventArgs e)
{
IReadOnlyList <DownloadOperation> downloads = await BackgroundDownloader.GetCurrentDownloadsAsync();
if (downloads.Count > 0)
{
downloadOperation = downloads.First();
cancellationToken = new CancellationTokenSource();
Progress <DownloadOperation> progress = new Progress <DownloadOperation>(progressChanged);
btnDownload.IsEnabled = false;
btnCancel.IsEnabled = true;
btnPauseResume.IsEnabled = true;
try
{
txtStatus.Text = "Initializing...";
await downloadOperation.AttachAsync().AsTask(cancellationToken.Token, progress);
}
catch (TaskCanceledException)
{
txtStatus.Text = "Download cancelled";
downloadOperation.ResultFile.DeleteAsync();
btnPauseResume.Content = "Resume";
btnCancel.IsEnabled = false;
btnPauseResume.IsEnabled = false;
btnDownload.IsEnabled = true;
downloadOperation = null;
}
}
}
/// <summary>
/// Handle the Background download operation
/// </summary>
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
ModelDownloadStarted?.Invoke(this, null);
await download.StartAsync().AsTask(_cts.Token, progressCallback);
}
else
{
await download.AttachAsync().AsTask(_cts.Token, progressCallback);
}
var response = download.GetResponseInformation();
}
catch (TaskCanceledException ex)
{
}
catch (Exception ex)
{
ModelDownloadError?.Invoke(this, null);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
// Store the download so we can pause/resume.
activeDownloads.Add(download);
if (start)
{
// Start the download and attach a progress handler.
await download.StartAsync();
}
else
{
// The download was already running when the application started, re-attach the progress handler.
await download.AttachAsync();
}
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
}
finally
{
activeDownloads.Remove(download);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
// Start the download and attach a progress handler.
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The download was already running when the application started, re-attach the progress handler.
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
}
catch (TaskCanceledException)
{
}
catch (Exception ex)
{
}
finally
{
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
TransferModel transfer = new TransferModel();
transfer.DownloadOperation = download;
transfer.Source = download.RequestedUri.ToString();
transfer.Destination = download.ResultFile.Path;
transfer.BytesReceived = download.Progress.BytesReceived;
transfer.TotalBytesToReceive = download.Progress.TotalBytesToReceive;
transfer.Progress = 0;
transfer.Title = download.ResultFile.Name.Replace(".mp4", "");
transfer.PhanTram = "0 %";
App.ViewModel.transfers.Add(transfer);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
await download.AttachAsync().AsTask(cancelToken.Token, progressCallback);
ResponseInformation response = download.GetResponseInformation();
Debug.WriteLine(String.Format(CultureInfo.CurrentCulture, "Completed: {0}, Status Code: {1}",
download.Guid, response.StatusCode));
}
catch (TaskCanceledException)
{
Debug.WriteLine("Canceled: " + download.Guid);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
}
finally
{
App.ViewModel.transfers.Remove(App.ViewModel.transfers.First(p => p.DownloadOperation == download));
activeDownloads.Remove(download);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try {
//LogStatus("Running: " + download.Guid, NotifyType.StatusMessage);
// Store the download so we can pause/resume.
activeDownloads.Add(download);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
// Start the download and attach a progress handler.
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The download was already running when the application started, re-attach the progress handler.
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
//LogStatus(String.Format(CultureInfo.CurrentCulture, "Completed: {0}, Status Code: {1}",
// download.Guid, response.StatusCode), NotifyType.StatusMessage);
} catch (TaskCanceledException) {
//LogStatus("Canceled: " + download.Guid, NotifyType.StatusMessage);
} catch (Exception ex) {
if (!IsExceptionHandled("Execution error", ex, download))
{
throw;
}
} finally {
activeDownloads.Remove(download);
}
}
/// <summary>
/// Download Handle
/// </summary>
/// <param name="download"></param>
/// <param name="start">ture or false; ture:start,false:attach</param>
/// <returns></returns>
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
this._listDownloads.Add(download);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
await download.StartAsync().AsTask(this._cts.Token, progressCallback);
}
else
{
await download.AttachAsync().AsTask(this._cts.Token, progressCallback);
}
}
catch (TaskCanceledException)
{
Debug.WriteLine("task canceled");
}
catch (Exception ex)
{
if (!IsExceptionHandled("Execution error", ex))
{
if (this.ErrorException != null)
{
this.ErrorException(this, ex.Message);
}
}
}
finally
{
this._listDownloads.Remove(download);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
// Start the upload and attach a progress handler.
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The upload was already running when the application started, re-attach the progress handler.
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
}
catch (TaskCanceledException)
{
XmlDocument toastXML = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText02);
XmlNodeList texts = toastXML.GetElementsByTagName("text");
texts[0].AppendChild(toastXML.CreateTextNode("HAP+ - Download Canceled"));
texts[1].AppendChild(toastXML.CreateTextNode("The download of " + download.ResultFile.Name + " has been Canceled."));
((XmlElement)toastXML.SelectSingleNode("/toast")).SetAttribute("launch", "{\"type\":\"toast\"}");
ToastNotification toast = new ToastNotification(toastXML);
ToastNotificationManager.CreateToastNotifier().Show(toast);
}
}
public async Task <StorageFile> Download(string uri)
{
Uri source = new Uri(uri + @"/download");
HttpClient client = new HttpClient();
var result = await client.GetAsync(source, HttpCompletionOption.ResponseHeadersRead);
var content = result.Content;
var header = content.Headers;
//Clean invalid chars in filename
string fileName = CleanFileName(header.ContentDisposition.FileName);
StorageFolder d = await StorageFolder.GetFolderFromPathAsync(ApplicationData.Current.LocalCacheFolder.Path);
StorageFile file = await d.CreateFileAsync(fileName, CreationCollisionOption.OpenIfExists);
var size = await file.GetBasicPropertiesAsync();
if (size.Size == 0)
{
_progress = new DownloadProgress();
_progress.ShowAsync();
_backgroundDownloader = new BackgroundDownloader();
Progress <DownloadOperation> progress = new Progress <DownloadOperation>(progressChanged);
_downloadOperation = _backgroundDownloader.CreateDownload(source, file);
_downloadOperation.StartAsync();
await _downloadOperation.AttachAsync().AsTask(_cancellationTokenSourceken.Token, progress);
}
return(file);
}
private async Task Handel(DownloadOperation downloadOperation)
{
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
await downloadOperation.AttachAsync().AsTask(progressCallback);
var ls = list_Downing.ItemsSource as ObservableCollection <DisplayModel>;
var item = ls.First(x => x.guid == downloadOperation.Guid.ToString());
ls.Remove(item);
//LoadDowning();
GetDowned();
}
catch (TaskCanceledException)
{
//SqlHelper.GetDownload(downloadOperation.Guid.ToString());
}
catch (Exception ex)
{
if (ex.Message.Contains("0x80072EF1") || ex.Message.Contains("0x80070002"))
{
return;
}
await new MessageDialog(ex.Message).ShowAsync();
}
}
private async Task HandleDownloadAsync(DownloadOperation download)
{
try
{
// For more advanced Background Transfer features, please take a look at the
// BackgroundTransfer sample.
if (download.Progress.Status == BackgroundTransferStatus.Idle)
{
await download.StartAsync();
}
else
{
await download.AttachAsync();
}
ResponseInformation response = download.GetResponseInformation();
// GetResponseInformation() returns null for non-HTTP transfers (e.g., FTP).
string statusCode = response != null?response.StatusCode.ToString() : String.Empty;
rootPage.NotifyUser(String.Format(CultureInfo.CurrentCulture,
"Successfully completed background download: {0}, Status Code: {1}",
download.Guid,
statusCode),
NotifyType.StatusMessage);
}
catch (Exception ex)
{
rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
// Start the download and attach a progress handler.
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The download was already running when the application started, re-attach the progress handler.
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
string statusCode = response != null?response.StatusCode.ToString() : String.Empty;
}
catch (TaskCanceledException)
{
//LogStatus("Canceled: " + download.Guid, NotifyType.StatusMessage);
}
catch (Exception ex)
{
/*
* if (!IsExceptionHandled("Execution error", ex, download))
* {
* throw;
* }
*/
}
}
public bool CancelDownloading(Uri uri)
{
bool bRes = false;
#if UNITY_WSA && ENABLE_WINMD_SUPPORT
if (_operations.ContainsKey(uri))
{
bRes = true;
DownloadOperation oper = _operations[uri].operation;
IStorageFile file = oper.ResultFile;
CancellationTokenSource canceledToken = new CancellationTokenSource();
canceledToken.Cancel();
oper.AttachAsync().AsTask(canceledToken.Token).ContinueWith((task) =>
{
if (file != null)
{
try
{
file.DeleteAsync();
}
catch { }
}
});
_operations.Remove(uri);
}
#endif
return(bRes);
}
/// <summary>
/// Handles download operation.
/// </summary>
/// <param name="download">The download operation.</param>
/// <param name="progress">The progress.</param>
/// <param name="start">if set to <c>true</c> starts a new operation, else attach to exist operation.</param>
private static async Task HandleDownloadAsync(DownloadOperation download, IProgress progress, bool start)
{
try
{
var progressCallback = new Progress <DownloadOperation>(
operation =>
{
if (operation.Progress.TotalBytesToReceive > 0)
{
progress.UpdateProgress(operation.Progress.BytesReceived, operation.Progress.TotalBytesToReceive);
}
});
if (start)
{
await download.StartAsync().AsTask(progressCallback);
}
else
{
await download.AttachAsync().AsTask(progressCallback);
}
}
catch (Exception ex)
{
throw HttpUtilities.ProcessException(ex);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
//LogStatus("Running: " + download.Guid, NotifyType.StatusMessage);
// Store the download so we can pause/resume.
activeDownloads.Add(download);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
//CancellationTokenSource cts = new CancellationTokenSource();
if (start)
{
// Start the download and attach a progress handler.
await download.AttachAsync().AsTask(progressCallback);
}
else
{
// The download was already running when the application started, re-attach the progress handler.
//await download.AttachAsync().AsTask(App.cts.Token, progressCallback);
try
{
await download.AttachAsync().AsTask(progressCallback);
}
catch (Exception ex)
{
//Helper.HelperMethods.MessageUser("Something went wrong. Please try again");
}
}
//ResponseInformation response = download.GetResponseInformation();
//LogStatus(String.Format(CultureInfo.CurrentCulture, "Completed: {0}, Status Code: {1}",
// download.Guid, response.StatusCode), NotifyType.StatusMessage);
}
catch (TaskCanceledException)
{
Helper.HelperMethods.MessageUser("Something went wrong. Please try again");
}
finally
{
activeDownloads.Remove(download);
}
}
/// <summary>
/// Hanbdles a single BackgroundDownload for a song.
/// </summary>
private async void HandleDownload(Track track, DownloadOperation download, bool start)
{
track.BackgroundDownload = new BackgroundDownload(download);
ActiveDownloads.Add(track);
Debug.WriteLine("Added {0} to active downloads", track);
try
{
var progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
// Start the BackgroundDownload and attach a progress handler.
await
download.StartAsync()
.AsTask(track.BackgroundDownload.CancellationTokenSrc.Token, progressCallback);
}
else
{
// The BackgroundDownload was already running when the application started, re-attach the progress handler.
await
download.AttachAsync()
.AsTask(track.BackgroundDownload.CancellationTokenSrc.Token, progressCallback);
}
//Download Completed
var response = download.GetResponseInformation();
//Make sure it is success
if (response.StatusCode < 400)
{
await DownloadFinishedForAsync(track);
}
else
{
Debug.WriteLine("Download status code for {0} is bad :/", track);
track.Status = TrackStatus.None;
await _libraryService.UpdateTrackAsync(track);
await((DownloadOperation)track.BackgroundDownload.DownloadOperation).ResultFile.DeleteAsync();
}
}
catch
{
Debug.WriteLine("Download cancelled {0}", track);
track.AudioLocalUri = null;
track.Status = TrackStatus.None;
await _libraryService.UpdateTrackAsync(track);
await((DownloadOperation)track.BackgroundDownload.DownloadOperation).ResultFile.DeleteAsync();
}
finally
{
ActiveDownloads.Remove(track);
}
}
public DownloadFileImplementation(DownloadOperation downloadOperation)
{
DownloadOperation = downloadOperation;
var progress = new Progress <DownloadOperation>(ProgressChanged);
_cancellationToken = new CancellationTokenSource();
DownloadOperation.AttachAsync().AsTask(_cancellationToken.Token, progress);
}
private async Task RestoreDonloadOperation(NicoVideoCacheProgress progress, DownloadOperation operation)
{
await AddDownloadOperation(progress);
var action = operation.AttachAsync();
action.Progress = OnDownloadProgress;
var task = action.AsTask()
.ContinueWith(OnDownloadCompleted)
.ConfigureAwait(false);
}
private void AttachDownloadOperationHandles(DownloadOperation download)
{
CurrentBlock.Text += String.Format(
"Download {0} has status {1}.\r\n",
download.Guid,
download.Progress.Status);
var asyncInfo = download.AttachAsync();
asyncInfo.Progress = new AsyncOperationProgressHandler <DownloadOperation, DownloadOperation>(OnAttachedDownloadProgress);
asyncInfo.Completed = new AsyncOperationWithProgressCompletedHandler <DownloadOperation, DownloadOperation>(OnAttachedDownloadCompleted);
}
static async Task CancelDownload(DownloadOperation download)
{
try
{
download.AttachAsync().Cancel();
await download.ResultFile.DeleteAsync();
}
catch
{
// Ignore error
}
}
private async Task Handel(DownloadOperation downloadOperation, CancellationTokenSource cancellationTokenSource)
{
bool success = true;
try
{
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (cancellationTokenSource != null)
{
await downloadOperation.AttachAsync().AsTask(cancellationTokenSource.Token, progressCallback);
}
else
{
await downloadOperation.AttachAsync().AsTask(progressCallback);
}
//var ls = list_Downing.ItemsSource as ObservableCollection<DisplayModel>;
RefreshDownloaded();
}
catch (TaskCanceledException)
{
success = false;
}
catch (Exception ex)
{
success = false;
if (ex.Message.Contains("0x80072EF1") || ex.Message.Contains("0x80070002") || ex.Message.Contains("0x80004004"))
{
return;
}
var guid = downloadOperation.Guid.ToString();
var item = Downloadings.FirstOrDefault(x => x.Items.FirstOrDefault(y => y.GUID == guid) != null);
await Utils.ShowDialog("下载出现问题", $"失败视频:{item.Title ?? ""} {item.EpisodeTitle ?? ""}\r\n" + ex.Message);
}
finally
{
RemoveItem(downloadOperation.Guid.ToString(), success);
}
}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
DownloadViewModel Selected = Downloads.FirstOrDefault(p => p.Address == download.RequestedUri.ToString());
try {
// LogStatus("Running: " + download.Guid, NotifyType.StatusMessage);
// Store the download so we can pause/resume.
// activeDownloads.Add(download);
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
if (start)
{
// Start the download and attach a progress handler.
await download.StartAsync().AsTask(cts.Token, progressCallback);
}
else
{
// The download was already running when the application started, re-attach the progress handler.
await download.AttachAsync().AsTask(cts.Token, progressCallback);
}
ResponseInformation response = download.GetResponseInformation();
// GetResponseInformation() returns null for non-HTTP transfers (e.g., FTP).
string statusCode = response != null?response.StatusCode.ToString() : String.Empty;
// download completed
Selected.Status = "decompressing...";
Selected.IsDownloadVisible = false;
// Unzip
var zipFile = await ApplicationData.Current.LocalFolder.GetFileAsync(Selected.FullFileName);
var unzipFolder = await FileHelper.GetFolderNotNullAsync(
ApplicationData.Current.LocalFolder, "cards");
await ZipHelper.UnZipFileAsync(zipFile, unzipFolder);
// end
Selected.Complete();
} catch (TaskCanceledException) {
// LogStatus("Canceled: " + download.Guid, NotifyType.StatusMessage);
} catch (Exception) {
if (Selected != null)
{
await Selected.Delete();
}
} finally {
// activeDownloads.Remove(download);
}
}
//private void StartDownload_Click(object sender, RoutedEventArgs e)
//{
// StartDownload(BackgroundTransferPriority.Default);
//}
//private void PauseAll_Click(object sender, RoutedEventArgs e)
//{
// Log("Downloads: " + activeDownloads.Count);
// foreach (DownloadOperation download in activeDownloads)
// {
// // DownloadOperation.Progress is updated in real-time while the operation is ongoing. Therefore,
// // we must make a local copy so that we can have a consistent view of that ever-changing state
// // throughout this method's lifetime.
// BackgroundDownloadProgress currentProgress = download.Progress;
// if (currentProgress.Status == BackgroundTransferStatus.Running)
// {
// download.Pause();
// Log("Paused: " + download.Guid);
// }
// else
// {
// Log(String.Format(CultureInfo.CurrentCulture, "Skipped: {0}, Status: {1}", download.Guid,
// currentProgress.Status));
// }
// }
//}
//private void ResumeAll_Click(object sender, RoutedEventArgs e)
//{
// Log("Downloads: " + activeDownloads.Count);
// foreach (DownloadOperation download in activeDownloads)
// {
// // DownloadOperation.Progress is updated in real-time while the operation is ongoing. Therefore,
// // we must make a local copy so that we can have a consistent view of that ever-changing state
// // throughout this method's lifetime.
// BackgroundDownloadProgress currentProgress = download.Progress;
// if (currentProgress.Status == BackgroundTransferStatus.PausedByApplication)
// {
// download.Resume();
// Log("Resumed: " + download.Guid);
// }
// else
// {
// Log(String.Format(CultureInfo.CurrentCulture, "Skipped: {0}, Status: {1}", download.Guid,
// currentProgress.Status));
// }
// }
//}
//private void CancelAll_Click(object sender, RoutedEventArgs e)
//{
// Log("Canceling Downloads: " + activeDownloads.Count);
// cts.Cancel();
// cts.Dispose();
// // Re-create the CancellationTokenSource and activeDownloads for future downloads.
// cts = new CancellationTokenSource();
// activeDownloads = new List<DownloadOperation>();
//}
// Note that this event is invoked on a background thread, so we cannot access the UI directly.
//private void DownloadProgress(DownloadOperation download)
//{
// // DownloadOperation.Progress is updated in real-time while the operation is ongoing. Therefore,
// // we must make a local copy so that we can have a consistent view of that ever-changing state
// // throughout this method's lifetime.
// BackgroundDownloadProgress currentProgress = download.Progress;
// MarshalLog(String.Format(CultureInfo.CurrentCulture, "Progress: {0}, Status: {1}", download.Guid,
// currentProgress.Status));
// double percent = 100;
// if (currentProgress.TotalBytesToReceive > 0)
// {
// percent = currentProgress.BytesReceived * 100 / currentProgress.TotalBytesToReceive;
// }
// MarshalLog(String.Format(
// CultureInfo.CurrentCulture,
// " - Transfered bytes: {0} of {1}, {2}%",
// currentProgress.BytesReceived,
// currentProgress.TotalBytesToReceive,
// percent));
// if (currentProgress.HasRestarted)
// {
// MarshalLog(" - Download restarted");
// }
// if (currentProgress.HasResponseChanged)
// {
// // We have received new response headers from the server.
// // Be aware that GetResponseInformation() returns null for non-HTTP transfers (e.g., FTP).
// ResponseInformation response = download.GetResponseInformation();
// int headersCount = response != null ? response.Headers.Count : 0;
// MarshalLog(" - Response updated; Header count: " + headersCount);
// // If you want to stream the response data this is a good time to start.
// // download.GetResultStreamAt(0);
// }
//}
private async Task HandleDownloadAsync(DownloadOperation download, bool start)
{
try
{
log.Info("Running: " + download.Guid);
// Store the download so we can pause/resume.
activeDownloads.Add(download);
//Progress<DownloadOperation> progressCallback = new Progress<DownloadOperation>(DownloadProgress);
if (start)
{
// Start the download and attach a progress handler.
await download.StartAsync().AsTask(cts.Token);
}
else
{
// The download was already running when the application started, re-attach the progress handler.
await download.AttachAsync().AsTask(cts.Token /*, progressCallback*/);
}
//ResponseInformation response = download.GetResponseInformation();
// GetResponseInformation() returns null for non-HTTP transfers (e.g., FTP).
//string statusCode = response != null ? response.StatusCode.ToString() : String.Empty;
//LogStatus(
// String.Format(
// CultureInfo.CurrentCulture,
// "Completed: {0}, Status Code: {1}",
// download.Guid,
// statusCode),
// NotifyType.StatusMessage);
}
catch (TaskCanceledException)
{
log.Info("Canceled: " + download.Guid);
}
catch (Exception ex)
{
if (!IsExceptionHandled("Execution error", ex, download))
{
throw;
}
}
finally
{
activeDownloads.Remove(download);
}
}
