public async Task CheckPrepareUpdateAsync() { if (!_settingsService.IsAutoUpdateEnabled) { return; } try { var check = await _updateManager.CheckForUpdatesAsync(); if (!check.CanUpdate || check.LastVersion is null) { return; } if (check.LastVersion != TryGetLastPreparedUpdate()) { await _updateManager.PrepareUpdateAsync(check.LastVersion); } } catch { // Failure to check for updates shouldn't crash the app } }
public async void CheckForUpdate() { var check = await _updateManager.CheckForUpdatesAsync(); // If there are none, notify user and return if (!check.CanUpdate) { return; } else { System.Windows.Forms.MessageBox.Show("There are updates available."); } // Prepare the latest update await _updateManager.PrepareUpdateAsync(check.LastVersion); // Launch updater and exit _updateManager.LaunchUpdater(check.LastVersion); if (System.Diagnostics.Process.GetProcessesByName(System.IO.Path.GetFileNameWithoutExtension(System.Reflection.Assembly.GetEntryAssembly().Location)).Count() > 0) { //System.Windows.MessageBox.Show("Closed to update", "WallEngine Updater", System.Windows.MessageBoxButton.OK); System.Diagnostics.Process.GetCurrentProcess().Kill(); } }
public async Task <Version> CheckPrepareUpdateAsync() { // If auto-update is disabled - don't check for updates if (!_settingsService.IsAutoUpdateEnabled) { return(null); } // Cleanup leftover files _manager.Cleanup(); // Check for updates var check = await _manager.CheckForUpdatesAsync(); if (!check.CanUpdate) { return(null); } // Prepare the update if (!_manager.IsUpdatePrepared(check.LastVersion)) { await _manager.PrepareUpdateAsync(check.LastVersion); } return(_updateVersion = check.LastVersion); }
public async Task <Version?> CheckPrepareUpdateAsync() { if (!_settingsService.IsAutoUpdateEnabled) { return(null); } try { // Check for updates var check = await _updateManager.CheckForUpdatesAsync(); if (!check.CanUpdate || check.LastVersion == null) { return(null); } // Prepare update if (check.LastVersion != GetLastPreparedUpdate()) { await _updateManager.PrepareUpdateAsync(check.LastVersion); } return(check.LastVersion); } catch { // Failure to check for updates shouldn't crash the app return(null); } }
private async void checkForUpdatesButton_Click(object sender, EventArgs e) { // Check for updates var check = await updateManager.CheckForUpdatesAsync(); // If there are none, notify user and return if (!check.CanUpdate) { MessageBox.Show("There are no updates available."); return; } else { DialogResult result = MessageBox.Show( $"There is an update available. Your current version is {currentVersion}, the latest version is {check.LastVersion}. Would you like to update to the latest version?", "Update Available", MessageBoxButtons.YesNo ); if (result == DialogResult.Yes) { // Prepare the latest update await updateManager.PrepareUpdateAsync(check.LastVersion); // Launch updater and exit updateManager.LaunchUpdater(check.LastVersion); Application.Exit(); } } }
public async Task <bool> CheckForUpdatesAsync() { // Check for updates var check = await _updateManager.CheckForUpdatesAsync(); return(check.CanUpdate); }
public async Task <Version> CheckPrepareUpdateAsync() { try { // If auto-update is disabled - don't check for updates if (!_settingsService.IsAutoUpdateEnabled) { return(null); } // Check for updates var check = await _updateManager.CheckForUpdatesAsync(); if (!check.CanUpdate) { return(null); } // Prepare the update await _updateManager.PrepareUpdateAsync(check.LastVersion); return(_updateVersion = check.LastVersion); } catch (UpdaterAlreadyLaunchedException) { return(null); } catch (LockFileNotAcquiredException) { return(null); } }
public async Task <Version> CheckPrepareUpdateAsync() { try { // Check for updates var check = await _updateManager.CheckForUpdatesAsync(); if (!check.CanUpdate) { return(null); } // Prepare the update await _updateManager.PrepareUpdateAsync(check.LastVersion); return(_updateVersion = check.LastVersion); } catch (UpdaterAlreadyLaunchedException) { return(null); } catch (LockFileNotAcquiredException) { return(null); } }
public async Task <Version?> CheckPrepareUpdateAsync() { try { // Check for updates var check = await _updateManager.CheckForUpdatesAsync(); if (!check.CanUpdate) { return(null); } // Prepare update if (check.LastVersion != GetLastPreparedUpdate()) { await _updateManager.PrepareUpdateAsync(check.LastVersion); } return(check.LastVersion); } catch { // Failure to check for updates shouldn't crash the app return(null); } }
public async void CheckForUpdates(bool initiatedByUser) { UpdateCheckStarted?.Invoke(this, initiatedByUser); CheckForUpdatesResult = await updateManager.CheckForUpdatesAsync(); UpdateCheckFinished?.Invoke(this, CheckForUpdatesResult, initiatedByUser); }
public async Task <Version?> CheckForUpdatesAsync() { if (!_settingsService.IsAutoUpdateEnabled) { return(null); } var check = await _updateManager.CheckForUpdatesAsync(); return(check.CanUpdate ? check.LastVersion : null); }
private async void Populate() { if (_checkForUpdates) { await _updateManager.CheckForUpdatesAsync(); } var releases = _updateManager.Releases .Where(r => _settings.IncludePrereleaseUpdates || !r.IsPrerelease) .OrderByDescending(r => r.Version) .SkipWhile(r => String.IsNullOrWhiteSpace(r.DownloadUrl)).ToList(); releases.ForEach(_releases.Add); IsUpdating = false; IsUpToDate = _releases.All(r => !r.IsNew); CanUpdate = _releases.Any(r => r.IsNew); }
/// <summary> /// Checks for new version and performs an update if available. /// </summary> public static async Task CheckPerformUpdateAsync(this IUpdateManager manager, bool restart = true, IProgress <double>?progress = null, CancellationToken cancellationToken = default) { // Check var result = await manager.CheckForUpdatesAsync(cancellationToken); if (!result.CanUpdate || result.LastVersion == null) { return; } // Prepare await manager.PrepareUpdateAsync(result.LastVersion, progress, cancellationToken); // Apply manager.LaunchUpdater(result.LastVersion, restart); // Exit Environment.Exit(0); }
public ShellViewModel(ISettings settings, IDialogManager dialogManager, IFlyoutManager flyoutManager, IUpdateManager updateManager, IViewModelFactory viewModelFactory, IMostRecentUsedFoldersRepository mostRecentUsedFoldersRepository) { _settings = settings; _dialogManager = dialogManager; _flyoutManager = flyoutManager; _updateManager = updateManager; _viewModelFactory = viewModelFactory; _mostRecentUsedFoldersRepository = mostRecentUsedFoldersRepository; _projectRepository = _viewModelFactory.CreateProjectRepositoryViewModel(new RelayCommand<ProjectViewModel>(projectViewModel => _solution.AddProject(projectViewModel.Project))); _updateManager.UpdatesAvailable += (sender, args) => AreUpdatesAvailable = _updateManager.Releases != null && _updateManager.Releases.Any(r => r.IsNew && (_settings.IncludePrereleaseUpdates || !r.IsPrerelease)); _showUpdatesCommand = new RelayCommand<bool>(checkForUpdates => _flyoutManager.ShowFlyout(_viewModelFactory.CreateUpdateViewModel(checkForUpdates))); _showSettingsCommand = new RelayCommand(OnShowSettings); _showAboutCommand = new RelayCommand(() => _flyoutManager.ShowFlyout(_viewModelFactory.CreateAboutViewModel())); _selectRootPathCommand = new AsyncRelayCommand(SelectRootPath); _setRootPathCommand = new AsyncRelayCommand<string>(LoadProjectsAsync, path => !String.Equals(path, RootPath)); _updateTimer = new Timer(_ => _updateManager.CheckForUpdatesAsync(), null, -1, -1); }
public ShellViewModel(ISettings settings, IDialogManager dialogManager, IFlyoutManager flyoutManager, IUpdateManager updateManager, IViewModelFactory viewModelFactory, IMostRecentUsedFoldersRepository mostRecentUsedFoldersRepository) { _settings = settings; _dialogManager = dialogManager; _flyoutManager = flyoutManager; _updateManager = updateManager; _viewModelFactory = viewModelFactory; _mostRecentUsedFoldersRepository = mostRecentUsedFoldersRepository; _projectRepository = _viewModelFactory.CreateProjectRepositoryViewModel(new RelayCommand <ProjectViewModel>(projectViewModel => _solution.AddProject(projectViewModel.Project))); _updateManager.UpdatesAvailable += (sender, args) => AreUpdatesAvailable = _updateManager.Releases != null && _updateManager.Releases.Any(r => r.IsNew && (_settings.IncludePrereleaseUpdates || !r.IsPrerelease)); ShowUpdatesCommand = new RelayCommand <bool>(checkForUpdates => _flyoutManager.ShowFlyout(_viewModelFactory.CreateUpdateViewModel(checkForUpdates))); ShowSettingsCommand = new RelayCommand(OnShowSettings); ShowAboutCommand = new RelayCommand(() => _flyoutManager.ShowFlyout(_viewModelFactory.CreateAboutViewModel())); SelectRootPathCommand = new AsyncRelayCommand(SelectRootPath); SetRootPathCommand = new AsyncRelayCommand <string>(LoadProjectsAsync, path => !String.Equals(path, RootPath)); _updateTimer = new Timer(_ => _updateManager.CheckForUpdatesAsync(), null, -1, -1); }
public async Task <Version> CheckPrepareUpdateAsync() { // Cleanup leftover files _updateManager.Cleanup(); // Check for updates var check = await _updateManager.CheckForUpdatesAsync(); if (!check.CanUpdate) { return(null); } // Prepare the update if (!_updateManager.IsUpdatePrepared(check.LastVersion)) { await _updateManager.PrepareUpdateAsync(check.LastVersion); } return(_updateVersion = check.LastVersion); }
/// <summary> /// Checks for new version and performs an update if available. /// </summary> public static async Task CheckPerformUpdateAsync(this IUpdateManager manager, bool restart = true, IProgress <double> progress = null, CancellationToken cancellationToken = default(CancellationToken)) { manager.GuardNotNull(nameof(manager)); // Check var result = await manager.CheckForUpdatesAsync().ConfigureAwait(false); if (!result.CanUpdate) { return; } // Prepare await manager.PrepareUpdateAsync(result.LastVersion, progress, cancellationToken).ConfigureAwait(false); // Apply manager.LaunchUpdater(result.LastVersion, restart); // Exit Environment.Exit(0); }
private async Task <bool> PrepareUpdateAsync() { var check = await _updateManager.CheckForUpdatesAsync(); if (check.CanUpdate) { try { await _updateManager.PrepareUpdateAsync(check.LastVersion); } catch (Exception e) when(e is UpdaterAlreadyLaunchedException || e is LockFileNotAcquiredException) { // Ignore race conditions return(false); } return(true); } return(false); }
public async Task <Version> CheckForUpdateAsync() { // If auto-update is disabled - don't check for updates if (!_settingsService.IsAutoUpdateEnabled) { return(null); } #if DEBUG // Never update in DEBUG mode return(null); #endif // Check for updates var check = await _manager.CheckForUpdatesAsync(); if (!check.CanUpdate) { return(null); } return(_updateVersion = check.LastVersion); }
private async void CheckForUpdates() { label.Text = LABEL_CHECKING; button.Enabled = false; checkForUpdatesResult = await updateManager.CheckForUpdatesAsync(); if (checkForUpdatesResult.CanUpdate) { label.Text = LABEL_UPDATE_AVAILABLE; button.Text = BUTTON_UPDATE_NOW; button.Enabled = true; } else { new Thread(() => { Thread.Sleep(500); Invoke((MethodInvoker) delegate() { label.Text = LABEL_NO_UPDATES; button.Text = BUTTON_CHECK_FOR_UPDATES; button.Enabled = true; }); }).Start(); } }
#pragma warning disable 612, 618 /// <summary> /// Check for available updates asynchronously. /// </summary> /// <param name="this">The this.</param> /// <param name="autoShowUi">Use the default update dialogs</param> /// <param name="shutdownActions">Callback to gracefully stop your application. If using default-ui, call has to be provided.</param> /// <param name="updateAvailableAction">Callback for available versions, if you want to provide own update dialogs</param> /// <returns></returns> public static async Task <bool> CheckForUpdatesAsync(this IHockeyClient @this, bool autoShowUi, Func <bool> shutdownActions = null, Action <IAppVersion> updateAvailableAction = null) { @this.AsInternal().CheckForInitialization(); return(await UpdateManager.CheckForUpdatesAsync(autoShowUi, shutdownActions, updateAvailableAction)); }
public async Task <bool> CanPerformUpdateAsync() => (await _updateManager.CheckForUpdatesAsync()).CanUpdate;
public async Task <Version?> CheckForUpdatesAsync() { var check = await _updateManager.CheckForUpdatesAsync(); return(check.CanUpdate ? check.LastVersion : null); }