Add varlink settings daemon interfaces for handling audio with pipewire

Cargo.toml

@@ -3,52 +3,57 @@ name = "cosmic-settings-daemon"
 version = "0.1.0"
 edition = "2024"
 license = "GPL-3.0-or-later"
+publish = false
 
 [workspace]
-members = ["config", "cosmic-settings-daemon-config", "geonames"]
+members = ["audio-client", "audio-core", "audio-server", "config", "cosmic-settings-daemon-config", "geonames", "cosmic-pipewire", "varlink-server"]
 
 [workspace.dependencies]
 cosmic-config = { git = "https://github.com/pop-os/libcosmic" }
 cosmic-theme = { git = "https://github.com/pop-os/libcosmic" }
 
-# cosmic-config = { path = "../libcosmic/cosmic-config" }
-# cosmic-theme = { path = "../libcosmic/cosmic-theme" }
-
+[workspace.dependencies.zlink]
+version = "0.5"
+default-features = false
+features = ["tokio"]
 
 [dependencies]
-cosmic-settings-pulse-subscription = { git = "https://github.com/pop-os/cosmic-settings", default-features = false }
+acpid_plug = "0.1.2"
 anyhow = "1.0.99"
+chrono = "0.4.42"
+cosmic-comp-config = { git = "https://github.com/pop-os/cosmic-comp" }
+cosmic-config.workspace = true
+cosmic-dbus-a11y = { git = "https://github.com/pop-os/dbus-settings-bindings" }
+cosmic-settings-audio-server = { path = "./audio-server" }
 cosmic-settings-daemon-config = { path = "./cosmic-settings-daemon-config", features = [
     "greeter",
 ] }
+cosmic-settings-varlink-server = { path = "./varlink-server" }
+cosmic-theme.export = true
+cosmic-theme.workspace = true
+ctrlc = { version = "3.5.0", features = ["termination"] }
+ddc-hi = "0.4.1"
 dirs = "6.0.0"
+futures = "0.3.31"
+futures-util = "0.3.31"
+geonames = { path = "geonames" }
+libcosmic = { git = "https://github.com/pop-os/libcosmic", default-features = false }
+locale1 = { git = "https://github.com/pop-os/dbus-settings-bindings" }
+log = "0.4.28"
+memoize = "0.5.1"
 notify = "8.2.0"
+notify-rust = "4.11.7"
+serde = "1.0.228"
+sunrise = "2.1.0"
 tokio = { version = "1.47.1", features = ["macros", "net", "rt"] }
-udev = "0.9.3"
-zbus = { version = "5.11.0", default-features = false, features = ["tokio"] }
 tokio-stream = "0.1.17"
-sunrise = "2.1.0"
-cosmic-config.workspace = true
-cosmic-theme.workspace = true
-cosmic-theme.export = true
-cosmic-comp-config = { git = "https://github.com/pop-os/cosmic-comp" }
-chrono = "0.4.42"
-libcosmic = { git = "https://github.com/pop-os/libcosmic", default-features = false }
-acpid_plug = "0.1.2"
+tracing = "0.1.44"
+tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
+udev = "0.9.3"
 upower_dbus = { git = "https://github.com/pop-os/dbus-settings-bindings" }
-locale1 = { git = "https://github.com/pop-os/dbus-settings-bindings" }
-cosmic-dbus-a11y = { git = "https://github.com/pop-os/dbus-settings-bindings" }
-notify-rust = "4.11.7"
 walkdir = "2.5.0"
-memoize = "0.5.1"
-futures-util = "0.3.31"
-futures = "0.3.31"
-ctrlc = { version = "3.5.0", features = ["termination"] }
 xkb-data = "0.2.1"
-geonames = { path = "geonames" }
-log = "0.4.28"
-env_logger = "0.11.8"
-ddc-hi = "0.4.1"
+zbus = { version = "5.11.0", default-features = false, features = ["tokio"] }
 
 # For development and testing purposes
 # [patch.'https://github.com/pop-os/libcosmic']

audio-client/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "cosmic-settings-audio-client"
+version = "1.0.0"
+edition = "2024"
+license = "MPL-2.0"
+publish = true
+
+[features]
+codec = ["dep:futures-util", "dep:ron", "dep:tokio", "tokio/net", "tokio-util/codec"]
+
+[dependencies]
+cosmic-settings-audio-core = { path = "../audio-core" }
+dirs = "6.0.0"
+futures-util = { version = "0.3", optional = true}
+tokio = { version = "1.0", default-features = false, optional = true}
+tokio-util = { version = "0.7" }
+serde = "1.0"
+ron = { version = "0.12", optional = true }
+# Needed by zlink
+tracing = "0.1.44"
+
+[dependencies.zlink]
+workspace = true
+default-features = false
+features = ["proxy", "tokio", "tracing"]
+
+[dev-dependencies]
+cosmic-settings-audio-client = { path = ".", features = ["codec"] }
+cosmic-settings-audio-core = { path = "../audio-core" }
+tokio = { version = "1.49.0", features = ["full"] }
+zlink = { workspace = true, features = ["idl", "introspection", "tokio", "tracing", "server", "service"] }
+tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
+tracing = "0.1.44"
+futures-util = "0.3.32"
+serde = "1.0.228"

