214 lines
7.6 KiB
Rust
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
|
|
}
|