jmb05/jmb-bar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clippy

Browse Source
This commit is contained in:
jmb05
2026-10-25 00:02:36 +02:00
parent d6a2c6afea
commit 4ca6596b1d
14 changed files with 351 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
src/backend/audio.rs
View File

@@ -307,8 +307,8 @@ impl BackendThread<MediaCommand, Sender<MediaCommand>> for MediaBackend {
loop {
while let Ok(msg) = controller_rx.try_recv() {
match msg {
ControllerMsg::Request => {
let _ = instance_clone.lock().expect("Couldn't get lock").publish(
Request => {
instance_clone.lock().expect("Couldn't get lock").publish(
MediaCommand::Cmd(
controller.current_vol,
controller.current_mute,
@@ -319,7 +319,7 @@ impl BackendThread<MediaCommand, Sender<MediaCommand>> for MediaBackend {
ControllerMsg::NotifyServer => {
controller.query_default_device_blocking();
let _ = controller.query_state_blocking();
let _ = instance_clone.lock().expect("Couldn't get lock").publish(
instance_clone.lock().expect("Couldn't get lock").publish(
MediaCommand::Cmd(
controller.current_vol,
controller.current_mute,
@@ -331,14 +331,13 @@ impl BackendThread<MediaCommand, Sender<MediaCommand>> for MediaBackend {
if controller.device_index.is_some_and(|i| i == idx) {
let changed = controller.query_state_blocking();
if changed {
let _ = instance_clone
.lock()
.expect("Couldn't get lock")
.publish(MediaCommand::Cmd(
instance_clone.lock().expect("Couldn't get lock").publish(
MediaCommand::Cmd(
controller.current_vol,
controller.current_mute,
controller.device_bt.unwrap_or(false),
));
),
);
trace!(
&LOGGER,
"Change: {} muted: {}",
@@ -350,7 +349,7 @@ impl BackendThread<MediaCommand, Sender<MediaCommand>> for MediaBackend {
}
ControllerMsg::Set(volume, mute) => {
controller.set_state(volume, mute);
let _ = instance_clone.lock().expect("Couldn't get lock").publish(
instance_clone.lock().expect("Couldn't get lock").publish(
MediaCommand::Cmd(
controller.current_vol,
controller.current_mute,

58
src/backend/brightness_control.rs
View File

@@ -15,7 +15,7 @@ use std::{fs, thread};
pub enum DisplayBackend {
Sysfs(BrightnessDevice),
DdcCi(ddc_hi::Display),
DdcCi(Box<ddc_hi::Display>),
}
fn get_sysfs_dev(id: &str) -> Option<BrightnessDevice> {
@@ -47,7 +47,7 @@ impl DisplayBackend {
pub fn get_brightness(&mut self) -> Option<u8> {
match self {
DisplayBackend::Sysfs(dev) => dev.get().and_then(|val| Ok(val as u8)).ok(),
DisplayBackend::Sysfs(dev) => dev.get().map(|val| val as u8).ok(),
DisplayBackend::DdcCi(display) => {
if let Ok(val) = display.handle.get_vcp_feature(0x10) {
Some(val.value() as u8)
@@ -70,11 +70,11 @@ struct DisplayData(DisplayBackend, u8);
impl DisplayData {
fn update(&mut self) -> bool {
if let Some(value) = self.0.get_brightness() {
if self.1 != value {
self.1 = value;
return true;
}
if let Some(value) = self.0.get_brightness()
&& self.1 != value
{
self.1 = value;
return true;
}
false
}
@@ -116,7 +116,7 @@ impl BackendThread<BrightnessMessage, Sender<BrightnessMessage>> for BrightnessM
subscribers: Vec::new(),
}));
let instance_clone = instance.clone();
std::thread::spawn(move || {
thread::spawn(move || {
while let Ok(tx) = registration_rx.recv() {
if tx.send(BrightnessMessage::Init(f2b_tx.clone())).is_ok() {
trace!(&LOGGER, "Added Brightness Subscriber: {tx:?}");
@@ -129,7 +129,7 @@ impl BackendThread<BrightnessMessage, Sender<BrightnessMessage>> for BrightnessM
}
});
let instance_clone = instance.clone();
std::thread::spawn(move || {
thread::spawn(move || {
while let Ok(mut msg) = f2b_rx.recv() {
while let Ok(newer) = f2b_rx.try_recv() {
msg = newer;
@@ -151,7 +151,7 @@ impl BackendThread<BrightnessMessage, Sender<BrightnessMessage>> for BrightnessM
.expect("Couldn't get lock")
.display_cache
.get(&id)
.and_then(|v| Some(v.1))
.map(|v| v.1)
{
instance_clone
.lock()
@@ -216,23 +216,21 @@ impl BrightnessManager {
if path.file_name().eq("device")
&& let Ok(link) = fs::read_link(path.path())
&& let Some(name) = link.file_name()
{
if name
&& name
.to_str()
.is_some_and(|name| name.eq(&format!("card1-{connector}")))
{
println!("Found sysfs display {connector}");
let path = bl_path.file_name();
let Some(name) = path.to_str() else { continue };
let Some(device) = get_sysfs_dev(name) else {
continue;
};
let mut backend = DisplayBackend::Sysfs(device);
let value = backend.get_brightness().unwrap_or(60);
self.display_cache
.insert(connector.clone(), DisplayData(backend, value));
return;
}
{
println!("Found sysfs display {connector}");
let path = bl_path.file_name();
let Some(name) = path.to_str() else { continue };
let Some(device) = get_sysfs_dev(name) else {
continue;
};
let mut backend = DisplayBackend::Sysfs(device);
let value = backend.get_brightness().unwrap_or(60);
self.display_cache
.insert(connector.clone(), DisplayData(backend, value));
return;
}
}
}
@@ -244,7 +242,7 @@ impl BrightnessManager {
println!("Found DDC/CI display {connector}");
for display in ddc_hi::Display::enumerate() {
if id.to_string().eq(&display.info.id) {
let mut backend = DisplayBackend::DdcCi(display);
let mut backend = DisplayBackend::DdcCi(Box::new(display));
let value = backend.get_brightness().unwrap_or(60);
self.display_cache
.insert(connector.clone(), DisplayData(backend, value));
@@ -307,10 +305,10 @@ impl BrightnessManager {
}
}
if drm_connector.as_deref() == Some(connector) {
if let Some(bus) = bus {
return Ok(bus);
}
if drm_connector.as_deref() == Some(connector)
&& let Some(bus) = bus
{
return Ok(bus);
}
}

115
src/backend/network.rs
View File

@@ -39,7 +39,7 @@ impl PartialEq<Self> for NetworkInfo {
impl PartialOrd<Self> for NetworkInfo {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(other.cmp(self))
Some(self.cmp(other))
}
}
@@ -82,20 +82,17 @@ impl From<ConnectionError> for ConnectError {
match value {
ConnectionError::AuthFailed => ConnectError::AuthFailed,
ConnectionError::NotFound => ConnectError::NotFound,
ConnectionError::Dbus(err) => match err {
Error::MethodError(name, ..) => {
if name.eq(&ErrorName::try_from(
"org.freedesktop.NetworkManager.Device.SpecificObjectNotFound",
)
.unwrap())
{
ConnectError::NotFound
} else {
ConnectError::Unknown
}
ConnectionError::Dbus(Error::MethodError(name, ..)) => {
if name.eq(&ErrorName::try_from(
"org.freedesktop.NetworkManager.Device.SpecificObjectNotFound",
)
.unwrap())
{
ConnectError::NotFound
} else {
ConnectError::Unknown
}
_ => ConnectError::Unknown,
},
}
_ => ConnectError::Unknown,
}
}
@@ -208,13 +205,13 @@ impl BackendThread<NetworkState, UnboundedSender<NetworkCommand>> for NetworkBac
} else {
match auth {
Auth::Open => {
if let Ok(networks) = nm.list_access_points(None).await {
if let Some(ap) = networks.iter().find(|net| net.ssid.eq(&ssid)) {
if ap.security.is_open() {
instance_clone.connect(&nm, ssid, WifiSecurity::Open).await;
} else {
instance_clone.publish(NetworkState::Auth(ssid, AuthType::Password));
}
if let Ok(networks) = nm.list_access_points(None).await
&& let Some(ap) = networks.iter().find(|net| net.ssid.eq(&ssid))
{
if ap.security.is_open() {
instance_clone.connect(&nm, ssid, WifiSecurity::Open).await;
} else {
instance_clone.publish(NetworkState::Auth(ssid, AuthType::Password));
}
}
}
@@ -269,23 +266,23 @@ impl NetworkBackendHandle {
}
async fn print_network_info(&self, nm: &NetworkManager, ssid: &str, level: Level) {
if let Ok(nets) = nm.list_networks(None).await {
if let Some(net) = nets.iter().find(|net| net.ssid.eq(ssid)) {
log!(&LOGGER, level, "Network:");
log!(&LOGGER, level, " SSID: {}", net.ssid);
log!(&LOGGER, level, " Active: {}", net.is_active);
log!(&LOGGER, level, " Known: {}", net.known);
log!(&LOGGER, level, " Secured: {}", net.secured);
if net.secured {
log!(&LOGGER, level, " Features: {:?}", net.security_features);
log!(&LOGGER, level, " EAP: {}", net.is_eap);
log!(&LOGGER, level, " PSK: {}", net.is_psk);
}
log!(&LOGGER, level, " Strength: {:?}", net.strength);
log!(&LOGGER, level, " Device: {}", net.device);
log!(&LOGGER, level, " Addr(4): {:?}", net.ip4_address);
log!(&LOGGER, level, " Addr(6): {:?}", net.ip6_address);
if let Ok(nets) = nm.list_networks(None).await
&& let Some(net) = nets.iter().find(|net| net.ssid.eq(ssid))
{
log!(&LOGGER, level, "Network:");
log!(&LOGGER, level, " SSID: {}", net.ssid);
log!(&LOGGER, level, " Active: {}", net.is_active);
log!(&LOGGER, level, " Known: {}", net.known);
log!(&LOGGER, level, " Secured: {}", net.secured);
if net.secured {
log!(&LOGGER, level, " Features: {:?}", net.security_features);
log!(&LOGGER, level, " EAP: {}", net.is_eap);
log!(&LOGGER, level, " PSK: {}", net.is_psk);
}
log!(&LOGGER, level, " Strength: {:?}", net.strength);
log!(&LOGGER, level, " Device: {}", net.device);
log!(&LOGGER, level, " Addr(4): {:?}", net.ip4_address);
log!(&LOGGER, level, " Addr(6): {:?}", net.ip6_address);
}
}
@@ -304,7 +301,7 @@ impl NetworkBackendHandle {
NetworkEvent::WirelessEnabledChanged => {
if let Ok(state) = nm.wifi_state().await {
if !state.enabled {
let _ = self.publish(NetworkState::ChangeNetwork(None));
self.publish(NetworkState::ChangeNetwork(None));
} else {
let _ = self.send_active_connection(nm).await;
}
@@ -313,23 +310,22 @@ impl NetworkBackendHandle {
NetworkEvent::ActiveConnectionsChanged => {
let _ = self.send_active_connection(nm).await;
}
NetworkEvent::DeviceChanged { interface } => match interface {
Some(interface) => match nm.active_vpn_connections().await {
Ok(connections) => {
let mut connected = false;
for conn in connections {
if conn.interface.is_some_and(|s| s.eq(&interface)) {
connected = true;
}
NetworkEvent::DeviceChanged {
interface: Some(interface),
} => match nm.active_vpn_connections().await {
Ok(connections) => {
let mut connected = false;
for conn in connections {
if conn.interface.is_some_and(|s| s.eq(&interface)) {
connected = true;
}
let _ = self.publish(NetworkState::VpnState {
profile: interface,
connected,
});
}
Err(err) => error!(&LOGGER, "Error getting active vpns: {}", err.to_string()),
},
None => {}
self.publish(NetworkState::VpnState {
profile: interface,
connected,
});
}
Err(err) => error!(&LOGGER, "Error getting active vpns: {}", err.to_string()),
},
_ => {}
}
@@ -443,7 +439,7 @@ impl NetworkBackendHandle {
secured: None,
known: true,
};
let _ = self.publish(NetworkState::ChangeNetwork(Some(info)));
self.publish(NetworkState::ChangeNetwork(Some(info)));
}
ActiveConnection::Wifi(c) => {
let info = NetworkInfo {
@@ -453,13 +449,13 @@ impl NetworkBackendHandle {
secured: None, // Not relevant here
known: true,
};
let _ = self.publish(NetworkState::ChangeNetwork(Some(info)));
self.publish(NetworkState::ChangeNetwork(Some(info)));
}
_ => {}
}
}
None => {
let _ = self.publish(NetworkState::ChangeNetwork(None));
self.publish(NetworkState::ChangeNetwork(None));
}
}
}
@@ -478,11 +474,8 @@ impl NetworkBackendHandle {
Ok::<bool, Box<dyn std::error::Error>>(active.iter().any(|vpn| vpn.name == profile))
};
match operation.await {
Ok(connected) => {
let _ = self.publish(NetworkState::VpnState { profile, connected });
}
Err(_) => {}
if let Ok(connected) = operation.await {
self.publish(NetworkState::VpnState { profile, connected });
}
}
}

50
src/backend/perf_stats.rs
View File

@@ -91,33 +91,31 @@ impl BackendThread<Stats, ()> for StatsBackend {
let mut battery_draw: f32 = 0.0;
let mut battery_time: u64 = 0;
if let Ok(manager) = &manager {
if let Ok(mut batteries) = manager.batteries() {
match batteries.next() {
Some(Ok(battery)) => {
battery_charge =
battery.state_of_charge().get::<percent>().round() as u8;
battery_state = battery.state();
battery_draw = battery.energy_rate().get::<watt>();
battery_time = if battery_state == State::Charging {
battery
.time_to_full()
.unwrap_or(Time::new::<millisecond>(0.0))
.get::<millisecond>()
as u64
} else if battery_state == State::Discharging {
battery
.time_to_empty()
.unwrap_or(Time::new::<millisecond>(0.0))
.get::<millisecond>()
as u64
} else {
0
};
}
Some(Err(e)) => error!(&LOGGER, "Error accessing battery: {e:?}"),
None => {}
if let Ok(manager) = &manager
&& let Ok(mut batteries) = manager.batteries()
{
match batteries.next() {
Some(Ok(battery)) => {
battery_charge =
battery.state_of_charge().get::<percent>().round() as u8;
battery_state = battery.state();
battery_draw = battery.energy_rate().get::<watt>();
battery_time = if battery_state == State::Charging {
battery
.time_to_full()
.unwrap_or(Time::new::<millisecond>(0.0))
.get::<millisecond>() as u64
} else if battery_state == State::Discharging {
battery
.time_to_empty()
.unwrap_or(Time::new::<millisecond>(0.0))
.get::<millisecond>() as u64
} else {
0
};
}
Some(Err(e)) => error!(&LOGGER, "Error accessing battery: {e:?}"),
None => {}
}
}

24
src/backend/tailscale.rs
View File

@@ -89,13 +89,13 @@ impl TailscaleBackend {
match serde_json::from_slice::<serde_json::Value>(line) {
Ok(notification) => {
if let Some(state) = notification.get("State") {
if !state.is_null() {
let state =
TailscaleState::try_from_value(state.as_i64().unwrap_or(4))
.unwrap_or(TailscaleState::Stopped);
instance.lock().expect("Couldn't get lock").publish(state);
}
if let Some(state) = notification.get("State")
&& !state.is_null()
{
let state =
TailscaleState::try_from_value(state.as_i64().unwrap_or(4))
.unwrap_or(TailscaleState::Stopped);
instance.lock().expect("Couldn't get lock").publish(state);
}
}
Err(err) => {
@@ -174,11 +174,11 @@ fn initial_state() -> TailscaleState {
.output()
{
let val: Result<serde_json::Value, _> = serde_json::from_slice(&output.stdout);
if val.is_ok() {
if let Some(res) = val.unwrap().get("BackendState").and_then(|v| v.as_str()) {
if res.eq("Running") {
return TailscaleState::Running;
}
if let Ok(val) = val {
if let Some(res) = val.get("BackendState").and_then(|v| v.as_str())
&& res.eq("Running")
{
return TailscaleState::Running;
}
} else {
error!(&LOGGER, "{:?}", val.err());

36
src/backend/window_manager_hypr.rs
View File

@@ -45,13 +45,13 @@ impl BackendThread<WindowManagerEvent, ()> for HyprlandComms {
let inst_clone = instance.clone();
listener.add_workspace_changed_handler(move |workspace| {
if let WorkspaceType::Regular(name) = workspace.name {
if let Ok(id) = name.parse::<i32>() {
inst_clone
.lock()
.expect("Couldn't get Subscribers")
.publish(WindowManagerEvent::WorkspaceChanged(id));
}
if let WorkspaceType::Regular(name) = workspace.name
&& let Ok(id) = name.parse::<i32>()
{
inst_clone
.lock()
.expect("Couldn't get Subscribers")
.publish(WindowManagerEvent::WorkspaceChanged(id));
}
});
@@ -84,13 +84,13 @@ impl BackendThread<WindowManagerEvent, ()> for HyprlandComms {
let inst_clone = instance.clone();
listener.add_workspace_deleted_handler(move |workspace| {
if let WorkspaceType::Regular(name) = workspace.name {
if let Ok(id) = name.parse::<i32>() {
inst_clone
.lock()
.expect("Couldn't get Subscribers")
.publish(WindowManagerEvent::WorkspaceRemoved(id));
}
if let WorkspaceType::Regular(name) = workspace.name
&& let Ok(id) = name.parse::<i32>()
{
inst_clone
.lock()
.expect("Couldn't get Subscribers")
.publish(WindowManagerEvent::WorkspaceRemoved(id));
}
});
@@ -159,10 +159,10 @@ impl BackendThread<WindowManagerEvent, ()> for HyprlandComms {
impl HyprlandComms {
fn monitor_id_from_workspace_id(id: WorkspaceId) -> Option<MonitorId> {
if let Ok(wss) = Workspaces::get() {
if let Some(ws) = wss.to_vec().iter().find(|ws| ws.id().unwrap() == id) {
return ws.monitor_id;
}
if let Ok(wss) = Workspaces::get()
&& let Some(ws) = wss.to_vec().iter().find(|ws| ws.id().unwrap() == id)
{
return ws.monitor_id;
}
None
}