leyoda/cosmic-applets
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: more improvements to network applet

Browse source
This commit is contained in:
Ashley Wulber 2023-01-07 00:21:16 -05:00
parent 13ccc03676
commit c10087a55d
No known key found for this signature in database
GPG key ID: 5216D4F46A90A820
6 changed files with 363 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

20
cosmic-applet-network/src/network_manager/available_wifi.rs
View file

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-3.0-or-later
use cosmic_dbus_networkmanager::device::wireless::WirelessDevice;
use cosmic_dbus_networkmanager::{device::wireless::WirelessDevice, interface::enums::DeviceState};
use futures_util::StreamExt;
use itertools::Itertools;
@ -16,17 +16,32 @@ pub async fn handle_wireless_device(device: WirelessDevice<'_>) -> zbus::Result<
}
}
let access_points = device.get_access_points().await?;
let state: DeviceState = device
.upcast()
.await
.and_then(|dev| dev.cached_state())
.unwrap_or_default()
.map(|s| s.into())
.unwrap_or_else(|| DeviceState::Unknown);
// Sort by strength and remove duplicates
let mut aps = HashMap::<String, AccessPoint>::new();
for ap in access_points {
let ssid = String::from_utf8_lossy(&ap.ssid().await?.clone()).into_owned();
let strength = ap.strength().await?;
if let Some(access_point) = aps.get(&ssid) {
if access_point.strength > strength {
continue;
}
}
aps.insert(ssid.clone(), AccessPoint { ssid, strength });
aps.insert(
ssid.clone(),
AccessPoint {
ssid,
strength,
state: state,
},
);
}
let aps = aps
.into_iter()
@ -40,4 +55,5 @@ pub async fn handle_wireless_device(device: WirelessDevice<'_>) -> zbus::Result<
pub struct AccessPoint {
pub ssid: String,
pub strength: u8,
pub state: DeviceState,
}

61
cosmic-applet-network/src/network_manager/mod.rs
View file

@ -5,10 +5,17 @@ use std::{fmt::Debug, hash::Hash, time::Duration};
use cosmic::iced::{self, subscription};
use cosmic_dbus_networkmanager::{
device::SpecificDevice, interface::enums::DeviceType, nm::NetworkManager,
device::SpecificDevice,
interface::{enums::DeviceType, settings::connection::ConnectionSettingsProxy},
nm::NetworkManager,
settings::{
connection::{ConnectionSettings, Secrets, Settings},
NetworkManagerSettings,
},
};
use futures::{
channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender},
future::ok,
FutureExt, StreamExt,
};
use zbus::Connection;
@ -49,6 +56,12 @@ async fn start_listening<I: Copy>(
Ok(n) => n,
Err(_) => return (None, State::Finished),
};
let s = match NetworkManagerSettings::new(&conn).await {
Ok(s) => s,
Err(_) => return (None, State::Finished),
};
let known_conns = s.list_connections().await.unwrap_or_default();
let (tx, rx) = unbounded();
let mut active_conns = active_connections(
network_manager
@ -85,8 +98,30 @@ async fn start_listening<I: Copy>(
let mut wireless_access_points =
Vec::with_capacity(wireless_access_point_futures.len());
for f in wireless_access_point_futures {
wireless_access_points.append(&mut f.await);
let mut access_points = f.await;
wireless_access_points.append(&mut access_points);
}
let mut known_ssid = Vec::with_capacity(known_conns.len());
for c in known_conns {
let s = c.get_settings().await.unwrap();
let s = Settings::new(s);
if let Some(cur_ssid) = s
.wifi
.clone()
.and_then(|w| w.ssid)
.and_then(|ssid| String::from_utf8(ssid).ok())
{
known_ssid.push(cur_ssid);
}
}
let known_access_points: Vec<_> = wireless_access_points
.iter()
.filter(|a| {
known_ssid.contains(&a.ssid)
&& !active_conns.iter().any(|ac| ac.name() == a.ssid)
})
.cloned()
.collect();
wireless_access_points.sort_by(|a, b| b.strength.cmp(&a.strength));
drop(network_manager);
return (
@ -97,6 +132,7 @@ async fn start_listening<I: Copy>(
wireless_access_points,
wifi_enabled,
airplane_mode: false,
known_access_points,
active_conns,
},
)),
@ -108,6 +144,7 @@ async fn start_listening<I: Copy>(
Ok(n) => n,
Err(_) => return (None, State::Finished),
};
let mut active_conns_changed = tokio::time::sleep(Duration::from_secs(5))
.then(|_| async { network_manager.receive_active_connections_changed().await })
.await;
@ -153,7 +190,26 @@ async fn start_listening<I: Copy>(
Some(NetworkManagerRequest::SelectAccessPoint(ssid)) => {
'device_loop: for device in network_manager.devices().await.ok().unwrap_or_default() {
if matches!(device.device_type().await.unwrap_or(DeviceType::Other), DeviceType::Wifi) {
let connection_settings = NetworkManagerSettings::new(&conn).await.unwrap();
for conn in connection_settings.list_connections().await.unwrap() {
let s = conn.get_settings().await.unwrap();
let s = Settings::new(s);
let cur_ssid = s
.wifi
.clone()
.and_then(|w| w.ssid)
.and_then(|ssid| String::from_utf8(ssid).ok());
if cur_ssid.as_ref() == Some(&ssid) {
// dbg!(s);
// dbg!(conn.get_secrets("connection").await);
// dbg!(Secrets::new(&conn).await);
// dbg!(psk);
// connection update can be used to set password
}
}
for conn in device.available_connections().await.unwrap_or_default() {
// network_manager.activate_connection(conn, device.clone());
// dbg!(&conn.path());
// TODO activate connection
}
@ -225,6 +281,7 @@ pub enum NetworkManagerEvent {
sender: UnboundedSender<NetworkManagerRequest>,
wireless_access_points: Vec<AccessPoint>,
active_conns: Vec<ActiveConnectionInfo>,
known_access_points: Vec<AccessPoint>,
wifi_enabled: bool,
airplane_mode: bool,
},