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 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); }
static void CreateBackgroundDownloadGroup() { if (s_BackgroundDownloadGroup == null) { s_BackgroundDownloadGroup = BackgroundTransferGroup.CreateGroup("UnityBackgroundDownloads"); } }
public Scenario7_DownloadReordering() { reorderGroup = BackgroundTransferGroup.CreateGroup("{7421B969-18D4-4532-B6BD-22BDABF71C08}"); reorderGroup.TransferBehavior = BackgroundTransferBehavior.Serialized; this.DataContext = this; this.InitializeComponent(); }
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 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 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 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 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 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 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); }
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); } }
// 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 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); }
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(); }