audio-client/README.md

@@ -0,0 +1,3 @@
+# cosmic-settings-audio-client
+
+Varlink client proxy for clients using the `com.system76.CosmicSettings.Audio` interfaces on `com.system76.CosmicSettings`.

audio-client/examples/audio_client.rs

@@ -0,0 +1,47 @@
+// Copyright 2026 System76 <info@system76.com>
+// SPDX-License-Identifier: GPL-3.0-only
+
+use cosmic_settings_audio_client::CosmicAudioProxy;
+use futures_util::StreamExt;
+use tracing_subscriber::prelude::*;
+
+#[tokio::main(flavor = "current_thread")]
+pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let log_format = tracing_subscriber::fmt::format()
+        .pretty()
+        .without_time()
+        .with_line_number(true)
+        .with_file(true)
+        .with_target(false)
+        .with_thread_names(true);
+
+    let log_layer = tracing_subscriber::fmt::Layer::default()
+        .with_writer(std::io::stderr)
+        .event_format(log_format);
+
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::EnvFilter::from_env("RUST_LOG"))
+        .with(log_layer)
+        .init();
+
+    let mut client = cosmic_settings_audio_client::connect().await.unwrap();
+
+    println!(
+        "default source: {:?}",
+        client.conn.default_source().await.unwrap()
+    );
+    println!(
+        "default sink: {:?}",
+        client.conn.default_source().await.unwrap()
+    );
+
+    client
+        .recv_events()
+        .await??
+        .for_each(|result| async move {
+            eprintln!("{:?}", result.unwrap());
+        })
+        .await;
+
+    Ok(())
+}

audio-client/src/codec.rs

@@ -0,0 +1,80 @@
+// Copyright 2026 System76 <info@system76.com>
+// SPDX-License-Identifier: MPL-2.0
+
+use cosmic_settings_audio_core::Event;
+use tokio_util::bytes::Buf;
+
+const MAX: usize = 8 * 1024 * 1024;
+
+pub struct EventDecoder;
+
+impl tokio_util::codec::Decoder for EventDecoder {
+    type Item = Event;
+    type Error = Error;
+
+    fn decode(
+        &mut self,
+        src: &mut tokio_util::bytes::BytesMut,
+    ) -> Result<Option<Self::Item>, Self::Error> {
+        if src.len() < 4 {
+            // Not enough data to read length marker.
+            return Ok(None);
+        }
+
+        // Read length marker.
+        let mut length_bytes = [0u8; 4];
+        length_bytes.copy_from_slice(&src[..4]);
+        let length = u32::from_le_bytes(length_bytes) as usize;
+
+        // Check that the length is not too large to avoid a denial of
+        // service attack where the server runs out of memory.
+        if length > MAX {
+            return Err(Error::IO(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                format!("Frame of length {} is too large.", length),
+            )));
+        }
+
+        if src.len() < 4 + length {
+            // The full string has not yet arrived.
+            //
+            // We reserve more space in the buffer. This is not strictly
+            // necessary, but is a good idea performance-wise.
+            src.reserve(4 + length - src.len());
+
+            // We inform the Framed that we need more bytes to form the next
+            // frame.
+            return Ok(None);
+        }
+
+        // Use advance to modify src such that it no longer contains
+        // this frame.
+        let data = src[4..4 + length].to_vec();
+        src.advance(4 + length);
+
+        ron::de::from_bytes(&data).map(Some).map_err(Error::Ron)
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    IO(std::io::Error),
+    Ron(ron::de::SpannedError),
+}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Ron(why) => write!(f, "RON deserialize error: {why}"),
+            Self::IO(why) => write!(f, "I/O stream error: {why}"),
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl From<std::io::Error> for Error {
+    fn from(error: std::io::Error) -> Self {
+        Self::IO(error)
+    }
+}

audio-client/src/lib.rs

