feat: implement wifi-connection plugin

Cargo.toml

@@ -6,4 +6,5 @@ members = [
   "plugin-run",
   "plugin-desktop",
   "plugin-audio",
+  "plugin-network",
 ]

Makefile

@@ -21,6 +21,7 @@ deploy:
 	cp -vf ./target/release/desktop ${DEST}/drun
 	cp -vf ./target/release/run ${DEST}/run
 	cp -vf ./target/release/audio ${DEST}/audio
+	cp -vf ./target/release/rmenu-network ${DEST}/network
 	cp -vf ./rmenu/public/config.yaml ${DEST}/config.yaml
 
 build: build-rmenu build-plugins
@@ -32,3 +33,4 @@ build-plugins:
 	${CARGO} build -p run ${FLAGS}
 	${CARGO} build -p desktop ${FLAGS}
 	${CARGO} build -p audio ${FLAGS}
+	${CARGO} build -p rmenu-network ${FLAGS}

plugin-network/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "rmenu-network"
+version = "0.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.72"
+async-std = "1.12.0"
+clap = { version = "4.3.21", features = ["derive"] }
+dioxus = "0.4.0"
+dioxus-desktop = "0.4.0"
+dioxus-free-icons = { version = "0.7.0", features = ["font-awesome-regular"] }
+env_logger = "0.10.0"
+futures-channel = "0.3.28"
+glib = { git = "https://github.com/gtk-rs/gtk-rs-core", version = "0.19.0" }
+keyboard-types = "0.6.2"
+log = "0.4.20"
+nm = { git = "https://github.com/balena-io-modules/libnm-rs.git", version = "0.4.0" }
+once_cell = "1.18.0"
+rmenu-plugin = { version = "0.0.0", path = "../rmenu-plugin" }
+serde_json = "1.0.104"

plugin-network/public/default.css

@@ -0,0 +1,96 @@
+
+html, body {
+  overflow: hidden;
+  font-size: 14px;
+  background-color: #e8edee;
+}
+
+#header {
+  padding: 0.15rem;
+}
+
+#controls {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  margin-top: 0.5rem;
+}
+
+#secret {
+  width: -webkit-fill-available;
+  height: 2rem;
+
+  border: none;
+  outline: none;
+  padding: 0 0.5rem;
+  background-color: #ccd2df;
+}
+
+#icon {
+  float: right;
+  position: relative;
+  z-index: 2;
+  margin-left: -2.5rem;
+ 
+  display: flex;
+  align-items: center;
+  height: 2rem;
+  border: none;
+  background: none;
+}
+
+@keyframes movein {
+  from { margin-top: 10rem; }
+  to   { margin-top: 1rem; }
+}
+
+@keyframes moveout {
+  from { margin-top: 1rem; }
+  to   { bottom: 10rem; }
+}
+
+#message {
+  display: flex;
+  justify-content: center;
+  margin-top: 1rem; 
+  
+  font-size: 15px;
+  font-style: italic;
+  animation: movein 0.5s ease-in-out;
+}
+
+#message.error {
+  color: white;
+  background-color: #de5a5a;
+}
+
+#message.success {
+  color: white;
+  background-color: #53c351;
+}
+
+#blackout {
+  display:  none;
+  width:    100%;
+  height:   100%; 
+  position: absolute;
+  top:      0;
+  left:     0; 
+  z-index:  100; 
+
+  background-color: black;
+  filter: alpha(opacity=30);
+  opacity: 0.3;
+}
+
+#blackout > #spinner {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+#blackout.active {
+  display: block;
+}

plugin-network/public/spinner.css

