Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-07-07 10:37:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat: Add stop listener

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-11-13 10:28:48 +01:00
parent f5f6246ad1
commit e3b95d7540
14 changed files with 215 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

72
src/components/wifi/wifiBox.rs
View file

@ -6,6 +6,7 @@ use std::thread;
use std::time::Duration;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::utils::Listeners;
use adw::glib;
use adw::glib::Object;
use adw::prelude::{BoxExt, ListBoxRowExt};
@ -58,7 +59,7 @@ impl WifiBox {
}
}
pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
pub fn scanForWifi(listeners: Arc<Listeners>, wifiBox: Arc<WifiBox>) {
let wifibox_ref = wifiBox.clone();
let wifibox_ref_listener = wifiBox.clone();
let wifiEntries = wifiBox.imp().wifiEntries.clone();
@ -72,39 +73,36 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
let mut wifiEntries = wifiEntries.lock().unwrap();
let selfImp = wifibox_ref.imp();
for accessPoint in accessPoints {
let path = accessPoint.dbus_path.clone();
let ssid = accessPoint.ssid.clone();
let entry = Arc::new(ListEntry::new(&*WifiEntry::new(accessPoint)));
wifiEntries.insert(path, entry.clone());
wifiEntries.insert(ssid, entry.clone());
selfImp.resetWifiList.append(&*entry);
}
});
});
let wifiBoxImpl = wifibox_ref_listener.imp();
wifiBoxImpl
.listener_active
.store(true, std::sync::atomic::Ordering::SeqCst);
if listeners.network_listener.load(Ordering::SeqCst) {
return;
}
listeners.network_listener.store(true, Ordering::SeqCst);
dbus_start_network_events();
let (sender, receiver): (
Sender<Events<(AccessPoint,), (Path<'static>,)>>,
Receiver<Events<(AccessPoint,), (Path<'static>,)>>,
Sender<Events<(AccessPoint,), (AccessPoint,)>>,
Receiver<Events<(AccessPoint,), (AccessPoint,)>>,
) = channel();
let sender_ref = Arc::new(sender);
let res = start_event_listener::<
(AccessPoint,),
(Path<'static>,),
(AccessPoint,),
AccessPointAdded,
AccessPointRemoved,
>(
wifibox_ref_listener.imp().listener_active.clone(),
sender_ref,
);
>(listeners.clone(), sender_ref);
if res.is_err() {
println!("Could not connect listener");
}
loop {
let wifiEntriesListener = wifiEntriesListener.clone();
if wifiBoxImpl
.listener_active
if listeners
.network_listener
.load(std::sync::atomic::Ordering::SeqCst)
== false
{
@ -121,26 +119,23 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
glib::spawn_future(async move {
glib::idle_add_once(move || {
let mut wifiEntries = wifiEntriesListener.lock().unwrap();
let path = access_point.0.dbus_path.clone();
if wifiEntries.get(&path).is_some() {
// don't add the entry if it exists, somehow networkmanager
// spams these added things?
// TODO perhaps use ssid?
let ssid = access_point.0.ssid.clone();
if wifiEntries.get(&ssid).is_some() {
return;
}
let entry =
Arc::new(ListEntry::new(&*WifiEntry::new(access_point.0)));
wifiEntries.insert(path, entry.clone());
wifiEntries.insert(ssid, entry.clone());
wifiBoxImpl.imp().resetWifiList.append(&*entry);
});
});
}
Events::RemovedEvent(path) => {
Events::RemovedEvent(access_point) => {
let wifiBoxImpl = wifibox_ref_listener.clone();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let mut wifiEntries = wifiEntriesListener.lock().unwrap();
let entry = wifiEntries.remove(&path.0);
let entry = wifiEntries.remove(&access_point.0.ssid);
if entry.is_none() {
return;
}
@ -158,27 +153,18 @@ pub fn scanForWifi(wifiBox: Arc<WifiBox>) {
pub fn show_stored_connections(wifiBox: Arc<WifiBox>) {
let wifibox_ref = wifiBox.clone();
let wifiEntries = wifiBox.imp().savedWifiEntries.clone();
gio::spawn_blocking(move || {
let connections = get_stored_connections();
let wifiEntries = wifiEntries.clone();
{
let mut wifiEntries = wifiEntries.lock().unwrap();
for connection in connections {
// TODO include button for settings
let name = &String::from_utf8(connection.1).unwrap_or_else(|_| String::from(""));
let entry = ListEntry::new(&SavedWifiEntry::new(name, connection.0));
entry.set_activatable(false);
wifiEntries.push(entry);
}
}
glib::spawn_future(async move {
glib::idle_add_once(move || {
let wifiEntries = wifiEntries.lock().unwrap();
let selfImp = wifibox_ref.imp();
for wifiEntry in wifiEntries.iter() {
selfImp.resetStoredWifiList.append(wifiEntry);
for connection in connections {
// TODO include button for settings
let name =
&String::from_utf8(connection.1).unwrap_or_else(|_| String::from(""));
let entry = ListEntry::new(&SavedWifiEntry::new(name, connection.0));
entry.set_activatable(false);
selfImp.resetStoredWifiList.append(&entry);
}
});
});
@ -262,7 +248,7 @@ pub fn start_event_listener<
AddedEvent: ReadAll + AppendAll + dbus::message::SignalArgs + GetVal<AddedType>,
RemovedEvent: ReadAll + AppendAll + dbus::message::SignalArgs + GetVal<RemovedType>,
>(
active_listener: Arc<AtomicBool>,
listeners: Arc<Listeners>,
sender: Arc<Sender<Events<AddedType, RemovedType>>>,
) -> Result<(), dbus::Error> {
thread::spawn(move || {
@ -311,11 +297,11 @@ pub fn start_event_listener<
"Failed to match signal on ReSet.",
));
}
active_listener.store(true, Ordering::SeqCst);
listeners.network_listener.store(true, Ordering::SeqCst);
println!("starting thread listener");
loop {
let _ = conn.process(Duration::from_millis(1000))?;
if !active_listener.load(Ordering::SeqCst) {
if !listeners.network_listener.load(Ordering::SeqCst) {
println!("stopping thread listener");
break;
}

3
src/components/wifi/wifiBoxImpl.rs
View file

@ -27,9 +27,8 @@ pub struct WifiBox {
pub resetStoredWifiList: TemplateChild<ListBox>,
#[template_child]
pub resetAvailableNetworks: TemplateChild<ListEntry>,
pub wifiEntries: Arc<Mutex<HashMap<Path<'static>,Arc<ListEntry>>>>,
pub wifiEntries: Arc<Mutex<HashMap<Vec<u8>,Arc<ListEntry>>>>,
pub savedWifiEntries: Arc<Mutex<Vec<ListEntry>>>,
pub listener_active: Arc<AtomicBool>,
}
unsafe impl Send for WifiBox {}

7
src/components/wifi/wifiEntry.rs
View file

@ -62,14 +62,11 @@ impl WifiEntry {
entryImp.accessPoint.set(access_point);
let gesture = GestureClick::new();
if stored {
entryImp
.resetWifiStored
.get()
.set_from_icon_name(Some("document-save-symbolic"));
gesture.connect_released(move |_, _, _, _| {
click_stored_network(stored_entry.clone());
});
} else {
entryImp.resetWifiEditButton.set_sensitive(false);
gesture.connect_released(move |_, _, _, _| {
click_new_network(new_entry.clone());
});
@ -93,11 +90,9 @@ pub fn click_stored_network(entry: Arc<WifiEntry>) {
let root = &entry.root().unwrap();
let root = root.downcast_ref::<gtk::Window>();
if root.is_none() {
println!("ERROR BRO");
return;
}
let root = root.unwrap();
// TODO handle unknown access point -> should be done by having 2 different categories
let entryImp = entry.imp();
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(

2
src/components/wifi/wifiEntryImpl.rs
View file

@ -20,8 +20,6 @@ pub struct WifiEntry {
#[template_child]
pub resetWifiConnected: TemplateChild<Image>,
#[template_child]
pub resetWifiStored: TemplateChild<Image>,
#[template_child]
pub resetWifiPopup: TemplateChild<Popup>,
pub wifiName: RefCell<String>,
pub wifiStrength: RefCell<WifiStrength>,