fix(connection): preserve history connections across periodic port rediscovery

The 3-second periodic port refresh rebuilt _connection_tuples entirely
from auto-discovered ports, silently dropping any connections that were
added from persistent history or via the UI but were not physically
present on the bus at that moment.

- Add `preserved_connections` parameter to `discover_connections()` so
  the caller (frontend) can supply history entries to re-merge after each
  auto-discovery scan, keeping the backend free of settings/filesystem
  dependencies
- Pass `ProgramSettings.get_connection_history()` as
  `preserved_connections` on every periodic refresh in
  `ConnectionSelectionWidgets._refresh_ports()`
- Store successfully connected device to `ProgramSettings` and register
  it via `add_connection()` in `reconnect()`, not only when the
  connection was typed via the "Add another" dialog but also when an
  existing combobox entry is selected
- Update protocol, facade, and tests accordingly

Author: amilcarlucas

ardupilot_methodic_configurator/backend_flightcontroller.py

@@ -318,9 +318,15 @@ def reset_and_reconnect(
         # Reconnect to the flight controller
         return self.create_connection_with_retry(connection_progress_callback, baudrate=self.baudrate)
 
-    def discover_connections(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> None:
+    def discover_connections(
+        self,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+        preserved_connections: Optional[list[str]] = None,
+    ) -> None:
         """Discover available connections - delegates to connection manager."""
-        self._connection_manager.discover_connections(progress_callback=progress_callback)
+        self._connection_manager.discover_connections(
+            progress_callback=progress_callback, preserved_connections=preserved_connections
+        )
 
     def disconnect(self) -> None:
         """Close the connection to the flight controller - delegates to connection manager."""

ardupilot_methodic_configurator/backend_flightcontroller_connection.py

@@ -149,7 +149,11 @@ def __init__(  # pylint: disable=too-many-arguments, too-many-positional-argumen
             mavlink_connection_factory or SystemMavlinkConnectionFactory()
         )
 
-    def discover_connections(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> None:
+    def discover_connections(
+        self,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+        preserved_connections: Optional[list[str]] = None,
+    ) -> None:
         """
         Discover all available connections (serial and network ports).
 
@@ -158,6 +162,10 @@ def discover_connections(self, progress_callback: Optional[Callable[[int, int],
 
         Args:
             progress_callback: Optional callback for progress updates. Signature: callback(current, total)
+            preserved_connections: Optional list of connection strings (e.g. from persistent history)
+                that should always appear in the available connections list even when not auto-discovered.
+                The caller (frontend) is responsible for supplying these so the backend stays
+                free of any dependency on the settings/filesystem layer.
 
         """
         if progress_callback:
@@ -175,6 +183,12 @@ def discover_connections(self, progress_callback: Optional[Callable[[int, int],
 
         # list of tuples with the first element being the port name and the second element being the port description
         self._connection_tuples = [(port.device, port.description) for port in comports] + [(port, port) for port in netports]
+        # Merge caller-supplied preserved connections (e.g. persistent history) that are not auto-discovered
+        if preserved_connections:
+            auto_discovered = {t[0] for t in self._connection_tuples}
+            for conn in preserved_connections:
+                if conn not in auto_discovered:
+                    self._connection_tuples.append((conn, conn))
         self._log_connection_changes()
         # now that it is logged, add the 'Add another' tuple
         self._connection_tuples += [(_("Add another"), _("Add another"))]

ardupilot_methodic_configurator/backend_flightcontroller_protocols.py

@@ -94,7 +94,11 @@ def baudrate(self) -> int:
         """Get the default baud rate for serial connections."""
         ...  # pylint: disable=unnecessary-ellipsis
 
-    def discover_connections(self, progress_callback: Optional[Callable[[int, int], None]] = None) -> None: ...
+    def discover_connections(
+        self,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+        preserved_connections: Optional[list[str]] = None,
+    ) -> None: ...
 
     def disconnect(self) -> None: ...
 

ardupilot_methodic_configurator/frontend_tkinter_connection_selection.py

@@ -134,7 +134,10 @@ def _refresh_ports(self) -> None:
         try:
             # Scan for new ports and get current data
             current_selection = self.conn_selection_combobox.get_selected_key()
-            self.flight_controller.discover_connections(progress_callback=None)
+            self.flight_controller.discover_connections(
+                progress_callback=None,
+                preserved_connections=ProgramSettings.get_connection_history(),
+            )
             new_connection_tuples = self.flight_controller.get_connection_tuples()
 
             # update the UI
@@ -257,7 +260,12 @@ def reconnect(self, selected_connection: str = "") -> bool:  # Default is auto-c
         self.stop_periodic_refresh()
         # Store the current connection as the previous selection
         if self.flight_controller.comport and hasattr(self.flight_controller.comport, "device"):
-            self.previous_selection = self.flight_controller.comport.device
+            device: str = self.flight_controller.comport.device
+            self.previous_selection = device
+            # Persist the connection so it is available next time the program opens
+            # and so it survives periodic auto-discovery refreshes during the current session.
+            ProgramSettings.store_connection(device)
+            self.flight_controller.add_connection(device)
         if self.destroy_parent_on_connect:
             self.parent.root.destroy()
         if self.download_params_on_connect and hasattr(self.parent, "download_flight_controller_parameters"):

tests/test_backend_flightcontroller.py

@@ -966,4 +966,6 @@ def track_progress(current: int, total: int) -> None:  # pylint: disable=unused-
         fc.discover_connections(progress_callback=track_progress)
 
         # Assert: Connection manager received progress callback
-        mock_conn_mgr.discover_connections.assert_called_once_with(progress_callback=track_progress)
+        mock_conn_mgr.discover_connections.assert_called_once_with(
+            progress_callback=track_progress, preserved_connections=None
+        )

tests/test_backend_flightcontroller_connection.py

@@ -470,6 +470,90 @@ def test_custom_connection_string_deduplication(self) -> None:
         count = sum(1 for t in tuples if t[0] == "/dev/ttyUSB0")
         assert count == 1
 
+    def test_preserved_connection_survives_port_rediscovery(self) -> None:
+        """
+        Caller-supplied preserved connection persists across auto-discovery refreshes.
+
+        GIVEN: User has previously used a custom connection (e.g. a TCP address stored in history)
+        WHEN: discover_connections() is called again (periodic 3s refresh) and returns different ports
+            AND the caller supplies the history list as preserved_connections
+        THEN: The preserved connection should still be present in the combobox
+        AND: Auto-discovered ports that disappeared should be gone
+        AND: Newly auto-discovered ports should appear
+        """
+        # Given: Connection manager with a mocked serial port discovery
+        mock_discovery = Mock()
+        mock_port = Mock()
+        mock_port.device = "COM3"
+        mock_port.description = "USB Serial"
+
+        # First discovery: COM3 is present
+        mock_discovery.get_available_ports.return_value = [mock_port]
+        connection = FlightControllerConnection(
+            info=FlightControllerInfo(),
+            serial_port_discovery=mock_discovery,
+            network_ports=[],
+        )
+        connection.discover_connections()
+
+        # When: Port list changes (COM3 disappears, COM4 appears) but caller preserves the TCP address
+        mock_port2 = Mock()
+        mock_port2.device = "COM4"
+        mock_port2.description = "Another USB Serial"
+        mock_discovery.get_available_ports.return_value = [mock_port2]
+        connection.discover_connections(preserved_connections=["tcp:127.0.0.1:5760"])
+
+        # Then: Preserved TCP connection is present
+        tuples = connection.get_connection_tuples()
+        assert any(t[0] == "tcp:127.0.0.1:5760" for t in tuples)
+        # COM3 is gone (no longer auto-discovered, not in preserved list)
+        assert not any(t[0] == "COM3" for t in tuples)
+        # COM4 is present (auto-discovered)
+        assert any(t[0] == "COM4" for t in tuples)
+
+    def test_without_preserved_connections_non_discovered_ports_disappear(self) -> None:
+        """
+        Without preserved_connections, ports that are no longer auto-discovered are removed.
+
+        GIVEN: Many USB devices are connected and auto-discovered
+        WHEN: discover_connections() is called again without preserved_connections
+            AND one port is no longer detected
+        THEN: The missing port is removed from the combobox
+        AND: The backend has no hidden state keeping old connections alive
+        """
+        # Given: Connection manager with multiple auto-discovered ports
+        mock_discovery = Mock()
+        ports = []
+        for i in range(5):
+            p = Mock()
+            p.device = f"COM{i + 1}"
+            p.description = f"USB Device {i + 1}"
+            ports.append(p)
+        mock_discovery.get_available_ports.return_value = ports
+
+        connection = FlightControllerConnection(
+            info=FlightControllerInfo(),
+            serial_port_discovery=mock_discovery,
+            network_ports=[],
+        )
+
+        # When: Initial discovery
+        connection.discover_connections()
+        tuples = connection.get_connection_tuples()
+        for i in range(5):
+            assert any(t[0] == f"COM{i + 1}" for t in tuples)
+
+        # When: Re-discovery with fewer ports and no preserved list
+        mock_discovery.get_available_ports.return_value = ports[:2]  # Only COM1, COM2 remain
+        connection.discover_connections()
+
+        # Then: Only auto-discovered ports are present - COM3..COM5 are gone
+        tuples = connection.get_connection_tuples()
+        assert any(t[0] == "COM1" for t in tuples)
+        assert any(t[0] == "COM2" for t in tuples)
+        for i in range(2, 5):
+            assert not any(t[0] == f"COM{i + 1}" for t in tuples)
+
 
 class TestFlightControllerConnectionInfo:
     """Test flight controller information gathering."""

tests/test_frontend_tkinter_connection_selection.py

@@ -934,6 +934,10 @@ def setUp(self) -> None:
             patch("tkinter.ttk.Combobox"),
             patch("tkinter.StringVar", return_value=mock_baudrate_var),
             patch("ardupilot_methodic_configurator.frontend_tkinter_connection_selection.show_tooltip"),
+            patch(
+                "ardupilot_methodic_configurator.frontend_tkinter_connection_selection.ProgramSettings.get_connection_history",
+                return_value=[],
+            ),
         ):
             self.widget = ConnectionSelectionWidgets(
                 self.mock_parent,
@@ -957,7 +961,9 @@ def test_periodic_refresh_starts_on_init(self) -> None:
         """
         # The widget is already initialized in setUp
         # Verify observable behavior: port scan actually ran
-        self.mock_flight_controller.discover_connections.assert_called_once_with(progress_callback=None)
+        self.mock_flight_controller.discover_connections.assert_called_once_with(
+            progress_callback=None, preserved_connections=[]
+        )
         # Verify the recurring timer was scheduled via the tkinter event loop
         self.mock_parent.root.after.assert_called_with(3000, self.widget._refresh_ports)
         assert self.widget._is_refreshing is False