support hidden networks

Author: pythops

Cargo.lock

@@ -25,7 +25,7 @@ serde = { version = "1", features = ["derive"] }
 toml = { version = "0.9" }
 clap = { version = "4", features = ["derive", "cargo"] }
 anyhow = "1"
-iwdrs = "0.2.4"
+iwdrs = "0.2.5"
 chrono = "0.4"
 log = "0.4"
 env_logger = "0.11"

Cargo.toml

@@ -65,13 +65,17 @@ pub struct Station {
 
     #[serde(default)]
     pub known_network: KnownNetwork,
+
+    #[serde(default)]
+    pub new_network: NewNetwork,
 }
 
 impl Default for Station {
     fn default() -> Self {
         Self {
             start_scanning: 's',
             known_network: KnownNetwork::default(),
+            new_network: NewNetwork::default(),
         }
     }
 }
@@ -104,6 +108,17 @@ fn default_station_remove_known_network() -> char {
     'd'
 }
 
+#[derive(Deserialize, Debug)]
+pub struct NewNetwork {
+    pub show_all: char,
+}
+
+impl Default for NewNetwork {
+    fn default() -> Self {
+        Self { show_all: 'a' }
+    }
+}
+
 // Access Point
 #[derive(Deserialize, Debug)]
 pub struct AccessPoint {

src/config.rs

@@ -20,15 +20,40 @@ pub async fn toggle_connect(app: &mut App, sender: UnboundedSender<Event>) -> Re
         match app.focused_block {
             FocusedBlock::NewNetworks => {
                 if let Some(net_index) = station.new_networks_state.selected() {
-                    let (net, _) = station.new_networks[net_index].clone();
+                    if net_index < station.new_networks.len() {
+                        let (net, _) = station.new_networks[net_index].clone();
 
-                    if net.network_type == NetworkType::Eap {
-                        sender.send(Event::ConfigureNewEapNetwork(net.name.clone()))?;
-                        return Ok(());
+                        if net.network_type == NetworkType::Eap {
+                            sender.send(Event::ConfigureNewEapNetwork(net.name.clone()))?;
+                            return Ok(());
+                        }
+                        tokio::spawn(async move {
+                            let _ = net.connect(sender.clone()).await;
+                        });
+                    } else {
+                        let net = station.new_hidden_networks
+                            [net_index.saturating_sub(station.new_networks.len())]
+                        .clone();
+
+                        if net.network_type == NetworkType::Eap {
+                            sender.send(Event::ConfigureNewEapNetwork(net.address.clone()))?;
+                            return Ok(());
+                        }
+                        tokio::spawn({
+                            let iwd_station =
+                                station.session.stations().await.unwrap().pop().unwrap();
+                            let ssid = net.address.clone();
+                            async move {
+                                if let Err(e) = iwd_station.connect_hidden_network(ssid).await {
+                                    let _ = Notification::send(
+                                        e.to_string(),
+                                        notification::NotificationLevel::Error,
+                                        &sender,
+                                    );
+                                }
+                            }
+                        });
                     }
-                    tokio::spawn(async move {
-                        let _ = net.connect(sender.clone()).await;
-                    });
                 }
             }
             FocusedBlock::KnownNetworks => match &station.connected_network {
@@ -532,18 +557,28 @@ pub async fn handle_key_events(
                                     }
                                 }
                                 FocusedBlock::NewNetworks => match key_event.code {
+                                    // Show / Hide unavailable networks
+                                    KeyCode::Char(c)
+                                        if c == config.station.new_network.show_all =>
+                                    {
+                                        station.show_hidden_networks =
+                                            !station.show_hidden_networks;
+                                    }
                                     KeyCode::Enter | KeyCode::Char(' ') => {
                                         toggle_connect(app, sender).await?
                                     }
                                     KeyCode::Char('j') | KeyCode::Down => {
                                         if !station.new_networks.is_empty() {
                                             let i = match station.new_networks_state.selected() {
                                                 Some(i) => {
-                                                    if i < station.new_networks.len() - 1 {
-                                                        i + 1
+                                                    let limit = if station.show_hidden_networks {
+                                                        station.new_networks.len()
+                                                            + station.new_hidden_networks.len()
+                                                            - 1
                                                     } else {
-                                                        i
-                                                    }
+                                                        station.new_networks.len() - 1
+                                                    };
+                                                    if i < limit { i + 1 } else { i }
                                                 }
                                                 None => 0,
                                             };

src/handler.rs

@@ -9,6 +9,7 @@ use std::sync::Arc;
 use futures::future::join_all;
 use iwdrs::{
     error::{IWDError, station::ScanError},
+    hidden_network::HiddenNetwork,
     session::Session,
     station::{State, diagnostics::ActiveStationDiagnostics},
 };
@@ -39,12 +40,14 @@ pub struct Station {
     pub is_scanning: bool,
     pub connected_network: Option<Network>,
     pub new_networks: Vec<(Network, i16)>,
+    pub new_hidden_networks: Vec<HiddenNetwork>,
     pub known_networks: Vec<(Network, i16)>,
     pub unavailable_known_networks: Vec<KnownNetwork>,
     pub known_networks_state: TableState,
     pub new_networks_state: TableState,
     pub diagnostic: Option<ActiveStationDiagnostics>,
     pub show_unavailable_known_networks: bool,
+    pub show_hidden_networks: bool,
     pub share: Option<Share>,
 }
 
@@ -94,6 +97,11 @@ impl Station {
             .filter(|(net, _signal)| net.known_network.is_none())
             .collect();
 
+        let new_hidden_networks = iwd_station
+            .get_hidden_networks()
+            .await
+            .unwrap_or(Vec::new());
+
         let known_networks: Vec<(Network, i16)> = networks
             .into_iter()
             .filter(|(net, _signal)| net.known_network.is_some())
@@ -144,16 +152,24 @@ impl Station {
             is_scanning,
             connected_network,
             new_networks,
+            new_hidden_networks,
             known_networks,
             unavailable_known_networks,
             known_networks_state,
             new_networks_state,
             diagnostic,
             show_unavailable_known_networks: false,
+            show_hidden_networks: false,
             share: None,
         })
     }
 
+    pub async fn connect_hidden_network(&self, ssid: String) -> Result<()> {
+        let iwd_station = self.session.stations().await?.pop().unwrap();
+        iwd_station.connect_hidden_network(ssid).await?;
+        Ok(())
+    }
+
     pub async fn refresh(&mut self) -> Result<()> {
         let iwd_station = self.session.stations().await.unwrap().pop().unwrap();
 
@@ -243,6 +259,11 @@ impl Station {
             self.known_networks = known_networks;
         }
 
+        self.new_hidden_networks = iwd_station
+            .get_hidden_networks()
+            .await
+            .unwrap_or(Vec::new());
+
         let available_networks_names: Vec<String> = self
             .known_networks
             .iter()
@@ -598,7 +619,7 @@ impl Station {
         //
         // New networks
         //
-        let rows: Vec<Row> = self
+        let mut rows: Vec<Row> = self
             .new_networks
             .iter()
             .map(|(net, signal)| {
@@ -625,6 +646,34 @@ impl Station {
             })
             .collect();
 
+        if self.show_hidden_networks {
+            self.new_hidden_networks.iter().for_each(|net| {
+                rows.push(
+                    Row::new(vec![
+                        Line::from(net.address.clone()).centered(),
+                        Line::from(net.network_type.to_string().clone()).centered(),
+                        Line::from({
+                            let signal = {
+                                if net.signal_strength / 100 >= -50 {
+                                    100
+                                } else {
+                                    2 * (100 + net.signal_strength / 100)
+                                }
+                            };
+                            match signal {
+                                n if n >= 75 => format!("{signal:3}% 󰤨"),
+                                n if (50..75).contains(&n) => format!("{signal:3}% 󰤥"),
+                                n if (25..50).contains(&n) => format!("{signal:3}% 󰤢"),
+                                _ => format!("{signal:3}% 󰤟"),
+                            }
+                        })
+                        .centered(),
+                    ])
+                    .dark_gray(),
+                )
+            })
+        };
+
         let widths = [
             Constraint::Length(25),
             Constraint::Length(15),
@@ -789,7 +838,6 @@ impl Station {
                             Span::from(" | "),
                             Span::from(config.station.start_scanning.to_string()).bold(),
                             Span::from(" Scan"),
-                            Span::from(" | "),
                         ]),
                         Line::from(vec![
                             Span::from("k,").bold(),
@@ -816,6 +864,9 @@ impl Station {
                         Span::from("󱁐  or ↵ ").bold(),
                         Span::from(" Connect"),
                         Span::from(" | "),
+                        Span::from(config.station.new_network.show_all.to_string()).bold(),
+                        Span::from(" Show All"),
+                        Span::from(" | "),
                         Span::from(config.station.start_scanning.to_string()).bold(),
                         Span::from(" Scan"),
                         Span::from(" | "),