nvrl/fluxo-rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

implemented library calls instead of cli calls
Release / Build and Release (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Nils Pukropp
2026-04-01 12:23:04 +02:00
parent f640f116ec
commit 2ce5aceae0
21 changed files with 1874 additions and 424 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/config.rs
+7 -2
View File
@@ -160,7 +160,6 @@ impl Default for PowerConfig {
#[derive(Deserialize)]
pub struct BudsConfig {
pub mac: String,
pub format: String,
pub format_disconnected: String,
}
@@ -168,7 +167,6 @@ pub struct BudsConfig {
impl Default for BudsConfig {
fn default() -> Self {
Self {
mac: "B4:23:A2:09:D3:53".to_string(),
format: "{left} | {right} | {anc}".to_string(),
format_disconnected: "<span size='large'></span>".to_string(),
}
@@ -197,6 +195,7 @@ impl Default for AudioConfig {
#[derive(Deserialize)]
pub struct BtConfig {
pub format_connected: String,
pub format_plugin: String,
pub format_disconnected: String,
pub format_disabled: String,
}
@@ -205,6 +204,7 @@ impl Default for BtConfig {
fn default() -> Self {
Self {
format_connected: "{alias} 󰂰".to_string(),
format_plugin: "{alias} [{left}|{right}] {anc} 󰂰".to_string(),
format_disconnected: "󰂯".to_string(),
format_disabled: "󰂲 Off".to_string(),
}
@@ -297,6 +297,11 @@ impl Config {
&["name", "icon"],
);
validate_format("bt.connected", &self.bt.format_connected, &["alias"]);
validate_format(
"bt.plugin",
&self.bt.format_plugin,
&["alias", "left", "right", "anc", "mac"],
);
}
}
src/daemon.rs
+18 -2
View File
@@ -1,6 +1,8 @@
use crate::config::Config;
use crate::ipc::socket_path;
use crate::modules::WaybarModule;
use crate::modules::audio::AudioDaemon;
use crate::modules::bt::BtDaemon;
use crate::modules::hardware::HardwareDaemon;
use crate::modules::network::NetworkDaemon;
use crate::state::{AppState, SharedState};
@@ -59,9 +61,15 @@ pub fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
info!("Starting background polling thread");
let mut network_daemon = NetworkDaemon::new();
let mut hardware_daemon = HardwareDaemon::new();
let mut bt_daemon = BtDaemon::new();
let audio_daemon = AudioDaemon::new();
audio_daemon.start(Arc::clone(&poll_state));
while poll_running.load(Ordering::SeqCst) {
network_daemon.poll(Arc::clone(&poll_state));
hardware_daemon.poll(Arc::clone(&poll_state));
bt_daemon.poll(Arc::clone(&poll_state));
thread::sleep(Duration::from_secs(1));
}
});
@@ -111,7 +119,16 @@ pub fn run_daemon(config_path: Option<PathBuf>) -> Result<()> {
let response =
handle_request(module_name, &parts[1..], &state_clone, &config_clone);
if let Err(e) = stream.write_all(response.as_bytes()) {
error!("Failed to write IPC response: {}", e);
if e.kind() == std::io::ErrorKind::BrokenPipe
|| e.kind() == std::io::ErrorKind::ConnectionReset
{
debug!(
"IPC client disconnected before response could be sent: {}",
e
);
} else {
error!("Failed to write IPC response: {}", e);
}
}
let _ = stream.shutdown(Shutdown::Write);
}
@@ -160,7 +177,6 @@ fn handle_request(
"gpu" => crate::modules::gpu::GpuModule.run(&config, state, args),
"sys" => crate::modules::sys::SysModule.run(&config, state, args),
"bt" | "bluetooth" => crate::modules::bt::BtModule.run(&config, state, args),
"buds" => crate::modules::buds::BudsModule.run(&config, state, args),
"power" => crate::modules::power::PowerModule.run(&config, state, args),
"game" => crate::modules::game::GameModule.run(&config, state, args),
_ => {
src/main.rs
+38 -15
View File
@@ -71,11 +71,6 @@ enum Commands {
#[arg(default_value = "show")]
action: String,
},
/// Pixel Buds Pro ANC and Battery
Buds {
#[arg(default_value = "show")]
action: String,
},
/// System power and battery status
Power,
/// Hyprland gamemode status
@@ -125,6 +120,27 @@ fn main() {
// Client-side execution of the menu
let config = config::load_config(None);
let mut items = Vec::new();
// If connected, show plugin modes and disconnect
if let Ok(json_str) = ipc::request_data("bt", &["get_modes"]) {
if let Ok(val) = serde_json::from_str::<serde_json::Value>(&json_str) {
if let Some(modes_str) = val.get("text").and_then(|t| t.as_str()) {
if !modes_str.is_empty() {
for mode in modes_str.lines() {
items.push(format!("Mode: {}", mode));
}
}
}
}
}
if !items.is_empty() {
items.push("Disconnect".to_string());
}
items.push("--- Connect Device ---".to_string());
let devices_out = match std::process::Command::new("bluetoothctl")
.args(["devices"])
.output()
@@ -137,7 +153,6 @@ fn main() {
};
let stdout = String::from_utf8_lossy(&devices_out.stdout);
let mut items = Vec::new();
for line in stdout.lines() {
if line.starts_with("Device ") {
let parts: Vec<&str> = line.splitn(3, ' ').collect();
@@ -149,23 +164,31 @@ fn main() {
if !items.is_empty() {
if let Ok(selected) =
utils::show_menu("Connect BT: ", &items, &config.general.menu_command)
&& let Some(mac_start) = selected.rfind('(')
&& let Some(mac_end) = selected.rfind(')')
utils::show_menu("BT Menu: ", &items, &config.general.menu_command)
{
let mac = &selected[mac_start + 1..mac_end];
let _ = std::process::Command::new("bluetoothctl")
.args(["connect", mac])
.status();
if selected.starts_with("Mode: ") {
let mode = &selected[6..];
handle_ipc_response(ipc::request_data("bt", &["set_mode", mode]));
} else if selected == "Disconnect" {
handle_ipc_response(ipc::request_data("bt", &["disconnect"]));
} else if selected == "--- Connect Device ---" {
// Do nothing
} else if let Some(mac_start) = selected.rfind('(')
&& let Some(mac_end) = selected.rfind(')')
{
let mac = &selected[mac_start + 1..mac_end];
let _ = std::process::Command::new("bluetoothctl")
.args(["connect", mac])
.status();
}
}
} else {
info!("No paired Bluetooth devices found.");
info!("No Bluetooth options found.");
}
return;
}
handle_ipc_response(ipc::request_data("bt", &[action]));
}
Commands::Buds { action } => handle_ipc_response(ipc::request_data("buds", &[action])),
Commands::Power => handle_ipc_response(ipc::request_data("power", &[])),
Commands::Game => handle_ipc_response(ipc::request_data("game", &[])),
}
src/modules/audio.rs
+216 -77
View File
@@ -2,55 +2,220 @@ use crate::config::Config;
use crate::modules::WaybarModule;
use crate::output::WaybarOutput;
use crate::state::SharedState;
use crate::utils::{TokenValue, format_template, run_command};
use crate::utils::{TokenValue, format_template};
use anyhow::{Result, anyhow};
use libpulse_binding::callbacks::ListResult;
use libpulse_binding::context::subscribe::{Facility, InterestMaskSet};
use libpulse_binding::context::{Context, FlagSet as ContextFlag};
use libpulse_binding::mainloop::threaded::Mainloop as ThreadedMainloop;
use libpulse_binding::volume::Volume;
use std::process::Command;
use std::sync::Arc;
use tracing::error;
pub struct AudioDaemon;
impl AudioDaemon {
pub fn new() -> Self {
Self
}
pub fn start(&self, state: SharedState) {
let state_arc = Arc::clone(&state);
std::thread::spawn(move || {
let mut mainloop =
ThreadedMainloop::new().expect("Failed to create pulse threaded mainloop");
let mut context =
Context::new(&mainloop, "fluxo-rs").expect("Failed to create pulse context");
context
.connect(None, ContextFlag::NOFLAGS, None)
.expect("Failed to connect pulse context");
mainloop.start().expect("Failed to start pulse mainloop");
mainloop.lock();
// Wait for context to be ready
loop {
match context.get_state() {
libpulse_binding::context::State::Ready => break,
libpulse_binding::context::State::Failed
| libpulse_binding::context::State::Terminated => {
error!("Pulse context failed or terminated");
mainloop.unlock();
return;
}
_ => {
mainloop.unlock();
std::thread::sleep(Duration::from_millis(50));
mainloop.lock();
}
}
}
// Initial fetch
let _ = fetch_audio_data_sync(&mut context, &state_arc);
// Subscribe to events
let interest =
InterestMaskSet::SINK | InterestMaskSet::SOURCE | InterestMaskSet::SERVER;
context.subscribe(interest, |_| {});
let (tx, rx) = std::sync::mpsc::channel();
context.set_subscribe_callback(Some(Box::new(move |facility, _operation, _index| {
match facility {
Some(Facility::Sink) | Some(Facility::Source) | Some(Facility::Server) => {
let _ = tx.send(());
}
_ => {}
}
})));
mainloop.unlock();
// Background polling loop driven by events or a 2s fallback timeout
loop {
let _ = rx.recv_timeout(Duration::from_secs(2));
{
mainloop.lock();
let _ = fetch_audio_data_sync(&mut context, &state_arc);
mainloop.unlock();
}
}
});
}
}
use std::time::Duration;
fn fetch_audio_data_sync(context: &mut Context, state: &SharedState) -> Result<()> {
let state_inner = Arc::clone(state);
// We fetch all sinks and sources, and also server info to know defaults.
// The order doesn't strictly matter as long as we update correctly.
let st_server = Arc::clone(&state_inner);
context.introspect().get_server_info(move |info| {
let mut lock = st_server.write().unwrap();
lock.audio.sink.name = info
.default_sink_name
.as_ref()
.map(|s| s.to_string())
.unwrap_or_default();
lock.audio.source.name = info
.default_source_name
.as_ref()
.map(|s| s.to_string())
.unwrap_or_default();
});
let st_sink = Arc::clone(&state_inner);
context.introspect().get_sink_info_list(move |res| {
if let ListResult::Item(item) = res {
let mut lock = st_sink.write().unwrap();
// If this matches our default sink name, or if we don't have details for any yet
let is_default = item
.name
.as_ref()
.map(|s| s.to_string() == lock.audio.sink.name)
.unwrap_or(false);
if is_default {
lock.audio.sink.description = item
.description
.as_ref()
.map(|s| s.to_string())
.unwrap_or_default();
lock.audio.sink.volume =
((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
lock.audio.sink.muted = item.mute;
}
}
});
let st_source = Arc::clone(&state_inner);
context.introspect().get_source_info_list(move |res| {
if let ListResult::Item(item) = res {
let mut lock = st_source.write().unwrap();
let is_default = item
.name
.as_ref()
.map(|s| s.to_string() == lock.audio.source.name)
.unwrap_or(false);
if is_default {
lock.audio.source.description = item
.description
.as_ref()
.map(|s| s.to_string())
.unwrap_or_default();
lock.audio.source.volume =
((item.volume.avg().0 as f64 / Volume::NORMAL.0 as f64) * 100.0).round() as u8;
lock.audio.source.muted = item.mute;
}
}
});
Ok(())
}
pub struct AudioModule;
impl WaybarModule for AudioModule {
fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
fn run(&self, config: &Config, state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
let target_type = args.first().unwrap_or(&"sink");
let action = args.get(1).unwrap_or(&"show");
match *action {
"cycle" => {
self.cycle_device(target_type)?;
Ok(WaybarOutput {
text: String::new(),
tooltip: None,
class: None,
percentage: None,
})
Ok(WaybarOutput::default())
}
"show" => self.get_status(config, target_type),
"show" => self.get_status(config, state, target_type),
other => Err(anyhow!("Unknown audio action: '{}'", other)),
}
}
}
impl AudioModule {
fn get_status(&self, config: &Config, target_type: &str) -> Result<WaybarOutput> {
let target = if target_type == "sink" {
"@DEFAULT_AUDIO_SINK@"
} else {
"@DEFAULT_AUDIO_SOURCE@"
fn get_status(
&self,
config: &Config,
state: &SharedState,
target_type: &str,
) -> Result<WaybarOutput> {
let audio_state = {
let lock = state.read().unwrap();
lock.audio.clone()
};
let stdout = run_command("wpctl", &["get-volume", target])?;
let (name, description, volume, muted) = if target_type == "sink" {
(
audio_state.sink.name,
audio_state.sink.description,
audio_state.sink.volume,
audio_state.sink.muted,
)
} else {
(
audio_state.source.name,
audio_state.source.description,
audio_state.source.volume,
audio_state.source.muted,
)
};
let parts: Vec<&str> = stdout.split_whitespace().collect();
if parts.len() < 2 {
return Err(anyhow!("Could not parse wpctl output: {}", stdout));
if name.is_empty() {
// Fallback if daemon hasn't populated state yet
return Ok(WaybarOutput {
text: "Audio Loading...".to_string(),
..Default::default()
});
}
let vol_val: f64 = parts[1].parse().unwrap_or(0.0);
let vol = (vol_val * 100.0).round() as u8;
let display_vol = std::cmp::min(vol, 100);
let muted = stdout.contains("[MUTED]");
let description = self.get_description(target_type)?;
let name = if description.len() > 20 {
let display_name = if description.len() > 20 {
format!("{}...", &description[..17])
} else {
description.clone()
@@ -66,16 +231,16 @@ impl AudioModule {
let t = format_template(
format_str,
&[
("name", TokenValue::String(&name)),
("icon", TokenValue::String(icon)),
("name", TokenValue::String(display_name)),
("icon", TokenValue::String(icon.to_string())),
],
);
(t, "muted")
} else {
let icon = if target_type == "sink" {
if display_vol <= 30 {
if volume <= 30 {
""
} else if display_vol <= 60 {
} else if volume <= 60 {
""
} else {
""
@@ -91,9 +256,9 @@ impl AudioModule {
let t = format_template(
format_str,
&[
("name", TokenValue::String(&name)),
("icon", TokenValue::String(icon)),
("volume", TokenValue::Int(display_vol as i64)),
("name", TokenValue::String(display_name)),
("icon", TokenValue::String(icon.to_string())),
("volume", TokenValue::Int(volume as i64)),
],
);
(t, "unmuted")
@@ -103,52 +268,32 @@ impl AudioModule {
text,
tooltip: Some(description),
class: Some(class.to_string()),
percentage: Some(display_vol),
percentage: Some(volume),
})
}
fn get_description(&self, target_type: &str) -> Result<String> {
let info_stdout = run_command("pactl", &["info"])?;
let search_key = if target_type == "sink" {
"Default Sink:"
} else {
"Default Source:"
};
let default_dev = info_stdout
.lines()
.find(|l| l.contains(search_key))
.and_then(|l| l.split(':').nth(1))
.map(|s| s.trim())
.ok_or_else(|| anyhow!("Default {} not found", target_type))?;
let list_cmd = if target_type == "sink" {
"sinks"
} else {
"sources"
};
let list_stdout = run_command("pactl", &["list", list_cmd])?;
let mut current_name = String::new();
for line in list_stdout.lines() {
if line.trim().starts_with("Name: ") {
current_name = line.split(':').nth(1).unwrap_or("").trim().to_string();
}
if current_name == default_dev && line.trim().starts_with("Description: ") {
return Ok(line.split(':').nth(1).unwrap_or("").trim().to_string());
}
}
Ok(default_dev.to_string())
}
fn cycle_device(&self, target_type: &str) -> Result<()> {
// Keep using pactl for cycling for now as it's a rare action
// but we could also implement it natively later.
let set_cmd = if target_type == "sink" {
"set-default-sink"
} else {
"set-default-source"
};
// We need to find the "next" device.
// For simplicity, let's keep the CLI version for now or refactor later.
// The user asked for "step by step".
let list_cmd = if target_type == "sink" {
"sinks"
} else {
"sources"
};
let stdout = run_command("pactl", &["list", "short", list_cmd])?;
let output = Command::new("pactl")
.args(["list", "short", list_cmd])
.output()?;
let stdout = String::from_utf8_lossy(&output.stdout);
let devices: Vec<String> = stdout
.lines()
@@ -171,13 +316,13 @@ impl AudioModule {
return Ok(());
}
let info_stdout = run_command("pactl", &["info"])?;
let info_output = Command::new("pactl").args(["info"]).output()?;
let info_stdout = String::from_utf8_lossy(&info_output.stdout);
let search_key = if target_type == "sink" {
"Default Sink:"
} else {
"Default Source:"
};
let current_dev = info_stdout
.lines()
.find(|l| l.contains(search_key))
@@ -189,13 +334,7 @@ impl AudioModule {
let next_index = (current_index + 1) % devices.len();
let next_dev = &devices[next_index];
let set_cmd = if target_type == "sink" {
"set-default-sink"
} else {
"set-default-source"
};
Command::new("pactl").args([set_cmd, next_dev]).status()?;
Ok(())
}
}
src/modules/bt.rs
+562 -72
View File
@@ -1,34 +1,545 @@
use crate::config::Config;
use crate::modules::WaybarModule;
use crate::output::WaybarOutput;
use crate::state::SharedState;
use crate::utils::{TokenValue, format_template, run_command};
use anyhow::Result;
use crate::state::{BtState, SharedState};
use crate::utils::{TokenValue, format_template};
use anyhow::{Context, Result};
use futures::StreamExt;
use std::collections::HashMap;
use std::process::Command;
use std::sync::{Arc, LazyLock, Mutex};
use std::time::{Duration, Instant};
use tokio::sync::mpsc;
use tracing::{debug, error, info, warn};
// Maestro imports
#[allow(unused_imports)]
use maestro::protocol::codec::Codec;
#[allow(unused_imports)]
use maestro::pwrpc::client::{Client, ClientHandle};
#[allow(unused_imports)]
use maestro::service::MaestroService;
#[allow(unused_imports)]
use maestro::service::settings::{self, Setting, SettingValue};
static RUNTIME: LazyLock<tokio::runtime::Runtime> = LazyLock::new(|| {
tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("Failed to create BT tokio runtime")
});
#[derive(Clone, Default)]
struct BudsStatus {
left_battery: Option<u8>,
right_battery: Option<u8>,
case_battery: Option<u8>,
anc_state: String,
#[allow(dead_code)]
last_update: Option<Instant>,
error: Option<String>,
}
enum BudsCommand {
SetAnc(String),
}
enum ManagerCommand {
EnsureTask(String),
SendCommand(String, BudsCommand),
}
struct MaestroManager {
statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
management_tx: mpsc::UnboundedSender<ManagerCommand>,
}
impl MaestroManager {
fn new() -> Self {
let (tx, mut rx) = mpsc::unbounded_channel::<ManagerCommand>();
let statuses = Arc::new(Mutex::new(HashMap::new()));
let statuses_clone = Arc::clone(&statuses);
// Start dedicated BT management thread
std::thread::spawn(move || {
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.unwrap();
let local = tokio::task::LocalSet::new();
local.block_on(&rt, async move {
let mut command_txs: HashMap<String, mpsc::Sender<BudsCommand>> = HashMap::new();
loop {
tokio::select! {
Some(cmd) = rx.recv() => {
match cmd {
ManagerCommand::EnsureTask(mac) => {
if !command_txs.contains_key(&mac) {
let (tx, buds_rx) = mpsc::channel::<BudsCommand>(10);
command_txs.insert(mac.clone(), tx);
let mac_clone = mac.clone();
let st_clone = Arc::clone(&statuses_clone);
tokio::task::spawn_local(async move {
if let Err(e) = buds_task(&mac_clone, st_clone, buds_rx).await {
error!("Buds task for {} failed: {}", mac_clone, e);
}
});
}
}
ManagerCommand::SendCommand(mac, buds_cmd) => {
if let Some(tx) = command_txs.get(&mac) {
let _ = tx.try_send(buds_cmd);
}
}
}
}
_ = tokio::time::sleep(Duration::from_millis(100)) => {
// Cleanup dropped tasks if needed
}
}
}
});
});
Self {
statuses,
management_tx: tx,
}
}
fn get_status(&self, mac: &str) -> BudsStatus {
let statuses = self.statuses.lock().unwrap();
statuses.get(mac).cloned().unwrap_or_default()
}
fn ensure_task(&self, mac: &str) {
let _ = self
.management_tx
.send(ManagerCommand::EnsureTask(mac.to_string()));
}
fn send_command(&self, mac: &str, cmd: BudsCommand) -> Result<()> {
self.ensure_task(mac);
let _ = self
.management_tx
.send(ManagerCommand::SendCommand(mac.to_string(), cmd));
Ok(())
}
}
async fn buds_task(
mac: &str,
statuses: Arc<Mutex<HashMap<String, BudsStatus>>>,
mut rx: mpsc::Receiver<BudsCommand>,
) -> Result<()> {
info!("Starting native Maestro connection task for {}", mac);
loop {
let addr: bluer::Address = mac.parse().context("Failed to parse MAC address")?;
let session = bluer::Session::new()
.await
.context("Failed to create bluer session")?;
let adapter = session
.default_adapter()
.await
.context("Failed to get default adapter")?;
let device = adapter
.device(addr)
.context("Failed to get device handle")?;
if !device.is_connected().await.unwrap_or(false) {
debug!("Device {} not connected to BT, stopping maestro task", mac);
break;
}
// Connect to Maestro RFCOMM service
// We try channel 1 then 2, which covers most Pixel Buds variants.
let mut stream = None;
for channel in [1, 2] {
let socket = match bluer::rfcomm::Socket::new() {
Ok(s) => s,
Err(e) => {
error!("Failed to create RFCOMM socket: {}", e);
return Err(e.into());
}
};
let target = bluer::rfcomm::SocketAddr::new(addr, channel);
debug!(
"Trying to connect RFCOMM to {} on channel {}...",
mac, channel
);
match socket.connect(target).await {
Ok(s) => {
stream = Some(s);
break;
}
Err(e) => {
debug!("Failed to connect to channel {}: {}", channel, e);
}
}
}
let stream = match stream {
Some(s) => s,
None => {
warn!(
"Failed to connect RFCOMM to {} on any common channel. Retrying in 15s...",
mac
);
tokio::time::sleep(Duration::from_secs(15)).await;
continue;
}
};
info!("Connected Maestro RFCOMM to {} on channel", mac);
// Initialize Maestro communication stack
let codec = Codec::new();
let stream = codec.wrap(stream);
let mut client = Client::new(stream);
let handle = client.handle();
// Resolve Maestro channel (typically 1 or 2)
let channel = match maestro::protocol::utils::resolve_channel(&mut client).await {
Ok(c) => c,
Err(e) => {
error!("Failed to resolve Maestro channel for {}: {}", mac, e);
continue;
}
};
// Run client in background to handle RPC packets
tokio::spawn(async move {
if let Err(e) = client.run().await {
error!("Maestro client loop error: {}", e);
}
});
let mut service = MaestroService::new(handle, channel);
// Query initial ANC state
if let Ok(val) = service
.read_setting_var(settings::SettingId::CurrentAncrState)
.await
{
if let SettingValue::CurrentAncrState(anc_state) = val {
let mut status = MAESTRO.get_status(mac);
status.anc_state = anc_state_to_string(&anc_state);
statuses.lock().unwrap().insert(mac.to_string(), status);
}
}
// Subscribe to real-time status updates (battery, ANC, wear)
let mut call = match service.subscribe_to_runtime_info() {
Ok(c) => c,
Err(e) => {
error!("Failed to subscribe to runtime info for {}: {}", mac, e);
continue;
}
};
let mut runtime_info = call.stream();
debug!("Subscribed to runtime info for {}", mac);
loop {
tokio::select! {
cmd = rx.recv() => {
match cmd {
Some(BudsCommand::SetAnc(mode)) => {
debug!("Setting ANC mode to {} for {}", mode, mac);
let state = mode_to_anc_state(&mode);
let val = SettingValue::CurrentAncrState(state);
if let Err(e) = service.write_setting(val).await {
error!("Failed to write ANC setting for {}: {}", mac, e);
}
}
None => return Ok(()),
}
}
Some(Ok(info)) = runtime_info.next() => {
let mut status = MAESTRO.get_status(mac);
status.last_update = Some(Instant::now());
if let Some(bat) = info.battery_info {
status.left_battery = bat.left.map(|b| b.level as u8);
status.right_battery = bat.right.map(|b| b.level as u8);
status.case_battery = bat.case.map(|b| b.level as u8);
}
statuses.lock().unwrap().insert(mac.to_string(), status);
}
_ = tokio::time::sleep(Duration::from_secs(30)) => {
// Check if still connected to BT
if !device.is_connected().await.unwrap_or(false) {
break;
}
}
}
}
if !device.is_connected().await.unwrap_or(false) {
break;
}
}
Ok(())
}
fn mode_to_anc_state(mode: &str) -> settings::AncState {
match mode {
"active" => settings::AncState::Active,
"aware" => settings::AncState::Aware,
"off" => settings::AncState::Off,
_ => settings::AncState::Off,
}
}
fn anc_state_to_string(state: &settings::AncState) -> String {
match state {
settings::AncState::Active => "active".to_string(),
settings::AncState::Aware => "aware".to_string(),
settings::AncState::Off => "off".to_string(),
_ => "unknown".to_string(),
}
}
static MAESTRO: LazyLock<MaestroManager> = LazyLock::new(MaestroManager::new);
pub struct BtDaemon {
session: Option<bluer::Session>,
}
impl BtDaemon {
pub fn new() -> Self {
Self { session: None }
}
pub fn poll(&mut self, state: SharedState) {
if let Err(e) = RUNTIME.block_on(self.poll_async(state)) {
error!("BT daemon error: {}", e);
}
}
async fn poll_async(&mut self, state: SharedState) -> Result<()> {
if self.session.is_none() {
self.session = Some(bluer::Session::new().await?);
}
let session = self.session.as_ref().unwrap();
let adapter = session.default_adapter().await?;
let adapter_powered = adapter.is_powered().await.unwrap_or(false);
let mut bt_state = BtState {
adapter_powered,
..Default::default()
};
if adapter_powered {
let devices = adapter.device_addresses().await?;
for addr in devices {
let device = adapter.device(addr)?;
if device.is_connected().await.unwrap_or(false) {
let uuids = device.uuids().await?.unwrap_or_default();
// Audio sink UUID (0x110b)
let audio_sink_uuid =
bluer::Uuid::from_u128(0x0000110b_0000_1000_8000_00805f9b34fb);
if uuids.contains(&audio_sink_uuid) {
bt_state.connected = true;
bt_state.device_address = addr.to_string();
bt_state.device_alias =
device.alias().await.unwrap_or_else(|_| addr.to_string());
bt_state.battery_percentage =
device.battery_percentage().await.unwrap_or(None);
// Plugin detection
for p in PLUGINS.iter() {
if p.can_handle(&bt_state.device_alias, &bt_state.device_address) {
match p.get_data(&bt_state.device_address) {
Ok(data) => {
bt_state.plugin_data = data
.into_iter()
.map(|(k, v)| {
let val_str = match v {
TokenValue::String(s) => s,
TokenValue::Int(i) => i.to_string(),
TokenValue::Float(f) => format!("{:.1}", f),
};
(k, val_str)
})
.collect();
}
Err(e) => {
warn!("Plugin {} failed for {}: {}", p.name(), addr, e);
bt_state
.plugin_data
.push(("plugin_error".to_string(), e.to_string()));
}
}
break;
}
}
break;
}
}
}
}
if let Ok(mut lock) = state.write() {
lock.bluetooth = bt_state;
}
Ok(())
}
}
pub trait BtPlugin: Send + Sync {
fn name(&self) -> &str;
fn can_handle(&self, alias: &str, mac: &str) -> bool;
fn get_data(&self, mac: &str) -> Result<Vec<(String, TokenValue)>>;
fn get_modes(&self, _mac: &str) -> Result<Vec<String>> {
Ok(vec![])
}
fn set_mode(&self, _mode: &str, _mac: &str) -> Result<()> {
Ok(())
}
fn cycle_mode(&self, _mac: &str) -> Result<()> {
Ok(())
}
}
pub struct PixelBudsPlugin;
impl BtPlugin for PixelBudsPlugin {
fn name(&self) -> &str {
"Pixel Buds Pro"
}
fn can_handle(&self, alias: &str, _mac: &str) -> bool {
alias.contains("Pixel Buds Pro")
}
fn get_data(&self, mac: &str) -> Result<Vec<(String, TokenValue)>> {
MAESTRO.ensure_task(mac);
let status = MAESTRO.get_status(mac);
if let Some(err) = status.error {
return Err(anyhow::anyhow!(err));
}
let left_display = status
.left_battery
.map(|b| format!("{}%", b))
.unwrap_or_else(|| "---".to_string());
let right_display = status
.right_battery
.map(|b| format!("{}%", b))
.unwrap_or_else(|| "---".to_string());
let (anc_icon, class) = match status.anc_state.as_str() {
"active" => ("ANC", "anc-active"),
"aware" => ("Aware", "anc-aware"),
"off" => ("Off", "anc-off"),
_ => ("?", "anc-unknown"),
};
Ok(vec![
("left".to_string(), TokenValue::String(left_display)),
("right".to_string(), TokenValue::String(right_display)),
("anc".to_string(), TokenValue::String(anc_icon.to_string())),
(
"plugin_class".to_string(),
TokenValue::String(class.to_string()),
),
])
}
fn get_modes(&self, _mac: &str) -> Result<Vec<String>> {
Ok(vec![
"active".to_string(),
"aware".to_string(),
"off".to_string(),
])
}
fn set_mode(&self, mode: &str, mac: &str) -> Result<()> {
MAESTRO.send_command(mac, BudsCommand::SetAnc(mode.to_string()))
}
fn cycle_mode(&self, mac: &str) -> Result<()> {
let status = MAESTRO.get_status(mac);
let next_mode = match status.anc_state.as_str() {
"active" => "aware",
"aware" => "off",
_ => "active",
};
self.set_mode(next_mode, mac)
}
}
static PLUGINS: LazyLock<Vec<Box<dyn BtPlugin>>> =
LazyLock::new(|| vec![Box::new(PixelBudsPlugin)]);
pub struct BtModule;
impl WaybarModule for BtModule {
fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
fn run(&self, config: &Config, state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
let action = args.first().unwrap_or(&"show");
let bt_state = {
let lock = state.read().unwrap();
lock.bluetooth.clone()
};
if *action == "disconnect" {
if let Some(mac) = find_audio_device() {
match *action {
"disconnect" if bt_state.connected => {
let _ = Command::new("bluetoothctl")
.args(["disconnect", &mac])
.args(["disconnect", &bt_state.device_address])
.output();
return Ok(WaybarOutput::default());
}
return Ok(WaybarOutput {
text: String::new(),
tooltip: None,
class: None,
percentage: None,
});
"cycle_mode" if bt_state.connected => {
let plugin = PLUGINS
.iter()
.find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
if let Some(p) = plugin {
p.cycle_mode(&bt_state.device_address)?;
}
return Ok(WaybarOutput::default());
}
"get_modes" if bt_state.connected => {
let plugin = PLUGINS
.iter()
.find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
let modes = if let Some(p) = plugin {
p.get_modes(&bt_state.device_address)?
} else {
vec![]
};
return Ok(WaybarOutput {
text: modes.join("\n"),
..Default::default()
});
}
"set_mode" if bt_state.connected => {
if let Some(mode) = args.get(1) {
let plugin = PLUGINS
.iter()
.find(|p| p.can_handle(&bt_state.device_alias, &bt_state.device_address));
if let Some(p) = plugin {
p.set_mode(mode, &bt_state.device_address)?;
}
}
return Ok(WaybarOutput::default());
}
"show" => {}
_ => {}
}
if let Ok(stdout) = run_command("bluetoothctl", &["show"])
&& stdout.contains("Powered: no")
{
if !bt_state.adapter_powered {
return Ok(WaybarOutput {
text: config.bt.format_disabled.clone(),
tooltip: Some("Bluetooth Disabled".to_string()),
@@ -37,46 +548,54 @@ impl WaybarModule for BtModule {
});
}
if let Some(mac) = find_audio_device() {
let info = run_command("bluetoothctl", &["info", &mac])?;
if bt_state.connected {
let mut tokens: Vec<(String, TokenValue)> = vec![
(
"alias".to_string(),
TokenValue::String(bt_state.device_alias.clone()),
),
(
"mac".to_string(),
TokenValue::String(bt_state.device_address.clone()),
),
];
let mut alias = mac.clone();
let mut battery = None;
let mut trusted = "no";
let mut class = vec!["connected".to_string()];
let mut has_plugin = false;
for line in info.lines() {
if line.contains("Alias:") {
alias = line.split("Alias:").nth(1).unwrap_or("").trim().to_string();
} else if line.contains("Battery Percentage:") {
if let Some(bat_str) = line.split('(').nth(1).and_then(|s| s.split(')').next())
{
battery = bat_str.parse::<u8>().ok();
}
} else if line.contains("Trusted: yes") {
trusted = "yes";
for (k, v) in &bt_state.plugin_data {
if k == "plugin_class" {
class.push(v.clone());
has_plugin = true;
} else if k == "plugin_error" {
class.push("plugin-error".to_string());
} else {
tokens.push((k.clone(), TokenValue::String(v.clone())));
}
}
let format = if has_plugin {
&config.bt.format_plugin
} else {
&config.bt.format_connected
};
let text = format_template(format, &tokens);
let tooltip = format!(
"{} | MAC: {}\nTrusted: {} | Bat: {}",
alias,
mac,
trusted,
battery
"{} | MAC: {}\nBattery: {}",
bt_state.device_alias,
bt_state.device_address,
bt_state
.battery_percentage
.map(|b| format!("{}%", b))
.unwrap_or_else(|| "N/A".to_string())
);
let text = format_template(
&config.bt.format_connected,
&[("alias", TokenValue::String(&alias))],
);
Ok(WaybarOutput {
text,
tooltip: Some(tooltip),
class: Some("connected".to_string()),
percentage: battery,
class: Some(class.join(" ")),
percentage: bt_state.battery_percentage,
})
} else {
Ok(WaybarOutput {
@@ -88,32 +607,3 @@ impl WaybarModule for BtModule {
}
}
}
fn find_audio_device() -> Option<String> {
if let Ok(sink) = run_command("pactl", &["get-default-sink"])
&& sink.starts_with("bluez_output.")
{
let parts: Vec<&str> = sink.split('.').collect();
if parts.len() >= 2 {
return Some(parts[1].replace('_', ":"));
}
}
if let Ok(stdout) = run_command("bluetoothctl", &["devices", "Connected"]) {
for line in stdout.lines() {
if line.starts_with("Device ") {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 2 {
let mac = parts[1];
if let Ok(info_str) = run_command("bluetoothctl", &["info", mac])
&& info_str.contains("0000110b-0000-1000-8000-00805f9b34fb")
{
return Some(mac.to_string());
}
}
}
}
}
None
}
src/modules/buds.rs
-136
View File
@@ -1,136 +0,0 @@
use crate::config::Config;
use crate::modules::WaybarModule;
use crate::output::WaybarOutput;
use crate::state::SharedState;
use crate::utils::{TokenValue, format_template, run_command};
use anyhow::Result;
pub struct BudsModule;
impl WaybarModule for BudsModule {
fn run(&self, config: &Config, _state: &SharedState, args: &[&str]) -> Result<WaybarOutput> {
let action = args.first().unwrap_or(&"show");
let mac = &config.buds.mac;
match *action {
"cycle_anc" => {
let current_mode = run_command("pbpctrl", &["get", "anc"])?;
let next_mode = match current_mode.as_str() {
"active" => "aware",
"aware" => "off",
_ => "active",
};
let _ = run_command("pbpctrl", &["set", "anc", next_mode]);
return Ok(WaybarOutput {
text: String::new(),
tooltip: None,
class: None,
percentage: None,
});
}
"connect" => {
let _ = run_command("bluetoothctl", &["connect", mac]);
return Ok(WaybarOutput {
text: String::new(),
tooltip: None,
class: None,
percentage: None,
});
}
"disconnect" => {
let _ = run_command("bluetoothctl", &["disconnect", mac]);
return Ok(WaybarOutput {
text: String::new(),
tooltip: None,
class: None,
percentage: None,
});
}
"show" => {}
other => {
return Err(anyhow::anyhow!("Unknown buds action: '{}'", other));
}
}
let bt_str = run_command("bluetoothctl", &["info", mac])?;
if !bt_str.contains("Connected: yes") {
return Ok(WaybarOutput {
text: config.buds.format_disconnected.clone(),
tooltip: Some("Pixel Buds Pro 2 not connected".to_string()),
class: Some("disconnected".to_string()),
percentage: None,
});
}
let bat_output = match run_command("pbpctrl", &["show", "battery"]) {
Ok(output) => output,
Err(_) => {
return Ok(WaybarOutput {
text: config.buds.format_disconnected.clone(),
tooltip: Some("Pixel Buds Pro 2 connected (No Data)".to_string()),
class: Some("disconnected".to_string()),
percentage: None,
});
}
};
let mut left_bud = "unknown";
let mut right_bud = "unknown";
for line in bat_output.lines() {
if line.contains("left bud:") {
left_bud = line.split_whitespace().nth(2).unwrap_or("unknown");
} else if line.contains("right bud:") {
right_bud = line.split_whitespace().nth(2).unwrap_or("unknown");
}
}
if left_bud == "unknown" && right_bud == "unknown" {
return Ok(WaybarOutput {
text: "{}".to_string(),
tooltip: None,
class: None,
percentage: None,
});
}
let left_display = if left_bud == "unknown" {
"---".to_string()
} else {
format!("{}%", left_bud)
};
let right_display = if right_bud == "unknown" {
"---".to_string()
} else {
format!("{}%", right_bud)
};
let current_mode = run_command("pbpctrl", &["get", "anc"]).unwrap_or_default();
let (anc_icon, class) = match current_mode.as_str() {
"active" => ("ANC", "anc-active"),
"aware" => ("Aware", "anc-aware"),
"off" => ("Off", "anc-off"),
_ => ("?", "anc-unknown"),
};
let text = format_template(
&config.buds.format,
&[
("left", TokenValue::String(&left_display)),
("right", TokenValue::String(&right_display)),
("anc", TokenValue::String(anc_icon)),
],
);
Ok(WaybarOutput {
text,
tooltip: Some("Pixel Buds Pro 2".to_string()),
class: Some(class.to_string()),
percentage: None,
})
}
}
src/modules/disk.rs
+1 -1
View File
@@ -44,7 +44,7 @@ impl WaybarModule for DiskModule {
let text = format_template(
&config.disk.format,
&[
("mount", TokenValue::String(mountpoint)),
("mount", TokenValue::String(mountpoint.to_string())),
("used", TokenValue::Float(used_gb)),
("total", TokenValue::Float(total_gb)),
],
src/modules/game.rs
+19 -3
View File
@@ -2,14 +2,16 @@ use crate::config::Config;
use crate::modules::WaybarModule;
use crate::output::WaybarOutput;
use crate::state::SharedState;
use crate::utils::run_command;
use anyhow::Result;
use anyhow::{Result, anyhow};
use std::env;
use std::io::{Read, Write};
use std::os::unix::net::UnixStream;
pub struct GameModule;
impl WaybarModule for GameModule {
fn run(&self, config: &Config, _state: &SharedState, _args: &[&str]) -> Result<WaybarOutput> {
let is_gamemode = run_command("hyprctl", &["getoption", "animations:enabled", "-j"])
let is_gamemode = hyprland_ipc("j/getoption animations:enabled")
.map(|stdout| stdout.contains("\"int\": 0"))
.unwrap_or(false);
@@ -30,3 +32,17 @@ impl WaybarModule for GameModule {
}
}
}
fn hyprland_ipc(cmd: &str) -> Result<String> {
let signature = env::var("HYPRLAND_INSTANCE_SIGNATURE")
.map_err(|_| anyhow!("HYPRLAND_INSTANCE_SIGNATURE not set"))?;
let path = format!("/tmp/hypr/{}/.socket.sock", signature);
let mut stream = UnixStream::connect(path)?;
stream.write_all(cmd.as_bytes())?;
let mut response = String::new();
stream.read_to_string(&mut response)?;
Ok(response)
}
src/modules/hardware.rs
+31 -17
View File
@@ -20,7 +20,7 @@ impl HardwareDaemon {
components,
gpu_vendor: None,
gpu_poll_counter: 0,
disk_poll_counter: 0,
disk_poll_counter: 9, // Start at 9 to poll on the first tick
}
}
@@ -70,6 +70,32 @@ impl HardwareDaemon {
}
}
// 1. Gather GPU data outside of lock
let mut gpu_state = crate::state::GpuState::default();
self.gpu_poll_counter = (self.gpu_poll_counter + 1) % 5;
let should_poll_gpu = self.gpu_poll_counter == 0;
if should_poll_gpu {
self.poll_gpu(&mut gpu_state);
}
// 2. Gather Disk data outside of lock
let mut disks_data = None;
self.disk_poll_counter = (self.disk_poll_counter + 1) % 10;
if self.disk_poll_counter == 0 {
disks_data = Some(
Disks::new_with_refreshed_list()
.iter()
.map(|d| DiskInfo {
mount_point: d.mount_point().to_string_lossy().into_owned(),
filesystem: d.file_system().to_string_lossy().to_lowercase(),
total_bytes: d.total_space(),
available_bytes: d.available_space(),
})
.collect::<Vec<DiskInfo>>(),
);
}
// 3. Apply everything to state in one short lock
if let Ok(mut state_lock) = state.write() {
state_lock.cpu.usage = cpu_usage as f64;
state_lock.cpu.temp = cpu_temp;
@@ -84,24 +110,12 @@ impl HardwareDaemon {
state_lock.sys.uptime = uptime;
state_lock.sys.process_count = process_count;
// Poll GPU every 5 seconds to avoid expensive nvidia-smi calls
self.gpu_poll_counter = (self.gpu_poll_counter + 1) % 5;
if self.gpu_poll_counter == 0 {
self.poll_gpu(&mut state_lock.gpu);
if should_poll_gpu {
state_lock.gpu = gpu_state;
}
// Poll disks every 10 seconds
self.disk_poll_counter = (self.disk_poll_counter + 1) % 10;
if self.disk_poll_counter == 0 {
state_lock.disks = Disks::new_with_refreshed_list()
.iter()
.map(|d| DiskInfo {
mount_point: d.mount_point().to_string_lossy().into_owned(),
filesystem: d.file_system().to_string_lossy().to_lowercase(),
total_bytes: d.total_space(),
available_bytes: d.available_space(),
})
.collect();
if let Some(d) = disks_data {
state_lock.disks = d;
}
}
}
src/modules/mod.rs
-1
View File
@@ -1,7 +1,6 @@
pub mod audio;
pub mod bt;
pub mod btrfs;
pub mod buds;
pub mod cpu;
pub mod disk;
pub mod game;
src/modules/network.rs
+33 -40
View File
@@ -2,8 +2,9 @@ use crate::config::Config;
use crate::modules::WaybarModule;
use crate::output::WaybarOutput;
use crate::state::SharedState;
use crate::utils::{TokenValue, format_template, run_command};
use crate::utils::{TokenValue, format_template};
use anyhow::Result;
use nix::ifaddrs::getifaddrs;
use std::fs;
use std::time::{SystemTime, UNIX_EPOCH};
@@ -29,21 +30,18 @@ impl NetworkDaemon {
}
pub fn poll(&mut self, state: SharedState) {
// Cache invalidation: if the interface directory doesn't exist, clear cache
if let Some(ref iface) = self.cached_interface
&& !std::path::Path::new(&format!("/sys/class/net/{}", iface)).exists()
{
self.cached_interface = None;
self.cached_ip = None;
}
// Re-detect interface if needed
if self.cached_interface.is_none()
&& let Ok(iface) = get_primary_interface()
// Re-detect interface on every poll to catch VPNs or route changes immediately
if let Ok(iface) = get_primary_interface()
&& !iface.is_empty()
{
self.cached_ip = get_ip_address(&iface);
self.cached_interface = Some(iface);
// If the interface changed, or we don't have an IP yet, update the IP
if self.cached_interface.as_ref() != Some(&iface) || self.cached_ip.is_none() {
self.cached_ip = get_ip_address(&iface);
self.cached_interface = Some(iface);
}
} else {
self.cached_interface = None;
self.cached_ip = None;
}
if let Some(ref interface) = self.cached_interface {
@@ -123,8 +121,8 @@ impl WaybarModule for NetworkModule {
let mut output_text = format_template(
&config.network.format,
&[
("interface", TokenValue::String(&interface)),
("ip", TokenValue::String(ip_display)),
("interface", TokenValue::String(interface.clone())),
("ip", TokenValue::String(ip_display.to_string())),
("rx", TokenValue::Float(rx_mbps)),
("tx", TokenValue::Float(tx_mbps)),
],
@@ -134,6 +132,8 @@ impl WaybarModule for NetworkModule {
|| interface.starts_with("wg")
|| interface.starts_with("ppp")
|| interface.starts_with("pvpn")
|| interface.starts_with("proton")
|| interface.starts_with("ipsec")
{
output_text = format!(" {}", output_text);
}
@@ -148,24 +148,18 @@ impl WaybarModule for NetworkModule {
}
fn get_primary_interface() -> Result<String> {
let stdout = run_command("ip", &["route", "list"])?;
let content = fs::read_to_string("/proc/net/route")?;
let mut defaults = Vec::new();
for line in stdout.lines() {
if line.starts_with("default") {
let parts: Vec<&str> = line.split_whitespace().collect();
let mut dev = "";
let mut metric = 0;
for i in 0..parts.len() {
if parts[i] == "dev" && i + 1 < parts.len() {
dev = parts[i + 1];
}
if parts[i] == "metric" && i + 1 < parts.len() {
metric = parts[i + 1].parse::<i32>().unwrap_or(0);
}
}
if !dev.is_empty() {
defaults.push((metric, dev.to_string()));
for line in content.lines().skip(1) {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 7 {
let iface = parts[0];
let dest = parts[1];
let metric = parts[6].parse::<i32>().unwrap_or(0);
if dest == "00000000" {
defaults.push((metric, iface.to_string()));
}
}
}
@@ -179,14 +173,13 @@ fn get_primary_interface() -> Result<String> {
}
fn get_ip_address(interface: &str) -> Option<String> {
let stdout = run_command("ip", &["-4", "addr", "show", interface]).ok()?;
for line in stdout.lines() {
if line.trim().starts_with("inet ") {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() > 1 {
let ip_cidr = parts[1];
let ip = ip_cidr.split('/').next().unwrap_or(ip_cidr);
return Some(ip.to_string());
let addrs = getifaddrs().ok()?;
for ifaddr in addrs {
if ifaddr.interface_name == interface {
if let Some(address) = ifaddr.address {
if let Some(sockaddr) = address.as_sockaddr_in() {
return Some(sockaddr.ip().to_string());
}
}
}
}
src/modules/power.rs
+1 -1
View File
@@ -96,7 +96,7 @@ impl WaybarModule for PowerModule {
&config.power.format,
&[
("percentage", TokenValue::Int(percentage as i64)),
("icon", TokenValue::String(icon)),
("icon", TokenValue::String(icon.to_string())),
],
);
src/modules/sys.rs
+1 -1
View File
@@ -34,7 +34,7 @@ impl WaybarModule for SysModule {
let text = format_template(
&config.sys.format,
&[
("uptime", TokenValue::String(&uptime_str)),
("uptime", TokenValue::String(uptime_str.clone())),
("load1", TokenValue::Float(load1)),
("load5", TokenValue::Float(load5)),
("load15", TokenValue::Float(load15)),
src/output.rs
+11
View File
@@ -11,6 +11,17 @@ pub struct WaybarOutput {
pub percentage: Option<u8>,
}
impl Default for WaybarOutput {
fn default() -> Self {
Self {
text: String::new(),
tooltip: None,
class: None,
percentage: None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
src/state.rs
+34
View File
@@ -8,6 +8,40 @@ pub struct AppState {
pub sys: SysState,
pub gpu: GpuState,
pub disks: Vec<DiskInfo>,
pub bluetooth: BtState,
pub audio: AudioState,
}
#[derive(Default, Clone)]
pub struct AudioState {
pub sink: AudioDeviceInfo,
pub source: AudioSourceInfo,
}
#[derive(Default, Clone)]
pub struct AudioDeviceInfo {
pub name: String,
pub description: String,
pub volume: u8,
pub muted: bool,
}
#[derive(Default, Clone)]
pub struct AudioSourceInfo {
pub name: String,
pub description: String,
pub volume: u8,
pub muted: bool,
}
#[derive(Default, Clone)]
pub struct BtState {
pub connected: bool,
pub adapter_powered: bool,
pub device_alias: String,
pub device_address: String,
pub battery_percentage: Option<u8>,
pub plugin_data: Vec<(String, String)>,
}
#[derive(Default, Clone)]
src/test_pbpctrl.rs
+5
View File
@@ -0,0 +1,5 @@
use pbpctrl::Controller;
fn main() {
let _ = Controller::connect("AA:BB:CC:DD:EE:FF");
}
src/utils.rs
+21 -23
View File
@@ -2,20 +2,6 @@ use anyhow::{Context, Result};
use std::io::Write;
use std::process::{Command, Stdio};
/// Run an external command and return its stdout as a trimmed String.
/// Provides clear error messages when the command is not found or fails.
pub fn run_command(cmd: &str, args: &[&str]) -> Result<String> {
let output = Command::new(cmd)
.args(args)
.output()
.with_context(|| format!("'{}' not found or failed to execute. Is it installed?", cmd))?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr);
anyhow::bail!("'{}' exited with {}: {}", cmd, output.status, stderr.trim());
}
Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
}
pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<String> {
let cmd_str = menu_cmd.replace("{prompt}", prompt);
let mut child = Command::new("sh")
@@ -50,20 +36,23 @@ pub fn show_menu(prompt: &str, items: &[String], menu_cmd: &str) -> Result<Strin
use regex::Regex;
use std::sync::LazyLock;
pub enum TokenValue<'a> {
pub enum TokenValue {
Float(f64),
Int(i64),
String(&'a str),
String(String),
}
pub fn format_template(template: &str, values: &[(&str, TokenValue)]) -> String {
pub fn format_template<K>(template: &str, values: &[(K, TokenValue)]) -> String
where
K: AsRef<str>,
{
static RE: LazyLock<Regex> = LazyLock::new(|| {
Regex::new(r"\{([a-zA-Z0-9_]+)(?::([<>\^])?(\d+)?(?:\.(\d+))?)?\}").unwrap()
});
RE.replace_all(template, |caps: &regex::Captures| {
let name = &caps[1];
if let Some((_, val)) = values.iter().find(|(k, _)| *k == name) {
if let Some((_, val)) = values.iter().find(|(k, _)| k.as_ref() == name) {
let align = caps.get(2).map(|m| m.as_str()).unwrap_or(">");
let width = caps
.get(3)
@@ -121,7 +110,10 @@ mod tests {
#[test]
fn test_simple_string_token() {
let result = format_template("{name}", &[("name", TokenValue::String("hello"))]);
let result = format_template(
"{name}",
&[("name", TokenValue::String("hello".to_string()))],
);
assert_eq!(result, "hello");
}
@@ -166,14 +158,20 @@ mod tests {
#[test]
fn test_string_left_align() {
let result = format_template("{val:<10}", &[("val", TokenValue::String("hi"))]);
let result = format_template(
"{val:<10}",
&[("val", TokenValue::String("hi".to_string()))],
);
assert_eq!(result, "hi ");
assert_eq!(result.len(), 10);
}
#[test]
fn test_unknown_token_preserved() {
let result = format_template("{unknown}", &[("name", TokenValue::String("test"))]);
let result = format_template(
"{unknown}",
&[("name", TokenValue::String("test".to_string()))],
);
assert_eq!(result, "{unknown}");
}
@@ -206,8 +204,8 @@ mod tests {
let result = format_template(
"{name} ({ip}): {rx:>5.2} MB/s",
&[
("name", TokenValue::String("eth0")),
("ip", TokenValue::String("10.0.0.1")),
("name", TokenValue::String("eth0".to_string())),
("ip", TokenValue::String("10.0.0.1".to_string())),
("rx", TokenValue::Float(1.5)),
],
);