refactor: move various clients to own folder

src/modules/focused.rs

@@ -1,6 +1,6 @@
+use crate::clients::wayland::{self, ToplevelChange};
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::wayland::ToplevelChange;
-use crate::{await_sync, icon, wayland};
+use crate::{await_sync, icon};
 use color_eyre::Result;
 use glib::Continue;
 use gtk::prelude::*;

src/modules/launcher/item.rs

@@ -1,9 +1,9 @@
 use super::open_state::OpenState;
+use crate::clients::wayland::ToplevelInfo;
 use crate::icon::get_icon;
 use crate::modules::launcher::{ItemEvent, LauncherUpdate};
 use crate::modules::ModuleUpdateEvent;
 use crate::popup::Popup;
-use crate::wayland::ToplevelInfo;
 use gtk::prelude::*;
 use gtk::{Button, IconTheme, Image, Orientation};
 use indexmap::IndexMap;

src/modules/launcher/mod.rs

@@ -3,10 +3,9 @@ mod open_state;
 
 use self::item::{Item, ItemButton, Window};
 use self::open_state::OpenState;
+use crate::clients::wayland::{self, ToplevelChange};
 use crate::icon::find_desktop_file;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::wayland;
-use crate::wayland::ToplevelChange;
 use color_eyre::{Help, Report};
 use glib::Continue;
 use gtk::prelude::*;

src/modules/launcher/open_state.rs

@@ -1,4 +1,4 @@
-use crate::wayland::ToplevelInfo;
+use crate::clients::wayland::ToplevelInfo;
 
 /// Open state for a launcher item, or item window.
 #[derive(Debug, Clone, Eq, PartialEq, Copy)]

src/modules/mpd.rs

@@ -1,7 +1,4 @@
-mod client;
-
-use crate::modules::mpd::client::MpdConnectionError;
-use crate::modules::mpd::client::{get_client, get_duration, get_elapsed};
+use crate::clients::mpd::{get_client, get_duration, get_elapsed, MpdConnectionError};
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use crate::popup::Popup;
 use color_eyre::Result;

src/modules/mpd/client.rs

@@ -1,167 +0,0 @@
-use lazy_static::lazy_static;
-use mpd_client::client::{CommandError, Connection, ConnectionEvent, Subsystem};
-use mpd_client::commands::Command;
-use mpd_client::protocol::MpdProtocolError;
-use mpd_client::responses::Status;
-use mpd_client::Client;
-use std::collections::HashMap;
-use std::fmt::{Display, Formatter};
-use std::os::unix::fs::FileTypeExt;
-use std::path::PathBuf;
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::net::{TcpStream, UnixStream};
-use tokio::spawn;
-use tokio::sync::broadcast::{channel, error::SendError, Receiver, Sender};
-use tokio::sync::Mutex;
-use tokio::time::sleep;
-use tracing::debug;
-
-lazy_static! {
-    static ref CONNECTIONS: Arc<Mutex<HashMap<String, Arc<MpdClient>>>> =
-        Arc::new(Mutex::new(HashMap::new()));
-}
-
-pub struct MpdClient {
-    client: Client,
-    tx: Sender<()>,
-    _rx: Receiver<()>,
-}
-
-#[derive(Debug)]
-pub enum MpdConnectionError {
-    MaxRetries,
-    ProtocolError(MpdProtocolError),
-}
-
-impl Display for MpdConnectionError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::MaxRetries => write!(f, "Reached max retries"),
-            Self::ProtocolError(e) => write!(f, "{:?}", e),
-        }
-    }
-}
-
-impl std::error::Error for MpdConnectionError {}
-
-impl MpdClient {
-    async fn new(host: &str) -> Result<Self, MpdConnectionError> {
-        debug!("Creating new MPD connection to {}", host);
-
-        let (client, mut state_changes) =
-            wait_for_connection(host, Duration::from_secs(5), None).await?;
-
-        let (tx, rx) = channel(16);
-        let tx2 = tx.clone();
-
-        spawn(async move {
-            while let Some(change) = state_changes.next().await {
-                debug!("Received state change: {:?}", change);
-
-                if let ConnectionEvent::SubsystemChange(
-                    Subsystem::Player | Subsystem::Queue | Subsystem::Mixer,
-                ) = change
-                {
-                    tx2.send(())?;
-                }
-            }
-
-            Ok::<(), SendError<()>>(())
-        });
-
-        Ok(Self {
-            client,
-            tx,
-            _rx: rx,
-        })
-    }
-
-    pub fn subscribe(&self) -> Receiver<()> {
-        self.tx.subscribe()
-    }
-
-    pub async fn command<C: Command>(&self, command: C) -> Result<C::Response, CommandError> {
-        self.client.command(command).await
-    }
-}
-
-pub async fn get_client(host: &str) -> Result<Arc<MpdClient>, MpdConnectionError> {
-    let mut connections = CONNECTIONS.lock().await;
-    match connections.get(host) {
-        None => {
-            let client = MpdClient::new(host).await?;
-            let client = Arc::new(client);
-            connections.insert(host.to_string(), Arc::clone(&client));
-            Ok(client)
-        }
-        Some(client) => Ok(Arc::clone(client)),
-    }
-}
-
-async fn wait_for_connection(
-    host: &str,
-    interval: Duration,
-    max_retries: Option<usize>,
-) -> Result<Connection, MpdConnectionError> {
-    let mut retries = 0;
-    let max_retries = max_retries.unwrap_or(usize::MAX);
-
-    loop {
-        if retries == max_retries {
-            break Err(MpdConnectionError::MaxRetries);
-        }
-
-        retries += 1;
-
-        match try_get_mpd_conn(host).await {
-            Ok(conn) => break Ok(conn),
-            Err(err) => {
-                if retries == max_retries {
-                    break Err(MpdConnectionError::ProtocolError(err));
-                }
-            }
-        }
-
-        sleep(interval).await;
-    }
-}
-
-/// Cycles through each MPD host and
-/// returns the first one which connects,
-/// or none if there are none
-async fn try_get_mpd_conn(host: &str) -> Result<Connection, MpdProtocolError> {
-    if is_unix_socket(host) {
-        connect_unix(host).await
-    } else {
-        connect_tcp(host).await
-    }
-}
-
-fn is_unix_socket(host: &str) -> bool {
-    let path = PathBuf::from(host);
-    path.exists()
-        && path
-            .metadata()
-            .map_or(false, |metadata| metadata.file_type().is_socket())
-}
-
-async fn connect_unix(host: &str) -> Result<Connection, MpdProtocolError> {
-    let connection = UnixStream::connect(host).await?;
-    Client::connect(connection).await
-}
-
-async fn connect_tcp(host: &str) -> Result<Connection, MpdProtocolError> {
-    let connection = TcpStream::connect(host).await?;
-    Client::connect(connection).await
-}
-
-/// Gets the duration of the current song
-pub fn get_duration(status: &Status) -> Option<u64> {
-    status.duration.map(|duration| duration.as_secs())
-}
-
-/// Gets the elapsed time of the current song
-pub fn get_elapsed(status: &Status) -> Option<u64> {
-    status.elapsed.map(|duration| duration.as_secs())
-}

