Xetibo/ReSet
1
0
Fork 0
mirror of https://github.com/Xetibo/ReSet.git synced 2025-07-01 15:57:46 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat: Add all audio events

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-11-15 23:02:27 +01:00
parent a84c71d9e1
commit 6ad3f07cf3
13 changed files with 785 additions and 345 deletions
Download patch file Download diff file Expand all files Collapse all files

30
src/components/input/outputStreamEntry.rs
View file

@ -54,17 +54,17 @@ impl OutputStreamEntry {
}),
);
{
let mut list = box_imp.resetModelList.try_borrow();
while list.is_err() {
list = box_imp.resetModelList.try_borrow();
}
let list = list.unwrap();
let list = box_imp.resetModelList.read().unwrap();
// while list.is_err() {
// list = box_imp.resetModelList.try_borrow();
// }
// let list = list.unwrap();
imp.resetSelectedSource.set_model(Some(&*list));
let mut map = box_imp.resetSourceMap.try_borrow();
while map.is_err() {
map = box_imp.resetSourceMap.try_borrow();
}
let map = map.unwrap();
let map = box_imp.resetSourceMap.write().unwrap();
// while map.is_err() {
// map = box_imp.resetSourceMap.try_borrow();
// }
// let map = map.unwrap();
let mut name = box_imp.resetDefaultSource.try_borrow();
while name.is_err() {
name = box_imp.resetDefaultSource.try_borrow();
@ -85,11 +85,7 @@ impl OutputStreamEntry {
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let mut source = box_imp.resetSourceMap.try_borrow();
while source.is_err() {
source = box_imp.resetSourceMap.try_borrow();
}
let source = source.unwrap();
let source = box_imp.resetSourceMap.write().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;
@ -116,10 +112,10 @@ impl OutputStreamEntry {
let index = stream.index;
if muted {
imp.resetSourceMute
.set_icon_name("audio-volume-muted-symbolic");
.set_icon_name("microphone-volume-muted-symbolic");
} else {
imp.resetSourceMute
.set_icon_name("audio-volume-high-symbolic");
.set_icon_name("microphone-volume-high-symbolic");
}
toggle_output_stream_mute(index, muted);
}));

323
src/components/input/sourceBox.rs
View file

@ -1,15 +1,20 @@
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::Duration;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::utils::Listeners;
use crate::components::base::utils::{
Listeners, OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded,
SourceChanged, SourceRemoved,
};
use crate::components::input::sourceBoxImpl;
use crate::components::input::sourceEntry::set_source_volume;
use adw::glib;
use adw::glib::Object;
use adw::prelude::{BoxExt, ButtonExt, ListBoxRowExt, RangeExt};
use adw::prelude::{BoxExt, ButtonExt, CheckButtonExt, ListBoxRowExt, RangeExt};
use dbus::blocking::Connection;
use dbus::Error;
use dbus::message::SignalArgs;
use dbus::{Error, Path};
use glib::subclass::prelude::ObjectSubclassIsExt;
use glib::{clone, Cast, Propagation, Variant};
use gtk::prelude::ActionableExt;
@ -48,55 +53,65 @@ impl SourceBox {
}
}
pub fn populate_sources(output_box: Arc<SourceBox>) {
pub fn populate_sources(input_box: Arc<SourceBox>) {
gio::spawn_blocking(move || {
let output_box_imp = output_box.imp();
let output_box_imp = input_box.imp();
let sources = get_sources();
{
let list = output_box_imp.resetModelList.borrow_mut();
let mut map = output_box_imp.resetSourceMap.borrow_mut();
let list = output_box_imp.resetModelList.write().unwrap();
let mut map = output_box_imp.resetSourceMap.write().unwrap();
let mut model_index = output_box_imp.resetModelIndex.write().unwrap();
let mut i: u32 = 0;
for source in sources.iter() {
list.append(&source.alias);
map.insert(source.alias.clone(), (source.index, i, source.name.clone()));
i += 1;
*model_index += 1;
}
}
output_box_imp
.resetDefaultSource
.replace(get_default_source());
populate_outputstreams(input_box.clone());
glib::spawn_future(async move {
glib::idle_add_once(move || {
// TODO handle events
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_ref_slider = input_box.clone();
let output_box_ref_mute = input_box.clone();
let output_box_ref = input_box.clone();
{
let output_box_imp = output_box_ref.imp();
let default_sink = output_box_imp.resetDefaultSource.clone(); // Clone outside closure
let source = default_sink.borrow(); //
let default_sink = output_box_imp.resetDefaultSource.clone();
let source = default_sink.borrow();
let volume = source.volume.first().unwrap_or_else(|| &(0 as u32));
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
output_box_imp.resetVolumePercentage.set_text(&percentage);
output_box_imp.resetVolumeSlider.set_value(*volume as f64);
let mut list = output_box_imp.resetSourceList.write().unwrap();
for stream in sources {
let index = source.index;
let alias = source.alias.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSource.borrow().name == stream.name {
is_default = true;
}
let entry = ListEntry::new(&SourceEntry::new(
let source_entry = Arc::new(SourceEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
stream,
));
let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
output_box_imp.resetSources.append(&entry);
list.insert(index, (entry.clone(), source_clone, alias));
output_box_imp.resetSources.append(&*entry);
}
let list = output_box_imp.resetModelList.borrow();
let list = output_box_imp.resetModelList.read().unwrap();
output_box_imp.resetSourceDropdown.set_model(Some(&*list));
let map = output_box_imp.resetSourceMap.borrow();
let map = output_box_imp.resetSourceMap.read().unwrap();
let name = output_box_imp.resetDefaultSource.borrow();
let name = &name.alias;
let index = map.get(name);
@ -115,7 +130,7 @@ pub fn populate_sources(output_box: Arc<SourceBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = output_box_imp.resetSourceMap.borrow();
let source = output_box_imp.resetSourceMap.read().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;
@ -131,7 +146,6 @@ pub fn populate_sources(output_box: Arc<SourceBox>) {
.connect_change_value(move |_, _, value| {
let imp = output_box_ref_slider.imp();
let fraction = (value / 655.36).round();
println!("{fraction}");
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
let source = imp.resetDefaultSource.borrow();
@ -165,19 +179,23 @@ pub fn populate_sources(output_box: Arc<SourceBox>) {
});
}
pub fn populate_outputstreams(_listeners: Arc<Listeners>, output_box: Arc<SourceBox>) {
pub fn populate_outputstreams(input_box: Arc<SourceBox>) {
// TODO add listener
let output_box_ref = output_box.clone();
let input_box_ref = input_box.clone();
gio::spawn_blocking(move || {
let streams = get_output_streams();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box_imp = output_box_ref.imp();
let input_box_imp = input_box_ref.imp();
let mut list = input_box_imp.resetOutputStreamList.write().unwrap();
for stream in streams {
let entry = ListEntry::new(&OutputStreamEntry::new(output_box.clone(), stream));
let index = stream.index;
let input_stream = Arc::new(OutputStreamEntry::new(input_box.clone(), stream));
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
output_box_imp.resetOutputStreams.append(&entry);
list.insert(index, (entry.clone(), input_stream.clone()));
input_box_imp.resetOutputStreams.append(&*entry);
}
});
});
@ -228,3 +246,262 @@ fn get_default_source() -> Source {
}
res.unwrap().0
}
pub fn start_input_box_listener(
conn: Connection,
listeners: Arc<Listeners>,
source_box: Arc<SourceBox>,
) -> Connection {
if listeners.network_listener.load(Ordering::SeqCst) {
return conn;
}
listeners.network_listener.store(true, Ordering::SeqCst);
let source_added = SourceAdded::match_rule(
Some(&"org.xetibo.ReSet".into()),
Some(&Path::from("/org/xetibo/ReSet")),
)
.static_clone();
let source_removed = SourceRemoved::match_rule(
Some(&"org.xetibo.ReSet".into()),
Some(&Path::from("/org/xetibo/ReSet")),
)
.static_clone();
let source_changed = SourceChanged::match_rule(
Some(&"org.xetibo.ReSet".into()),
Some(&Path::from("/org/xetibo/ReSet")),
)
.static_clone();
let output_stream_added = OutputStreamAdded::match_rule(
Some(&"org.xetibo.ReSet".into()),
Some(&Path::from("/org/xetibo/ReSet")),
)
.static_clone();
let output_stream_removed = OutputStreamRemoved::match_rule(
Some(&"org.xetibo.ReSet".into()),
Some(&Path::from("/org/xetibo/ReSet")),
)
.static_clone();
let output_stream_changed = OutputStreamChanged::match_rule(
Some(&"org.xetibo.ReSet".into()),
Some(&Path::from("/org/xetibo/ReSet")),
)
.static_clone();
let source_added_box = source_box.clone();
let source_removed_box = source_box.clone();
let source_changed_box = source_box.clone();
let output_stream_added_box = source_box.clone();
let output_stream_removed_box = source_box.clone();
let output_stream_changed_box = source_box.clone();
let res = conn.add_match(source_added, move |ir: SourceAdded, _, _| {
let source_box = source_added_box.clone();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSourceList.write().unwrap();
let index = ir.source.index;
let alias = ir.source.alias.clone();
let name = ir.source.name.clone();
let mut is_default = false;
if output_box_imp.resetDefaultSource.borrow().name == ir.source.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
output_box_imp.resetDefaultCheckButton.clone(),
ir.source,
));
let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
list.insert(index, (entry.clone(), source_clone, alias.clone()));
output_box_imp.resetSources.append(&*entry);
let mut map = output_box_imp.resetSourceMap.write().unwrap();
let mut index = output_box_imp.resetModelIndex.write().unwrap();
map.insert(alias, (*index, *index, name));
*index += 1;
});
});
true
});
if res.is_err() {
println!("fail on source add");
return conn;
}
let res = conn.add_match(source_removed, move |ir: SourceRemoved, _, _| {
let source_box = source_removed_box.clone();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetSourceList.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;
}
output_box_imp.resetSources.remove(&*entry.unwrap().0);
list.remove(&ir.index);
let alias = list.remove(&ir.index);
if alias.is_none() {
return;
}
let mut map = output_box_imp.resetSourceMap.write().unwrap();
map.remove(&alias.unwrap().2);
let mut index = output_box_imp.resetModelIndex.write().unwrap();
*index -= 1;
});
});
true
});
if res.is_err() {
println!("fail on source remove");
return conn;
}
let res = conn.add_match(source_changed, move |ir: SourceChanged, _, _| {
let source_box = source_changed_box.clone();
let default_source = get_default_source();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let list = output_box_imp.resetSourceList.read().unwrap();
let entry = list.get(&ir.source.index);
if entry.is_none() {
return;
}
let imp = entry.unwrap().1.imp();
let is_default = ir.source.name == default_source.name;
imp.resetSourceName
.set_text(ir.source.alias.clone().as_str());
let volume = ir.source.volume.first().unwrap_or_else(|| &(0 as u32));
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
if is_default {
imp.resetSelectedSource.set_active(true);
} else {
imp.resetSelectedSource.set_active(false);
}
});
});
true
});
if res.is_err() {
println!("fail on source remove");
return conn;
}
let res = conn.add_match(output_stream_added, move |ir: OutputStreamAdded, _, _| {
let source_box = output_stream_added_box.clone();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetOutputStreamList.write().unwrap();
let index = ir.stream.index;
let output_stream = Arc::new(OutputStreamEntry::new(output_box.clone(), ir.stream));
let entry = Arc::new(ListEntry::new(&*output_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), output_stream.clone()));
output_box_imp.resetOutputStreams.append(&*entry);
});
});
true
});
if res.is_err() {
println!("fail on stream add");
return conn;
}
let res = conn.add_match(
output_stream_changed,
move |ir: OutputStreamChanged, _, _| {
let imp = output_stream_changed_box.imp();
let alias: String;
{
let source_list = imp.resetSourceList.read().unwrap();
let alias_opt = source_list.get(&ir.stream.source_index);
if alias_opt.is_some() {
alias = alias_opt.unwrap().2.clone();
} else {
alias = String::from("");
}
}
let source_box = output_stream_changed_box.clone();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let entry: Arc<OutputStreamEntry>;
{
let list = output_box_imp.resetOutputStreamList.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
}
entry = entry_opt.unwrap().1.clone();
}
let imp = entry.imp();
if ir.stream.muted {
imp.resetSourceMute
.set_icon_name("microphone-volume-muted-symbolic");
} else {
imp.resetSourceMute
.set_icon_name("microphone-volume-high-symbolic");
}
let name = ir.stream.application_name.clone() + ": " + ir.stream.name.as_str();
imp.resetSourceName.set_text(name.as_str());
let volume = ir.stream.volume.first().unwrap_or_else(|| &(0 as u32));
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
imp.resetVolumeSlider.set_value(*volume as f64);
let map = output_box_imp.resetSourceMap.read().unwrap();
let index = map.get(&alias);
if index.is_some() {
imp.resetSelectedSource.set_selected(index.unwrap().1);
}
});
});
true
},
);
if res.is_err() {
println!("fail on stream change");
return conn;
}
let res = conn.add_match(
output_stream_removed,
move |ir: OutputStreamRemoved, _, _| {
let source_box = output_stream_removed_box.clone();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let mut list = output_box_imp.resetOutputStreamList.write().unwrap();
let entry = list.get(&ir.index);
if entry.is_none() {
return;
}
output_box_imp.resetOutputStreams.remove(&*entry.unwrap().0);
list.remove(&ir.index);
});
});
true
},
);
if res.is_err() {
println!("fail on stream remove");
return conn;
}
listeners.network_listener.store(true, Ordering::SeqCst);
conn
}

