fix: Improve performance by passing smaller datatypes to dbus

src/components/input/outputStreamEntry.rs

@@ -4,12 +4,12 @@ use std::time::Duration;
 
 use adw::glib;
 use adw::glib::Object;
-use adw::prelude::RangeExt;
+use adw::prelude::{ButtonExt, RangeExt};
 use dbus::blocking::Connection;
 use dbus::Error;
-use ReSet_Lib::audio::audio::OutputStream;
-use glib::{clone, Propagation};
 use glib::subclass::types::ObjectSubclassIsExt;
+use glib::{clone, Propagation};
+use ReSet_Lib::audio::audio::OutputStream;
 
 use super::outputStreamEntryImpl;
 
@@ -40,21 +40,53 @@ impl OutputStreamEntry {
                     let fraction = (value / 655.36).round();
                     let percentage = (fraction).to_string() + "%";
                     imp.resetVolumePercentage.set_text(&percentage);
-                    set_outputstream_volume(value, imp.stream.clone());
+                    let stream = imp.stream.borrow();
+                    let index = stream.index;
+                    let channels = stream.channels;
+                    set_outputstream_volume(value, index, channels);
                     Propagation::Proceed
                 }),
             );
+            imp.resetSourceMute
+                .connect_clicked(clone!(@weak imp => move |_| {
+                    let stream = imp.stream.clone();
+                    let mut stream = stream.borrow_mut();
+                    stream.muted = !stream.muted;
+                    let muted = stream.muted;
+                    let index = stream.index;
+                    if muted {
+                        imp.resetSourceMute
+                           .set_icon_name("audio-volume-muted-symbolic");
+                    } else {
+                        imp.resetSourceMute
+                           .set_icon_name("audio-volume-high-symbolic");
+                    }
+                    toggle_output_stream_mute(index, muted);
+                }));
         }
         obj
     }
 }
 
-fn set_outputstream_volume(value: f64, stream: Arc<RefCell<OutputStream>>) -> bool {
+fn set_outputstream_volume(value: f64, index: u32, channels: u16) -> bool {
-    let mut stream = stream.borrow_mut().clone();
+    let conn = Connection::new_session().unwrap();
-    // let x = stream.volume.iter_mut().map(|_| value as u32);
+    let proxy = conn.with_proxy(
-    stream.volume = vec![value as u32; stream.channels as usize];
+        "org.xetibo.ReSet",
-    dbg!(stream.volume.clone());
+        "/org/xetibo/ReSet",
+        Duration::from_millis(1000),
+    );
+    let res: Result<(bool,), Error> = proxy.method_call(
+        "org.xetibo.ReSet",
+        "SetOutputStreamVolume",
+        (index, channels, value as u32),
+    );
+    if res.is_err() {
+        return false;
+    }
+    res.unwrap().0
+}
 
+fn toggle_output_stream_mute(index: u32, muted: bool) -> bool {
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(
         "org.xetibo.ReSet",
@@ -62,7 +94,7 @@ fn set_outputstream_volume(value: f64, stream: Arc<RefCell<OutputStream>>) -> bo
         Duration::from_millis(1000),
     );
     let res: Result<(bool,), Error> =
-        proxy.method_call("org.xetibo.ReSet", "SetOutputStreamVolume", (stream,));
+        proxy.method_call("org.xetibo.ReSet", "SetOutputStreamMute", (index, muted));
     if res.is_err() {
         return false;
     }

src/components/input/sourceBox.rs

@@ -7,7 +7,7 @@ use crate::components::input::sourceBoxImpl;
 use crate::components::input::sourceEntry::set_source_volume;
 use adw::glib;
 use adw::glib::Object;
-use adw::prelude::{BoxExt, ListBoxRowExt, RangeExt};
+use adw::prelude::{BoxExt, ButtonExt, ListBoxRowExt, RangeExt};
 use dbus::blocking::Connection;
 use dbus::Error;
 use glib::subclass::prelude::ObjectSubclassIsExt;
@@ -17,7 +17,7 @@ use gtk::prelude::ActionableExt;
 use ReSet_Lib::audio::audio::{OutputStream, Source};
 
 use super::outputStreamEntry::OutputStreamEntry;
-use super::sourceEntry::SourceEntry;
+use super::sourceEntry::{toggle_source_mute, SourceEntry};
 
 glib::wrapper! {
     pub struct SourceBox(ObjectSubclass<sourceBoxImpl::SourceBox>)
@@ -59,6 +59,7 @@ pub fn populate_sources(output_box: Arc<SourceBox>) {
             glib::idle_add_once(move || {
                 // TODO handle default mapping
                 let output_box_ref_slider = output_box.clone();
+                let output_box_ref_mute = output_box.clone();
                 let output_box_ref = output_box.clone();
                 {
                     let output_box_imp = output_box_ref.imp();
@@ -85,9 +86,32 @@ pub fn populate_sources(output_box: Arc<SourceBox>) {
                         println!("{fraction}");
                         let percentage = (fraction).to_string() + "%";
                         imp.resetVolumePercentage.set_text(&percentage);
-                        set_source_volume(value, imp.resetDefaultSource.clone());
+                        let source = imp.resetDefaultSource.borrow();
+                        let index = source.index;
+                        let channels = source.channels;
+                        set_source_volume(value, index, channels);
                         Propagation::Proceed
                     });
+
+                output_box_ref
+                    .imp()
+                    .resetSourceMute
+                    .connect_clicked(move |_| {
+                        let imp = output_box_ref_mute.imp();
+                        let stream = imp.resetDefaultSource.clone();
+                        let mut stream = stream.borrow_mut();
+                        stream.muted = !stream.muted;
+                        let muted = stream.muted;
+                        let index = stream.index;
+                        if muted {
+                            imp.resetSourceMute
+                                .set_icon_name("audio-volume-muted-symbolic");
+                        } else {
+                            imp.resetSourceMute
+                                .set_icon_name("audio-volume-high-symbolic");
+                        }
+                        toggle_source_mute(index, muted);
+                    });
             });
         });
     });

