Tauri 2 без окна при старте, меню трея из трёх пунктов, окно создаётся по клику и уничтожается при закрытии. Флаг --measure-scenario и measure.ps1 для замеров ОЗУ и времени открытия по методике карты. Refs: 1.8.1, 1.8.2
192 lines
6.6 KiB
Rust
192 lines
6.6 KiB
Rust
use std::{
|
|
collections::HashMap,
|
|
fs::{File, OpenOptions},
|
|
io::Write,
|
|
sync::Mutex,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
use tauri::{
|
|
AppHandle, Manager, State, WebviewUrl, WebviewWindow, Wry,
|
|
menu::{IsMenuItem, Menu, MenuItem},
|
|
tray::{TrayIcon, TrayIconBuilder},
|
|
webview::WebviewWindowBuilder,
|
|
};
|
|
|
|
struct MeasureLog {
|
|
started: Instant,
|
|
file: Mutex<Option<File>>,
|
|
}
|
|
|
|
impl MeasureLog {
|
|
fn marker(&self, text: &str) {
|
|
let line = format!("[{:>7.2}s] {}", self.started.elapsed().as_secs_f64(), text);
|
|
if let Some(f) = self.file.lock().unwrap().as_mut() {
|
|
let _ = writeln!(f, "{}", line).and_then(|_| f.flush());
|
|
}
|
|
eprintln!("{}", line);
|
|
}
|
|
}
|
|
|
|
struct AppState {
|
|
tray: Mutex<Option<TrayIcon>>,
|
|
open_started: Mutex<HashMap<String, Instant>>,
|
|
window_seq: Mutex<u32>,
|
|
last_label: Mutex<Option<String>>,
|
|
measure: MeasureLog,
|
|
}
|
|
|
|
#[tauri::command]
|
|
fn first_paint(window: WebviewWindow, state: State<'_, AppState>) -> Option<u128> {
|
|
let elapsed = state
|
|
.open_started
|
|
.lock()
|
|
.unwrap()
|
|
.remove(window.label())
|
|
.map(|t| t.elapsed().as_millis());
|
|
if let Some(ms) = elapsed {
|
|
state
|
|
.measure
|
|
.marker(&format!("window-opened {} ms={}", window.label(), ms));
|
|
}
|
|
elapsed
|
|
}
|
|
|
|
fn open_window(app: &AppHandle, view: &str) {
|
|
let state = app.state::<AppState>();
|
|
let label = {
|
|
let mut seq = state.window_seq.lock().unwrap();
|
|
*seq += 1;
|
|
format!("win-{}-{}", view, *seq)
|
|
};
|
|
let title = match view {
|
|
"report" => "Сообщить о проблеме",
|
|
"tickets" => "Мои обращения",
|
|
_ => "О программе",
|
|
};
|
|
let started = Instant::now();
|
|
match WebviewWindowBuilder::new(app, &label, WebviewUrl::App("index.html".into()))
|
|
.title(title)
|
|
.inner_size(460.0, 560.0)
|
|
.build()
|
|
{
|
|
Ok(_) => {
|
|
state
|
|
.open_started
|
|
.lock()
|
|
.unwrap()
|
|
.insert(label.clone(), started);
|
|
*state.last_label.lock().unwrap() = Some(label);
|
|
}
|
|
Err(e) => state
|
|
.measure
|
|
.marker(&format!("open-failed {}: {}", label, e)),
|
|
}
|
|
}
|
|
|
|
fn close_last_window(app: &AppHandle) {
|
|
let label = app.state::<AppState>().last_label.lock().unwrap().take();
|
|
if let Some(label) = label
|
|
&& let Some(window) = app.get_webview_window(&label)
|
|
{
|
|
let _ = window.destroy();
|
|
}
|
|
}
|
|
|
|
fn build_tray(app: &AppHandle) -> tauri::Result<TrayIcon> {
|
|
let report = MenuItem::with_id(app, "report", "Сообщить о проблеме", true, None::<&str>)?;
|
|
let tickets = MenuItem::with_id(app, "tickets", "Мои обращения", true, None::<&str>)?;
|
|
let about = MenuItem::with_id(app, "about", "О программе", true, None::<&str>)?;
|
|
// Выход только в debug-сборке: в релизном Помощнике пункта «Выход» не будет.
|
|
let quit = MenuItem::with_id(app, "quit", "Выход (debug)", true, None::<&str>)?;
|
|
let items: Vec<&dyn IsMenuItem<Wry>> = if cfg!(debug_assertions) {
|
|
vec![&report, &tickets, &about, &quit]
|
|
} else {
|
|
vec![&report, &tickets, &about]
|
|
};
|
|
let menu = Menu::with_items(app, &items)?;
|
|
TrayIconBuilder::new()
|
|
.icon(app.default_window_icon().unwrap().clone())
|
|
.tooltip("Штиль Помощник (PoC)")
|
|
.menu(&menu)
|
|
.on_menu_event(|app, event| match event.id().as_ref() {
|
|
"quit" => app.exit(0),
|
|
view @ ("report" | "tickets" | "about") => open_window(app, view),
|
|
_ => {}
|
|
})
|
|
.build(app)
|
|
}
|
|
|
|
// Отметка этапа пишется заранее, чтобы measure.ps1 успел снять ОЗУ до действия:
|
|
// два CIM-запроса в скрипте занимают ~0,5 с, поэтому запас делаем больше.
|
|
fn stage_then(app: &AppHandle, name: &str, action: impl Fn(&AppHandle) + Send + 'static) {
|
|
app.state::<AppState>().measure.marker(name);
|
|
std::thread::sleep(Duration::from_millis(1500));
|
|
let app2 = app.clone();
|
|
let _ = app.run_on_main_thread(move || action(&app2));
|
|
}
|
|
|
|
fn spawn_measure_scenario(app: AppHandle) {
|
|
std::thread::spawn(move || {
|
|
let sleep = |secs: u64| std::thread::sleep(Duration::from_secs(secs));
|
|
sleep(30);
|
|
stage_then(&app, "stage open-window-1", |a| open_window(a, "report"));
|
|
sleep(10);
|
|
stage_then(&app, "stage close-window-1", close_last_window);
|
|
sleep(10);
|
|
stage_then(&app, "stage open-window-2", |a| open_window(a, "report"));
|
|
sleep(10);
|
|
stage_then(&app, "stage close-window-2", close_last_window);
|
|
app.state::<AppState>().measure.marker("stage done");
|
|
app.exit(0);
|
|
});
|
|
}
|
|
|
|
fn measure_log_file() -> Option<File> {
|
|
let dir = std::env::current_exe()
|
|
.ok()
|
|
.and_then(|p| p.parent().map(|d| d.to_path_buf()))
|
|
.unwrap_or_else(std::env::temp_dir);
|
|
OpenOptions::new()
|
|
.create(true)
|
|
.write(true)
|
|
.truncate(true)
|
|
.open(dir.join("helper-tray-poc.measure.log"))
|
|
.ok()
|
|
}
|
|
|
|
#[cfg_attr(mobile, tauri::mobile_entry_point)]
|
|
pub fn run() {
|
|
let measure = std::env::args().any(|a| a == "--measure-scenario");
|
|
let app = tauri::Builder::default()
|
|
.invoke_handler(tauri::generate_handler![first_paint])
|
|
.setup(move |app| {
|
|
app.manage(AppState {
|
|
tray: Mutex::new(None),
|
|
open_started: Mutex::new(HashMap::new()),
|
|
window_seq: Mutex::new(0),
|
|
last_label: Mutex::new(None),
|
|
measure: MeasureLog {
|
|
started: Instant::now(),
|
|
file: Mutex::new(if measure { measure_log_file() } else { None }),
|
|
},
|
|
});
|
|
let tray = build_tray(app.handle())?;
|
|
*app.state::<AppState>().tray.lock().unwrap() = Some(tray);
|
|
if measure {
|
|
app.state::<AppState>().measure.marker("stage app-started");
|
|
spawn_measure_scenario(app.handle().clone());
|
|
}
|
|
Ok(())
|
|
})
|
|
.build(tauri::generate_context!())
|
|
.expect("error while building tauri application");
|
|
// Трею нельзя завершаться при закрытии последнего окна;
|
|
// app.exit(0) при этом продолжает работать.
|
|
app.run(|_handle, event| {
|
|
if let tauri::RunEvent::ExitRequested { api, .. } = event {
|
|
api.prevent_exit();
|
|
}
|
|
});
|
|
}
|