Implement password

src/components/wifi/wifiEntry.rs

@@ -84,7 +84,7 @@ impl WifiEntry {
         let selfImp = self.imp();
         selfImp.resetWifiEditButton.connect_clicked(clone!(@ weak selfImp, @ weak wifiBox => move |_| {
             let _option = getConnectionSettings(selfImp.accessPoint.borrow().associated_connection.clone());
-            wifiBox.resetWifiNavigation.push(&*WifiOptions::new(_option));
+            wifiBox.resetWifiNavigation.push(&*WifiOptions::new(_option, selfImp.accessPoint.borrow().dbus_path.clone()));
         }));
     }
 }

src/components/wifi/wifiOptions.rs

@@ -1,14 +1,18 @@
 use std::net::{Ipv4Addr, Ipv6Addr};
 use std::str::FromStr;
 use std::sync::Arc;
+use std::time::Duration;
 
-use adw::glib;
+use adw::{gio, glib};
 use adw::glib::Object;
 use adw::prelude::{ActionRowExt, ComboRowExt, PreferencesGroupExt};
 use adw::subclass::prelude::ObjectSubclassIsExt;
+use dbus::{Error, Path};
+use dbus::arg::PropMap;
 use glib::{clone, PropertySet};
 use gtk::prelude::{ButtonExt, EditableExt, WidgetExt};
 use ReSet_Lib::network::connection::{Connection, DNSMethod4, DNSMethod6, Enum, TypeSettings};
+use ReSet_Lib::network::network::AccessPoint;
 use IpProtocol::{IPv4, IPv6};
 
 use crate::components::wifi::utils::IpProtocol;
