public void DownloadIntoFolderTest()
{
string targetFolderPath = Path.Combine(Path.GetTempPath(), "downloader test folder");
DirectoryInfo targetFolder = new DirectoryInfo(targetFolderPath);
DownloadConfiguration config = new DownloadConfiguration {
BufferBlockSize = 1024,
ChunkCount = 1,
ParallelDownload = false,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
DownloadService downloader = new DownloadService(config);
downloader.DownloadFileAsync(DownloadTestHelper.File1KbUrl, targetFolder).Wait();
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize);
downloader.Clear();
downloader.DownloadFileAsync(DownloadTestHelper.File150KbUrl, targetFolder).Wait();
Assert.AreEqual(DownloadTestHelper.FileSize150Kb, downloader.Package.TotalFileSize);
downloader.Clear();
Assert.IsTrue(targetFolder.Exists);
FileInfo[] downloadedFiles = targetFolder.GetFiles();
long totalSize = downloadedFiles.Sum(file => file.Length);
Assert.AreEqual(DownloadTestHelper.FileSize1Kb + DownloadTestHelper.FileSize150Kb, totalSize);
Assert.IsTrue(downloadedFiles.Any(file => file.Name == DownloadTestHelper.File1KbName));
Assert.IsTrue(downloadedFiles.Any(file => file.Name == DownloadTestHelper.File150KbName));
targetFolder.Delete(true);
}
public void StopResumeOnTheFlyDownloadTest()
{
var stopCount = 0;
var downloadCompletedSuccessfully = false;
var expectedFileSize = DownloadTestHelper.FileSize150Kb; // real bytes size
var address = DownloadTestHelper.File150KbUrl;
var file = new FileInfo(Path.GetTempFileName());
var config = new DownloadConfiguration()
{
BufferBlockSize = 1024,
ChunkCount = 8,
ParallelDownload = false,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
var progressCount = config.ChunkCount * (int)Math.Ceiling((double)expectedFileSize / config.ChunkCount / config.BufferBlockSize);
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += delegate { Interlocked.Decrement(ref progressCount); };
downloader.DownloadFileCompleted += (s, e) =>
{
if (e.Cancelled)
{
Interlocked.Increment(ref stopCount);
}
else if (e.Error == null)
{
downloadCompletedSuccessfully = true;
}
};
downloader.CancelAfterDownloading(10); // Stopping after start of downloading.
downloader.DownloadFileAsync(address, file.FullName).Wait(); // wait to download stopped!
Assert.AreEqual(1, stopCount);
downloader.CancelAfterDownloading(10); // Stopping after resume of downloading.
downloader.DownloadFileAsync(downloader.Package).Wait(); // resume download from stooped point.
Assert.AreEqual(2, stopCount);
Assert.IsFalse(downloadCompletedSuccessfully);
downloader.DownloadFileAsync(downloader.Package).Wait(); // resume download from stooped point, again.
Assert.IsTrue(file.Exists);
Assert.AreEqual(expectedFileSize, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedFileSize, file.Length);
Assert.IsTrue(progressCount <= 0);
Assert.AreEqual(2, stopCount);
Assert.IsTrue(downloadCompletedSuccessfully);
file.Delete();
}
public void Download1KbWithFilenameTest()
{
// arrange
var downloadCompletedSuccessfully = false;
var file = new FileInfo(Path.GetTempFileName());
var downloader = new DownloadService(Config);
downloader.DownloadFileCompleted += (s, e) => {
if (e.Cancelled == false && e.Error == null)
{
downloadCompletedSuccessfully = true;
}
};
// act
downloader.DownloadFileAsync(DownloadTestHelper.File1KbUrl, file.FullName).Wait();
// assert
Assert.IsTrue(downloadCompletedSuccessfully);
Assert.IsTrue(file.Exists);
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, file.Length);
Assert.IsTrue(DownloadTestHelper.AreEqual(DownloadTestHelper.File1Kb, file.OpenRead()));
file.Delete();
}
public override void PageDisplayed()
{
// GetApplication.SetNextPage <...> ();
// GetApplication.PushNextPage <...> ();
Task.Run(async() =>
{
var cancellationToken = new CancellationTokenSource();
await downloader.DownloadFileAsync(
"http://download.thinkbroadband.com/1MB.zip",
cancellationToken.Token,
(message) =>
{
Device.BeginInvokeOnMainThread(async() =>
{
await this.DisplayAlert(
"Download Failed",
message,
"Ok");
});
},
() =>
{
Device.BeginInvokeOnMainThread(async() =>
{
await this.DisplayAlert(
"Download Complete",
"Download has completed",
"Ok");
});
});
});
}
public async void StartAsync()
{
try
{
HtmlWeb web = new HtmlWeb();
var htmlDoc = web.Load(url);
string title = this.Title(htmlDoc);
foreach (HtmlNode link in htmlDoc.DocumentNode.SelectNodes("//a[@class='image'][@href]"))
{
string url = link.Attributes["href"].Value;
itemName = link.Attributes["title"].Value;
// download here
string filepath = String.Format(@"{0}\{1}\{2}", dest, title, itemName);
Console.WriteLine(filepath);
await downloader.DownloadFileAsync(url, filepath);
}
}
catch (Exception e)
{
Console.WriteLine("error StartAsync");
Console.WriteLine(e);
MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void DownloadPdf150KTest()
{
var expectedFileSize = DownloadTestHelper.FileSize150Kb; // real bytes size
var address = DownloadTestHelper.File150KbUrl;
var file = new FileInfo(Path.GetTempFileName());
var config = new DownloadConfiguration()
{
BufferBlockSize = 1024,
ChunkCount = 1,
ParallelDownload = false,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
var progressCount = config.ChunkCount * (int)Math.Ceiling((double)expectedFileSize / config.ChunkCount / config.BufferBlockSize);
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += delegate { Interlocked.Decrement(ref progressCount); };
downloader.DownloadFileAsync(address, file.FullName).Wait();
Assert.IsTrue(file.Exists);
Assert.AreEqual(expectedFileSize, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedFileSize, file.Length);
Assert.IsTrue(progressCount <= 0);
file.Delete();
}
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 && IsHashCheckPass(download.Patch, outFile))
{
download.State = PatchState.Downloaded;
Slots[index] = true;
Progresses[index] = download.Patch.Length;
return;
}
var dlService = new DownloadService(_downloadOpt);
dlService.DownloadProgressChanged += (sender, args) =>
{
Progresses[index] = args.BytesReceived;
Speeds[index] = dlService.DownloadSpeed;
};
dlService.DownloadFileCompleted += (sender, args) =>
{
if (args.Error != null)
{
Log.Error(args.Error, "Download failed for {0}", download.Patch.VersionId);
MessageBox.Show($"Download FAILED for {download.Patch.VersionId}.\nPlease try again.\n\n" + args.Error, "XIVLauncher Error", MessageBoxButton.OK, MessageBoxImage.Error);
Environment.Exit(0);
return;
}
if (args.Cancelled)
{
Log.Error("Download cancelled for {0}", download.Patch.VersionId);
MessageBox.Show($"Download CANCELLED for {download.Patch.VersionId}.\nPlease try again.\n\n" + args.Error, "XIVLauncher Error", MessageBoxButton.OK, MessageBoxImage.Error);
Environment.Exit(0);
}
// Let's just bail for now, need better handling of this later
if (!IsHashCheckPass(download.Patch, outFile))
{
Log.Error("HashCHeck failed for {0} after DL", download.Patch.VersionId);
MessageBox.Show($"IsHashCheckPass FAILED for {download.Patch.VersionId}.\nPlease try again.", "XIVLauncher Error", MessageBoxButton.OK, MessageBoxImage.Error);
outFile.Delete();
Environment.Exit(0);
return;
}
download.State = PatchState.Downloaded;
Slots[index] = true;
Log.Verbose("Patch at {0} downloaded completely", download.Patch.Url);
};
await dlService.DownloadFileAsync(download.Patch.Url, outFile.FullName);
}
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.DownloadFileAsync(DownloadTestHelper.File150KbUrl, Path.GetTempFileName()).Wait();
while (expectedStopCount > downloadFileExecutionCounter++)
{
downloader.DownloadFileAsync(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);
}
static async Task Main(string[] args)
{
var chunkCount = 8;
DownloadList = File.Exists(DownloadListFile)
? JsonConvert.DeserializeObject <List <DownloadItem> >(File.ReadAllText(DownloadListFile))
: null;
DownloadList ??= new List <DownloadItem>
{
new DownloadItem {
FileName = Path.Combine(Path.GetTempPath(), "100MB.zip"), Url = "http://ipv4.download.thinkbroadband.com/100MB.zip"
}
};
var options = new ProgressBarOptions
{
ForegroundColor = ConsoleColor.Green,
ForegroundColorDone = ConsoleColor.DarkGreen,
BackgroundColor = ConsoleColor.DarkGray,
BackgroundCharacter = '\u2593'
};
ChildOption = new ProgressBarOptions
{
ForegroundColor = ConsoleColor.Yellow,
BackgroundColor = ConsoleColor.DarkGray,
ProgressCharacter = '─'
};
var downloadOpt = new DownloadConfiguration()
{
ParallelDownload = true, // download parts of file as parallel or not
BufferBlockSize = 10240, // usually, hosts support max to 8000 bytes
ChunkCount = chunkCount, // 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
};
var ds = new DownloadService(downloadOpt);
ds.ChunkDownloadProgressChanged += OnChunkDownloadProgressChanged;
ds.DownloadProgressChanged += OnDownloadProgressChanged;
ds.DownloadFileCompleted += OnDownloadFileCompleted;
foreach (var downloadItem in DownloadList)
{
Console.Clear();
ConsoleProgress = new ProgressBar(10000, $"Downloading {Path.GetFileName(downloadItem.FileName)} file", options);
ChildConsoleProgresses = new ConcurrentDictionary <string, ChildProgressBar>();
await ds.DownloadFileAsync(downloadItem.Url, downloadItem.FileName).ConfigureAwait(false);
ds.Clear();
}
}
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.DownloadFileAsync(downloadItem.Url, new DirectoryInfo(downloadItem.FolderPath))
.ConfigureAwait(false);
}
else
{
await _currentDownloadService.DownloadFileAsync(downloadItem.Url, downloadItem.FileName).ConfigureAwait(false);
}
return(_currentDownloadService);
}
public void DownloadOnMemoryStreamTypeTest()
{
// arrange
var downloader = new DownloadService(Config);
// act
using var stream = downloader.DownloadFileAsync(DownloadTestHelper.File1KbUrl).Result;
// assert
Assert.IsTrue(stream is MemoryStream);
}
private async void btnDownload_Click(object sender, RoutedEventArgs e)
{
btnDownload.Content = "Downloading...";
btnDownload.IsEnabled = false;
DownloadService downloadService = new DownloadService();
downloadService.DownloadProgressChanged += DownloadService_DownloadProgressChanged;
downloadService.DownloadFileCompleted += DownloadService_DownloadFileCompleted;
await downloadService.DownloadFileAsync(App.Argument.Url, tempRarFile);
}
public void DownloadOnMemoryStreamContentTest()
{
// arrange
var downloader = new DownloadService(Config);
// act
using var stream = (MemoryStream)downloader.DownloadFileAsync(DownloadTestHelper.File1KbUrl).Result;
// assert
Assert.IsTrue(DownloadTestHelper.File1Kb.SequenceEqual(stream.ToArray()));
}
public void DownloadOnMemoryStreamSizeTest()
{
// arrange
var downloader = new DownloadService(Config);
// act
using var stream = downloader.DownloadFileAsync(DownloadTestHelper.File1KbUrl).Result;
// assert
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, stream.Length);
}
private static async Task DownloadItem(KeyValuePair<string, string> item, Uri uri)
{
try
{
Logger.Log($"Starting download for {uri}").FireAndForget();
bool isSmall = false;
using (var client = new HttpClient())
{
HttpRequestMessage m = new HttpRequestMessage(HttpMethod.Head, uri);
HttpResponseMessage resp = await client.SendAsync(m);
if (resp.Content.Headers.ContentLength < 100) { isSmall = true; }
if (resp.Content.Headers.ContentType != null && (resp.Content.Headers.ContentType.ToString() == "text/plain" || resp.Content.Headers.ContentType.ToString() == "text/json"))
{
isSmall = true;
}
m.Dispose();
}
Directory.CreateDirectory(Path.GetDirectoryName(NormalizePath(item.Key)));
try
{
if (isSmall)
{
DownloadService ds = new DownloadService(downloadOptSmall);
await RetryPolicy.ExecuteAsync(async () => { await ds.DownloadFileAsync(uri.ToString(), item.Key); });
}
else
{
await RetryPolicy.ExecuteAsync(async () => { await new DownloadService(downloadOpt).DownloadFileAsync(uri.ToString(), item.Key); });
}
}
catch (System.IO.InvalidDataException)
{
await RetryPolicy.ExecuteAsync(async () => { await DownloadManually(uri, item.Key); });
}
Logger.Log($"Download for {uri} finished.").FireAndForget();
}
catch (System.Net.WebException e)
{
if (e.Message == "The remote server returned an error: (404) Not Found.")
{
Logger.Log("Could not download " + uri + ": 404 not found.", LogType.ERROR).FireAndForget();
}
else { throw; }
}
}
private async Task DownloadImage(string image, string destination, int imageNum)
{
var downloader = new DownloadService();
string tempFilePath = Path.GetTempFileName();
string filePath = Path.Combine(destination, GetFilenameFromUrl(image, imageNum));
if (!File.Exists(filePath))
{
await downloader.DownloadFileAsync(image, tempFilePath, _source.Token);
File.Move(tempFilePath, filePath);
}
}
private static async Task <DownloadService> DownloadFile(DownloadItem downloadItem,
DownloadConfiguration downloadOpt)
{
DownloadService ds = new DownloadService(downloadOpt);
ds.ChunkDownloadProgressChanged += OnChunkDownloadProgressChanged;
ds.DownloadProgressChanged += OnDownloadProgressChanged;
ds.DownloadFileCompleted += OnDownloadFileCompleted;
ds.DownloadStarted += OnDownloadStarted;
if (string.IsNullOrWhiteSpace(downloadItem.FileName))
{
await ds.DownloadFileAsync(downloadItem.Url, new DirectoryInfo(downloadItem.FolderPath))
.ConfigureAwait(false);
}
else
{
await ds.DownloadFileAsync(downloadItem.Url, downloadItem.FileName).ConfigureAwait(false);
}
return(ds);
}
public void SpeedLimitTest()
{
var speedPerSecondsHistory = new ConcurrentBag <long>();
var lastTick = 0L;
var expectedFileSize = DownloadTestHelper.FileSize10Mb; // real bytes size
var address = DownloadTestHelper.File10MbUrl;
var file = new FileInfo(Path.GetTempFileName());
var config = new DownloadConfiguration()
{
BufferBlockSize = 1024,
ChunkCount = 8,
ParallelDownload = true,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true,
MaximumBytesPerSecond = 1024 * 1024 // 1MB/s
};
var progressCount = config.ChunkCount * (int)Math.Ceiling((double)expectedFileSize / config.ChunkCount / config.BufferBlockSize);
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += (s, e) =>
{
Interlocked.Decrement(ref progressCount);
if (Environment.TickCount64 - lastTick >= 1000)
{
speedPerSecondsHistory.Add(e.BytesPerSecondSpeed);
lastTick = Environment.TickCount64;
}
};
downloader.DownloadFileAsync(address, file.FullName).Wait(); // wait to download stopped!
var avgSpeed = (long)speedPerSecondsHistory.Average();
Assert.IsTrue(file.Exists);
Assert.AreEqual(expectedFileSize, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedFileSize, file.Length);
Assert.IsTrue(progressCount <= 0);
Assert.IsTrue(avgSpeed <= config.MaximumBytesPerSecond);
if (File.Exists(file.FullName))
{
try
{
file.Delete();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
private void LoadFileFromUrl()
{
StartCoroutine(DownloadService.DownloadFileAsync(_url,
progress =>
{
_progressBar.value = progress;
}, (path) =>
{
// Import and convert our model
var data = RuntimeConverter.ConvertToPointCloudData(path);
_renderer.sourceData = data;
_progressBar.gameObject.SetActive(false);
}));
}
private static async Task <DownloadService> Download(DownloadItem downloadItem, DownloadConfiguration downloadOpt)
{
var ds = new DownloadService(downloadOpt);
ds.ChunkDownloadProgressChanged += OnChunkDownloadProgressChanged;
ds.DownloadProgressChanged += OnDownloadProgressChanged;
ds.DownloadFileCompleted += OnDownloadFileCompleted;
Console.Clear();
ConsoleProgress = new ProgressBar(10000, $"Downloading {Path.GetFileName(downloadItem.FileName)} file", ProcessBarOption);
ChildConsoleProgresses = new ConcurrentDictionary <string, ChildProgressBar>();
await ds.DownloadFileAsync(downloadItem.Url, downloadItem.FileName).ConfigureAwait(false);
return(ds);
}
public void DownloadJson1KTest()
{
var downloadCompletedSuccessfully = false;
var expectedFileSize = DownloadTestHelper.FileSize1Kb; // real bytes size
var address = DownloadTestHelper.File1KbUrl;
var file = new FileInfo(Path.GetTempFileName());
var config = new DownloadConfiguration()
{
AllowedHeadRequest = false,
BufferBlockSize = 1024,
ChunkCount = 16,
ParallelDownload = false,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
var progressCount = config.ChunkCount * (int)Math.Ceiling((double)expectedFileSize / config.ChunkCount / config.BufferBlockSize);
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += delegate
{
Interlocked.Decrement(ref progressCount);
};
downloader.DownloadFileCompleted += (s, e) =>
{
if (e.Cancelled == false && e.Error == null)
{
downloadCompletedSuccessfully = true;
}
};
downloader.DownloadFileAsync(address, file.FullName).Wait();
Assert.IsTrue(file.Exists);
Assert.AreEqual(expectedFileSize, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedFileSize, file.Length);
Assert.AreEqual(0, progressCount);
using (var reader = file.OpenText())
{
var json = reader.ReadToEnd();
var obj = JsonConvert.DeserializeObject(json);
Assert.IsNotNull(obj);
}
Assert.IsTrue(downloadCompletedSuccessfully);
file.Delete();
}
public void Download16KbWithoutFilenameTest()
{
// arrange
var downloader = new DownloadService(Config);
// act
downloader.DownloadFileAsync(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);
}
/// <summary>
/// Кнопка Скачать
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void ButtonStart_Click(object sender, EventArgs e)
{
//проверяем и получаем введенные адрес и путь
if (!TryGetDownloadPathes(out (Uri uri, string path)downloadPathes))
{
return;
}
//создаем экз.сервиса скачивания
var service = new DownloadService(downloadPathes.uri, downloadPathes.path);
//выключаем кнопки
SetFormState(FormState.Downloading);
//готовим токен отмены и отображение процесса скачивания
_tokenSource = new CancellationTokenSource();
var token = _tokenSource.Token;
//размер скачиваемого файла
var sizeFile = 0L;
//колбек отображения процесса скачки
var progress = new Progress <int>(readed =>
{
_progressBar.Value = readed;
_labelReport.Text = $"{_progressBar.Value}%";
});
try
{
//размер
sizeFile = await service.GetFileSize(token);
_labelSize.Text = sizeFile.ToString() + " байт";
//файл
await service.DownloadFileAsync(token, progress);
}
catch (Exception ex)
{
var message = $"Oшибка: \n'{ex.Message}'";
var caption = "Ошибка загрузки файла";
MessageBox.Show(message, caption, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
finally
{
_tokenSource.Dispose();
SetFormState(FormState.Initial);
}
}
private async void FileDownloadButton_Clicked(object sender, EventArgs e)
{
string fileUrl = $"https://dummyimage.com/2560x1600/08f24a/e61c6d.jpg&text=File+Number+{fileCounter}";
ourLogger.LogInformation($"File Download Clicked For Downloading file {fileUrl}");
var fileDownloadService = new DownloadService(DependencyService.Get <IFileService>());
await Task.Factory.StartNew(async() =>
{
string filePath = await fileDownloadService.DownloadFileAsync(fileUrl, $"FileNumber{fileCounter}.jpg");
if (filePath != null)
{
ourLogger.LogInformation($"Downloaded file location: {filePath}");
DownloadImageFile.Source = ImageSource.FromFile(filePath);
}
});
fileCounter++;
}
private async void PostPinCode()
{
HttpClient client = new HttpClient();
Uri uri = new Uri("https://api.socialscore.be/api/v1/tv/Pincode/" + pin_code);
try
{
StringContent content = new StringContent("", Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(uri, content);
var result = await response.Content.ReadAsStringAsync();
App.appInfo = JsonConvert.DeserializeObject <ResultInfo>(result);
IFileService fileService = DependencyService.Get <IFileService>();
DownloadService downloadService = new DownloadService(fileService);
await downloadService.DownloadFileAsync(App.appInfo.projectInfo.url);
if (App.appInfo.isSuccess)
{
await Navigation.PopAsync();
App.mngPreferences.SaveAllInfo(App.appInfo);
Page page = new MainPage();
await Navigation.PushAsync(page);
}
else
{
await DisplayAlert(null, "Your PIN code is not valid. Please rewrite your PIN code.", "OK");
entry_pin_code.Focus();
entry_pin_code.CursorPosition = 5;
}
}
catch (Exception er)
{
var lb = er.ToString();
await DisplayAlert(null, "The server is not responding. Just a second and retry.", "OK");
entry_pin_code.Focus();
entry_pin_code.CursorPosition = 5;
}
}
private async void GetUrlsAndDownload(HtmlAgilityPack.HtmlDocument htmlDoc)
{
string title = this.GetTitle(htmlDoc);
// check for illegal chars
title = CheckIllegalChars(title);
// scuffed af; having form controls in business logic
listBox.Items.Insert(0, "Album: " + title);
foreach (HtmlNode link in htmlDoc.DocumentNode.SelectNodes("//a[@class='image'][@href]"))
{
string url = link.Attributes["href"].Value;
itemName = link.Attributes["title"].Value;
// scuffed af; having form controls in business logic
listBox.Items.Insert(0, "Downloading item: " + itemName);
// download here
string filepath = String.Format(@"{0}\{1}\{2}", dest, title, itemName);
await downloader.DownloadFileAsync(url, filepath);
}
}
public void DownloadProgressChangedTest()
{
// arrange
var downloader = new DownloadService(Config);
var filename = Path.GetTempFileName();
var progressChangedCount = (int)Math.Ceiling((double)DownloadTestHelper.FileSize16Kb / Config.BufferBlockSize);
var progressCounter = 0;
downloader.DownloadProgressChanged += (s, e) => Interlocked.Increment(ref progressCounter);
// act
downloader.DownloadFileAsync(DownloadTestHelper.File16KbUrl, filename).Wait();
// assert
// Note: some times received bytes on read stream method was less than block size!
Assert.IsTrue(progressChangedCount <= progressCounter);
File.Delete(filename);
}
protected async void CheckUpdate()
{
string guid = mngPreferences.GetPrefereceStringValue("key_Guid");
string lastUpdate = mngPreferences.GetPrefereceStringValue("key_LastUpdate");
HttpClient client = new HttpClient();
Uri uri = new Uri("https://api.socialscore.be/api/v1/tv/projectinfo/" + guid);
try
{
HttpResponseMessage response = await client.GetAsync(uri);
var result = await response.Content.ReadAsStringAsync();
ProjectInfo projectInfo = JsonConvert.DeserializeObject <ProjectInfo>(result);
if (projectInfo.lastUpdate != lastUpdate)
{
mngPreferences.SaveProjectInfo(projectInfo);
IFileService fileService = DependencyService.Get <IFileService>();
DownloadService downloadService = new DownloadService(fileService);
await downloadService.DownloadFileAsync(App.appInfo.projectInfo.url);
Type CurPageType = MainPage.GetType();
if (ImInPinView == false)
{
MainPage = new NavigationPage(new Views.MainPage());
}
}
}
catch (Exception er)
{
var lb = er.ToString();
}
}
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.DownloadFileAsync(DownloadTestHelper.File1KbUrl, Path.GetTempFileName()).Wait();
// assert
Assert.IsTrue(File.Exists(downloader.Package.FileName));
Assert.AreEqual(DownloadTestHelper.FileSize1Kb, downloader.Package.TotalFileSize);
Assert.IsTrue(averageSpeed <= Config.MaximumBytesPerSecond, $"Average Speed: {averageSpeed} , Speed Limit: {Config.MaximumBytesPerSecond}");
File.Delete(downloader.Package.FileName);
}
public void DownloadJson1KTest()
{
var expectedFileSize = 20471; // real bytes size
var address = "https://file-examples.com/wp-content/uploads/2017/02/file_example_JSON_1kb.json";
var file = new FileInfo(Path.GetTempFileName());
var config = new DownloadConfiguration()
{
BufferBlockSize = 1024,
ChunkCount = 16,
ParallelDownload = false,
MaxTryAgainOnFailover = 100,
OnTheFlyDownload = true
};
var progressCount = config.ChunkCount * (int)Math.Ceiling((double)expectedFileSize / config.ChunkCount / config.BufferBlockSize);
var downloader = new DownloadService(config);
downloader.DownloadProgressChanged += delegate
{
Interlocked.Decrement(ref progressCount);
};
downloader.DownloadFileAsync(address, file.FullName).Wait();
Assert.IsTrue(file.Exists);
Assert.AreEqual(expectedFileSize, downloader.Package.TotalFileSize);
Assert.AreEqual(expectedFileSize, file.Length);
Assert.AreEqual(0, progressCount);
using (var reader = file.OpenText())
{
var json = reader.ReadToEnd();
var obj = JsonConvert.DeserializeObject(json);
Assert.IsNotNull(obj);
}
file.Delete();
}
