feat: add control for alerts volume/mute (fixes #1017)

cgevans · cgevans · commit 9c112c6b4481 · 2025-12-16T23:24:25.000Z
Using an approach based on the System Sounds setting in pavucontrol,
this gets and sets route-settings metadata that adjusts the volume of
media with the Notification media-role.
diff --git a/cosmic-settings/src/pages/sound/mod.rs b/cosmic-settings/src/pages/sound/mod.rs
@@ -47,6 +47,10 @@ pub enum Message {
     ToggleOverAmplificationSink(bool),
     /// Toggle amplification for sink
     ToggleOverAmplificationSource(bool),
+    /// Toggle the mute status of notifications.
+    ToggleNotificationMute,
+    /// Set the volume of notifications.
+    SetNotificationVolume(u32),
 }
 
 impl From<Message> for crate::pages::Message {
@@ -116,6 +120,7 @@ impl page::Page<crate::pages::Message> for Page {
         sections: &mut SlotMap<section::Entity, Section<crate::pages::Message>>,
     ) -> Option<page::Content> {
         Some(vec![
+            sections.insert(alerts()),
             sections.insert(output()),
             sections.insert(input()),
             sections.insert(device_profiles()),
@@ -199,6 +204,8 @@ impl Page {
 
             Message::ToggleSourceMute => self.model.toggle_source_mute(),
 
+            Message::ToggleNotificationMute => self.model.toggle_notification_mute(),
+
             Message::SetSinkVolume(volume) => {
                 return self
                     .model
@@ -213,6 +220,13 @@ impl Page {
                     .map(|message| Message::Subscription(message).into());
             }
 
+            Message::SetNotificationVolume(volume) => {
+                return self
+                    .model
+                    .set_notification_volume(volume)
+                    .map(|message| Message::Subscription(message).into());
+            }
+
             Message::ToggleOverAmplificationSink(enabled) => {
                 self.amplification_sink = enabled;
 
@@ -459,21 +473,53 @@ fn device_profiles() -> Section<crate::pages::Message> {
         })
 }
 
-// fn alerts() -> Section<crate::pages::Message> {
-//     let mut descriptions = Slab::new();
-//     let volume = descriptions.insert(fl!("sound-alerts", "volume"));
-//     let sound = descriptions.insert(fl!("sound-alerts", "sound"));
+fn alerts() -> Section<crate::pages::Message> {
+    let mut descriptions = Slab::new();
+    let volume = descriptions.insert(fl!("sound-alerts", "volume"));
+    let sound = descriptions.insert(fl!("sound-alerts", "sound"));
 
-//     Section::default()
-//         .title(fl!("sound-alerts"))
-//         .descriptions(descriptions)
-//         .view::<Page>(move |_binder, _page, section| {
-//             settings::section().title(&section.title)
-//                 .add(settings::item(&section.descriptions[volume], text::body("TODO")))
-//                 .add(settings::item(&section.descriptions[sound], text::body("TODO")))
-//                 .into()
-//         })
-// }
+    Section::default()
+        .title(fl!("sound-alerts"))
+        .descriptions(descriptions)
+        .view::<Page>(move |_binder, page, section| {
+            let slider = if page.amplification_sink {
+                widget::slider(0..=150, page.model.notification_volume, |change| {
+                    Message::SetNotificationVolume(change).into()
+                })
+                .breakpoints(&[100])
+            } else {
+                widget::slider(0..=100, page.model.notification_volume, |change| {
+                    Message::SetNotificationVolume(change).into()
+                })
+            };
+
+            let volume_control = widget::row::with_capacity(4)
+                .align_y(Alignment::Center)
+                .push(
+                    widget::button::icon(if page.model.notification_mute {
+                        widget::icon::from_name("audio-volume-muted-symbolic")
+                    } else {
+                        widget::icon::from_name("audio-volume-high-symbolic")
+                    })
+                    .on_press(Message::ToggleNotificationMute.into()),
+                )
+                .push(
+                    widget::text::body(&page.model.notification_volume_text)
+                        .width(Length::Fixed(22.0))
+                        .align_x(Alignment::Center),
+                )
+                .push(widget::horizontal_space().width(8))
+                .push(slider);
+
+            settings::section()
+                .title(&section.title)
+                .add(settings::flex_item(
+                    &*section.descriptions[volume],
+                    volume_control,
+                ))
+                .into()
+        })
+}
 
 // fn applications() -> Section<crate::pages::Message> {
 //     let mut descriptions = Slab::new();
diff --git a/crates/cosmic-pipewire/src/lib.rs b/crates/cosmic-pipewire/src/lib.rs
@@ -77,6 +77,7 @@ fn run_service(
         node_props: IntMap::new(),
         main_loop: main_loop.downgrade(),
         on_event: Box::new(on_event),
+        route_settings_metadata_id: None,
     }));
 
     let _request_handler = rx.attach(main_loop.loop_(), {
@@ -100,6 +101,12 @@ fn run_service(
                 }
             }
 
+            Request::SetNotification(volume, mute) => {
+                if let Some(state) = state.upgrade() {
+                    state.borrow_mut().set_notification_settings(volume, mute);
+                }
+            }
+
             Request::SetProfile(id, index, save) => {
                 if let Some(state) = state.upgrade() {
                     state.borrow_mut().set_profile(id, index, save);
@@ -332,6 +339,14 @@ fn run_service(
 
                     let id = metadata.upcast_ref().id();
 
+                    if obj
+                        .props
+                        .and_then(|props| props.get("metadata.name"))
+                        .is_some_and(|name| name == "route-settings")
+                    {
+                        state.borrow_mut().route_settings_metadata_id = Some(id);
+                    }
+
                     let listener = metadata
                         .add_listener_local()
                         .property({
@@ -366,6 +381,26 @@ fn run_service(
                                         }
                                     }
 
+                                    "restore.stream.Output/Audio.media.role:Notification" => {
+                                        if let Ok(metadata) =
+                                            serde_json::de::from_str::<NotificationRouteSettingsMetadata>(
+                                                value,
+                                            )
+                                        {
+                                            if let Some(state) = state.upgrade() {
+                                                let volume = metadata
+                                                    .volumes
+                                                    .first()
+                                                    .copied()
+                                                    .unwrap_or(1.0)
+                                                    .powf(1.0 / 3.0);
+                                                state.borrow_mut().on_event(Event::NotificationVolume(
+                                                    volume, metadata.mute,
+                                                ));
+                                            }
+                                        }
+                                    }
+
                                     _ => (),
                                 }
 
@@ -421,6 +456,8 @@ pub enum Event {
     DefaultSink(String),
     /// The default source was changed.
     DefaultSource(String),
+    /// The notification volume/mute state changed.
+    NotificationVolume(f32, bool),
     /// Emitted when the properties of a node has changed.
     NodeProperties(NodeId, NodeProps),
     /// A device with the given device_id was removed.
@@ -439,6 +476,8 @@ pub enum Request {
     SetProfile(DeviceId, u32, bool),
     /// Set a new volume
     SetNodeVolume(DeviceId, f32, Option<f32>),
+    /// Set the notification volume and mute state
+    SetNotification(f32, bool),
     /// Stop the main loop and exit the thread.
     Quit,
 }
@@ -463,6 +502,12 @@ pub struct DefaultAudio<'a> {
     name: &'a str,
 }
 
+#[derive(serde::Deserialize)]
+struct NotificationRouteSettingsMetadata {
+    mute: bool,
+    volumes: Vec<f32>,
+}
+
 struct Proxies {
     devices: IntMap<
         PipewireId,
@@ -494,6 +539,7 @@ struct State {
     main_loop: MainLoopWeak,
     /// Handle events and exit the loop when `true` is returned.
     on_event: Box<dyn FnMut(Event)>,
+    route_settings_metadata_id: Option<u32>,
 }
 
 impl State {
@@ -860,6 +906,28 @@ impl State {
         }
     }
 
+    fn set_notification_settings(&self, volume: f32, mute: bool) {
+        if let Some((metadata, ..)) = self
+            .route_settings_metadata_id
+            .map(|id| self.proxies.metadata.get(id))
+            .flatten()
+        {
+            metadata.set_property(
+                0,
+                "restore.stream.Output/Audio.media.role:Notification",
+                Some("Spa:String:JSON"),
+                Some(
+                    &serde_json::json!({
+                        "mute": mute,
+                        "volumes": [volume.powi(3)],
+                        "channels": ["MONO"]
+                    })
+                    .to_string(),
+                ),
+            );
+        }
+    }
+
     fn device(&self, id: DeviceId) -> Option<&pipewire::device::Device> {
         self.proxies
             .devices
diff --git a/subscriptions/sound/src/lib.rs b/subscriptions/sound/src/lib.rs
@@ -114,15 +114,19 @@ pub struct Model {
 
     pub sink_volume_text: String,
     pub source_volume_text: String,
+    pub notification_volume_text: String,
     pub sink_balance: Option<f32>,
 
     pub sink_volume: u32,
     pub source_volume: u32,
+    pub notification_volume: u32,
 
     pub sink_mute: bool,
     sink_volume_debounce: bool,
     pub source_mute: bool,
     source_volume_debounce: bool,
+    pub notification_mute: bool,
+    notification_volume_debounce: bool,
 }
 
 impl Model {
@@ -354,6 +358,28 @@ impl Model {
         Task::none()
     }
 
+    pub fn set_notification_volume(&mut self, volume: u32) -> Task<Message> {
+        self.notification_volume = volume;
+        self.notification_volume_text = numtoa::BaseN::<10>::u32(volume).as_str().to_owned();
+        if self.notification_volume_debounce {
+            return Task::none();
+        }
+
+        self.notification_volume_debounce = true;
+        return cosmic::Task::future(async move {
+            tokio::time::sleep(Duration::from_millis(128)).await;
+            Message::NotificationVolumeApply().into()
+        });
+    }
+
+    pub fn toggle_notification_mute(&mut self) {
+        self.notification_mute = !self.notification_mute;
+        self.pipewire_send(pipewire::Request::SetNotification(
+            self.notification_volume as f32 / 100.0,
+            self.notification_mute,
+        ));
+    }
+
     pub fn update(&mut self, message: Message) -> Task<Message> {
         match message {
             Message::Server(events) => {
@@ -381,6 +407,15 @@ impl Model {
                 ));
             }
 
+            Message::NotificationVolumeApply() => {
+                self.notification_volume_debounce = false;
+                let new_volume = self.notification_volume as f32 / 100.0;
+                self.pipewire_send(pipewire::Request::SetNotification(
+                    new_volume,
+                    self.notification_mute,
+                ));
+            }
+
             Message::SubHandle(handle) => {
                 if let Some(handle) = Arc::into_inner(handle) {
                     self.subscription_handle = Some(handle);
@@ -393,6 +428,17 @@ impl Model {
 
     fn pipewire_update(&mut self, event: pipewire::Event) {
         match event {
+            pipewire::Event::NotificationVolume(volume, mute) => {
+                if self.notification_volume_debounce {
+                    return;
+                }
+
+                self.notification_mute = mute;
+                self.notification_volume = (volume * 100.0) as u32;
+                self.notification_volume_text = numtoa::BaseN::<10>::u32(self.notification_volume)
+                    .as_str()
+                    .to_owned();
+            }
             pipewire::Event::NodeProperties(id, props) => {
                 if self.active_sink_node == Some(id) {
                     if self.sink_volume_debounce {
@@ -849,6 +895,8 @@ pub enum Message {
     SinkVolumeApply(NodeId),
     /// Change the input volume.
     SourceVolumeApply(NodeId),
+    /// Change the notification volume.
+    NotificationVolumeApply(),
     /// On init of the subscription, channels for closing background threads are given to the app.
     SubHandle(Arc<SubscriptionHandle>),
 }
