`968443b`

Refactor volume to use pactl, remove libpulse dependency

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 968443bea97038031d70f1b2e58bd27f19770a18
Parents: 925e1bb
Tree: 965f974

3 changed files

Status	File	+	-
M	`Cargo.toml`	0	3
M	`gartray/Cargo.toml`	0	3
M	`gartray/src/panel/volume.rs`	132	149

Cargo.tomlmodified

  anyhow = "1.0"
  thiserror = "1.0"
--# Audio (PulseAudio)
--libpulse-binding = "2.0"
--
  # Utilities
  dirs = "5.0"
  shellexpand = "3.0"

gartray/Cargo.tomlmodified

  anyhow = { workspace = true }
  thiserror = { workspace = true }
--# Audio
--libpulse-binding = { workspace = true }
--
  # Utilities
  dirs = { workspace = true }
  shellexpand = { workspace = true }

gartray/src/panel/volume.rsmodified

--//! Volume control module using PulseAudio
++//! Volume control module using pactl
  //!
  //! Provides volume slider and mute toggle for audio output.
++//! Uses pactl commands - works with both PulseAudio and PipeWire.
  use anyhow::{Context, Result};
--use libpulse_binding as pulse;
++use std::process::Command;
--use libpulse_binding::context::Context as PulseContext;
--use libpulse_binding::mainloop::standard::Mainloop;
--use libpulse_binding::context::subscribe::InterestMaskSet;
--use std::cell::RefCell;
--use std::rc::Rc;
--use std::sync::{Arc, Mutex};
  use tracing::{debug, info, warn};
  /// Volume state
      pub muted: bool,
      /// Sink name
      pub sink_name: String,