@@ -23,11 +27,11 @@ glib::wrapper! {
 }
 
 impl WifiOptions {
-    pub fn new(connection: Connection) -> Arc<Self> {
+    pub fn new(connection: Connection, accessPoint: Path<'static>) -> Arc<Self> {
         let wifiOption: Arc<WifiOptions> = Arc::new(Object::builder().build());
         wifiOption.imp().connection.set(connection);
         wifiOption.initializeUI();
-        setupCallbacks(&wifiOption);
+        setupCallbacks(&wifiOption, accessPoint);
         wifiOption
     }
 
@@ -45,7 +49,6 @@ impl WifiOptions {
             ip6RouteLength = conn.ipv4.route_data.len();
 
             // General
-
             selfImp.resetWifiAutoConnect.set_active(conn.settings.autoconnect);
             selfImp.resetWifiMetered.set_active(conn.settings.metered != -1);
             match &conn.device {
@@ -91,7 +94,23 @@ impl WifiOptions {
             }).collect();
             selfImp.resetIP6DNS.set_text(&ipv6Dns.join(", "));
             selfImp.resetIP6Gateway.set_text(&conn.ipv6.gateway);
-            dbg!(conn);
+
+            // Security
+            if let TypeSettings::WIFI(wifi) = &conn.device {
+                match wifi.security_settings.key_management.as_str() {
+                    "none" => {
+                        selfImp.resetWifiSecurityDropdown.set_selected(0);
+                        selfImp.resetWifiPassword.set_visible(false);
+                        selfImp.resetWifiPassword.set_text("");
+                    }
+                    "wpa-psk" => {
+                        selfImp.resetWifiSecurityDropdown.set_selected(1);
+                        selfImp.resetWifiPassword.set_visible(true);
+                        selfImp.resetWifiPassword.set_text(&wifi.security_settings.psk);
+                    }
+                    _ => {}
+                }
+            }
         }
         // IPv4
         for i in 0..ip4AddressLength {
@@ -118,11 +137,12 @@ impl WifiOptions {
 
         for i in 0..ip6RouteLength {
             let route = &WifiRouteEntry::new(Some(i), selfImp.connection.clone(), IPv6);
-            selfImp.resetIP6RoutesGroup.add(route)
+            selfImp.resetIP6RoutesGroup.add(route);
         }
         let route = &WifiRouteEntry::new(None, selfImp.connection.clone(), IPv6);
-        selfImp.resetIP6RoutesGroup.add(route)
+        selfImp.resetIP6RoutesGroup.add(route);
         // Security
+        dbg!(selfImp.connection.borrow());
     }
 
     pub fn setIP4Visibility(&self, method: u32) {
@@ -168,9 +188,8 @@ impl WifiOptions {
     }
 }
 
-fn setupCallbacks(wifiOptions: &Arc<WifiOptions>) {
+fn setupCallbacks(wifiOptions: &Arc<WifiOptions>, path: Path<'static>) {
     let imp = wifiOptions.imp();
-
     // General
     imp.resetWifiAutoConnect.connect_active_notify(clone!(@weak imp => move |x| {
         imp.connection.borrow_mut().settings.autoconnect = x.is_active();
@@ -180,7 +199,7 @@ fn setupCallbacks(wifiOptions: &Arc<WifiOptions>) {
     }));
     imp.wifiOptionsApplyButton.connect_clicked(clone!(@weak imp => move |_| {
         let prop = imp.connection.borrow().convert_to_propmap();
-        // todo send to daemon somehow
+        setConnectionSettings(path.clone(), prop);
     }));
     // IPv4
     let wifiOptionsIP4 = wifiOptions.clone();
@@ -274,5 +293,48 @@ fn setupCallbacks(wifiOptions: &Arc<WifiOptions>) {
             imp.resetIP6Gateway.add_css_class("error");
         }
     }));
+
     // Security
+    imp.resetWifiSecurityDropdown.connect_selected_notify(clone!(@weak imp => move |dropdown| {
+        let selected = dropdown.selected();
+        let mut conn = imp.connection.borrow_mut();
+
+        match (selected, &mut conn.device) {
+            (0 , TypeSettings::WIFI(wifi)) => { // None
+                imp.resetWifiPassword.set_visible(false);
+                wifi.security_settings.key_management = String::from("none");
+                wifi.security_settings.authentication_algorithm = String::from("open");
+            },
+            (1 , TypeSettings::WIFI(wifi)) => { // WPA/WPA2 Personal
+                imp.resetWifiPassword.set_visible(true);
+                wifi.security_settings.key_management = String::from("wpa-psk");
+                wifi.security_settings.authentication_algorithm = String::from("");
+            },
+            (_, _) => {}
+        }
+    }));
+
+    imp.resetWifiPassword.connect_changed(clone!(@weak imp => move |entry| {
+        let passwordInput = entry.text();
+        let mut conn = imp.connection.borrow_mut();
+        if let TypeSettings::WIFI(wifi) = &mut conn.device {
+            wifi.security_settings.psk = passwordInput.to_string();
+        }
+    }));
 }
+
+fn setConnectionSettings(path: Path<'static>, prop: PropMap) {
+    gio::spawn_blocking(move || {
+        let conn = dbus::blocking::Connection::new_session().unwrap();
+        let proxy = conn.with_proxy(
+            "org.Xetibo.ReSetDaemon",
+            "/org/Xetibo/ReSetDaemon",
+            Duration::from_millis(1000),
+        );
+        let _: Result<(bool,), Error> = proxy.method_call(
+            "org.Xetibo.ReSetWireless",
+            "SetConnectionSettings",
+            (path, prop),
+        );
+    });
+}

src/components/wifi/wifiOptionsImpl.rs

@@ -1,11 +1,12 @@
 use crate::components::wifi::wifiOptions;
 use adw::subclass::prelude::NavigationPageImpl;
-use adw::{ActionRow, ComboRow, EntryRow, NavigationPage, PreferencesGroup, SwitchRow};
+use adw::{ActionRow, ComboRow, EntryRow, NavigationPage, PasswordEntryRow, PreferencesGroup, SwitchRow};
 use gtk::subclass::prelude::*;
 use gtk::{glib, Button, CompositeTemplate};
 use std::cell::RefCell;
 use std::rc::Rc;
 use ReSet_Lib::network::connection::Connection;
+use ReSet_Lib::network::network::AccessPoint;
 
 #[allow(non_snake_case)]
 #[derive(Default, CompositeTemplate)]
@@ -63,6 +64,10 @@ pub struct WifiOptions {
     #[template_child]
     pub resetIP6RouteAddButton: TemplateChild<Button>,
     // Security
+    #[template_child]
+    pub resetWifiSecurityDropdown: TemplateChild<ComboRow>,
+    #[template_child]
+    pub resetWifiPassword: TemplateChild<PasswordEntryRow>,
     // Misc
     #[template_child]
     pub wifiOptionsApplyButton: TemplateChild<Button>,