static void CreateBackgroundDownloadGroup()
{
if (s_BackgroundDownloadGroup == null)
{
s_BackgroundDownloadGroup = BackgroundTransferGroup.CreateGroup("UnityBackgroundDownloads");
}
}
private async Task <BackgroundDownloader> ResetDownloader()
{
await BackgroundExecutionManager.RequestAccessAsync();
const string BackgroundTransferCompletetionTaskNameBase = "HohoemaBGDLCompletion";
var _BTCG = new BackgroundTransferCompletionGroup();
var groupName = BackgroundTransferCompletetionTaskNameBase + Path.GetFileNameWithoutExtension(Path.GetRandomFileName());
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = groupName;
builder.SetTrigger(_BTCG.Trigger);
var status = BackgroundExecutionManager.GetAccessStatus();
BackgroundTaskRegistration downloadProcessingTask = builder.Register();
var _BackgroundDownloader = new BackgroundDownloader(_BTCG)
{
TransferGroup = BackgroundTransferGroup.CreateGroup(groupName)
};
_BackgroundTransferCompletionInfoMap.Add(groupName, new BackgroundTransferCompletionInfo()
{
Id = groupName,
Downloader = _BackgroundDownloader,
TaskRegistration = downloadProcessingTask,
TransferCompletionGroup = _BTCG
});
return(_BackgroundDownloader);
}
public Scenario7_DownloadReordering()
{
reorderGroup = BackgroundTransferGroup.CreateGroup("{7421B969-18D4-4532-B6BD-22BDABF71C08}");
reorderGroup.TransferBehavior = BackgroundTransferBehavior.Serialized;
this.DataContext = this;
this.InitializeComponent();
}
private BackgroundDownloader CreateBackgroundDownloader()
{
// Use a unique group name so that no other component in the app uses the same group. The recommended way
// is to generate a GUID and use it as group name as shown below.
var notificationsGroup = BackgroundTransferGroup.CreateGroup("{E37CDDEC-CFB4-4748-8314-576F1D328A60}");
// When creating a group, we can optionally define the transfer behavior of transfers associated with the
// group. A "parallel" transfer behavior allows multiple transfers in the same group to run concurrently
// (default). A "serialized" transfer behavior allows at most one default priority transfer at a time for
// the group.
notificationsGroup.TransferBehavior = BackgroundTransferBehavior.Parallel;
BackgroundTransferCompletionGroup completionGroup = new BackgroundTransferCompletionGroup();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder
{
TaskEntryPoint = "Aurora.Music.Services.DownloadCompletor"
};
builder.SetTrigger(completionGroup.Trigger);
BackgroundTaskRegistration taskRegistration = builder.Register();
return(new BackgroundDownloader(completionGroup)
{
TransferGroup = notificationsGroup
});
}
private void InitializeDownloader()
{
const int initialCapecity = 10;
_transferGroup = BackgroundTransferGroup.CreateGroup("2336B35A-4F7A-49F9-BB7A-45EBBC45B769");
_transferGroup.TransferBehavior = BackgroundTransferBehavior.Parallel;
_backgroundDownloader = new BackgroundDownloader();
_backgroundDownloader.TransferGroup = _transferGroup;
_cancellationTokenSources = new Dictionary <Guid, CancellationTokenSource>(initialCapecity);
}
public DownloadsService2(IMusicCacheService musicCacheService)
{
_musicCacheService = musicCacheService;
_transferGroup = BackgroundTransferGroup.CreateGroup(DOWNLOAD_TRASNFER_GROUP_NAME);
_transferGroup.TransferBehavior = BackgroundTransferBehavior.Serialized;
_downloader = new BackgroundDownloader();
_downloader.TransferGroup = _transferGroup;
_downloads = new List <DownloadOperation>(INIT_DOWNLOADS_LIST_CAPACITY);
_cts = new Dictionary <Guid, CancellationTokenSource>(INIT_DOWNLOADS_LIST_CAPACITY);
}
public static async Task <bool> AddDownload(string filename, string url, DownloadType type, StorageFolder folder = null)
{
try
{
var down = new BackgroundDownloader();
down.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
if (folder == null)
{
folder = await KnownFolders.MusicLibrary.GetFolderAsync("kgdownload");
switch (type)
{
case DownloadType.song:
folder = await folder.GetFolderAsync("song");
down.TransferGroup = BackgroundTransferGroup.CreateGroup("song");
break;
case DownloadType.mv:
folder = await folder.GetFolderAsync("mv");
down.TransferGroup = BackgroundTransferGroup.CreateGroup("mv");
break;
case DownloadType.other:
folder = await folder.GetFolderAsync("other");
down.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
break;
default:
break;
}
}
var files = (await folder.GetFilesAsync()).ToList();
foreach (var item in files)
{
await item.DeleteAsync();
}
var file = await folder.CreateFileAsync(filename);
down.FailureToastNotification = DownloadToast(filename, DownloadResult.Failure);
down.SuccessToastNotification = DownloadToast(filename, DownloadResult.Success);
var opera = down.CreateDownload(new Uri(url), file);
opera.CostPolicy = BackgroundTransferCostPolicy.Always;
opera.StartAsync();
return(true);
}
catch (Exception)
{
return(false);
}
}
public S3_Notifications()
{
// Use a unique group name so that no other component in the app uses the same group. The recommended way
// is to generate a GUID and use it as group name as shown below.
notificationsGroup = BackgroundTransferGroup.CreateGroup("{296628BF-5AE6-48CE-AA36-86A85A726B6A}");
// When creating a group, we can optionally define the transfer behavior of transfers associated with the
// group. A "parallel" transfer behavior allows multiple transfers in the same group to run concurrently
// (default). A "serialized" transfer behavior allows at most one default priority transfer at a time for
// the group.
notificationsGroup.TransferBehavior = BackgroundTransferBehavior.Parallel;
this.InitializeComponent();
}
public S3_Notifications()
{
// Use a unique group name so that no other component in the app uses the same group. The recommended way
// is to generate a GUID and use it as group name as shown below.
notificationsGroup = BackgroundTransferGroup.CreateGroup("{296628BF-5AE6-48CE-AA36-86A85A726B6A}");
// When creating a group, we can optionally define the transfer behavior of transfers associated with the
// group. A "parallel" transfer behavior allows multiple transfers in the same group to run concurrently
// (default). A "serialized" transfer behavior allows at most one default priority transfer at a time for
// the group.
notificationsGroup.TransferBehavior = BackgroundTransferBehavior.Parallel;
this.InitializeComponent();
}
private void Construct()
{
if (string.IsNullOrEmpty(downloaderID))
{
downloaderID = Windows.ApplicationModel.Package.Current.Id.FullName + "_downloads";
}
_group = BackgroundTransferGroup.CreateGroup(downloaderID.Substring(0, 40));
_group.TransferBehavior = BackgroundTransferBehavior.Serialized;
_downloader = new BackgroundDownloader();
_downloader.TransferGroup = _group;
InitializeOperations().Wait();
}
public UploadsService(
ILogService logService,
IUploadsPostprocessor uploadsPostprocessor,
ILocService locService)
{
_logService = logService;
_uploadsPostprocessor = uploadsPostprocessor;
_locService = locService;
_transferGroup = BackgroundTransferGroup.CreateGroup(UPLOAD_TRASNFER_GROUP_NAME);
_transferGroup.TransferBehavior = BackgroundTransferBehavior.Serialized;
_uploads = new Dictionary <UploadOperation, ICompletedUpload>(INIT_DOWNLOADS_LIST_CAPACITY);
_cts = new Dictionary <Guid, CancellationTokenSource>(INIT_DOWNLOADS_LIST_CAPACITY);
}
private static async Task StartDownload(Uri target, BackgroundTransferPriority priority, string localFilename)
{
var result = await BackgroundExecutionManager.RequestAccessAsync();
StorageFile destinationFile;
destinationFile = await GetLocalFileFromName(localFilename);
var group = BackgroundTransferGroup.CreateGroup(Guid.NewGuid().ToString());
group.TransferBehavior = BackgroundTransferBehavior.Serialized;
BackgroundTransferCompletionGroup completionGroup = new BackgroundTransferCompletionGroup();
// this will cause the app to be activated when the download completes and
// CheckCompletionResult will be called for the final download state
RegisterBackgroundTask(completionGroup.Trigger);
BackgroundDownloader downloader = new BackgroundDownloader(completionGroup);
downloader.TransferGroup = group;
group.TransferBehavior = BackgroundTransferBehavior.Serialized;
CreateNotifications(downloader);
DownloadOperation download = downloader.CreateDownload(target, destinationFile);
download.Priority = priority;
completionGroup.Enable();
Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress);
var downloadTask = download.StartAsync().AsTask(progressCallback);
string tag = GetFileNameFromUri(target);
CreateToast(tag, localFilename);
try
{
await downloadTask;
// Will occur after download completes
ResponseInformation response = download.GetResponseInformation();
}
catch (Exception)
{
Debug.WriteLine("Download exception");
}
}
public static async Task StartGalleryDownloadAsync(ExGallery gallery, StorageFolder galleryFolder)
{
// Download image list
await gallery.LoadAllItemsAsync();
BackgroundTransferCompletionGroup completionGroup = new BackgroundTransferCompletionGroup();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder()
{
Name = "DownloadFinished"
};
builder.SetTrigger(completionGroup.Trigger);
BackgroundTaskRegistration taskRegistration = builder.Register();
BackgroundDownloader downloader = new BackgroundDownloader(completionGroup)
{
TransferGroup = BackgroundTransferGroup.CreateGroup("Gallery")
};
downloader.TransferGroup.TransferBehavior = BackgroundTransferBehavior.Parallel;
// Create tasks and file for each pic
StorageFile[] files = new StorageFile[gallery.Count];
foreach (var image in gallery)
{
files[gallery.IndexOf(image)] = await galleryFolder.CreateFileAsync($"{gallery.IndexOf(image) + 1}.jpg", CreationCollisionOption.ReplaceExisting);
}
// Get the image uri and download data for each pic
List <Task> getImageUriTasks = new List <Task>();
foreach (var image in gallery)
{
if (files[gallery.IndexOf(image)] != null)
{
getImageUriTasks.Add(StartImageDownloadAsync(gallery, image, files[gallery.IndexOf(image)], downloader));
}
}
await Task.WhenAll(getImageUriTasks);
downloader.CompletionGroup.Enable();
}
public MediaCache(StorageFolder cache_directory, String token)
{
this.cache_directory = cache_directory;
this.token = token;
group = BackgroundTransferGroup.CreateGroup(token);
client = new BackgroundDownloader();
client.TransferGroup = group;
pending_downloads = new Dictionary <Uri, Task <StorageFile> >();
finished_downloads = new Dictionary <Uri, StorageFile>();
pending_metadata = new Dictionary <string, Task <string> >();
finished_metadata = new Dictionary <string, string>();
IReadOnlyList <DownloadOperation> downloads = Task.Run(async() => {
try
{
return(await BackgroundDownloader.GetCurrentDownloadsForTransferGroupAsync(group));
}
catch (Exception)
{
return(new List <DownloadOperation>());
}
}).Result;
foreach (var op in downloads)
{
try
{
var pending = fetchObjectToCache(op.RequestedUri, op);
if (!pending.IsCompleted)
{
pending_downloads.Add(op.RequestedUri, pending);
}
}
catch (Exception e)
{
Debug.WriteLine("Could not resume download to cache: " + e.ToString());
}
}
}
public async Task DownloadMusicAsync()
{
var file = await KnownFolders.MusicLibrary.CreateFileAsync("aaa.mp3", CreationCollisionOption.ReplaceExisting);
var downloader = new BackgroundDownloader {
TransferGroup = BackgroundTransferGroup.CreateGroup(DoubanMusicGroup),
};
var succeed_trans = Uri.TryCreate("http://m2.music.126.net/KP1OE1TKzCOFfoUSt0o_ig==/1192970116145619.mp3", UriKind.Absolute, out var do_url);
if (!succeed_trans)
{
return;
}
var operation = downloader.CreateDownload(do_url, file);
operation.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly;
var control = await operation.StartAsync();
}
public DownloadsService(
IMusicCacheService musicCacheService,
ISettingsService settingsService,
ILogService logService,
ILocService locService)
{
_musicCacheService = musicCacheService;
_settingsService = settingsService;
_logService = logService;
_locService = locService;
_transferGroup = BackgroundTransferGroup.CreateGroup(DOWNLOADS_TRANSFER_GROUP_NAME);
_transferGroup.TransferBehavior = BackgroundTransferBehavior.Serialized;
_musicDownloads = new Dictionary <string, VKSaverAudio>();
#if WINDOWS_UWP
_downloads = new List <DownloadOperation>();
_cts = new Dictionary <Guid, CancellationTokenSource>();
#else
_downloads = new List <DownloadOperation>(MAX_DOWNLOADS_LIST_CAPACITY);
_cts = new Dictionary <Guid, CancellationTokenSource>(MAX_DOWNLOADS_LIST_CAPACITY);
#endif
}
List <BackgroundTransferContentPart> PrepareRequest(BackgroundUploader uploader, string tag, IDictionary <string, string> headers = null, IDictionary <string, string> parameters = null)
{
List <BackgroundTransferContentPart> parts = new List <BackgroundTransferContentPart>();
if (headers != null)
{
foreach (string key in headers.Keys)
{
if (!string.IsNullOrEmpty(headers[key]))
{
uploader.SetRequestHeader(key, headers[key]);
}
}
}
if (parameters != null)
{
foreach (string key in parameters.Keys)
{
if (parameters[key] != null)
{
BackgroundTransferContentPart part = new BackgroundTransferContentPart(key);
part.SetText(parameters[key]);
parts.Add(part);
}
}
}
if (tag.Length > 40)
{
tag = tag.Substring(0, 40);
}
uploader.TransferGroup = BackgroundTransferGroup.CreateGroup(tag);
return(parts);
}
// Just for debug
private async void CommentButton_Click(object sender, RoutedEventArgs e)
{
var d = await BackgroundDownloader.GetCurrentDownloadsForTransferGroupAsync(BackgroundTransferGroup.CreateGroup("Gallery"));
var downloawwqwds = d.ToList();
}
/// <summary>
/// 要下载调用这个方法
/// </summary>
/// <param name="url">下载的文件网址的来源</param>
/// <returns></returns>
public static async Task Start(string filename, string url, DownloadType type, StorageFolder folder = null)
{
try
{
Uri uri = new Uri(Uri.EscapeUriString(url), UriKind.RelativeOrAbsolute);
BackgroundDownloader downloader = new BackgroundDownloader();
string extname = "";
if (folder == null)
{
folder = await KnownFolders.MusicLibrary.CreateFolderAsync("kgdownload", CreationCollisionOption.OpenIfExists);
switch (type)
{
case DownloadType.song:
switch (KuGouUWP.Class.Setting.DownQu.GetType())
{
case KuGouUWP.Class.Setting.DownQu.Type.low:
extname = ".mp3";
break;
case KuGouUWP.Class.Setting.DownQu.Type.mid:
extname = ".mp3";
break;
case KuGouUWP.Class.Setting.DownQu.Type.high:
extname = ".flac";
break;
default:
break;
}
folder = await folder.CreateFolderAsync("song", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("song");
break;
case DownloadType.mv:
extname = ".mp4";
folder = await folder.CreateFolderAsync("mv", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("mv");
break;
case DownloadType.other:
folder = await folder.CreateFolderAsync("other", CreationCollisionOption.OpenIfExists);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
break;
default:
break;
}
}
else
{
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup("other");
}
//string name = uri.ToString().Substring(uri.ToString().LastIndexOf("/"), uri.ToString().Length);
string name = filename + extname;;
StorageFile file = await folder.CreateFileAsync(name, CreationCollisionOption.ReplaceExisting);
downloader.FailureToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Fa);
downloader.SuccessToastNotification = DownloadedToast.Done(filename, DownloadedToast.DownResult.Su);
var download = downloader.CreateDownload(new Uri(url), file);
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>(DownloadProgress);
download.StartAsync().AsTask(cancelToken.Token, progressCallback);
if (type != DownloadType.song)
{
await new MessageDialog(ResourceLoader.GetForCurrentView().GetString("AddDownSuccess")).ShowAsync();
}
}
catch
{
await new MessageDialog(ResourceLoader.GetForCurrentView().GetString("AddDownFalied")).ShowAsync();
}
}
public async Task <DownloadResult> DownloadMusicAsync(MHzSongBase song, bool not_show = false, bool show_start = true, bool show_succ_notif = true, bool show_fail_notif = true)
{
var file = default(StorageFile);
try {
var folder = await GetBeansproutMusicFolderAsync();
var filename = MHzSongBaseHelper.GetIdentity(song) + StorageHelper.MusicTemporaryExtension;
file = await CreateFileInMusicFolderWithNameAsync(folder, filename);
var fail_toast = ToastHelper.CreateToastNotificaion(
title: GetUIString("Download_Failed") + " : " + song.Title,
content: DateTime.Now.ToString("h:mm tt"),
imageUri: " -- ",
uri: " -- ",
logoOverride: song.Picture,
voice: "ms-appx:///Voice/yellsedtsr.mp3");
var succeed_toast = ToastHelper.CreateToastNotificaion(
title: GetUIString("Download_Succeed") + " : " + song.Title,
content: DateTime.Now.ToString("h:mm tt"),
imageUri: " -- ",
uri: " -- ",
logoOverride: song.Picture,
voice: "ms-appx:///Voice/haizi.mp3");
var group = BackgroundTransferGroup.CreateGroup(DoubanMusicGroup);
group.TransferBehavior = BackgroundTransferBehavior.Serialized;
var downloader = new BackgroundDownloader {
FailureToastNotification = show_succ_notif ? new Windows.UI.Notifications.ToastNotification(fail_toast) : null,
SuccessToastNotification = show_fail_notif ? new Windows.UI.Notifications.ToastNotification(succeed_toast) : null,
TransferGroup = group,
};
var succeed_trans = Uri.TryCreate(song.Url, UriKind.Absolute, out var do_url);
if (!succeed_trans)
{
throw new DownloadCanNotRunException();
}
var operation = downloader.CreateDownload(do_url, file);
operation.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly;
if (show_start)
{
ReportHelper.ReportAttentionAsync(GetUIString("Download_Start"));
}
if (!not_show)
{
DownloadListAddNewItem(song, operation);
operation = await operation.StartAsync();
}
else
{
var control = await operation.StartAsync();
}
var mess_succeed = await CreateBJSONMessageAsync(song, folder, file.Path);
if (!mess_succeed)
{
throw new JSONCanNotCreateException();
}
await file.RenameAsync(filename.Replace(StorageHelper.MusicTemporaryExtension, StorageHelper.MusicExtension), NameCollisionOption.ReplaceExisting);
return(DownloadResult.Successfully);
} catch (JSONCanNotCreateException) {
await file.DeleteAsync();
return(DownloadResult.Failed);
} catch (DownloadCanNotRunException) {
await file.DeleteAsync();
return(DownloadResult.Failed);
} catch (FileCannNotCreateException) {
return(DownloadResult.Failed);
} catch (FileExistException) {
return(DownloadResult.FileExist);
} catch (Exception e) {
Debug.WriteLine(e.Message);
return(DownloadResult.Failed);
}
}
private async void AppBarButton_Click(object sender, RoutedEventArgs e)
{
if (this.GalleryViewModel?.Gallery == null)
{
return;
}
var savePicker = new FolderPicker();
//savePicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
savePicker.FileTypeFilter.Add("*");
var galleryParentFolder = await savePicker.PickSingleFolderAsync();
if (galleryParentFolder == null)
{
return;
}
var galleryFolder = await galleryParentFolder.CreateFolderAsync(this.GalleryViewModel.Gallery.Gid, CreationCollisionOption.OpenIfExists);
//var galleriesFolder = await ApplicationData.Current.LocalFolder.CreateFolderAsync(EX_GALLERIES_FOLDER_NAME, CreationCollisionOption.OpenIfExists);
//var galleryFolder = await galleriesFolder.CreateFolderAsync(this.GalleryViewModel.Gallery.Gid, CreationCollisionOption.OpenIfExists);
// Download image list
await this.GalleryViewModel.Gallery.LoadAllItemsAsync();
BackgroundTransferCompletionGroup completionGroup = new BackgroundTransferCompletionGroup();
BackgroundTaskBuilder builder = new BackgroundTaskBuilder();
builder.Name = "DownloadFinished";
builder.SetTrigger(completionGroup.Trigger);
BackgroundTaskRegistration taskRegistration = builder.Register();
BackgroundDownloader downloader = new BackgroundDownloader(completionGroup);
downloader.TransferGroup = BackgroundTransferGroup.CreateGroup($"{this.GalleryViewModel.Gallery.Gid}");
downloader.TransferGroup.TransferBehavior = BackgroundTransferBehavior.Parallel;
// Create tasks and file for each pic
StorageFile[] files = new StorageFile[this.GalleryViewModel.Gallery.Count];
foreach (var image in this.GalleryViewModel.Gallery)
{
files[this.GalleryViewModel.Gallery.IndexOf(image)] = await galleryFolder.CreateFileAsync($"{this.GalleryViewModel.Gallery.IndexOf(image) + 1}.jpg", CreationCollisionOption.ReplaceExisting);
}
// Get the image uri and download data for each pic
List <Task> getImageUriTasks = new List <Task>();
var gallery = this.GalleryViewModel.Gallery;
foreach (var image in gallery)
{
getImageUriTasks.Add(Download(image, files[gallery.IndexOf(image)], downloader));
}
await Task.WhenAll(getImageUriTasks);
downloader.CompletionGroup.Enable();
await new MessageDialog("You can exit the app now. There will be a toast notification when all downloads are finished.", "Download started").ShowAsync();
}
public static async Task <ObservableCollection <DownloadModel> > GetDownload(DownloadType type)
{
var group = "";
switch (type)
{
case DownloadType.song:
group = "song";
break;
case DownloadType.mv:
group = "mv";
break;
case DownloadType.other:
group = "other";
break;
default:
break;
}
var downs = await BackgroundDownloader.GetCurrentDownloadsForTransferGroupAsync(BackgroundTransferGroup.CreateGroup(group));
var downlist = new ObservableCollection <DownloadModel>();
if (downs.Count > 0)
{
foreach (var down in downs)
{
var model = new DownloadModel();
downlist.Add(model);
}
}
return(downlist);
}