--    /// Sink description
--    pub sink_description: String,
+ }
--/// Volume module for controlling PulseAudio
++/// Volume module for controlling audio via pactl
  pub struct VolumeModule {
--    mainloop: Option<Rc<RefCell<Mainloop>>>,
++    state: VolumeState,
--    context: Option<Rc<RefCell<PulseContext>>>,
++    available: bool,
--    state: Arc<Mutex<VolumeState>>,
--    connected: bool,
+ }
  impl VolumeModule {
      /// Create a new volume module
      pub fn new() -> Self {
          Self {
--            mainloop: None,
++            state: VolumeState::default(),
--            context: None,
++            available: false,
--            state: Arc::new(Mutex::new(VolumeState::default())),
--            connected: false,
+         }
+     }
--    /// Connect to PulseAudio
++    /// Connect and check if pactl is available
      pub fn connect(&mut self) -> Result<()> {
--        let mainloop = Rc::new(RefCell::new(
++        // Check if pactl is available
--            Mainloop::new().context("Failed to create PulseAudio mainloop")?
++        let output = Command::new("pactl")
--        ));
++            .arg("--version")
--
++            .output()
--        let context = Rc::new(RefCell::new(
++            .context("pactl not found")?;
--            PulseContext::new(&*mainloop.borrow(), "gartray")
++
--                .context("Failed to create PulseAudio context")?
++        if !output.status.success() {
--        ));
++            anyhow::bail!("pactl not working");
--
--        // Connect
--        context.borrow_mut()
--            .connect(None, pulse::context::FlagSet::NOFLAGS, None)
--            .map_err(|_| anyhow::anyhow!("Failed to connect to PulseAudio"))?;
--
--        // Wait for connection
--        loop {
--            mainloop.borrow_mut().iterate(true);
--            match context.borrow().get_state() {
--                pulse::context::State::Ready => break,
--                pulse::context::State::Failed |
--                pulse::context::State::Terminated => {
--                    return Err(anyhow::anyhow!("PulseAudio connection failed"));
--                }
--                _ => {}
--            }
+         }
++        self.available = true;
          info!("Connected to PulseAudio");
--        self.mainloop = Some(mainloop);
--        self.context = Some(context);
--        self.connected = true;
          // Get initial state
          self.refresh()?;
          Ok(())
+     }
--    /// Refresh volume state from PulseAudio
++    /// Refresh volume state from pactl
      pub fn refresh(&mut self) -> Result<()> {
--        if !self.connected {
++        if !self.available {
              return Ok(());
+         }
--        let context = self.context.as_ref()
++        // Get default sink
--            .ok_or_else(|| anyhow::anyhow!("Not connected"))?;
++        if let Ok(sink) = self.get_default_sink() {
--        let mainloop = self.mainloop.as_ref()
++            self.state.sink_name = sink;
--            .ok_or_else(|| anyhow::anyhow!("No mainloop"))?;
++        }
++
++        // Get volume and mute state
++        if let Ok((volume, muted)) = self.get_sink_volume(&self.state.sink_name) {
++            self.state.volume = volume;
++            self.state.muted = muted;
++        }
--        let state = self.state.clone();
++        debug!("Volume: {:.0}%, muted: {}", self.state.volume * 100.0, self.state.muted);
++        Ok(())
++    }
--        // Get default sink info
++    /// Get the default sink name
--        let introspector = context.borrow().introspect();
++    fn get_default_sink(&self) -> Result<String> {
--        let op = introspector.get_server_info(move |info| {
++        let output = Command::new("pactl")
--            if let Some(default_sink) = &info.default_sink_name {
++            .args(["get-default-sink"])
--                let mut s = state.lock().unwrap();
++            .output()
--                s.sink_name = default_sink.to_string();
++            .context("Failed to get default sink")?;
--            }
++
--        });
++        if output.status.success() {
--
++            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
--        // Wait for operation
++        } else {
--        while op.get_state() == pulse::operation::State::Running {
++            anyhow::bail!("pactl get-default-sink failed")
--            mainloop.borrow_mut().iterate(true);
++        }
--        }
++    }
--
++
--        // Now get sink details
++    /// Get volume and mute state for a sink
--        let state = self.state.clone();
++    fn get_sink_volume(&self, sink: &str) -> Result<(f64, bool)> {
--        let sink_name = {
++        // Get volume
--            let s = state.lock().unwrap();
++        let output = Command::new("pactl")
--            s.sink_name.clone()
++            .args(["get-sink-volume", sink])
--        };
++            .output()
--
++            .context("Failed to get sink volume")?;
--        if !sink_name.is_empty() {
++
--            let introspector = context.borrow().introspect();
++        let mut volume = 0.5;
--            let op = introspector.get_sink_info_by_name(&sink_name, move |result| {
++        if output.status.success() {
--                if let pulse::callbacks::ListResult::Item(sink) = result {
++            let stdout = String::from_utf8_lossy(&output.stdout);
--                    let mut s = state.lock().unwrap();
++            // Parse output like "Volume: front-left: 65536 / 100% / 0.00 dB, ..."
--                    s.muted = sink.mute;
++            if let Some(pct) = stdout.split('/').nth(1) {
--                    if let Some(desc) = &sink.description {
++                if let Some(num) = pct.trim().strip_suffix('%') {
--                        s.sink_description = desc.to_string();
++                    if let Ok(v) = num.trim().parse::<f64>() {
++                        volume = v / 100.0;
+                     }
--                    // Calculate average volume
--                    let vol = sink.volume.avg().0 as f64 / pulse::volume::Volume::NORMAL.0 as f64;
--                    s.volume = vol.min(1.5); // Cap at 150%
--                    debug!("Volume: {:.0}%, muted: {}", s.volume * 100.0, s.muted);
+                 }
--            });
--
--            while op.get_state() == pulse::operation::State::Running {
--                mainloop.borrow_mut().iterate(true);
+             }
+         }
--        Ok(())
++        // Get mute state
++        let output = Command::new("pactl")
++            .args(["get-sink-mute", sink])
++            .output()
++            .context("Failed to get sink mute")?;
++
++        let mut muted = false;
++        if output.status.success() {
++            let stdout = String::from_utf8_lossy(&output.stdout);
++            muted = stdout.contains("yes");
++        }
++
++        Ok((volume, muted))
+     }
      /// Set volume (0.0 - 1.0)
      pub fn set_volume(&mut self, volume: f64) -> Result<()> {
--        if !self.connected {
++        if !self.available {
              return Ok(());
+         }
--        let context = self.context.as_ref()
++        let sink = &self.state.sink_name;
--            .ok_or_else(|| anyhow::anyhow!("Not connected"))?;
++        if sink.is_empty() {
--        let mainloop = self.mainloop.as_ref()
--            .ok_or_else(|| anyhow::anyhow!("No mainloop"))?;
--
--        let sink_name = {
--            let s = self.state.lock().unwrap();
--            s.sink_name.clone()
--        };
--
--        if sink_name.is_empty() {
              return Ok(());
+         }
--        // Convert to PulseAudio volume
++        // Convert to percentage
--        let pa_vol = (volume.clamp(0.0, 1.5) * pulse::volume::Volume::NORMAL.0 as f64) as u32;
++        let pct = (volume.clamp(0.0, 1.5) * 100.0) as u32;
--        let mut channel_vol = pulse::volume::ChannelVolumes::default();
++        let volume_str = format!("{}%", pct);
--        channel_vol.set(2, pulse::volume::Volume(pa_vol));
--        let mut introspector = context.borrow().introspect();
++        let status = Command::new("pactl")
--        let op = introspector.set_sink_volume_by_name(&sink_name, &channel_vol, None);
++            .args(["set-sink-volume", sink, &volume_str])
--
++            .status()
--        while op.get_state() == pulse::operation::State::Running {
++            .context("Failed to set volume")?;
--            mainloop.borrow_mut().iterate(true);
--        }
--        // Update local state
++        if status.success() {
--        {
++            self.state.volume = volume;
--            let mut s = self.state.lock().unwrap();
++            debug!("Set volume to {:.0}%", volume * 100.0);
--            s.volume = volume;
++        } else {
++            warn!("pactl set-sink-volume failed");
+         }
--        debug!("Set volume to {:.0}%", volume * 100.0);
          Ok(())
+     }
      /// Toggle mute
      pub fn toggle_mute(&mut self) -> Result<()> {
--        if !self.connected {
++        if !self.available {
              return Ok(());
+         }
--        let context = self.context.as_ref()
++        let sink = &self.state.sink_name;
--            .ok_or_else(|| anyhow::anyhow!("Not connected"))?;
++        if sink.is_empty() {
--        let mainloop = self.mainloop.as_ref()
++            return Ok(());
--            .ok_or_else(|| anyhow::anyhow!("No mainloop"))?;
++        }
--        let (sink_name, muted) = {
++        let status = Command::new("pactl")
--            let s = self.state.lock().unwrap();
++            .args(["set-sink-mute", sink, "toggle"])
--            (s.sink_name.clone(), s.muted)
++            .status()
--        };
++            .context("Failed to toggle mute")?;
--        if sink_name.is_empty() {
++        if status.success() {
--            return Ok(());
++            self.state.muted = !self.state.muted;
++            debug!("Mute toggled to {}", self.state.muted);
++        } else {
++            warn!("pactl set-sink-mute failed");
+         }
--        let mut introspector = context.borrow().introspect();
++        Ok(())
--        let op = introspector.set_sink_mute_by_name(&sink_name, !muted, None);
++    }
++
++    /// Set mute state
++    pub fn set_mute(&mut self, muted: bool) -> Result<()> {
++        if !self.available {
++            return Ok(());
++        }
--        while op.get_state() == pulse::operation::State::Running {
++        let sink = &self.state.sink_name;
--            mainloop.borrow_mut().iterate(true);
++        if sink.is_empty() {
++            return Ok(());
+         }
--        // Update local state
++        let mute_str = if muted { "1" } else { "0" };
--        {
++
--            let mut s = self.state.lock().unwrap();
++        let status = Command::new("pactl")
--            s.muted = !muted;
++            .args(["set-sink-mute", sink, mute_str])
++            .status()
++            .context("Failed to set mute")?;
++
++        if status.success() {
++            self.state.muted = muted;
+         }
--        debug!("Mute toggled to {}", !muted);
          Ok(())
+     }
      /// Get current state
      pub fn state(&self) -> VolumeState {
--        self.state.lock().unwrap().clone()
++        self.state.clone()
+     }
--    /// Check if connected
++    /// Check if available
--    pub fn is_connected(&self) -> bool {
++    pub fn is_available(&self) -> bool {
--        self.connected
++        self.available
+     }
+ }
--impl Drop for VolumeModule {
++impl Default for VolumeModule {
--    fn drop(&mut self) {
++    fn default() -> Self {
--        if let Some(context) = &self.context {
++        Self::new()
--            context.borrow_mut().disconnect();
--        }
+     }
+ }