public void RefreshDownloads()
{
var downloads = DownloadManager.GetDownloads();
foreach (var download in downloads)
{
var existingDownload = Downloads.FirstOrDefault(d => d.Id == download.Id);
if (existingDownload != null)
{
existingDownload.UpdateValues(download);
}
else
{
Downloads.Add(new DownloadViewModel(download));
}
}
var nonExistantDownloads = new List <DownloadViewModel>();
foreach (var nonExistantDownload in Downloads.Where(d => !downloads.Any(existinDownload => existinDownload.Id == d.Id)))
{
nonExistantDownloads.Add(nonExistantDownload);
}
foreach (var toRemove in nonExistantDownloads)
{
Downloads.Remove(toRemove);
}
}
private void ModInitialized(object?sender, EventArgs e)
{
if (sender is ModDownload initializedItem)
{
Log.Information($@"Mod has initialized: {initializedItem.ModFile.Name}");
var nextDownload = Downloads.FirstOrDefault(x => !x.Downloaded);
nextDownload?.StartDownload(cancellationTokenSource.Token);
}
}
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 TakeSequanceItem()
{
lock (Downloads)
{
var currentDownload = Downloads.FirstOrDefault(x => x.State == DownloadState.InQueue);
if (currentDownload != null)
{
currentDownload.Start();
currentDownload.DownloadFileCompleted += SequanceDownloadCompleted;
}
IsInProgressChanged?.Invoke();
}
}
private async void OnDownloadProgressChanged(object sender, TransferItem e)
{
await _dispatcherWrapper.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
if (DownloadsState == ContentState.Loading)
{
return;
}
DownloadsState = ContentState.Normal;
var item = Downloads.FirstOrDefault(d => d.OperationGuid == e.OperationGuid);
if (item == null)
{
if (e.Status != BackgroundTransferStatus.Completed &&
e.Status != BackgroundTransferStatus.Canceled)
{
return;
}
Downloads.Add(new TransferItemViewModel(e, _locService));
item = Downloads.FirstOrDefault(d => d.OperationGuid == e.OperationGuid);
if (item == null)
{
return;
}
}
else
{
item.Operation = e;
}
if (item.Status == BackgroundTransferStatus.Completed ||
item.Status == BackgroundTransferStatus.Canceled)
{
Downloads.Remove(item);
}
if (Downloads.Count == 0)
{
DownloadsState = ContentState.NoData;
}
else
{
Downloads.OrderBy(d => d.Status, new TransferStatusComparer());
}
CancelAllDownloadsCommand.RaiseCanExecuteChanged();
});
}
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);
}
}
public void RefreshDownloadItems()
{
if (!m_Releases.Any())
{
RefreshAfterSynchronize(null);
}
var selectedReleaseId = SelectedDownload?.ReleaseId;
DownloadItemsMode type = DownloadItemsMode.All;
switch (m_SelectedSection.Type)
{
case DownloadSectionType.All:
type = DownloadItemsMode.All;
break;
case DownloadSectionType.Downloading:
type = DownloadItemsMode.Downloading;
break;
case DownloadSectionType.Downloaded:
type = DownloadItemsMode.Downloaded;
break;
case DownloadSectionType.NotDownloaded:
type = DownloadItemsMode.NotDownloaded;
break;
default: throw new NotSupportedException($"Type {type} not supported");
}
var downloads = m_DownloadService.GetDownloads(type)
.Select(MapToModel)
.ToList();
Downloads = FilterDownloads(downloads);
NoFilteredDownloads = !Downloads.Any();
if (selectedReleaseId.HasValue)
{
SelectedDownload = Downloads.FirstOrDefault(a => a.ReleaseId == selectedReleaseId.Value);
}
}
private void AddDownload(DownloadViewModel download)
{
// Find an existing download for this file path
var existingDownload = Downloads.FirstOrDefault(d => d.FilePath == download.FilePath);
// If it exists - cancel and remove it
if (existingDownload != null)
{
if (existingDownload.CanCancel)
{
existingDownload.Cancel();
}
Downloads.Remove(existingDownload);
}
// Add to the beginning
Downloads.Insert(0, download);
}
private async Task Start()
{
var currentlyRunning = Downloads.Count(dt => dt.Task.Status == TaskStatus.Running);
if (currentlyRunning >= ConcurrentConnections)
{
return;
}
var startNew = Downloads.FirstOrDefault(dt => dt.Image.State == Image.DownloadState.Enqueued);
if (startNew == null)
{
return;
}
startNew.Image.State = Image.DownloadState.Downloading;
startNew.Task.Start();
int i = 0;
i++;
}
private void UpdateQueueState()
{
lock (Downloads)
{
switch (Type)
{
case QueueType.Parallel:
var downloadsForStartup = Downloads.Where(x => x.State == DownloadState.InQueue);
foreach (var download in downloadsForStartup)
{
download.Start();
}
break;
case QueueType.Sequence:
var firstDownload = Downloads.FirstOrDefault(x => x.State == DownloadState.InProgress);
var downloadsInRun = Downloads
.Where(x => x.State == DownloadState.InProgress)
.ToList();
foreach (var download in downloadsInRun)
{
if (download != firstDownload)
{
download.Suspend();
}
}
if (firstDownload == null)
{
TakeSequanceItem();
}
break;
}
}
}