src/components/input/sourceEntry.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use adw::glib;
 use adw::glib::Object;
-use adw::prelude::RangeExt;
+use adw::prelude::{ButtonExt, RangeExt};
 use dbus::blocking::Connection;
 use dbus::Error;
 use glib::subclass::types::ObjectSubclassIsExt;
@@ -42,21 +42,53 @@ impl SourceEntry {
                     println!("{fraction}");
                     let percentage = (fraction).to_string() + "%";
                     imp.resetVolumePercentage.set_text(&percentage);
-                    set_source_volume(value, imp.stream.clone());
+                    let source = imp.stream.borrow();
+                    let index = source.index;
+                    let channels = source.channels;
+                    set_source_volume(value, index, channels);
                     Propagation::Proceed
                 }),
             );
+            imp.resetSourceMute
+                .connect_clicked(clone!(@weak imp => move |_| {
+                    let stream = imp.stream.clone();
+                    let mut stream = stream.borrow_mut();
+                    stream.muted = !stream.muted;
+                    let muted = stream.muted;
+                    let index = stream.index;
+                    if muted {
+                        imp.resetSourceMute
+                           .set_icon_name("audio-volume-muted-symbolic");
+                    } else {
+                        imp.resetSourceMute
+                           .set_icon_name("audio-volume-high-symbolic");
+                    }
+                    toggle_source_mute(index, muted);
+                }));
         }
         obj
     }
 }
 
