/// <summary> /// Updates the current progress and call the <see cref="ProgressChanged"/> event to notify listeners. /// </summary> private void UpdateProgress(IDownloadProgress progress) { var changed = ProgressChanged; if (changed != null) { changed(progress); } }
/// <summary> /// Helper method to download assets asynchronously. After completion, scene is automatically reloaded /// if new assets have been downloaded. /// </summary> /// <param name="config">Current config</param> /// <param name="downloadProgress">Download progress interface - used to indicate download progress</param> /// <returns></returns> public static async Task DownloadAssetsAsync(Config config, IDownloadProgress downloadProgress = null, bool forceCheck = false) { // Start background thread Task.Run(async() => { // Mutual exclusion while loading assets await AssetsDownloader.semaphoreSlim.WaitAsync(); // Attach / detatch JNI. Required for any calls into JNI from background threads. AndroidJNI.AttachCurrentThread(); try { // Download assets from repos. AssetsDownloader assetsDownloader = new AssetsDownloader(); return(await assetsDownloader.DownloadFromReposAsync(config, downloadProgress, forceCheck)); } finally { AssetsDownloader.semaphoreSlim.Release(); AndroidJNI.DetachCurrentThread(); } }).ContinueWith((downloadedAssets) => { if (downloadedAssets.Result) { // We downloaded new assets, so re-load the scene Debug.Log("Downloaded new assets. Re-populating panel"); SceneManager.LoadSceneAsync(SceneManager.GetActiveScene().name); } }); }
private async Task ExtractContents(ICollection <ZipArchiveEntry> entries, string destination, IEntry baseEntry = null, IDownloadProgress progressObserver = null) { var total = entries.Count; var copied = 0; foreach (var entry in entries) { var filePath = entry.Key.Substring(baseEntry?.Key.Length ?? 0); var destFile = Path.Combine(destination, filePath.Replace("/", "\\")); var dir = Path.GetDirectoryName(destFile); if (!fileSystemOperations.DirectoryExists(dir)) { fileSystemOperations.CreateDirectory(dir); } using (var destStream = File.Open(destFile, FileMode.OpenOrCreate)) using (var stream = entry.OpenEntryStream()) { await stream.CopyToAsync(destStream); copied++; progressObserver?.Percentage.OnNext(copied / (double)total); } } progressObserver?.Percentage.OnNext(double.NaN); }
public async Task Download(string url, string path, IDownloadProgress progressObserver = null, int timeout = 30) { using (var fileStream = File.OpenWrite(path)) { await Download(url, fileStream, progressObserver, timeout); } }
private void OnMediaDownloaderProgressChanged(IDownloadProgress obj) { string content; switch (obj.Status) { case DownloadStatus.NotStarted: content = "Not Started"; break; case DownloadStatus.Downloading: content = "downloading the file..."; break; case DownloadStatus.Failed: content = "download failed"; break; case DownloadStatus.Completed: content = "download completed"; break; default: throw new ArgumentOutOfRangeException(); } MessagingCenter.Send(new DownloadStatusModel() { DownloadStatus = content }, "DownloadStatus"); }
static void Download_ProgressChanged(IDownloadProgress progress) { switch (progress.Status) { case DownloadStatus.Downloading: { Console.WriteLine(progress.BytesDownloaded); break; } case DownloadStatus.Completed: { Console.WriteLine("Download complete."); // Hoàn thành việc tải file xuống MemoryStream thì thực hiện việc chuyển MemoryStream ra FileStream thực tế break; } case DownloadStatus.Failed: { MessageBox.Show("Download failed. Try again"); break; } } }
private async Task Download(string url, Stream destination, IDownloadProgress progressObserver = null, int timeout = 30) { long?totalBytes = 0; long bytesWritten = 0; await ObservableMixin.Using(() => client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead), s => { totalBytes = s.Content.Headers.ContentLength; if (!totalBytes.HasValue) { progressObserver?.Percentage.OnNext(double.PositiveInfinity); } return(ObservableMixin.Using(() => s.Content.ReadAsStreamAsync(), contentStream => contentStream.ReadToEndObservable())); }) .Do(bytes => { bytesWritten += bytes.Length; if (totalBytes.HasValue) { progressObserver?.Percentage.OnNext((double)bytesWritten / totalBytes.Value); } progressObserver?.BytesDownloaded?.OnNext(bytesWritten); }) .Timeout(TimeSpan.FromSeconds(timeout)) .Select(bytes => Observable.FromAsync(async() => { await destination.WriteAsync(bytes, 0, bytes.Length); return(Unit.Default); })) .Merge(1); }
private async Task Run(string args, IDownloadProgress progressObserver) { var dismName = WindowsCommandLineUtils.Dism; ISubject <string> outputSubject = new Subject <string>(); IDisposable stdOutputSubscription = null; if (progressObserver != null) { stdOutputSubscription = outputSubject .Select(GetPercentage) .Where(d => !double.IsNaN(d)) .Subscribe(progressObserver.Percentage); } Log.Verbose("We are about to run DISM: {ExecName} {Parameters}", dismName, args); var resultCode = await ProcessUtils.RunProcessAsync(dismName, args, outputSubject); progressObserver?.Percentage.OnNext(double.NaN); if (resultCode != 0) { throw new DeploymentException( $"There has been a problem during deployment: DISM exited with code {resultCode}."); } stdOutputSubscription?.Dispose(); }
public AdvancedViewModel(ISettingsService settingsService, IFileSystemOperations fileSystemOperations, UIServices uiServices, IProviderBasedWindowsDeployer deployer, IDiskLayoutPreparer preparer, IWindowsOptionsProvider optionsProvider, IDeviceProvider deviceProvider, IDownloadProgress progress, StatusViewModel statusViewModel, IPhone phone) { StatusViewModel = statusViewModel; this.settingsService = settingsService; this.uiServices = uiServices; this.deployer = deployer; this.preparer = preparer; this.optionsProvider = optionsProvider; this.deviceProvider = deviceProvider; this.progress = progress; this.phone = phone; sizeReservedForWindows = this.WhenAnyValue(x => x.GbsReservedForWindows, ByteSize.FromGigaBytes) .ToProperty(this, x => x.SizeReservedForWindows); DeleteDownloadedWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(() => DeleteDownloaded(fileSystemOperations)), uiServices.Dialog); ForceDualBootWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(ForceDualBoot), uiServices.Dialog); ForceDisableDualBootWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(ForceDisableDualBoot), uiServices.Dialog); BackupCommandWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(Backup), uiServices.Dialog); RestoreCommandWrapper = new CommandWrapper <Unit, Unit>(this, ReactiveCommand.CreateFromTask(Restore), uiServices.Dialog); IsBusyObservable = Observable.Merge(new [] { DeleteDownloadedWrapper.Command.IsExecuting, BackupCommandWrapper.Command.IsExecuting, RestoreCommandWrapper.Command.IsExecuting, ForceDualBootWrapper.Command.IsExecuting, ForceDisableDualBootWrapper.Command.IsExecuting, }); }
private static async Task Execute(IEnumerable <string> args, IDownloadProgress progress) { var optionsProvider = new WindowsDeploymentOptionsProvider(); var deployer = GetDeployer(optionsProvider, progress); var parserResult = Parser.Default .ParseArguments <WindowsDeploymentCmdOptions, EnableDualBootCmdOptions, DisableDualBootCmdOptions, NonWindowsDeploymentCmdOptions>(args); await parserResult .MapResult( (WindowsDeploymentCmdOptions opts) => { optionsProvider.Options = new WindowsDeploymentOptions() { ImageIndex = opts.Index, ImagePath = opts.WimImage, SizeReservedForWindows = ByteSize.FromGigaBytes(opts.ReservedSizeForWindowsInGb), UseCompact = opts.UseCompact, }; return(deployer.Deploy()); }, (EnableDualBootCmdOptions opts) => deployer.ToggleDualBoot(true), (DisableDualBootCmdOptions opts) => deployer.ToggleDualBoot(false), (NonWindowsDeploymentCmdOptions opts) => deployer.Deploy(), HandleErrors); }
public DeployWindows(IDeviceProvider deviceProvider, IDiskLayoutPreparer preparer, IProviderBasedWindowsDeployer providerBasedWindowsDeployer, IDownloadProgress progressObserver) { this.deviceProvider = deviceProvider; this.preparer = preparer; this.providerBasedWindowsDeployer = providerBasedWindowsDeployer; this.progressObserver = progressObserver; }
public async Task Capture(string destination, IDownloadProgress progressObserver) { Log.Information("Preparing for Windows backup..."); var device = deviceProvider.Device; await deployer.Backup(await device.GetWindowsVolume(), destination, progressObserver); }
private void OnDownloadProgress( IDownloadProgress downloadProgress, ulong totalSize, IGcsFileOperationCallback operation) { operation.Progress((double)downloadProgress.BytesDownloaded / totalSize); }
/// <summary> /// Download assets from repos. The download manifest is also updated. /// </summary> /// <param name="manifest">Download manifest</param> /// <param name="assetsInfo">Assets to download</param> /// <param name="downloadProgress">Download progress interface</param> /// <returns></returns> private async Task <bool> DownloadFromReposInternalAsync( AssetsManifest manifest, Dictionary <string, AssetInfo> assetsInfo, IDownloadProgress downloadProgress = null) { var downloadedAsset = false; foreach (var entry in assetsInfo) { // Download asset var success = await DownloadAssetFromGitHubRepoAsync(entry.Key, entry.Value, downloadProgress); if (success) { // Update manifest manifest.Metadata[entry.Key] = entry.Value; downloadedAsset = true; } } if (downloadedAsset) { // Persist manifest SaveManifest(manifest); } return(downloadedAsset); }
private void Download_ProgressChanged(IDownloadProgress progress) { label1.Invoke(new Action(() => label1.Text = String.Format("{0:0.00} MB", progress.BytesDownloaded / 1048576.0))); //progressBar1.Invoke(new Action(() => progressBar1.Value = (int)(((double)progress.BytesDownloaded / size) * 100))); }
private static IWoaDeployer GetDeployer(WindowsDeploymentOptionsProvider op, IDownloadProgress progress) { var container = CompositionRoot.CreateContainer(op, progress); var deployer = container.Locate <IWoaDeployer>(); return(deployer); }
public async Task Deploy(WindowsDeploymentOptions options, IDevice device, IDownloadProgress progressObserver) { Log.Information("Applying Windows Image"); progressObserver.Percentage.OnNext(double.NaN); await imageService.ApplyImage(await device.GetWindowsVolume(), options.ImagePath, options.ImageIndex, options.UseCompact, progressObserver); await MakeBootable(device); }
private void Download_ProgressChanged(IDownloadProgress progress) { if (isStarting == true) { System.Diagnostics.Process.Start("C:\\Img_0226.MOV"); isStarting = false; } Console.WriteLine(progress.Status + " " + progress.BytesDownloaded); }
/// <summary> /// Asynchronously download assets from configured repos. /// </summary> /// <param name="config">Current config</param> /// <param name="downloadProgress">Download progress interface</param> /// <returns></returns> private async Task <bool> DownloadFromReposAsync(Config config, IDownloadProgress downloadProgress = null, bool forceCheck = false) { if (null == config.downloadRepos) { // No repos configured, so return return(false); } // Load the download manifest. This is used to compare if we're up-to-date or not. AssetsManifest manifest = LoadManifest(); if (null == manifest) { manifest = new AssetsManifest(); } // Rate limit update checks to one per couple of minutes, to avoid GitHub's rate limit if (!forceCheck && DateTime.Now.Subtract(manifest.LastUpdated).TotalMinutes < RateLimitInMins) { Debug.LogFormat("Exceeded rate limit of {0} mins - last checked for update on {1}", RateLimitInMins, manifest.LastUpdated); return(false); } // Mark that we've just checked for updates & update manifest manifest.LastUpdated = DateTime.Now; SaveManifest(manifest); if (null != downloadProgress) { downloadProgress.OnCheckingForUpdates(); } // Download the assets metadata - used to determine whether we are up-to-date or not var assetsInfo = await DownloadAssetsMetadata(config, manifest, downloadProgress, forceCheck); if (assetsInfo.Count == 0) { // No updates have been found, so return Debug.Log("No updates found"); if (null != downloadProgress) { downloadProgress.OnNoUpdatesAvailable(); } return(false); } // Download the assets var downloadedAssets = await DownloadFromReposInternalAsync(manifest, assetsInfo, downloadProgress); if (null != downloadProgress) { downloadProgress.OnUpdateFinish(); } return(downloadedAssets); }
/// <summary> /// Updates the current progress and call the <see cref="ProgressChanged"/> event to notify listeners. /// </summary> private void UpdateProgress(IDownloadProgress progress) { var changed = ProgressChanged; if (changed != null) { changed(progress); } }
public FetchAzureDevOpsArtifact(string descriptor, IAzureDevOpsBuildClient buildClient, IZipExtractor extractor, IDownloader downloader, IDownloadProgress progressObserver) { ParseDescriptor(descriptor); this.buildClient = buildClient; this.extractor = extractor; this.downloader = downloader; this.progressObserver = progressObserver; }
public async Task <Stream> GetStream(string url, IDownloadProgress progress = null, int timeout = 30) { var tmpFile = Path.Combine(Path.GetTempPath(), Path.GetTempFileName()); var stream = File.Create(tmpFile, BufferSize, FileOptions.DeleteOnClose); await Download(url, stream, progress, timeout); return(stream); }
public async Task ExtractToFolder(Stream stream, string destination, IDownloadProgress progressObserver = null) { await ExtractCore(stream, destination, zipArchive => { var contents = zipArchive.Entries.Where(x => !x.IsDirectory); return(contents); }, progressObserver : progressObserver); }
public static string DownloadFileToTemp(string remoteFilename, IDownloadProgress progress) { var localFilePath = Path.GetTempFileName(); if (DownloadFile(remoteFilename, localFilePath, progress)) { return(localFilePath); } return(string.Empty); }
public Fetch(string url, string destination, IZipExtractor extractor, IFileSystemOperations fileSystemOperations, IDownloader downloader, IDownloadProgress progressObserver) { this.url = url; this.destination = destination; this.extractor = extractor; this.fileSystemOperations = fileSystemOperations; this.downloader = downloader; this.progressObserver = progressObserver; }
/// <inheritdoc/> public async Task SendDownloadProgressUpdate(IDownloadProgress downloadProgress) { if (_progressHub?.Clients?.All == null) { Log.Error("No Clients connected to ProgressHub"); return; } await _progressHub.Clients.All.SendAsync("DownloadProgress", downloadProgress); }
public void Download(DownloadInfo di, IDownloadProgress dpClient) { stop = false; this.dpClient = dpClient; this.di = di; if (di.Link.ScrapState == LinkScrapState.FullyLoaded) OnScrapVideoDetailsCompleted(di.Link); else new ScraperService().ScrapVideosDetailsAsync(this, di.Link); }
public FetchGitHubFolder(string url, string relativePath, string destination, IZipExtractor zipExtractor, IFileSystemOperations fileSystemOperations, IDownloader downloader, IDownloadProgress progressObserver) { this.url = url; this.relativePath = relativePath; this.destination = destination; this.zipExtractor = zipExtractor; this.fileSystemOperations = fileSystemOperations; this.downloader = downloader; this.progressObserver = progressObserver; }
private static void DownloadFile(string fileId, string targetDirectory) { FilesResource.GetRequest request = driveService.Files.Get(fileId); request.Fields = "size,name,id,md5Checksum"; GoogleFile fileinfo = request.Execute(); var stream = new MemoryStream(); IDownloadProgress progress = request.DownloadWithStatus(stream); EditorCoroutineUtility.StartCoroutine(DownloadRoutine(progress, stream, fileId, fileinfo.Name, fileinfo.Size.Value, targetDirectory), Instance); WriteTasks.TryAdd(fileId, false); }
public async Task ExtractRelativeFolder(Stream stream, string relativeZipPath, string destination, IDownloadProgress progressObserver = null) { await ExtractCore(stream, destination, zipArchive => { var baseEntry = relativeZipPath; var contents = zipArchive.Entries.Where(x => x.Key.StartsWith(baseEntry) && !x.IsDirectory); return(contents); }, progressObserver : progressObserver); }
public async Task ExtractFirstChildToFolder(Stream stream, string destination, IDownloadProgress progressObserver = null) { await ExtractCore(stream, destination, zipArchive => { var baseEntry = FirstChild(zipArchive.Entries); var contents = zipArchive.Entries.Where(x => x.Key.StartsWith(baseEntry.Key) && !x.IsDirectory); return(contents); }, FirstChild, progressObserver); }
public FetchGitHubLatestReleaseAsset(string repoUrl, string assetName, IZipExtractor extractor, IGitHubClient gitHubClient, IDownloader downloader, IDownloadProgress progressObserver) { this.repoUrl = repoUrl ?? throw new ArgumentNullException(nameof(repoUrl)); this.assetName = assetName ?? throw new ArgumentNullException(nameof(assetName)); this.extractor = extractor ?? throw new ArgumentNullException(nameof(extractor)); this.gitHubClient = gitHubClient; this.downloader = downloader; this.progressObserver = progressObserver; folderPath = Path.Combine(SubFolder, Path.GetFileNameWithoutExtension(assetName)); }
protected void DriveService_ProgressChanged(IDownloadProgress downloadProgress) { try { var status = StatusType.NotStarted; long bytesProcessed = downloadProgress.BytesDownloaded; long totalBytes = FileSize; Exception processException = downloadProgress.Exception; if (downloadProgress.Status == DownloadStatus.Completed) { status = StatusType.Completed; } else if (downloadProgress.Status == DownloadStatus.Downloading) { status = StatusType.Processing; } else if (downloadProgress.Status == DownloadStatus.Failed) { status = StatusType.Failed; } else { status = StatusType.Starting; } UpdateProgress(status, bytesProcessed, totalBytes, processException); if (_Status == StatusType.Failed && String.IsNullOrEmpty(_ExceptionMessage)) { Debugger.Break(); } if (Processed) { try { if (Completed) { if (!String.IsNullOrEmpty(_DownloadFilePath)) { if (!String.Equals(_DownloadFilePath, _FileInfo.FilePath, StringComparison.CurrentCultureIgnoreCase)) { API.DriveService.MoveFile(_DownloadFilePath, _FileInfo.FilePath); _DownloadFilePath = ""; } } } else { if (!String.IsNullOrEmpty(_DownloadFilePath)) { API.DriveService.DeleteFile(_DownloadFilePath); _DownloadFilePath = ""; } _DriveService.CleanupFile(_FileInfo, true); } } catch (Exception exception) { Log.Error(exception, false); if (!Failed) { _ExceptionMessage = exception.Message; _Status = StatusType.Failed; } } try { if (Completed) { _LastWriteTime = API.DriveService.GetFileLastWriteTime(FilePath); if (!API.DriveService.IsDateTimeEqual(_LastWriteTime, _FileInfo.ModifiedDate)) { _LastWriteTime = API.DriveService.SetFileLastWriteTime(FilePath, _FileInfo.ModifiedDate); } } } catch (Exception exception) { Log.Error(exception, false); if (!Failed) { _ExceptionMessage = exception.Message; _Status = StatusType.Failed; } } } if (_Status == StatusType.Failed && String.IsNullOrEmpty(_ExceptionMessage)) { Debugger.Break(); } InvokeOnProgressEvent(); } catch (Exception exception) { Log.Error(exception, false); } }
static void Download_ProgressChanged(IDownloadProgress progress) { Console.WriteLine(progress.Status + " " + progress.BytesDownloaded + " bytes"); }
private void CheckForError(IDownloadProgress downloadProgress) { if (downloadProgress.Status == DownloadStatus.Failed || downloadProgress.Exception != null) { GoogleApiException googleApiException = downloadProgress.Exception as GoogleApiException; if (googleApiException != null && googleApiException.HttpStatusCode == HttpStatusCode.NotFound) { ErrorRecord errorRecord = new ErrorRecord( new ItemNotFoundException($"Storage object '{ObjectName}' does not exist."), "ObjectNotFound", ErrorCategory.ObjectNotFound, ObjectName); ThrowTerminatingError(errorRecord); } // Default to just throwing the exception we get. throw downloadProgress.Exception; } }
/// <summary> /// Updates the current progress and call the <see cref="ProgressChanged"/> event to notify listeners. /// </summary> private void UpdateProgress(IDownloadProgress progress) { ProgressChanged?.Invoke(progress); }