private async Task DownloadAsync(DownloadOperation download) { Log(String.Format(CultureInfo.CurrentCulture, "Downloading {0}", download.ResultFile.Name)); try { await download.StartAsync(); LogStatus(String.Format(CultureInfo.CurrentCulture, "Downloading {0} completed.", download.ResultFile.Name), NotifyType.StatusMessage); } catch (TaskCanceledException) { } catch (Exception ex) { if (!IsExceptionHandled("Execution error", ex, download)) { throw; } } }
internal void StartDownloadAsync(string destinationPathName, bool mobileNetworkAllowed) { var downloader = new BackgroundDownloader(); var downloadUrl = new Uri(Url); if (Headers != null) { foreach (var header in Headers) { downloader.SetRequestHeader(header.Key, header.Value); } } if (!mobileNetworkAllowed) { downloader.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; } StorageFile file; if (destinationPathName != null) { var folder = StorageFolder.GetFolderFromPathAsync(Path.GetDirectoryName(destinationPathName)).AsTask().Result; file = folder.CreateFileAsync(Path.GetFileName(destinationPathName), CreationCollisionOption.ReplaceExisting).AsTask().Result; } else { var folder = Windows.ApplicationModel.Package.Current.InstalledLocation; file = folder.CreateFileAsync(downloadUrl.Segments.Last(), CreationCollisionOption.GenerateUniqueName).AsTask().Result; } DownloadOperation = downloader.CreateDownload(downloadUrl, file); var progress = new Progress <DownloadOperation>(ProgressChanged); _cancellationToken = new CancellationTokenSource(); DownloadOperation.StartAsync().AsTask(_cancellationToken.Token, progress); }
private async void ladeDaten() { try { Uri source = new Uri("https://opendata.arcgis.com/datasets/917fc37a709542548cc3be077a786c17_0.csv", UriKind.Absolute); BackgroundDownloader downloader = new BackgroundDownloader(); Debug.WriteLine(Windows.Storage.ApplicationData.Current.LocalFolder); StorageFile testfile = await folder.CreateFileAsync("data.csv", CreationCollisionOption.ReplaceExisting); DownloadOperation download = downloader.CreateDownload(source, testfile); await download.StartAsync(); await Task.Delay(TimeSpan.FromSeconds(5)); if (parser == null) { parser = new CSV_Parser(); } parser.getDaten(); await Task.Delay(TimeSpan.FromSeconds(5)); int lol = parser.getDatenLange(); Debug.WriteLine(lol); LiveKachelCreator library = new LiveKachelCreator(); library.sendMessage(OldDataService.getOldLandkreis(), parser.getIndex(OldDataService.getOldLandkreis())); try { ladeGrid(); } catch (Exception e) { Debug.WriteLine("Download Error", e); } } catch (Exception ex) { Debug.WriteLine("Download Error", ex); } }
public async Task <string> DownloadAndInstall(string versionFromWeb) { try { string fileType = obj.isDeviceHandheld ? "_ARM.appx" : "_x64.appxbundle"; BackgroundDownloader downloader = new BackgroundDownloader(); Uri source = new Uri("http://www.develok.ee/KoneskoWMS/Install/KoneskoWMS_" + versionFromWeb + fileType, UriKind.Absolute); StorageFolder fold = KnownFolders.PicturesLibrary; StorageFile testfile = await fold.CreateFileAsync("KoneskoWMS_" + versionFromWeb + fileType, CreationCollisionOption.ReplaceExisting); Progress <DownloadOperation> progress = new Progress <DownloadOperation>(progressChanged); DownloadOperation download = downloader.CreateDownload(source, testfile); CancellationTokenSource cancellationToken = new CancellationTokenSource(); await download.StartAsync().AsTask(cancellationToken.Token, progress); IReadOnlyList <StorageFile> filesInFolder = await KnownFolders.PicturesLibrary.GetFilesAsync(); foreach (StorageFile file in filesInFolder) { if (file.Name == "KoneskoWMS_" + versionFromWeb + fileType) { if (await Windows.System.Launcher.LaunchFileAsync(file)) { return(null); } else { return("UUENDAMINE EI ÕNNESTUNUD!"); } } } return("UUENDAMINE EI ÕNNESTUNUD!"); } catch (Exception ex) { Debug.WriteLine(ex.Message); return("UUENDAMINE EI ÕNNESTUNUD! " + "\r\n" + ex.Message); } }
private async Task HandleDownloadAsync(DownloadOperation download, bool start) { try { // Store the download so we can pause/resume. activeDownloads.Add(download); Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress); var cts = new CancellationTokenSource(); cancellationTokens.Add(download.Guid, cts); if (start) { // Start the download and attach a progress handler. await download.StartAsync().AsTask(cts.Token, progressCallback); } else { // The download was already running when the application started, re-attach the progress handler. await download.AttachAsync().AsTask(cts.Token, progressCallback); } ResponseInformation response = download.GetResponseInformation(); // GetResponseInformation() returns null for non-HTTP transfers (e.g., FTP). string statusCode = response != null?response.StatusCode.ToString() : String.Empty; } catch (TaskCanceledException) { } catch (Exception ex) { } finally { activeDownloads.Remove(download); } }
private async void Download(String url, String name) { Uri source = new Uri(url); StorageFile destinationFile = await MediaManager.Instance.SaveFolder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName); BackgroundDownloader downloader = new BackgroundDownloader(); _downloadOperation = downloader.CreateDownload(source, destinationFile); Timer timer = new System.Timers.Timer(50); // Hook up the Elapsed event for the timer. // timer.Elapsed += ShowCacheProgress; // timer.AutoReset = true; // timer.Enabled = false; await _downloadOperation.StartAsync(); // timer.Stop(); // timer.Dispose(); CacheButton.Content = "取消缓存"; CacheButton.IsEnabled = true; MediaManager.Instance.LoadCachedItems(); }
private async Task DownloadCoupon() { try { Uri source = new Uri("https://localhost:44315/" + Promotion.Attachments[0].Path); StorageFile destinationFile = await DownloadsFolder.CreateFileAsync( $"Stapp_Kortingsbon.pdf", CreationCollisionOption.GenerateUniqueName); BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(source, destinationFile); await download.StartAsync(); await Launcher.LaunchFileAsync(destinationFile); } catch (Exception ex) { Debug.WriteLine("Download Error", ex.Message); } }
private async Task <StorageFile> StartDownloadAsync(DownloadOperation downloadOperation) { try { Download = downloadOperation; await downloadOperation.StartAsync().AsTask(cts.Token, progressCallback); CurrentDownloadedBytes += (long)downloadOperation.Progress.BytesReceived; return((StorageFile)downloadOperation.ResultFile); } catch (Exception e) { Downloading = false; CurrentDownloadedBytes = 0; foreach (Playlist downloadedPlaylist in currentlyDownloadingPlaylists) { RemoveDownload(downloadedPlaylist);//may not have even started downloading this playlist when this is called } currentlyDownloadingPlaylists = new List <Playlist>(); return(null); } }
private async Task HandleDownloadAsync(DownloadOperation download, bool start) { try { status.Log(string.Format( CultureInfo.CurrentCulture, LocalizableStrings.BACKGROUND_TRANSFER_RUNNING, download.Guid)); activeDownloads.Add(download); Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadProgress); if (start) { await download.StartAsync().AsTask(cancelToken.Token, progressCallback); } else { await download.AttachAsync().AsTask(cancelToken.Token, progressCallback); } ResponseInformation response = download.GetResponseInformation(); status.Log(string.Format( CultureInfo.CurrentCulture, LocalizableStrings.BACKGROUND_TRANSFER_COMPLETED, download.Guid, response.StatusCode)); } catch (TaskCanceledException) { status.Log(string.Format( CultureInfo.CurrentCulture, LocalizableStrings.BACKGROUND_TRANSFER_CANCELLED, download.Guid)); } catch (Exception ex) { status.Log(ex.Message); Debug.WriteLine(ex.ToString()); } finally { activeDownloads.Remove(download); } }
private static async Task HandleDownloadImageAsync(DownloadOperation download, bool start) { try { System.Diagnostics.Debug.WriteLine("Running image: " + download.Guid); // Store the download so we can pause/resume. Progress <DownloadOperation> progressCallback = new Progress <DownloadOperation>(DownloadImageProgress); if (start) { // Start the download and attach a progress handler. await download.StartAsync().AsTask(cts.Token, progressCallback); } else { // The download was already running when the application started, re-attach the progress handler. await download.AttachAsync().AsTask(cts.Token, progressCallback); } ResponseInformation response = download.GetResponseInformation(); System.Diagnostics.Debug.WriteLine(String.Format("Completed image: {0}, Status Code: {1}", download.Guid, response.StatusCode)); // grDownload.Visibility = Visibility.Collapsed; if (response.StatusCode == 200) { //image loaded System.Diagnostics.Debug.WriteLine("Downloaded file: " + download.ResultFile.Name); } } catch (TaskCanceledException) { System.Diagnostics.Debug.WriteLine("Canceled: " + download.Guid); OnDownloadEvent?.Invoke(null, new DownloadEventArgs(download.ResultFile.Name, DownloadState.Canceled)); cts = null; } }
/// Download /// PART private async void btnDownload_Click(object sender, RoutedEventArgs e) { FolderPicker folderPicker = new FolderPicker(); folderPicker.SuggestedStartLocation = PickerLocationId.Downloads; folderPicker.ViewMode = PickerViewMode.Thumbnail; folderPicker.FileTypeFilter.Add("*"); StorageFolder folder = await folderPicker.PickSingleFolderAsync(); if (folder != null) { StorageFile file = await folder.CreateFileAsync(fileName, CreationCollisionOption.GenerateUniqueName); downloadOperation = backgroundDownloader.CreateDownload(new Uri(urlName), file); Progress <DownloadOperation> progress = new Progress <DownloadOperation>(progressChanged); cancellationToken = new CancellationTokenSource(); btnDownload.IsEnabled = false; btnCancel.IsEnabled = true; btnPauseResume.IsEnabled = true; try { txtStatus.Text = "Initializing..."; await downloadOperation.StartAsync().AsTask(cancellationToken.Token, progress); } catch (TaskCanceledException) { txtStatus.Text = "Download cancelled"; downloadOperation.ResultFile.DeleteAsync(); btnPauseResume.Content = "Resume"; btnCancel.IsEnabled = false; btnPauseResume.IsEnabled = false; btnDownload.IsEnabled = true; downloadOperation = null; } } }
public async void Savefile() { FileSavePicker savefile = new FileSavePicker(); savefile.SuggestedStartLocation = PickerLocationId.DocumentsLibrary; string f = "保存文件类型"; savefile.FileTypeChoices.Add(f, new List <string>() { ".jpg", ".png", ".bmp" }); savefile.SuggestedFileName = imgname + "ID" + imgid; storagefile = await savefile.PickSaveFileAsync(); //var a = new ToastDialog(); if (storagefile != null) { CachedFileManager.DeferUpdates(storagefile); string Filename = imgname + imgid; string _transferUri = imguri; Uri transferUri; try { transferUri = new Uri(Uri.EscapeUriString(_transferUri), UriKind.RelativeOrAbsolute); } catch { return; } BackgroundDownloader backgrounddownloader = new BackgroundDownloader();//后台下载 DownloadOperation downloader = backgrounddownloader.CreateDownload(transferUri, storagefile); await downloader.StartAsync(); await showtast(); } }//总是调起资源选择器
private async Task RetryDownloads(IEnumerable <DownloadOperation> downloads, List <DownloadDesc> list) { BackgroundDownloader downloader = CreateBackgroundDownloader(); foreach (DownloadOperation download in downloads) { try { DownloadOperation download1 = downloader.CreateDownload(download.RequestedUri, download.ResultFile); Task <DownloadOperation> startTask = download1.StartAsync().AsTask(); var p = list.Find(a => a.Guid == download.Guid); p.Guid = download1.Guid; await SQLOperator.Current().UpdateDownload(p); list.Remove(p); } catch (Exception) { continue; } } downloader.CompletionGroup.Enable(); }
public async void DownloadVideo() { var client = new YoutubeClient(); var videoUrl = Constants.videoInfo.Muxed[0].Url; var savePicker = new Windows.Storage.Pickers.FileSavePicker { SuggestedStartLocation = Windows.Storage.Pickers.PickerLocationId.Downloads }; savePicker.FileTypeChoices.Add("Video File", new List <string>() { ".mp4" }); Windows.Storage.StorageFile file = await savePicker.PickSaveFileAsync(); if (file != null) { // Prevent updates to the remote version of the file until // we finish making changes and call CompleteUpdatesAsync. Windows.Storage.CachedFileManager.DeferUpdates(file); // write to file BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(new Uri(videoUrl), file); DownloadProgress.Visibility = Visibility.Visible; Progress <DownloadOperation> progress = new Progress <DownloadOperation>(); progress.ProgressChanged += Progress_ProgressChanged; await download.StartAsync().AsTask(CancellationToken.None, progress); } else { Log.Info("Download operation was cancelled."); } }
private async Task StartOneDownload(string fileName, Uri uri, DownloadData dd) { StorageFile destinationFile = null; try { var acFolder = await KnownFolders.VideosLibrary.CreateFolderAsync("ACFUNVideo", CreationCollisionOption.OpenIfExists); destinationFile = await acFolder.CreateFileAsync(fileName, CreationCollisionOption.ReplaceExisting); } catch (Exception ex) { return; } BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(uri, destinationFile); dd.DownloadGuid.Add(download.Guid.ToString()); SaveDB(); download.Priority = BackgroundTransferPriority.Default; await download.StartAsync(); }
private async Task HandleDownloadAsync(DownloadOperation download, bool start) { try { //Log("Running: " + download.Guid); // Store the download so we can pause/resume. activeDownloads.Add(download); progressCallback = new Progress <DownloadOperation>(DownloadProgress); if (start) { // Start the download and attach a progress handler. await download.StartAsync().AsTask(cts.Token, progressCallback); } else { // The download was already running when the application started, re-attach the progress handler. await download.AttachAsync().AsTask(cts.Token, progressCallback); } } catch (TaskCanceledException) { //HelperMethods.HelperMethods.MessageUser("Downloads Cancelled", topStack); //Frame.Navigate(typeof(ActiveDownloads)); } catch (Exception ex) { // Helper.HelperMethods.MessageUser("Something went wrong. Please try again"); } finally { activeDownloads.Remove(download); } }
private async Task TestBackgroundDownloader(string name, string URL) { BackgroundDownloader bd = new BackgroundDownloader(); bd.FailureToastNotification = this.CreateFailureToast(); bd.SuccessToastNotification = this.CreateSuccessToast(); FolderPicker folderPicker = new FolderPicker(); folderPicker.SuggestedStartLocation = PickerLocationId.Downloads; folderPicker.ViewMode = PickerViewMode.Thumbnail; folderPicker.FileTypeFilter.Add("*"); StorageFolder folder = await folderPicker.PickSingleFolderAsync(); if (folder != null) { StorageFile file = await folder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName); Debug.WriteLine(file.Path); Uri uri = new Uri(URL); DownloadOperation op = bd.CreateDownload(uri, file); var progress = op.StartAsync(); progress.Completed = this.Completed; } }
public static async Task SaveImageAsync(string imageName, string imageUri) { BackgroundDownloader backgroundDownload = new BackgroundDownloader(); StorageFolder folder = null; StorageFile newFile = null; if (Setting.GetSettingValue("DownloadPath").Contains("我的文档\\图片\\Acafe")) { folder = await KnownFolders.PicturesLibrary.CreateFolderAsync("Acafe", CreationCollisionOption.OpenIfExists); newFile = await folder.CreateFileAsync(imageName, CreationCollisionOption.OpenIfExists); } else { folder = await StorageFolder.GetFolderFromPathAsync(Setting.GetSettingValue("DownloadPath")); newFile = await folder.CreateFileAsync(imageName, CreationCollisionOption.OpenIfExists); } Uri uri = new Uri(imageUri); DownloadOperation download = backgroundDownload.CreateDownload(uri, newFile); await download.StartAsync(); }
private async Task StartDownloadAndReadContentsAsync() { try { // Retrieve a random access stream from the download operation. Every OpenReadAsync() operation returns // a new stream instance that is independent of previous ones (i.e., the seek position of one stream // isn't affected by calls on another stream). // // This sample demonstrates the direct usage of a DownloadOperation's random access stream and its // effects on the ongoing transfer. However, bear in mind that there are a variety of operations // that can manage the stream on the app's behalf for specific scenarios. For instance, a // DownloadOperation pointing to a video URL can be consumed by the MediaPlayer class in four easy // steps: // // var randomAccessStreamReference = download.GetResultRandomAccessStreamReference(); // stream = await randomAccessStreamReference.OpenReadAsync(); // var mediaPlayer = new Windows.Media.Playback.MediaPlayer(); // mediaPlayer.Source = Windows.Media.Core.MediaSource.CreateFromStream(stream, stream.ContentType); var randomAccessStreamReference = download.GetResultRandomAccessStreamReference(); randomAccessStream = await randomAccessStreamReference.OpenReadAsync(); // Start the download. If the server doesn't support random access, the download will fail // with WebErrorStatus.InsufficientRangeSupport or WebErrorStatus.MissingContentLengthSupport. IAsyncOperationWithProgress <DownloadOperation, DownloadOperation> downloadOperation = download.StartAsync(); downloadOperation.Progress += OnDownloadProgress; Task downloadTask = downloadOperation.AsTask(); startDownloadButton.IsEnabled = false; pauseDownloadButton.IsEnabled = true; // Read data while the download is still ongoing. Use a 1 MB read buffer for that purpose. var readBuffer = new Windows.Storage.Streams.Buffer(BytesPerMegaByte); while (!downloadTask.IsCompleted) { ulong readOffsetInBytes = randomAccessStream.Position; PreviousReadText.Text = CurrentReadText.Text; CurrentReadText.Text = $"Reading from offset {readOffsetInBytes:n0}"; readOperation = randomAccessStream.ReadAsync( readBuffer, readBuffer.Capacity, InputStreamOptions.None). AsTask(readCancellationTokenSource.Token); // Update the UI to show the current read's position. currentPositionSlider.Value = readOffsetInBytes / BytesPerMegaByte; try { // Wait for the read to complete. IBuffer bytesRead = await readOperation; CurrentReadText.Text += $", completed with {bytesRead.Length:n0} bytes"; // At this point, a real app would process the 'bytesRead' data to do something interesting // with it (e.g., display video and/or play audio). if (randomAccessStream.Position >= randomAccessStream.Size) { // We have reached EOF. Wrap around to the beginning while we wait for the download to complete. randomAccessStream.Seek(0); } } catch (OperationCanceledException) { // The ongoing read was canceled by SeekDownload_Click(...) in order for a new download // position to take effect immediately. CurrentReadText.Text += ", cancelled."; } } // Wait for the download to complete. await downloadTask; rootPage.NotifyUser("Download completed successfully", NotifyType.StatusMessage); } catch (Exception ex) when(IsWebException("Execution error", ex)) { // Abandon the operation if a web exception occurs. } finally { download = null; randomAccessStream = null; readOperation = null; startDownloadButton.IsEnabled = true; pauseDownloadButton.IsEnabled = false; resumeDownloadButton.IsEnabled = false; } }
public Task Start() { DownloadStatus = DownloadStatus.Run; return(DownloadOperation.StartAsync().AsTask(Cts.Token, Progress)); }
public static async void StartDownload(DownloadModel m, int index) { try { if (folderList == null) { await GetfolderList(); } BackgroundDownloader downloader = new BackgroundDownloader(); downloader.SetRequestHeader("Referer", "https://www.bilibili.com/blackboard/html5player.html?crossDomain=true"); downloader.SetRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36"); //设置下载模式 if (SettingHelper.Get_DownMode() == 0) { group.TransferBehavior = BackgroundTransferBehavior.Serialized; } else { group.TransferBehavior = BackgroundTransferBehavior.Parallel; } downloader.TransferGroup = group; //设置视频文件夹 StorageFolder videoFolder = null; var f = folderList.Find(x => x.id == m.folderinfo.id); if (f == null) { videoFolder = await DownFolder.CreateFolderAsync(m.folderinfo.id, CreationCollisionOption.OpenIfExists); m.folderinfo.folderPath = videoFolder.Path; m.folderinfo.thumb = await DownThumb(m.folderinfo.thumb, m.folderinfo.id, videoFolder); folderList.Add(m.folderinfo); } else { try { videoFolder = await StorageFolder.GetFolderFromPathAsync(f.folderPath); } catch (Exception ex) { MessageDialog md = new MessageDialog("Get videoFolder Error!\r\n" + ex.Message); } } //读取part文件夹 StorageFolder PartFolder = null; var partf = await videoFolder.CreateFolderAsync(m.videoinfo.mid, CreationCollisionOption.OpenIfExists); if (partf == null) { PartFolder = await videoFolder.CreateFolderAsync(m.videoinfo.mid, CreationCollisionOption.OpenIfExists); } else { PartFolder = partf; } //创建相关文件 //创建配置文件 //创建视频文件 StorageFile file = await PartFolder.CreateFileAsync(m.videoinfo.mid + "-" + index + ".flv", CreationCollisionOption.OpenIfExists); //下载弹幕文件 await DownDanMu(m.videoinfo.mid, PartFolder); DownloadOperation downloadOp = downloader.CreateDownload(new Uri(m.videoinfo.videoUrl), file); //设置下载策略 if (SettingHelper.Get_Use4GDown()) { downloadOp.CostPolicy = BackgroundTransferCostPolicy.Always; } else { downloadOp.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; } BackgroundTransferStatus downloadStatus = downloadOp.Progress.Status; m.videoinfo.downGUID = downloadOp.Guid.ToString(); m.videoinfo.videoPath = downloadOp.ResultFile.Path; m.videoinfo.folderPath = PartFolder.Path; m.videoinfo.downstatus = false; StorageFile sefile = await PartFolder.CreateFileAsync(m.videoinfo.mid + ".json", CreationCollisionOption.OpenIfExists); await FileIO.WriteTextAsync(sefile, JsonConvert.SerializeObject(m.videoinfo)); await SetGUIDFile(m); downloadOp.StartAsync(); } catch (Exception ex) { MessageDialog md = new MessageDialog("StartDownload Eroor!\r\n" + ex.Message); await md.ShowAsync(); } finally { await SetfolderList(); await GetfolderList(); } }
public async Task StartAsync() { await op.StartAsync().AsTask(cts.Token); }
public async void StartDownload(DownModel downModel) { try { BackgroundDownloader downloader = new BackgroundDownloader(); if (Mode == 0) { DownModel.group.TransferBehavior = BackgroundTransferBehavior.Serialized; } else { DownModel.group.TransferBehavior = BackgroundTransferBehavior.Parallel; } downloader.TransferGroup = DownModel.group; if (setting.SettingContains("UseWifi")) { if ((bool)setting.GetSettingValue("UseWifi")) { downloader.CostPolicy = BackgroundTransferCostPolicy.Default; } else { downloader.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; } } else { downloader.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; setting.SetSettingValue("UseWifi", false); } StorageFolder DowFolder = await KnownFolders.VideosLibrary.CreateFolderAsync("Bili-Down", CreationCollisionOption.OpenIfExists); StorageFolder VideoFolder = await DowFolder.CreateFolderAsync(ReplaceSymbol(downModel.title), CreationCollisionOption.OpenIfExists); StorageFolder PartFolder = await VideoFolder.CreateFolderAsync(downModel.part, CreationCollisionOption.OpenIfExists); StorageFile file = await PartFolder.CreateFileAsync(downModel.mid + ".mp4", CreationCollisionOption.OpenIfExists); DownloadOperation downloadOp = downloader.CreateDownload(new Uri(downModel.url), file); downloadOp.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; BackgroundTransferStatus downloadStatus = downloadOp.Progress.Status; downModel.Guid = downloadOp.Guid.ToString(); downModel.path = downloadOp.ResultFile.Path; string jsonInfo = JsonConvert.SerializeObject(downModel); StorageFile fileWrite = await PartFolder.CreateFileAsync(downModel.Guid + ".json", CreationCollisionOption.OpenIfExists); await FileIO.WriteTextAsync(fileWrite, jsonInfo); StorageFile fileWrite2 = await DowFolder.CreateFileAsync(downModel.Guid + ".bili", CreationCollisionOption.OpenIfExists); await FileIO.WriteTextAsync(fileWrite2, WebUtility.UrlEncode(PartFolder.Path)); DownDanMu(downModel.mid, PartFolder); downloadOp.StartAsync(); } catch (Exception ex) { //WebErrorStatus error = BackgroundTransferError.GetStatus(ex.HResult); MessageDialog md = new MessageDialog(ex.Message); await md.ShowAsync(); } }
private static async void CreateDown(DownloadTaskModel m, int index, DownloadUrlInfo url, StorageFolder folder) { BackgroundDownloader downloader = new BackgroundDownloader(); foreach (var item in url.Headers) { downloader.SetRequestHeader(item.Key, item.Value); } //downloader.SetRequestHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0"); //if (!url.Contains("360.cn")) //{ // downloader.SetRequestHeader("Origin", "https://www.bilibili.com/"); // downloader.SetRequestHeader("Referer", "https://www.bilibili.com/"); //} //设置下载模式 if (SettingHelper.Get_DownMode() == 0) { group.TransferBehavior = BackgroundTransferBehavior.Serialized; } else { group.TransferBehavior = BackgroundTransferBehavior.Parallel; } downloader.TransferGroup = group; //创建视频文件 var filetype = ".flv"; if (url.Url.Contains(".mp4")) { filetype = ".mp4"; } StorageFile file = await folder.CreateFileAsync(index.ToString("000") + filetype, CreationCollisionOption.OpenIfExists); DownloadOperation downloadOp = downloader.CreateDownload(new Uri(url.Url), file); //设置下载策略 if (SettingHelper.Get_Use4GDown()) { downloadOp.CostPolicy = BackgroundTransferCostPolicy.Always; } else { downloadOp.CostPolicy = BackgroundTransferCostPolicy.UnrestrictedOnly; } SqlHelper.InsertDownload(new DownloadGuidClass() { guid = downloadOp.Guid.ToString(), cid = m.cid, index = index, aid = (m.downloadMode == DownloadMode.Anime) ? m.sid : m.avid, eptitle = m.epTitle, title = m.title, mode = (m.downloadMode == DownloadMode.Anime) ? "anime" : "video" }); try { await downloadOp.StartAsync(); } catch (Exception) { } }
public static async Task <ObservableCollection <WeaponSkin> > GetSkins() { //Collection of the skins ObservableCollection <WeaponSkin> SkinCollection = new ObservableCollection <WeaponSkin>(); //CSGO-File where the URIs are stored in StorageFile inputFile = await GetSkinsFileAsync(); //Saves the text of the inputFile in a string for further editing string text = await Windows.Storage.FileIO.ReadTextAsync(inputFile); //erases all entries in the text before the first url if (!text.StartsWith("weapon")) { text = text.Substring(text.IndexOf("weapon")); } //downloading the pictures from the different urls while (text.Length != 0) { WeaponSkin skin = new WeaponSkin(); skin.Id = text.Substring(0, text.IndexOf("=")); text = text.Substring(text.IndexOf("=") + 1); skin.Url = text.Substring(0, text.IndexOf("\r\n")); text = text.Substring(text.IndexOf("\n") + 1); try { //downloading the pictures from the urls Uri sourceUri = new Uri("ms-appx:///Images/WeaponSkins/defaultSkin.png"); string destination = "ms-appx:///Images/WeaponSkins/" + skin.Id + ".png"; //getting the destination Folder for the pictures, by receiving the parent folder from a default file StorageFile defaultFile = await StorageFile.GetFileFromApplicationUriAsync(sourceUri); Windows.Storage.StorageFolder storageFolder = await defaultFile.GetParentAsync(); //creating the .png file for the picture Windows.Storage.StorageFile destinationFile = await storageFolder.CreateFileAsync(skin.Id + ".png", Windows.Storage.CreationCollisionOption.ReplaceExisting); //StorageFile destinationFile = await KnownFolders.PicturesLibrary.CreateFileAsync(destination, CreationCollisionOption.GenerateUniqueName); //downloading the picture from the url BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(new Uri(skin.Url), destinationFile); // Attach progress and completion handlers. var result = download.StartAsync(); //assign the downloaded picture to the skin skin.Icon = destinationFile.Path; } catch (Exception ex) { //LogException("Download Error", ex); } //adding the skin to the collection SkinCollection.Add(skin); } return(SkinCollection); }
public static async void Download(string url, string thumbnail, bool isVideo = false, string username = null, string caption = null, bool sendNotify = false, bool story = false, bool userDownloader = false) { try { StorageFolder folder; if (story) { folder = await Helper.GetPictureFolderForStories(); } else { folder = await Helper.GetPictureFolder(); } var date = DateTime.UtcNow; //DateTime.Now.ToString("yyyy-dd-MMTh:mm:ss-0fffZ") var name = $"{username?.ToUpper()}_IMG_{date.ToString("yyyyddMM_hmmssfff", CultureInfo.CurrentCulture)}.jpg"; if (isVideo) { name = $"{username?.ToUpper()}_VID_{date.ToString("yyyyddMM_hmmssfff", CultureInfo.CurrentCulture)}.mp4"; } var destinationFile = await folder.CreateFileAsync(name, CreationCollisionOption.GenerateUniqueName); if (!string.IsNullOrEmpty(caption)) { if (caption.Length > 110) { caption = caption.Substring(0, 108); } } if (caption == null) { caption = string.Empty; } caption = ReplaceInvalidXmlCharacterReferences(caption); ToastNotification failed = null; ToastNotification success = null; if (userDownloader) { failed = NotificationHelper.GetSingleUserNotify(username, thumbnail, "Download failed"); success = NotificationHelper.GetSuccessUserNotify(username, thumbnail); } else { try { failed = NotificationHelper.GetFailedNotify(caption, thumbnail); } catch { failed = NotificationHelper.GetFailedNotify(null, thumbnail); } try { success = NotificationHelper.GetSuccessNotify(caption, thumbnail); } catch { success = NotificationHelper.GetSuccessNotify(null, thumbnail); } } BackgroundDownloader downloader = new BackgroundDownloader { FailureToastNotification = failed, SuccessToastNotification = success }; if (sendNotify) { MainPage.Current.ShowInAppNotify($"Download started...", 1200); } DownloadOperation download = downloader.CreateDownload(new Uri(url), destinationFile); await download.StartAsync().AsTask(); } catch (Exception ex) { ex.PrintException("Download"); } }
internal static async Task DownloadFileASync(string link, StorageFile destination, IProgress <DownloadOperation> progress, CancellationToken cancellationToken = default) { BackgroundDownloader downloader = new BackgroundDownloader(); DownloadOperation download = downloader.CreateDownload(new Uri(link), destination); await download.StartAsync().AsTask(cancellationToken, progress); }
private async Task StartDownloadAsync(DownloadOperation obj) { var process = new Progress <DownloadOperation>(ProgressCallback); await obj.StartAsync().AsTask(process); }
// Picture Download Progress private async Task <DownloadOperation> PerformDownload(DownloadOperation download) { Progress <DownloadOperation> callback = new Progress <DownloadOperation>(UpdateDownloadProgress); return(await download.StartAsync().AsTask(callback)); }
public async Task <MediaSource> RequestMusic(MusicModel model) { EventHandler <DownloadOperation> downloadProgressHandler = (o, e) => { _logger.Debug($"Downloading status of {model.Title}:\n\t{e.Progress.Status}, ({e.Progress.BytesReceived}/{e.Progress.TotalBytesToReceive})"); switch (e.Progress.Status) { case BackgroundTransferStatus.Completed: _utilityHelper.RunAtUIThread(() => model.HasCached = true); break; default: break; } }; IRandomAccessStreamReference ras = null; DownloadOperation downloadOperation = null; var downloadProgress = new Progress <DownloadOperation>(); downloadProgress.ProgressChanged += downloadProgressHandler; var cacheFile = await _createMusicFile(model); if (cacheFile == null) { var operations = await BackgroundDownloader.GetCurrentDownloadsForTransferGroupAsync(_backgroundDownloaderGroup); foreach (var item in operations) { if (item.ResultFile is StorageFile cachedFile) { if (cachedFile.Name == _utilityHelper.CreateMd5HashString(model.Title)) { downloadOperation = item; break; } } } if (downloadOperation != null) { ras = downloadOperation.GetResultRandomAccessStreamReference(); downloadOperation.AttachAsync().AsTask(downloadProgress); } else { _logger.Warning($"Don't find the downloading task for {model.Title}"); return(null); } } else { downloadOperation = _backgroundDownloader.CreateDownload(model.Uri, cacheFile); downloadOperation.IsRandomAccessRequired = true; ras = downloadOperation.GetResultRandomAccessStreamReference(); downloadOperation.StartAsync().AsTask(downloadProgress); } var source = MediaSource.CreateFromStreamReference(ras, "audio/mpeg"); return(source); }