src/modules/tray.rs

@@ -1,7 +1,5 @@
-mod client;
-
 use crate::await_sync;
-use crate::modules::tray::client::get_tray_event_client;
+use crate::clients::system_tray::get_tray_event_client;
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
 use color_eyre::Result;
 use gtk::prelude::*;

src/modules/tray/client.rs

@@ -1,74 +0,0 @@
-use async_once::AsyncOnce;
-use lazy_static::lazy_static;
-use stray::message::{NotifierItemCommand, NotifierItemMessage};
-use stray::StatusNotifierWatcher;
-use tokio::spawn;
-use tokio::sync::{broadcast, mpsc};
-use tracing::debug;
-
-pub struct TrayEventReceiver {
-    tx: mpsc::Sender<NotifierItemCommand>,
-    b_tx: broadcast::Sender<NotifierItemMessage>,
-    _b_rx: broadcast::Receiver<NotifierItemMessage>,
-}
-
-impl TrayEventReceiver {
-    async fn new() -> stray::error::Result<Self> {
-        let (tx, rx) = mpsc::channel(16);
-        let (b_tx, b_rx) = broadcast::channel(16);
-
-        let tray = StatusNotifierWatcher::new(rx).await?;
-        let mut host = tray.create_notifier_host("ironbar").await?;
-
-        let b_tx2 = b_tx.clone();
-        spawn(async move {
-            while let Ok(message) = host.recv().await {
-                b_tx2.send(message)?;
-            }
-
-            Ok::<(), broadcast::error::SendError<NotifierItemMessage>>(())
-        });
-
-        Ok(Self {
-            tx,
-            b_tx,
-            _b_rx: b_rx,
-        })
-    }
-
-    pub fn subscribe(
-        &self,
-    ) -> (
-        mpsc::Sender<NotifierItemCommand>,
-        broadcast::Receiver<NotifierItemMessage>,
-    ) {
-        (self.tx.clone(), self.b_tx.subscribe())
-    }
-}
-
-lazy_static! {
-    static ref CLIENT: AsyncOnce<TrayEventReceiver> = AsyncOnce::new(async {
-        const MAX_RETRIES: i32 = 10;
-
-        // sometimes this can fail
-        let mut retries = 0;
-
-        let value = loop {
-            retries += 1;
-
-            let tray = TrayEventReceiver::new().await;
-
-            if tray.is_ok() || retries == MAX_RETRIES {
-                break tray;
-            }
-
-            debug!("Failed to create StatusNotifierWatcher (attempt {retries})");
-        };
-
-        value.expect("Failed to create StatusNotifierWatcher")
-    });
-}
-
-pub async fn get_tray_event_client() -> &'static TrayEventReceiver {
-    CLIENT.get().await
-}

src/modules/workspaces.rs

@@ -1,6 +1,6 @@
 use crate::await_sync;
+use crate::clients::sway::{get_client, get_sub_client};
 use crate::modules::{Module, ModuleInfo, ModuleUpdateEvent, ModuleWidget, WidgetContext};
-use crate::sway::{get_client, get_sub_client};
 use color_eyre::{Report, Result};
 use gtk::prelude::*;
 use gtk::Button;