Three levels of reconnection strictness checks instead of two!

nullstalgia · nullstalgia · commit a1279c891248 · 2026-01-25T21:21:58.000-08:00
diff --git a/src/app.rs b/src/app.rs
@@ -46,8 +46,8 @@ use crate::{
     keybinds::{Action, BaseAction, BuiltinAction, Keybinds, PortAction, ShowPopupAction},
     notifications::{EMERGE_TIME, EXPAND_TIME, EXPIRE_TIME, Notifications, PAUSE_AND_SHOW_TIME},
     serial::{
-        DeserializedUsb, PrintablePortInfo, ReconnectType, Reconnections, SerialDisconnectReason,
-        SerialEvent,
+        DeserializedUsb, PrintablePortInfo, ReconnectType, ReconnectionStrictness,
+        SerialDisconnectReason, SerialEvent,
         handle::{BlockingCommandError, SerialHandle},
         port_status::InnerPortStatus,
         worker::MOCK_PORT_NAME,
@@ -792,11 +792,16 @@ impl App {
                     }
                     SerialDisconnectReason::Error(error) => {
                         error!("Serial worker reported error on disconnect! {error}");
-                        let reconnect_text = match &self.settings.serial.reconnections {
-                            Reconnections::Disabled => "Not attempting to reconnect",
-                            Reconnections::LooseChecks => "Attempting to reconnect (loose checks)",
-                            Reconnections::StrictChecks => {
-                                "Attempting to reconnect (strict checks)"
+                        let reconnect_text = match &self.settings.serial.reconnection_strictness {
+                            ReconnectionStrictness::Disabled => "Not attempting to reconnect",
+                            ReconnectionStrictness::Low => {
+                                "Attempting to reconnect (low strictness checks)"
+                            }
+                            ReconnectionStrictness::Med => {
+                                "Attempting to reconnect (med strictness checks)"
+                            }
+                            ReconnectionStrictness::High => {
+                                "Attempting to reconnect (high strictness checks)"
                             }
                         };
                         self.notifs.notify_str(
@@ -860,8 +865,12 @@ impl App {
 
                     let port_status = &self.serial.port_status.load().status();
 
-                    let reconnections_allowed =
-                        self.serial.port_settings.load().reconnections.allowed();
+                    let reconnections_allowed = self
+                        .serial
+                        .port_settings
+                        .load()
+                        .reconnection_strictness
+                        .allowed();
                     if !port_status.is_connected()
                         && !port_status.is_lent_out()
                         && reconnections_allowed
@@ -1733,13 +1742,17 @@ impl App {
             A::Port(PortAction::DeassertRts) => {
                 self.serial.write_signals(None, Some(false))?;
             }
-            A::Port(PortAction::AttemptReconnectStrict) => {
+            A::Port(PortAction::AttemptReconnectStrictHigh) => {
+                self.serial
+                    .request_reconnect(Some(ReconnectionStrictness::High))?;
+            }
+            A::Port(PortAction::AttemptReconnectStrictMed) => {
                 self.serial
-                    .request_reconnect(Some(Reconnections::StrictChecks))?;
+                    .request_reconnect(Some(ReconnectionStrictness::Med))?;
             }
-            A::Port(PortAction::AttemptReconnectLoose) => {
+            A::Port(PortAction::AttemptReconnectStrictLow) => {
                 self.serial
-                    .request_reconnect(Some(Reconnections::LooseChecks))?;
+                    .request_reconnect(Some(ReconnectionStrictness::Low))?;
             }
             A::Base(BaseAction::ToggleTextwrap) => {
                 let state = pretty_bool(self.settings.rendering.wrap_text.flip());
@@ -1996,7 +2009,7 @@ impl App {
                 // and if auto-reconnections is disabled.
                 // (when auto-reconns. are enabled, the normal Disconnect prompt
                 // is supposed to show to act as a pause for auto-reconnections)
-                && !port_settings_guard.reconnections.allowed())
+                && !port_settings_guard.reconnection_strictness.allowed())
     }
     // fn tab_pressed(&mut self) {}
     fn esc_pressed(&mut self) {
@@ -2877,14 +2890,14 @@ impl App {
                 self.notifs
                     .notify_str("Attempting to reconnect! (Loose Checks)", Color::Yellow);
                 self.serial
-                    .request_reconnect(Some(Reconnections::LooseChecks))?;
+                    .request_reconnect(Some(ReconnectionStrictness::Low))?;
             }
             AttemptReconnectPrompt::AttemptReconnect => {
                 self.repeating_line_flip.flip();
                 self.notifs
                     .notify_str("Attempting to reconnect! (Strict Checks)", Color::Yellow);
                 self.serial
-                    .request_reconnect(Some(Reconnections::StrictChecks))?;
+                    .request_reconnect(Some(ReconnectionStrictness::High))?;
             }
             AttemptReconnectPrompt::Cancel => self.dismiss_popup(),
             AttemptReconnectPrompt::OpenPortSettings => {
@@ -3227,7 +3240,7 @@ impl App {
             }
             Popup::DisconnectPrompt => {
                 let port_state = { self.serial.port_status.load().status() };
-                let reconns_paused = if self.settings.serial.reconnections.allowed()
+                let reconns_paused = if self.settings.serial.reconnection_strictness.allowed()
                     && port_state.is_premature_disconnect()
                 {
                     Some("(Auto-reconnections paused while open)")
diff --git a/src/keybinds.rs b/src/keybinds.rs
@@ -173,16 +173,19 @@ pub enum PortAction {
     DeassertDtr,
 
     /// Attempt to reconnect to device, must match USB info if applicable.
-    AttemptReconnectStrict,
+    AttemptReconnectStrictHigh,
+    AttemptReconnectStrictMed,
     /// Attempt to reconnect to device, best-effort.
-    AttemptReconnectLoose,
+    AttemptReconnectStrictLow,
 }
 
 impl RequiresPort for PortAction {
     fn requires_connection(&self) -> bool {
         match self {
             // Can't require a connection for the method to revitalize one.
-            Self::AttemptReconnectLoose | Self::AttemptReconnectStrict => false,
+            Self::AttemptReconnectStrictHigh
+            | Self::AttemptReconnectStrictMed
+            | Self::AttemptReconnectStrictLow => false,
             _ => true,
         }
     }
diff --git a/src/serial/handle.rs b/src/serial/handle.rs
@@ -9,7 +9,7 @@ use tracing::{debug, error};
 
 use crate::{
     app::Event,
-    serial::{Reconnections, port_status::PortStatus, worker::WorkerError},
+    serial::{ReconnectionStrictness, port_status::PortStatus, worker::WorkerError},
     settings::{Ignored, PortSettings},
 };
 
@@ -29,7 +29,7 @@ pub enum SerialWorkerCommand {
         result_tx: Sender<Result<(), super::worker::WorkerError>>,
     },
     PortCommand(PortCommand),
-    RequestReconnect(Option<Reconnections>),
+    RequestReconnect(Option<ReconnectionStrictness>),
     Disconnect {
         user_wants_break: bool,
     },
@@ -226,7 +226,10 @@ impl SerialHandle {
         }
     }
     /// Non-blocking request for the serial worker to attempt to reconnect to the "current" device
-    pub fn request_reconnect(&self, strictness_opt: Option<Reconnections>) -> HandleResult<()> {
+    pub fn request_reconnect(
+        &self,
+        strictness_opt: Option<ReconnectionStrictness>,
+    ) -> HandleResult<()> {
         self.command_tx
             .send(SerialWorkerCommand::RequestReconnect(strictness_opt))?;
         Ok(())
diff --git a/src/serial/mod.rs b/src/serial/mod.rs
@@ -77,25 +77,34 @@ impl From<SerialEvent> for Event {
 )]
 #[strum(serialize_all = "title_case")]
 /// Allowance level of Auto-Reconnections
-pub enum Reconnections {
+pub enum ReconnectionStrictness {
     /// No auto reconnections
     Disabled,
+
+    /// Also known as "Strict"
     /// Will only reconnect to devices that either:
     /// 1. Match the last device exactly (Port Name + Port Type) -> PerfectMatch
     /// 2. Match the USB characteristics exactly (PID, VID, Serial, and the rest) -> UsbStrict
-    StrictChecks,
-    /// also known as "Best-Effort"
+    #[serde(alias = "StrictChecks")]
+    High,
+
+    /// Also known as "Loose"
     /// Will first try the Strict Checks and if those fail, will try to connect to devices that:
     /// 3. Match the USB PID and VID of the last device -> UsbLoose
+    Med,
+
+    /// Also known as "Best-Effort"
+    /// Will first try the Strict+Loose Checks and if those fail, will try to connect to devices that:
     /// 4. Any port at the same path of the last device -> LastDitch
-    LooseChecks,
+    #[serde(alias = "LooseChecks")]
+    Low,
 }
 
-impl Reconnections {
+impl ReconnectionStrictness {
     pub fn allowed(&self) -> bool {
         match self {
-            Reconnections::Disabled => false,
-            Reconnections::LooseChecks | Reconnections::StrictChecks => true,
+            ReconnectionStrictness::Disabled => false,
+            _ => true,
         }
     }
 }
diff --git a/src/serial/worker.rs b/src/serial/worker.rs
@@ -19,7 +19,7 @@ use crate::{
 };
 
 use super::{
-    ReconnectType, Reconnections,
+    ReconnectType, ReconnectionStrictness,
     handle::{PortCommand, SerialWorkerCommand},
 };
 
@@ -361,7 +361,7 @@ impl SerialWorker {
             } => {
                 // self.port_status = SerialStatus::idle();
 
-                let settings = self.shared_settings.load();
+                // let settings = self.shared_settings.load();
 
                 let previous_status = { self.shared_status.load().as_ref().clone() };
 
@@ -539,7 +539,7 @@ impl SerialWorker {
     /// not that reconnection was successful.
     fn attempt_reconnect(
         &mut self,
-        strictness_opt: Option<Reconnections>,
+        strictness_opt: Option<ReconnectionStrictness>,
     ) -> Result<(), WorkerError> {
         let port_available = self.port.is_available();
         #[cfg(feature = "espflash")]
@@ -549,10 +549,10 @@ impl SerialWorker {
             return Ok(());
         }
 
-        let reconnections =
-            strictness_opt.unwrap_or_else(|| self.shared_settings.load().reconnections.clone());
+        let reconnections = strictness_opt
+            .unwrap_or_else(|| self.shared_settings.load().reconnection_strictness.clone());
 
-        if reconnections == Reconnections::Disabled {
+        if reconnections == ReconnectionStrictness::Disabled {
             warn!("Got request to reconnect when reconnections are disabled!");
             return Ok(());
         }
@@ -602,21 +602,23 @@ impl SerialWorker {
             };
 
             // Loose check
-            if reconnections == Reconnections::LooseChecks
-                && let Some(port) = current_ports
-                    .iter()
-                    // Filtering out ports that didn't change across scans
-                    .filter(|p| !self.scan_snapshot.contains(p))
-                    // Trying to find another USB device with *just* matching USB PID & VID
-                    // Use cases: Some devices seem to change their Serial # arbitrarily?
-                    //          - And for interfacing with several identical devices (one at a time) without reconnecting via TUI
-                    // Needs a toggle with Strict/Loose options, as the extra behavior isn't always desirable.
-                    .find(|p| match &p.port_type {
-                        SerialPortType::UsbPort(usb) => {
-                            usb.vid == desired_usb.vid && usb.pid == desired_usb.pid
-                        }
-                        _ => false,
-                    })
+            if matches!(
+                reconnections,
+                ReconnectionStrictness::Med | ReconnectionStrictness::Low
+            ) && let Some(port) = current_ports
+                .iter()
+                // Filtering out ports that didn't change across scans
+                .filter(|p| !self.scan_snapshot.contains(p))
+                // Trying to find another USB device with *just* matching USB PID & VID
+                // Use cases: Some devices seem to change their Serial # arbitrarily?
+                //          - And for interfacing with several identical devices (one at a time) without reconnecting via TUI
+                // Needs a toggle with Strict/Loose options, as the extra behavior isn't always desirable.
+                .find(|p| match &p.port_type {
+                    SerialPortType::UsbPort(usb) => {
+                        usb.vid == desired_usb.vid && usb.pid == desired_usb.pid
+                    }
+                    _ => false,
+                })
             {
                 info!(
                     "[NON-STRICT] Connecting to similar USB device with port: {}",
@@ -629,7 +631,7 @@ impl SerialWorker {
         }
 
         // Loose check
-        if reconnections == Reconnections::LooseChecks
+        if matches!(reconnections, ReconnectionStrictness::Low)
             // Last ditch effort, just try to connect to the same port_name if it's present.
             && let Some(port) = current_ports
                 .iter()
diff --git a/src/settings/mod.rs b/src/settings/mod.rs
@@ -19,7 +19,7 @@ use strum::VariantArray;
 use crate::{
     app::{COMMON_BAUD_TRUNC, DEFAULT_BAUD},
     buffer::UserEcho,
-    serial::{DeserializedUsb, Reconnections, SignalAssertion},
+    serial::{DeserializedUsb, ReconnectionStrictness, SignalAssertion},
 };
 
 pub mod ser;
@@ -552,9 +552,9 @@ pub struct PortSettings {
     #[table(rename = "Limit TX Speed")]
     pub limit_tx_speed: bool,
 
-    /// Enable reconnections. Strict checks USB PID+VID+Serial#. Loose checks for any similar USB device/COM port.
-    #[table(values = Reconnections::VARIANTS)]
-    pub reconnections: Reconnections,
+    /// Enable reconnections with checks. High checks USB PID+VID+Serial#, Med checks USB PID+VID, and Low checks for *any* similar USB device or COM port.
+    #[table(values = ReconnectionStrictness::VARIANTS)]
+    pub reconnection_strictness: ReconnectionStrictness,
 
     /// Line endings for RX'd data.
     #[table(display = ["\\n", "\\r", "\\r\\n", "None"])]
@@ -607,7 +607,7 @@ impl Default for PortSettings {
             dtr_on_reconnect: SignalAssertion::InheritConnect,
             rts_on_reconnect: SignalAssertion::InheritConnect,
             limit_tx_speed: true,
-            reconnections: Reconnections::LooseChecks,
+            reconnection_strictness: ReconnectionStrictness::Med,
         }
     }
 }
diff --git a/src/tui/prompts.rs b/src/tui/prompts.rs
@@ -1,6 +1,6 @@
 use std::str::FromStr;
 
-use crokey::{KeyCombination, crossterm::event::KeyCode};
+use crokey::crossterm::event::KeyCode;
 use ratatui::{
     Frame,
     layout::{Alignment, Constraint, Rect},
