Files
shtil/poc/helper-tray/src-tauri/src/lib.rs
T
TMSH d663869304 feat(helper): добавлен PoC Помощника только с иконкой в трее
Tauri 2 без окна при старте, меню трея из трёх пунктов, окно создаётся
по клику и уничтожается при закрытии. Флаг --measure-scenario и
measure.ps1 для замеров ОЗУ и времени открытия по методике карты.

Refs: 1.8.1, 1.8.2
2026-11-09 22:53:25 +03:00

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();
}
});
}