Add SpeedTestApp functionality: Implement lifecycle management for speed tests, including start and stop operations, state management, and error handling. Introduce UI components for configuration and results display, enhancing user interaction and experience.

sh1ftd · sh1ftd · commit c7540256bc1f · 2025-09-26T16:05:09.000+02:00
diff --git a/src/ui/app/lifecycle.rs b/src/ui/app/lifecycle.rs
@@ -0,0 +1,75 @@
+use super::super::test_management::start_test;
+
+use super::state::SpeedTestApp;
+use crate::ui::console::log_to_console;
+
+impl SpeedTestApp {
+    pub fn start_test_impl(&mut self) {
+        self.is_running = true;
+        self.error_message = None;
+        self.show_error_modal = false;
+        self.error_modal_message.clear();
+        self.results.lock().unwrap().clear();
+        self.current_throughput = 0.0;
+        self.current_reads = 0;
+        self.current_latency = 0.0;
+        self.max_throughput = 0.0;
+        self.test_start_time = Some(std::time::Instant::now());
+        self.overall_test_start_time = Some(std::time::Instant::now());
+        self.test_end_time = None;
+        self.current_test_size = None;
+        self.completed_chunks.clear();
+
+        let (modal_tx, modal_rx) = std::sync::mpsc::channel::<String>();
+        let (stats_tx, stats_rx) = tokio::sync::mpsc::channel(100);
+        self.stats_rx = Some(stats_rx);
+        self.modal_rx = Some(modal_rx);
+
+        match start_test(
+            self.connector,
+            self.pcileech_device.clone(),
+            self.duration,
+            &self.test_sizes,
+            &self.console,
+            modal_tx,
+            stats_tx,
+        ) {
+            Ok(test) => {
+                self.test = Some(test);
+            }
+            Err(error_msg) => {
+                log_to_console(&self.console, &error_msg);
+                self.show_error_modal = true;
+                self.error_modal_message = error_msg;
+                self.is_running = false;
+                self.show_config = true;
+                self.modal_rx = None;
+            }
+        }
+    }
+
+    pub fn stop_test_impl(&mut self) {
+        self.is_running = false;
+        self.test = None;
+        self.stats_rx = None;
+
+        if let Some(overall_start_time) = self.overall_test_start_time {
+            let final_time = overall_start_time.elapsed().as_secs_f64();
+            self.test_end_time = Some(final_time);
+
+            if let Some(current_size) = self.current_test_size
+                && !self
+                    .completed_chunks
+                    .iter()
+                    .any(|(s, _)| *s == current_size)
+            {
+                self.completed_chunks.push((current_size, final_time));
+            }
+        }
+        self.test_start_time = None;
+        self.overall_test_start_time = None;
+        self.current_test_size = None;
+        self.modal_rx = None;
+        log_to_console(&self.console, "Test stopped");
+    }
+}
diff --git a/src/ui/app/mod.rs b/src/ui/app/mod.rs
@@ -0,0 +1,5 @@
+mod lifecycle;
+mod state;
+mod update;
+
+pub use state::SpeedTestApp;
diff --git a/src/ui/app/state.rs b/src/ui/app/state.rs
@@ -0,0 +1,101 @@
+use std::sync::{Arc, Mutex};
+use std::time::Instant;
+
+use tokio::sync::mpsc;
+
+use crate::speedtest::{Connector, SpeedTest};
+use crate::ui::console::ConsoleWindow;
+
+use super::super::constants::DEFAULT_PLOT_HEIGHT;
+use super::super::constants::DEFAULT_PLOT_WIDTH;
+use super::super::types::PlotResizeDirection;
+use super::super::types::TestResults;
+
+pub struct SpeedTestApp {
+    pub connector: Connector,
+    pub pcileech_device: String,
+    pub duration: u64,
+    pub test: Option<SpeedTest>,
+    pub results: TestResults,
+    pub is_running: bool,
+    pub was_running: bool,
+    pub error_message: Option<String>,
+    pub current_throughput: f64,
+    pub current_reads: u64,
+    pub current_latency: f64,
+    pub show_config: bool,
+    #[allow(clippy::type_complexity)]
+    pub stats_rx: Option<mpsc::Receiver<(f64, u64, f64, usize, f64)>>, // (throughput, reads_per_sec, elapsed_secs, read_size, latency_us)
+    pub test_start_time: Option<Instant>,
+    pub overall_test_start_time: Option<Instant>,
+    pub test_end_time: Option<f64>,
+    pub current_test_size: Option<usize>,
+    pub completed_chunks: Vec<(usize, f64)>,
+    pub max_throughput: f64,
+    pub console: ConsoleWindow,
+    pub ui_scale: f32,
+    pub ui_scale_text: String,
+    pub test_sizes: Vec<(usize, bool)>,
+    pub show_error_modal: bool,
+    pub error_modal_message: String,
+    pub modal_rx: Option<std::sync::mpsc::Receiver<String>>,
+    pub custom_plot_width: f32,
+    pub custom_plot_height: f32,
+    pub plot_resize_start_time: Option<std::time::Instant>,
+    pub plot_resize_direction: PlotResizeDirection,
+    pub plot_resize_last_repeat: Option<std::time::Instant>,
+}
+
+impl Default for SpeedTestApp {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SpeedTestApp {
+    pub fn new() -> Self {
+        Self {
+            connector: Connector::default(),
+            pcileech_device: String::new(),
+            duration: 10,
+            test: None,
+            results: Arc::new(Mutex::new(Vec::new())), // (read_size, (throughput_points, reads_points, latency_points))
+            is_running: false,
+            was_running: false,
+            error_message: None,
+            current_throughput: 0.0,
+            current_reads: 0,
+            current_latency: 0.0,
+            show_config: true,
+            stats_rx: None,
+            test_start_time: None,
+            overall_test_start_time: None,
+            test_end_time: None,
+            current_test_size: None,
+            completed_chunks: Vec::new(),
+            max_throughput: 0.0,
+            console: ConsoleWindow::new(),
+            ui_scale: 1.0,
+            ui_scale_text: "1.0".to_string(),
+            show_error_modal: false,
+            error_modal_message: String::new(),
+            modal_rx: None,
+            custom_plot_width: DEFAULT_PLOT_WIDTH,
+            custom_plot_height: DEFAULT_PLOT_HEIGHT,
+            plot_resize_start_time: None,
+            plot_resize_direction: PlotResizeDirection::None,
+            plot_resize_last_repeat: None,
+            test_sizes: vec![
+                (512, false),    // 512 bytes
+                (1024, false),   // 1KB
+                (2048, false),   // 2KB
+                (4096, true),    // 4KB - selected by default
+                (8192, true),    // 8KB - selected by default
+                (16384, true),   // 16KB - selected by default
+                (32768, true),   // 32KB - selected by default
+                (65536, false),  // 64KB
+                (131072, false), // 128KB
+            ],
+        }
+    }
+}
diff --git a/src/ui/app/update.rs b/src/ui/app/update.rs
@@ -0,0 +1,199 @@
+use anyhow::Result;
+use eframe::egui;
+
+use crate::ui::config_panel::render_config_panel;
+use crate::ui::modal::show_modal;
+use crate::ui::results_panel::render_results_panel;
+use crate::ui::test_management::handle_stats_update;
+use crate::ui::types::{
+    ConfigParams, PlotControls, ResultsPanelParams, StatsUpdateParams, TestState,
+};
+
+use super::state::SpeedTestApp;
+
+impl SpeedTestApp {
+    pub fn run(self) -> Result<()> {
+        let options = eframe::NativeOptions {
+            window_builder: Some(Box::new(|builder| {
+                builder
+                    .with_inner_size(egui::vec2(
+                        super::super::constants::CONFIG_WINDOW_MIN_WIDTH,
+                        super::super::constants::CONFIG_WINDOW_MIN_HEIGHT,
+                    ))
+                    .with_min_inner_size(egui::vec2(
+                        super::super::constants::CONFIG_WINDOW_MIN_WIDTH,
+                        super::super::constants::CONFIG_WINDOW_MIN_HEIGHT,
+                    ))
+                    .with_max_inner_size(egui::vec2(
+                        super::super::constants::CONFIG_WINDOW_MAX_WIDTH,
+                        super::super::constants::CONFIG_WINDOW_MAX_HEIGHT,
+                    ))
+                    .with_resizable(true)
+                    .with_decorations(true)
+                    .with_title("DMA Speed Test")
+            })),
+            ..Default::default()
+        };
+
+        eframe::run_native(
+            "DMA Speed Test",
+            options,
+            Box::new(|cc| {
+                let mut fonts = egui::FontDefinitions::default();
+                egui_phosphor::add_to_fonts(&mut fonts, egui_phosphor::Variant::Regular);
+                cc.egui_ctx.set_fonts(fonts);
+
+                Ok::<Box<dyn eframe::App>, Box<dyn std::error::Error + Send + Sync>>(Box::new(self))
+            }),
+        )
+        .map_err(|e| anyhow::anyhow!("Failed to run GUI: {e}"))?;
+
+        Ok(())
+    }
+}
+
+impl eframe::App for SpeedTestApp {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        ctx.set_pixels_per_point(self.ui_scale * 1.3);
+
+        if self.is_running && !self.was_running {
+            ctx.send_viewport_cmd(egui::ViewportCommand::MinInnerSize(egui::vec2(
+                super::super::constants::TEST_WINDOW_MIN_WIDTH,
+                super::super::constants::TEST_WINDOW_MIN_HEIGHT,
+            )));
+            ctx.send_viewport_cmd(egui::ViewportCommand::MaxInnerSize(egui::vec2(
+                super::super::constants::TEST_WINDOW_MAX_WIDTH,
+                super::super::constants::TEST_WINDOW_MAX_HEIGHT,
+            )));
+            ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::vec2(
+                super::super::constants::TEST_WINDOW_MIN_WIDTH,
+                super::super::constants::TEST_WINDOW_MIN_HEIGHT,
+            )));
+        }
+        self.was_running = self.is_running;
+
+        self.console.show(ctx);
+
+        if self.show_error_modal {
+            let message = self.error_modal_message.clone();
+            let mut on_close = || {
+                self.show_error_modal = false;
+            };
+            show_modal(ctx, &message, &mut on_close);
+            if !self.show_error_modal {
+                self.error_modal_message.clear();
+            }
+            return;
+        }
+
+        if self.is_running
+            && let Some(rx) = &mut self.stats_rx
+        {
+            let mut stats_params = StatsUpdateParams {
+                current_throughput: &mut self.current_throughput,
+                current_reads: &mut self.current_reads,
+                current_latency: &mut self.current_latency,
+                current_test_size: &mut self.current_test_size,
+                test_start_time: &mut self.test_start_time,
+                max_throughput: &mut self.max_throughput,
+                completed_chunks: &mut self.completed_chunks,
+            };
+
+            let stats_closed =
+                handle_stats_update(rx, &mut stats_params, &self.results, &self.console);
+
+            if stats_closed {
+                self.stop_test_impl();
+            }
+        }
+
+        if let Some(rx) = &self.modal_rx
+            && let Ok(error_msg) = rx.try_recv()
+        {
+            self.show_error_modal = true;
+            self.error_modal_message = error_msg;
+            self.stop_test_impl();
+            self.show_config = true;
+        }
+
+        if self.show_config {
+            egui::CentralPanel::default().show(ctx, |ui| {
+                let mut should_start_test = false;
+                let mut config_params = ConfigParams {
+                    connector: &mut self.connector,
+                    pcileech_device: &mut self.pcileech_device,
+                    duration: &mut self.duration,
+                    ui_scale: &mut self.ui_scale,
+                    ui_scale_text: &mut self.ui_scale_text,
+                    test_sizes: &mut self.test_sizes,
+                    show_error_modal: &mut self.show_error_modal,
+                    error_modal_message: &mut self.error_modal_message,
+                    show_config: &mut self.show_config,
+                };
+                render_config_panel(ui, &mut config_params, || should_start_test = true);
+                if should_start_test {
+                    self.start_test_impl();
+                }
+            });
+        } else {
+            egui::CentralPanel::default().show(ctx, |ui| {
+                let mut should_stop_test = false;
+                let mut should_start_test = false;
+                let mut should_toggle_console = false;
+
+                let plot_controls = PlotControls {
+                    custom_plot_width: &mut self.custom_plot_width,
+                    custom_plot_height: &mut self.custom_plot_height,
+                    plot_resize_start_time: &mut self.plot_resize_start_time,
+                    plot_resize_direction: &mut self.plot_resize_direction,
+                    plot_resize_last_repeat: &mut self.plot_resize_last_repeat,
+                };
+
+                let test_state = TestState {
+                    is_running: self.is_running,
+                    current_throughput: self.current_throughput,
+                    current_reads: self.current_reads,
+                    current_latency: self.current_latency,
+                    current_test_size: self.current_test_size,
+                    test_start_time: self.test_start_time,
+                    test_end_time: self.test_end_time,
+                    completed_chunks: &self.completed_chunks,
+                };
+
+                let mut results_params = ResultsPanelParams {
+                    results: &self.results,
+                    duration: self.duration,
+                    plot_controls,
+                    console: &self.console,
+                    ui_scale: &mut self.ui_scale,
+                    ui_scale_text: &mut self.ui_scale_text,
+                    test_state,
+                    test_sizes: &self.test_sizes,
+                    show_config: &mut self.show_config,
+                };
+
+                render_results_panel(
+                    ui,
+                    &mut results_params,
+                    || should_stop_test = true,
+                    || should_start_test = true,
+                    &mut should_toggle_console,
+                );
+
+                if should_stop_test {
+                    self.stop_test_impl();
+                }
+                if should_start_test {
+                    self.start_test_impl();
+                }
+                if should_toggle_console {
+                    self.console.toggle();
+                }
+            });
+        }
+
+        if self.is_running {
+            ctx.request_repaint();
+        }
+    }
+}
diff --git a/src/ui/config_panel/connector_section.rs b/src/ui/config_panel/connector_section.rs