-pub fn set_source_volume(value: f64, stream: Arc<RefCell<Source>>) -> bool {
+pub fn set_source_volume(value: f64, index: u32, channels: u16) -> bool {
-    let mut stream = stream.borrow_mut().clone();
+    let conn = Connection::new_session().unwrap();
-    // let x = stream.volume.iter_mut().map(|_| value as u32);
+    let proxy = conn.with_proxy(
-    stream.volume = vec![value as u32; stream.channels as usize];
+        "org.xetibo.ReSet",
-    dbg!(stream.volume.clone());
+        "/org/xetibo/ReSet",
+        Duration::from_millis(1000),
+    );
+    let res: Result<(bool,), Error> = proxy.method_call(
+        "org.xetibo.ReSet",
+        "SetSourceVolume",
+        (index, channels, value as u32),
+    );
+    if res.is_err() {
+        return false;
+    }
+    res.unwrap().0
+}
 
+pub fn toggle_source_mute(index: u32, muted: bool) -> bool {
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(
         "org.xetibo.ReSet",
@@ -64,7 +96,7 @@ pub fn set_source_volume(value: f64, stream: Arc<RefCell<Source>>) -> bool {
         Duration::from_millis(1000),
     );
     let res: Result<(bool,), Error> =
-        proxy.method_call("org.xetibo.ReSet", "SetSourceVolume", (stream,));
+        proxy.method_call("org.xetibo.ReSet", "SetSourceMute", (index, muted));
     if res.is_err() {
         return false;
     }

src/components/output/inputStreamEntry.rs

@@ -4,10 +4,11 @@ use std::time::Duration;
 
 use adw::glib;
 use adw::glib::Object;
-use adw::prelude::RangeExt;
+use adw::prelude::{ButtonExt, RangeExt};
 use dbus::blocking::Connection;
 use dbus::Error;
 use glib::subclass::types::ObjectSubclassIsExt;
+use glib::subclass::ObjectImplRef;
 use glib::{clone, Propagation};
 use ReSet_Lib::audio::audio::InputStream;
 
@@ -23,10 +24,16 @@ impl InputStreamEntry {
     pub fn new(stream: InputStream) -> Self {
         let obj: Self = Object::builder().build();
         // TODO use event callback for progress bar -> this is the "im speaking" indicator
-        // TODO map mute to callback
         // TODO map dropdown
         {
             let imp = obj.imp();
+            if stream.muted {
+                imp.resetSinkMute
+                    .set_icon_name("audio-volume-muted-symbolic");
+            } else {
+                imp.resetSinkMute
+                    .set_icon_name("audio-volume-high-symbolic");
+            }
             let name = stream.application_name.clone() + ": " + stream.name.as_str();
             imp.resetSinkName.set_text(name.as_str());
             let volume = stream.volume.first().unwrap_or_else(|| &(0 as u32));
@@ -40,21 +47,53 @@ impl InputStreamEntry {
                     let fraction = (value / 655.36).round();
                     let percentage = (fraction).to_string() + "%";
                     imp.resetVolumePercentage.set_text(&percentage);
-                    set_inputstream_volume(value, imp.stream.clone());
+                    let stream = imp.stream.borrow();
+                    let index = stream.index;
+                    let channels = stream.channels;
+                    set_inputstream_volume(value, index, channels);
                     Propagation::Proceed
                 }),
             );
+            imp.resetSinkMute
+                .connect_clicked(clone!(@weak imp => move |_| {
+                    let stream = imp.stream.clone();
+                    let mut stream = stream.borrow_mut();
+                    stream.muted = !stream.muted;
+                    let muted = stream.muted;
+                    let index = stream.index;
+                    if muted {
+                        imp.resetSinkMute
+                           .set_icon_name("audio-volume-muted-symbolic");
+                    } else {
+                        imp.resetSinkMute
+                           .set_icon_name("audio-volume-high-symbolic");
+                    }
+                    toggle_input_stream_mute(index, muted);
+                }));
         }
         obj
     }
 }
 
-fn set_inputstream_volume(value: f64, stream: Arc<RefCell<InputStream>>) -> bool {
+fn set_inputstream_volume(value: f64, index: u32, channels: u16) -> bool {
-    let mut stream = stream.borrow_mut().clone();
+    let conn = Connection::new_session().unwrap();
-    // let x = stream.volume.iter_mut().map(|_| value as u32);
+    let proxy = conn.with_proxy(
-    stream.volume = vec![value as u32; stream.channels as usize];
+        "org.xetibo.ReSet",
-    dbg!(stream.volume.clone());
+        "/org/xetibo/ReSet",
+        Duration::from_millis(1000),
+    );
+    let res: Result<(bool,), Error> = proxy.method_call(
+        "org.xetibo.ReSet",
+        "SetInputStreamVolume",
+        (index, channels, value as u32),
+    );
+    if res.is_err() {
+        return false;
+    }
+    res.unwrap().0
+}
 
+fn toggle_input_stream_mute(index: u32, muted: bool) -> bool {
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(
         "org.xetibo.ReSet",
@@ -62,7 +101,7 @@ fn set_inputstream_volume(value: f64, stream: Arc<RefCell<InputStream>>) -> bool
         Duration::from_millis(1000),
     );
     let res: Result<(bool,), Error> =
-        proxy.method_call("org.xetibo.ReSet", "SetInputStreamVolume", (stream,));
+        proxy.method_call("org.xetibo.ReSet", "SetInputStreamMute", (index, muted));
     if res.is_err() {
         return false;
     }

src/components/output/sinkBox.rs

@@ -5,7 +5,7 @@ use crate::components::base::listEntry::ListEntry;
 use crate::components::base::utils::Listeners;
 use crate::components::output::sinkEntry::set_sink_volume;
 use adw::glib::Object;
-use adw::prelude::{BoxExt, RangeExt};
+use adw::prelude::{BoxExt, ButtonExt, RangeExt};
 use adw::{glib, prelude::ListBoxRowExt};
 use dbus::blocking::Connection;
 use dbus::Error;
@@ -17,7 +17,7 @@ use ReSet_Lib::audio::audio::{InputStream, Sink};
 
 use super::inputStreamEntry::InputStreamEntry;
 use super::sinkBoxImpl;
-use super::sinkEntry::SinkEntry;
+use super::sinkEntry::{toggle_sink_mute, SinkEntry};
 
 glib::wrapper! {
     pub struct SinkBox(ObjectSubclass<sinkBoxImpl::SinkBox>)
@@ -60,6 +60,7 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
             glib::idle_add_once(move || {
                 // TODO handle default mapping
                 let output_box_ref_slider = output_box.clone();
+                let output_box_ref_mute = output_box.clone();
                 {
                     let output_box_imp = output_box_ref.imp();
                     let default_sink = output_box_imp.resetDefaultSink.clone(); // Clone outside closure
@@ -86,9 +87,31 @@ pub fn populate_sinks(output_box: Arc<SinkBox>) {
                         println!("{fraction}");
                         let percentage = (fraction).to_string() + "%";
                         imp.resetVolumePercentage.set_text(&percentage);
-                        set_sink_volume(value, imp.resetDefaultSink.clone());
+                        let sink = imp.resetDefaultSink.borrow();
+                        let index = sink.index;
+                        let channels = sink.channels;
+                        set_sink_volume(value, index, channels);
                         Propagation::Proceed
                     });
+                output_box_ref
+                    .imp()
+                    .resetSinkMute
+                    .connect_clicked(move |_| {
+                        let imp = output_box_ref_mute.imp();
+                        let stream = imp.resetDefaultSink.clone();
+                        let mut stream = stream.borrow_mut();
+                        stream.muted = !stream.muted;
+                        let muted = stream.muted;
+                        let index = stream.index;
+                        if muted {
+                            imp.resetSinkMute
+                                .set_icon_name("audio-volume-muted-symbolic");
+                        } else {
+                            imp.resetSinkMute
+                                .set_icon_name("audio-volume-high-symbolic");
+                        }
+                        toggle_sink_mute(index, muted);
+                    });
             });
         });
     });