@@ -0,0 +1,78 @@
+.lds-spinner {
+  color: official;
+  display: inline-block;
+  position: relative;
+  width: 80px;
+  height: 80px;
+}
+.lds-spinner div {
+  transform-origin: 40px 40px;
+  animation: lds-spinner 1.2s linear infinite;
+}
+.lds-spinner div:after {
+  content: " ";
+  display: block;
+  position: absolute;
+  top: 3px;
+  left: 37px;
+  width: 6px;
+  height: 18px;
+  border-radius: 20%;
+  background: #fff;
+}
+.lds-spinner div:nth-child(1) {
+  transform: rotate(0deg);
+  animation-delay: -1.1s;
+}
+.lds-spinner div:nth-child(2) {
+  transform: rotate(30deg);
+  animation-delay: -1s;
+}
+.lds-spinner div:nth-child(3) {
+  transform: rotate(60deg);
+  animation-delay: -0.9s;
+}
+.lds-spinner div:nth-child(4) {
+  transform: rotate(90deg);
+  animation-delay: -0.8s;
+}
+.lds-spinner div:nth-child(5) {
+  transform: rotate(120deg);
+  animation-delay: -0.7s;
+}
+.lds-spinner div:nth-child(6) {
+  transform: rotate(150deg);
+  animation-delay: -0.6s;
+}
+.lds-spinner div:nth-child(7) {
+  transform: rotate(180deg);
+  animation-delay: -0.5s;
+}
+.lds-spinner div:nth-child(8) {
+  transform: rotate(210deg);
+  animation-delay: -0.4s;
+}
+.lds-spinner div:nth-child(9) {
+  transform: rotate(240deg);
+  animation-delay: -0.3s;
+}
+.lds-spinner div:nth-child(10) {
+  transform: rotate(270deg);
+  animation-delay: -0.2s;
+}
+.lds-spinner div:nth-child(11) {
+  transform: rotate(300deg);
+  animation-delay: -0.1s;
+}
+.lds-spinner div:nth-child(12) {
+  transform: rotate(330deg);
+  animation-delay: 0s;
+}
+@keyframes lds-spinner {
+  0% {
+    opacity: 1;
+  }
+  100% {
+    opacity: 0;
+  }
+}

plugin-network/public/spinner.html

@@ -0,0 +1,14 @@
+<div class="lds-spinner">
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+  <div></div>
+</div>

plugin-network/src/gui.rs