16
src/components/input/sourceBoxImpl.rs
View file

@ -1,13 +1,13 @@
use std::cell::RefCell;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::sync::{Arc, RwLock};
use crate::components::base::listEntry::ListEntry;
use crate::components::input::sourceBox;
use gtk::subclass::prelude::*;
use gtk::{glib, CheckButton, CompositeTemplate, DropDown, StringList, TemplateChild};
use gtk::{prelude::*, Button, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::{OutputStream, Source};
use ReSet_Lib::audio::audio::Source;
use super::outputStreamEntry::OutputStreamEntry;
use super::sourceEntry::SourceEntry;
@ -36,11 +36,13 @@ pub struct SourceBox {
pub resetOutputStreams: TemplateChild<gtk::Box>,
pub resetDefaultCheckButton: Arc<CheckButton>,
pub resetDefaultSource: Arc<RefCell<Source>>,
pub resetSourceList: Arc<Mutex<Vec<Source>>>,
pub resetOutputStreamList: Arc<Mutex<Vec<OutputStream>>>,
pub resetModelList: Arc<RefCell<StringList>>,
// first u32 is the index of the source, the second the index in the model list
pub resetSourceMap: Arc<RefCell<HashMap<String, (u32, u32, String)>>>,
pub resetSourceList: Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<SourceEntry>, String)>>>,
pub resetOutputStreamList: Arc<RwLock<HashMap<u32, (Arc<ListEntry>, Arc<OutputStreamEntry>)>>>,
pub resetModelList: Arc<RwLock<StringList>>,
pub resetModelIndex: Arc<RwLock<u32>>,
// first u32 is the index of the source, the second the index in the model list and the third is
// the full name
pub resetSourceMap: Arc<RwLock<HashMap<String, (u32, u32, String)>>>,
}
#[glib::object_subclass]

2
src/components/input/sourceEntry.rs
View file

@ -24,7 +24,6 @@ impl SourceEntry {
pub fn new(is_default: bool, check_group: Arc<CheckButton>, stream: Source) -> Self {
let obj: Self = Object::builder().build();
// TODO use event callback for progress bar -> this is the "im speaking" indicator
// TODO handle events
{
let imp = obj.imp();
imp.resetSourceName.set_text(stream.alias.clone().as_str());
@ -38,7 +37,6 @@ impl SourceEntry {
imp.resetVolumeSlider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
println!("{fraction}");
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
let source = imp.stream.borrow();