src/components/output/sinkEntry.rs

@@ -4,7 +4,7 @@ use std::time::Duration;
 
 use adw::glib;
 use adw::glib::Object;
-use adw::prelude::RangeExt;
+use adw::prelude::{ButtonExt, RangeExt};
 use dbus::blocking::Connection;
 use dbus::Error;
 use glib::subclass::types::ObjectSubclassIsExt;
@@ -42,21 +42,53 @@ impl SinkEntry {
                     println!("{fraction}");
                     let percentage = (fraction).to_string() + "%";
                     imp.resetVolumePercentage.set_text(&percentage);
-                    set_sink_volume(value, imp.stream.clone());
+                     let sink = imp.stream.borrow();
+                     let index = sink.index;
+                     let channels = sink.channels;
+                     set_sink_volume(value, index, channels);
                     Propagation::Proceed
                 }),
             );
+            imp.resetSinkMute
+                .connect_clicked(clone!(@weak imp => move |_| {
+                    let stream = imp.stream.clone();
+                    let mut stream = stream.borrow_mut();
+                    stream.muted = !stream.muted;
+                    let muted = stream.muted;
+                    let index = stream.index;
+                    if muted {
+                        imp.resetSinkMute
+                           .set_icon_name("audio-volume-muted-symbolic");
+                    } else {
+                        imp.resetSinkMute
+                           .set_icon_name("audio-volume-high-symbolic");
+                    }
+                    toggle_sink_mute(index, muted);
+                }));
         }
         obj
     }
 }
 
-pub fn set_sink_volume(value: f64, stream: Arc<RefCell<Sink>>) -> bool {
+pub fn set_sink_volume(value: f64, index: u32, channels: u16) -> bool {
-    let mut stream = stream.borrow_mut().clone();
+    let conn = Connection::new_session().unwrap();
-    // let x = stream.volume.iter_mut().map(|_| value as u32);
+    let proxy = conn.with_proxy(
-    stream.volume = vec![value as u32; stream.channels as usize];
+        "org.xetibo.ReSet",
-    dbg!(stream.volume.clone());
+        "/org/xetibo/ReSet",
+        Duration::from_millis(1000),
+    );
+    let res: Result<(bool,), Error> = proxy.method_call(
+        "org.xetibo.ReSet",
+        "SetSinkVolume",
+        (index, channels, value as u32),
+    );
+    if res.is_err() {
+        return false;
+    }
+    res.unwrap().0
+}
 
+pub fn toggle_sink_mute(index: u32, muted: bool) -> bool {
     let conn = Connection::new_session().unwrap();
     let proxy = conn.with_proxy(
         "org.xetibo.ReSet",
@@ -64,7 +96,7 @@ pub fn set_sink_volume(value: f64, stream: Arc<RefCell<Sink>>) -> bool {
         Duration::from_millis(1000),
     );
     let res: Result<(bool,), Error> =
-        proxy.method_call("org.xetibo.ReSet", "SetSinkVolume", (stream,));
+        proxy.method_call("org.xetibo.ReSet", "SetSinkMute", (index, muted));
     if res.is_err() {
         return false;
     }