private void HandleDownloadProgress(DownloadItemViewModel downloadItemViewModel, object progress) { if (progress is DownloadFileProgress downloadFileProgress) { downloadItemViewModel.UpdateProgress(downloadFileProgress.DownloadedBytes, downloadFileProgress.FileSize); } }
public void Download(DownloadItemViewModel newDownload) { if (!AssetCatalog.TryParseDownloadUrl(newDownload.DownloadUrl, out DownloadLocationType type, out string location)) { return; } switch (type) { case DownloadLocationType.Url: DownloadFileFromUrl(newDownload, location); break; case DownloadLocationType.GDrive: DownloadFileFromGDrive(newDownload, location); break; case DownloadLocationType.MegaFile: DownloadFileFromMega(newDownload, location); break; } newDownload.IsStarted = true; }
private void ApplyDownloadManagerBatchEventArgs(ObservableCollection <DownloadItemViewModel> downloads, DownloadManagerBatchEventArgs downloadManagerBatchEventArgs, out bool selectionButtonStatesUpdateRequired, out bool nonSelectionButtonStatesUpdateRequired) { selectionButtonStatesUpdateRequired = false; nonSelectionButtonStatesUpdateRequired = false; foreach (DownloadItemEventArgs downloadItemEventArgs in downloadManagerBatchEventArgs.BatchEvents) { switch (downloadItemEventArgs) { case DownloadItemAddedEventArgs downloadItemAddedEvent: DownloadItemViewModel newDownloadItemViewModel = ToDownloadItemViewModel(downloadItemAddedEvent.AddedDownloadItem); downloadDictionary[newDownloadItemViewModel.Id] = newDownloadItemViewModel; downloads.Add(newDownloadItemViewModel); nonSelectionButtonStatesUpdateRequired = true; break; case DownloadItemChangedEventArgs downloadItemChangedEvent: DownloadItem changedDownloadItem = downloadItemChangedEvent.ChangedDownloadItem; DownloadItemViewModel changedDownloadItemViewModel = downloadDictionary[changedDownloadItem.Id]; bool statusChanged = changedDownloadItemViewModel.Status != changedDownloadItem.Status; changedDownloadItemViewModel.Name = changedDownloadItem.FileName; if (statusChanged) { changedDownloadItemViewModel.Status = changedDownloadItem.Status; } changedDownloadItemViewModel.ProgressText = GetDownloadProgressText(changedDownloadItem); changedDownloadItemViewModel.ProgressValue = GetDownloadProgressValue(changedDownloadItem); if (statusChanged) { if (changedDownloadItemViewModel.IsSelected) { selectionButtonStatesUpdateRequired = true; } nonSelectionButtonStatesUpdateRequired = true; } break; case DownloadItemRemovedEventArgs downloadItemRemovedEvent: DownloadItem removedDownloadItem = downloadItemRemovedEvent.RemovedDownloadItem; DownloadItemViewModel removedDownloadItemViewModel = downloadDictionary[removedDownloadItem.Id]; bool wasSelected = removedDownloadItemViewModel.IsSelected; downloads.Remove(removedDownloadItemViewModel); if (wasSelected) { selectionButtonStatesUpdateRequired = true; } nonSelectionButtonStatesUpdateRequired = true; break; case DownloadItemLogLineEventArgs downloadItemLogLineEvent: DownloadItemViewModel downloadItemViewModel = downloadDictionary[downloadItemLogLineEvent.DownloadItemId]; if (downloadItemLogLineEvent.LineIndex >= downloadItemViewModel.Logs.Count) { downloadItemViewModel.Logs.Add(ToDownloadItemLogLineViewModel(downloadItemLogLineEvent.LogLine)); } break; } } }
public DownloadItemViewModel Download(string link, string saveFilePath, string description, Action onCancel, Action onComplete) { DownloadLocationType type; string location; if (!AssetCatalog.TryParseDownloadUrl(link, out type, out location)) { return(null); } Action onError = () => { }; DownloadItemViewModel newDownload = new DownloadItemViewModel() { ItemName = description, OnCancel = onCancel, OnError = onError, OnComplete = onComplete, DownloadSpeed = "Calculating ...", DownloadType = DownloadType.Asset }; switch (type) { case DownloadLocationType.Url: using (var wc = new System.Net.WebClient()) { newDownload.PerformCancel = () => { wc.CancelAsync(); newDownload.OnCancel?.Invoke(); }; wc.DownloadProgressChanged += new System.Net.DownloadProgressChangedEventHandler(_wc_DownloadProgressChanged); wc.DownloadFileCompleted += new AsyncCompletedEventHandler(_wc_DownloadFileCompleted); wc.DownloadFileAsync(new Uri(location), saveFilePath, newDownload); } break; case DownloadLocationType.GDrive: var gd = new GDrive(); newDownload.PerformCancel = () => { gd.CancelAsync(); newDownload.OnCancel?.Invoke(); }; gd.DownloadProgressChanged += new System.Net.DownloadProgressChangedEventHandler(_wc_DownloadProgressChanged); gd.DownloadFileCompleted += new AsyncCompletedEventHandler(_wc_DownloadFileCompleted); gd.Download(location, saveFilePath, newDownload); break; } newDownload.IsStarted = true; return(newDownload); }
void _wc_DownloadProgressChanged(object sender, System.Net.DownloadProgressChangedEventArgs e) { DownloadItemViewModel item = (DownloadItemViewModel)e.UserState; int prog = e.ProgressPercentage; if ((e.TotalBytesToReceive < 0) && (sender is GDrive)) { prog = (int)(100 * e.BytesReceived / (sender as GDrive).GetContentLength()); } UpdateDownloadProgress(item, prog, e.BytesReceived); }
private void menuItemCancelDownload_Click(object sender, RoutedEventArgs e) { DownloadItemViewModel downloadItem = lstDownloads.SelectedItem as DownloadItemViewModel; if (downloadItem == null) { return; } downloadItem.PerformCancel?.Invoke(); }
public void SelectDownload(Guid downloadId) { ExecuteInUiThread(() => { DownloadItemViewModel downloadItemToSelect = Downloads.FirstOrDefault(downloadItemViewModel => downloadItemViewModel.Id == downloadId); if (downloadItemToSelect != null) { SelectedDownload = downloadItemToSelect; Events.RaiseEvent(ViewModelEvent.RegisteredEventId.SCROLL_TO_SELECTION); } }); }
private void menuItemCancelDownload_Click(object sender, RoutedEventArgs e) { DownloadItemViewModel downloadItem = lstDownloads.SelectedItem as DownloadItemViewModel; if (downloadItem == null) { return; } downloadItem.IsCanceled = true; ViewModel.CancelDownload(downloadItem); }
private void DownloadFileFromGDrive(DownloadItemViewModel newDownload, string fileId) { GDrive gd = new GDrive(); newDownload.PerformCancel = () => { gd.CancelAsync(); newDownload.OnCancel?.Invoke(); }; gd.DownloadProgressChanged += new System.Net.DownloadProgressChangedEventHandler(_wc_DownloadProgressChanged); gd.DownloadFileCompleted += new AsyncCompletedEventHandler(_wc_DownloadFileCompleted); gd.Download(fileId, newDownload.SaveFilePath, newDownload); }
private void DownloadFileFromUrl(DownloadItemViewModel newDownload, string url) { using (var wc = new System.Net.WebClient()) { newDownload.PerformCancel = () => { wc.CancelAsync(); newDownload.OnCancel?.Invoke(); }; wc.DownloadProgressChanged += new System.Net.DownloadProgressChangedEventHandler(_wc_DownloadProgressChanged); wc.DownloadFileCompleted += new AsyncCompletedEventHandler(_wc_DownloadFileCompleted); wc.DownloadFileAsync(new Uri(url), newDownload.SaveFilePath, newDownload); } }
public void AddAndStart(string filepath, string url, int no, int type = 0) { var item = new DownloadItemViewModel(_downloadService) { FilePath = filepath, Url = url, No = no, Type = type }; Downloads.Add(item); item.Start(); }
private async Task DownloadNextItemAsync() { DownloadItemViewModel downloadItem = Downloads.FirstOrDefault(downloadItemViewModel => downloadItemViewModel.Status == DownloadItemStatus.QUEUED); if (downloadItem == null) { return; } string dumpUrl = downloadItem.Collection.DownloadUrl; string dumpFilePath = downloadItem.Collection.DownloadFilePath; Progress <object> downloadProgressHandler = new Progress <object>(progress => HandleDownloadProgress(downloadItem, progress)); DownloadUtils.DownloadResult downloadResult = default; bool error = false; downloadItem.UpdateStatus(DownloadItemStatus.DOWNLOADING); try { downloadResult = await MainModel.LibgenDumpDownloader.DownloadDumpAsync(dumpUrl, dumpFilePath, downloadProgressHandler, downloadCancellationTokenSource.Token); } catch (Exception exception) { Logger.Exception(exception); error = true; } if (!error) { switch (downloadResult) { case DownloadUtils.DownloadResult.COMPLETED: downloadItem.UpdateStatus(DownloadItemStatus.COMPLETED); break; case DownloadUtils.DownloadResult.CANCELLED: downloadItem.UpdateStatus(DownloadItemStatus.STOPPED); break; case DownloadUtils.DownloadResult.INCOMPLETE: case DownloadUtils.DownloadResult.ERROR: error = true; break; } } if (error) { downloadItem.UpdateStatus(DownloadItemStatus.ERROR); } }
private void DownloaderListBoxDoubleClick() { if (SelectedRows.Count == 1) { DownloadItemViewModel selectedDownload = SelectedDownloads.First(); if (selectedDownload.Status == DownloadItemStatus.COMPLETED) { string downloadedFilePath = Path.Combine(selectedDownload.DownloadDirectory, selectedDownload.Name); if (File.Exists(downloadedFilePath)) { Process.Start(downloadedFilePath); } else { ShowMessage(Localization.FileNotFoundErrorTitle, Localization.GetFileNotFoundErrorText(downloadedFilePath)); } } } }
public void Download(DownloadItemViewModel newDownload) { DownloadLocationType type; string location; if (!AssetCatalog.TryParseDownloadUrl(newDownload.DownloadUrl, out type, out location)) { return; } switch (type) { case DownloadLocationType.Url: using (var wc = new System.Net.WebClient()) { newDownload.PerformCancel = () => { wc.CancelAsync(); newDownload.OnCancel?.Invoke(); }; wc.DownloadProgressChanged += new System.Net.DownloadProgressChangedEventHandler(_wc_DownloadProgressChanged); wc.DownloadFileCompleted += new AsyncCompletedEventHandler(_wc_DownloadFileCompleted); wc.DownloadFileAsync(new Uri(location), newDownload.SaveFilePath, newDownload); } break; case DownloadLocationType.GDrive: var gd = new GDrive(); newDownload.PerformCancel = () => { gd.CancelAsync(); newDownload.OnCancel?.Invoke(); }; gd.DownloadProgressChanged += new System.Net.DownloadProgressChangedEventHandler(_wc_DownloadProgressChanged); gd.DownloadFileCompleted += new AsyncCompletedEventHandler(_wc_DownloadFileCompleted); gd.Download(location, newDownload.SaveFilePath, newDownload); break; } newDownload.IsStarted = true; }
private void UpdateDownloadProgress(DownloadItemViewModel item, int percentDone, long bytesReceived) { if (item.PercentComplete != percentDone) { item.PercentComplete = percentDone; } TimeSpan interval = DateTime.Now - item.LastCalc; if ((interval.TotalSeconds >= 5)) { if (bytesReceived > 0) { item.DownloadSpeed = (((bytesReceived - item.LastBytes) / 1024.0) / interval.TotalSeconds).ToString("0.0") + "KB/s"; item.LastBytes = bytesReceived; } item.LastCalc = DateTime.Now; } }
private void DownloadAllPreviewImagesAsync() { Task t = Task.Factory.StartNew(() => { CreateRequiredFolders(); foreach (AssetViewModel asset in AllAssets.ToList()) { string pathToThumbnail = Path.Combine(AbsolutePathToThumbnails, asset.Asset.IDWithoutExtension); if (ImageCache.IsOutOfDate(pathToThumbnail) || ImageCache.IsSourceUrlDifferent(pathToThumbnail, asset.Asset.PreviewImage)) { ImageCache.AddOrUpdate(pathToThumbnail, asset.Asset.PreviewImage); Guid downloadId = Guid.NewGuid(); Action onCancel = () => { RemoveFromDownloads(downloadId); }; Action onError = () => { RemoveFromDownloads(downloadId); }; Action onComplete = () => { RemoveFromDownloads(downloadId); }; string formattedUrl = "rsmm://Url/" + asset.Asset.PreviewImage.Replace("://", "$"); DownloadItemViewModel downloadItem = new DownloadItemViewModel() { UniqueId = downloadId, DownloadType = DownloadType.Image, ItemName = "Downloading preview image", DownloadUrl = formattedUrl, SaveFilePath = pathToThumbnail, OnCancel = onCancel, OnComplete = onComplete, OnError = onError }; AddToDownloads(downloadItem); } } }); }
void _wc_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e) { DownloadItemViewModel item = (DownloadItemViewModel)e.UserState; if (e.Cancelled) { if (sender is System.Net.WebClient) { (sender as System.Net.WebClient).Dispose(); } item.OnCancel?.Invoke(); } else if (e.Error != null) { item.OnError?.Invoke(e.Error); } else { item.OnComplete?.Invoke(); } }
public static void AddDownload(DownloadFileInfo downloadItem) { DownloadWindow tempWindow = null; lock (DownloadWindows) { if (!DownloadWindows.TryGetValue(downloadItem.Id, out tempWindow))//不在缓存列表 { SaveFileDialog sfd = new SaveFileDialog(); sfd.FileName = downloadItem.SuggestedFileName; sfd.Filter = "所有文件|*"; var res = sfd.ShowDialog(); if (res == DialogResult.OK) { tempWindow = new DownloadWindow(); var vm = new DownloadItemViewModel() { FullPath = sfd.FileName, ID = downloadItem.Id, ReceivedBytes = 0, Url = downloadItem.Url, TotalBytes = downloadItem.TotalBytes }; tempWindow.Closed += (s, e) => { tempWindow.DataContext = null; tempWindow.Close(); DownloadWindows.TryRemove(downloadItem.Id, out tempWindow); }; tempWindow.DataContext = vm; tempWindow.Show(); tempWindow.Activate(); DownloadWindows.TryAdd(downloadItem.Id, tempWindow); } } } }
void _wc_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e) { DownloadItemViewModel item = (DownloadItemViewModel)e.UserState; if (e.Cancelled) { if (sender is System.Net.WebClient) { (sender as System.Net.WebClient).Dispose(); } item.OnCancel?.Invoke(); } else if (e.Error != null) { item.OnError?.Invoke(); string msg = $"Error {item.ItemName} - {e.Error.GetBaseException().Message}"; } else { item.OnComplete?.Invoke(); } }
private void RemoveFromDownloads(DownloadItemViewModel download) { if (download == null) { return; } var currentList = CurrentDownloads.ToList(); currentList.Remove(download); CurrentDownloads = currentList; if (CurrentDownloads.Count > 0) { int nextItemIndex = CurrentDownloads.FindIndex(d => !d.IsStarted); if (nextItemIndex >= 0) { AssetDownloader.Instance.Download(CurrentDownloads[nextItemIndex]); } } }
private void AddToDownloads(DownloadItemViewModel downloadItem) { if (downloadItem == null) { return; } var currentList = CurrentDownloads.ToList(); // return if already added to download queue if (currentList.Any(d => d.SaveFilePath == downloadItem.SaveFilePath)) { return; } currentList.Add(downloadItem); CurrentDownloads = currentList; if (CurrentDownloads.Count == 1) { // first item added to queue so start download AssetDownloader.Instance.Download(downloadItem); } else if (CurrentDownloads.Count > 1 && CurrentDownloads[0].IsStarted && CurrentDownloads[0].DownloadType == DownloadType.Asset) { // multiple items queued with the first item being an asset... // ... in this case start the next non-asset download int nextItemIndex = CurrentDownloads.FindIndex(d => d.DownloadType != DownloadType.Asset && !d.IsStarted); if (nextItemIndex >= 0) { AssetDownloader.Instance.Download(CurrentDownloads[nextItemIndex]); } } }
private void DownloaderEvent(object sender, EventArgs e) { switch (e) { case DownloadItemAddedEventArgs downloadItemAddedEvent: DownloadItemViewModel newDownloadItemViewModel = ToDownloadItemViewModel(downloadItemAddedEvent.AddedDownloadItem); downloadDictionary[newDownloadItemViewModel.Id] = newDownloadItemViewModel; ExecuteInUiThread(() => { Downloads.Add(newDownloadItemViewModel); UpdateNonSelectionButtonStates(); }); break; case DownloadItemChangedEventArgs downloadItemChangedEvent: DownloadItem changedDownloadItem = downloadItemChangedEvent.ChangedDownloadItem; DownloadItemViewModel changedDownloadItemViewModel = downloadDictionary[changedDownloadItem.Id]; bool statusChanged = changedDownloadItemViewModel.Status != changedDownloadItem.Status; ExecuteInUiThread(() => { changedDownloadItemViewModel.Name = changedDownloadItem.FileName; if (statusChanged) { changedDownloadItemViewModel.Status = changedDownloadItem.Status; } changedDownloadItemViewModel.ProgressText = GetDownloadProgressText(changedDownloadItem); changedDownloadItemViewModel.ProgressValue = GetDownloadProgressValue(changedDownloadItem); if (statusChanged) { if (changedDownloadItemViewModel.IsSelected) { UpdateSelectionButtonStates(); } UpdateNonSelectionButtonStates(); } }); break; case DownloadItemRemovedEventArgs downloadItemRemovedEvent: DownloadItem removedDownloadItem = downloadItemRemovedEvent.RemovedDownloadItem; DownloadItemViewModel removedDownloadItemViewModel = downloadDictionary[removedDownloadItem.Id]; ExecuteInUiThread(() => { bool isSelected = removedDownloadItemViewModel.IsSelected; Downloads.Remove(removedDownloadItemViewModel); if (isSelected) { UpdateSelectionButtonStates(); } UpdateNonSelectionButtonStates(); }); break; case DownloadItemLogLineEventArgs downloadItemLogLineEvent: DownloadItemViewModel downloadItemViewModel = downloadDictionary[downloadItemLogLineEvent.DownloadItemId]; if (downloadItemLogLineEvent.LineIndex >= downloadItemViewModel.Logs.Count) { ExecuteInUiThread(() => downloadItemViewModel.Logs.Add(ToDownloadItemLogLineViewModel(downloadItemLogLineEvent.LogLine))); } break; } }
public void OnDownloadUpdated(IBrowser browser, DownloadItem downloadItem, IDownloadItemCallback callback) { try { if (!string.IsNullOrEmpty(downloadItem.FullPath)) { DownloadWindow tempWindow = null; if (DownloadWindows.TryGetValue(downloadItem.Id, out tempWindow))//存在缓存里 { var vm = tempWindow.DataContext as DownloadItemViewModel; vm.ReceivedBytes = downloadItem.ReceivedBytes; vm.TotalBytes = downloadItem.TotalBytes; if (downloadItem.IsComplete)//删除完成删除 { tempWindow.Close(); callback.Dispose(); DownloadWindows.TryRemove(downloadItem.Id, out tempWindow); } } else { if (CacheList.Count(c => c.ID == downloadItem.Id) > 0) { return; } tempWindow = new DownloadWindow(); var vm = new DownloadItemViewModel() { FullPath = downloadItem.FullPath, ID = downloadItem.Id, ReceivedBytes = downloadItem.ReceivedBytes, TotalBytes = downloadItem.TotalBytes, Url = downloadItem.Url }; tempWindow.Closed += (s, e) => { CacheList.Add(new CacheModel() { ID = downloadItem.Id, AddTime = DateTime.Now }); downloadItem.IsCancelled = true; tempWindow.DataContext = null; tempWindow.Close(); callback.Dispose(); DownloadWindows.TryRemove(downloadItem.Id, out tempWindow); Application.Current.Dispatcher.Invoke(new Action(() => { if (hideWindow != null) { hideWindow.Close(); } })); }; tempWindow.DataContext = vm; tempWindow.Show(); tempWindow.Activate(); DownloadWindows.TryAdd(downloadItem.Id, tempWindow); } } } catch (Exception ex) { Logger.Error(ex); } }
private void GetSelectedPreviewImageAsync() { if (SelectedAsset == null) { return; } IsLoadingImage = true; UserMessage = "Fetching preview image ..."; bool isDownloadingImage = false; Task t = Task.Factory.StartNew(() => { CreateRequiredFolders(); string pathToThumbnail = Path.Combine(AbsolutePathToThumbnails, SelectedAsset.Asset.IDWithoutExtension); if (ImageCache.IsOutOfDate(pathToThumbnail) || ImageCache.IsSourceUrlDifferent(pathToThumbnail, SelectedAsset.Asset.PreviewImage)) { ImageCache.AddOrUpdate(pathToThumbnail, SelectedAsset.Asset.PreviewImage); Guid downloadGuid = Guid.NewGuid(); Action onCancel = () => { RemoveFromDownloads(downloadGuid); }; Action onError = () => { RemoveFromDownloads(downloadGuid); }; Action onComplete = () => { RemoveFromDownloads(downloadGuid); GetSelectedPreviewImageAsync(); }; isDownloadingImage = true; string formattedUrl = "rsmm://Url/" + SelectedAsset.Asset.PreviewImage.Replace("://", "$"); DownloadItemViewModel imageDownload = new DownloadItemViewModel() { UniqueId = downloadGuid, DownloadType = DownloadType.Image, ItemName = "Downloading preview image", OnCancel = onCancel, OnComplete = onComplete, OnError = onError, DownloadUrl = formattedUrl, SaveFilePath = pathToThumbnail }; AddToDownloads(imageDownload); return; } else { UserMessage = ""; } if (PreviewImageSource != null) { PreviewImageSource.Close(); PreviewImageSource = null; } using (FileStream stream = File.Open(pathToThumbnail, FileMode.Open, FileAccess.Read, FileShare.Read)) { PreviewImageSource = new MemoryStream(); stream.CopyTo(PreviewImageSource); } PreviewImageSource = new MemoryStream(File.ReadAllBytes(pathToThumbnail)); }); t.ContinueWith((taskResult) => { if (taskResult.IsFaulted) { UserMessage = "Failed to get preview image."; PreviewImageSource = null; Logger.Error(taskResult.Exception); } IsLoadingImage = isDownloadingImage; }); }
public Task CheckForCatalogUpdatesAsync(bool clearCache = true) { object countLock = new object(); Task t = Task.Factory.StartNew(() => { string catFile = AbsolutePathToCatalogSettingsJson; Directory.CreateDirectory(AbsolutePathToTempDownloads); CatalogSettings currentSettings = new CatalogSettings(); if (File.Exists(catFile)) { currentSettings = JsonConvert.DeserializeObject <CatalogSettings>(File.ReadAllText(catFile)); currentSettings.CatalogUrls.RemoveAll(s => string.IsNullOrWhiteSpace(s.Url)); } else { CatalogSettings.AddDefaults(currentSettings); } if (currentSettings.CatalogUrls.Count == 0) { if (File.Exists(catFile)) { File.Delete(catFile); } _catalogCache = new AssetCatalog(); ReloadAllAssets(); RefreshFilteredAssetList(); return; } if (clearCache) { lock (catalogCacheLock) { _catalogCache = new AssetCatalog(); } } foreach (CatalogSubscription sub in currentSettings.CatalogUrls.Where(c => c.IsActive).ToArray()) { Logger.Info($"Checking catalog {sub.Url}"); string uniqueFileName = $"cattemp{Path.GetRandomFileName()}.xml"; // save temp catalog update to unique filename so multiple catalog updates can download async string path = Path.Combine(AbsolutePathToTempDownloads, uniqueFileName); Guid downloadId = Guid.NewGuid(); Action onCancel = () => { RemoveFromDownloads(downloadId); }; Action onError = () => { RemoveFromDownloads(downloadId); }; Action onComplete = () => { RemoveFromDownloads(downloadId); try { AssetCatalog c = JsonConvert.DeserializeObject <AssetCatalog>(File.ReadAllText(path)); lock (catalogCacheLock) // put a lock on the Catalog so multiple threads can only merge one at a time { _catalogCache = AssetCatalog.Merge(_catalogCache, c); File.WriteAllText(AbsolutePathToCatalogJson, JsonConvert.SerializeObject(_catalogCache, Formatting.Indented)); } } catch (Exception ex) { Logger.Error(ex); } finally { // delete temp catalog if (File.Exists(path)) { File.Delete(path); } ReloadAllAssets(); RefreshFilteredAssetList(); } }; DownloadItemViewModel catalogDownload = new DownloadItemViewModel() { UniqueId = downloadId, DownloadType = DownloadType.Catalog, ItemName = $"Checking catalog {sub.Url}", DownloadUrl = AssetCatalog.FormatUrl(sub.Url), SaveFilePath = path, OnComplete = onComplete, OnError = onError, OnCancel = onCancel }; AddToDownloads(catalogDownload); } }); return(t); }
private void RemoveFromDownloads(Guid downloadID) { DownloadItemViewModel toRemove = CurrentDownloads.FirstOrDefault(d => d.UniqueId == downloadID); RemoveFromDownloads(toRemove); }
/// <summary> /// Main method for downloading and installing the selected asset asynchronously. /// </summary> public void DownloadSelectedAssetAsync() { CreateRequiredFolders(); AssetViewModel assetToDownload = SelectedAsset; // get the selected asset currently in-case user selection changes while download occurs string pathToDownload = Path.Combine(AbsolutePathToTempDownloads, assetToDownload.Asset.ID); Guid downloadId = Guid.NewGuid(); Action onComplete = () => { IsInstallingAsset = true; RemoveFromDownloads(downloadId); UserMessage = $"Installing asset: {assetToDownload.Name} ... "; Task installTask = Task.Factory.StartNew(() => { InstallDownloadedAsset(assetToDownload, pathToDownload); }); installTask.ContinueWith((installResult) => { if (installResult.IsFaulted) { UserMessage = $"Failed to install asset ..."; Logger.Error(installResult.Exception); IsInstallingAsset = false; return; } // lastly delete downloaded file if (DeleteDownloadAfterInstall && File.Exists(pathToDownload)) { File.Delete(pathToDownload); } IsInstallingAsset = false; RefreshPreviewForSelected(); // refresh list if filtering by installed or uninstalled if (SelectedInstallStatus != defaultInstallStatusValue) { RefreshFilteredAssetList(); } if (assetToDownload.AssetCategory == AssetCategory.Maps.Value) { HasDownloadedMap = true; } }); }; Action onError = () => { RemoveFromDownloads(downloadId); UserMessage = $"Failed to download {assetToDownload.Name}"; }; Action onCancel = () => { RemoveFromDownloads(downloadId); UserMessage = $"Canceled downloading {assetToDownload.Name}"; }; DownloadItemViewModel downloadItem = new DownloadItemViewModel() { UniqueId = downloadId, DownloadType = DownloadType.Asset, ItemName = $"Downloading {assetToDownload.Name}", DownloadUrl = assetToDownload.Asset.DownloadLink, SaveFilePath = pathToDownload, OnCancel = onCancel, OnComplete = onComplete, OnError = onError, }; AddToDownloads(downloadItem); }
public void OnDownloadUpdated(IWebBrowser chromiumWebBrowser, IBrowser browser, DownloadItem downloadItem, IDownloadItemCallback callback) { DownloadItemViewModel _item = null; //初始暂停 if (string.IsNullOrWhiteSpace(downloadItem.FullPath)) { callback.Pause(); } else//初始化完毕 { //插入记录 if (!DownloadMap.ContainsKey(downloadItem.Id)) { _item = new DownloadItemViewModel(); _item.customDownloadHandler = this; _item.UpDate(downloadItem); DownloadMap.Add(downloadItem.Id, _item); //Console.WriteLine("----insert {0}", _item.ID); } else { //获取对应记录 _item = DownloadMap[downloadItem.Id]; } //继续开始下载 if (!_item.IsInitalized) { _item.IsInitalized = true; callback.Resume(); } } if (_item != null && _item.IsInitalized) { _item.UpDate(downloadItem); //callback管理 if (callback.IsDisposed) { Console.WriteLine("Callback disposed"); } else { if (ControlMap.ContainsKey(_item.ID)) { ControlMap[_item.ID] = callback; } else { ControlMap.Add(_item.ID, callback); } } //更新 OnUpdated?.BeginInvoke(this, _item, (o) => { if (_item.NeedPause) { try { GetControl(_item.ID)?.Pause(); } catch (Exception e) { Console.WriteLine("Cancel Error :{0}", e.Message); } _item.NeedPause = false; _item.IsPaused = true; } if (_item.NeedCancel) { try { GetControl(_item.ID)?.Cancel(); } catch (Exception e) { Console.WriteLine("Cancel Error :{0}", e.Message); } _item.NeedCancel = false; _item.IsCancelled = true; } if (_item.NeedResume) { try { GetControl(_item.ID)?.Resume(); } catch (Exception e) { Console.WriteLine("Resume Error :{0}", e.Message); } _item.NeedResume = false; _item.IsPaused = false; } OnUpdated.Invoke(this, _item); }, null); } }
private void DownloadFileFromMega(DownloadItemViewModel newDownload, string megaFileId) { bool wasCanceled = false; newDownload.PerformCancel = () => { wasCanceled = true; try { _megaDownloadCancelTokenSource?.Cancel(); } catch (Exception dex) { Logger.Error(dex); } finally { _megaDownloadCancelTokenSource?.Dispose(); _megaDownloadCancelTokenSource = null; } newDownload.OnCancel?.Invoke(); }; var client = new MegaApiClient(); client.LoginAnonymousAsync().ContinueWith((loginResult) => { if (wasCanceled) { return; // don't continue after async login since user already canceled download } if (loginResult.IsFaulted) { newDownload.OnError?.Invoke(loginResult.Exception.GetBaseException()); return; } // get nodes from mega folder Uri fileLink = new Uri($"https://mega.nz/file/{megaFileId}"); INodeInfo node = client.GetNodeFromLink(fileLink); if (wasCanceled) { return; // don't continue after async login since user already canceled download } if (node == null) { newDownload.OnError?.Invoke(new Exception($"could not find node from link {fileLink}")); client.LogoutAsync(); return; } if (File.Exists(newDownload.SaveFilePath)) { File.Delete(newDownload.SaveFilePath); //delete old temp file if it exists (throws exception otherwise) } IProgress <double> progressHandler = new Progress <double>(x => { double estimatedBytesReceived = (double)node.Size * (x / 100); UpdateDownloadProgress(newDownload, (int)x, (long)estimatedBytesReceived); }); _megaDownloadCancelTokenSource = new CancellationTokenSource(); Task downloadTask = client.DownloadFileAsync(fileLink, newDownload.SaveFilePath, progressHandler, _megaDownloadCancelTokenSource.Token); downloadTask.ContinueWith((downloadResult) => { _megaDownloadCancelTokenSource?.Dispose(); _megaDownloadCancelTokenSource = null; client.LogoutAsync(); if (downloadResult.IsCanceled) { return; } if (downloadResult.IsFaulted) { newDownload.OnError?.Invoke(downloadResult.Exception.GetBaseException()); return; } _wc_DownloadFileCompleted(client, new AsyncCompletedEventArgs(null, false, newDownload)); }); }); }