Save last connection type (file, serial, tcp) [ CPP-495] [CPP-430] (#328)

* Save last connection type into connection_history.yml file

This is used so that in the connection screen, the last connection type
is remembered.

* Use the common python -> rust ConnectionType enum

Author: joelynch

console_backend/src/common_constants.rs

@@ -287,6 +287,8 @@ pub enum Keys {
     RECORDING_FILENAME,
     #[strum(serialize = "CONSOLE_VERSION")]
     CONSOLE_VERSION,
+    #[strum(serialize = "PREVIOUS_CONNECTION_TYPE")]
+    PREVIOUS_CONNECTION_TYPE,
     #[strum(serialize = "CONNECTION_MESSAGE")]
     CONNECTION_MESSAGE,
     #[strum(serialize = "NOTIFICATION")]
@@ -305,6 +307,16 @@ pub enum ConnectionState {
     CONNECTING,
 }
 
+#[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
+pub enum ConnectionType {
+    #[strum(serialize = "Tcp")]
+    Tcp,
+    #[strum(serialize = "File")]
+    File,
+    #[strum(serialize = "Serial")]
+    Serial,
+}
+
 #[derive(Clone, Debug, Display, EnumString, EnumVariantNames, Eq, Hash, PartialEq)]
 pub enum QTKeys {
     #[strum(serialize = "QVariantList")]

console_backend/src/shared_state.rs

@@ -22,7 +22,6 @@ use parking_lot::Mutex;
 use serde::{Deserialize, Serialize};
 use serialport::FlowControl;
 
-use crate::connection::Connection;
 use crate::constants::{
     APPLICATION_NAME, APPLICATION_ORGANIZATION, APPLICATION_QUALIFIER, CONNECTION_HISTORY_FILENAME,
     DEFAULT_LOG_DIRECTORY, MAX_CONNECTION_HISTORY, MPS,
@@ -38,6 +37,7 @@ use crate::update_tab::UpdateTabUpdate;
 use crate::utils::send_conn_state;
 use crate::watch::{WatchReceiver, Watched};
 use crate::{client_sender::BoxedClientSender, main_tab::logging_stats_thread};
+use crate::{common_constants::ConnectionType, connection::Connection};
 use crate::{
     common_constants::{self as cc, SbpLogging},
     status_bar::Heartbeat,
@@ -147,6 +147,9 @@ impl SharedState {
     pub fn serial_history(&self) -> IndexMap<String, SerialConfig> {
         self.lock().connection_history.serial_configs()
     }
+    pub fn connection_type_history(&self) -> ConnectionType {
+        self.lock().connection_history.last_connection_type.clone()
+    }
     pub fn update_folder_history(&self, folder: PathBuf) {
         let folder = String::from(folder.to_str().expect(CONVERT_TO_STR_FAILURE));
         self.lock().connection_history.record_folder(folder);
@@ -713,6 +716,17 @@ pub struct ConnectionHistory {
     files: IndexSet<String>,
     folders: IndexSet<String>,
     serial_configs: IndexMap<String, SerialConfig>,
+    #[serde(with = "ConnectionTypeDef")]
+    last_connection_type: ConnectionType,
+}
+
+// https://serde.rs/remote-derive.html
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "ConnectionType")]
+enum ConnectionTypeDef {
+    Tcp,
+    File,
+    Serial,
 }
 
 impl Default for ConnectionHistory {
@@ -739,6 +753,7 @@ impl ConnectionHistory {
             files: IndexSet::new(),
             folders,
             serial_configs: IndexMap::new(),
+            last_connection_type: ConnectionType::Serial,
         }
     }
     /// Return the filename of the saved connection history file.
@@ -772,6 +787,7 @@ impl ConnectionHistory {
         self.addresses.insert(address);
         let diff = i32::max(0, self.addresses.len() as i32 - MAX_CONNECTION_HISTORY);
         self.addresses = self.addresses.split_off(diff as usize);
+        self.last_connection_type = ConnectionType::Tcp;
 
         if let Err(e) = self.save() {
             error!("Unable to save connection history, {}.", e);
@@ -786,6 +802,7 @@ impl ConnectionHistory {
         self.files.insert(filename);
         let diff = i32::max(0, self.files.len() as i32 - MAX_CONNECTION_HISTORY);
         self.files = self.files.split_off(diff as usize);
+        self.last_connection_type = ConnectionType::File;
 
         if let Err(e) = self.save() {
             error!("Unable to save connection history, {}.", e);
@@ -818,6 +835,7 @@ impl ConnectionHistory {
         self.serial_configs.insert(device, serial);
         let diff = i32::max(0, self.serial_configs.len() as i32 - MAX_CONNECTION_HISTORY);
         self.serial_configs = self.serial_configs.split_off(diff as usize);
+        self.last_connection_type = ConnectionType::Serial;
 
         if let Err(e) = self.save() {
             error!("Unable to save connection history, {}.", e);
@@ -943,6 +961,7 @@ mod tests {
         let first_addy = addresses.first().unwrap();
         assert_eq!(host1, first_addy.host);
         assert_eq!(port, first_addy.port);
+        assert_eq!(ConnectionType::Tcp, conn_history.last_connection_type);
 
         conn_history.record_address(host2.clone(), port);
         let addresses = conn_history.addresses();
@@ -972,6 +991,7 @@ mod tests {
         let files = conn_history.files();
         assert_eq!(filename1, files[1]);
         assert_eq!(filename2, files[0]);
+        assert_eq!(ConnectionType::File, conn_history.last_connection_type);
 
         for ele in 0..MAX_CONNECTION_HISTORY {
             conn_history.record_file(ele.to_string());
@@ -987,13 +1007,16 @@ mod tests {
         backup_file(bfilename.clone());
 
         let mut conn_history = ConnectionHistory::new();
+        assert_eq!(ConnectionType::Serial, conn_history.last_connection_type);
 
         let configs = conn_history.serial_configs();
         assert_eq!(configs.keys().len(), 0);
 
         conn_history.record_serial("/dev/ttyUSB0".to_string(), 115200, FlowControl::Software);
         conn_history.record_serial("/dev/ttyUSB0".to_string(), 115200, FlowControl::None);
 
+        assert_eq!(ConnectionType::Serial, conn_history.last_connection_type);
+
         let configs = conn_history.serial_configs();
 
         // Should only store one serial record despite the settings changing

console_backend/src/utils.rs

@@ -153,6 +153,9 @@ pub fn refresh_connection_frontend(client_sender: &BoxedClientSender, shared_sta
         prevous_files.set(i as u32, filename);
     }
 
+    let prev_conn_type = shared_state.connection_type_history().to_string();
+    connection_status.set_previous_connection_type(&*prev_conn_type);
+
     client_sender.send_data(serialize_capnproto_builder(builder));
 }
 

resources/ConnectionScreen.qml

@@ -9,6 +9,7 @@ Item {
     property string tcp_ip: "TCP/IP"
     property string serial_usb: "Serial/USB"
     property string file: "File"
+    property string previous_connection_type: ""
     property var sources: [tcp_ip, serial_usb, file]
     property variant available_baudrates: []
     property variant available_devices: []
@@ -79,23 +80,25 @@ Item {
                     Layout.alignment: Qt.AlignTop
 
                     RadioButton {
-                        id: tcpRadio
+                        id: serialRadio
 
-                        checked: true
-                        text: tcp_ip
+                        checked: previous_connection_type == "Serial"
+                        text: serial_usb
                         onToggled: dialogRect.forceActiveFocus()
                     }
 
                     RadioButton {
-                        id: serialRadio
+                        id: tcpRadio
 
-                        text: serial_usb
+                        checked: previous_connection_type == "TCP"
+                        text: tcp_ip
                         onToggled: dialogRect.forceActiveFocus()
                     }
 
                     RadioButton {
                         id: fileRadio
 
+                        checked: previous_connection_type == "File"
                         text: file
                         onToggled: dialogRect.forceActiveFocus()
                     }
@@ -370,6 +373,7 @@ Item {
                     previous_ports = connectionData.previous_ports;
                     previous_files = connectionData.previous_files;
                     previous_serial_configs = connectionData.previous_serial_configs;
+                    previous_connection_type = connectionData.previous_connection_type;
                     if (!last_used_serial_device && connectionData.last_used_serial_device) {
                         // Set the default selected to the last used
                         last_used_serial_device = connectionData.last_used_serial_device;

src/main/resources/base/console_backend.capnp

@@ -158,6 +158,7 @@ struct ConnectionStatus {
     previousHosts @3: List(Text);
     previousPorts @4: List(UInt16);
     previousFiles @5: List(Text);
+    previousConnectionType @10: Text;
     previousSerialConfigs @6: List(SerialRequest);
     lastSerialDevice: union {
         port @7 :Text;

swiftnav_console/connection.py

@@ -5,7 +5,7 @@
 
 from PySide2.QtCore import Property, QObject, Slot
 
-from .constants import Keys, QTKeys, ConnectionState
+from .constants import Keys, QTKeys, ConnectionState, ConnectionType
 
 CONNECTION: Dict[str, Any] = {
     Keys.AVAILABLE_PORTS: [],
@@ -20,6 +20,7 @@
     Keys.LAST_USED_SERIAL_DEVICE: None,
     Keys.PREVIOUS_SERIAL_CONFIGS: [],
     Keys.CONSOLE_VERSION: str,
+    Keys.PREVIOUS_CONNECTION_TYPE: "",
 }
 
 
@@ -36,6 +37,7 @@ class ConnectionData(QObject):  # pylint: disable=too-many-instance-attributes d
     _last_used_serial_device: str
     _previous_serial_configs: List[List[Any]] = []
     _console_version: str = ""
+    _previous_connection_type: ConnectionType = ConnectionType.Serial
     _connection_message: str = ""
 
     def get_available_ports(self) -> List[str]:
@@ -128,6 +130,14 @@ def set_console_version(self, console_version: str) -> None:
 
     console_version = Property(str, get_console_version, set_console_version)
 
+    def get_previous_connection_type(self) -> ConnectionType:
+        return self._previous_connection_type
+
+    def set_previous_connection_type(self, previous_connection_type: ConnectionType) -> None:
+        self._previous_connection_type = previous_connection_type
+
+    previous_connection_type = Property(str, get_previous_connection_type, set_previous_connection_type)
+
     def get_connection_message(self) -> str:
         return self._connection_message
 
@@ -150,6 +160,7 @@ def fill_data(self, cp: ConnectionData) -> ConnectionData:  # pylint:disable=no-
         cp.set_last_used_serial_device(CONNECTION[Keys.LAST_USED_SERIAL_DEVICE])
         cp.set_previous_serial_configs(CONNECTION[Keys.PREVIOUS_SERIAL_CONFIGS])
         cp.set_console_version(CONNECTION[Keys.CONSOLE_VERSION])
+        cp.set_previous_connection_type(CONNECTION[Keys.PREVIOUS_CONNECTION_TYPE])
         cp.set_connection_message(CONNECTION[Keys.CONNECTION_MESSAGE])
         CONNECTION[Keys.CONNECTION_MESSAGE] = ""
         return cp

swiftnav_console/constants.py

@@ -136,6 +136,7 @@ class Keys(str, Enum):
     PREVIOUS_SERIAL_CONFIGS = "PREVIOUS_SERIAL_CONFIGS"
     RECORDING_FILENAME = "RECORDING_FILENAME"
     CONSOLE_VERSION = "CONSOLE_VERSION"
+    PREVIOUS_CONNECTION_TYPE = "PREVIOUS_CONNECTION_TYPE"
     CONNECTION_MESSAGE = "CONNECTION_MESSAGE"
     NOTIFICATION = "NOTIFICATION"
 
@@ -147,6 +148,12 @@ class ConnectionState(str, Enum):
     CONNECTING = "CONNECTING"
 
 
+class ConnectionType(str, Enum):
+    Tcp = "Tcp"
+    File = "File"
+    Serial = "Serial"
+
+
 class QTKeys(str, Enum):
     QVARIANTLIST = "QVariantList"
     QVARIANT = "QVariant"

swiftnav_console/main.py

@@ -24,7 +24,7 @@
 
 import console_backend.server  # type: ignore  # pylint: disable=import-error,no-name-in-module
 
-from .constants import ApplicationMetadata, ConnectionState, Keys, Tabs, QTKeys
+from .constants import ApplicationMetadata, ConnectionState, ConnectionType, Keys, Tabs, QTKeys
 
 from .log_panel import (
     LOG_PANEL,
@@ -382,6 +382,7 @@ def receive_messages(app_, backend, messages):
                 [entry.device, entry.baudrate, entry.flowControl] for entry in m.connectionStatus.previousSerialConfigs
             ]
             CONNECTION[Keys.CONSOLE_VERSION] = m.connectionStatus.consoleVersion
+            CONNECTION[Keys.PREVIOUS_CONNECTION_TYPE] = ConnectionType(m.connectionStatus.previousConnectionType)
         elif m.which == Message.Union.LoggingBarStatus:
             LOGGING_BAR[Keys.PREVIOUS_FOLDERS][:] = m.loggingBarStatus.previousFolders
             LOGGING_BAR[Keys.CSV_LOGGING] = m.loggingBarStatus.csvLogging