@@ -0,0 +1,129 @@
+// Copyright 2026 System76 <info@system76.com>
+// SPDX-License-Identifier: MPL-2.0
+
+#[cfg(feature = "codec")]
+pub mod codec;
+
+pub use zlink;
+use zlink::Connection;
+
+pub use cosmic_settings_audio_core::*;
+use std::{os::fd::OwnedFd, path::PathBuf};
+
+pub async fn connect() -> zlink::Result<Client> {
+    zlink::unix::connect(socket_path())
+        .await
+        .map(|conn| Client { conn })
+}
+
+#[derive(Debug)]
+pub struct Client {
+    pub conn: Connection<zlink::unix::Stream>,
+}
+
+impl Client {
+    #[cfg(feature = "codec")]
+    pub async fn recv_events(
+        &mut self,
+    ) -> zlink::Result<
+        Result<
+            impl futures_util::Stream<Item = Result<Event, codec::Error>> + Sync + Send + 'static,
+            Error,
+        >,
+    > {
+        self.conn
+            .recv_events()
+            .await
+            .map(|(result, mut fds)| match result {
+                Ok(()) => Ok(tokio_util::codec::FramedRead::new(
+                    tokio::net::unix::pipe::Receiver::from_owned_fd(fds.swap_remove(0)).unwrap(),
+                    codec::EventDecoder,
+                )),
+                Err(why) => Err(why),
+            })
+    }
+}
+
+pub fn socket_path() -> PathBuf {
+    dirs::runtime_dir()
+        .expect("runtime dir required by varlink service")
+        .join("com.system76.CosmicSettings")
+}
+
+#[zlink::proxy("com.system76.CosmicSettings.Audio")]
+pub trait CosmicAudioProxy {
+    /// Request to listen to audio events through the returned `OwnedFd`.
+    #[zlink(return_fds)]
+    async fn recv_events(&mut self) -> zlink::Result<(Result<(), Error>, Vec<OwnedFd>)>;
+
+    async fn default_sink(&mut self) -> zlink::Result<Result<Node, Error>>;
+
+    async fn default_source(&mut self) -> zlink::Result<Result<Node, Error>>;
+
+    async fn sink_mute_toggle(&mut self) -> zlink::Result<Result<Mute, Error>>;
+
+    async fn sink_volume_lower(&mut self, step: u32) -> zlink::Result<Result<Volume, Error>>;
+
+    async fn sink_volume_raise(&mut self, step: u32) -> zlink::Result<Result<Volume, Error>>;
+
+    async fn source_mute_toggle(&mut self) -> zlink::Result<Result<Mute, Error>>;
+
+    async fn source_volume_lower(&mut self, step: u32) -> zlink::Result<Result<Volume, Error>>;
+
+    async fn source_volume_raise(&mut self, step: u32) -> zlink::Result<Result<Volume, Error>>;
+
+    async fn set_default(&mut self, node_id: u32, save: bool) -> zlink::Result<Result<(), Error>>;
+
+    /// Select the headphone profile of a device, if available.
+    async fn select_headphone_profile(
+        &mut self,
+        device_id: u32,
+    ) -> zlink::Result<Result<(), Error>>;
+
+    /// Select the headset profile of a device, if available.
+    async fn select_headset_profile(&mut self, device_id: u32) -> zlink::Result<Result<(), Error>>;
+
+    /// Change the active profile of an audio device; changing which routes are active.
+    async fn set_profile(
+        &mut self,
+        device_id: u32,
+        profile_index: u32,
+        save: bool,
+    ) -> zlink::Result<Result<(), Error>>;
+
+    /// Change the active route of an audio device.
+    async fn set_route(
+        &mut self,
+        device_id: u32,
+        card_profile_device: u32,
+        route_index: u32,
+        save: bool,
+    ) -> zlink::Result<Result<(), Error>>;
+
+    /// Apply a volume to the default sink node.
+    async fn set_sink_volume(&mut self, volume: u32) -> zlink::Result<Result<Volume, Error>>;
+
+    /// Apply a volume to the default source node.
+    async fn set_source_volume(&mut self, volume: u32) -> zlink::Result<Result<Volume, Error>>;
+
+    /// Apply a mute state to a node by its ID.
+    async fn set_node_mute(
+        &mut self,
+        node_id: u32,
+        mute: bool,
+    ) -> zlink::Result<Result<Mute, Error>>;
+
+    /// Apply a volume to a node by its ID.
+    async fn set_node_volume(
+        &mut self,
+        node_id: u32,
+        volume: u32,
+    ) -> zlink::Result<Result<Volume, Error>>;
+
+    /// Set the balance of a node by its ID. 1.
+    async fn set_node_volume_balance(
+        &mut self,
+        node_id: u32,
+        balance: Option<f32>,
+    ) -> zlink::Result<Result<Volume, Error>>;
+}

audio-core/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "cosmic-settings-audio-core"
+version = "1.0.0"
+edition = "2024"
+license = "MPL-2.0"
+publish = true
+
+[dependencies]
+dirs = "6.0.0"
+ron = "0.12.0"
+serde = { version = "1.0.228", features = ["derive"] }
+
+[dependencies.zlink]
+workspace = true
+features = ["introspection"]