fix icon

Split the long continuous block in `draw_footer` into smaller,
modular methods (`draw_mic_selection`, `draw_master_volume`,
`draw_hotkeys_button`, `draw_settings_button`) for better
readability and maintainability.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pwsp"
-version = "1.9.1"
+version = "1.10.0"
 edition = "2024"
 authors = ["arabian"]
 description = "PWSP lets you play audio files through your microphone. Has both CLI and GUI clients."
@@ -43,7 +43,7 @@ rustix = { version = "1.1.4", features = ["process"] }
 rust-i18n = "4.0.0"
 sys-locale = "0.3.2"
 
-rodio = { git = "https://github.com/arabianq/rodio.git", rev = "1a08f281c352622bd82b87b8731585245802d9cf", default-features = false, features = [
+rodio = { git = "https://github.com/arabianq/rodio.git", rev = "a634dd471e9d59196e19bf01323fb45f2f899821", default-features = false, features = [
     "symphonia-all",
     "symphonia-libopus",
     "playback",
@@ -64,6 +64,9 @@ egui_extras = "0.34.1"
 egui_material_icons = "0.6.0"
 egui_dnd = "0.15.0"
 
+reqwest = "0.13.4"
+percent-encoding = "2.3.2"
+
 [[bin]]
 name = "pwsp-daemon"
 path = "src/bin/daemon.rs"

assets/pwsp-gui.desktop

@@ -1,8 +1,9 @@
 [Desktop Entry]
 Name=PWSP (Soundpad)
 Comment=Let's you play audio files through you microphone
-Exec=pwsp-gui %u
+Exec=/usr/bin/pwsp-gui %u
 Icon=pwsp
 Terminal=false
 Type=Application
-Categories=Audio
+Categories=Audio
+MimeType=x-scheme-handler/soundpad;

packages/aur/bin/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = pwsp-bin
 pkgdesc = Lets you play audio files through your microphone (Pre-built binaries)
-pkgver = 1.9.1
+pkgver = 1.10.0
 pkgrel = 1
 url = https://github.com/arabianq/pipewire-soundpad
 arch = x86_64
@@ -9,8 +9,8 @@ depends = pipewire
 depends = alsa-lib
 provides = pwsp
 conflicts = pwsp
-source = pwsp-bin-1.9.1.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.9.1/pwsp-v1.9.1-linux-x64.zip
-source = pipewire-soundpad-1.9.1.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.1.tar.gz
+source = pwsp-bin-1.10.0.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.10.0/pwsp-v1.10.0-linux-x64.zip
+source = pipewire-soundpad-1.10.0.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.10.0.tar.gz
 sha256sums = SKIP
 sha256sums = SKIP
 

packages/aur/bin/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgname=pwsp-bin
 _pkgname=pipewire-soundpad
-pkgver=1.9.1
+pkgver=1.10.0
 pkgrel=1
 pkgdesc="Lets you play audio files through your microphone (Pre-built binaries)"
 arch=('x86_64')

packages/aur/standart/.SRCINFO

@@ -1,7 +1,7 @@
 pkgbase = pwsp
 	pkgdesc = Lets you play audio files through your microphone
-	pkgver = 1.9.1
-	pkgrel = 2
+	pkgver = 1.10.0
+	pkgrel = 1
 	url = https://github.com/arabianq/pipewire-soundpad
 	arch = any
 	license = MIT
@@ -11,7 +11,7 @@ pkgbase = pwsp
 	makedepends = cmake
 	makedepends = pipewire
 	makedepends = alsa-lib
-	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.1.tar.gz
+	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.10.0.tar.gz
 	sha256sums = SKIP
 
 pkgname = pwsp

packages/aur/standart/PKGBUILD

@@ -1,8 +1,8 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgsubn=pwsp
 pkgname=pwsp
-pkgver=1.9.1
-pkgrel=2
+pkgver=1.10.0
+pkgrel=1
 pkgdesc="Lets you play audio files through your microphone"
 arch=('any')
 url="https://github.com/arabianq/pipewire-soundpad"

packages/flatpak/pwsp-wrapper.py

@@ -2,21 +2,26 @@
 
 import argparse
 import subprocess
+import sys
 
 if __name__ == "__main__":
+    if len(sys.argv) == 2 and sys.argv[1].startswith("soundpad://"):
+        subprocess.Popen(["pwsp-gui", sys.argv[1]])
+        sys.exit(0)
+
     parser = argparse.ArgumentParser(
-        prog="PWSP Flatpak",
-        add_help=True,
-        exit_on_error=True
+        prog="PWSP Flatpak", add_help=True, exit_on_error=True
     )
     subparsers = parser.add_subparsers(dest="command")
 
     cli_parser = subparsers.add_parser("cli", add_help=False, prefix_chars=" ")
-    cli_parser.add_argument("args", nargs=argparse.REMAINDER, help="Arguments for pwsp-cli")
+    cli_parser.add_argument(
+        "args", nargs=argparse.REMAINDER, help="Arguments for pwsp-cli"
+    )
 
     daemon_parser = subparsers.add_parser("daemon", add_help=True)
     daemon_group = daemon_parser.add_mutually_exclusive_group(required=True)
-    daemon_group.add_argument("--start", action="store_true", help="Start pwps-daemon")
+    daemon_group.add_argument("--start", action="store_true", help="Start pwsp-daemon")
     daemon_group.add_argument("--kill", action="store_true", help="Kill pwsp-daemon")
 
     args = parser.parse_args()
@@ -32,4 +37,4 @@ if __name__ == "__main__":
             if args.start:
                 subprocess.Popen("pwsp-daemon")
             elif args.kill:
-                subprocess.Popen(["pwsp-cli", "action", "kill"])
+                subprocess.Popen(["pwsp-cli", "action", "kill"])

packages/flatpak/ru.arabianq.pwsp.desktop

@@ -7,3 +7,4 @@ Terminal=false
 Type=Application
 Categories=AudioVideo;Audio;
 Keywords=soundpad;pipewire;audio;
+MimeType=x-scheme-handler/soundpad;

packages/flatpak/ru.arabianq.pwsp.metainfo.xml

@@ -25,7 +25,7 @@
         <name>arabian</name>
     </developer>
     <releases>
-        <release version="1.9.1" date="2026-05-22" />
+        <release version="1.10.0" date="2026-06-01" />
     </releases>
     <content_rating type="oars-1.1" />
 </component>

packages/rpm/pwsp.spec

@@ -4,7 +4,7 @@
 %global cargo_install_lib 0
 
 Name:            pwsp
-Version:         1.9.1
+Version:         1.10.0
 Release:         %autorelease
 Summary:         Lets you play audio files through your microphone
 

src/bin/daemon.rs

@@ -15,7 +15,7 @@ use std::os::unix::fs::PermissionsExt;
 use std::{fs, time::Duration};
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
-    net::UnixListener,
+    net::{UnixListener, UnixStream},
     time::sleep,
 };
 
@@ -83,83 +83,92 @@ async fn main() -> Result<()> {
 
 async fn commands_loop(listener: UnixListener) -> Result<()> {
     loop {
-        let (mut stream, _addr) = listener.accept().await?;
+        let (stream, _addr) = listener.accept().await?;
 
         tokio::spawn(async move {
-            // ---------- Read request (start) ----------
-            let mut len_bytes = [0u8; 4];
-            if stream.read_exact(&mut len_bytes).await.is_err() {
-                eprintln!("Failed to read message length from client!");
-                return;
-            }
+            handle_connection(stream).await;
+        });
+    }
+}
 
-            let request_len = u32::from_le_bytes(len_bytes) as usize;
+async fn handle_connection(mut stream: UnixStream) {
+    // ---------- Read request (start) ----------
+    let mut len_bytes = [0u8; 4];
+    if stream.read_exact(&mut len_bytes).await.is_err() {
+        eprintln!("Failed to read message length from client!");
+        return;
+    }
 
-            if request_len > MAX_MESSAGE_SIZE {
-                eprintln!(
-                    "Failed to read message from client: request too large ({} bytes)!",
-                    request_len
-                );
-                return;
-            }
+    let request_len = u32::from_le_bytes(len_bytes) as usize;
 
-            let mut buffer = vec![0u8; request_len];
-            if stream.read_exact(&mut buffer).await.is_err() {
-                eprintln!("Failed to read message from client!");
-                return;
-            }
+    if request_len > MAX_MESSAGE_SIZE {
+        eprintln!(
+            "Failed to read message from client: request too large ({} bytes)!",
+            request_len
+        );
+        return;
+    }
 
-            let request: Request = match serde_json::from_slice(&buffer) {
-                Ok(req) => req,
-                Err(err) => {
-                    let response =
-                        Response::new(false, format!("Failed to parse request: {}", err));
-                    let response_data = match serde_json::to_vec(&response) {
-                        Ok(data) => data,
-                        Err(_) => return, // Should not happen with this simple Response
-                    };
-                    let response_len = response_data.len() as u32;
-                    let _ = stream.write_all(&response_len.to_le_bytes()).await;
-                    let _ = stream.write_all(&response_data).await;
-                    return;
-                }
-            };
-            // ---------- Read request (end) ----------
+    let mut buffer = Vec::new();
+    if (&mut stream)
+        .take(request_len as u64)
+        .read_to_end(&mut buffer)
+        .await
+        .is_err()
+        || buffer.len() != request_len
+    {
+        eprintln!("Failed to read message from client!");
+        return;
+    }
 
-            // ---------- Generate response (start) ----------
-            let command = parse_command(&request);
-            let response: Response;
-            if let Some(command) = command {
-                response = command.execute().await;
-            } else {
-                response = Response::new(false, "Unknown command");
-            }
-            // ---------- Generate response (end) ----------
-
-            // ---------- Send response (start) ----------
+    let request: Request = match serde_json::from_slice(&buffer) {
+        Ok(req) => req,
+        Err(err) => {
+            let response = Response::new(false, format!("Failed to parse request: {}", err));
             let response_data = match serde_json::to_vec(&response) {
                 Ok(data) => data,
-                Err(err) => {
-                    eprintln!("Failed to serialize response: {}", err);
-                    return;
-                }
+                Err(_) => return, // Should not happen with this simple Response
             };
             let response_len = response_data.len() as u32;
+            let _ = stream.write_all(&response_len.to_le_bytes()).await;
+            let _ = stream.write_all(&response_data).await;
+            return;
+        }
+    };
+    // ---------- Read request (end) ----------
 
-            if stream.write_all(&response_len.to_le_bytes()).await.is_err() {
-                eprintln!("Failed to write response length to client!");
-                return;
-            }
-            if stream.write_all(&response_data).await.is_err() {
-                eprintln!("Failed to write response to client!");
-                return;
-            }
-            // ---------- Send response (end) ----------
+    // ---------- Generate response (start) ----------
+    let command = parse_command(&request);
+    let response: Response;
+    if let Some(command) = command {
+        response = command.execute().await;
+    } else {
+        response = Response::new(false, "Unknown command");
+    }
+    // ---------- Generate response (end) ----------
 
-            if response.status && response.message.eq("killed") {
-                std::process::exit(0);
-            }
-        });
+    // ---------- Send response (start) ----------
+    let response_data = match serde_json::to_vec(&response) {
+        Ok(data) => data,
+        Err(err) => {
+            eprintln!("Failed to serialize response: {}", err);
+            return;
+        }
+    };
+    let response_len = response_data.len() as u32;
+
+    if stream.write_all(&response_len.to_le_bytes()).await.is_err() {
+        eprintln!("Failed to write response length to client!");
+        return;
+    }
+    if stream.write_all(&response_data).await.is_err() {
+        eprintln!("Failed to write response to client!");
+        return;
+    }
+    // ---------- Send response (end) ----------
+
+    if response.status && response.message.eq("killed") {
+        std::process::exit(0);
     }
 }
 

src/gui/views/footer.rs

@@ -8,79 +8,85 @@ impl SoundpadGui {
     pub fn draw_footer(&mut self, ui: &mut Ui) {
         ui.add_space(5.0);
         ui.horizontal(|ui| {
-            // ---------- Microphone selection ----------
-            let mics = &self.audio_player_state.all_inputs_sorted;
-
-            let mut selected_input = self.audio_player_state.current_input.to_owned();
-            let prev_input = selected_input.to_owned();
-            ComboBox::from_label(t!("gui.choose_mic_select"))
-                .height(30.0)
-                .selected_text(
-                    self.audio_player_state
-                        .all_inputs
-                        .get(&selected_input)
-                        .unwrap_or(&String::new()),
-                )
-                .show_ui(ui, |ui| {
-                    for (name, nick) in mics {
-                        ui.selectable_value(&mut selected_input, name.clone(), nick);
-                    }
-                });
-
-            if selected_input != prev_input {
-                self.set_input(selected_input);
-            }
-            // --------------------------------
-
-            // ---------- Master Volume Slider ----------
-            let volume_icon = Self::get_volume_icon(self.audio_player_state.volume);
-            let volume_label = Label::new(RichText::new(volume_icon).size(18.0));
-            ui.add_sized([18.0, 18.0], volume_label)
-                .on_hover_text(format!(
-                    "Master Volume: {:.0}%",
-                    self.audio_player_state.volume * 100.0
-                ));
-
-            let should_update_volume = !self.app_state.volume_dragged
-                && self
-                    .app_state
-                    .ignore_volume_update_until
-                    .map(|t| Instant::now() > t)
-                    .unwrap_or(true);
-
-            if should_update_volume {
-                self.app_state.volume_slider_value = self.audio_player_state.volume;
-            }
-
-            let volume_slider = Slider::new(&mut self.app_state.volume_slider_value, 0.0..=1.0)
-                .show_value(false)
-                .step_by(0.01);
-            let volume_slider_response = ui.add_sized([150.0, 18.0], volume_slider);
-            if volume_slider_response.drag_stopped() {
-                self.app_state.volume_dragged = true;
-            }
-            // ------------------------------------------
+            self.draw_mic_selection(ui);
+            self.draw_master_volume(ui);
 
             ui.add_space(ui.available_width() - 18.0 * 2.0 - ui.spacing().item_spacing.x * 2.0);
 
-            // ---------- Hotkeys button ----------
-            let hotkeys_button =
-                Button::new(ICON_KEYBOARD.atom_size(Vec2::new(18.0, 18.0))).frame(false);
-            let hotkeys_button_response = ui.add_sized([18.0, 18.0], hotkeys_button);
-            if hotkeys_button_response.clicked() {
-                self.app_state.show_hotkeys = true;
-            }
-            hotkeys_button_response.on_hover_text("Hotkeys (H)");
-            // --------------------------------
-
-            // ---------- Settings button ----------
-            let settings_button =
-                Button::new(ICON_SETTINGS.atom_size(Vec2::new(18.0, 18.0))).frame(false);
-            let settings_button_response = ui.add_sized([18.0, 18.0], settings_button);
-            if settings_button_response.clicked() {
-                self.app_state.show_settings = true;
-            }
-            // --------------------------------
+            self.draw_hotkeys_button(ui);
+            self.draw_settings_button(ui);
         });
     }
+
+    fn draw_mic_selection(&mut self, ui: &mut Ui) {
+        let mics = &self.audio_player_state.all_inputs_sorted;
+
+        let mut selected_input = self.audio_player_state.current_input.to_owned();
+        let prev_input = selected_input.to_owned();
+        ComboBox::from_label(t!("gui.choose_mic_select"))
+            .height(30.0)
+            .selected_text(
+                self.audio_player_state
+                    .all_inputs
+                    .get(&selected_input)
+                    .unwrap_or(&String::new()),
+            )
+            .show_ui(ui, |ui| {
+                for (name, nick) in mics {
+                    ui.selectable_value(&mut selected_input, name.clone(), nick);
+                }
+            });
+
+        if selected_input != prev_input {
+            self.set_input(selected_input);
+        }
+    }
+
+    fn draw_master_volume(&mut self, ui: &mut Ui) {
+        let volume_icon = Self::get_volume_icon(self.audio_player_state.volume);
+        let volume_label = Label::new(RichText::new(volume_icon).size(18.0));
+        ui.add_sized([18.0, 18.0], volume_label)
+            .on_hover_text(format!(
+                "Master Volume: {:.0}%",
+                self.audio_player_state.volume * 100.0
+            ));
+
+        let should_update_volume = !self.app_state.volume_dragged
+            && self
+                .app_state
+                .ignore_volume_update_until
+                .map(|t| Instant::now() > t)
+                .unwrap_or(true);
+
+        if should_update_volume {
+            self.app_state.volume_slider_value = self.audio_player_state.volume;
+        }
+
+        let volume_slider = Slider::new(&mut self.app_state.volume_slider_value, 0.0..=1.0)
+            .show_value(false)
+            .step_by(0.01);
+        let volume_slider_response = ui.add_sized([150.0, 18.0], volume_slider);
+        if volume_slider_response.drag_stopped() {
+            self.app_state.volume_dragged = true;
+        }
+    }
+
+    fn draw_hotkeys_button(&mut self, ui: &mut Ui) {
+        let hotkeys_button =
+            Button::new(ICON_KEYBOARD.atom_size(Vec2::new(18.0, 18.0))).frame(false);
+        let hotkeys_button_response = ui.add_sized([18.0, 18.0], hotkeys_button);
+        if hotkeys_button_response.clicked() {
+            self.app_state.show_hotkeys = true;
+        }
+        hotkeys_button_response.on_hover_text("Hotkeys (H)");
+    }
+
+    fn draw_settings_button(&mut self, ui: &mut Ui) {
+        let settings_button =
+            Button::new(ICON_SETTINGS.atom_size(Vec2::new(18.0, 18.0))).frame(false);
+        let settings_button_response = ui.add_sized([18.0, 18.0], settings_button);
+        if settings_button_response.clicked() {
+            self.app_state.show_settings = true;
+        }
+    }
 }

src/main.rs

@@ -1,7 +1,9 @@
 mod gui;
 
-use anyhow::Result;
+use anyhow::{Context, Result};
+use pwsp::utils::gui::ensure_pwsp_audio_dir;
 use rust_i18n::i18n;
+use std::{env, path::PathBuf};
 
 i18n!("locales", fallback = "en");
 
@@ -10,5 +12,49 @@ async fn main() -> Result<()> {
     let locale = sys_locale::get_locale().unwrap_or(String::from("en-US"));
     rust_i18n::set_locale(&locale);
 
-    gui::run().await
+    let args = env::args().skip(1).collect::<Vec<String>>();
+
+    if let Some(uri) = args.first() {
+        match download_audio_from_url(uri).await {
+            Ok(path) => println!("Successfully downloaded to: {:?}", path),
+            Err(e) => eprintln!("Error downloading file: {}", e),
+        }
+    } else {
+        gui::run().await?;
+    }
+
+    Ok(())
+}
+
+async fn download_audio_from_url(uri: &str) -> Result<PathBuf> {
+    let prefix = "soundpad://sound/url/";
+
+    let target_url = uri
+        .strip_prefix(prefix)
+        .ok_or_else(|| anyhow::anyhow!("URI does not containt an expected prefix: {}", prefix))?;
+
+    let file_name_encoded = target_url
+        .split('/')
+        .next_back()
+        .unwrap_or("downloaded_audio.mp3");
+
+    let file_name = percent_encoding::percent_decode_str(file_name_encoded)
+        .decode_utf8()
+        .unwrap_or_else(|_| file_name_encoded.into())
+        .into_owned();
+
+    let save_path = ensure_pwsp_audio_dir().join(file_name);
+
+    let response = reqwest::get(target_url)
+        .await?
+        .error_for_status()
+        .context("Failed to fetch file")?;
+
+    let bytes = response.bytes().await?;
+
+    tokio::fs::write(&save_path, bytes)
+        .await
+        .context("Failed to save file to disk")?;
+
+    Ok(save_path)
 }

src/types/audio_player.rs

@@ -349,7 +349,11 @@ impl AudioPlayer {
 
                 let duration = source.total_duration().map(|d| d.as_secs_f32());
 
-                let mixer = self.stream_handle.as_ref().unwrap().mixer();
+                let mixer = self
+                    .stream_handle
+                    .as_ref()
+                    .ok_or_else(|| anyhow::anyhow!("stream_handle is unexpectedly missing"))?
+                    .mixer();
                 let sink = Player::connect_new(mixer);
                 sink.set_volume(self.volume); // Default volume is 1.0 * master
                 sink.append(source);

src/types/config.rs

@@ -1,4 +1,7 @@
-use crate::{types::socket::Request, utils::config::get_config_path};
+use crate::{
+    types::socket::Request,
+    utils::{config::get_config_path, gui::ensure_pwsp_audio_dir},
+};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fs, path::PathBuf};
@@ -69,7 +72,7 @@ impl Default for GuiConfig {
             save_scale_factor: false,
             pause_on_exit: false,
 
-            dirs: vec![],
+            dirs: vec![ensure_pwsp_audio_dir()],
 
             preferred_theme: PreferredTheme::System,
         }

src/types/pipewire.rs

@@ -29,3 +29,46 @@ pub struct AudioDevice {
     pub output_fl: Option<Port>,
     pub output_fr: Option<Port>,
 }
+
+impl AudioDevice {
+    pub fn new(
+        id: u32,
+        nick: Option<&str>,
+        description: Option<&str>,
+        name: Option<&str>,
+        device_type: DeviceType,
+    ) -> Self {
+        Self {
+            id,
+            nick: nick
+                .or(description)
+                .or(name)
+                .unwrap_or_default()
+                .to_string(),
+            name: name.unwrap_or_default().to_string(),
+            device_type,
+            input_fl: None,
+            input_fr: None,
+            output_fl: None,
+            output_fr: None,
+        }
+    }
+
+    pub fn add_port(&mut self, port: Port) {
+        match port.name.as_str() {
+            "input_FL" => self.input_fl = Some(port),
+            "input_FR" => self.input_fr = Some(port),
+            "output_FL" | "capture_FL" => self.output_fl = Some(port),
+            "output_FR" | "capture_FR" => self.output_fr = Some(port),
+            "input_MONO" => {
+                self.input_fl = Some(port.clone());
+                self.input_fr = Some(port);
+            }
+            "output_MONO" | "capture_MONO" => {
+                self.output_fl = Some(port.clone());
+                self.output_fr = Some(port);
+            }
+            _ => {}
+        }
+    }
+}

src/utils/gui.rs

@@ -9,6 +9,7 @@ use crate::{
 };
 use anyhow::{Result, anyhow};
 use std::{
+    path::PathBuf,
     sync::{Arc, Mutex},
     time::Instant,
 };
@@ -36,6 +37,17 @@ pub fn make_request_async(request: Request) {
     });
 }
 
