VNOX-Client/src/ui/updater.rs

214 lines
7.6 KiB
Rust

//! Glue between the updater (`vnox_client::update`) and the settings panel.
//!
//! Slint owns no logic here: [`wire`] creates the manager, connects the panel callbacks and
//! refreshes the panel from the manager once a second. Installs are deferred while a voice
//! session is active.
use std::cell::RefCell;
use std::rc::Rc;
use std::sync::Arc;
use std::time::Duration;
use slint::ComponentHandle;
use vnox_client::update::settings::default_path;
use vnox_client::update::{Layout, UpdateConfig, UpdateManager, UpdatePhase};
use crate::AppState;
use crate::ui::i18n;
use crate::ui::slint::{MainWindow, UpdateUi};
use crate::ui::state::VoiceUiState;
/// How often the background check runs, in panel refresh ticks (one per second).
const AUTO_CHECK_TICKS: u64 = 6 * 60 * 60;
/// Text shown for an updater phase.
pub fn phase_text(phase: &UpdatePhase) -> String {
let with =
|source: &str, version: &String| i18n::format(source, &[("version", version.clone())]);
match phase {
UpdatePhase::Idle => i18n::text("Not checked yet"),
UpdatePhase::Checking => i18n::text("Checking for updates..."),
UpdatePhase::UpToDate => i18n::text("You are up to date"),
UpdatePhase::Available { version } => i18n::format(
"Version {version} is available",
&[("version", version.clone())],
),
UpdatePhase::Downloading { version } => with_downloading(version),
UpdatePhase::Ready { version } => i18n::format(
"Version {version} is downloaded and ready to install",
&[("version", version.clone())],
),
UpdatePhase::InstallDeferred { version } => i18n::format(
"Version {version} will install when the voice session ends",
&[("version", version.clone())],
),
UpdatePhase::Installing { version } => i18n::format(
"Installing version {version}",
&[("version", version.clone())],
),
UpdatePhase::Installed { version } => i18n::format(
"Version {version} is installed. Restart Vnox to use it.",
&[("version", version.clone())],
),
UpdatePhase::ManualInstallRequired { version } => {
with("Version {version} needs a manual reinstall", version)
}
UpdatePhase::Error(error) => {
i18n::format("Update failed: {error}", &[("error", error.clone())])
}
}
}
fn with_downloading(version: &str) -> String {
i18n::format(
"Downloading version {version}",
&[("version", version.to_string())],
)
}
/// Connects the updater to the settings panel. Keep the returned timer alive for as long as the
/// window lives.
pub fn wire(window: &MainWindow, state: &Rc<RefCell<AppState>>) -> slint::Timer {
let ui = window.global::<UpdateUi>();
ui.set_installed_version(vnox_client::update::CLIENT_VERSION.into());
ui.set_lnex_version(vnox_client::update::LNEX_PROTOCOL.into());
let layout = Layout::user_default();
let manager: Option<Arc<UpdateManager>> = layout
.clone()
.map(|layout| UpdateManager::new(UpdateConfig::production(layout), None, default_path()));
let timer = slint::Timer::default();
let Some(manager) = manager else {
ui.set_state_text(i18n::text("Not checked yet").into());
return timer;
};
// A staged Windows binary is swapped in before the window opens; restart into it.
if let Some(layout) = &layout
&& layout.apply_pending().unwrap_or(false)
&& let Ok(exe) = std::env::current_exe()
&& std::process::Command::new(exe)
.args(std::env::args_os().skip(1))
.spawn()
.is_ok()
{
std::process::exit(0);
}
ui.set_auto_update(manager.auto_update());
let note: Rc<RefCell<String>> = Rc::default();
{
let manager = manager.clone();
tokio::spawn(async move {
manager.startup().await;
manager.auto_pass().await;
});
}
{
let (manager, note) = (manager.clone(), note.clone());
ui.on_check(move || {
note.borrow_mut().clear();
let manager = manager.clone();
tokio::spawn(async move {
let _ = manager.check().await;
});
});
}
{
let (manager, note) = (manager.clone(), note.clone());
ui.on_download(move || {
note.borrow_mut().clear();
let manager = manager.clone();
tokio::spawn(async move {
let _ = manager.download().await;
});
});
}
{
let (manager, note) = (manager.clone(), note.clone());
ui.on_install(move || {
note.borrow_mut().clear();
let manager = manager.clone();
tokio::spawn(async move {
let _ = manager.install().await;
});
});
}
{
let (manager, note) = (manager.clone(), note.clone());
ui.on_rollback(move || {
*note.borrow_mut() = match manager.rollback() {
Ok(()) => i18n::text("Rolled back. Restart Vnox to use the previous version."),
Err(error) => {
i18n::format("Update failed: {error}", &[("error", error.to_string())])
}
};
});
}
{
let (manager, note) = (manager.clone(), note.clone());
ui.on_auto_update_changed(move |enabled| {
if let Err(error) = manager.set_auto_update(enabled) {
*note.borrow_mut() = i18n::format(
"Cannot save the update setting: {error}",
&[("error", error.to_string())],
);
}
});
}
let weak = window.as_weak();
let state = state.clone();
let mut ticks: u64 = 0;
timer.start(
slint::TimerMode::Repeated,
Duration::from_secs(1),
move || {
ticks += 1;
let Some(window) = weak.upgrade() else {
return;
};
let in_voice = {
let s = state.borrow();
s.voice_channel.is_some() || matches!(s.ui.voice, VoiceUiState::Active { .. })
};
manager.set_voice_active(in_voice);
if !in_voice && manager.install_waiting() {
let manager = manager.clone();
tokio::spawn(async move {
let _ = manager.run_deferred().await;
});
}
if ticks.is_multiple_of(AUTO_CHECK_TICKS) {
let manager = manager.clone();
tokio::spawn(async move { manager.auto_pass().await });
}
let status = manager.status();
let ui = window.global::<UpdateUi>();
let note = note.borrow();
ui.set_state_text(if note.is_empty() {
phase_text(&status.phase).into()
} else {
note.as_str().into()
});
ui.set_central_text(status.central_latest.unwrap_or_default().into());
ui.set_busy(matches!(
status.phase,
UpdatePhase::Checking
| UpdatePhase::Downloading { .. }
| UpdatePhase::Installing { .. }
));
ui.set_can_download(matches!(status.phase, UpdatePhase::Available { .. }));
ui.set_can_install(matches!(
status.phase,
UpdatePhase::Ready { .. } | UpdatePhase::InstallDeferred { .. }
));
ui.set_can_rollback(
layout
.as_ref()
.is_some_and(|layout| layout.state().previous.is_some()),
);
},
);
timer
}