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

fix: Update default sink and source after setting it

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-12-09 13:39:38 +01:00
parent d3bc2edf88
commit 049a846c36
15 changed files with 425 additions and 258 deletions
Download patch file Download diff file Expand all files Collapse all files

228
src/components/input/source_box.rs
View file

@ -40,7 +40,13 @@ unsafe impl Sync for SourceBox {}
impl SourceBox {
pub fn new() -> Self {
Object::builder().build()
let obj: Self = Object::builder().build();
{
let imp = obj.imp();
let mut model_index = imp.reset_model_index.write().unwrap();
*model_index = 0;
}
obj
}
pub fn setup_callbacks(&self) {
@ -85,68 +91,70 @@ impl Default for SourceBox {
pub fn populate_sources(input_box: Arc<SourceBox>) {
gio::spawn_blocking(move || {
let output_box_imp = input_box.imp();
let sources = get_sources();
{
let list = output_box_imp.reset_model_list.write().unwrap();
let mut map = output_box_imp.reset_source_map.write().unwrap();
let mut model_index = output_box_imp.reset_model_index.write().unwrap();
let input_box_imp = input_box.imp();
let list = input_box_imp.reset_model_list.write().unwrap();
let mut map = input_box_imp.reset_source_map.write().unwrap();
let mut model_index = input_box_imp.reset_model_index.write().unwrap();
input_box_imp
.reset_default_source
.replace(get_default_source());
for (i, source) in (0_u32..).zip(sources.iter()) {
list.append(&source.alias);
map.insert(source.alias.clone(), (source.index, i, source.name.clone()));
*model_index += 1;
}
}
output_box_imp
.reset_default_source
.replace(get_default_source());
populate_outputstreams(input_box.clone());
populate_cards(input_box.clone());
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box_ref_slider = input_box.clone();
let output_box_ref_mute = input_box.clone();
let output_box_ref = input_box.clone();
let input_box_ref_slider = input_box.clone();
let input_box_ref_toggle = input_box.clone();
let input_box_ref_mute = input_box.clone();
let input_box_ref = input_box.clone();
{
let output_box_imp = output_box_ref.imp();
let default_sink = output_box_imp.reset_default_source.clone();
let input_box_imp = input_box_ref.imp();
let default_sink = input_box_imp.reset_default_source.clone();
let source = default_sink.borrow();
let volume = source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
output_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = output_box_imp.reset_source_list.write().unwrap();
for stream in sources {
input_box_imp.reset_volume_percentage.set_text(&percentage);
input_box_imp.reset_volume_slider.set_value(*volume as f64);
let mut list = input_box_imp.reset_source_list.write().unwrap();
for source in sources {
let index = source.index;
let alias = source.alias.clone();
let mut is_default = false;
if output_box_imp.reset_default_source.borrow().name == stream.name {
if input_box_imp.reset_default_source.borrow().name == source.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
output_box_imp.reset_default_check_button.clone(),
stream,
input_box_imp.reset_default_check_button.clone(),
source,
input_box.clone(),
));
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));
output_box_imp.reset_sources.append(&*entry);
input_box_imp.reset_sources.append(&*entry);
}
let list = output_box_imp.reset_model_list.read().unwrap();
output_box_imp.reset_source_dropdown.set_model(Some(&*list));
let map = output_box_imp.reset_source_map.read().unwrap();
let name = output_box_imp.reset_default_source.borrow();
let list = input_box_imp.reset_model_list.read().unwrap();
input_box_imp.reset_source_dropdown.set_model(Some(&*list));
let map = input_box_imp.reset_source_map.read().unwrap();
let name = input_box_imp.reset_default_source.borrow();
if let Some(index) = map.get(&name.alias) {
output_box_imp.reset_source_dropdown.set_selected(index.1);
input_box_imp.reset_source_dropdown.set_selected(index.1);
}
output_box_imp
.reset_source_dropdown
.connect_selected_notify(clone!(@weak output_box_imp => move |dropdown| {
input_box_imp.reset_source_dropdown.connect_selected_notify(
clone!(@weak input_box_imp => move |dropdown| {
let input_box = input_box_ref_toggle.clone();
let selected = dropdown.selected_item();
if selected.is_none() {
return;
@ -155,20 +163,27 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = output_box_imp.reset_source_map.read().unwrap();
let source = input_box_imp.reset_source_map.read().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;
}
let sink = Arc::new(source.unwrap().2.clone());
set_default_source(sink);
}));
let source = Arc::new(source.unwrap().2.clone());
gio::spawn_blocking(move || {
let result = set_default_source(source);
if result.is_none(){
return;
}
refresh_default_source(result.unwrap(), input_box.clone(), false);
});
}),
);
}
output_box_ref
input_box_ref
.imp()
.reset_volume_slider
.connect_change_value(move |_, _, value| {
let imp = output_box_ref_slider.imp();
let imp = input_box_ref_slider.imp();
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage);
@ -188,27 +203,64 @@ pub fn populate_sources(input_box: Arc<SourceBox>) {
Propagation::Proceed
});
output_box_ref
input_box_ref
.imp()
.reset_source_mute
.connect_clicked(move |_| {
let imp = output_box_ref_mute.imp();
let mut stream = imp.reset_default_source.borrow_mut();
stream.muted = !stream.muted;
if stream.muted {
let imp = input_box_ref_mute.imp();
let mut source = imp.reset_default_source.borrow_mut();
source.muted = !source.muted;
if source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_source_mute(stream.index, stream.muted);
toggle_source_mute(source.index, source.muted);
});
});
});
});
}
pub fn refresh_default_source(new_source: Source, input_box: Arc<SourceBox>, entry: bool) {
let volume = *new_source.volume.first().unwrap_or(&0_u32);
let fraction = (volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = input_box.imp();
if !entry {
let list = imp.reset_source_list.read().unwrap();
let entry = list.get(&new_source.index);
if entry.is_none() {
return;
}
let entry_imp = entry.unwrap().1.imp();
entry_imp.reset_selected_source.set_active(true);
} else {
let map = imp.reset_source_map.read().unwrap();
let entry = map.get(&new_source.alias);
if entry.is_none() {
return;
}
imp.reset_source_dropdown.set_selected(entry.unwrap().1);
}
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(volume as f64);
if new_source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
imp.reset_default_source.replace(new_source);
});
});
}
pub fn populate_outputstreams(input_box: Arc<SourceBox>) {
let input_box_ref = input_box.clone();
@ -234,11 +286,11 @@ pub fn populate_outputstreams(input_box: Arc<SourceBox>) {
pub fn populate_cards(input_box: Arc<SourceBox>) {
gio::spawn_blocking(move || {
let output_box_ref = input_box.clone();
let input_box_ref = input_box.clone();
let cards = get_cards();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = output_box_ref.imp();
let imp = input_box_ref.imp();
for card in cards {
imp.reset_cards.add(&CardEntry::new(card));
}
@ -365,29 +417,30 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
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.reset_source_list.write().unwrap();
let input_box = source_box.clone();
let input_box_imp = input_box.imp();
let mut list = input_box_imp.reset_source_list.write().unwrap();
let source_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.reset_default_source.borrow().name == ir.source.name {
if input_box_imp.reset_default_source.borrow().name == ir.source.name {
is_default = true;
}
let source_entry = Arc::new(SourceEntry::new(
is_default,
output_box_imp.reset_default_check_button.clone(),
input_box_imp.reset_default_check_button.clone(),
ir.source,
input_box.clone(),
));
let source_clone = source_entry.clone();
let entry = Arc::new(ListEntry::new(&*source_entry));
entry.set_activatable(false);
list.insert(source_index, (entry.clone(), source_clone, alias.clone()));
output_box_imp.reset_sources.append(&*entry);
let mut map = output_box_imp.reset_source_map.write().unwrap();
let mut index = output_box_imp.reset_model_index.write().unwrap();
output_box_imp
input_box_imp.reset_sources.append(&*entry);
let mut map = input_box_imp.reset_source_map.write().unwrap();
let mut index = input_box_imp.reset_model_index.write().unwrap();
input_box_imp
.reset_model_list
.write()
.unwrap()
@ -407,29 +460,26 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
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.reset_source_list.write().unwrap();
let entry = list.get(&ir.index);
let input_box = source_box.clone();
let input_box_imp = input_box.imp();
let mut list = input_box_imp.reset_source_list.write().unwrap();
let entry = list.remove(&ir.index);
if entry.is_none() {
return;
}
output_box_imp.reset_sources.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.reset_source_map.write().unwrap();
let entry_index = map.remove(&alias.unwrap().2);
input_box_imp
.reset_sources
.remove(&*entry.clone().unwrap().0);
let mut map = input_box_imp.reset_source_map.write().unwrap();
let entry_index = map.remove(&entry.unwrap().2);
if let Some(entry_index) = entry_index {
output_box_imp
input_box_imp
.reset_model_list
.write()
.unwrap()
.remove(entry_index.1);
}
let mut index = output_box_imp.reset_model_index.write().unwrap();
let mut index = input_box_imp.reset_model_index.write().unwrap();
if *index != 0 {
*index -= 1;
}
@ -447,30 +497,31 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let default_source = get_default_source_name();
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box = source_box.clone();
let output_box_imp = output_box.imp();
let input_box = source_box.clone();
let input_box_imp = input_box.imp();
let is_default = ir.source.name == default_source;
let volume = ir.source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
let list = output_box_imp.reset_source_list.read().unwrap();
let list = input_box_imp.reset_source_list.read().unwrap();
let entry = list.get(&ir.source.index);
if entry.is_none() {
return;
}
let imp = entry.unwrap().1.imp();
if is_default {
output_box_imp.reset_volume_percentage.set_text(&percentage);
output_box_imp.reset_volume_slider.set_value(*volume as f64);
output_box_imp
input_box_imp.reset_volume_percentage.set_text(&percentage);
input_box_imp.reset_volume_slider.set_value(*volume as f64);
input_box_imp
.reset_default_source
.replace(ir.source.clone());
if ir.source.muted {
output_box_imp
input_box_imp
.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
output_box_imp
input_box_imp
.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
@ -502,16 +553,15 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
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.reset_output_stream_list.write().unwrap();
let input_box = source_box.clone();
let input_box_imp = input_box.imp();
let mut list = input_box_imp.reset_output_stream_list.write().unwrap();
let index = ir.stream.index;
let output_stream = Arc::new(OutputStreamEntry::new(output_box.clone(), ir.stream));
let output_stream_clone = output_stream.clone();
let output_stream = Arc::new(OutputStreamEntry::new(input_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.reset_output_streams.append(&*entry);
list.insert(index, (entry.clone(), output_stream.clone()));
input_box_imp.reset_output_streams.append(&*entry);
});
});
true
@ -537,11 +587,11 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
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 input_box = source_box.clone();
let input_box_imp = input_box.imp();
let entry: Arc<OutputStreamEntry>;
{
let list = output_box_imp.reset_output_stream_list.read().unwrap();
let list = input_box_imp.reset_output_stream_list.read().unwrap();
let entry_opt = list.get(&ir.stream.index);
if entry_opt.is_none() {
return;
@ -563,7 +613,7 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
let map = output_box_imp.reset_source_map.read().unwrap();
let map = input_box_imp.reset_source_map.read().unwrap();
if let Some(index) = map.get(&alias) {
imp.reset_source_selection.set_selected(index.1);
}
@ -583,14 +633,14 @@ pub fn start_input_box_listener(conn: Connection, source_box: Arc<SourceBox>) ->
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.reset_output_stream_list.write().unwrap();
let input_box = source_box.clone();
let input_box_imp = input_box.imp();
let mut list = input_box_imp.reset_output_stream_list.write().unwrap();
let entry = list.remove(&ir.index);
if entry.is_none() {
return;
}
output_box_imp
input_box_imp
.reset_output_streams
.remove(&*entry.unwrap().0);
});

71
src/components/input/source_entry.rs
View file

@ -11,6 +11,7 @@ use glib::{clone, Propagation};
use gtk::{gio, CheckButton};
use re_set_lib::audio::audio_structures::Source;
use super::source_box::{refresh_default_source, SourceBox};
use super::source_entry_impl;
glib::wrapper! {
@ -23,26 +24,31 @@ unsafe impl Send for SourceEntry {}
unsafe impl Sync for SourceEntry {}
impl SourceEntry {
pub fn new(is_default: bool, check_group: Arc<CheckButton>, stream: Source) -> Self {
pub fn new(
is_default: bool,
check_group: Arc<CheckButton>,
source: Source,
input_box: Arc<SourceBox>,
) -> Self {
let obj: Self = Object::builder().build();
// TODO use event callback for progress bar -> this is the "im speaking" indicator
{
let imp = obj.imp();
imp.reset_source_name
.set_title(stream.alias.clone().as_str());
let name = Arc::new(stream.name.clone());
let volume = stream.volume.first().unwrap_or(&0_u32);
.set_title(source.alias.clone().as_str());
let name = Arc::new(source.name.clone());
let volume = source.volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage);
imp.reset_volume_slider.set_value(*volume as f64);
imp.stream.replace(stream);
imp.source.replace(source);
imp.reset_volume_slider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.reset_volume_percentage.set_text(&percentage);
let source = imp.stream.borrow();
let source = imp.source.borrow();
let index = source.index;
let channels = source.channels;
{
@ -65,23 +71,30 @@ impl SourceEntry {
imp.reset_selected_source.set_active(false);
}
imp.reset_selected_source.connect_toggled(move |button| {
let input_box = input_box.clone();
if button.is_active() {
set_default_source(name.clone());
let name = name.clone();
gio::spawn_blocking(move || {
let result = set_default_source(name);
if result.is_none() {
return;
}
refresh_default_source(result.unwrap(), input_box, true);
});
}
});
imp.reset_source_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.borrow_mut();
stream.muted = !stream.muted;
if stream.muted {
let mut source = imp.source.borrow_mut();
source.muted = !source.muted;
if source.muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_source_mute(stream.index, stream.muted);
toggle_source_mute(source.index, source.muted);
}));
}
obj
@ -127,22 +140,20 @@ pub fn toggle_source_mute(index: u32, muted: bool) -> bool {
true
}
pub fn set_default_source(name: Arc<String>) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSetDaemon",
"/org/Xetibo/ReSetDaemon",
Duration::from_millis(1000),
);
let _: Result<(), Error> =
proxy.method_call("org.Xetibo.ReSetAudio", "SetDefaultSink", (name.as_str(),));
// if res.is_err() {
// return;
// }
// handle change
});
true
pub fn set_default_source(name: Arc<String>) -> Option<Source> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.Xetibo.ReSetDaemon",
"/org/Xetibo/ReSetDaemon",
Duration::from_millis(1000),
);
let res: Result<(Source,), Error> = proxy.method_call(
"org.Xetibo.ReSetAudio",
"SetDefaultSource",
(name.as_str(),),
);
if res.is_err() {
return None;
}
Some(res.unwrap().0)
}
// TODO propagate error from dbus

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

@ -25,7 +25,7 @@ pub struct SourceEntry {
pub reset_volume_percentage: TemplateChild<Label>,
#[template_child]
pub reset_volume_meter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<Source>>,
pub source: Arc<RefCell<Source>>,
pub volume_time_stamp: RefCell<Option<SystemTime>>,
}