public void StopResumeDownloadFromLastPositionTest() { // arrange var expectedStopCount = 5; var stopCount = 0; var downloadFileExecutionCounter = 0; var totalDownloadSize = 0L; var config = (DownloadConfiguration)Config.Clone(); config.BufferBlockSize = 1024; var downloader = new DownloadService(Config); downloader.DownloadProgressChanged += (s, e) => { totalDownloadSize += e.ReceivedBytes.Length; if (expectedStopCount > stopCount) { // Stopping after start of downloading downloader.CancelAsync(); stopCount++; } }; // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File16KbUrl).Wait(); while (expectedStopCount > downloadFileExecutionCounter++) { downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point. } // assert Assert.AreEqual(DownloadTestHelper.FileSize16Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DownloadTestHelper.FileSize16Kb, totalDownloadSize); }
public void TestTotalReceivedBytesOnResumeDownloadWhenLostDownloadedData() { // arrange var canStopDownload = true; var totalDownloadSize = 0L; var lastProgressPercentage = 0.0; var config = (DownloadConfiguration)Config.Clone(); config.BufferBlockSize = 1024; config.ChunkCount = 1; var downloader = new DownloadService(config); downloader.DownloadProgressChanged += (s, e) => { totalDownloadSize = e.ReceivedBytesSize; lastProgressPercentage = e.ProgressPercentage; if (canStopDownload && totalDownloadSize > DownloadTestHelper.FileSize16Kb / 2) { // Stopping after start of downloading downloader.CancelAsync(); canStopDownload = false; } }; // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File16KbUrl).Wait(); downloader.Package.Chunks[0].Storage.Clear(); // set position to zero downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point. // assert Assert.AreEqual(DownloadTestHelper.FileSize16Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DownloadTestHelper.FileSize16Kb, totalDownloadSize); Assert.AreEqual(100.0, lastProgressPercentage); }
public void StopResumeDownloadOverFirstPackagePositionTest() { // arrange var packageCheckPoint = new DownloadPackage() { Address = DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb) }; var stopThreshold = 4100; var totalReceivedBytes = 0L; var downloader = new DownloadService(Config); var isSavingStateOnCancel = false; var isSavingStateBeforCancel = false; downloader.DownloadProgressChanged += (s, e) => { totalReceivedBytes += e.ReceivedBytes.Length; isSavingStateBeforCancel |= downloader.Package.IsSaving; if (e.ReceivedBytesSize > stopThreshold) { // Stopping after start of downloading downloader.CancelAsync(); stopThreshold *= 2; // check point of package for once time packageCheckPoint.Chunks ??= downloader.Package.Chunks.Clone() as Chunk[]; } }; // act downloader.DownloadFileTaskAsync(packageCheckPoint.Address).Wait(); while (downloader.IsCancelled) { isSavingStateOnCancel |= downloader.Package.IsSaving; var firstCheckPointClone = new DownloadPackage() { Address = packageCheckPoint.Address, Chunks = packageCheckPoint.Chunks.Clone() as Chunk[] }; // resume download from first stopped point. downloader.DownloadFileTaskAsync(firstCheckPointClone).Wait(); } // assert Assert.IsTrue(downloader.Package.IsSaveComplete); Assert.IsFalse(downloader.Package.IsSaving); Assert.IsFalse(isSavingStateOnCancel); Assert.IsTrue(isSavingStateBeforCancel); Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DummyFileHelper.FileSize16Kb, totalReceivedBytes); }
public async void start() { await Task.Delay(5000); await Task.Run(async() => { var downloadOpt = new DownloadConfiguration() { ParallelDownload = true, // download parts of file as parallel or not BufferBlockSize = 10240, // usually, hosts support max to 8000 bytes ChunkCount = 8, // file parts to download MaxTryAgainOnFailover = int.MaxValue, // the maximum number of times to fail. OnTheFlyDownload = true, // caching in-memory mode Timeout = 1000 // timeout (millisecond) per stream block reader }; await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { var downloader = new DownloadService(downloadOpt); downloader.DownloadProgressChanged += OnDownloadProgressChangedAsync; downloader.DownloadFileCompleted += OnDownloadFileCompleted; var file = @"Downloads\Annotation-2019-10-04-194747.png"; await downloader.DownloadFileTaskAsync("https://i.ibb.co/YDHN1HY/Annotation-2019-10-04-194747.png", file); }); }); }
public void DynamicSpeedLimitTest() { // arrange double upperTolerance = 1.2; // 20% upper than expected avg speed double expectedAverageSpeed = DummyFileHelper.FileSize16Kb / 30; // == (256*16 + 512*8 + 1024*4 + 2048*2)/30 double averageSpeed = 0; var progressCounter = 0; Config.MaximumBytesPerSecond = 256; // 256 Byte/s var downloader = new DownloadService(Config); downloader.DownloadProgressChanged += (s, e) => { averageSpeed += e.BytesPerSecondSpeed; progressCounter++; var oneSpeedStepSize = 4096; // DummyFileHelper.FileSize16Kb / 4 var pow = Math.Ceiling((double)e.ReceivedBytesSize / oneSpeedStepSize); Config.MaximumBytesPerSecond = 128 * (int)Math.Pow(2, pow); // 256, 512, 1024, 2048 }; // act downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)).Wait(); averageSpeed /= progressCounter; // assert Assert.AreEqual(DummyFileHelper.FileSize16Kb, downloader.Package.TotalFileSize); Assert.IsTrue(averageSpeed <= expectedAverageSpeed * upperTolerance, $"Avg Speed: {averageSpeed} , Expected Avg Speed Limit: {expectedAverageSpeed*upperTolerance}, " + $"Progress Count: {progressCounter}"); }
private async void btnGetHashWeb_Click(object sender, RoutedEventArgs e) { try { if (!string.IsNullOrEmpty(txtUrl.Text) && txtUrl.Text.IsUrl()) { prgStatus.IsIndeterminate = false; btnGetHashWeb.IsEnabled = false; btnGetHashLocal.IsEnabled = false; txtHash.IsEnabled = false; try { var downloader = new DownloadService(); downloader.DownloadProgressChanged += OnDownloadProgressChanged; downloader.DownloadFileCompleted += OnDownloadFileCompleted; await downloader.DownloadFileTaskAsync(txtUrl.Text, new DirectoryInfo(Consts.TempSetupPath)); } catch (Exception ex) { prgStatus.IsIndeterminate = true; prgStatus.ShowError = true; Growl.ErrorGlobal(ex.Message); } } else { Growl.ErrorGlobal("Url field is Empty or Invalid"); } } catch (Exception ex) { Growl.ErrorGlobal(ex.Message); } }
public async void StartDownload() { await _downloader.DownloadFileTaskAsync(Url, FilePath); intermation.Status = "下载中"; intermation.StatusId = 1; }
public void Download1KbWithFilenameTest() { // arrange var downloadCompletedSuccessfully = false; var downloader = new DownloadService(Config); downloader.DownloadFileCompleted += (s, e) => { if (e.Cancelled == false && e.Error == null) { downloadCompletedSuccessfully = true; } }; // act var downloadTask = downloader.DownloadFileTaskAsync(DownloadTestHelper.File1KbUrl); downloadTask.Wait(); using var memoryStream = downloadTask.Result; // assert Assert.IsTrue(downloadCompletedSuccessfully); Assert.IsNotNull(memoryStream); Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DownloadTestHelper.FileSize1Kb, memoryStream.Length); Assert.IsTrue(DownloadTestHelper.AreEqual(DownloadTestHelper.File1Kb, memoryStream)); }
public void TestDownloadAndExecuteFileInDownloadCompletedEvent() { // arrange byte[] downloadedBytes = null; var downloadCompletedSuccessfully = false; var downloader = new DownloadService(Config); downloader.DownloadFileCompleted += (s, e) => { if (e.Cancelled == false && e.Error == null) { // Execute the downloaded file within completed event // Note: Execute within this event caused to an IOException: // The process cannot access the file '...\Temp\tmp14D3.tmp' because it is being used by another process.) downloadCompletedSuccessfully = true; downloadedBytes = File.ReadAllBytes(downloader.Package.FileName); } }; // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File1KbUrl, Path.GetTempFileName()).Wait(); // assert Assert.IsTrue(downloadCompletedSuccessfully); Assert.IsNotNull(downloadedBytes); Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloadedBytes.Length); Assert.IsTrue(DownloadTestHelper.File1Kb.AreEqual(new MemoryStream(downloadedBytes))); }
public void StopResumeDownloadTest() { // arrange var expectedStopCount = 5; var stopCount = 0; var cancellationsOccurrenceCount = 0; var downloadFileExecutionCounter = 0; var downloadCompletedSuccessfully = false; var downloader = new DownloadService(Config); downloader.DownloadFileCompleted += (s, e) => { if (e.Cancelled && e.Error != null) { cancellationsOccurrenceCount++; } else { downloadCompletedSuccessfully = true; } }; downloader.DownloadStarted += delegate { if (expectedStopCount > stopCount) { // Stopping after start of downloading downloader.CancelAsync(); stopCount++; } }; // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File150KbUrl, Path.GetTempFileName()).Wait(); while (expectedStopCount > downloadFileExecutionCounter++) { downloader.DownloadFileTaskAsync(downloader.Package).Wait(); // resume download from stopped point. } // assert Assert.IsTrue(File.Exists(downloader.Package.FileName)); Assert.AreEqual(DownloadTestHelper.FileSize150Kb, downloader.Package.TotalFileSize); Assert.AreEqual(expectedStopCount, stopCount); Assert.AreEqual(expectedStopCount, cancellationsOccurrenceCount); Assert.IsTrue(downloadCompletedSuccessfully); File.Delete(downloader.Package.FileName); }
private async Task OnStartDownload() { Model.InfoText = "Starting..."; Model.IsReady = false; InitDownloader(); if (Model.UrlAddress.StartsWith("http", StringComparison.OrdinalIgnoreCase)) { await _downloader.DownloadFileTaskAsync(Model.UrlAddress, Model.FilePath); } else { IFormatter formatter = new BinaryFormatter(); await using var packageStream = File.OpenRead(Model.UrlAddress); var package = formatter.Deserialize(packageStream) as DownloadPackage; await _downloader.DownloadFileTaskAsync(package); } }
private static async Task <DownloadService> DownloadFile(DownloadItem downloadItem) { _currentDownloadService = new DownloadService(GetDownloadConfiguration()); _currentDownloadService.ChunkDownloadProgressChanged += OnChunkDownloadProgressChanged; _currentDownloadService.DownloadProgressChanged += OnDownloadProgressChanged; _currentDownloadService.DownloadFileCompleted += OnDownloadFileCompleted; _currentDownloadService.DownloadStarted += OnDownloadStarted; if (string.IsNullOrWhiteSpace(downloadItem.FileName)) { await _currentDownloadService.DownloadFileTaskAsync(downloadItem.Url, new DirectoryInfo(downloadItem.FolderPath)).ConfigureAwait(false); } else { await _currentDownloadService.DownloadFileTaskAsync(downloadItem.Url, downloadItem.FileName).ConfigureAwait(false); } return(_currentDownloadService); }
public void DownloadOnMemoryStreamContentTest() { // arrange var downloader = new DownloadService(Config); // act using var stream = (MemoryStream)downloader.DownloadFileTaskAsync(DownloadTestHelper.File1KbUrl).Result; // assert Assert.IsTrue(DownloadTestHelper.File1Kb.SequenceEqual(stream.ToArray())); }
public void DownloadOnMemoryStreamTypeTest() { // arrange var downloader = new DownloadService(Config); // act using var stream = downloader.DownloadFileTaskAsync(DownloadTestHelper.File1KbUrl).Result; // assert Assert.IsTrue(stream is MemoryStream); }
public void TestTypeWhenDownloadOnMemoryStream() { // arrange var downloader = new DownloadService(Config); // act using var stream = downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Result; // assert Assert.IsTrue(stream is MemoryStream); }
public void TestContentWhenDownloadOnMemoryStream() { // arrange var downloader = new DownloadService(Config); // act using var stream = (MemoryStream)downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Result; // assert Assert.IsTrue(DummyFileHelper.File1Kb.SequenceEqual(stream.ToArray())); }
public void DownloadOnMemoryStreamSizeTest() { // arrange var downloader = new DownloadService(Config); // act using var stream = downloader.DownloadFileTaskAsync(DownloadTestHelper.File1KbUrl).Result; // assert Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DownloadTestHelper.FileSize1Kb, stream.Length); }
public void TestSizeWhenDownloadOnMemoryStream() { // arrange var downloader = new DownloadService(Config); // act using var stream = downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize1Kb)).Result; // assert Assert.AreEqual(DummyFileHelper.FileSize1Kb, downloader.Package.TotalFileSize); Assert.AreEqual(DummyFileHelper.FileSize1Kb, stream.Length); }
private async void DownloadPackageWithInternalDownloader() { try { var isConnected = ApplicationHelper.IsConnectedToInternet(); if (isConnected) { var item = cmbArchitectures.SelectedItem as Installer; if (item != null) { var url = Helper.RemoveUrlComment(item.InstallerUrl); if (Helper.Settings.IsIDMEnabled) { toogleDownload.IsChecked = false; Helper.DownloadWithIDM(url); } else { txtStatus.Text = $"Preparing to download {txtId.Text}"; progress.IsIndeterminate = false; progress.ShowError = false; progress.Value = 0; downloadedInstallerPath = $@"{Consts.TempPath}\{txtId.Text}-{txtVersion.Text}-{(cmbArchitectures.SelectedItem as Installer)?.Architecture}{Helper.GetExtension(url)}".Trim(); if (!File.Exists(downloadedInstallerPath)) { downloaderService = new DownloadService(); downloaderService.DownloadProgressChanged += DownloaderService_DownloadProgressChanged; downloaderService.DownloadFileCompleted += DownloaderService_DownloadFileCompleted; await downloaderService.DownloadFileTaskAsync(url, downloadedInstallerPath); } else { txtStatus.Text = $"{txtId.Text} Already downloaded, We are running it now!"; Helper.StartProcess(downloadedInstallerPath); toogleDownload.IsChecked = false; } } } } else { Helper.CreateInfoBar("Network UnAvailable", "Unable to connect to the Internet", panel, Severity.Error); } } catch (Exception ex) { Helper.CreateInfoBar("Error", ex.Message, panel, Severity.Error); toogleDownload.IsChecked = false; } }
static async Task <Image <Rgba32> > DownloadImage(string url) { var downloader = new DownloadService(new DownloadConfiguration() { BufferBlockSize = 4096, ChunkCount = 5, OnTheFlyDownload = false, ParallelDownload = true }); var stream = await downloader.DownloadFileTaskAsync(url); stream.Seek(0, SeekOrigin.Begin); return(ReadGif(stream)); }
public static async void DowloadServer(string url, string fileName) { var downloadOpt = new DownloadConfiguration() { BufferBlockSize = 10240, // usually, hosts support max to 8000 bytes, default values is 8000 ChunkCount = 8, // file parts to download, default value is 1 MaximumBytesPerSecond = int.MaxValue, // download speed limited to 1MB/s, default values is zero or unlimited MaxTryAgainOnFailover = int.MaxValue, // the maximum number of times to fail OnTheFlyDownload = false, // caching in-memory or not? default values is true ParallelDownload = true, // download parts of file as parallel or not. Default value is false TempDirectory = "C:\\temp", // Set the temp path for buffering chunk files, the default path is Path.GetTempPath() Timeout = 1000, // timeout (millisecond) per stream block reader, default values is 1000 RequestConfiguration = // config and customize request headers { Accept = "*/*", AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate, CookieContainer = new CookieContainer(), // Add your cookies Headers = new WebHeaderCollection(), // Add your custom headers KeepAlive = false, ProtocolVersion = HttpVersion.Version11, // Default value is HTTP 1.1 UseDefaultCredentials = false, UserAgent = $"DownloaderSample/{Assembly.GetExecutingAssembly().GetName().Version.ToString(3)}" } }; DownloadService downloader = new DownloadService(downloadOpt); downloader.DownloadStarted += OnDowloadStarted; downloader.DownloadFileCompleted += OnDownloadFileCompleted; downloader.DownloadProgressChanged += OnDowloadProgresChanged; await downloader.DownloadFileTaskAsync(url, fileName); void OnDowloadStarted(object sender, DownloadStartedEventArgs e) { UCLogsViewModel.TextLogs.Value += "\nDowload started"; } void OnDownloadFileCompleted(object sender, AsyncCompletedEventArgs e) { DowloadInfoUpdater.OnStopUpdateInfo(); } void OnDowloadProgresChanged(object sender, DownloadProgressChangedEventArgs e) { DowloadInfoUpdater.OnNewUpdateInfo(e); } }
public void DownloadProgressChangedTest() { // arrange var downloader = new DownloadService(Config); var progressChangedCount = (int)Math.Ceiling((double)DownloadTestHelper.FileSize16Kb / Config.BufferBlockSize); var progressCounter = 0; downloader.DownloadProgressChanged += (s, e) => Interlocked.Increment(ref progressCounter); // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File16KbUrl).Wait(); // assert // Note: some times received bytes on read stream method was less than block size! Assert.IsTrue(progressChangedCount <= progressCounter); }
public void Download16KbWithoutFilenameTest() { // arrange var downloader = new DownloadService(Config); // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File16KbUrl, new DirectoryInfo(DownloadTestHelper.TempDirectory)).Wait(); // assert Assert.IsTrue(File.Exists(downloader.Package.FileName)); Assert.IsTrue(downloader.Package.FileName.StartsWith(DownloadTestHelper.TempDirectory)); Assert.AreEqual(DownloadTestHelper.FileSize16Kb, downloader.Package.TotalFileSize); Assert.IsTrue(DownloadTestHelper.AreEqual(DownloadTestHelper.File16Kb, File.OpenRead(downloader.Package.FileName))); File.Delete(downloader.Package.FileName); }
public override async Task StartDownloadAsync(string url, FileInfo outFile) { _dlService = new DownloadService(_downloadOpt); _dlService.DownloadProgressChanged += (sender, args) => { OnProgressChanged(new AcquisitionProgress { BytesPerSecondSpeed = (long)args.BytesPerSecondSpeed, Progress = args.ReceivedBytesSize }); }; _dlService.DownloadFileCompleted += (sender, args) => { if (args.Error != null) { Log.Error(args.Error, "[WEB] Download failed for {0} with reason {1}", url, args.Error); // If we cancel downloads, we don't want to see an error message if (args.Error is OperationCanceledException) { OnComplete(AcquisitionResult.Cancelled); return; } OnComplete(AcquisitionResult.Error); return; } if (args.Cancelled) { Log.Error("[WEB] Download cancelled for {0} with reason {1}", url, args.Error); /* * Cancellation should not produce an error message, since it is always triggered by another error or the user. */ OnComplete(AcquisitionResult.Cancelled); return; } OnComplete(AcquisitionResult.Success); }; await _dlService.DownloadFileTaskAsync(url, outFile.FullName); }
public void DownloadProgressChangedTest() { // arrange var downloader = new DownloadService(Config); var progressChangedCount = (int)Math.Ceiling((double)DummyFileHelper.FileSize16Kb / Config.BufferBlockSize); var progressCounter = 0; downloader.DownloadProgressChanged += (s, e) => Interlocked.Increment(ref progressCounter); // act downloader.DownloadFileTaskAsync(DummyFileHelper.GetFileUrl(DummyFileHelper.FileSize16Kb)).Wait(); // assert // Note: some times received bytes on read stream method was less than block size! Assert.IsTrue(progressChangedCount <= progressCounter); Assert.AreEqual(100.0, downloader.Package.SaveProgress); Assert.IsTrue(downloader.Package.IsSaveComplete); Assert.IsFalse(downloader.Package.IsSaving); }
public void SpeedLimitTest() { // arrange double averageSpeed = 0; var progressCounter = 0; Config.MaximumBytesPerSecond = 128; // 128 Byte/s var downloader = new DownloadService(Config); downloader.DownloadProgressChanged += (s, e) => { averageSpeed = ((averageSpeed * progressCounter) + e.BytesPerSecondSpeed) / (progressCounter + 1); progressCounter++; }; // act downloader.DownloadFileTaskAsync(DownloadTestHelper.File1KbUrl).Wait(); // assert Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize); Assert.IsTrue(averageSpeed <= Config.MaximumBytesPerSecond, $"Average Speed: {averageSpeed} , Speed Limit: {Config.MaximumBytesPerSecond}"); }
/// <summary> /// Download MSIX from Azure /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private async void btnUpdate_Click(object sender, RoutedEventArgs e) { btnUpdate.IsEnabled = false; bool isConnected = ApplicationHelper.IsConnectedToInternet(); if (isConnected) { txtStatus.Text = "Downloading Database..."; txtMSIXStatus.Text = string.Empty; prgMSIX.Value = 0; prgMSIX.Visibility = Visibility.Visible; prgMSIX.IsIndeterminate = false; var downloader = new DownloadService(); downloader.DownloadProgressChanged += Downloader_DownloadProgressChanged; downloader.DownloadFileCompleted += Downloader_DownloadFileCompleted; await downloader.DownloadFileTaskAsync(Consts.MSIXSourceUrl, new DirectoryInfo(Consts.MSIXPath)); } else { CreateInfoBar("Network UnAvailable", "Unable to connect to the Internet", panel, Severity.Error); btnUpdate.IsEnabled = true; } }
public static async Task <string> MultiThreadDownloadFileAsync( this string url, string tempDir, string fileName = "" ) { var throttleDispatcher = new ThrottleDispatcher(2000); var pathFileName = Path.GetFileName(url); if (fileName.IsNotNullOrEmpty()) { pathFileName = fileName; } var paths = Path.Combine( "Storage/Caches/", tempDir, pathFileName ); var downloadOpt = new DownloadConfiguration() { ChunkCount = 8, ParallelDownload = true, MaxTryAgainOnFailover = 10, OnTheFlyDownload = false, RequestConfiguration = // config and customize request headers { Accept = "*/*", AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate, CookieContainer = new CookieContainer(), // Add your cookies Headers = new WebHeaderCollection(), // Add your custom headers KeepAlive = false, // default value is false ProtocolVersion = HttpVersion.Version11, // Default value is HTTP 1.1 UseDefaultCredentials = false, UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.64 Safari/537.36 Edg/101.0.1210.53" } }; var downloader = new DownloadService(downloadOpt); downloader.DownloadStarted += ( sender, args ) => { Log.Information( "Downloading File. FileName: {FileName}, Size: {Size}", args.FileName, args.TotalBytesToReceive ); }; downloader.DownloadProgressChanged += ( sender, args ) => { var downloadService = sender as DownloadService; if (downloadService == null) { return; } var downloadPackage = downloadService.Package; throttleDispatcher.Throttle( () => { Log.Debug( "Downloading URL: {FileName}. {Run}/{Size} - {Speed} ({Progress}%)", downloadPackage.Address, downloadPackage.ReceivedBytesSize.SizeFormat(), downloadPackage.TotalFileSize.SizeFormat(), args.AverageBytesPerSecondSpeed.SizeFormat("/s"), args.ProgressPercentage.ToString("N2") ); } ); }; downloader.DownloadFileCompleted += ( sender, args ) => { var downloadService = sender as DownloadService; if (downloadService == null) { return; } var downloadPackage = downloadService.Package; Log.Information( "Download completed. Url: {Address}. Size: {Size}", downloadPackage.Address, downloadPackage.TotalFileSize.SizeFormat() ); }; await downloader.DownloadFileTaskAsync(url, paths); return(paths); }
private async Task DownloadPatchAsync(PatchDownload download, int index) { var outFile = GetPatchFile(download.Patch); Log.Information("Downloading patch {0} at {1} to {2}", download.Patch.VersionId, download.Patch.Url, outFile.FullName); Actives[index] = download; if (outFile.Exists && CheckPatchValidity(download.Patch, outFile) == HashCheckResult.Pass) { download.State = PatchState.Downloaded; Slots[index] = SlotState.Done; Progresses[index] = download.Patch.Length; return; } var dlService = new DownloadService(_downloadOpt); dlService.DownloadProgressChanged += (sender, args) => { Progresses[index] = args.ReceivedBytesSize; Speeds[index] = args.BytesPerSecondSpeed; }; dlService.DownloadFileCompleted += (sender, args) => { if (args.Error != null) { Log.Error(args.Error, "Download failed for {0} with reason {1}", download.Patch.VersionId, args.Error); // If we cancel downloads, we don't want to see an error message if (args.Error is OperationCanceledException) { return; } CancelAllDownloads(); CustomMessageBox.Show(string.Format(Loc.Localize("PatchManDlFailure", "XIVLauncher could not verify the downloaded game files.\n\nThis usually indicates a problem with your internet connection.\nIf this error occurs again, try using a VPN set to Japan.\n\nContext: {0}\n{1}"), "Problem", download.Patch.VersionId), "XIVLauncher Error", MessageBoxButton.OK, MessageBoxImage.Error); Environment.Exit(0); return; } if (args.Cancelled) { Log.Error("Download cancelled for {0} with reason {1}", download.Patch.VersionId, args.Error); /* * Cancellation should not produce an error message, since it is always triggered by another error or the user. * * CancelAllDownloads(); * CustomMessageBox.Show(string.Format(Loc.Localize("PatchManDlFailure", "XIVLauncher could not verify the downloaded game files.\n\nThis usually indicates a problem with your internet connection.\nIf this error occurs again, try using a VPN set to Japan.\n\nContext: {0}\n{1}"), "Cancelled", download.Patch.VersionId), "XIVLauncher Error", MessageBoxButton.OK, MessageBoxImage.Error); * Environment.Exit(0); */ return; } var checkResult = CheckPatchValidity(download.Patch, outFile); // Indicate "Checking..." Slots[index] = SlotState.Checking; // Let's just bail for now, need better handling of this later if (checkResult != HashCheckResult.Pass) { CancelAllDownloads(); Log.Error("IsHashCheckPass failed for {0} after DL", download.Patch.VersionId); CustomMessageBox.Show(string.Format(Loc.Localize("PatchManDlFailure", "XIVLauncher could not verify the downloaded game files.\n\nThis usually indicates a problem with your internet connection.\nIf this error occurs again, try using a VPN set to Japan.\n\nContext: {0}\n{1}"), $"IsHashCheckPass({checkResult})", download.Patch.VersionId), "XIVLauncher Error", MessageBoxButton.OK, MessageBoxImage.Error); outFile.Delete(); Environment.Exit(0); return; } download.State = PatchState.Downloaded; Slots[index] = SlotState.Done; Progresses[index] = 0; Speeds[index] = 0; Log.Information("Patch at {0} downloaded completely", download.Patch.Url); this.CheckIsDone(); }; DownloadServices[index] = dlService; await dlService.DownloadFileTaskAsync(download.Patch.Url, outFile.FullName); }
public async void DownloadSubtitle() { ISubtitleDownloadPage.Instance.CloseStatus(); if (GeneralHelper.IsNetworkAvailable()) { if (!Helper.Settings.IsIDMEnabled) { DownloadButton.IsEnabled = false; ProgressStatus.IsIndeterminate = true; ProgressStatus.Visibility = Visibility.Visible; ProgressStatus.Value = 0; } try { var web = new HtmlWeb(); var doc = await web.LoadFromWebAsync(Link); if (doc != null) { var downloadLink = Constants.ISubtitleBaseUrl + doc?.DocumentNode ?.SelectSingleNode("//div[@class='col-lg-16 col-md-24 col-sm-16']//a")?.Attributes["href"] ?.Value; if (!string.IsNullOrEmpty(downloadLink)) { // if luanched from ContextMenu set location next to the movie file if (!string.IsNullOrEmpty(App.StartUpArguments.Name)) { location = App.StartUpArguments.Path; } else { // get location from config location = Helper.Settings.DefaultDownloadLocation; // get location from FolderPicker if (Helper.Settings.IsAskLocationEnabled) { var path = await Helper.OpenAndSelectFolder(); if (!string.IsNullOrEmpty(path)) { location = path; } } } if (!Helper.Settings.IsIDMEnabled) { downloadLink = await Helper.GetRedirectedUrl(downloadLink); Debug.WriteLine(downloadLink); var downloader = new DownloadService(); downloader.DownloadProgressChanged += Downloader_DownloadProgressChanged; downloader.DownloadFileCompleted += Downloader_DownloadFileCompleted; await downloader.DownloadFileTaskAsync(downloadLink, new DirectoryInfo(location)); } else { ProgressStatus.Visibility = Visibility.Collapsed; Helper.OpenLinkWithIDM(downloadLink); } } } } catch (NullReferenceException ex) { ISubtitleDownloadPage.Instance.ShowStatus(null, ex.Message, InfoBarSeverity.Error); DownloadButton.IsEnabled = true; } catch (UnauthorizedAccessException ex) { ISubtitleDownloadPage.Instance.ShowStatus(null, ex.Message, InfoBarSeverity.Error); DownloadButton.IsEnabled = true; } catch (NotSupportedException) { } catch (ArgumentException) { } catch (Exception ex) { ISubtitleDownloadPage.Instance.ShowStatus(null, ex.Message, InfoBarSeverity.Error); DownloadButton.IsEnabled = true; } finally { ProgressStatus.Visibility = Visibility.Collapsed; DownloadButton.IsEnabled = true; } } else { ISubtitleDownloadPage.Instance.ShowStatus(Constants.InternetIsNotAvailableTitle, Constants.InternetIsNotAvailable, InfoBarSeverity.Error); } }