//! 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>) -> slint::Timer { let ui = window.global::(); 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> = 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> = 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::(); 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 }