@@ -0,0 +1,211 @@
+#![allow(non_snake_case)]
+
+///! NetworkManager Authenticator GUI
+use anyhow::{anyhow, Result};
+use dioxus::prelude::*;
+use dioxus_desktop::LogicalSize;
+use dioxus_free_icons::icons::fa_regular_icons::{FaEye, FaEyeSlash};
+use dioxus_free_icons::Icon;
+use keyboard_types::Code;
+
+use crate::network::Manager;
+
+static SPINNER_CSS: &'static str = include_str!("../public/spinner.css");
+static SPINNER_HTML: &'static str = include_str!("../public/spinner.html");
+static DEFAULT_CSS_CONTENT: &'static str = include_str!("../public/default.css");
+
+/// Run GUI Application
+pub fn run_app(ssid: &str, timeout: u32) {
+    let builder = dioxus_desktop::WindowBuilder::new()
+        .with_title("RMenu - Network Login")
+        .with_inner_size(LogicalSize {
+            width: 400,
+            height: 150,
+        })
+        .with_focused(true)
+        .with_decorations(false)
+        .with_always_on_top(true);
+    dioxus_desktop::launch_with_props(
+        App,
+        AppProp {
+            ssid: ssid.to_owned(),
+            timeout,
+        },
+        dioxus_desktop::Config::new().with_window(builder),
+    );
+}
+
+/// Message to send to GUI
+#[derive(Debug, Clone, PartialEq)]
+pub enum UserMessage {
+    Nothing,
+    Error(String),
+    Success(String),
+}
+
+impl UserMessage {
+    /// Retrieve CSS-Class to use on UserMessage
+    fn css_class(&self) -> &str {
+        match self {
+            Self::Error(_) => "error",
+            Self::Success(_) => "success",
+            Self::Nothing => "none",
+        }
+    }
+    /// Retrieve Message Value
+    fn message(&self) -> Option<String> {
+        match self {
+            Self::Nothing => None,
+            Self::Error(msg) => Some(msg.to_owned()),
+            Self::Success(msg) => Some(msg.to_owned()),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Props)]
+struct AppProp {
+    ssid: String,
+    timeout: u32,
+}
+
+//TODO: add auth timeout
+
+/// Set Cursor/Keyboard Focus onto Input
+#[inline]
+fn focus<T>(cx: Scope<T>) {
+    let eval = use_eval(cx);
+    let js = "document.getElementById(`secret`).focus()";
+    let _ = eval(&js);
+}
+
+/// Complete Network Connection/Authentication Attempt
+async fn connect_async(ssid: String, timeout: u32, secret: &str) -> Result<()> {
+    // retrieve access-point from manager
+    let manager = Manager::new().await?.with_timeout(timeout);
+    let access_point = manager
+        .access_points()
+        .into_iter()
+        .find(|a| a.ssid == ssid)
+        .ok_or_else(|| anyhow!("Unable to find Access Point: {ssid:?}"))?;
+    // attempt to establish connection w/ secret
+    log::debug!("Found AccessPoint: {ssid:?} | {:?}", access_point.security);
+    manager.connect(&access_point, Some(secret)).await
+}
+
+/// Simple Login GUI Application
+fn App(cx: Scope<AppProp>) -> Element {
+    let secret = use_state(cx, || String::new());
+    let message = use_state(cx, || UserMessage::Nothing);
+    let show_secret = use_state(cx, || false);
+    let loading = use_state(cx, || false);
+
+    // always ensure focus
+    focus(cx);
+
+    // build keyboard actions event handler
+    let keyboard_controls = move |e: KeyboardEvent| match e.code() {
+        Code::Escape => std::process::exit(0),
+        Code::Enter => {
+            let ssid = cx.props.ssid.to_owned();
+            let timeout = cx.props.timeout.to_owned();
+            let secret = secret.get().to_owned();
+            let message = message.to_owned();
+            let loading = loading.to_owned();
+            loading.set(true);
+            message.set(UserMessage::Nothing);
+
+            cx.spawn(async move {
+                log::info!("connecting to ssid: {ssid:?}");
+                let result = connect_async(ssid, timeout, &secret).await;
+                log::info!("connection result: {result:?}");
+                match result {
+                    Ok(_) => {
+                        // update message and unlock gui
+                        message.set(UserMessage::Success("Connection Complete!".to_owned()));
+                        loading.set(false);
+                        // exit program after timeout
+                        let wait = std::time::Duration::from_secs(1);
+                        async_std::task::sleep(wait).await;
+                        std::process::exit(0);
+                    }
+                    Err(err) => {
+                        message.set(UserMessage::Error(format!("Connection Failed: {err:?}")));
+                        loading.set(false);
+                    }
+                }
+            });
+        }
+        _ => {}
+    };
+
+    // retrieve message details / set input-type / get loading css-class
+    let msg_css = message.css_class();
+    let msg_str = message.message();
+    let input_type = match show_secret.get() {
+        true => "text",
+        false => "password",
+    };
+    let blackout_css = match loading.get() {
+        true => "active",
+        false => "",
+    };
+
+    // complete final rendering
+    cx.render(rsx! {
+        style { DEFAULT_CSS_CONTENT }
+        style { SPINNER_CSS }
+        div {
+            onkeydown: keyboard_controls,
+            label {
+                id: "header",
+                "for": "secret",
+                "Wi-Fi Network {cx.props.ssid:?} Requires a Password"
+            }
+            div {
+                id: "controls",
+                input {
+                    id: "secret",
+                    value: "{secret}",
+                    placeholder: "Password",
+                    oninput: move |e| secret.set(e.value.clone()),
+                    "type": "{input_type}"
+                }
+                button {
+                    id: "icon",
+                    onclick: |_| show_secret.modify(|v| !v),
+                    match show_secret.get() {
+                        true => cx.render(rsx! {
+                            Icon {
+                                fill: "black",
+                                icon: FaEye,
+                            }
+                        }),
+                        false => cx.render(rsx! {
+                            Icon {
+                                fill: "black",
+                                icon: FaEyeSlash,
+                            }
+                        })
+                    }
+                }
+            }
+            if let Some(msg) = msg_str {
+                cx.render(rsx! {
+                    div {
+                        id: "message",
+                        class: "{msg_css}",
+                        "{msg}"
+                    }
+                })
+            }
+            div {
+                id: "blackout",
+                class: "{blackout_css}",
+                div {
+                    id: "spinner",
+                    dangerous_inner_html: "{SPINNER_HTML}"
+                }
+            }
+        }
+    })
+}

plugin-network/src/main.rs

@@ -0,0 +1,105 @@
+use anyhow::{anyhow, Result};
+
+use clap::{Parser, Subcommand};
+use rmenu_plugin::Entry;
+
+mod gui;
+mod network;
+
+#[derive(Debug, Subcommand)]
+pub enum Commands {
+    ListAccessPoints,
+    Connect { ssid: String, timeout: Option<u32> },
+}
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+#[command(propagate_version = true)]
+pub struct Cli {
+    #[clap(subcommand)]
+    command: Option<Commands>,
+}
+
+/// Get Signal Bars based on a signal-value
+fn get_bars(signal: u8) -> String {
+    if signal >= 80 {
+        return "▂▄▆█".to_owned();
+    }
+    if signal > 50 {
+        return "▂▄▆_".to_owned();
+    }
+    if signal > 30 {
+        return "▂▄__".to_owned();
+    }
+    "▂___".to_owned()
+}
+
+/// List AccessPoints using NetworkManager
+async fn list_aps() -> Result<()> {
+    let exe = std::env::current_exe()?.to_str().unwrap().to_string();
+    // spawn manager and complete scan (if nessesary)
+    let manager = network::Manager::new().await?;
+    if !manager.scanned_recently() {
+        log::info!("Scanning for Access-Points...");
+        manager.scan_wifi().await?;
+    }
+    // retrive access-points and print as entries
+    for ap in manager.access_points() {
+        let star = ap.is_active.then(|| " *").unwrap_or("");
+        let bars = get_bars(ap.signal);
+        let desc = format!("{bars} {}{star}", ap.ssid);
+        let exec = format!("{exe} connect {:?}", ap.ssid);
+        let entry = Entry::new(&desc, &exec, None);
+        println!("{}", serde_json::to_string(&entry).unwrap());
+    }
+    Ok(())
+}
+
+/// Attempt to Connect to the Specified SSID (If Connection Already Exists)
+async fn try_connect_ap(ssid: String, timeout: Option<u32>) -> Result<bool> {
+    // spawn manager and complete scan (if nessesary)
+    let mut manager = network::Manager::new().await?;
+    if let Some(timeout) = timeout {
+        manager = manager.with_timeout(timeout)
+    }
+    if !manager.scanned_recently() {
+        log::info!("Scanning for Access-Points...");
+        manager.scan_wifi().await?;
+    }
+    // attempt to find access-point
+    let access_point = manager
+        .access_points()
+        .into_iter()
+        .find(|ap| ap.ssid == ssid)
+        .ok_or_else(|| anyhow!("Unable to find Access-Point: {ssid:?}"))?;
+    // if connection already exists, try to connect
+    if access_point.connection.is_some() {
+        log::info!("Attempting Connection to {ssid:?} w/o Password");
+        match manager.connect(&access_point, None).await {
+            Err(err) => log::info!("Connection Failed: {err:?}"),
+            Ok(_) => {
+                log::info!("Connection Successful!");
+                return Ok(true);
+            }
+        };
+    }
+    Ok(false)
+}
+
+fn main() -> Result<()> {
+    env_logger::init();
+    let cli = Cli::parse();
+    let context = glib::MainContext::default();
+    let command = cli.command.unwrap_or(Commands::ListAccessPoints);
+    match command {
+        Commands::ListAccessPoints => context.block_on(list_aps())?,
+        Commands::Connect { ssid, timeout } => {
+            let connected = context.block_on(try_connect_ap(ssid.clone(), timeout))?;
+            if !connected {
+                log::info!("Spawning GUI to complete AP Login");
+                gui::run_app(&ssid, timeout.unwrap_or(30));
+            }
+        }
+    }
+    Ok(())
+}

plugin-network/src/network.rs

@@ -0,0 +1,309 @@
+use glib::translate::FromGlib;
+
+use async_std::task;
+use futures_channel::oneshot;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::rc::Rc;
+use std::time::{Duration, SystemTime};
+
+use anyhow::{anyhow, Context, Result};
+use nm::*;
+
+static SCAN_INTERVAL_MS: u64 = 500;
+static SCAN_TOTAL_WAIT: u64 = 3;
+static SCAN_BETWEEN: i64 = 30;
+
+/// NetworkManager Simplified API
+#[derive(Debug)]
+pub struct Manager {
+    client: Client,
+    wifi: DeviceWifi,
+    timeout: Duration,
+}
+
+/// AccessPoint Information
+#[derive(Debug)]
+pub struct AccessPoint {
+    pub in_use: bool,
+    pub ssid: String,
+    pub rate: u32,
+    pub signal: u8,
+    pub security: String,
+    pub is_active: bool,
+    pub connection: Option<Connection>,
+}
+
+// SETTING_WIRELESS_MODE
+// SETTING_IP4_CONFIG_METHOD_AUTO
+
+/// Generate a NEW Connection to Use AccessPoint
+fn new_conn(ap: &AccessPoint, password: Option<&str>) -> Result<SimpleConnection> {
+    let connection = SimpleConnection::new();
+
+    // configure generate connection settings
+    let s_connection = SettingConnection::new();
+    s_connection.set_type(Some(&SETTING_WIRELESS_SETTING_NAME));
+    s_connection.set_id(Some(&ap.ssid));
+    s_connection.set_autoconnect(false);
+    // s_connection.set_interface_name(interface);
+    connection.add_setting(s_connection);
+
+    // configure wireless settings
+    let s_wireless = SettingWireless::new();
+    s_wireless.set_ssid(Some(&(ap.ssid.as_bytes().into())));
+    // s_wireless.set_band(Some("bg"));
+    // s_wireless.set_hidden(false);
+    // s_wireless.set_mode(Some(&SETTING_WIRELESS_MODE));
+    connection.add_setting(s_wireless);
+
+    // configure login settings
+    if let Some(password) = password {
+        //TODO: potentially determine key-mgmt based on ap-security
+        let s_wireless_security = SettingWirelessSecurity::new();
+        s_wireless_security.set_key_mgmt(Some("wpa-psk"));
+        s_wireless_security.set_psk(Some(password));
+        connection.add_setting(s_wireless_security);
+    }
+
+    // assume DHCP Assignment
+    let s_ip4 = SettingIP4Config::new();
+    s_ip4.set_method(Some(&SETTING_IP4_CONFIG_METHOD_AUTO));
+    connection.add_setting(s_ip4);
+
+    Ok(connection)
+}
+
+/// Exit Security Section to Specify New Password
+fn edit_conn(conn: &Connection, password: Option<&str>) -> Result<()> {
+    let s_wireless_security = conn
+        .setting_wireless_security()
+        .unwrap_or_else(|| SettingWirelessSecurity::new());
+    s_wireless_security.set_key_mgmt(Some("wpa-psk"));
+    s_wireless_security.set_psk(password);
+    conn.add_setting(s_wireless_security);
+    Ok(())
+}
+
+/// Wait for Connection to Fail or Complete
+async fn wait_conn(active: &ActiveConnection, timeout: Duration) -> Result<()> {
+    // spawn communication channels
+    let (sender, receiver) = oneshot::channel::<Result<()>>();
+    let sender = Rc::new(RefCell::new(Some(sender)));
+    // spawn state-callback
+    active.connect_state_changed(move |active_connection, state, _| {
+        let sender = sender.clone();
+        let active_connection = active_connection.clone();
+        glib::MainContext::ref_thread_default().spawn_local(async move {
+            let state = unsafe { ActiveConnectionState::from_glib(state as _) };
+            log::debug!("[Connect] Active connection state: {:?}", state);
+            // generate send function
+            let send = move |result| {
+                let sender = sender.borrow_mut().take();
+                if let Some(sender) = sender {
+                    sender.send(result).expect("Sender Dropped");
+                }
+            };
+            // handle connection state-changes
+            match state {
+                ActiveConnectionState::Activated => {
+                    log::debug!("[Connect] Successfully activated");
+                    return send(Ok(()));
+                }
+                ActiveConnectionState::Deactivated => {
+                    log::debug!("[Connect] Connection deactivated");
+                    match active_connection.connection() {
+                        Some(remote_connection) => {
+                            let result = remote_connection
+                                .delete_future()
+                                .await
+                                .context("Failed to delete connection");
+                            if result.is_err() {
+                                return send(result);
+                            }
+                            return send(Err(anyhow!("Connection Failed (Deactivated)")));
+                        }
+                        None => {
+                            return send(Err(anyhow!(
+                                "Failed to get remote connection from active connection"
+                            )))
+                        }
+                    }
+                }
+                _ => {}
+            };
+        });
+    });
+    // wait until state notification is done
+    let result = async_std::future::timeout(timeout, receiver).await;
+    match result {
+        Ok(result) => match result {
+            Ok(res) => res,
+            Err(err) => Err(anyhow!("Connection Cancelled: {err:?}")),
+        },
+        Err(err) => Err(anyhow!("Timeout Reached: {err:?}")),
+    }
+}
+
+impl Manager {
+    /// Spawn new Wifi Manager Instance
+    pub async fn new() -> Result<Self> {
+        // get network-manager client
+        let client = Client::new_future()
+            .await
+            .context("Failed to create NM Client")?;
+        // get wifi device if any are available
+        let device = client
+            .devices()
+            .into_iter()
+            .filter(|d| d.device_type() == DeviceType::Wifi)
+            .next()
+            .ok_or_else(|| anyhow!("Cannot find a Wi-Fi device"))?;
+        // access inner wifi-device object
+        let wifi: DeviceWifi = device
+            .downcast()
+            .map_err(|_| anyhow!("Failed to Access Wi-Fi Device"))?;
+        log::debug!("NetworkManager Connection Established");
+        Ok(Self {
+            client,
+            wifi,
+            timeout: Duration::from_secs(30),
+        })
+    }
+
+    /// Update Manager Timeout and Return Self
+    pub fn with_timeout(mut self, secs: u32) -> Self {
+        self.timeout = Duration::from_secs(secs.into());
+        self
+    }
+
+    /// Check if NetworkManager already scanned recently
+    pub fn scanned_recently(&self) -> bool {
+        let last_ms = self.wifi.last_scan();
+        let now_ms = utils_get_timestamp_msec();
+        let elapsed = (now_ms - last_ms) / 1000;
+        last_ms > 0 && elapsed < SCAN_BETWEEN
+    }
+
+    /// Complete General Wifi-Scan
+    pub async fn scan_wifi(&self) -> Result<()> {
+        // request wifi-scan
+        self.wifi
+            .request_scan_future()
+            .await
+            .context("Failed to Request Wi-Fi Scan")?;
+        // wait until access-points are collected
+        let mut then = SystemTime::now();
+        let mut current = self.wifi.access_points().len();
+        loop {
+            // wait interval for more access-points
+            task::sleep(Duration::from_millis(SCAN_INTERVAL_MS)).await;
+            // check if time has elapsed
+            let now = SystemTime::now();
+            let elapsed = now.duration_since(then)?;
+            if elapsed.as_secs() > SCAN_TOTAL_WAIT {
+                break;
+            }
+            // check if more access-points were discovered
+            let found = self.wifi.access_points().len();
+            if found > current {
+                then = now;
+                current = found;
+            }
+        }
+        Ok(())
+    }
+
+    /// Retrieve Access-Point Information
+    pub fn access_points(&self) -> Vec<AccessPoint> {
+        let conns: Vec<Connection> = self
+            .client
+            .connections()
+            .into_iter()
+            .map(|c| c.upcast())
+            .collect();
+        let mut access: BTreeMap<String, AccessPoint> = BTreeMap::new();
+        let active = self.wifi.active_access_point();
+        for a in self.wifi.access_points() {
+            // retrieve access-point information
+            let rate = a.max_bitrate() / 1000;
+            let signal = a.strength();
+            let ssid = a
+                .ssid()
+                .map(|b| b.escape_ascii().to_string())
+                .unwrap_or_else(|| "--".to_owned());
+            // determine if connection-map should be updated
+            let is_active = active
+                .as_ref()
+                .map(|b| a.bssid() == b.bssid())
+                .unwrap_or(false);
+            if !is_active {
+                if let Some(point) = access.get(&ssid) {
+                    if point.rate > rate {
+                        continue;
+                    }
+                }
+            }
+            // build security-string
+            let mut security = vec![];
+            let wpa_flags = a.wpa_flags();
+            let wpa2_flags = a.rsn_flags();
+            if !wpa_flags.is_empty() {
+                security.push("WPA1");
+            }
+            if !wpa2_flags.is_empty() {
+                security.push("WPA2");
+            }
+            if wpa2_flags.intersects(_80211ApSecurityFlags::KEY_MGMT_802_1X) {
+                security.push("802.1X");
+            }
+            if security.is_empty() {
+                security.push("--");
+            }
+            // insert access-point
+            access.insert(
+                ssid.to_owned(),
+                AccessPoint {
+                    in_use: is_active,
+                    ssid,
+                    rate,
+                    signal,
+                    is_active,
+                    security: security.join(" ").to_owned(),
+                    connection: a.filter_connections(&conns).get(0).cloned(),
+                },
+            );
+        }
+        // move map values into vector and sort by signal-strength
+        let mut points: Vec<AccessPoint> = access.into_values().collect();
+        points.sort_by_key(|a| a.signal);
+        points.reverse();
+        points
+    }
+
+    /// Attempt to Authenticate and Activate Access-Point Connection
+    pub async fn connect(&self, ap: &AccessPoint, password: Option<&str>) -> Result<()> {
+        let device = self.wifi.clone().upcast::<Device>();
+        match &ap.connection {
+            Some(conn) => {
+                edit_conn(conn, password)?;
+                let active_conn = self
+                    .client
+                    .activate_connection_future(Some(conn), Some(&device), None)
+                    .await
+                    .context("Failed to activate existing connection")?;
+                wait_conn(&active_conn, self.timeout).await?;
+            }
+            None => {
+                let conn = new_conn(ap, password)?;
+                let active_conn = self
+                    .client
+                    .add_and_activate_connection_future(Some(&conn), Some(&device), None)
+                    .await
+                    .context("Failed to add and activate connection")?;
+                wait_conn(&active_conn, self.timeout).await?;
+            }
+        }
+        Ok(())
+    }
+}

rmenu/public/99-rmenu-sway.conf

@@ -1,3 +1,4 @@
 # Configure RMenu to Spawn Floating in the Center of the Screen
 
 for_window [app_id="rmenu"] floating enable
+for_window [app_id="rmenu-network"] floating enable

rmenu/public/config.yaml

@@ -29,6 +29,10 @@ plugins:
     exec:  ["~/.config/rmenu/audio"]
     cache: false
     placeholder: "Select an Audio Sink"
+  network:
+    exec:  ["~/.config/rmenu/network"]
+    cache: false
+    placeholder: "Connect to the Specified Wi-Fi"
 
 # custom keybindings
 keybinds: