Update dependencies and change version to 1.7.2 (#63)

* deps: bump tokio to 1.52.1

* deps: bump clap to 4.6.1

* deps: cargo update

bitflags -> v2.11.1
core2 -
dary_heap -> v0.3.9
font-types -> v0.11.3
include-flate -> v0.3.3
include-flate-codegen -> v0.3.3
include-flate-compress -> v0.3.3
libc -> v0.2.185
libflate -> v2.3.0
libflate_lz77 -> v2.3.0
no_std_io2 + v0.9.3
portable-atomic-util -> v0.2.7
pxfm -> v0.1.29
rayon -> v1.12.0
uuid -> v1.23.1
webbrowser -> v1.2.1

* change version to 1.7.2

.github/FUNDING.yml

@@ -0,0 +1 @@
+custom: ['https://boosty.to/arabian']

.github/workflows/build.yml

@@ -0,0 +1,119 @@
+name: Build
+
+permissions:
+  contents: write
+  packages: write
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+  workflow_dispatch:
+
+jobs:
+  linux-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install apt deps (jq/zip + dev-libs)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            zip jq \
+            libpipewire-0.3-dev \
+            libclang-dev \
+            libasound2-dev
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 1.94.1
+
+      - name: Extract all binary names
+        id: cargo-meta
+        run: |
+          set -euo pipefail
+          BIN_NAMES=$(cargo metadata --no-deps --format-version 1 \
+            | jq -r '.packages[0].targets[] | select(.kind[] | contains("bin")) | .name')
+          echo "bin_names<<EOF" >> $GITHUB_OUTPUT
+          echo "$BIN_NAMES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Build all release binaries
+        run: cargo build --release --locked
+
+      - name: Package all binaries into one archive
+        shell: bash
+        run: |
+          set -euo pipefail
+          COMMIT_SHA="${{ github.sha }}"
+          ARCHIVE_NAME="pwsp-${COMMIT_SHA}-linux-x64.zip"
+          echo "Creating archive: $ARCHIVE_NAME"
+
+          FILES=()
+          while IFS= read -r BIN; do
+            [ -z "$BIN" ] && continue
+            FILES+=("target/release/$BIN")
+          done <<< "${{ steps.cargo-meta.outputs.bin_names }}"
+
+          if [ "${#FILES[@]}" -eq 0 ]; then
+            echo "Error: no binaries were discovered via cargo metadata." >&2
+            exit 1
+          fi
+
+          for f in "${FILES[@]}"; do
+            if [ ! -f "$f" ]; then
+              echo "Error: expected binary not found: $f" >&2
+              exit 1
+            fi
+            echo "Will add: $f"
+          done
+
+          zip -j "$ARCHIVE_NAME" "${FILES[@]}"
+
+      - name: Upload archive as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: archive
+          path: pwsp-*.zip
+          retention-days: 7
+
+      - name: Install cargo-deb and create .deb
+        shell: bash
+        run: |
+          set -euo pipefail
+          cargo install --locked cargo-deb
+          export PATH="$HOME/.cargo/bin:$PATH"
+
+          cargo-deb
+
+      - name: Upload .deb(s) as artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: deb-packages
+          path: target/debian/*.deb
+          retention-days: 7
+
+  flatpak-build:
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/flathub-infra/flatpak-github-actions:freedesktop-25.08
+      options: --privileged
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build Flatpak
+        uses: flatpak/flatpak-github-actions/flatpak-builder@v6
+        with:
+          bundle: ru.arabianq.pwsp.flatpak
+          manifest-path: packages/flatpak/ru.arabianq.pwsp.yaml
+          cache: true
+          branch: master
+          build-bundle: true

.github/workflows/release.yml

@@ -0,0 +1,183 @@
+name: Release
+
+permissions:
+  contents: write
+  packages: write
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Tag to attach assets to (e.g. v1.0.0)"
+        required: false
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      tag: ${{ steps.tag.outputs.tag }}
+    steps:
+      - name: Determine tag to use
+        id: tag
+        run: |
+          set -euo pipefail
+
+          INPUT_TAG="${{ github.event.inputs.tag || '' }}"
+          if [ -n "$INPUT_TAG" ]; then
+            echo "Using input tag: $INPUT_TAG"
+            echo "tag=$INPUT_TAG" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          EVENT_TAG="${{ github.event.release.tag_name || '' }}"
+          if [ -n "$EVENT_TAG" ]; then
+            echo "Using event tag: $EVENT_TAG"
+            echo "tag=$EVENT_TAG" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          if [[ "${GITHUB_REF:-}" =~ ^refs/tags/(.+)$ ]]; then
+            echo "Using GITHUB_REF tag: ${BASH_REMATCH[1]}"
+            echo "tag=${BASH_REMATCH[1]}" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          echo "No tag in input/event/GITHUB_REF — querying latest release via API..."
+          LATEST_JSON=$(curl -sSf -H "Authorization: Bearer ${{ secrets.GITHUB_TOKEN }}" -H "Accept: application/vnd.github+json" "https://api.github.com/repos/${{ github.repository }}/releases/latest" || true)
+          TAG_NAME=$(echo "$LATEST_JSON" | jq -r '.tag_name // empty')
+          if [ -n "$TAG_NAME" ]; then
+            echo "Found latest release tag: $TAG_NAME"
+            echo "tag=$TAG_NAME" >> $GITHUB_OUTPUT
+            exit 0
+          fi
+
+          echo "No tag found"
+          echo "tag=" >> $GITHUB_OUTPUT
+
+      - name: Fail if no tag determined
+        if: ${{ steps.tag.outputs.tag == '' }}
+        run: |
+          echo "ERROR: No tag determined. Provide a tag when running manually or ensure a release exists."
+          exit 1
+
+  linux-release:
+    needs: prepare
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Install apt deps (jq/zip + dev-libs)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y \
+            zip jq \
+            libpipewire-0.3-dev \
+            libclang-dev \
+            libasound2-dev
+
+      - name: Checkout code at tag
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.prepare.outputs.tag }}
+          fetch-depth: 0
+
+      - name: Setup Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 1.94.1
+
+      - name: Extract all binary names
+        id: cargo-meta
+        run: |
+          set -euo pipefail
+          BIN_NAMES=$(cargo metadata --no-deps --format-version 1 \
+            | jq -r '.packages[0].targets[] | select(.kind[] | contains("bin")) | .name')
+          echo "bin_names<<EOF" >> $GITHUB_OUTPUT
+          echo "$BIN_NAMES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - name: Build all release binaries
+        run: cargo build --release --locked
+
+      - name: Package all binaries into one archive
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="${{ needs.prepare.outputs.tag }}"
+          ARCHIVE_NAME="pwsp-${TAG}-linux-x64.zip"
+          echo "Creating archive: $ARCHIVE_NAME"
+
+          FILES=()
+          while IFS= read -r BIN; do
+            [ -z "$BIN" ] && continue
+            FILES+=("target/release/$BIN")
+          done <<< "${{ steps.cargo-meta.outputs.bin_names }}"
+
+          if [ "${#FILES[@]}" -eq 0 ]; then
+            echo "Error: no binaries were discovered via cargo metadata." >&2
+            exit 1
+          fi
+
+          for f in "${FILES[@]}"; do
+            if [ ! -f "$f" ]; then
+              echo "Error: expected binary not found: $f" >&2
+              exit 1
+            fi
+            echo "Will add: $f"
+          done
+
+          zip -j "$ARCHIVE_NAME" "${FILES[@]}"
+
+      - name: Upload release archive
+        uses: softprops/action-gh-release@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag_name: ${{ needs.prepare.outputs.tag }}
+          files: |
+            pwsp-*.zip
+
+      - name: Install cargo-deb and create .deb
+        shell: bash
+        run: |
+          set -euo pipefail
+          cargo install --locked cargo-deb
+          export PATH="$HOME/.cargo/bin:$PATH"
+
+          cargo-deb
+
+      - name: Upload .deb(s) to release
+        uses: softprops/action-gh-release@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag_name: ${{ needs.prepare.outputs.tag }}
+          files: |
+            target/debian/*.deb
+
+  flatpak-release:
+    needs: prepare
+    runs-on: ubuntu-latest
+    container:
+      image: ghcr.io/flathub-infra/flatpak-github-actions:freedesktop-25.08
+      options: --privileged
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ needs.prepare.outputs.tag }}
+        
+      - name: Build Flatpak
+        uses: flatpak/flatpak-github-actions/flatpak-builder@v6
+        with:
+          bundle: ru.arabianq.pwsp.flatpak
+          manifest-path: packages/flatpak/ru.arabianq.pwsp.yaml
+          cache: true
+          branch: master
+          build-bundle: true
+
+      - name: Upload Flatpak to release
+        uses: softprops/action-gh-release@v2
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          tag_name: ${{ needs.prepare.outputs.tag }}
+          files: ru.arabianq.pwsp.flatpak

.gitignore

@@ -1,3 +1,4 @@
 /target
 .idea
-Cargo.lock
+packages/aur/bin/.git
+packages/aur/standart/.git

Cargo.toml

@@ -1,24 +1,69 @@
 [package]
 name = "pwsp"
-version = "0.1.0"
-edition = "2021"
+version = "1.7.2"
+edition = "2024"
 authors = ["arabian"]
-description = "A simple soundpad application written in Rust using egui for the GUI, pipewire for audio input/output, and rodio for audio decoding."
+description = "PWSP lets you play audio files through your microphone. Has both CLI and GUI clients."
 readme = "README.md"
-homepage = "https://github.com/arabianq/pipewire-soundpad"
+homepage = "https://pwsp.arabianq.ru"
 repository = "https://github.com/arabianq/pipewire-soundpad"
 license = "MIT"
-keywords = ["soundpad", "pipewire"]
+keywords = ["soundpad", "pipewire", "linux", "cli", "gui"]
 
 
 [dependencies]
-egui = "0.31.0"
-eframe = "0.31.0"
-egui_material_icons = "0.3.0"
-rfd = "0.15.2"
+tokio = { version = "1.52.1", features = ["full"] }
+async-trait = "0.1.89"
+
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = "1.0.149"
+
+clap = { version = "4.6.1", default-features = false, features = [
+    "std",
+    "suggestions",
+    "help",
+    "usage",
+    "error-context",
+    "derive",
+] }
 dirs = "6.0.0"
-rodio = {version = "0.20.1", default-features = false, features = ["symphonia-all"]}
-metadata = "0.1.10"
+itertools = "0.14.0"
+
+rodio = { version = "0.22.2", default-features = false, features = [
+    "symphonia-all",
+    "playback",
+] }
+pipewire = "0.9.2"
+evdev = { version = "0.13.2", features = ["tokio"] }
+rfd = { version = "0.17.2", default-features = false, features = [
+    "xdg-portal",
+] }
+opener = { version = "0.8.4", features = ["reveal"] }
+
+egui = { version = "0.34.1", default-features = false, features = [
+    "default_fonts",
+    "rayon",
+] }
+eframe = { version = "0.34.1", default-features = false, features = [
+    "default_fonts",
+    "glow",
+    "x11",
+    "wayland",
+] }
+egui_material_icons = "0.6.0"
+egui_dnd = "0.15.0"
+
+[[bin]]
+name = "pwsp-daemon"
+path = "src/bin/daemon.rs"
+
+[[bin]]
+name = "pwsp-cli"
+path = "src/bin/cli.rs"
+
+[[bin]]
+name = "pwsp-gui"
+path = "src/main.rs"
 
 [profile.release]
 strip = true
@@ -27,3 +72,36 @@ codegen-units = 1
 opt-level = "z"
 panic = "abort"
 
+[package.metadata.deb]
+assets = [
+    [
+        "target/release/pwsp-daemon",
+        "usr/bin/",
+        "755",
+    ],
+    [
+        "target/release/pwsp-cli",
+        "usr/bin/",
+        "755",
+    ],
+    [
+        "target/release/pwsp-gui",
+        "usr/bin/",
+        "755",
+    ],
+    [
+        "assets/pwsp-gui.desktop",
+        "usr/share/applications/pwsp.desktop",
+        "644",
+    ],
+    [
+        "assets/icon.png",
+        "usr/share/icons/hicolor/256x256/apps/pwsp.png",
+        "644",
+    ],
+    [
+        "assets/pwsp-daemon.service",
+        "usr/lib/systemd/user/pwsp-daemon.service",
+        "644",
+    ],
+]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tarasov Alexander
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,48 +1,215 @@
-# PipeWire SoundPad
+# **🎵 Pipewire Soundpad (PWSP)**
 
-This is a simple soundpad application written in Rust using egui for the GUI, pipewire for audio input/output, and rodio for audio decoding. It allows you to play various audio files (mp3, wav, ogg, flac, mp4, aac) through your microphone.
+**PipeWire Soundpad (PWSP)** is a simple yet powerful **soundboard application** written in **Rust**. It provides a
+user-friendly graphical interface for **managing and playing audio files, directing their output directly to the virtual
+microphone.** This makes it an ideal tool for gamers, streamers, and anyone looking to inject sound effects into voice
+chats on platforms like **Discord, Zoom, or Teamspeak**.
 
-![ScreenShot](screenshot.png)
+![screenshot.png](assets/screenshot.png)
 
-## Features
+# **🌟 Key Features**
 
-*   **Audio File Playback:** Supports a wide range of audio formats including mp3, wav, ogg, flac, mp4, and aac.
-*   **Microphone Output:** Plays selected audio files through the chosen microphone.
-*   **PipeWire Integration:** Leverages PipeWire for efficient audio routing and device management.
-*   **egui GUI:** Provides a user-friendly interface for file selection, playback control, and microphone selection.
-*   **Directory Management:** Allows adding and removing directories for organizing audio files.
-*   **Search Functionality:** Enables searching for specific audio files within loaded directories.
-*   **Playback Control:** Offers play/pause functionality, volume control, and a playback position slider.
-*   **Persistent Configuration:** Saves the list of added directories and the selected microphone for future use.
-
-## Installation
-
-1.  **Rust and Cargo:** Ensure you have Rust and Cargo installed. You can install them from [https://www.rust-lang.org/tools/install](https://www.rust-lang.org/tools/install).
-2.  **Dependencies:** This project requires PipeWire to be installed on your system.  The specific installation steps will depend on your distribution.
-3.  **Clone the Repository:** Clone this repository to your local machine.
-4.  **Build:** Navigate to the project directory in your terminal and run `cargo build --release`.
-
-## Usage
-
-1.  **Run:** After building, run the application using `cargo run --release`.
-2.  **Add Directories:** Click the "+" button to add directories containing your audio files.
-3.  **Select Directory:** Click on a directory in the list to view its contents.
-4.  **Select Audio File:** Click on an audio file in the list to select it.
-5.  **Choose Microphone:** Select your desired microphone from the dropdown menu.
-6.  **Play/Pause:** Use the play/pause button to control playback.
-7.  **Volume:** Adjust the volume using the volume slider.
-8.  **Seek:** Use the playback position slider to navigate through the audio file.
-9.  **Search:** Use the search bar to filter audio files by name.
-
-## Configuration
-
-The application saves the list of added directories and the selected microphone in the application's configuration directory.  This directory is typically located at `~/.config/pwsp`.
+* **Multi-Format Support**: Play audio files in popular formats, including _**mp3**_, _**wav**_, _**ogg**_, _**flac**_,
+  _**mp4**_, and _**aac**_.
+* **Virtual Microphone Output**: The application routes audio through a virtual device created by PipeWire, allowing
+  other users to hear the sounds as if you were speaking into your microphone.
+* **Modern and Clean GUI**: The interface is built with the [egui](https://egui.rs) library, ensuring an intuitive and
+  responsive user experience.
+* **Sound Collection Management**: Easily add and remove directories containing your audio files. The application scans
+  these folders and displays all supported files for quick access.
+* **Quick Search**: Use the built-in search bar to instantly find any sound file within your library.
+* **Detailed Playback Controls**:
+    * **Play/Pause button**.
+    * **Volume slider** for individual sound adjustment.
+    * **Position slider** to fast-forward or rewind the audio.
+* **Persistent Configuration**: The list of added directories and your selected audio output device are saved
+  automatically, so you won't need to reconfigure them every time you launch the application.
+* **Collapsible Audio Tracks**: You can collapse every audio track to save space.
+* **Drag and Drop Directories**: Reorder your sound directories easily using drag and drop.
+* **Automatic Device Detection**: PWSP automatically detects when an input device is connected or disconnected and handles linking/unlinking.
+* **Global Hotkeys**: Assign custom keyboard shortcuts to any sound file (or action) to trigger playback instantly, even when the application is not in focus.
 
 
-## Contributing
+# **⚙️ How It Works**
 
-Contributions are welcome! Please open an issue or submit a pull request.
+PWSP is designed with a clear separation of concerns, operating through a client-server architecture. It consists of
+three main components:
 
-## License
+* **pwsp-daemon**: This is the core of the application. It runs silently in the background, managing all the
+  heavy-lifting tasks. The daemon is responsible for:
+    * Creating and managing virtual audio devices.
+    * Linking these devices within the PipeWire graph.
+    * Handling all audio playback.
+* **UnixSocket**. This is how you interact with your sound collection, control playback, and configure settings.
+* **pwsp-gui**: This is the graphical user interface. It acts as a client that communicates with pwsp-daemon via a
+* **pwsp-cli**: This is the command-line interface, also acting as a client. It provides a way to control the daemon
+  without a GUI, allowing for scripting or quick command-based actions.
 
-[MIT](LICENSE)
+# **🚀 Installation**
+
+## **Pre-built Packages**
+
+You can download pre-built binaries and .deb packages from
+the [releases page](https://github.com/arabianq/pipewire-soundpad/releases).
+
+## **Fedora Linux (and derivatives)**
+
+If you're using Fedora, you can install PWSP from a dedicated repository using DNF.
+
+Add the repository:
+
+```bash
+sudo dnf copr enable arabianq/pwsp
+```
+
+Update cache:
+
+```bash
+sudo dnf makecache
+```
+
+Install PWSP:
+
+```bash
+sudo dnf install pwsp
+```
+
+## **Arch Linux**
+There is pwsp package in AUR.
+You can install it using yay, paru or any other AUR helper.
+```bash
+paru pwsp-bin # or paru pwsp to build it locally
+```
+
+## **Installing using cargo**
+
+```bash
+cargo install pwsp
+```
+
+## **Building from source**
+
+#### **Requirements**
+
+* **Rust**: Install [Rust](https://www.rust-lang.org/tools/install) (using rustup is recommended).
+* **PipeWire**: Ensure that [PipeWire](https://pipewire.org/) is installed and running on your system.
+
+#### **Build Instructions**
+
+Clone the repository:
+
+```bash
+git clone https://github.com/arabianq/pipewire-soundpad.git  
+cd pipewire-soundpad
+```
+
+Build the project:
+
+```bash
+cargo build --release
+```
+
+Now you have three binary files inside ./target/release/:
+
+- **pwsp-gui**
+- **pwsp-cli**
+- **pwsp-daemon**
+
+# **🎮 Usage**
+
+Before using pwsp-gui or pwsp-cli, you **must** first run the pwsp-daemon in the background.
+
+### **Running the Daemon**
+
+You can start the daemon from the terminal or enable the systemd service for automatic startup.
+
+* **Manual Start:**
+
+```bash
+/path/to/your/pwsp-daemon &
+```
+
+* **Using systemd (recommended):**  
+  If you installed PWSP using prebuilt packages, the systemd service is added automatically.
+    1. **Start the service:**
+        ```bash  
+        systemctl --user start pwsp-daemon
+        ```
+    2. **Enable autostart (starts on login):**
+        ```bash
+       systemctl --user enable --now pwsp-daemon
+        ```
+
+### **Using the GUI**
+
+1. **Add Sounds**: Click the **"+"** button and select a folder containing your audio files. The application
+   will automatically list all supported files.
+2. **Select Microphone**: In the main application window, select your microphone. PWSP will automatically
+   create a virtual microphone and feed it sound from two sources: **your microphone** and the **audio files**.
+3. **Playback**: Click on a file in the list to load it, then use the **"Play"** and **"Pause"** buttons to control
+   playback. You can also play single file once using **"Play File"** button.
+
+### **Using the CLI**
+
+The pwsp-cli tool allows you to control the daemon from the command line.
+
+* **General Help**: To see a list of all available commands, run:
+
+```bash
+pwsp-cli --help
+```
+
+* **Example Commands**:
+    * **Play a file**:
+
+      ```bash
+      pwsp-cli action play <file_path>
+      ```
+
+    * **Get the current volume**:
+
+      ```bash
+      pwsp-cli get volume
+      ```
+
+    * **Set playback position to 20 seconds**:
+
+      ```bash 
+      pwsp-cli set position 20
+      ```
+
+### **Hotkeys & Controls**
+
+#### **Keyboard Shortcuts**
+
+| Key                      | Action                                               |
+| :----------------------- | :--------------------------------------------------- |
+| **Space**                | Pause / Resume audio                                 |
+| **Backspace**            | Stop all audio tracks                                |
+| **Enter**                | Play selected file (stops all other tracks)          |
+| **Ctrl + Enter**         | Add selected file to playback (plays simultaneously) |
+| **Shift + Enter**        | Replace the last added track with the selected one   |
+| **I**                    | Open / Close settings                                |
+| **/**                    | Focus search field                                   |
+| **Ctrl + ↑ / ↓**         | Navigate through files                               |
+| **Ctrl + Shift + ↑ / ↓** | Navigate through directories                         |
+
+#### **Mouse Controls**
+
+* **Left Click**: Play track (stops all other tracks).
+* **Ctrl + Left Click**: Add track (plays simultaneously with current tracks).
+* **Shift + Left Click**: Replace the last added track with the selected one.
+
+# **🤝 Contributing**
+
+Contributions are welcome\! If you have ideas for improvements or find a bug, feel free to create
+an [issue](https://github.com/arabianq/pipewire-soundpad/issues) or submit
+a [pull request](https://github.com/arabianq/pipewire-soundpad/pulls).
+
+# **📜 License**
+
+This project is licensed under
+the [MIT License](https://github.com/arabianq/pipewire-soundpad/blob/main/LICENSE).
+
+# **🤖 AI Wiki**
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/arabianq/pipewire-soundpad)

assets/pwsp-daemon.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Pipewire Soundpad Daemon
+After=pipewire.service
+
+[Service]
+ExecStart=/usr/bin/pwsp-daemon
+Restart=no
+RuntimeDirectory=pwsp
+
+[Install]
+WantedBy=default.target

assets/pwsp-gui.desktop

@@ -0,0 +1,8 @@
+[Desktop Entry]
+Name=PWSP (Soundpad)
+Comment=Let's you play audio files through you microphone
+Exec=pwsp-gui %u
+Icon=pwsp
+Terminal=false
+Type=Application
+Categories=Audio

packages/aur/bin/.SRCINFO

@@ -0,0 +1,17 @@
+pkgbase = pwsp-bin
+pkgdesc = Lets you play audio files through your microphone (Pre-built binaries)
+pkgver = 1.7.2
+pkgrel = 2
+url = https://github.com/arabianq/pipewire-soundpad
+arch = x86_64
+license = MIT
+depends = pipewire
+depends = alsa-lib
+provides = pwsp
+conflicts = pwsp
+source = pwsp-bin-1.7.2.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.7.2/pwsp-v1.7.2-linux-x64.zip
+source = pipewire-soundpad-1.7.2.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.7.2.tar.gz
+sha256sums = SKIP
+sha256sums = SKIP
+
+pkgname = pwsp-bin

packages/aur/bin/.gitignore

@@ -0,0 +1,163 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+*.db
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+.poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cythikaaryhon_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+#.vscode/

packages/aur/bin/PKGBUILD

@@ -0,0 +1,32 @@
+# Maintainer: Alexander Tarasov <a.tevg@ya.ru>
+pkgname=pwsp-bin
+_pkgname=pipewire-soundpad
+pkgver=1.7.2
+pkgrel=2
+pkgdesc="Lets you play audio files through your microphone (Pre-built binaries)"
+arch=('x86_64')
+url="https://github.com/arabianq/pipewire-soundpad"
+license=('MIT')
+depends=('pipewire' 'alsa-lib')
+provides=('pwsp')
+conflicts=('pwsp')
+
+source=("${pkgname}-${pkgver}.zip::https://github.com/arabianq/$_pkgname/releases/download/v$pkgver/pwsp-v$pkgver-linux-x64.zip"
+        "${_pkgname}-${pkgver}.tar.gz::https://github.com/arabianq/$_pkgname/archive/refs/tags/v$pkgver.tar.gz")
+
+sha256sums=('SKIP'
+            'SKIP')
+
+package() {
+  _srcsrc="${srcdir}/${_pkgname}-${pkgver}"
+
+  install -Dm755 "${srcdir}/pwsp-cli" "${pkgdir}/usr/bin/pwsp-cli"
+  install -Dm755 "${srcdir}/pwsp-daemon" "${pkgdir}/usr/bin/pwsp-daemon"
+  install -Dm755 "${srcdir}/pwsp-gui" "${pkgdir}/usr/bin/pwsp-gui"
+
+  install -Dm644 "$_srcsrc/assets/pwsp-gui.desktop" "${pkgdir}/usr/share/applications/pwsp-gui.desktop"
+  install -Dm644 "$_srcsrc/assets/icon.png" "${pkgdir}/usr/share/icons/hicolor/256x256/apps/icon.png"
+  install -Dm644 "$_srcsrc/assets/pwsp-daemon.service" "${pkgdir}/usr/lib/systemd/user/pwsp-daemon.service"
+  
+  install -Dm644 "$_srcsrc/LICENSE" "${pkgdir}/usr/share/licenses/${pkgname}/LICENSE"
+}

packages/aur/standart/.SRCINFO

@@ -0,0 +1,16 @@
+pkgbase = pwsp
+	pkgdesc = Lets you play audio files through your microphone
+	pkgver = 1.7.2
+	pkgrel = 1
+	url = https://github.com/arabianq/pipewire-soundpad
+	arch = any
+	license = MIT
+	makedepends = clang
+	makedepends = rust
+	makedepends = cargo
+	makedepends = pipewire
+	makedepends = alsa-lib
+	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.7.2.tar.gz
+	sha256sums = SKIP
+
+pkgname = pwsp

packages/aur/standart/.gitignore

@@ -0,0 +1,163 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+*.db
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+poetry.lock
+
+.poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cythikaaryhon_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+#.vscode/

packages/aur/standart/PKGBUILD

@@ -0,0 +1,47 @@
+# Maintainer: Alexander Tarasov <a.tevg@ya.ru>
+pkgsubn=pwsp
+pkgname=pwsp
+pkgver=1.7.2
+pkgrel=1
+pkgdesc="Lets you play audio files through your microphone"
+arch=('any')
+url="https://github.com/arabianq/pipewire-soundpad"
+license=('MIT')
+makedepends=(clang rust cargo pipewire alsa-lib)
+source=("$url/archive/refs/tags/v$pkgver.tar.gz")
+sha256sums=('SKIP')
+
+
+prepare() {
+  cd "${srcdir}/pipewire-soundpad-${pkgver}"
+  
+  export CARGO_HOME="${srcdir}/${pkgname%}/.cargo"    # Download all to src directory, not in ~/.cargo
+
+  cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')"
+}
+
+build() {
+  cd "${srcdir}/pipewire-soundpad-${pkgver}"
+
+  export CARGO_ENCODED_RUSTFLAGS="--remap-path-prefix=${srcdir}=/"    # Prevent warning: 'Package contains reference to $srcdir'
+  [[ -n "${_sccache}" ]] && export RUSTC_WRAPPER=sccache  # If $_sccache not empty, build using binary cache
+
+  export CARGO_HOME="${srcdir}/${pkgname%}/.cargo"    # Use downloaded earlier from src directory, not from ~/.cargo
+  export CARGO_TARGET_DIR=target                        # Place the output in target relative to the current directory
+
+  cargo build --frozen --release
+}
+
+
+package() {
+  cd "${srcdir}/pipewire-soundpad-${pkgver}"
+  
+  install -Dm755 "target/release/pwsp-cli" "${pkgdir}/usr/bin/pwsp-cli"
+  install -Dm755 "target/release/pwsp-daemon" "${pkgdir}/usr/bin/pwsp-daemon"
+  install -Dm755 "target/release/pwsp-gui" "${pkgdir}/usr/bin/pwsp-gui"
+
+  install -Dm644 "assets/pwsp-gui.desktop" "${pkgdir}/usr/share/applications/pwsp-gui.desktop"
+  install -Dm644 "assets/icon.png" "${pkgdir}/usr/share/icons/hicolor/256x256/apps/icon.png"
+
+  install -Dm644 "assets/pwsp-daemon.service" "${pkgdir}/usr/lib/systemd/user/pwsp-daemon.service"
+}

packages/flatpak/pwsp-wrapper.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+
+import argparse
+import subprocess
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        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")
+
+    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("--kill", action="store_true", help="Kill pwsp-daemon")
+
+    args = parser.parse_args()
+
+    command = args.command
+    if not command:
+        subprocess.Popen("pwsp-daemon")
+        subprocess.Popen("pwsp-gui")
+    else:
+        if command == "cli":
+            subprocess.Popen(["pwsp-cli"] + args.args)
+        elif command == "daemon":
+            if args.start:
+                subprocess.Popen("pwsp-daemon")
+            elif args.kill:
+                subprocess.Popen(["pwsp-cli", "action", "kill"])

packages/flatpak/ru.arabianq.pwsp.desktop

@@ -0,0 +1,9 @@
+[Desktop Entry]
+Name=PWSP (Soundpad)
+Comment=Let's you play audio files through you microphone
+Exec=pwsp-wrapper.py %u
+Icon=ru.arabianq.pwsp
+Terminal=false
+Type=Application
+Categories=Audio;Utility;
+Keywords=soundpad;pipewire;audio;

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

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<component type="desktop-application">
+    <id>ru.arabianq.pwsp</id>
+    <metadata_license>CC0-1.0</metadata_license>
+    <project_license>MIT</project_license>
+    <name>PWSP</name>
+    <summary>Play audio files through your microphone using PipeWire</summary>
+    <description>
+        <p>
+            PWSP (PipeWire Soundpad) is a tool that allows you to play audio files through your
+            microphone.
+            It features both a graphical user interface and a command-line interface.
+        </p>
+    </description>
+    <launchable type="desktop-id">ru.arabianq.pwsp.desktop</launchable>
+    <screenshots>
+        <screenshot type="default">
+            <image>
+                https://raw.githubusercontent.com/arabianq/pipewire-soundpad/master/assets/screenshot.png</image>
+        </screenshot>
+    </screenshots>
+    <url type="homepage">https://pwsp.arabianq.ru</url>
+    <developer_name>arabian</developer_name>
+    <content_rating type="oars-1.1" />
+</component>

packages/flatpak/ru.arabianq.pwsp.yaml

@@ -0,0 +1,47 @@
+app-id: ru.arabianq.pwsp
+runtime: org.freedesktop.Platform
+runtime-version: "25.08"
+sdk: org.freedesktop.Sdk
+sdk-extensions:
+  - org.freedesktop.Sdk.Extension.rust-stable
+  - org.freedesktop.Sdk.Extension.llvm20
+command: pwsp-wrapper.py
+finish-args:
+  - --share=ipc
+  - --socket=fallback-x11
+  - --socket=wayland
+  - --socket=pulseaudio
+  - --filesystem=xdg-run/pipewire-0
+  - --filesystem=xdg-run/pwsp:create
+  - --filesystem=xdg-run/app/ru.arabianq.pwsp:create
+  - --filesystem=host
+  - --device=all
+  - --device=dri
+  - --share=network
+  - --talk-name=org.freedesktop.portal.Desktop
+  - --talk-name=org.freedesktop.portal.Documents
+
+build-options:
+  append-path: /usr/lib/sdk/rust-stable/bin:/usr/lib/sdk/llvm20/bin
+  env:
+    CARGO_HOME: /run/build/pwsp/cargo
+    LIBCLANG_PATH: /usr/lib/sdk/llvm20/lib
+
+modules:
+  - name: pwsp
+    buildsystem: simple
+    build-options:
+      build-args:
+        - --share=network
+    build-commands:
+      - cargo build --release
+      - install -Dm755 target/release/pwsp-daemon /app/bin/pwsp-daemon
+      - install -Dm755 target/release/pwsp-cli /app/bin/pwsp-cli
+      - install -Dm755 target/release/pwsp-gui /app/bin/pwsp-gui
+      - install -Dm755 packages/flatpak/pwsp-wrapper.py /app/bin/pwsp-wrapper.py
+      - install -Dm644 assets/icon.png /app/share/icons/hicolor/256x256/apps/ru.arabianq.pwsp.png
+      - install -Dm644 packages/flatpak/ru.arabianq.pwsp.desktop /app/share/applications/ru.arabianq.pwsp.desktop
+      - install -Dm644 packages/flatpak/ru.arabianq.pwsp.metainfo.xml /app/share/metainfo/ru.arabianq.pwsp.metainfo.xml
+    sources:
+      - type: dir
+        path: ../../

packages/rpm/pwsp.spec

@@ -0,0 +1,55 @@
+%bcond check 1
+
+# prevent library files from being installed
+%global cargo_install_lib 0
+
+Name:            pwsp
+Version:         1.7.2
+Release:         %autorelease
+Summary:         Lets you play audio files through your microphone
+
+License:         MIT
+
+URL:             https://github.com/arabianq/pipewire-soundpad
+Source:          https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v%{version}.tar.gz
+
+BuildRequires: rust
+BuildRequires: cargo
+BuildRequires: pipewire-devel
+BuildRequires: alsa-lib-devel
+BuildRequires: clang-devel
+
+%global _description %{expand:
+PWSP lets you play audio files through your microphone. Has both CLI and
+GUI clients.}
+
+%description %{_description}
+
+%prep
+%autosetup -n pipewire-soundpad-%{version} -p1
+
+%build
+cargo build --release --locked
+
+%install
+install -Dm755 target/release/pwsp-cli %{buildroot}%{_bindir}/pwsp-cli
+install -Dm755 target/release/pwsp-daemon %{buildroot}%{_bindir}/pwsp-daemon
+install -Dm755 target/release/pwsp-gui %{buildroot}%{_bindir}/pwsp-gui
+
+install -Dm644 assets/pwsp-gui.desktop %{buildroot}%{_datadir}/applications/pwsp.desktop
+install -Dm644 assets/icon.png %{buildroot}%{_datadir}/icons/hicolor/256x256/apps/pwsp.png
+
+install -Dm644 assets/pwsp-daemon.service %{buildroot}/usr/lib/systemd/user/pwsp-daemon.service
+
+%files
+%license LICENSE
+%doc README.md
+%{_bindir}/pwsp-cli
+%{_bindir}/pwsp-daemon
+%{_bindir}/pwsp-gui
+%{_datadir}/applications/pwsp.desktop
+%{_datadir}/icons/hicolor/256x256/apps/pwsp.png
+/usr/lib/systemd/user/pwsp-daemon.service
+
+%changelog
+%autochangelog

src/bin/cli.rs

@@ -0,0 +1,213 @@
+use clap::{Parser, Subcommand};
+use pwsp::{
+    types::socket::Request,
+    utils::daemon::{make_request, wait_for_daemon},
+};
+use std::{error::Error, path::PathBuf};
+
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+struct Cli {
+    #[clap(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand, Debug)]
+enum Commands {
+    /// Perform an action (ping, pause, resume, toggle-pause, stop, play)
+    Action {
+        #[clap(subcommand)]
+        action: Actions,
+    },
+    /// Get information from the player (is paused, volume, position, duration, state, current-file-path, input, inputs)
+    Get {
+        #[clap(subcommand)]
+        parameter: GetCommands,
+    },
+    /// Set information in the player (volume, position, input)
+    Set {
+        #[clap(subcommand)]
+        parameter: SetCommands,
+    },
+}
+
+#[derive(Subcommand, Debug)]
+enum Actions {
+    /// Ping the daemon
+    Ping,
+    /// Kill the daemon
+    Kill,
+    /// Pause audio playback
+    Pause {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Resume audio playback
+    Resume {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Toggle pause
+    TogglePause {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Stop audio playback and clear the queue
+    Stop {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Play a file
+    Play {
+        file_path: PathBuf,
+        #[clap(short, long)]
+        concurrent: bool,
+    },
+    /// Toggle loop
+    ToggleLoop {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Play a sound by hotkey slot name
+    PlayHotkey { slot: String },
+    /// Remove the hotkey slot
+    ClearHotkey { slot: String },
+    /// Clear the key chord for a hotkey slot
+    ClearHotkeyKey { slot: String },
+}
+
+#[derive(Subcommand, Debug)]
+enum GetCommands {
+    /// Check if the player is paused
+    IsPaused,
+    /// Playback volume
+    Volume {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Playback position (in seconds)
+    Position {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Duration of the current file
+    Duration {
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Player state (Playing, Paused or Stopped)
+    State,
+    /// Get all playing tracks
+    Tracks,
+    /// Current audio input
+    Input,
+    /// All audio inputs
+    Inputs,
+    /// Version of the daemon
+    DaemonVersion,
+    /// Full player state
+    FullState,
+    /// All hotkey slots
+    Hotkeys,
+}
+
+#[derive(Subcommand, Debug)]
+enum SetCommands {
+    /// Playback volume
+    Volume {
+        volume: f32,
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Playback position (in seconds)
+    Position {
+        position: f32,
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Audio input id (see pwsp-cli get inputs)
+    Input { name: String },
+    /// Enable or disable loop (true or false)
+    Loop {
+        enabled: String,
+        #[clap(short, long)]
+        id: Option<u32>,
+    },
+    /// Assign a sound file to a hotkey slot
+    Hotkey { slot: String, file_path: PathBuf },
+    /// Set the key chord for a hotkey slot (e.g. "Ctrl+Alt+1")
+    HotkeyKey { slot: String, key_chord: String },
+    /// Atomically set the action and key chord for a hotkey slot
+    HotkeyActionAndKey {
+        slot: String,
+        action: String,
+        key_chord: String,
+    },
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let cli = Cli::parse();
+
+    wait_for_daemon().await?;
+
+    let request = match cli.command {
+        Commands::Action { action } => match action {
+            Actions::Ping => Request::ping(),
+            Actions::Kill => Request::kill(),
+            Actions::Pause { id } => Request::pause(id),
+            Actions::Resume { id } => Request::resume(id),
+            Actions::TogglePause { id } => Request::toggle_pause(id),
+            Actions::Stop { id } => Request::stop(id),
+            Actions::Play {
+                file_path,
+                concurrent,
+            } => Request::play(&file_path.to_string_lossy(), concurrent),
+            Actions::ToggleLoop { id } => Request::toggle_loop(id),
+            Actions::PlayHotkey { slot } => Request::play_hotkey(&slot),
+            Actions::ClearHotkey { slot } => Request::clear_hotkey(&slot),
+            Actions::ClearHotkeyKey { slot } => Request::clear_hotkey_key(&slot),
+        },
+        Commands::Get { parameter } => match parameter {
+            GetCommands::IsPaused => Request::get_is_paused(),
+            GetCommands::Volume { id } => Request::get_volume(id),
+            GetCommands::Position { id } => Request::get_position(id),
+            GetCommands::Duration { id } => Request::get_duration(id),
+            GetCommands::State => Request::get_state(),
+            GetCommands::Tracks => Request::get_tracks(),
+            GetCommands::Input => Request::get_input(),
+            GetCommands::Inputs => Request::get_inputs(),
+            GetCommands::DaemonVersion => Request::get_daemon_version(),
+            GetCommands::FullState => Request::get_full_state(),
+            GetCommands::Hotkeys => Request::get_hotkeys(),
+        },
+        Commands::Set { parameter } => match parameter {
+            SetCommands::Volume { volume, id } => Request::set_volume(volume, id),
+            SetCommands::Position { position, id } => Request::seek(position, id),
+            SetCommands::Input { name } => Request::set_input(&name),
+            SetCommands::Loop { enabled, id } => Request::set_loop(&enabled, id),
+            SetCommands::Hotkey { slot, file_path } => {
+                Request::set_hotkey(&slot, &file_path.to_string_lossy())
+            }
+            SetCommands::HotkeyKey { slot, key_chord } => {
+                Request::set_hotkey_key(&slot, &key_chord)
+            }
+            SetCommands::HotkeyActionAndKey {
+                slot,
+                action,
+                key_chord,
+            } => Request::set_hotkey_action_and_key(
+                &slot,
+                &serde_json::from_str::<Request>(&action)?,
+                &key_chord,
+            ),
+        },
+    };
+
+    let response = make_request(request)
+        .await
+        .map_err(|e| e as Box<dyn Error>)?;
+    println!("{} : {}", response.status, response.message);
+
+    Ok(())
+}

src/bin/daemon.rs

@@ -0,0 +1,183 @@
+use pwsp::{
+    types::socket::{MAX_MESSAGE_SIZE, Request, Response},
+    utils::{
+        commands::parse_command,
+        daemon::{
+            create_runtime_dir, get_audio_player, get_daemon_config, get_runtime_dir,
+            is_daemon_running,
+        },
+        global_hotkeys::start_global_hotkey_listener,
+        pipewire::create_virtual_mic,
+    },
+};
+use std::os::unix::fs::PermissionsExt;
+use std::{error::Error, fs, time::Duration};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::UnixListener,
+    time::sleep,
+};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    create_runtime_dir()?;
+
+    if is_daemon_running()? {
+        return Err("Another instance is already running.".into());
+    }
+
+    get_daemon_config(); // Initialize daemon config
+    create_virtual_mic()?;
+    if let Err(err) = get_audio_player().await {
+        eprintln!("Failed to initialize audio player: {}", err);
+    } // Initialize audio player
+
+    tokio::spawn(async {
+        start_global_hotkey_listener().await;
+    });
+
+    let runtime_dir = get_runtime_dir();
+
+    let lock_file = fs::File::create(runtime_dir.join("daemon.lock"))?;
+    lock_file.lock()?;
+
+    let socket_path = runtime_dir.join("daemon.sock");
+    if let Err(e) = fs::remove_file(&socket_path) {
+        if e.kind() != std::io::ErrorKind::NotFound {
+            return Err(e.into());
+        }
+    }
+
+    let listener = UnixListener::bind(&socket_path)?;
+    fs::set_permissions(&socket_path, fs::Permissions::from_mode(0o600))?;
+
+    println!(
+        "Daemon started. Listening on {}",
+        socket_path.to_str().unwrap_or_default()
+    );
+
+    let commands_loop_handle = tokio::spawn(async {
+        commands_loop(listener).await.ok();
+    });
+
+    let player_loop_handle = tokio::spawn(async {
+        player_loop().await;
+    });
+
+    tokio::select! {
+        _ = commands_loop_handle => {
+            eprint!("Commands loop was finished, stopping program...");
+        }
+        _ = player_loop_handle => {
+            eprint!("Audio Player loop was finished, stopping program...");
+        }
+    }
+
+    Ok(())
+}
+
+async fn commands_loop(listener: UnixListener) -> Result<(), Box<dyn Error>> {
+    loop {
+        let (mut 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;
+            }
+
+            let request_len = u32::from_le_bytes(len_bytes) as usize;
+
+            if request_len > MAX_MESSAGE_SIZE {
+                eprintln!(
+                    "Failed to read message from client: request too large ({} bytes)!",
+                    request_len
+                );
+                return;
+            }
+
+            let mut buffer = vec![0u8; request_len];
+            if stream.read_exact(&mut buffer).await.is_err() {
+                eprintln!("Failed to read message from client!");
+                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) ----------
+
+            // ---------- 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 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);
+            }
+        });
+    }
+}
+
+async fn player_loop() {
+    let mut device_check_counter: u32 = 0;
+    loop {
+        let is_idle = match get_audio_player().await {
+            Ok(player_mutex) => {
+                let mut audio_player = player_mutex.lock().await;
+                let check_devices = device_check_counter == 0;
+                audio_player.update(check_devices).await;
+                audio_player.tracks.is_empty()
+            }
+            Err(_err) => true,
+        };
+
+        if is_idle {
+            device_check_counter = 0;
+            sleep(Duration::from_secs(2)).await;
+        } else {
+            // Check devices every ~5 seconds (50 * 100ms) while playing
+            device_check_counter = (device_check_counter + 1) % 50;
+            sleep(Duration::from_millis(100)).await;
+        }
+    }
+}

src/gui/draw.rs

@@ -0,0 +1,918 @@
+use crate::gui::SoundpadGui;
+use egui::{
+    Align, AtomExt, Button, CollapsingHeader, Color32, ComboBox, CursorIcon, FontFamily, Grid,
+    Label, Layout, RichText, ScrollArea, Sense, Slider, TextEdit, Ui, Vec2,
+};
+use egui_dnd::dnd;
+use egui_material_icons::icons::*;
+use pwsp::types::socket::Request;
+use pwsp::types::{audio_player::TrackInfo, gui::AppState};
+use pwsp::utils::gui::{format_time_pair, make_request_async};
+use std::{
+    path::{Path, PathBuf},
+    time::Instant,
+};
+
+enum TrackAction {
+    Pause(u32),
+    Resume(u32),
+    ToggleLoop(u32),
+    Stop(u32),
+}
+
+enum HotkeyAction {
+    Remove(String),
+    Capture(String),
+    ClearChord(String),
+    Play(String),
+}
+
+impl SoundpadGui {
+    fn get_volume_icon(volume: f32) -> &'static str {
+        if volume > 0.7 {
+            ICON_VOLUME_UP.codepoint
+        } else if volume <= 0.0 {
+            ICON_VOLUME_OFF.codepoint
+        } else if volume < 0.3 {
+            ICON_VOLUME_MUTE.codepoint
+        } else {
+            ICON_VOLUME_DOWN.codepoint
+        }
+    }
+
+    pub fn draw(&mut self, ui: &mut Ui) {
+        self.draw_header(ui);
+        self.draw_body(ui);
+        ui.separator();
+        self.draw_footer(ui);
+    }
+
+    pub fn draw_waiting_for_daemon(&mut self, ui: &mut Ui) {
+        ui.centered_and_justified(|ui| {
+            ui.label(
+                RichText::new("Waiting for PWSP daemon to start...")
+                    .size(34.0)
+                    .monospace(),
+            );
+        });
+    }
+
+    pub fn draw_hotkey_capture(&mut self, ui: &mut Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add_space(ui.available_height() / 3.0);
+            ui.label(
+                RichText::new("Press a key combination (e.g. Ctrl+Alt+1)")
+                    .size(18.0)
+                    .color(Color32::YELLOW)
+                    .monospace(),
+            );
+            ui.add_space(10.0);
+            let target = if let Some(slot) = &self.app_state.assigning_hotkey_slot {
+                format!("for slot '{}'", slot)
+            } else if let Some(path) = &self.app_state.assigning_hotkey_for_file {
+                format!(
+                    "for '{}'",
+                    path.file_name().unwrap_or_default().to_string_lossy()
+                )
+            } else {
+                String::new()
+            };
+            ui.label(RichText::new(target).size(16.0));
+            ui.add_space(10.0);
+            ui.label("Press Escape to cancel");
+        });
+    }
+
+    pub fn draw_settings(&mut self, ui: &mut Ui) {
+        ui.vertical(|ui| {
+            ui.spacing_mut().item_spacing.y = 5.0;
+            // --------- Back Button and Title ----------
+            ui.horizontal_top(|ui| {
+                let back_button = Button::new(ICON_ARROW_BACK).frame(false);
+                let back_button_response = ui.add(back_button);
+                if back_button_response.clicked() {
+                    self.app_state.show_settings = false;
+                }
+
+                ui.add_space(ui.available_width() / 2.0 - 40.0);
+
+                ui.label(RichText::new("Settings").color(Color32::WHITE).monospace());
+            });
+            // --------------------------------
+
+            ui.separator();
+            ui.add_space(20.0);
+
+            // --------- Checkboxes ----------
+            let save_volume_response =
+                ui.checkbox(&mut self.config.save_volume, "Always remember volume");
+            let save_input_response =
+                ui.checkbox(&mut self.config.save_input, "Always remember microphone");
+            let save_scale_response = ui.checkbox(
+                &mut self.config.save_scale_factor,
+                "Always remember UI scale factor",
+            );
+            let pause_on_exit_response = ui.checkbox(
+                &mut self.config.pause_on_exit,
+                "Pause audio playback when the window is closed",
+            );
+
+            if save_volume_response.changed()
+                || save_input_response.changed()
+                || save_scale_response.changed()
+                || pause_on_exit_response.changed()
+            {
+                self.config.save_to_file().ok();
+            }
+            // --------------------------------
+
+            ui.with_layout(Layout::bottom_up(Align::Min), |ui| {
+                ui.label(format!("GUI version: {}", env!("CARGO_PKG_VERSION")));
+            });
+        });
+    }
+
+    pub fn draw_hotkeys(&mut self, ui: &mut Ui) {
+        let area_size = ui.available_size();
+        ui.vertical(|ui| {
+            ui.set_min_width(area_size.x);
+            ui.set_min_height(area_size.y);
+            ui.spacing_mut().item_spacing.y = 5.0;
+
+            // Header
+            ui.horizontal_top(|ui| {
+                let back_button = Button::new(ICON_ARROW_BACK).frame(false);
+                if ui.add(back_button).clicked() {
+                    self.app_state.show_hotkeys = false;
+                }
+
+                ui.add_space(ui.available_width() / 2.0 - 40.0);
+                ui.label(RichText::new("Hotkeys").color(Color32::WHITE).monospace());
+            });
+
+            ui.separator();
+
+            // Search and Add Command
+            ui.horizontal(|ui| {
+                ui.menu_button(format!("{} Add Command", ICON_ADD.codepoint), |ui| {
+                    let mut selected_cmd = None;
+                    if ui.button("Toggle Pause").clicked() {
+                        selected_cmd = Some(("cmd_toggle_pause", Request::toggle_pause(None)));
+                    }
+                    if ui.button("Stop Playback").clicked() {
+                        selected_cmd = Some(("cmd_stop", Request::stop(None)));
+                    }
+                    if ui.button("Pause Playback").clicked() {
+                        selected_cmd = Some(("cmd_pause", Request::pause(None)));
+                    }
+                    if ui.button("Resume Playback").clicked() {
+                        selected_cmd = Some(("cmd_resume", Request::resume(None)));
+                    }
+                    if ui.button("Toggle Loop").clicked() {
+                        selected_cmd = Some(("cmd_toggle_loop", Request::toggle_loop(None)));
+                    }
+
+                    if let Some((slot_name, req)) = selected_cmd {
+                        make_request_async(Request::set_hotkey_action(slot_name, &req));
+                        self.app_state
+                            .hotkey_config
+                            .set_slot(slot_name.to_string(), req);
+                        self.app_state.assigning_hotkey_slot = Some(slot_name.to_string());
+                        self.app_state.hotkey_capture_active = true;
+                        ui.close();
+                    }
+                });
+
+                ui.add_space(10.0);
+
+                ui.add_sized(
+                    [ui.available_width(), 22.0],
+                    TextEdit::singleline(&mut self.app_state.hotkey_search_query)
+                        .hint_text("Search hotkeys..."),
+                );
+            });
+
+            ui.separator();
+            ui.add_space(5.0);
+
+            let conflicts = self.app_state.hotkey_config.find_conflicts();
+            let conflict_slots: std::collections::HashSet<String> = conflicts
+                .iter()
+                .flat_map(|(a, b)| vec![a.clone(), b.clone()])
+                .collect();
+
+            let search = self.app_state.hotkey_search_query.to_lowercase();
+
+            // Slots table
+            let mut action: Option<HotkeyAction> = None;
+            let area_size = ui.available_size();
+
+            ScrollArea::vertical().show(ui, |ui| {
+                ui.set_min_width(area_size.x);
+                Grid::new("hotkeys_grid")
+                    .striped(true)
+                    .num_columns(4)
+                    .max_col_width(area_size.x)
+                    .min_col_width(area_size.x / 4.0)
+                    .spacing([40.0, 10.0])
+                    .show(ui, |ui| {
+                        // Table header
+                        ui.label(
+                            RichText::new("Slot")
+                                .strong()
+                                .monospace()
+                                .color(Color32::LIGHT_GRAY),
+                        );
+                        ui.label(
+                            RichText::new("Sound")
+                                .strong()
+                                .monospace()
+                                .color(Color32::LIGHT_GRAY),
+                        );
+                        ui.label(
+                            RichText::new("Key Chord")
+                                .strong()
+                                .monospace()
+                                .color(Color32::LIGHT_GRAY),
+                        );
+                        ui.label(
+                            RichText::new("Actions")
+                                .strong()
+                                .monospace()
+                                .color(Color32::LIGHT_GRAY),
+                        );
+                        ui.end_row();
+
+                        let slots: Vec<_> = self
+                            .app_state
+                            .hotkey_config
+                            .slots
+                            .iter()
+                            .filter(|s| {
+                                if search.is_empty() {
+                                    return true;
+                                }
+                                s.slot.to_lowercase().contains(&search)
+                                    || format!("{:?}", s.action).to_lowercase().contains(&search)
+                                    || s.key_chord
+                                        .as_deref()
+                                        .unwrap_or("")
+                                        .to_lowercase()
+                                        .contains(&search)
+                            })
+                            .cloned()
+                            .collect();
+
+                        for slot in &slots {
+                            ui.horizontal(|ui| {
+                                // Conflict badge
+                                if conflict_slots.contains(&slot.slot) {
+                                    ui.label(
+                                        RichText::new(ICON_WARNING.codepoint)
+                                            .color(Color32::from_rgb(255, 165, 0)),
+                                    )
+                                    .on_hover_text("Key chord conflict");
+                                }
+
+                                // Slot name
+                                let slot_text = RichText::new(&slot.slot).monospace();
+                                ui.label(slot_text);
+                            });
+
+                            // Action description
+                            let action_name = match slot.action.name.as_str() {
+                                "play" => {
+                                    if let Some(file_path_str) = slot.action.args.get("file_path") {
+                                        Path::new(file_path_str)
+                                            .file_name()
+                                            .unwrap_or_default()
+                                            .to_string_lossy()
+                                            .to_string()
+                                    } else {
+                                        "Play".to_string()
+                                    }
+                                }
+                                "toggle_pause" => "Toggle Pause".to_string(),
+                                "pause" => "Pause Playback".to_string(),
+                                "resume" => "Resume Playback".to_string(),
+                                "stop" => "Stop Playback".to_string(),
+                                "toggle_loop" => "Toggle Loop".to_string(),
+                                other => other.to_string(),
+                            };
+                            ui.add(Label::new(RichText::new(action_name).monospace()).truncate());
+
+                            // Key chord
+                            let chord_text = slot.key_chord.as_deref().unwrap_or("(none)");
+                            ui.label(RichText::new(chord_text).monospace().color(
+                                if slot.key_chord.is_some() {
+                                    Color32::from_rgb(100, 200, 100)
+                                } else {
+                                    Color32::GRAY
+                                },
+                            ));
+
+                            ui.horizontal(|ui| {
+                                // Delete button
+                                if ui
+                                    .add(Button::new(ICON_DELETE).frame(false))
+                                    .on_hover_text("Remove slot")
+                                    .clicked()
+                                {
+                                    action = Some(HotkeyAction::Remove(slot.slot.clone()));
+                                }
+
+                                // Set key chord button
+                                if ui
+                                    .add(Button::new(ICON_KEYBOARD).frame(false))
+                                    .on_hover_text("Set key chord")
+                                    .clicked()
+                                {
+                                    action = Some(HotkeyAction::Capture(slot.slot.clone()));
+                                }
+
+                                // Clear key chord
+                                if slot.key_chord.is_some()
+                                    && ui
+                                        .add(Button::new(ICON_BACKSPACE).frame(false))
+                                        .on_hover_text("Clear key chord")
+                                        .clicked()
+                                {
+                                    action = Some(HotkeyAction::ClearChord(slot.slot.clone()));
+                                }
+
+                                // Play button
+                                if ui
+                                    .add(Button::new(ICON_PLAY_ARROW).frame(false))
+                                    .on_hover_text("Play")
+                                    .clicked()
+                                {
+                                    action = Some(HotkeyAction::Play(slot.slot.clone()));
+                                }
+                            });
+                            ui.end_row();
+                        }
+
+                        if slots.is_empty() {
+                            ui.label("No hotkey slots configured.");
+                            ui.label("");
+                            ui.label("");
+                            ui.label("");
+                            ui.end_row();
+                        }
+                    });
+            });
+
+            if let Some(action) = action {
+                match action {
+                    HotkeyAction::Remove(slot) => {
+                        make_request_async(Request::clear_hotkey(&slot));
+                        self.app_state.hotkey_config.remove_slot(&slot);
+                    }
+                    HotkeyAction::Capture(slot) => {
+                        self.app_state.assigning_hotkey_slot = Some(slot);
+                        self.app_state.hotkey_capture_active = true;
+                    }
+                    HotkeyAction::ClearChord(slot) => {
+                        make_request_async(Request::clear_hotkey_key(&slot));
+                        self.app_state.hotkey_config.set_key_chord(&slot, None);
+                    }
+                    HotkeyAction::Play(slot) => {
+                        self.play_hotkey_slot(&slot);
+                    }
+                }
+            }
+        });
+    }
+
+    fn draw_header(&mut self, ui: &mut Ui) {
+        ui.vertical_centered_justified(|ui| {
+            if self.audio_player_state.tracks.is_empty() {
+                ui.label("No tracks playing");
+                return;
+            }
+
+            let tracks = self.audio_player_state.tracks.clone();
+            let mut action = None;
+
+            for track in tracks {
+                CollapsingHeader::new(
+                    RichText::new(
+                        track
+                            .path
+                            .file_stem()
+                            .unwrap_or_default()
+                            .to_str()
+                            .unwrap_or_default(),
+                    )
+                    .color(Color32::WHITE)
+                    .family(FontFamily::Monospace),
+                )
+                .default_open(true)
+                .show(ui, |ui| {
+                    if let Some(act) = Self::draw_track_control(ui, &mut self.app_state, &track) {
+                        action = Some(act);
+                    }
+                });
+                ui.separator();
+            }
+
+            if let Some(action) = action {
+                match action {
+                    TrackAction::Pause(id) => self.pause(Some(id)),
+                    TrackAction::Resume(id) => self.resume(Some(id)),
+                    TrackAction::ToggleLoop(id) => self.toggle_loop(Some(id)),
+                    TrackAction::Stop(id) => self.stop(Some(id)),
+                }
+            }
+        });
+    }
+
+    fn draw_track_control(
+        ui: &mut Ui,
+        app_state: &mut AppState,
+        track: &TrackInfo,
+    ) -> Option<TrackAction> {
+        let ui_state = app_state.track_ui_states.entry(track.id).or_default();
+
+        let should_update_position = !ui_state.position_dragged
+            && ui_state
+                .ignore_position_update_until
+                .map(|t| Instant::now() > t)
+                .unwrap_or(true);
+
+        if should_update_position {
+            ui_state.position_slider_value = track.position;
+        }
+
+        let should_update_volume = !ui_state.volume_dragged
+            && ui_state
+                .ignore_volume_update_until
+                .map(|t| Instant::now() > t)
+                .unwrap_or(true);
+
+        if should_update_volume {
+            ui_state.volume_slider_value = track.volume;
+        }
+
+        let mut action = None;
+
+        ui.horizontal_top(|ui| {
+            // ---------- Play Button ----------
+            let play_button = Button::new(if track.paused {
+                ICON_PLAY_ARROW
+            } else {
+                ICON_PAUSE
+            })
+            .corner_radius(15.0);
+
+            let play_button_response = ui.add_sized([30.0, 30.0], play_button);
+            if play_button_response.clicked() {
+                if track.paused {
+                    action = Some(TrackAction::Resume(track.id));
+                } else {
+                    action = Some(TrackAction::Pause(track.id));
+                }
+            }
+            // --------------------------------
+
+            // ---------- Loop Button ----------
+            let loop_button = Button::new(
+                RichText::new(if track.looped {
+                    ICON_REPEAT_ONE
+                } else {
+                    ICON_REPEAT
+                })
+                .size(18.0),
+            )
+            .frame(false);
+
+            let loop_button_response = ui.add_sized([15.0, 30.0], loop_button);
+            if loop_button_response.clicked() {
+                action = Some(TrackAction::ToggleLoop(track.id));
+            }
+            // --------------------------------
+
+            // ---------- Position Slider ----------
+            let duration = track.duration.unwrap_or(1.0);
+            let position_slider = Slider::new(&mut ui_state.position_slider_value, 0.0..=duration)
+                .show_value(false)
+                .step_by(0.01);
+
+            let default_slider_width = ui.spacing().slider_width;
+            let position_slider_width = ui.available_width()
+                - (30.0 * 3.0)
+                - default_slider_width
+                - (ui.spacing().item_spacing.x * 6.0);
+            ui.spacing_mut().slider_width = position_slider_width;
+            let position_slider_response = ui.add_sized([30.0, 30.0], position_slider);
+            if position_slider_response.drag_stopped() {
+                ui_state.position_dragged = true;
+            }
+            // --------------------------------
+
+            // ---------- Time Label ----------
+            let time_label =
+                Label::new(RichText::new(format_time_pair(track.position, duration)).monospace());
+            ui.add_sized([30.0, 30.0], time_label);
+            // --------------------------------
+
+            // ---------- Volume Icon ----------
+            let volume_icon = Self::get_volume_icon(track.volume);
+            let volume_label = Label::new(RichText::new(volume_icon).size(18.0));
+            ui.add_sized([30.0, 30.0], volume_label)
+                .on_hover_text(format!("Volume: {:.0}%", track.volume * 100.0));
+            // --------------------------------
+
+            // ---------- Volume Slider ----------
+            let volume_slider = Slider::new(&mut ui_state.volume_slider_value, 0.0..=1.0)
+                .show_value(false)
+                .step_by(0.01);
+
+            ui.spacing_mut().slider_width = default_slider_width - 30.0;
+            ui.spacing_mut().item_spacing.x = 0.0;
+
+            let volume_slider_response = ui.add_sized([30.0, 30.0], volume_slider);
+            if volume_slider_response.drag_stopped() {
+                ui_state.volume_dragged = true;
+            }
+            // --------------------------------
+
+            // ---------- Stop Button ---------
+            let stop_button = Button::new(ICON_CLOSE).frame(false);
+            let stop_button_response = ui.add_sized([30.0, 30.0], stop_button);
+            if stop_button_response.clicked() {
+                action = Some(TrackAction::Stop(track.id));
+            }
+            // --------------------------------
+        });
+
+        action
+    }
+
+    fn draw_body(&mut self, ui: &mut Ui) {
+        let left_panel_width = self
+            .config
+            .left_panel_width
+            .max(100.0)
+            .min(ui.available_width() - 100.0);
+        let dirs_size = Vec2::new(left_panel_width, ui.available_height() - 40.0);
+
+        ui.horizontal(|ui| {
+            self.draw_dirs(ui, dirs_size);
+
+            let (rect, response) = ui.allocate_at_least(
+                Vec2::new(ui.spacing().item_spacing.x, ui.available_height()),
+                Sense::click_and_drag(),
+            );
+
+            if ui.is_rect_visible(rect) {
+                let stroke = ui.visuals().widgets.noninteractive.bg_stroke;
+                ui.painter().vline(rect.center().x, rect.y_range(), stroke);
+            }
+
+            let vertical_separator_response =
+                response.on_hover_and_drag_cursor(CursorIcon::ResizeHorizontal);
+
+            if vertical_separator_response.dragged() {
+                self.config.left_panel_width += vertical_separator_response.drag_delta().x;
+                self.config.left_panel_width = self.config.left_panel_width.clamp(100.0, 500.0);
+            }
+
+            if vertical_separator_response.drag_stopped() {
+                self.config.save_to_file().ok();
+            }
+
+            let files_size = Vec2::new(ui.available_width(), ui.available_height() - 40.0);
+            self.draw_files(ui, files_size);
+        });
+    }
+
+    fn draw_dirs(&mut self, ui: &mut Ui, area_size: Vec2) {
+        ui.vertical(|ui| {
+            ui.set_min_width(area_size.x);
+            ui.set_min_height(area_size.y);
+
+            ScrollArea::vertical().id_salt(0).show(ui, |ui| {
+                ui.set_min_width(area_size.x);
+
+                let mut dirs = self.app_state.dirs.clone();
+
+                dnd(ui, "dnd_directories").show_vec(&mut dirs, |ui, item, handle, _state| {
+                    let path = item.clone();
+                    ui.horizontal(|ui| {
+                        handle.ui(ui, |ui| {
+                            ui.label(ICON_DRAG_INDICATOR.codepoint);
+                        });
+                        let name = path
+                            .file_name()
+                            .map(|s| s.to_string_lossy().to_string())
+                            .unwrap_or_else(|| path.to_string_lossy().to_string());
+
+                        let mut dir_button_text = RichText::new(name.clone());
+                        if let Some(current_dir) = &self.app_state.current_dir {
+                            if current_dir.eq(&path) {
+                                dir_button_text = dir_button_text.color(Color32::WHITE);
+                            }
+                        }
+
+                        let dir_button =
+                            Button::new(dir_button_text.atom_max_width(area_size.x)).frame(false);
+
+                        let dir_button_response = ui.add(dir_button);
+                        if dir_button_response.clicked() {
+                            self.open_dir(&path);
+                        }
+
+                        let delete_dir_button = Button::new(ICON_DELETE).frame(false);
+                        let delete_dir_button_response =
+                            ui.add_sized([18.0, 18.0], delete_dir_button);
+                        if delete_dir_button_response.clicked() {
+                            self.app_state.dirs_to_remove.insert(path.clone());
+                        }
+
+                        // Context menu
+                        dir_button_response.context_menu(|ui| {
+                            if ui
+                                .button(format!("{} {}", ICON_OPEN_IN_NEW.codepoint, "Show"))
+                                .clicked()
+                            {
+                                self.open_dir(&path);
+                            }
+
+                            if ui
+                                .button(format!(
+                                    "{} {}",
+                                    ICON_OPEN_IN_BROWSER.codepoint, "Open in File Manager"
+                                ))
+                                .clicked()
+                            {
+                                if let Err(e) = opener::open(&path) {
+                                    eprintln!("Failed to open file manager: {}", e);
+                                }
+                            }
+
+                            ui.separator();
+
+                            if ui
+                                .button(format!("{} {}", ICON_DELETE.codepoint, "Remove"))
+                                .clicked()
+                            {
+                                self.app_state.dirs_to_remove.insert(path.clone());
+                            }
+                        });
+                    });
+                });
+                self.app_state.dirs = dirs;
+
+                ui.horizontal(|ui| {
+                    let add_dirs_button = Button::new(ICON_ADD).frame(false);
+                    let add_dirs_button_response = ui.add_sized([18.0, 18.0], add_dirs_button);
+                    if add_dirs_button_response.clicked() {
+                        self.add_dirs();
+                    }
+                });
+
+                ui.with_layout(Layout::bottom_up(Align::Min), |ui| {
+                    let play_file_button = Button::new("Play file");
+                    let play_file_button_response = ui.add(play_file_button);
+                    if play_file_button_response.clicked() {
+                        self.open_file();
+                    }
+                });
+            });
+        });
+    }
+
+    fn draw_files(&mut self, ui: &mut Ui, area_size: Vec2) {
+        ui.vertical(|ui| {
+            ui.horizontal(|ui| {
+                let search_field_response = ui.add_sized(
+                    [ui.available_width(), 22.0],
+                    TextEdit::singleline(&mut self.app_state.search_query).hint_text("Search..."),
+                );
+
+                if self.app_state.force_focus_search {
+                    search_field_response.request_focus();
+                    self.app_state.force_focus_search = false;
+                }
+
+                self.app_state.search_field_id = Some(search_field_response.id);
+            });
+
+            ui.separator();
+
+            ScrollArea::vertical().id_salt(1).show(ui, |ui| {
+                ui.set_min_width(area_size.x);
+                ui.set_min_height(area_size.y);
+
+                ui.vertical(|ui| {
+                    let files = self.get_filtered_files();
+
+                    for entry_path in files {
+                        let file_name = entry_path
+                            .file_name()
+                            .unwrap_or_default()
+                            .to_string_lossy()
+                            .to_string();
+
+                        ui.horizontal(|ui| {
+                            // Hotkey badge
+                            let hotkey_badge = self.get_hotkey_badge(&entry_path);
+                            if let Some(badge) = &hotkey_badge {
+                                ui.label(
+                                    RichText::new(badge)
+                                        .small()
+                                        .monospace()
+                                        .color(Color32::from_rgb(100, 200, 100)),
+                                );
+                            }
+
+                            let mut file_button_text = RichText::new(&file_name);
+                            if let Some(current_file) = &self.app_state.selected_file {
+                                if current_file.eq(&entry_path) {
+                                    file_button_text = file_button_text.color(Color32::WHITE);
+                                }
+                            }
+
+                            let file_button = Button::new(file_button_text).frame(false);
+                            let file_button_response = ui.add(file_button);
+                            if file_button_response.clicked() {
+                                ui.input(|i| {
+                                    if i.modifiers.ctrl {
+                                        self.play_file(&entry_path, true);
+                                    } else if i.modifiers.shift
+                                        && let Some(last_track) =
+                                            self.audio_player_state.tracks.last()
+                                    {
+                                        self.stop(Some(last_track.id));
+                                        self.play_file(&entry_path, true);
+                                    } else {
+                                        self.play_file(&entry_path, false);
+                                    }
+                                });
+                                self.app_state.selected_file = Some(entry_path.clone());
+                            }
+
+                            // Context menu
+                            file_button_response.context_menu(|ui| {
+                                if ui
+                                    .button(format!("{} {}", ICON_BOLT.codepoint, "Play Solo"))
+                                    .clicked()
+                                {
+                                    self.play_file(&entry_path, false);
+                                    self.app_state.selected_file = Some(entry_path.clone());
+                                }
+
+                                if ui
+                                    .button(format!("{} {}", ICON_ADD.codepoint, "Add New"))
+                                    .clicked()
+                                {
+                                    self.play_file(&entry_path, true);
+                                    self.app_state.selected_file = Some(entry_path.clone());
+                                }
+
+                                if ui
+                                    .button(format!(
+                                        "{} {}",
+                                        ICON_SWAP_HORIZ.codepoint, "Replace Last"
+                                    ))
+                                    .clicked()
+                                    && let Some(last_track) = self.audio_player_state.tracks.last()
+                                {
+                                    self.stop(Some(last_track.id));
+                                    self.play_file(&entry_path, true);
+                                    self.app_state.selected_file = Some(entry_path.clone());
+                                }
+
+                                ui.separator();
+
+                                if ui
+                                    .button(format!(
+                                        "{} {}",
+                                        ICON_OPEN_IN_BROWSER.codepoint, "Show in File Manager"
+                                    ))
+                                    .clicked()
+                                {
+                                    if let Err(e) = opener::reveal(&entry_path) {
+                                        eprintln!("Failed to open file manager: {}", e);
+                                    }
+                                }
+
+                                ui.separator();
+
+                                if ui
+                                    .button(format!(
+                                        "{} {}",
+                                        ICON_KEYBOARD.codepoint, "Assign Hotkey"
+                                    ))
+                                    .clicked()
+                                {
+                                    self.app_state.assigning_hotkey_for_file =
+                                        Some(entry_path.clone());
+                                    self.app_state.hotkey_capture_active = true;
+                                    ui.close();
+                                }
+                            });
+                        });
+                    }
+                });
+            });
+        });
+    }
+
+    fn get_hotkey_badge(&self, path: &PathBuf) -> Option<String> {
+        for slot in &self.app_state.hotkey_config.slots {
+            if slot.action.name == "play" {
+                if let Some(file_path_str) = slot.action.args.get("file_path") {
+                    if Path::new(file_path_str) == path.as_path() {
+                        if let Some(chord) = &slot.key_chord {
+                            return Some(format!("[{}]", chord));
+                        } else {
+                            return Some(format!("[{}]", slot.slot));
+                        }
+                    }
+                }
+            }
+        }
+        None
+    }
+
+    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("Choose microphone")
+                .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;
+            }
+            // ------------------------------------------
+
+            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;
+            }
+            // --------------------------------
+        });
+    }
+}

src/gui/input.rs

@@ -0,0 +1,283 @@
+use crate::gui::SoundpadGui;
+use egui::{Context, Id, Key, Modifiers};
+use pwsp::types::socket::Request;
+use pwsp::utils::gui::make_request_async;
+
+use std::path::PathBuf;
+
+/// Convert an egui Key + Modifiers to a normalized chord string like "Ctrl+Shift+A".
+fn chord_from_event(modifiers: &Modifiers, key: &Key) -> Option<String> {
+    let key_name = key.name();
+    let is_valid = (key_name.len() == 1
+        && key_name.chars().next().unwrap().is_ascii_alphanumeric())
+        || (key_name.starts_with('F')
+            && key_name.len() > 1
+            && key_name[1..].chars().all(|c| c.is_ascii_digit()));
+    if !is_valid {
+        return None;
+    }
+
+    // Require at least one modifier for hotkey chords (ignoring command/Super due to Wayland/Niri bug)
+    if !modifiers.ctrl && !modifiers.alt && !modifiers.shift {
+        return None;
+    }
+
+    let mut parts = vec![];
+    if modifiers.ctrl {
+        parts.push("Ctrl");
+    }
+    if modifiers.alt {
+        parts.push("Alt");
+    }
+    if modifiers.shift {
+        parts.push("Shift");
+    }
+    // We intentionally ignore modifiers.command (Super) here to bypass a Wayland/Niri bug
+    // where the Super key modifier is constantly active.
+
+    parts.push(key_name);
+
+    Some(parts.join("+"))
+}
+
+/// Parse a chord string back to (Modifiers, Key) for matching.
+pub fn parse_chord(chord: &str) -> Option<(Modifiers, Key)> {
+    let parts: Vec<&str> = chord.split('+').collect();
+    if parts.is_empty() {
+        return None;
+    }
+
+    let mut modifiers = Modifiers::NONE;
+    for &part in &parts[..parts.len() - 1] {
+        match part {
+            "Ctrl" => modifiers.ctrl = true,
+            "Alt" => modifiers.alt = true,
+            "Shift" => modifiers.shift = true,
+            "Super" => modifiers.command = true,
+            _ => return None,
+        }
+    }
+
+    let key_name = parts[parts.len() - 1];
+    let is_valid = (key_name.len() == 1
+        && key_name.chars().next().unwrap().is_ascii_alphanumeric())
+        || (key_name.starts_with('F')
+            && key_name.len() > 1
+            && key_name[1..].chars().all(|c| c.is_ascii_digit()));
+
+    if !is_valid {
+        return None;
+    }
+
+    let key = Key::from_name(key_name)?;
+
+    Some((modifiers, key))
+}
+
+impl SoundpadGui {
+    fn key_pressed(&self, ctx: &Context, key: Key) -> bool {
+        ctx.input(|i| i.key_pressed(key))
+    }
+
+    fn modifiers(&self, ctx: &Context) -> Modifiers {
+        ctx.input(|i| i.modifiers)
+    }
+
+    fn get_focused(&self, ctx: &Context) -> Option<Id> {
+        ctx.memory(|m| m.focused())
+    }
+
+    pub fn handle_input(&mut self, ctx: &Context) {
+        let modifiers = self.modifiers(ctx);
+        let search_focused = {
+            if let Some(focused_id) = self.get_focused(ctx)
+                && let Some(search_id) = self.app_state.search_field_id
+                && focused_id.eq(&search_id)
+            {
+                true
+            } else {
+                false
+            }
+        };
+
+        // Handle hotkey capture mode: listen for a key chord to assign
+        if self.app_state.hotkey_capture_active {
+            if self.key_pressed(ctx, Key::Escape) {
+                self.app_state.hotkey_capture_active = false;
+                self.app_state.assigning_hotkey_slot = None;
+                self.app_state.assigning_hotkey_for_file = None;
+                return;
+            }
+
+            // Try to capture a chord from any key press
+            let captured = ctx.input(|i| {
+                for event in &i.events {
+                    if let egui::Event::Key {
+                        key,
+                        pressed: true,
+                        modifiers: mods,
+                        ..
+                    } = event
+                        && let Some(chord) = chord_from_event(mods, key)
+                    {
+                        return Some(chord);
+                    }
+                }
+                None
+            });
+
+            if let Some(chord) = captured {
+                if let Some(slot) = self.app_state.assigning_hotkey_slot.take() {
+                    make_request_async(Request::set_hotkey_key(&slot, &chord));
+                    self.app_state
+                        .hotkey_config
+                        .set_key_chord(&slot, Some(chord));
+                } else if let Some(file_path) = self.app_state.assigning_hotkey_for_file.take() {
+                    // Auto-create a slot from the file name
+                    let slot_name = file_path
+                        .file_stem()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .to_string();
+                    let action = Request::play(&file_path.to_string_lossy(), false);
+
+                    make_request_async(Request::set_hotkey_action_and_key(
+                        &slot_name, &action, &chord,
+                    ));
+
+                    self.app_state
+                        .hotkey_config
+                        .set_slot(slot_name.clone(), action);
+                    self.app_state
+                        .hotkey_config
+                        .set_key_chord(&slot_name, Some(chord.clone()));
+                }
+                self.app_state.hotkey_capture_active = false;
+                self.app_state.assigning_hotkey_slot = None;
+                self.app_state.assigning_hotkey_for_file = None;
+            }
+            return;
+        }
+
+        // Open/close settings
+        if !search_focused && self.key_pressed(ctx, Key::I) {
+            self.app_state.show_settings = !self.app_state.show_settings;
+        }
+
+        // Toggle hotkeys view
+        if !search_focused && self.key_pressed(ctx, Key::H) {
+            self.app_state.show_hotkeys = !self.app_state.show_hotkeys;
+        }
+
+        if !self.app_state.show_settings && !self.app_state.show_hotkeys {
+            // Pause / resume audio on space
+            if !search_focused && self.key_pressed(ctx, Key::Space) {
+                self.play_toggle();
+            }
+
+            // Stop all audio tracks on backspace
+            if !search_focused && self.key_pressed(ctx, Key::Backspace) {
+                self.stop(None);
+            }
+
+            // Focus search field
+            if self.key_pressed(ctx, Key::Slash) {
+                if search_focused {
+                    ctx.memory_mut(|m| {
+                        m.request_focus(Id::NULL);
+                    });
+                } else {
+                    self.app_state.force_focus_search = true;
+                }
+            }
+
+            // Play selected file on Enter
+            if self.key_pressed(ctx, Key::Enter) {
+                if let Some(path) = self.app_state.selected_file.clone() {
+                    if modifiers.ctrl {
+                        self.play_file(&path, true);
+                    } else if modifiers.shift
+                        && let Some(last_track) = self.audio_player_state.tracks.last()
+                    {
+                        self.stop(Some(last_track.id));
+                        self.play_file(&path, true);
+                    } else {
+                        self.play_file(&path, false);
+                    }
+                }
+            }
+
+            // Iterate through dirs and files with Ctrl + Up/Down
+            let arrow_up_pressed = self.key_pressed(ctx, Key::ArrowUp);
+            let arrow_down_pressed = self.key_pressed(ctx, Key::ArrowDown);
+            if modifiers.ctrl && (arrow_up_pressed || arrow_down_pressed) {
+                if modifiers.shift && !self.app_state.dirs.is_empty() {
+                    let mut dirs: Vec<PathBuf> = self.app_state.dirs.iter().cloned().collect();
+                    dirs.sort();
+
+                    let current_dir_index = self
+                        .app_state
+                        .current_dir
+                        .as_ref()
+                        .and_then(|cd| dirs.iter().position(|x| x == cd));
+
+                    let new_dir_index =
+                        match (current_dir_index, arrow_up_pressed, arrow_down_pressed) {
+                            (Some(i), true, false) => (i + dirs.len() - 1) % dirs.len(),
+                            (Some(i), false, true) => (i + 1) % dirs.len(),
+                            (Some(i), true, true) => i,
+                            (None, true, _) => dirs.len() - 1,
+                            (None, false, true) => 0,
+                            _ => return,
+                        };
+
+                    self.open_dir(&dirs[new_dir_index]);
+                } else if self.app_state.current_dir.is_some() {
+                    let files = self.get_filtered_files();
+
+                    if files.is_empty() {
+                        return;
+                    }
+
+                    let current_files_index = self
+                        .app_state
+                        .selected_file
+                        .as_ref()
+                        .and_then(|f| files.iter().position(|x| x == f));
+
+                    let new_files_index =
+                        match (current_files_index, arrow_up_pressed, arrow_down_pressed) {
+                            (Some(i), true, false) => (i + files.len() - 1) % files.len(),
+                            (Some(i), false, true) => (i + 1) % files.len(),
+                            (Some(i), true, true) => i,
+                            (None, true, _) => files.len() - 1,
+                            (None, false, true) => 0,
+                            _ => return,
+                        };
+
+                    self.app_state.selected_file = Some(files[new_files_index].clone());
+                }
+            }
+
+            // Check for hotkey chord triggers
+            let slots_to_play: Vec<String> = ctx.input(|i| {
+                let mut result = vec![];
+                for slot in &self.app_state.hotkey_config.slots {
+                    if let Some(chord) = &slot.key_chord
+                        && let Some((mods, key)) = parse_chord(chord)
+                        && i.modifiers == mods
+                        && i.key_pressed(key)
+                    {
+                        result.push(slot.slot.clone());
+                    }
+                }
+                result
+            });
+
+            for slot in slots_to_play {
+                self.play_hotkey_slot(&slot);
+            }
+        }
+        // });
+    }
+}

src/gui/mod.rs

@@ -0,0 +1,233 @@
+mod draw;
+mod input;
+mod update;
+
+use eframe::{HardwareAcceleration, NativeOptions, icon_data::from_png_bytes, run_native};
+use egui::{Context, Vec2, ViewportBuilder};
+use itertools::Itertools;
+use pwsp::{
+    types::{
+        audio_player::PlayerState,
+        config::GuiConfig,
+        config::HotkeyConfig,
+        gui::{AppState, AudioPlayerState},
+        socket::Request,
+    },
+    utils::{
+        daemon::get_daemon_config,
+        gui::{get_gui_config, make_request_async, make_request_sync, start_app_state_thread},
+    },
+};
+use rfd::FileDialog;
+use std::{
+    error::Error,
+    path::PathBuf,
+    sync::{Arc, Mutex},
+};
+
+const SUPPORTED_EXTENSIONS: [&str; 12] = [
+    "mp3", "wav", "ogg", "flac", "mp4", "m4a", "aac", "mov", "mkv", "mka", "webm", "avi",
+];
+
+struct SoundpadGui {
+    pub app_state: AppState,
+    pub config: GuiConfig,
+    pub audio_player_state: AudioPlayerState,
+    pub audio_player_state_shared: Arc<Mutex<AudioPlayerState>>,
+}
+
+impl SoundpadGui {
+    fn new(ctx: &Context) -> Self {
+        let audio_player_state = Arc::new(Mutex::new(AudioPlayerState::default()));
+        start_app_state_thread(audio_player_state.clone());
+
+        let config = get_gui_config();
+
+        ctx.set_zoom_factor(config.scale_factor);
+
+        let mut soundpad_gui = SoundpadGui {
+            app_state: AppState::default(),
+            config: config.clone(),
+            audio_player_state: AudioPlayerState::default(),
+            audio_player_state_shared: audio_player_state.clone(),
+        };
+
+        soundpad_gui.app_state.dirs = config.dirs;
+        soundpad_gui.app_state.hotkey_config = HotkeyConfig::load().unwrap_or_default();
+
+        soundpad_gui
+    }
+
+    pub fn play_toggle(&mut self) {
+        let (new_state, request) = {
+            let guard = self
+                .audio_player_state_shared
+                .lock()
+                .unwrap_or_else(|e| e.into_inner());
+            match guard.state {
+                PlayerState::Playing => (Some(PlayerState::Paused), Some(Request::pause(None))),
+                PlayerState::Paused => (Some(PlayerState::Playing), Some(Request::resume(None))),
+                PlayerState::Stopped => (None, None),
+            }
+        };
+
+        if let Some(req) = request {
+            make_request_async(req);
+        }
+
+        if let Some(state) = new_state {
+            let mut guard = self
+                .audio_player_state_shared
+                .lock()
+                .unwrap_or_else(|e| e.into_inner());
+            guard.new_state = Some(state.clone());
+            guard.state = state;
+        }
+    }
+
+    pub fn open_file(&mut self) {
+        let file_dialog = FileDialog::new().add_filter("Audio File", &SUPPORTED_EXTENSIONS);
+        if let Some(path) = file_dialog.pick_file() {
+            self.play_file(&path, false);
+        }
+    }
+
+    pub fn add_dirs(&mut self) {
+        let file_dialog = FileDialog::new();
+        if let Some(paths) = file_dialog.pick_folders() {
+            for path in paths {
+                self.app_state.dirs.push(path);
+            }
+            self.app_state.dirs = self.app_state.dirs.iter().unique().cloned().collect();
+            self.config.dirs = self.app_state.dirs.clone();
+            self.config.save_to_file().ok();
+        }
+    }
+
+    pub fn open_dir(&mut self, path: &PathBuf) {
+        self.app_state.current_dir = Some(path.clone());
+        match path.read_dir() {
+            Ok(read_dir) => {
+                self.app_state.files = read_dir
+                    .filter_map(|res| res.ok())
+                    .map(|entry| entry.path())
+                    .collect();
+            }
+            Err(e) => {
+                eprintln!("Failed to read directory {:?}: {}", path, e);
+                self.app_state.files.clear();
+            }
+        }
+    }
+
+    pub fn play_file(&mut self, path: &PathBuf, concurrent: bool) {
+        make_request_async(Request::play(&path.to_string_lossy(), concurrent));
+    }
+
+    pub fn set_input(&mut self, name: String) {
+        make_request_async(Request::set_input(&name));
+
+        if self.config.save_input {
+            let mut daemon_config = get_daemon_config();
+            daemon_config.default_input_name = Some(name);
+            daemon_config.save_to_file().ok();
+        }
+    }
+
+    pub fn toggle_loop(&mut self, id: Option<u32>) {
+        make_request_async(Request::toggle_loop(id));
+    }
+
+    pub fn pause(&mut self, id: Option<u32>) {
+        make_request_async(Request::pause(id));
+    }
+
+    pub fn resume(&mut self, id: Option<u32>) {
+        make_request_async(Request::resume(id));
+    }
+
+    pub fn stop(&mut self, id: Option<u32>) {
+        make_request_async(Request::stop(id));
+    }
+
+    pub fn play_hotkey_slot(&mut self, slot: &str) {
+        make_request_async(Request::play_hotkey(slot));
+    }
+
+    pub fn get_filtered_files(&self) -> Vec<PathBuf> {
+        let mut files: Vec<PathBuf> = self.app_state.files.iter().cloned().collect();
+        files.sort();
+
+        let search_query = self.app_state.search_query.to_lowercase();
+        let search_query = search_query.trim();
+
+        files
+            .into_iter()
+            .filter(|entry_path| {
+                if entry_path.is_dir() {
+                    return false;
+                }
+
+                if !SUPPORTED_EXTENSIONS.contains(
+                    &entry_path
+                        .extension()
+                        .unwrap_or_default()
+                        .to_str()
+                        .unwrap_or_default(),
+                ) {
+                    return false;
+                }
+
+                if !search_query.is_empty() {
+                    let file_name = entry_path
+                        .file_name()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .to_string();
+
+                    if !file_name.to_lowercase().contains(search_query) {
+                        return false;
+                    }
+                }
+
+                true
+            })
+            .collect()
+    }
+}
+
+pub async fn run() -> Result<(), Box<dyn Error>> {
+    const ICON: &[u8] = include_bytes!("../../assets/icon.png");
+
+    let options = NativeOptions {
+        vsync: true,
+        centered: true,
+        hardware_acceleration: HardwareAcceleration::Preferred,
+
+        viewport: ViewportBuilder::default()
+            .with_app_id("ru.arabianq.pwsp")
+            .with_inner_size(Vec2::new(1200.0, 800.0))
+            .with_min_inner_size(Vec2::new(800.0, 600.0))
+            .with_icon(from_png_bytes(ICON)?),
+
+        ..Default::default()
+    };
+
+    match run_native(
+        "Pipewire Soundpad",
+        options,
+        Box::new(|cc| {
+            egui_material_icons::initialize(&cc.egui_ctx);
+            Ok(Box::new(SoundpadGui::new(&cc.egui_ctx)))
+        }),
+    ) {
+        Ok(_) => {
+            let config = get_gui_config();
+            if config.pause_on_exit {
+                make_request_sync(Request::pause(None)).ok();
+            }
+            Ok(())
+        }
+        Err(e) => Err(e.into()),
+    }
+}

src/gui/update.rs

@@ -0,0 +1,134 @@
+use crate::gui::SoundpadGui;
+use eframe::{App, Frame as EFrame};
+use egui::{CentralPanel, Context};
+use pwsp::{
+    types::socket::Request,
+    utils::{daemon::get_daemon_config, gui::make_request_async},
+};
+use std::time::{Duration, Instant};
+
+impl App for SoundpadGui {
+    fn logic(&mut self, ctx: &Context, _frame: &mut EFrame) {
+        // Remove directories
+        for path in self.app_state.dirs_to_remove.drain() {
+            self.app_state.dirs.retain(|x| x != &path);
+            if let Some(current_dir) = &self.app_state.current_dir
+                && current_dir == &path
+            {
+                self.app_state.current_dir = None;
+                self.app_state.files.clear();
+            }
+        }
+
+        // Save directories if changed
+        if !self.config.dirs.eq(&self.app_state.dirs) {
+            self.config.dirs = self.app_state.dirs.clone();
+            self.config.save_to_file().ok();
+        }
+
+        // Seek and volume requests
+        let mut seek_requests = vec![];
+        let mut volume_requests = vec![];
+
+        for (id, ui_state) in &mut self.app_state.track_ui_states {
+            if ui_state.position_dragged {
+                seek_requests.push((*id, ui_state.position_slider_value));
+            }
+            if ui_state.volume_dragged {
+                volume_requests.push((*id, ui_state.volume_slider_value));
+                ui_state.volume_dragged = false;
+            }
+        }
+
+        for (id, pos) in seek_requests {
+            make_request_async(Request::seek(pos, Some(id)));
+            if let Some(ui_state) = self.app_state.track_ui_states.get_mut(&id) {
+                ui_state.position_dragged = false;
+                ui_state.ignore_position_update_until =
+                    Some(Instant::now() + Duration::from_millis(300));
+            }
+        }
+
+        for (id, vol) in volume_requests {
+            make_request_async(Request::set_volume(vol, Some(id)));
+            if let Some(ui_state) = self.app_state.track_ui_states.get_mut(&id) {
+                ui_state.volume_dragged = false;
+                ui_state.ignore_volume_update_until =
+                    Some(Instant::now() + Duration::from_millis(300));
+            }
+        }
+
+        if self.app_state.volume_dragged {
+            make_request_async(Request::set_volume(
+                self.app_state.volume_slider_value,
+                None,
+            ));
+
+            self.app_state.volume_dragged = false;
+            self.app_state.ignore_volume_update_until =
+                Some(Instant::now() + Duration::from_millis(300));
+
+            if self.config.save_volume {
+                let mut daemon_config = get_daemon_config();
+                daemon_config.default_volume = Some(self.app_state.volume_slider_value);
+                daemon_config.save_to_file().ok();
+            }
+        }
+
+        // Sync audio player state
+        {
+            let mut guard = self
+                .audio_player_state_shared
+                .lock()
+                .unwrap_or_else(|e| e.into_inner());
+            if let Some(config) = guard.hotkey_config.take() {
+                self.app_state.hotkey_config = config;
+            }
+            self.audio_player_state = guard.clone();
+        }
+
+        // Handle scale factor changes
+        let old_scale_factor = self.config.scale_factor;
+        let new_scale_factor = ctx.zoom_factor().clamp(0.5, 2.0);
+
+        ctx.set_zoom_factor(new_scale_factor);
+        self.config.scale_factor = new_scale_factor;
+
+        if new_scale_factor != old_scale_factor && self.config.save_scale_factor {
+            self.config.save_to_file().ok();
+        }
+
+        // Handle input
+        self.handle_input(ctx);
+    }
+
+    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut EFrame) {
+        // Draw UI
+        CentralPanel::default().show_inside(ui, |ui| {
+            if !self.audio_player_state.is_daemon_running {
+                self.draw_waiting_for_daemon(ui);
+                return;
+            }
+
+            if self.app_state.hotkey_capture_active {
+                self.draw_hotkey_capture(ui);
+                return;
+            }
+
+            if self.app_state.show_settings {
+                self.draw_settings(ui);
+                return;
+            }
+
+            if self.app_state.show_hotkeys {
+                self.draw_hotkeys(ui);
+                return;
+            }
+
+            self.draw(ui);
+        });
+
+        // Request repaint
+        ui.request_repaint_after_secs(1.0 / 60.0);
+    }
+}

src/lib.rs

@@ -0,0 +1,2 @@
+pub mod types;
+pub mod utils;

src/main.rs

@@ -1,465 +1,8 @@
-use eframe::{CreationContext, Frame, NativeOptions};
-use egui::{
-    Button, CentralPanel, ComboBox, Context, Label, ScrollArea, Separator, Slider, TextEdit, Ui,
-    Vec2,
-};
-use egui_material_icons::icons;
-use metadata::media_file::MediaFileMetadata;
-use rfd::FileDialog;
-use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink};
-use std::io::Write;
-use std::{fs, path::PathBuf};
+mod gui;
 
-mod pw;
+use std::error::Error;
 
-enum PlayerState {
-    PLAYING,
-    PAUSED,
-}
-
-impl Default for PlayerState {
-    fn default() -> Self {
-        PlayerState::PAUSED
-    }
-}
-
-#[derive(Default)]
-struct App {
-    player_position: f32,
-    prev_player_position: f32,
-    max_player_position: f32,
-
-    volume: f32,
-
-    player_state: PlayerState,
-
-    directories: Vec<PathBuf>,
-    deleted_directory: Option<usize>,
-    current_directory: Option<usize>,
-
-    selected_input_device: String,
-    available_input_devices: Vec<pw::InputDevice>,
-
-    current_file: PathBuf,
-
-    search_query: String,
-
-    _audio_stream: Option<OutputStream>,
-    _audio_stream_handle: Option<OutputStreamHandle>,
-    audio_sink: Option<Sink>,
-}
-
-impl App {
-    pub fn new(_cc: &CreationContext<'_>) -> Self {
-        let saved_dirs_path = dirs::config_dir().unwrap().join("pwsp").join("saved_dirs");
-        let saved_dirs_content = fs::read_to_string(&saved_dirs_path).unwrap_or_default();
-        let saved_dirs: Vec<_> = saved_dirs_content.lines().map(PathBuf::from).collect();
-        let current_directory = match saved_dirs.is_empty() {
-            false => Some(0),
-            true => None,
-        };
-
-        let saved_mic_path = dirs::config_dir().unwrap().join("pwsp").join("saved_mic");
-        let saved_mic_content = fs::read_to_string(&saved_mic_path).unwrap_or_default();
-
-        let (_audio_stream, audio_stream_handle) = OutputStream::try_default().unwrap();
-        let audio_sink = Sink::try_new(&audio_stream_handle).unwrap();
-        audio_sink.pause();
-
-        Self {
-            max_player_position: 1.0,
-            directories: saved_dirs,
-            selected_input_device: saved_mic_content,
-            _audio_stream: Some(_audio_stream),
-            _audio_stream_handle: Some(audio_stream_handle),
-            audio_sink: Some(audio_sink),
-            volume: 1.0,
-            current_directory,
-
-            ..Default::default()
-        }
-    }
-
-    fn upd(&mut self, ui: &mut Ui, ctx: &Context, _frame: &mut Frame) {
-        self.available_input_devices = pw::get_input_devices().unwrap();
-
-        let saved_mic_path = dirs::config_dir().unwrap().join("pwsp").join("saved_mic");
-        let saved_mic_content = fs::read_to_string(&saved_mic_path).unwrap_or_default();
-        if self.selected_input_device != saved_mic_content {
-            fs::write(saved_mic_path, self.selected_input_device.clone()).ok();
-        }
-
-        if let PlayerState::PLAYING = self.player_state {
-            ctx.request_repaint();
-            self.audio_sink.as_ref().unwrap().set_volume(self.volume);
-        }
-
-        self.player_state = match self.audio_sink.as_ref().unwrap().is_paused() {
-            true => PlayerState::PAUSED,
-            false => PlayerState::PLAYING,
-        };
-
-        if self.player_position != self.prev_player_position {
-            let target_pos = core::time::Duration::from_secs_f32(self.player_position);
-            self.audio_sink
-                .as_ref()
-                .unwrap()
-                .try_seek(target_pos)
-                .unwrap();
-            self.prev_player_position = self.player_position;
-        } else {
-            self.player_position = self.audio_sink.as_ref().unwrap().get_pos().as_secs_f32();
-        }
-
-        self.prev_player_position = self.player_position;
-
-        self.render_ui(ui);
-    }
-
-    fn render_ui(&mut self, ui: &mut Ui) {
-        self.render_player(ui);
-
-        ui.add_space(10.0);
-        ui.separator();
-        ui.add_space(10.0);
-
-        self.render_content(ui);
-    }
-
-    fn render_player(&mut self, ui: &mut Ui) {
-        let file_title_label = Label::new(
-            self.current_file
-                .file_name()
-                .and_then(|n| n.to_str())
-                .unwrap_or(""),
-        );
-
-        let play_button_icon = match self.player_state {
-            PlayerState::PLAYING => icons::ICON_PAUSE,
-            PlayerState::PAUSED => icons::ICON_PLAY_ARROW,
-        };
-        let play_button = Button::new(play_button_icon).corner_radius(15.0);
-
-        let position_minutes = (self.player_position / 60.0) as i32;
-        let position_seconds = (self.player_position - (position_minutes as f32) * 60.0) as i32;
-        let position_minutes_str = match position_minutes.to_string().chars().count() {
-            1 => "0".to_string() + &position_minutes.to_string(),
-            2 => position_minutes.to_string(),
-            _ => "00".to_string(),
-        };
-        let position_seconds_str = match position_seconds.to_string().chars().count() {
-            1 => "0".to_string() + &position_seconds.to_string(),
-            2 => position_seconds.to_string(),
-            _ => "00".to_string(),
-        };
-        let player_position_label =
-            Label::new(format!("{}:{}", position_minutes_str, position_seconds_str));
-
-        let player_position_slider =
-            Slider::new(&mut self.player_position, 0.0..=self.max_player_position)
-                .show_value(false);
-
-        let volume_slider = Slider::new(&mut self.volume, 0.0..=1.0).show_value(false);
-
-        ui.add_space(10.0);
-
-        ui.horizontal_top(|ui| {
-            let play_button_response = ui.add_sized([30.0, 30.0], play_button);
-            if !self.current_file.display().to_string().is_empty() && play_button_response.clicked()
-            {
-                match self.player_state {
-                    PlayerState::PLAYING => {
-                        self.audio_sink.as_ref().unwrap().pause();
-                    }
-                    PlayerState::PAUSED => {
-                        self.audio_sink.as_ref().unwrap().play();
-                    }
-                }
-            }
-
-            ui.vertical(|ui| {
-                ui.spacing_mut().slider_width = ui.available_width() - 150.0;
-                ui.add_sized([ui.available_width() - 150.0, 15.0], file_title_label);
-                ui.add_sized([ui.available_width() - 150.0, 15.0], player_position_slider);
-            });
-
-            ui.add_sized([30.0, 30.0], player_position_label);
-
-            let volume_slider_response = ui.add_sized([15.0, 30.0], volume_slider);
-            if volume_slider_response.changed() {
-                // println!("{}", self.volume.);
-            }
-        });
-    }
-
-    fn render_content(&mut self, ui: &mut Ui) {
-        let dirs_area_size = Vec2::new(120.0, ui.available_height());
-
-        ui.horizontal(|ui| {
-            ui.vertical(|ui| {
-                self.render_directories_list(ui, dirs_area_size);
-                self.render_mic_selection(ui);
-            });
-            ui.allocate_ui(dirs_area_size, |ui| {
-                if !self.directories.is_empty() {
-                    ui.add(Separator::default().vertical());
-                }
-            });
-
-            let music_area_size = Vec2::new(ui.available_width(), ui.available_height());
-            self.render_music_list(ui, music_area_size);
-        });
-
-        self.handle_directory_deletion();
-    }
-
-    fn render_directories_list(&mut self, ui: &mut Ui, scroll_area_size: Vec2) {
-        let add_dir_button = Button::new(icons::ICON_ADD).frame(false);
-
-        ui.vertical(|ui| {
-            let add_dir_button_response = ui.add_sized([20.0, 20.0], add_dir_button);
-            if add_dir_button_response.clicked() {
-                self.handle_directory_adding();
-            }
-
-            ui.add_space(10.0);
-
-            ui.allocate_ui(scroll_area_size, |ui| {
-                ScrollArea::vertical().id_salt(0).show(ui, |ui| {
-                    for (index, dir) in self.directories.iter().enumerate() {
-                        let dir_name = dir
-                            .file_name()
-                            .and_then(|n| n.to_str())
-                            .unwrap_or("Invalid Directory");
-                        let dir_button = Button::new(dir_name).frame(false);
-
-                        let dir_delete_button = Button::new(icons::ICON_DELETE).frame(false);
-
-                        ui.horizontal(|ui| {
-                            let dir_button_response = ui.add(dir_button);
-                            if dir_button_response.clicked() {
-                                self.current_directory = Some(index);
-                            }
-
-                            let directory_delete_button_response = ui.add(dir_delete_button);
-                            if directory_delete_button_response.clicked() {
-                                self.deleted_directory = Some(index);
-                            }
-                        });
-                        ui.separator();
-                    }
-                });
-            });
-        });
-    }
-
-    fn handle_directory_adding(&mut self) {
-        if let Some(dirs) = FileDialog::pick_folders(Default::default()) {
-            let saved_dirs_path = dirs::config_dir().unwrap().join("pwsp").join("saved_dirs");
-            if let Ok(mut file) = fs::OpenOptions::new().append(true).open(saved_dirs_path) {
-                for path in dirs {
-                    if !self.directories.contains(&path) {
-                        self.directories.push(path.clone());
-                        writeln!(file, "{}", path.display()).ok();
-                    }
-                }
-            }
-        }
-    }
-
-    fn handle_directory_deletion(&mut self) {
-        if let Some(index) = self.deleted_directory {
-            if let Some(current_index) = self.current_directory {
-                if current_index > index {
-                    self.current_directory = Some(current_index - 1);
-                } else if current_index == index {
-                    self.current_directory = None;
-                }
-            }
-
-            self.directories.remove(index);
-            self.deleted_directory = None;
-
-            let saved_dirs_path = dirs::config_dir().unwrap().join("pwsp").join("saved_dirs");
-            let content = self
-                .directories
-                .iter()
-                .map(|p| p.display().to_string())
-                .collect::<Vec<_>>()
-                .join("\n");
-
-            fs::write(saved_dirs_path, content).ok();
-        }
-    }
-
-    fn render_music_list(&mut self, ui: &mut Ui, scroll_area_size: Vec2) {
-        if self.current_directory.is_none() {
-            return;
-        }
-
-        let current_path = self
-            .directories
-            .get(self.current_directory.unwrap())
-            .unwrap();
-        if !fs::exists(current_path).ok().unwrap_or(false) {
-            self.deleted_directory = self.current_directory;
-            return;
-        }
-
-        let files = fs::read_dir(current_path).ok().unwrap();
-        let mut music_files = Vec::new();
-        let music_extensions = ["mp3", "wav", "ogg", "flac", "mp4", "aac"].to_vec();
-        for file in files {
-            let path = file.unwrap().path();
-
-            if !path.is_file() {
-                continue;
-            }
-
-            if let Some(extension) = path.extension().and_then(|n| n.to_str()) {
-                if music_extensions.contains(&extension.to_lowercase().as_str()) {
-                    if path
-                        .to_str()
-                        .unwrap()
-                        .to_string()
-                        .to_lowercase()
-                        .contains(self.search_query.as_str())
-                    {
-                        music_files.push(path);
-                    }
-                }
-            }
-        }
-        ui.vertical(|ui| {
-            let search_entry = TextEdit::singleline(&mut self.search_query);
-            ui.add_sized([ui.available_width(), 20.0], search_entry);
-
-            ui.separator();
-
-            ui.allocate_ui(scroll_area_size, |ui| {
-                ScrollArea::vertical().id_salt(1).show(ui, |ui| {
-                    for file in music_files.iter() {
-                        let file_name = file.file_name().and_then(|n| n.to_str()).unwrap();
-                        let file_button = Button::new(file_name).frame(false);
-                        let file_button_response = ui.add(file_button);
-                        if file_button_response.clicked() {
-                            self.current_file = file.to_path_buf();
-                            self.play_current_file();
-                        }
-                        ui.separator();
-                    }
-                });
-            });
-        });
-    }
-
-    fn render_mic_selection(&mut self, ui: &mut Ui) {
-        ComboBox::from_label("Choose MIC")
-            .selected_text(format!("{:?}", self.selected_input_device))
-            .show_ui(ui, |ui| {
-                for device in self.available_input_devices.iter() {
-                    ui.selectable_value(
-                        &mut self.selected_input_device,
-                        device.audio_device.name.clone(),
-                        device.audio_device.nick.clone(),
-                    );
-                }
-            });
-    }
-
-    fn play_current_file(&mut self) {
-        if self.current_file.to_str().unwrap().is_empty() {
-            return;
-        }
-
-        if !self.current_file.exists() {
-            return;
-        }
-
-        if !self.selected_input_device.is_empty() {
-            self.link_devices();
-        }
-
-        let file = fs::File::open(self.current_file.display().to_string()).unwrap();
-        let source = Decoder::new(file).unwrap();
-
-        let metadata = MediaFileMetadata::new(&self.current_file.as_path()).unwrap();
-        self.max_player_position = metadata._duration.unwrap() as f32;
-
-        self.audio_sink.as_ref().unwrap().stop();
-        self.audio_sink.as_ref().unwrap().play();
-        self.audio_sink.as_ref().unwrap().append(source);
-    }
-
-    fn link_devices(&self) {
-        let output_devices = pw::get_output_devices().unwrap();
-        let mut pwsp_output: Option<&pw::OutputDevice> = None;
-
-        for device in output_devices.iter() {
-            if device.audio_device.name == "alsa_playback.pwsp" {
-                pwsp_output = Some(device);
-                break;
-            }
-        }
-
-        if pwsp_output.is_none() {
-            return;
-        }
-
-        let input_devices = pw::get_input_devices().unwrap();
-        let mut mic: Option<&pw::InputDevice> = None;
-
-        for device in input_devices.iter() {
-            if device.audio_device.name == self.selected_input_device {
-                mic = Some(device);
-                break;
-            }
-        }
-
-        if mic.is_none() {
-            return;
-        }
-
-        pwsp_output.unwrap().link(mic.unwrap());
-    }
-}
-
-impl eframe::App for App {
-    fn update(&mut self, ctx: &Context, frame: &mut Frame) {
-        CentralPanel::default().show(ctx, |ui| self.upd(ui, ctx, frame));
-    }
-}
-
-fn main() -> Result<(), eframe::Error> {
-    let config_dir_path = dirs::config_dir().unwrap().join("pwsp");
-    fs::create_dir_all(&config_dir_path).ok();
-
-    if !fs::exists(config_dir_path.join("saved_dirs"))
-        .ok()
-        .unwrap_or(false)
-    {
-        fs::File::create(config_dir_path.join("saved_dirs")).ok();
-    }
-    if !fs::exists(config_dir_path.join("saved_mic"))
-        .ok()
-        .unwrap_or(false)
-    {
-        fs::File::create(config_dir_path.join("saved_mic")).ok();
-    }
-
-    let mut options = NativeOptions {
-        ..Default::default()
-    };
-    options.viewport.min_inner_size = Some(Vec2::new(400.0, 400.0));
-    options.vsync = true;
-    options.hardware_acceleration = eframe::HardwareAcceleration::Preferred;
-
-    eframe::run_native(
-        "PipeWire SoundPad",
-        options,
-        Box::new(|cc| {
-            egui_material_icons::initialize(&cc.egui_ctx);
-            Ok(Box::new(App::new(cc)))
-        }),
-    )
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    gui::run().await
 }

src/pw.rs

@@ -1,216 +0,0 @@
-use std::error::Error;
-use std::process::Command;
-use std::collections::HashMap;
-
-
-pub struct AudioDevice {
-    pub nick: String,
-    pub name: String
-}
-
-
-pub struct InputDevice {
-    pub audio_device: AudioDevice,
-    pub input_fl: String,
-    pub input_fr: String
-}
-
-
-pub struct OutputDevice {
-    pub audio_device: AudioDevice,
-    pub output_fl: String,
-    pub output_fr: String
-}
-
-
-impl OutputDevice {
-    pub fn link(&self, input_device: &InputDevice) {
-        let _ = Command::new("pw-link")
-            .arg(&self.output_fl)
-            .arg(&input_device.input_fl)
-            .status();
-
-        let _ = Command::new("pw-link")
-            .arg(&self.output_fr)
-            .arg(&input_device.input_fr)
-            .status();
-    }
-}
-
-
-fn get_pw_entries() -> Result<Vec<HashMap<String, String>>, Box<dyn Error>> {
-    let output = Command::new("pw-cli")
-        .args(&["ls", "Node"])
-        .output()
-        .expect("Failed to execute pw-cli ls Node");
-
-    let output_str = String::from_utf8_lossy(&output.stdout);
-
-    let mut entries = Vec::new();
-    let mut current_entry = HashMap::new();
-
-    for line in output_str.lines() {
-        let line = line.trim();
-
-        if line.is_empty() {
-            continue
-        }
-
-        if line.starts_with("id ") {
-            if !current_entry.is_empty() {
-                entries.push(current_entry);
-                current_entry = HashMap::new();
-            }
-        } else {
-            let mut parts = line.splitn(2, " = ");
-
-            let key = match parts.next() {
-                Some(k) => k.trim().to_string(),
-                None => continue
-            };
-
-            let value = match parts.next() {
-                Some(k) => k.trim().strip_prefix("\"").unwrap().strip_suffix("\"").unwrap().to_string(),
-                None => continue
-            };
-
-            current_entry.insert(key, value);
-        }
-    }
-
-    if !current_entry.is_empty() {
-        entries.push(current_entry);
-    }
-
-    Ok(entries)
-}
-
-pub fn get_input_devices() -> Result<Vec<InputDevice>, Box<dyn Error>> {
-    let entries = get_pw_entries()?;
-
-    let mut input_devices = Vec::new();
-
-    for entry in entries.iter() {
-        let media_class = entry.get("media.class").map(String::as_str).unwrap_or("");
-        let nick = entry.get("node.nick").map(String::as_str)
-            .unwrap_or(entry.get("node.description").map(String::as_str)
-                .unwrap_or(entry.get("node.name").map(String::as_str).unwrap_or("")));
-        let name = entry.get("node.name").map(String::as_str).unwrap_or("");
-
-        if media_class.is_empty() {
-            continue
-        }
-
-        if !media_class.starts_with(&"Audio/Source") {
-            continue
-        }
-
-        if nick.is_empty() || name.is_empty() {
-            continue
-        }
-
-        let audio_device = AudioDevice {
-            nick: nick.to_string(),
-            name: name.to_string(),
-        };
-
-        let device = InputDevice {
-            audio_device,
-            input_fl: String::new(),
-            input_fr: String::new()
-        };
-
-        input_devices.push(device);
-    }
-
-    let output = Command::new("pw-link")
-        .arg("-i")
-        .output()
-        .expect("Failed to execute pw-link -i");
-
-    let output_str = String::from_utf8_lossy(&output.stdout);
-
-    for line in output_str.lines() {
-        let line = line.trim();
-
-        for device in input_devices.iter_mut() {
-            if line.starts_with(device.audio_device.name.as_str()) {
-                if line.ends_with("input_MONO") {
-                    device.input_fl = line.to_string();
-                    device.input_fr = line.to_string();
-                } else if line.ends_with("input_FL") {
-                    device.input_fl = line.to_string();
-                } else if line.ends_with("input_FR") {
-                    device.input_fr = line.to_string();
-                }
-            }
-        }
-    }
-
-    Ok(input_devices)
-}
-
-pub fn get_output_devices() -> Result<Vec<OutputDevice>, Box<dyn Error>> {
-    let entries = get_pw_entries()?;
-
-    let mut output_devices = Vec::new();
-
-    for entry in entries.iter() {
-        let media_class = entry.get("media.class").map(String::as_str).unwrap_or("");
-        let nick = entry.get("node.nick").map(String::as_str)
-            .unwrap_or(entry.get("node.description").map(String::as_str)
-                .unwrap_or(entry.get("node.name").map(String::as_str).unwrap_or("")));
-        let name = entry.get("node.name").map(String::as_str).unwrap_or("");
-
-        if media_class.is_empty() {
-            continue
-        }
-
-        if !media_class.starts_with(&"Stream/Output/Audio") {
-            continue
-        }
-
-        if nick.is_empty() || name.is_empty() {
-            continue
-        }
-
-        let audio_device = AudioDevice {
-            nick: nick.to_string(),
-            name: name.to_string(),
-        };
-
-        let device = OutputDevice {
-            audio_device,
-            output_fl: String::new(),
-            output_fr: String::new()
-        };
-
-        output_devices.push(device);
-    }
-
-    let output = Command::new("pw-link")
-        .arg("-o")
-        .output()
-        .expect("Failed to execute pw-link -o");
-
-    let output_str = String::from_utf8_lossy(&output.stdout);
-
-    for line in output_str.lines() {
-        let line = line.trim();
-
-        for device in output_devices.iter_mut() {
-            if line.starts_with(device.audio_device.name.as_str()) {
-                if line.ends_with("capture_MONO") {
-                    device.output_fl = line.to_string();
-                    device.output_fr = line.to_string();
-                } else if line.ends_with("output_FL") {
-                    device.output_fl = line.to_string();
-                } else if line.ends_with("output_FR") {
-                    device.output_fr = line.to_string();
-                }
-            }
-        }
-    }
-
-    Ok(output_devices)
-}

src/types/audio_player.rs

@@ -0,0 +1,489 @@
+use crate::{
+    types::pipewire::{DeviceType, Terminate},
+    utils::{
+        daemon::get_daemon_config,
+        pipewire::{create_link, get_device, link_player_to_virtual_mic},
+    },
+};
+use rodio::{Decoder, DeviceSinkBuilder, MixerDeviceSink, Player, Source};
+use serde::{Deserialize, Serialize};
+use std::{
+    collections::HashMap,
+    error::Error,
+    fs,
+    path::{Path, PathBuf},
+    time::Duration,
+};
+
+#[derive(Debug, Eq, PartialEq, Default, Clone, Serialize, Deserialize)]
+pub enum PlayerState {
+    #[default]
+    Stopped,
+    Paused,
+    Playing,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TrackInfo {
+    pub id: u32,
+    pub path: PathBuf,
+    pub duration: Option<f32>,
+    pub position: f32,
+    pub volume: f32,
+    pub looped: bool,
+    pub paused: bool,
+}
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct FullState {
+    pub state: PlayerState,
+    pub tracks: Vec<TrackInfo>,
+    pub volume: f32,
+    pub current_input: String,
+    pub all_inputs: HashMap<String, String>,
+}
+
+pub struct PlayingSound {
+    pub id: u32,
+    pub sink: Player,
+    pub path: PathBuf,
+    pub duration: Option<f32>,
+    pub looped: bool,
+    pub volume: f32,
+}
+
+pub struct AudioPlayer {
+    stream_handle: Option<MixerDeviceSink>,
+    pub tracks: HashMap<u32, PlayingSound>,
+    pub next_id: u32,
+
+    input_link_sender: Option<pipewire::channel::Sender<Terminate>>,
+    player_link_sender: Option<pipewire::channel::Sender<Terminate>>,
+    pub input_device_name: Option<String>,
+
+    pub volume: f32, // Master volume
+}
+
+impl AudioPlayer {
+    pub async fn new() -> Result<Self, Box<dyn Error>> {
+        let daemon_config = get_daemon_config();
+        let default_volume = daemon_config.default_volume.unwrap_or(1.0);
+
+        let mut audio_player = AudioPlayer {
+            stream_handle: None,
+            tracks: HashMap::new(),
+            next_id: 1,
+
+            input_link_sender: None,
+            player_link_sender: None,
+            input_device_name: daemon_config.default_input_name.clone(),
+
+            volume: default_volume,
+        };
+
+        if audio_player.input_device_name.is_some() {
+            audio_player.link_devices().await?;
+        }
+
+        Ok(audio_player)
+    }
+
+    fn ensure_stream(&mut self) -> Result<&MixerDeviceSink, Box<dyn Error>> {
+        if self.stream_handle.is_none() {
+            let mut sink = DeviceSinkBuilder::open_default_sink()?;
+            sink.log_on_drop(false);
+            self.stream_handle = Some(sink);
+        }
+        Ok(self.stream_handle.as_ref().unwrap())
+    }
+
+    fn drop_stream(&mut self) {
+        if self.stream_handle.is_some() {
+            self.stream_handle = None;
+            self.abort_player_link_thread();
+        }
+    }
+
+    fn abort_link_thread(&mut self) {
+        if let Some(sender) = &self.input_link_sender {
+            if let Ok(_) = sender.send(Terminate {}) {
+                println!("Sent terminate signal to input link thread");
+                self.input_link_sender = None;
+            } else {
+                eprintln!("Failed to send terminate signal to input link thread");
+            }
+        }
+    }
+
+    fn abort_player_link_thread(&mut self) {
+        if let Some(sender) = &self.player_link_sender {
+            if let Ok(_) = sender.send(Terminate {}) {
+                println!("Sent terminate signal to player link thread");
+                self.player_link_sender = None;
+            } else {
+                eprintln!("Failed to send terminate signal to player link thread");
+            }
+        }
+    }
+
+    async fn link_player(&mut self) -> Result<(), Box<dyn Error>> {
+        if self.player_link_sender.is_some() {
+            return Ok(());
+        }
+
+        match link_player_to_virtual_mic().await {
+            Ok(sender) => {
+                self.player_link_sender = Some(sender);
+                Ok(())
+            }
+            Err(_) => Ok(()),
+        }
+    }
+
+    async fn link_devices(&mut self) -> Result<(), Box<dyn Error>> {
+        self.abort_link_thread();
+
+        let input_device;
+        if let Some(input_device_name) = &self.input_device_name {
+            if let Ok(device) = get_device(input_device_name).await {
+                input_device = device;
+            } else {
+                eprintln!(
+                    "Could not find selected input device {}, skipping device linking",
+                    input_device_name
+                );
+                return Ok(());
+            }
+        } else {
+            eprintln!("No input device selected, skipping device linking");
+            return Ok(());
+        }
+
+        let daemon_input;
+        if let Ok(device) = get_device("pwsp-virtual-mic").await {
+            daemon_input = device;
+        } else {
+            eprintln!("Could not find pwsp-virtual-mic device, skipping device linking");
+            return Ok(());
+        }
+
+        let Some(output_fl) = input_device.output_fl.clone() else {
+            eprintln!("Failed to get pwsp-daemon output_fl");
+            return Ok(());
+        };
+        let Some(output_fr) = input_device.output_fr.clone() else {
+            eprintln!("Failed to get pwsp-daemon output_fr");
+            return Ok(());
+        };
+        let Some(input_fl) = daemon_input.input_fl.clone() else {
+            eprintln!("Failed to get pwsp-daemon input_fl");
+            return Ok(());
+        };
+        let Some(input_fr) = daemon_input.input_fr.clone() else {
+            eprintln!("Failed to get pwsp-daemon input_fr");
+            return Ok(());
+        };
+
+        self.input_link_sender = Some(create_link(output_fl, output_fr, input_fl, input_fr)?);
+
+        Ok(())
+    }
+
+    pub fn pause(&mut self, id: Option<u32>) {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get_mut(&id) {
+                sound.sink.pause();
+            }
+        } else {
+            for sound in self.tracks.values_mut() {
+                sound.sink.pause();
+            }
+        }
+    }
+
+    pub fn resume(&mut self, id: Option<u32>) {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get_mut(&id) {
+                sound.sink.play();
+            }
+        } else {
+            for sound in self.tracks.values_mut() {
+                sound.sink.play();
+            }
+        }
+    }
+
+    pub fn stop(&mut self, id: Option<u32>) {
+        if let Some(id) = id {
+            self.tracks.remove(&id);
+        } else {
+            self.tracks.clear();
+        }
+        if self.tracks.is_empty() {
+            self.drop_stream();
+        }
+    }
+
+    pub fn is_paused(&self) -> bool {
+        if self.tracks.is_empty() {
+            return false;
+        }
+        self.tracks.values().all(|s| s.sink.is_paused())
+    }
+
+    pub fn get_state(&self) -> PlayerState {
+        if self.tracks.is_empty() {
+            return PlayerState::Stopped;
+        }
+
+        if self
+            .tracks
+            .values()
+            .any(|s| !s.sink.is_paused() && !s.sink.empty())
+        {
+            return PlayerState::Playing;
+        }
+
+        if self.is_paused() {
+            return PlayerState::Paused;
+        }
+
+        PlayerState::Stopped
+    }
+
+    pub fn get_volume(&mut self, id: Option<u32>) -> Option<f32> {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get_mut(&id) {
+                return Some(sound.sink.volume());
+            } else {
+                return None;
+            }
+        } else {
+            return Some(self.volume);
+        }
+    }
+
+    pub fn set_volume(&mut self, volume: f32, id: Option<u32>) {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get_mut(&id) {
+                sound.volume = volume;
+                sound.sink.set_volume(self.volume * volume);
+            }
+        } else {
+            self.volume = volume;
+            for sound in self.tracks.values_mut() {
+                sound.sink.set_volume(self.volume * sound.volume);
+            }
+        }
+    }
+
+    pub fn get_position(&self, id: Option<u32>) -> f32 {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get(&id) {
+                return sound.sink.get_pos().as_secs_f32();
+            }
+        } else if let Some(sound) = self.tracks.values().last() {
+            // Fallback to last added track if no ID
+            return sound.sink.get_pos().as_secs_f32();
+        }
+        0.0
+    }
+
+    pub fn seek(&mut self, position: f32, id: Option<u32>) -> Result<(), Box<dyn Error>> {
+        let position = if position < 0.0 { 0.0 } else { position };
+
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get_mut(&id) {
+                sound.sink.try_seek(Duration::from_secs_f32(position))?;
+            }
+        } else {
+            // Seek all? Or last? Let's seek all for now if no ID provided
+            for sound in self.tracks.values_mut() {
+                sound.sink.try_seek(Duration::from_secs_f32(position)).ok();
+            }
+        }
+        Ok(())
+    }
+
+    pub fn get_duration(&mut self, id: Option<u32>) -> Result<f32, Box<dyn Error>> {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get(&id) {
+                return sound.duration.ok_or("Unknown duration".into());
+            }
+        } else if let Some(sound) = self.tracks.values().last() {
+            return sound.duration.ok_or("Unknown duration".into());
+        }
+        Err("No track playing".into())
+    }
+
+    pub async fn play(
+        &mut self,
+        file_path: &Path,
+        concurrent: bool,
+    ) -> Result<u32, Box<dyn Error>> {
+        let path_buf = file_path.to_path_buf();
+
+        let decoder_result =
+            tokio::task::spawn_blocking(move || -> Result<_, Box<dyn Error + Send + Sync>> {
+                if !path_buf.exists() {
+                    return Err(format!("File does not exist: {}", path_buf.display()).into());
+                }
+
+                let file = fs::File::open(&path_buf)?;
+                let decoder = Decoder::try_from(file)
+                    .map_err(|e| Box::new(e) as Box<dyn Error + Send + Sync>)?;
+                Ok(decoder)
+            })
+            .await?;
+
+        match decoder_result {
+            Ok(source) => {
+                if !concurrent {
+                    self.tracks.clear();
+                }
+
+                self.ensure_stream()?;
+                self.link_player().await.ok();
+
+                let id = self.next_id;
+                self.next_id += 1;
+
+                let duration = source.total_duration().map(|d| d.as_secs_f32());
+
+                let mixer = self.stream_handle.as_ref().unwrap().mixer();
+                let sink = Player::connect_new(mixer);
+                sink.set_volume(self.volume); // Default volume is 1.0 * master
+                sink.append(source);
+                sink.play();
+
+                let sound = PlayingSound {
+                    id,
+                    sink,
+                    path: file_path.to_path_buf(),
+                    duration,
+                    looped: false,
+                    volume: 1.0,
+                };
+
+                self.tracks.insert(id, sound);
+
+                Ok(id)
+            }
+            Err(err) => Err(err as Box<dyn Error>),
+        }
+    }
+
+    pub fn set_loop(&mut self, enabled: bool, id: Option<u32>) {
+        if let Some(id) = id {
+            if let Some(sound) = self.tracks.get_mut(&id) {
+                sound.looped = enabled;
+            }
+        } else {
+            // Set loop for all? Or just last?
+            // Let's set for all.
+            for sound in self.tracks.values_mut() {
+                sound.looped = enabled;
+            }
+        }
+    }
+
+    pub fn get_tracks(&self) -> Vec<TrackInfo> {
+        let mut tracks: Vec<_> = self
+            .tracks
+            .values()
+            .map(|sound| TrackInfo {
+                id: sound.id,
+                path: sound.path.clone(),
+                duration: sound.duration,
+                position: sound.sink.get_pos().as_secs_f32(),
+                volume: sound.volume,
+                looped: sound.looped,
+                paused: sound.sink.is_paused(),
+            })
+            .collect();
+        tracks.sort_by_key(|t| t.id);
+        tracks
+    }
+
+    pub async fn update(&mut self, check_devices: bool) {
+        if check_devices {
+            if let Some(input_device_name) = &self.input_device_name {
+                // Unlink devices if selected input device was removed
+                if self.input_link_sender.is_some() && get_device(input_device_name).await.is_err()
+                {
+                    eprintln!(
+                        "Selected input device {} was removed, unlinking devices",
+                        input_device_name
+                    );
+                    self.abort_link_thread();
+                }
+                // Link devices if not linked
+                else if self.input_link_sender.is_none() {
+                    self.link_devices().await.ok();
+                }
+            }
+
+            if self.stream_handle.is_some() && self.player_link_sender.is_none() {
+                self.link_player().await.ok();
+            }
+        }
+
+        // Handle looped sounds
+        let mut restarts = vec![];
+
+        for (id, sound) in &self.tracks {
+            if sound.sink.empty() && sound.looped {
+                restarts.push(*id);
+            }
+        }
+
+        let mut restart_futures = vec![];
+
+        for id in restarts {
+            if let Some(sound) = self.tracks.get(&id) {
+                let path = sound.path.clone();
+                let handle = tokio::task::spawn_blocking(move || {
+                    if let Ok(file) = fs::File::open(&path) {
+                        if let Ok(source) = Decoder::try_from(file) {
+                            return Some((id, source));
+                        }
+                    }
+                    None
+                });
+                restart_futures.push(handle);
+            }
+        }
+
+        for handle in restart_futures {
+            if let Ok(res) = handle.await {
+                if let Some((id, source)) = res {
+                    if let Some(sound) = self.tracks.get_mut(&id) {
+                        sound.sink.append(source);
+                        sound.sink.play();
+                    }
+                }
+            }
+        }
+
+        self.tracks
+            .retain(|_, sound| !sound.sink.empty() || sound.looped);
+
+        if self.tracks.is_empty() {
+            self.drop_stream();
+        }
+    }
+
+    pub async fn set_current_input_device(&mut self, name: &str) -> Result<(), Box<dyn Error>> {
+        let input_device = get_device(name).await?;
+
+        if input_device.device_type != DeviceType::Input {
+            return Err("Selected device is not an input device".into());
+        }
+
+        self.input_device_name = Some(name.to_string());
+
+        self.link_devices().await?;
+
+        Ok(())
+    }
+}