+pub fn ensure_pwsp_audio_dir() -> PathBuf {
+    let audio_dir = dirs::audio_dir().unwrap_or("~/Music".into());
+    let pwsp_audio_dir = audio_dir.join("PWSP");
+
+    if !pwsp_audio_dir.exists() {
+        std::fs::create_dir_all(&pwsp_audio_dir).ok();
+    }
+
+    pwsp_audio_dir
+}
+
 pub fn format_time_pair(position: f32, duration: f32) -> String {
     fn format_time(seconds: f32) -> String {
         let total_seconds = seconds.round() as u32;

src/utils/pipewire.rs

@@ -20,66 +20,54 @@ pub fn setup_pipewire_context() -> Result<(MainLoopRc, ContextRc), String> {
 fn parse_global_object(
     global_object: &GlobalObject<&DictRef>,
 ) -> (Option<AudioDevice>, Option<Port>) {
-    // Only objects with props can be devices/ports
-    if let Some(props) = global_object.props {
-        // Only objects with media.class can be devices
-        if let Some(media_class) = props.get("media.class") {
-            let node_id = global_object.id;
-            let node_nick = props.get("node.nick");
-            let node_name = props.get("node.name");
-            let node_description = props.get("node.description");
+    let props = match global_object.props {
+        Some(p) => p,
+        None => return (None, None),
+    };
 
-            // Check if the device is an input or output
-            return if media_class.starts_with("Audio/Source") {
-                let input_device = AudioDevice {
-                    id: node_id,
-                    nick: node_nick
-                        .unwrap_or(node_description.unwrap_or(node_name.unwrap_or_default()))
-                        .to_string(),
-                    name: node_name.unwrap_or_default().to_string(),
-                    device_type: DeviceType::Input,
+    if let Some(media_class) = props.get("media.class") {
+        let node_id = global_object.id;
+        let node_nick = props.get("node.nick");
+        let node_name = props.get("node.name");
+        let node_description = props.get("node.description");
 
-                    input_fl: None,
-                    input_fr: None,
-                    output_fl: None,
-                    output_fr: None,
-                };
-                (Some(input_device), None)
-            } else if media_class.starts_with("Stream/Output/Audio") {
-                let output_device = AudioDevice {
-                    id: node_id,
-                    nick: node_nick
-                        .unwrap_or(node_description.unwrap_or(node_name.unwrap_or_default()))
-                        .to_string(),
-                    name: node_name.unwrap_or_default().to_string(),
-                    device_type: DeviceType::Output,
-
-                    input_fl: None,
-                    input_fr: None,
-                    output_fl: None,
-                    output_fr: None,
-                };
-                (Some(output_device), None)
-            } else {
-                (None, None)
-            };
-            // Check if the object is a port
-        } else if props.get("port.direction").is_some()
-            && let (Some(node_id), Some(port_id), Some(port_name)) = (
-                props.get("node.id").and_then(|id| id.parse::<u32>().ok()),
-                props.get("port.id").and_then(|id| id.parse::<u32>().ok()),
-                props.get("port.name"),
-            )
-        {
-            let port = Port {
+        if media_class.starts_with("Audio/Source") {
+            let input_device = AudioDevice::new(
                 node_id,
-                port_id,
-                name: port_name.to_string(),
-            };
-
-            return (None, Some(port));
+                node_nick,
+                node_description,
+                node_name,
+                DeviceType::Input,
+            );
+            return (Some(input_device), None);
+        } else if media_class.starts_with("Stream/Output/Audio") {
+            let output_device = AudioDevice::new(
+                node_id,
+                node_nick,
+                node_description,
+                node_name,
+                DeviceType::Output,
+            );
+            return (Some(output_device), None);
         }
+        return (None, None);
     }
+
+    if props.get("port.direction").is_some()
+        && let (Some(node_id), Some(port_id), Some(port_name)) = (
+            props.get("node.id").and_then(|id| id.parse::<u32>().ok()),
+            props.get("port.id").and_then(|id| id.parse::<u32>().ok()),
+            props.get("port.name"),
+        )
+    {
+        let port = Port {
+            node_id,
+            port_id,
+            name: port_name.to_string(),
+        };
+        return (None, Some(port));
+    }
+
     (None, None)
 }
 
@@ -188,47 +176,14 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>)> {
                     let node_id = port.node_id;
 
                     if let Some(input_device) = input_devices.get_mut(&node_id) {
-                        match port.name.as_str() {
-                            "input_FL" => input_device.input_fl = Some(port),
-                            "input_FR" => input_device.input_fr = Some(port),
-                            "output_FL" => input_device.output_fl = Some(port),
-                            "output_FR" => input_device.output_fr = Some(port),
-                            "capture_FL" => input_device.output_fl = Some(port),
-                            "capture_FR" => input_device.output_fr = Some(port),
-                            "input_MONO" => {
-                                input_device.input_fl = Some(port.clone());
-                                input_device.input_fr = Some(port)
-                            }
-                            "capture_MONO" => {
-                                input_device.output_fl = Some(port.clone());
-                                input_device.output_fr = Some(port);
-                            }
-                            _ => {}
-                        }
+                        input_device.add_port(port);
                     } else if let Some(output_device) = output_devices.get_mut(&node_id) {
-                        match port.name.as_str() {
-                            "input_FL" => output_device.input_fl = Some(port),
-                            "input_FR" => output_device.input_fr = Some(port),
-                            "output_FL" => output_device.output_fl = Some(port),
-                            "output_FR" => output_device.output_fr = Some(port),
-                            "capture_FL" => output_device.output_fl = Some(port),
-                            "capture_FR" => output_device.output_fr = Some(port),
-                            "output_MONO" => {
-                                output_device.output_fl = Some(port.clone());
-                                output_device.output_fr = Some(port)
-                            }
-                            "capture_MONO" => {
-                                output_device.output_fl = Some(port.clone());
-                                output_device.output_fr = Some(port)
-                            }
-                            _ => {}
-                        }
+                        output_device.add_port(port);
                     }
                 }
 
-                let mut input_devices: Vec<AudioDevice> = input_devices.values().cloned().collect();
-                let mut output_devices: Vec<AudioDevice> =
-                    output_devices.values().cloned().collect();
+                let mut input_devices: Vec<AudioDevice> = input_devices.into_values().collect();
+                let mut output_devices: Vec<AudioDevice> = output_devices.into_values().collect();
 
                 input_devices.sort_by_key(|a| a.id);
                 output_devices.sort_by_key(|a| a.id);