src/types/commands.rs

@@ -0,0 +1,725 @@
+use crate::{
+    types::{
+        audio_player::{FullState, PlayerState},
+        config::HotkeyConfig,
+        socket::{Request, Response},
+    },
+    utils::{
+        commands::parse_command,
+        daemon::get_audio_player,
+        pipewire::{get_all_devices, get_device},
+    },
+};
+use async_trait::async_trait;
+use std::{collections::HashMap, path::PathBuf};
+
+#[async_trait]
+pub trait Executable {
+    async fn execute(&self) -> Response;
+}
+
+pub struct PingCommand {}
+
+pub struct KillCommand {}
+
+pub struct PauseCommand {
+    pub id: Option<u32>,
+}
+
+pub struct ResumeCommand {
+    pub id: Option<u32>,
+}
+
+pub struct TogglePauseCommand {
+    pub id: Option<u32>,
+}
+
+pub struct StopCommand {
+    pub id: Option<u32>,
+}
+
+pub struct IsPausedCommand {}
+
+pub struct GetStateCommand {}
+
+pub struct GetVolumeCommand {
+    pub id: Option<u32>,
+}
+
+pub struct SetVolumeCommand {
+    pub volume: Option<f32>,
+    pub id: Option<u32>,
+}
+
+pub struct GetPositionCommand {
+    pub id: Option<u32>,
+}
+
+pub struct SeekCommand {
+    pub position: Option<f32>,
+    pub id: Option<u32>,
+}
+
+pub struct GetDurationCommand {
+    pub id: Option<u32>,
+}
+
+pub struct PlayCommand {
+    pub file_path: Option<PathBuf>,
+    pub concurrent: Option<bool>,
+}
+
+pub struct GetTracksCommand {}
+
+pub struct GetCurrentInputCommand {}
+
+pub struct GetAllInputsCommand {}
+
+pub struct SetCurrentInputCommand {
+    pub name: Option<String>,
+}
+
+pub struct SetLoopCommand {
+    pub enabled: Option<bool>,
+    pub id: Option<u32>,
+}
+
+pub struct ToggleLoopCommand {
+    pub id: Option<u32>,
+}
+
+pub struct GetDaemonVersionCommand {}
+
+pub struct GetFullStateCommand {}
+
+pub struct GetHotkeysCommand {}
+
+pub struct SetHotkeyCommand {
+    pub slot: Option<String>,
+    pub file_path: Option<PathBuf>,
+}
+
+pub struct SetHotkeyActionCommand {
+    pub slot: Option<String>,
+    pub action: Option<Request>,
+}
+
+pub struct SetHotkeyKeyCommand {
+    pub slot: Option<String>,
+    pub key_chord: Option<String>,
+}
+
+pub struct SetHotkeyActionAndKeyCommand {
+    pub slot: Option<String>,
+    pub action: Option<Request>,
+    pub key_chord: Option<String>,
+}
+
+pub struct PlayHotkeyCommand {
+    pub slot: Option<String>,
+}
+
+pub struct ClearHotkeyCommand {
+    pub slot: Option<String>,
+}
+
+pub struct ClearHotkeyKeyCommand {
+    pub slot: Option<String>,
+}
+
+#[async_trait]
+impl Executable for PingCommand {
+    async fn execute(&self) -> Response {
+        Response::new(true, "pong")
+    }
+}
+
+#[async_trait]
+impl Executable for KillCommand {
+    async fn execute(&self) -> Response {
+        Response::new(true, "killed")
+    }
+}
+
+#[async_trait]
+impl Executable for PauseCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        audio_player.pause(self.id);
+        Response::new(true, "Audio was paused")
+    }
+}
+
+#[async_trait]
+impl Executable for ResumeCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        audio_player.resume(self.id);
+        Response::new(true, "Audio was resumed")
+    }
+}
+
+#[async_trait]
+impl Executable for TogglePauseCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+
+        if audio_player.get_state() == PlayerState::Stopped {
+            return Response::new(false, "Audio is not playing");
+        }
+
+        // This logic is a bit tricky with multiple tracks.
+        // If ID is provided, toggle that track.
+        // If not, toggle global pause state?
+        // For now, let's just use pause/resume based on global state if no ID.
+
+        if let Some(id) = self.id {
+            if let Some(track) = audio_player.tracks.get(&id) {
+                if track.sink.is_paused() {
+                    audio_player.resume(Some(id));
+                    Response::new(true, "Audio was resumed")
+                } else {
+                    audio_player.pause(Some(id));
+                    Response::new(true, "Audio was paused")
+                }
+            } else {
+                Response::new(false, "Track not found")
+            }
+        } else {
+            if audio_player.is_paused() {
+                audio_player.resume(None);
+                Response::new(true, "Audio was resumed")
+            } else {
+                audio_player.pause(None);
+                Response::new(true, "Audio was paused")
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for StopCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        audio_player.stop(self.id);
+        Response::new(true, "Audio was stopped")
+    }
+}
+
+#[async_trait]
+impl Executable for IsPausedCommand {
+    async fn execute(&self) -> Response {
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        let is_paused = audio_player.is_paused().to_string();
+        Response::new(true, is_paused)
+    }
+}
+
+#[async_trait]
+impl Executable for GetStateCommand {
+    async fn execute(&self) -> Response {
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        let state = audio_player.get_state();
+        match serde_json::to_string(&state) {
+            Ok(json) => Response::new(true, json),
+            Err(err) => Response::new(false, format!("Failed to serialize state: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetVolumeCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        let volume = audio_player.get_volume(self.id);
+
+        if let Some(volume) = volume {
+            Response::new(true, volume.to_string())
+        } else {
+            Response::new(false, "Failed to get volume")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetVolumeCommand {
+    async fn execute(&self) -> Response {
+        if let Some(volume) = self.volume {
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
+            audio_player.set_volume(volume, self.id);
+            Response::new(true, format!("Audio volume was set to {}", volume))
+        } else {
+            Response::new(false, "Invalid volume value")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetPositionCommand {
+    async fn execute(&self) -> Response {
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        let position = audio_player.get_position(self.id);
+        Response::new(true, position.to_string())
+    }
+}
+
+#[async_trait]
+impl Executable for SeekCommand {
+    async fn execute(&self) -> Response {
+        if let Some(position) = self.position {
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
+            match audio_player.seek(position, self.id) {
+                Ok(_) => Response::new(true, format!("Audio position was set to {}", position)),
+                Err(err) => Response::new(false, err.to_string()),
+            }
+        } else {
+            Response::new(false, "Invalid position value")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetDurationCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        match audio_player.get_duration(self.id) {
+            Ok(duration) => Response::new(true, duration.to_string()),
+            Err(err) => Response::new(false, err.to_string()),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for PlayCommand {
+    async fn execute(&self) -> Response {
+        if let Some(file_path) = &self.file_path {
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
+            match audio_player
+                .play(file_path, self.concurrent.unwrap_or(false))
+                .await
+            {
+                Ok(id) => Response::new(true, id.to_string()),
+                Err(err) => Response::new(false, err.to_string()),
+            }
+        } else {
+            Response::new(false, "Invalid file path")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetTracksCommand {
+    async fn execute(&self) -> Response {
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        let tracks = audio_player.get_tracks();
+        match serde_json::to_string(&tracks) {
+            Ok(json) => Response::new(true, json),
+            Err(err) => Response::new(false, format!("Failed to serialize tracks: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetCurrentInputCommand {
+    async fn execute(&self) -> Response {
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        if let Some(input_device_name) = &audio_player.input_device_name {
+            if let Ok(input_device) = get_device(input_device_name).await {
+                Response::new(
+                    true,
+                    format!("{} - {}", input_device.name, input_device.nick),
+                )
+            } else {
+                Response::new(false, "Failed to get current input device")
+            }
+        } else {
+            Response::new(false, "No input device selected")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetAllInputsCommand {
+    async fn execute(&self) -> Response {
+        let (input_devices, _output_devices) = match get_all_devices().await {
+            Ok(devices) => devices,
+            Err(err) => return Response::new(false, format!("Failed to get devices: {}", err)),
+        };
+        let mut input_devices_strings = vec![];
+        for device in input_devices {
+            if device.name == "pwsp-virtual-mic" {
+                continue;
+            }
+
+            let string = format!("{} - {}", device.name, device.nick);
+            input_devices_strings.push(string);
+        }
+        let response_message = input_devices_strings.join("; ");
+
+        Response::new(true, response_message)
+    }
+}
+
+#[async_trait]
+impl Executable for SetCurrentInputCommand {
+    async fn execute(&self) -> Response {
+        if let Some(name) = &self.name {
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
+            match audio_player.set_current_input_device(name).await {
+                Ok(_) => Response::new(true, "Input device was set"),
+                Err(err) => Response::new(false, err.to_string()),
+            }
+        } else {
+            Response::new(false, "Invalid index value")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetLoopCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+
+        match self.enabled {
+            Some(enabled) => {
+                audio_player.set_loop(enabled, self.id);
+                Response::new(true, format!("Loop was set to {}", enabled))
+            }
+            None => Response::new(false, "Invalid enabled value"),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for ToggleLoopCommand {
+    async fn execute(&self) -> Response {
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        if let Some(id) = self.id {
+            if let Some(track) = audio_player.tracks.get_mut(&id) {
+                track.looped = !track.looped;
+                Response::new(true, format!("Loop was set to {}", track.looped))
+            } else {
+                Response::new(false, "Track not found")
+            }
+        } else {
+            // Toggle all?
+            for track in audio_player.tracks.values_mut() {
+                track.looped = !track.looped;
+            }
+            Response::new(true, "Loop toggled for all tracks")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetDaemonVersionCommand {
+    async fn execute(&self) -> Response {
+        Response::new(true, env!("CARGO_PKG_VERSION"))
+    }
+}
+
+#[async_trait]
+impl Executable for GetFullStateCommand {
+    async fn execute(&self) -> Response {
+        let (input_devices, _output_devices) = match get_all_devices().await {
+            Ok(devices) => devices,
+            Err(err) => return Response::new(false, format!("Failed to get devices: {}", err)),
+        };
+        let mut all_inputs = HashMap::new();
+        let mut current_input_nick = String::new();
+
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
+        if let Some(current_input_name) = &audio_player.input_device_name {
+            for device in input_devices {
+                if device.name == "pwsp-virtual-mic" {
+                    continue;
+                }
+                if device.name == *current_input_name {
+                    current_input_nick = format!("{} - {}", device.name, device.nick);
+                }
+
+                all_inputs.insert(device.name, device.nick);
+            }
+        } else {
+            for device in input_devices {
+                if device.name == "pwsp-virtual-mic" {
+                    continue;
+                }
+
+                all_inputs.insert(device.name, device.nick);
+            }
+        }
+
+        let full_state = FullState {
+            state: audio_player.get_state(),
+            tracks: audio_player.get_tracks(),
+            volume: audio_player.volume,
+            current_input: current_input_nick,
+            all_inputs,
+        };
+
+        match serde_json::to_string(&full_state) {
+            Ok(json) => Response::new(true, json),
+            Err(err) => Response::new(false, format!("Failed to serialize full state: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for GetHotkeysCommand {
+    async fn execute(&self) -> Response {
+        match HotkeyConfig::load() {
+            Ok(config) => match serde_json::to_string(&config) {
+                Ok(json) => Response::new(true, json),
+                Err(err) => Response::new(false, format!("Failed to serialize hotkeys: {}", err)),
+            },
+            Err(err) => Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(file_path) = &self.file_path else {
+            return Response::new(false, "Missing file path");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        config.set_slot(
+            slot.clone(),
+            Request::play(&file_path.to_string_lossy(), false),
+        );
+
+        match config.save() {
+            Ok(_) => Response::new(true, format!("Hotkey slot '{}' set", slot)),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyActionCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(action) = &self.action else {
+            return Response::new(false, "Missing or invalid action");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        config.set_slot(slot.clone(), action.clone());
+
+        match config.save() {
+            Ok(_) => Response::new(true, format!("Hotkey slot '{}' set", slot)),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyKeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(key_chord) = &self.key_chord else {
+            return Response::new(false, "Missing key chord");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        if !config.set_key_chord(slot, Some(key_chord.clone())) {
+            return Response::new(false, format!("Slot '{}' not found", slot));
+        }
+
+        match config.save() {
+            Ok(_) => Response::new(
+                true,
+                format!("Key chord for slot '{}' set to '{}'", slot, key_chord),
+            ),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyActionAndKeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(action) = &self.action else {
+            return Response::new(false, "Missing or invalid action");
+        };
+        let Some(key_chord) = &self.key_chord else {
+            return Response::new(false, "Missing key chord");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        // Set the action and then the key chord
+        config.set_slot(slot.clone(), action.clone());
+        if !config.set_key_chord(slot, Some(key_chord.clone())) {
+            return Response::new(
+                false,
+                format!("Slot '{}' not found after setting action", slot),
+            );
+        }
+
+        match config.save() {
+            Ok(_) => Response::new(
+                true,
+                format!(
+                    "Hotkey slot '{}' set with action and key chord '{}'",
+                    slot, key_chord
+                ),
+            ),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for PlayHotkeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+
+        let config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        let Some(hotkey_slot) = config.find_slot(slot) else {
+            return Response::new(false, format!("Slot '{}' not found", slot));
+        };
+
+        let action = hotkey_slot.action.clone();
+
+        if let Some(cmd) = parse_command(&action) {
+            cmd.execute().await
+        } else {
+            Response::new(false, "Unknown command in hotkey slot".to_string())
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for ClearHotkeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        if config.remove_slot(slot) {
+            match config.save() {
+                Ok(_) => Response::new(true, format!("Hotkey slot '{}' cleared", slot)),
+                Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+            }
+        } else {
+            Response::new(false, format!("Slot '{}' not found", slot))
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for ClearHotkeyKeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        if !config.set_key_chord(slot, None) {
+            return Response::new(false, format!("Slot '{}' not found", slot));
+        }
+
+        match config.save() {
+            Ok(_) => Response::new(true, format!("Key chord for slot '{}' cleared", slot)),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}

src/types/config.rs

@@ -0,0 +1,205 @@
+use crate::{types::socket::Request, utils::config::get_config_path};
+use serde::{Deserialize, Serialize};
+use std::{collections::HashMap, error::Error, fs, path::PathBuf};
+
+#[derive(Default, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct DaemonConfig {
+    pub default_input_name: Option<String>,
+    pub default_volume: Option<f32>,
+}
+
+impl DaemonConfig {
+    pub fn save_to_file(&self) -> Result<(), Box<dyn Error>> {
+        let config_path = get_config_path()?.join("daemon.json");
+
+        if let Some(config_dir) = config_path.parent() {
+            if !config_path.exists() {
+                fs::create_dir_all(config_dir)?;
+            }
+        }
+
+        let config_json = serde_json::to_string_pretty(self)?;
+        fs::write(config_path, config_json.as_bytes())?;
+        Ok(())
+    }
+
+    pub fn load_from_file() -> Result<DaemonConfig, Box<dyn Error>> {
+        let config_path = get_config_path()?.join("daemon.json");
+        let bytes = fs::read(config_path)?;
+        match serde_json::from_slice::<DaemonConfig>(&bytes) {
+            Ok(config) => Ok(config),
+            Err(_) => Ok(DaemonConfig::default()),
+        }
+    }
+}
+
+#[derive(Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct GuiConfig {
+    pub scale_factor: f32,
+    pub left_panel_width: f32,
+
+    pub save_volume: bool,
+    pub save_input: bool,
+    pub save_scale_factor: bool,
+    pub pause_on_exit: bool,
+
+    pub dirs: Vec<PathBuf>,
+}
+
+impl Default for GuiConfig {
+    fn default() -> Self {
+        GuiConfig {
+            scale_factor: 1.0,
+            left_panel_width: 280.0,
+
+            save_volume: false,
+            save_input: false,
+            save_scale_factor: false,
+            pause_on_exit: false,
+
+            dirs: vec![],
+        }
+    }
+}
+
+impl GuiConfig {
+    pub fn save_to_file(&mut self) -> Result<(), Box<dyn Error>> {
+        let config_path = get_config_path()?.join("gui.json");
+
+        if let Some(config_dir) = config_path.parent() {
+            if !config_path.exists() {
+                fs::create_dir_all(config_dir)?;
+            }
+        }
+
+        // Do not save scale factor if user does not want to
+        if !self.save_scale_factor {
+            self.scale_factor = 1.0;
+        }
+
+        let config_json = serde_json::to_string_pretty(self)?;
+        fs::write(config_path, config_json.as_bytes())?;
+        Ok(())
+    }
+
+    pub fn load_from_file() -> Result<GuiConfig, Box<dyn Error>> {
+        let config_path = get_config_path()?.join("gui.json");
+        let bytes = fs::read(config_path)?;
+        match serde_json::from_slice::<GuiConfig>(&bytes) {
+            Ok(config) => Ok(config),
+            Err(_) => Ok(GuiConfig::default()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct HotkeySlot {
+    pub slot: String,
+    pub action: Request,
+    pub key_chord: Option<String>,
+}
+
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct HotkeyConfig {
+    #[serde(default)]
+    pub slots: Vec<HotkeySlot>,
+}
+
+impl HotkeyConfig {
+    pub fn config_path() -> Result<PathBuf, Box<dyn Error>> {
+        Ok(get_config_path()?.join("hotkeys.json"))
+    }
+
+    pub fn load() -> Result<HotkeyConfig, Box<dyn Error>> {
+        let path = Self::config_path()?;
+        if !path.exists() {
+            return Ok(HotkeyConfig::default());
+        }
+        let bytes = fs::read(&path)?;
+        match serde_json::from_slice::<HotkeyConfig>(&bytes) {
+            Ok(config) => Ok(config),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    pub fn save(&self) -> Result<(), Box<dyn Error>> {
+        let path = Self::config_path()?;
+        if let Some(dir) = path.parent()
+            && !dir.exists()
+        {
+            fs::create_dir_all(dir)?;
+        }
+        let json = serde_json::to_string_pretty(self)?;
+        fs::write(path, json.as_bytes())?;
+        Ok(())
+    }
+
+    pub fn find_slot(&self, slot: &str) -> Option<&HotkeySlot> {
+        self.slots.iter().find(|s| s.slot == slot)
+    }
+
+    pub fn find_slot_mut(&mut self, slot: &str) -> Option<&mut HotkeySlot> {
+        self.slots.iter_mut().find(|s| s.slot == slot)
+    }
+
+    pub fn set_slot(&mut self, slot: String, action: Request) {
+        if let Some(existing) = self.find_slot_mut(&slot) {
+            existing.action = action;
+        } else {
+            self.slots.push(HotkeySlot {
+                slot,
+                action,
+                key_chord: None,
+            });
+        }
+    }
+
+    pub fn set_key_chord(&mut self, slot: &str, key_chord: Option<String>) -> bool {
+        if let Some(existing) = self.find_slot_mut(slot) {
+            existing.key_chord = key_chord;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn remove_slot(&mut self, slot: &str) -> bool {
+        let len = self.slots.len();
+        self.slots.retain(|s| s.slot != slot);
+        self.slots.len() != len
+    }
+
+    /// Returns pairs of slot names that share the same key chord.
+    pub fn find_conflicts(&self) -> Vec<(String, String)> {
+        let mut conflicts = vec![];
+        let mut chord_map: HashMap<&str, Vec<&str>> = HashMap::new();
+
+        for s in &self.slots {
+            if let Some(chord) = &s.key_chord {
+                chord_map.entry(chord.as_str()).or_default().push(&s.slot);
+            }
+        }
+
+        for slots in chord_map.values() {
+            if slots.len() > 1 {
+                for i in 0..slots.len() {
+                    for j in (i + 1)..slots.len() {
+                        conflicts.push((slots[i].to_string(), slots[j].to_string()));
+                    }
+                }
+            }
+        }
+
+        conflicts
+    }
+
+    /// Find which slot(s) have the given key chord.
+    pub fn slots_for_chord(&self, chord: &str) -> Vec<&HotkeySlot> {
+        self.slots
+            .iter()
+            .filter(|s| s.key_chord.as_deref() == Some(chord))
+            .collect()
+    }
+}

src/types/gui.rs

@@ -0,0 +1,73 @@
+use crate::types::{
+    audio_player::{PlayerState, TrackInfo},
+    config::HotkeyConfig,
+};
+
+use egui::Id;
+
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    time::Instant,
+};
+
+#[derive(Default, Debug)]
+pub struct TrackUiState {
+    pub position_slider_value: f32,
+    pub volume_slider_value: f32,
+
+    pub position_dragged: bool,
+    pub volume_dragged: bool,
+
+    pub ignore_position_update_until: Option<Instant>,
+    pub ignore_volume_update_until: Option<Instant>,
+}
+
+#[derive(Default, Debug)]
+pub struct AppState {
+    pub search_query: String,
+
+    pub track_ui_states: HashMap<u32, TrackUiState>,
+
+    pub show_settings: bool,
+    pub volume_dragged: bool,
+    pub force_focus_search: bool,
+
+    pub volume_slider_value: f32,
+
+    pub search_field_id: Option<Id>,
+
+    pub ignore_volume_update_until: Option<Instant>,
+
+    pub current_dir: Option<PathBuf>,
+    pub dirs: Vec<PathBuf>,
+    pub dirs_to_remove: HashSet<PathBuf>,
+
+    pub selected_file: Option<PathBuf>,
+    pub files: HashSet<PathBuf>,
+
+    pub show_hotkeys: bool,
+    pub hotkey_config: HotkeyConfig,
+    pub hotkey_search_query: String,
+    pub assigning_hotkey_slot: Option<String>,
+    pub assigning_hotkey_for_file: Option<PathBuf>,
+    pub hotkey_capture_active: bool,
+}
+
+#[derive(Default, Debug, Clone)]
+pub struct AudioPlayerState {
+    pub state: PlayerState,
+    pub new_state: Option<PlayerState>,
+
+    pub tracks: Vec<TrackInfo>,
+
+    pub volume: f32, // Master volume
+
+    pub current_input: String,
+    pub all_inputs: HashMap<String, String>,
+    pub all_inputs_sorted: Vec<(String, String)>,
+
+    pub is_daemon_running: bool,
+
+    pub hotkey_config: Option<HotkeyConfig>,
+}

src/types/mod.rs

@@ -0,0 +1,6 @@
+pub mod audio_player;
+pub mod commands;
+pub mod config;
+pub mod gui;
+pub mod pipewire;
+pub mod socket;

src/types/pipewire.rs

@@ -0,0 +1,31 @@
+#[derive(Debug)]
+pub struct Terminate {}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct Port {
+    pub node_id: u32,
+    pub port_id: u32,
+
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub enum DeviceType {
+    Input,
+    Output,
+}
+
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct AudioDevice {
+    pub id: u32,
+
+    pub nick: String,
+    pub name: String,
+
+    pub device_type: DeviceType,
+
+    pub input_fl: Option<Port>,
+    pub input_fr: Option<Port>,
+    pub output_fl: Option<Port>,
+    pub output_fr: Option<Port>,
+}

src/types/socket.rs

@@ -0,0 +1,240 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+pub const MAX_MESSAGE_SIZE: usize = 128 * 1024;
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Request {
+    pub name: String,
+    pub args: HashMap<String, String>,
+}
+
+impl Request {
+    pub fn new<T: AsRef<str>>(function_name: T, data: Vec<(T, T)>) -> Self {
+        let hashmap_data: HashMap<String, String> = data
+            .into_iter()
+            .map(|(key, value)| (key.as_ref().to_string(), value.as_ref().to_string()))
+            .collect();
+
+        Request {
+            name: function_name.as_ref().to_string(),
+            args: hashmap_data,
+        }
+    }
+
+    pub fn ping() -> Self {
+        Request::new("ping", vec![])
+    }
+
+    pub fn kill() -> Self {
+        Request::new("kill", vec![])
+    }
+
+    pub fn pause(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("pause", args)
+    }
+
+    pub fn resume(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("resume", args)
+    }
+
+    pub fn toggle_pause(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("toggle_pause", args)
+    }
+
+    pub fn stop(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("stop", args)
+    }
+
+    pub fn play(file_path: &str, concurrent: bool) -> Self {
+        Request::new(
+            "play",
+            vec![
+                ("file_path", file_path),
+                ("concurrent", &concurrent.to_string()),
+            ],
+        )
+    }
+
+    pub fn get_is_paused() -> Self {
+        Request::new("is_paused", vec![])
+    }
+
+    pub fn get_volume(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("get_volume", args)
+    }
+
+    pub fn get_position(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("get_position", args)
+    }
+
+    pub fn get_duration(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("get_duration", args)
+    }
+
+    pub fn get_state() -> Self {
+        Request::new("get_state", vec![])
+    }
+
+    pub fn get_tracks() -> Self {
+        Request::new("get_tracks", vec![])
+    }
+
+    pub fn get_input() -> Self {
+        Request::new("get_input", vec![])
+    }
+
+    pub fn get_inputs() -> Self {
+        Request::new("get_inputs", vec![])
+    }
+
+    pub fn set_volume(volume: f32, id: Option<u32>) -> Self {
+        let mut args = vec![("volume".to_string(), volume.to_string())];
+        if let Some(id) = id {
+            args.push(("id".to_string(), id.to_string()));
+        }
+        Request::new("set_volume".to_string(), args)
+    }
+
+    pub fn seek(position: f32, id: Option<u32>) -> Self {
+        let mut args = vec![("position".to_string(), position.to_string())];
+        if let Some(id) = id {
+            args.push(("id".to_string(), id.to_string()));
+        }
+        Request::new("seek".to_string(), args)
+    }
+
+    pub fn set_input(name: &str) -> Self {
+        Request::new("set_input", vec![("input_name", name)])
+    }
+
+    pub fn set_loop(enabled: &str, id: Option<u32>) -> Self {
+        let mut args = vec![("enabled".to_string(), enabled.to_string())];
+        if let Some(id) = id {
+            args.push(("id".to_string(), id.to_string()));
+        }
+        Request::new("set_loop".to_string(), args)
+    }
+
+    pub fn toggle_loop(id: Option<u32>) -> Self {
+        let mut args = vec![];
+        let id_str;
+        if let Some(id) = id {
+            id_str = id.to_string();
+            args.push(("id", id_str.as_str()));
+        }
+        Request::new("toggle_loop", args)
+    }
+
+    pub fn get_daemon_version() -> Self {
+        Request::new("get_daemon_version", vec![])
+    }
+
+    pub fn get_full_state() -> Self {
+        Request::new("get_full_state", vec![])
+    }
+
+    pub fn get_hotkeys() -> Self {
+        Request::new("get_hotkeys", vec![])
+    }
+
+    pub fn set_hotkey(slot: &str, file_path: &str) -> Self {
+        Request::new("set_hotkey", vec![("slot", slot), ("file_path", file_path)])
+    }
+
+    pub fn set_hotkey_key(slot: &str, key_chord: &str) -> Self {
+        Request::new(
+            "set_hotkey_key",
+            vec![("slot", slot), ("key_chord", key_chord)],
+        )
+    }
+
+    pub fn clear_hotkey(slot: &str) -> Self {
+        Request::new("clear_hotkey", vec![("slot", slot)])
+    }
+
+    pub fn play_hotkey(slot: &str) -> Self {
+        Request::new("play_hotkey", vec![("slot", slot)])
+    }
+
+    pub fn set_hotkey_action(slot: &str, action: &Request) -> Self {
+        let action_json = serde_json::to_string(action).unwrap_or_default();
+        Request::new(
+            "set_hotkey_action",
+            vec![("slot", slot), ("action", &action_json)],
+        )
+    }
+
+    pub fn clear_hotkey_key(slot: &str) -> Self {
+        Request::new("clear_hotkey_key", vec![("slot", slot)])
+    }
+
+    pub fn set_hotkey_action_and_key(slot: &str, action: &Request, key_chord: &str) -> Self {
+        let action_json = serde_json::to_string(action).unwrap_or_default();
+        Request::new(
+            "set_hotkey_action_and_key",
+            vec![
+                ("slot", slot),
+                ("action", &action_json),
+                ("key_chord", key_chord),
+            ],
+        )
+    }
+}
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub struct Response {
+    pub status: bool,
+    pub message: String,
+}
+
+impl Response {
+    pub fn new<T: AsRef<str>>(status: bool, message: T) -> Self {
+        Response {
+            status,
+            message: message.as_ref().to_string(),
+        }
+    }
+}

src/utils/commands.rs

@@ -0,0 +1,124 @@
+use crate::types::{commands::*, socket::Request};
+
+use std::path::PathBuf;
+
+pub fn parse_command(request: &Request) -> Option<Box<dyn Executable + Send>> {
+    let id = request.args.get("id").and_then(|s| s.parse::<u32>().ok());
+
+    match request.name.as_str() {
+        "ping" => Some(Box::new(PingCommand {})),
+        "kill" => Some(Box::new(KillCommand {})),
+        "pause" => Some(Box::new(PauseCommand { id })),
+        "resume" => Some(Box::new(ResumeCommand { id })),
+        "toggle_pause" => Some(Box::new(TogglePauseCommand { id })),
+        "stop" => Some(Box::new(StopCommand { id })),
+        "is_paused" => Some(Box::new(IsPausedCommand {})),
+        "get_state" => Some(Box::new(GetStateCommand {})),
+        "get_volume" => Some(Box::new(GetVolumeCommand { id })),
+        "set_volume" => {
+            let volume = request
+                .args
+                .get("volume")
+                .unwrap_or(&String::new())
+                .parse::<f32>()
+                .ok();
+            Some(Box::new(SetVolumeCommand { volume, id }))
+        }
+        "get_position" => Some(Box::new(GetPositionCommand { id })),
+        "seek" => {
+            let position = request
+                .args
+                .get("position")
+                .unwrap_or(&String::new())
+                .parse::<f32>()
+                .ok();
+            Some(Box::new(SeekCommand { position, id }))
+        }
+        "get_duration" => Some(Box::new(GetDurationCommand { id })),
+        "play" => {
+            let file_path = request
+                .args
+                .get("file_path")
+                .unwrap_or(&String::new())
+                .parse::<PathBuf>()
+                .ok();
+            let concurrent = request
+                .args
+                .get("concurrent")
+                .unwrap_or(&String::new())
+                .parse::<bool>()
+                .ok();
+            Some(Box::new(PlayCommand {
+                file_path,
+                concurrent,
+            }))
+        }
+        "get_tracks" => Some(Box::new(GetTracksCommand {})),
+        "get_input" => Some(Box::new(GetCurrentInputCommand {})),
+        "get_inputs" => Some(Box::new(GetAllInputsCommand {})),
+        "set_input" => {
+            let name = Some(request.args.get("input_name").unwrap_or(&String::new())).cloned();
+            Some(Box::new(SetCurrentInputCommand { name }))
+        }
+        "set_loop" => {
+            let enabled = request
+                .args
+                .get("enabled")
+                .unwrap_or(&String::new())
+                .parse::<bool>()
+                .ok();
+            Some(Box::new(SetLoopCommand { enabled, id }))
+        }
+        "toggle_loop" => Some(Box::new(ToggleLoopCommand { id })),
+        "get_daemon_version" => Some(Box::new(GetDaemonVersionCommand {})),
+        "get_full_state" => Some(Box::new(GetFullStateCommand {})),
+        "get_hotkeys" => Some(Box::new(GetHotkeysCommand {})),
+        "set_hotkey" => {
+            let slot = request.args.get("slot").cloned();
+            let file_path = request
+                .args
+                .get("file_path")
+                .and_then(|s| s.parse::<PathBuf>().ok());
+            Some(Box::new(SetHotkeyCommand { slot, file_path }))
+        }
+        "set_hotkey_key" => {
+            let slot = request.args.get("slot").cloned();
+            let key_chord = request.args.get("key_chord").cloned();
+            Some(Box::new(SetHotkeyKeyCommand { slot, key_chord }))
+        }
+        "clear_hotkey" => {
+            let slot = request.args.get("slot").cloned();
+            Some(Box::new(ClearHotkeyCommand { slot }))
+        }
+        "play_hotkey" => {
+            let slot = request.args.get("slot").cloned();
+            Some(Box::new(PlayHotkeyCommand { slot }))
+        }
+        "set_hotkey_action" => {
+            let slot = request.args.get("slot").cloned();
+            let action = request
+                .args
+                .get("action")
+                .and_then(|s| serde_json::from_str::<Request>(s).ok());
+            Some(Box::new(SetHotkeyActionCommand { slot, action }))
+        }
+        "clear_hotkey_key" => {
+            let slot = request.args.get("slot").cloned();
+            Some(Box::new(ClearHotkeyKeyCommand { slot }))
+        }
+        "set_hotkey_action_and_key" => {
+            let slot = request.args.get("slot").cloned();
+            let action = request
+                .args
+                .get("action")
+                .and_then(|s| serde_json::from_str::<Request>(s).ok());
+            let key_chord = request.args.get("key_chord").cloned();
+            Some(Box::new(SetHotkeyActionAndKeyCommand {
+                slot,
+                action,
+                key_chord,
+            }))
+        }
+        _ => None,
+    }
+}

src/utils/config.rs

@@ -0,0 +1,6 @@
+use std::{error::Error, path::PathBuf};
+
+pub fn get_config_path() -> Result<PathBuf, Box<dyn Error>> {
+    let config_path = dirs::config_dir().expect("Failed to obtain config dir");
+    Ok(config_path.join("pwsp"))
+}

src/utils/daemon.rs

@@ -0,0 +1,115 @@
+use crate::{
+    types::{
+        audio_player::AudioPlayer,
+        config::DaemonConfig,
+        socket::{MAX_MESSAGE_SIZE, Request, Response},
+    },
+};
+
+use std::os::unix::fs::PermissionsExt;
+use std::path::PathBuf;
+use std::{error::Error, fs};
+use tokio::{
+    io::{AsyncReadExt, AsyncWriteExt},
+    net::UnixStream,
+    sync::{Mutex, OnceCell},
+    time::{Duration, sleep},
+};
+
+static AUDIO_PLAYER: OnceCell<Mutex<AudioPlayer>> = OnceCell::const_new();
+
+pub async fn get_audio_player() -> Result<&'static Mutex<AudioPlayer>, String> {
+    AUDIO_PLAYER
+        .get_or_try_init(|| async {
+            println!("Initializing audio player");
+            match AudioPlayer::new().await {
+                Ok(player) => Ok(Mutex::new(player)),
+                Err(err) => Err(err.to_string()),
+            }
+        })
+        .await
+}
+
+pub fn get_daemon_config() -> DaemonConfig {
+    DaemonConfig::load_from_file().unwrap_or_else(|_| {
+        let config = DaemonConfig::default();
+        config.save_to_file().ok();
+        config
+    })
+}
+
+pub fn get_runtime_dir() -> PathBuf {
+    dirs::runtime_dir().unwrap_or(PathBuf::from("/run/pwsp"))
+}
+
+pub fn create_runtime_dir() -> Result<(), Box<dyn Error>> {
+    let runtime_dir = get_runtime_dir();
+    if !runtime_dir.exists() {
+        fs::create_dir_all(&runtime_dir)?;
+    }
+    fs::set_permissions(&runtime_dir, fs::Permissions::from_mode(0o700))?;
+
+    Ok(())
+}
+
+pub fn is_daemon_running() -> Result<bool, Box<dyn Error>> {
+    let lock_file = fs::File::create(get_runtime_dir().join("daemon.lock"))?;
+    match lock_file.try_lock() {
+        Ok(_) => Ok(false),
+        Err(_) => Ok(true),
+    }
+}
+
+pub async fn wait_for_daemon() -> Result<(), Box<dyn Error>> {
+    if is_daemon_running()? {
+        return Ok(());
+    }
+
+    println!("Daemon not found, waiting for it...");
+    while !is_daemon_running()? {
+        sleep(Duration::from_millis(100)).await;
+    }
+
+    println!("Found running daemon");
+
+    Ok(())
+}
+
+pub async fn make_request(request: Request) -> Result<Response, Box<dyn Error + Send + Sync>> {
+    let socket_path = get_runtime_dir().join("daemon.sock");
+    let mut stream = UnixStream::connect(socket_path).await?;
+
+    // ---------- Send request (start) ----------
+    let request_data = serde_json::to_vec(&request)?;
+    let request_len = request_data.len() as u32;
+    if stream.write_all(&request_len.to_le_bytes()).await.is_err() {
+        return Err("Failed to send request length".into());
+    };
+    if stream.write_all(&request_data).await.is_err() {
+        return Err("Failed to send request".into());
+    }
+    // ---------- Send request (end) ----------
+
+    // ---------- Read response (start) ----------
+    let mut len_bytes = [0u8; 4];
+    if stream.read_exact(&mut len_bytes).await.is_err() {
+        return Err("Failed to read response length".into());
+    }
+    let response_len = u32::from_le_bytes(len_bytes) as usize;
+
+    if response_len > MAX_MESSAGE_SIZE {
+        eprintln!(
+            "Failed to read response from daemon: response too large ({} bytes)!",
+            response_len
+        );
+        return Err("Response too large".into());
+    }
+
+    let mut buffer = vec![0u8; response_len];
+    if stream.read_exact(&mut buffer).await.is_err() {
+        return Err("Failed to read response".into());
+    };
+    // ---------- Read response (end) ----------
+
+    Ok(serde_json::from_slice(&buffer)?)
+}

src/utils/global_hotkeys.rs

@@ -0,0 +1,201 @@
+use crate::{types::config::HotkeyConfig, utils::commands::parse_command};
+use evdev::{Device, EventStream, EventSummary, KeyCode};
+
+struct ModifierState {
+    ctrl: bool,
+    alt: bool,
+    shift: bool,
+    meta: bool,
+}
+
+impl ModifierState {
+    fn new() -> Self {
+        Self {
+            ctrl: false,
+            alt: false,
+            shift: false,
+            meta: false,
+        }
+    }
+
+    fn update(&mut self, key: KeyCode, pressed: bool) {
+        match key {
+            KeyCode::KEY_LEFTCTRL | KeyCode::KEY_RIGHTCTRL => self.ctrl = pressed,
+            KeyCode::KEY_LEFTALT | KeyCode::KEY_RIGHTALT => self.alt = pressed,
+            KeyCode::KEY_LEFTSHIFT | KeyCode::KEY_RIGHTSHIFT => self.shift = pressed,
+            KeyCode::KEY_LEFTMETA | KeyCode::KEY_RIGHTMETA => self.meta = pressed,
+            _ => {}
+        }
+    }
+
+    fn any_active(&self) -> bool {
+        self.ctrl || self.alt || self.shift || self.meta
+    }
+
+    fn is_modifier(key: KeyCode) -> bool {
+        matches!(
+            key,
+            KeyCode::KEY_LEFTCTRL
+                | KeyCode::KEY_RIGHTCTRL
+                | KeyCode::KEY_LEFTALT
+                | KeyCode::KEY_RIGHTALT
+                | KeyCode::KEY_LEFTSHIFT
+                | KeyCode::KEY_RIGHTSHIFT
+                | KeyCode::KEY_LEFTMETA
+                | KeyCode::KEY_RIGHTMETA
+        )
+    }
+}
+
+fn evdev_key_name(key: KeyCode) -> Option<&'static str> {
+    match key {
+        KeyCode::KEY_A => Some("A"),
+        KeyCode::KEY_B => Some("B"),
+        KeyCode::KEY_C => Some("C"),
+        KeyCode::KEY_D => Some("D"),
+        KeyCode::KEY_E => Some("E"),
+        KeyCode::KEY_F => Some("F"),
+        KeyCode::KEY_G => Some("G"),
+        KeyCode::KEY_H => Some("H"),
+        KeyCode::KEY_I => Some("I"),
+        KeyCode::KEY_J => Some("J"),
+        KeyCode::KEY_K => Some("K"),
+        KeyCode::KEY_L => Some("L"),
+        KeyCode::KEY_M => Some("M"),
+        KeyCode::KEY_N => Some("N"),
+        KeyCode::KEY_O => Some("O"),
+        KeyCode::KEY_P => Some("P"),
+        KeyCode::KEY_Q => Some("Q"),
+        KeyCode::KEY_R => Some("R"),
+        KeyCode::KEY_S => Some("S"),
+        KeyCode::KEY_T => Some("T"),
+        KeyCode::KEY_U => Some("U"),
+        KeyCode::KEY_V => Some("V"),
+        KeyCode::KEY_W => Some("W"),
+        KeyCode::KEY_X => Some("X"),
+        KeyCode::KEY_Y => Some("Y"),
+        KeyCode::KEY_Z => Some("Z"),
+        KeyCode::KEY_1 => Some("1"),
+        KeyCode::KEY_2 => Some("2"),
+        KeyCode::KEY_3 => Some("3"),
+        KeyCode::KEY_4 => Some("4"),
+        KeyCode::KEY_5 => Some("5"),
+        KeyCode::KEY_6 => Some("6"),
+        KeyCode::KEY_7 => Some("7"),
+        KeyCode::KEY_8 => Some("8"),
+        KeyCode::KEY_9 => Some("9"),
+        KeyCode::KEY_0 => Some("0"),
+        KeyCode::KEY_F1 => Some("F1"),
+        KeyCode::KEY_F2 => Some("F2"),
+        KeyCode::KEY_F3 => Some("F3"),
+        KeyCode::KEY_F4 => Some("F4"),
+        KeyCode::KEY_F5 => Some("F5"),
+        KeyCode::KEY_F6 => Some("F6"),
+        KeyCode::KEY_F7 => Some("F7"),
+        KeyCode::KEY_F8 => Some("F8"),
+        KeyCode::KEY_F9 => Some("F9"),
+        KeyCode::KEY_F10 => Some("F10"),
+        KeyCode::KEY_F11 => Some("F11"),
+        KeyCode::KEY_F12 => Some("F12"),
+        _ => None,
+    }
+}
+
+fn build_chord(modifiers: &ModifierState, key_name: &str) -> String {
+    let mut parts = Vec::with_capacity(5);
+    if modifiers.ctrl {
+        parts.push("Ctrl");
+    }
+    if modifiers.alt {
+        parts.push("Alt");
+    }
+    if modifiers.shift {
+        parts.push("Shift");
+    }
+    if modifiers.meta {
+        parts.push("Super");
+    }
+    parts.push(key_name);
+    parts.join("+")
+}
+
+fn is_keyboard(device: &Device) -> bool {
+    device
+        .supported_keys()
+        .is_some_and(|keys| keys.contains(KeyCode::KEY_A) && keys.contains(KeyCode::KEY_Z))
+}
+
+async fn handle_device_events(mut stream: EventStream) {
+    let mut modifiers = ModifierState::new();
+
+    loop {
+        match stream.next_event().await {
+            Ok(event) => {
+                if let EventSummary::Key(_, key, value) = event.destructure() {
+                    // 0 = released, 1 = pressed, 2 = repeat
+                    if value == 0 || value == 1 {
+                        modifiers.update(key, value == 1);
+                    }
+
+                    // Only trigger on press, skip modifiers and bare keys
+                    if value != 1 || ModifierState::is_modifier(key) || !modifiers.any_active() {
+                        continue;
+                    }
+
+                    let Some(key_name) = evdev_key_name(key) else {
+                        continue;
+                    };
+
+                    let chord = build_chord(&modifiers, key_name);
+
+                    let config = match HotkeyConfig::load() {
+                        Ok(c) => c,
+                        Err(_) => continue,
+                    };
+
+                    let slots = config.slots_for_chord(&chord);
+                    for slot in slots {
+                        if let Some(cmd) = parse_command(&slot.action) {
+                            cmd.execute().await;
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Global hotkeys: device read error: {e}");
+                break;
+            }
+        }
+    }
+}
+
+pub async fn start_global_hotkey_listener() {
+    let keyboards: Vec<_> = evdev::enumerate()
+        .filter(|(_, dev)| is_keyboard(dev))
+        .collect();
+
+    if keyboards.is_empty() {
+        eprintln!(
+            "Global hotkeys: no keyboard devices found. \
+             Make sure your user is in the 'input' group."
+        );
+        return;
+    }
+
+    println!(
+        "Global hotkeys: found {} keyboard device(s)",
+        keyboards.len()
+    );
+
+    for (path, device) in keyboards {
+        match device.into_event_stream() {
+            Ok(stream) => {
+                println!("Global hotkeys: listening on {}", path.display());
+                tokio::spawn(handle_device_events(stream));
+            }
+            Err(e) => {
+                eprintln!("Global hotkeys: failed to open {}: {}", path.display(), e);
+            }
+        }
+    }
+}

src/utils/gui.rs

@@ -0,0 +1,129 @@
+use crate::{
+    types::{
+        audio_player::FullState,
+        config::{GuiConfig, HotkeyConfig},
+        gui::AudioPlayerState,
+        socket::{Request, Response},
+    },
+    utils::daemon::{is_daemon_running, make_request},
+};
+use std::{
+    error::Error,
+    sync::{Arc, Mutex},
+    time::Instant,
+};
+use tokio::time::{Duration, sleep};
+
+pub fn get_gui_config() -> GuiConfig {
+    GuiConfig::load_from_file().unwrap_or_else(|_| {
+        let mut config = GuiConfig::default();
+        config.save_to_file().ok();
+        config
+    })
+}
+
+pub fn make_request_sync(request: Request) -> Result<Response, Box<dyn Error>> {
+    tokio::task::block_in_place(|| {
+        tokio::runtime::Handle::current()
+            .block_on(make_request(request))
+            .map_err(|e| e as Box<dyn Error>)
+    })
+}
+
+pub fn make_request_async(request: Request) {
+    tokio::spawn(async move {
+        make_request(request).await.ok();
+    });
+}
+
+pub fn format_time_pair(position: f32, duration: f32) -> String {
+    fn format_time(seconds: f32) -> String {
+        let total_seconds = seconds.round() as u32;
+        let minutes = total_seconds / 60;
+        let secs = total_seconds % 60;
+        format!("{:02}:{:02}", minutes, secs)
+    }
+
+    format!("{}/{}", format_time(position), format_time(duration))
+}
+
+pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerState>>) {
+    tokio::spawn(async move {
+        let sleep_duration = Duration::from_secs_f32(1.0 / 60.0);
+        let mut last_hotkey_poll = Instant::now();
+
+        loop {
+            let is_running = is_daemon_running().unwrap_or(false);
+
+            if !is_running {
+                {
+                    let mut guard = audio_player_state_shared
+                        .lock()
+                        .unwrap_or_else(|e| e.into_inner());
+                    guard.is_daemon_running = false;
+                }
+                sleep(Duration::from_millis(500)).await;
+                continue;
+            }
+
+            let full_state_req = Request::get_full_state();
+            let full_state_res = make_request(full_state_req).await.unwrap_or_default();
+
+            if full_state_res.status {
+                let full_state: FullState =
+                    serde_json::from_str(&full_state_res.message).unwrap_or_default();
+
+                let mut guard = audio_player_state_shared
+                    .lock()
+                    .unwrap_or_else(|e| e.into_inner());
+
+                guard.state = match guard.new_state.clone() {
+                    Some(new_state) => {
+                        guard.new_state = None;
+                        new_state
+                    }
+                    None => full_state.state,
+                };
+                guard.tracks = full_state.tracks;
+                guard.volume = full_state.volume;
+                guard.current_input = full_state
+                    .current_input
+                    .split(" - ")
+                    .next()
+                    .unwrap_or_default()
+                    .to_string();
+
+                if guard.all_inputs != full_state.all_inputs {
+                    guard.all_inputs = full_state.all_inputs;
+                    let mut sorted: Vec<(String, String)> = guard
+                        .all_inputs
+                        .iter()
+                        .map(|(k, v)| (k.clone(), v.clone()))
+                        .collect();
+                    sorted.sort_by(|a, b| a.0.cmp(&b.0));
+                    guard.all_inputs_sorted = sorted;
+                }
+
+                guard.is_daemon_running = true;
+            }
+
+            // Poll hotkey config at a lower frequency (~every 2 seconds)
+            if last_hotkey_poll.elapsed() >= Duration::from_secs(2) {
+                let hotkey_res = make_request(Request::get_hotkeys())
+                    .await
+                    .unwrap_or_default();
+                if hotkey_res.status {
+                    if let Ok(config) = serde_json::from_str::<HotkeyConfig>(&hotkey_res.message) {
+                        let mut guard = audio_player_state_shared
+                            .lock()
+                            .unwrap_or_else(|e| e.into_inner());
+                        guard.hotkey_config = Some(config);
+                    }
+                }
+                last_hotkey_poll = Instant::now();
+            }
+
+            sleep(sleep_duration).await;
+        }
+    });
+}

src/utils/mod.rs

@@ -0,0 +1,6 @@
+pub mod commands;
+pub mod config;
+pub mod daemon;
+pub mod global_hotkeys;
+pub mod gui;
+pub mod pipewire;

src/utils/pipewire.rs

@@ -0,0 +1,349 @@
+use crate::types::pipewire::{AudioDevice, DeviceType, Port, Terminate};
+use pipewire::{
+    context::ContextRc, link::Link, main_loop::MainLoopRc, properties::properties,
+    registry::GlobalObject, spa::utils::dict::DictRef,
+};
+use std::{collections::HashMap, error::Error, thread};
+use tokio::{
+    sync::mpsc,
+    time::{Duration, timeout},
+};
+
+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");
+
+            // 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,
+
+                    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() {
+            if 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)
+}
+
+async fn pw_get_global_objects_thread(
+    main_sender: mpsc::Sender<(Option<AudioDevice>, Option<Port>)>,
+    pw_receiver: pipewire::channel::Receiver<Terminate>,
+) {
+    pipewire::init();
+
+    let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+
+    // Stop main loop on Terminate message
+    let _receiver = pw_receiver.attach(main_loop.loop_(), {
+        let _main_loop = main_loop.clone();
+        move |_| _main_loop.quit()
+    });
+
+    let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
+    let core = context
+        .connect(None)
+        .expect("Failed to connect to pipewire context");
+    let registry = core
+        .get_registry()
+        .expect("Failed to get registry from pipewire context");
+
+    let _listener = registry
+        .add_listener_local()
+        .global(move |global| {
+            // Try to parse every global object pipewire finds
+            let (device, port) = parse_global_object(global);
+
+            // Send message to the main thread
+            let sender_clone = main_sender.clone();
+            tokio::task::spawn(async move {
+                sender_clone.send((device, port)).await.ok();
+            });
+        })
+        .register();
+
+    main_loop.run();
+}
+
+pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), Box<dyn Error>> {
+    // Channels to communicate with pipewire thread
+    let (main_sender, mut main_receiver) = mpsc::channel(10);
+    let (pw_sender, pw_receiver) = pipewire::channel::channel();
+
+    // Spawn pipewire thread in background
+    let _pw_thread =
+        tokio::spawn(async move { pw_get_global_objects_thread(main_sender, pw_receiver).await });
+
+    let mut input_devices: HashMap<u32, AudioDevice> = HashMap::new();
+    let mut output_devices: HashMap<u32, AudioDevice> = HashMap::new();
+    let mut ports: Vec<Port> = vec![];
+
+    loop {
+        // If we don't receive a message in 100ms, we can assume that pipewire thread is finished
+        match timeout(Duration::from_millis(100), main_receiver.recv()).await {
+            Ok(Some((device, port))) => {
+                if let Some(device) = device {
+                    match device.device_type {
+                        DeviceType::Input => {
+                            input_devices.insert(device.id, device);
+                        }
+                        DeviceType::Output => {
+                            output_devices.insert(device.id, device);
+                        }
+                    }
+                } else if let Some(port) = port {
+                    ports.push(port);
+                }
+            }
+            Ok(None) | Err(_) => {
+                // Pipewire thread is finished and we can collect our devices
+                pw_sender
+                    .send(Terminate {})
+                    .expect("Failed to terminate pipewire thread");
+
+                for port in ports {
+                    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);
+                            }
+                            _ => {}
+                        }
+                    } 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)
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                let mut input_devices: Vec<AudioDevice> = input_devices.values().cloned().collect();
+                let mut output_devices: Vec<AudioDevice> =
+                    output_devices.values().cloned().collect();
+
+                input_devices.sort_by(|a, b| a.id.cmp(&b.id));
+                output_devices.sort_by(|a, b| a.id.cmp(&b.id));
+
+                return Ok((input_devices, output_devices));
+            }
+        }
+    }
+}
+
+pub async fn get_device(device_name: &str) -> Result<AudioDevice, Box<dyn Error>> {
+    let (input_devices, output_devices) = get_all_devices().await?;
+
+    input_devices
+        .into_iter()
+        .chain(output_devices)
+        .find(|device| {
+            device.name == device_name
+                || device.nick == device_name
+                || device.name.contains(device_name)
+                || device.nick.contains(device_name)
+        })
+        .ok_or_else(|| "Device not found".into())
+}
+
+pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
+    let (pw_sender, pw_receiver) = pipewire::channel::channel::<Terminate>();
+
+    let _pw_thread = thread::spawn(move || {
+        pipewire::init();
+
+        let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+        let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
+        let core = context
+            .connect(None)
+            .expect("Failed to connect to pipewire context");
+
+        let props = properties!(
+            "factory.name" => "support.null-audio-sink",
+            "node.name" => "pwsp-virtual-mic",
+            "node.description" => "PWSP Virtual Mic",
+            "media.class" => "Audio/Source/Virtual",
+            "audio.position" => "[ FL FR ]",
+            "audio.channels" => "2",
+            "object.linger" => "false", // Destroy the node on app exit
+        );
+
+        let _node = core
+            .create_object::<pipewire::node::Node>("adapter", &props)
+            .expect("Failed to create virtual mic");
+
+        let _receiver = pw_receiver.attach(main_loop.loop_(), {
+            let _main_loop = main_loop.clone();
+            move |_| _main_loop.quit()
+        });
+
+        println!("Virtual mic created");
+        main_loop.run();
+    });
+
+    Ok(pw_sender)
+}
+
+pub async fn link_player_to_virtual_mic()
+-> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
+    let pwsp_daemon_output = match get_device("pwsp-daemon").await {
+        Ok(device) => device,
+        Err(_) => {
+            return Err(
+                "Could not find alsa_playback.pwsp-daemon device, skipping device linking".into(),
+            );
+        }
+    };
+
+    let pwsp_daemon_input = match get_device("pwsp-virtual-mic").await {
+        Ok(device) => device,
+        Err(_) => {
+            return Err("Could not find pwsp-virtual-mic device, skipping device linking".into());
+        }
+    };
+
+    let output_fl = match pwsp_daemon_output.output_fl {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-daemon output_fl".into()),
+    };
+    let output_fr = match pwsp_daemon_output.output_fr {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-daemon output_fr".into()),
+    };
+    let input_fl = match pwsp_daemon_input.input_fl {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-virtual-mic input_fl".into()),
+    };
+    let input_fr = match pwsp_daemon_input.input_fr {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-virtual-mic input_fr".into()),
+    };
+
+    create_link(output_fl, output_fr, input_fl, input_fr)
+}
+
+pub fn create_link(
+    output_fl: Port,
+    output_fr: Port,
+    input_fl: Port,
+    input_fr: Port,
+) -> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
+    let (pw_sender, pw_receiver) = pipewire::channel::channel::<Terminate>();
+
+    let _pw_thread = thread::spawn(move || {
+        pipewire::init();
+
+        let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+        let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
+        let core = context
+            .connect(None)
+            .expect("Failed to connect to pipewire context");
+
+        let props_fl = properties! {
+            "link.output.node" => format!("{}", output_fl.node_id).as_str(),
+            "link.output.port" => format!("{}", output_fl.port_id).as_str(),
+            "link.input.node"  => format!("{}", input_fl.node_id).as_str(),
+            "link.input.port"  => format!("{}", input_fl.port_id).as_str(),
+        };
+        let props_fr = properties! {
+            "link.output.node" => format!("{}", output_fr.node_id).as_str(),
+            "link.output.port" => format!("{}", output_fr.port_id).as_str(),
+            "link.input.node"  => format!("{}", input_fr.node_id).as_str(),
+            "link.input.port"  => format!("{}", input_fr.port_id).as_str(),
+        };
+
+        let _link_fl = core
+            .create_object::<Link>("link-factory", &props_fl)
+            .expect("Failed to create link FL");
+        let _link_fr = core
+            .create_object::<Link>("link-factory", &props_fr)
+            .expect("Failed to create link FR");
+
+        let _receiver = pw_receiver.attach(main_loop.loop_(), {
+            let _main_loop = main_loop.clone();
+            move |_| _main_loop.quit()
+        });
+
+        println!(
+            "Link created: FL: {}-{} FR: {}-{}",
+            output_fl.node_id, input_fl.node_id, output_fr.node_id, input_fr.node_id
+        );
+        main_loop.run();
+    });
+
+    Ok(pw_sender)
+}