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

wip: Add generic audio stream

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2024-04-02 12:13:09 +02:00
parent 88db8f33dd
commit 4d974ef408
18 changed files with 347 additions and 464 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -9,7 +9,7 @@ license = "GPL-3.0-or-later"
[dependencies]
# reset_daemon = "1.1.0"
re_set-lib = { git = "https://github.com/Xetibo/ReSet-Lib" , branch = "audioobject"}
# re_set-lib = "3.1.6"
# re_set-lib = "3.1.7"
reset_daemon = { git = "https://github.com/Xetibo/ReSet-Daemon", branch = "dashie" }
adw = { version = "0.6.0", package = "libadwaita", features = ["v1_4"] }
dbus = "0.9.7"

189
src/components/audio/generic_audio_functions.rs
View file

@ -1,11 +1,26 @@
use std::sync::Arc;
use std::{
sync::Arc,
time::{Duration, SystemTime},
};
use adw::prelude::ComboRowExt;
use gtk::prelude::{ButtonExt, CheckButtonExt, RangeExt};
use adw::{prelude::ComboRowExt, prelude::PreferencesRowExt};
use glib::{object::Cast, Object, Propagation};
use gtk::{
prelude::{ButtonExt, CheckButtonExt, RangeExt},
StringObject,
};
use re_set_lib::audio::audio_structures::{TAudioObject, TAudioStreamObject};
use super::generic_entry::{
TAudioBox, TAudioBoxImpl, TAudioEntry, TAudioEntryImpl, TAudioStream, TAudioStreamImpl,
use crate::components::{
base::error_impl::ReSetErrorImpl,
utils::{create_dropdown_label_factory, set_combo_row_ellipsis},
};
use super::{
generic_entry::{
TAudioBox, TAudioBoxImpl, TAudioEntry, TAudioEntryImpl, TAudioStream, TAudioStreamImpl,
},
generic_utils::audio_dbus_call,
};
pub fn refresh_default_audio_object<
@ -61,3 +76,167 @@ pub fn refresh_default_audio_object<
});
});
}
pub fn new_stream_entry<
AudioObject: TAudioObject + Send + Sync + 'static,
StreamObject: TAudioStreamObject + Send + Sync + 'static,
AudioEntry: TAudioEntry<AudioEntryImpl>,
AudioEntryImpl: TAudioEntryImpl<AudioObject>,
AudioStream: TAudioStream<AudioStreamImpl>,
AudioStreamImpl: TAudioStreamImpl<AudioObject, StreamObject>,
AudioBox: TAudioBox<AudioBoxImpl> + ReSetErrorImpl + Send + Sync + 'static,
AudioBoxImpl: TAudioBoxImpl<AudioObject, AudioEntry, AudioStream>,
>(
audio_box: Arc<AudioBox>,
stream: StreamObject,
) -> Arc<AudioStream> {
let obj: Arc<AudioStream> = Arc::new(Object::builder().build());
// TODO use event callback for progress bar -> this is the "im speaking" indicator
let output_box_mute_ref = audio_box.clone();
let output_box_volume_ref = audio_box.clone();
let output_box_sink_ref = audio_box.clone();
let entry_mute_ref = obj.clone();
let entry_volume_ref = obj.clone();
let entry_sink_ref = obj.clone();
{
let index = stream.audio_object_index();
let box_imp = audio_box.box_imp();
let imp = obj.entry_imp();
let icons = box_imp.icons();
if stream.muted() {
imp.audio_object_mute().set_icon_name(icons.muted);
} else {
imp.audio_object_mute().set_icon_name(icons.active);
}
let name = stream.application_name().clone() + ": " + stream.name().as_str();
imp.audio_object_selection().set_title(name.as_str());
imp.audio_object_selection()
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.audio_object_selection().get());
let volume = stream.volume();
let volume = volume.first().unwrap_or(&0_u32);
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.volume_percentage().set_text(&percentage);
imp.volume_slider().set_value(*volume as f64);
imp.stream_object().replace(stream);
{
let sink = box_imp.default_audio_object();
let sink = sink.borrow();
imp.associated_audio_object()
.replace((sink.index(), sink.name().clone()));
}
imp.volume_slider()
.connect_change_value(move |_, _, value| {
let imp = entry_volume_ref.entry_imp();
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.volume_percentage().set_text(&percentage);
let stream = imp.stream_object();
let mut stream_opt = stream.try_borrow();
while stream_opt.is_err() {
stream_opt = stream.try_borrow();
}
let stream = stream_opt.unwrap();
let index = stream.index();
let channels = stream.channels();
{
let mut time = imp.volume_time_stamp().borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
return Propagation::Proceed;
}
*time = Some(SystemTime::now());
}
audio_dbus_call::<AudioBox, (), (u32, u16, u32)>(
output_box_volume_ref.clone(),
(index, channels, value as u32),
imp.set_volume_fn(),
);
Propagation::Proceed
});
{
let list = box_imp.model_list();
let list = list.read().unwrap();
imp.audio_object_selection().set_model(Some(&*list));
let sink_list = box_imp.audio_object_list().read().unwrap();
let name = sink_list.get(&index);
let index = box_imp.model_index();
let index = index.read().unwrap();
if let Some(name) = name {
for entry in 0..*index {
if list.string(entry) == Some(name.2.clone().into()) {
imp.audio_object_selection().set_selected(entry);
break;
}
}
} else {
let name = box_imp.default_audio_object();
let mut name_opt = name.try_borrow();
while name_opt.is_err() {
name_opt = name.try_borrow();
}
let name = name_opt.unwrap();
for entry in 0..*index {
if list.string(entry) == Some(name.alias().into()) {
imp.audio_object_selection().set_selected(entry);
break;
}
}
}
}
imp.audio_object_selection()
.connect_selected_notify(move |dropdown| {
let imp = entry_sink_ref.entry_imp();
let box_imp = output_box_sink_ref.box_imp();
let selected = dropdown.selected_item();
if selected.is_none() {
return;
}
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let sink = box_imp.source_map().read().unwrap();
let sink = sink.get(&selected);
if sink.is_none() {
return;
}
let stream = imp.stream_object();
let mut stream_opt = stream.try_borrow();
while stream_opt.is_err() {
stream_opt = stream.try_borrow();
}
let stream = stream_opt.unwrap();
let sink = sink.unwrap().0;
audio_dbus_call::<AudioBox, (), (u32, u32)>(
output_box_sink_ref.clone(),
(stream.index(), sink),
imp.set_audio_object_fn(),
);
});
imp.audio_object_mute().connect_clicked(move |_| {
let imp = entry_mute_ref.entry_imp();
let stream = imp.stream_object().clone();
let mut stream_opt = stream.try_borrow_mut();
while stream_opt.is_err() {
stream_opt = stream.try_borrow_mut();
}
let mut stream = stream_opt.unwrap();
stream.toggle_muted();
let icons = imp.icons();
let muted = stream.muted();
if muted {
imp.audio_object_mute().set_icon_name(icons.muted);
} else {
imp.audio_object_mute().set_icon_name(icons.active);
}
audio_dbus_call::<AudioBox, (), (u32, bool)>(
output_box_mute_ref.clone(),
(stream.index(), muted),
imp.set_mute_fn(),
);
});
}
obj
}

2
src/components/audio/generic_const.rs
View file

@ -1,6 +1,6 @@
use super::generic_entry::DBusFunction;
pub const LISTCARDS: DBusFunction = DBusFunction {
pub const GETCARDS: DBusFunction = DBusFunction {
function: "ListCards",
error: "Failed to get list profiles",
};

7
src/components/audio/generic_entry.rs
View file

@ -59,7 +59,6 @@ pub trait TAudioEntry<TAudioEntryImpl>: IsClass + IsA<glib::Object> {
fn entry_imp(&self) -> &TAudioEntryImpl;
}
#[allow(dead_code)]
pub trait TAudioEntryImpl<AudioObject: TAudioObject> {
fn name(&self) -> &TemplateChild<ActionRow>;
fn selected_audio_object(&self) -> &TemplateChild<CheckButton>;
@ -74,7 +73,7 @@ pub trait TAudioEntryImpl<AudioObject: TAudioObject> {
fn icons(&self) -> &AudioIcons;
}
pub trait TAudioStream<TAudioStreamImpl> {
pub trait TAudioStream<TAudioStreamImpl>: IsClass + IsA<glib::Object> {
fn entry_imp(&self) -> &TAudioStreamImpl;
}
@ -86,6 +85,10 @@ pub trait TAudioStreamImpl<AudioObject: TAudioObject, StreamObject: TAudioStream
fn stream_object(&self) -> Arc<RefCell<StreamObject>>;
fn associated_audio_object(&self) -> Arc<RefCell<(u32, String)>>;
fn volume_time_stamp(&self) -> &RefCell<Option<SystemTime>>;
fn set_volume_fn(&self) -> &'static DBusFunction;
fn set_audio_object_fn(&self) -> &'static DBusFunction;
fn set_mute_fn(&self) -> &'static DBusFunction;
fn icons(&self) -> &AudioIcons;
}
pub struct AudioIcons {

195
src/components/audio/input/output_stream_entry.rs
View file

@ -1,23 +1,13 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::audio::generic_audio_functions::new_stream_entry;
use crate::components::audio::generic_entry::TAudioStream;
use crate::components::base::error_impl::show_error;
use crate::components::utils::{
create_dropdown_label_factory, set_combo_row_ellipsis, AUDIO, BASE, DBUS_PATH,
};
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
use dbus::blocking::Connection;
use dbus::Error;
use glib::prelude::Cast;
use glib::subclass::types::ObjectSubclassIsExt;
use glib::{clone, Propagation};
use gtk::{gio, StringObject};
use re_set_lib::audio::audio_structures::OutputStream;
use re_set_lib::audio::audio_structures::{OutputStream, Source};
use super::output_stream_entry_impl;
use super::source_box::SourceBox;
use super::source_entry::SourceEntry;
glib::wrapper! {
pub struct OutputStreamEntry(ObjectSubclass<output_stream_entry_impl::OutputStreamEntry>)
@ -35,173 +25,16 @@ impl TAudioStream<super::output_stream_entry_impl::OutputStreamEntry> for Output
}
impl OutputStreamEntry {
pub fn new(source_box: Arc<SourceBox>, stream: OutputStream) -> Self {
let obj: Self = Object::builder().build();
// TODO use event callback for progress bar -> this is the "im speaking" indicator
let output_box_volume_ref = source_box.clone();
let output_box_mute_ref = source_box.clone();
let output_box_source_ref = source_box.clone();
{
let index = stream.index;
let box_imp = source_box.imp();
let imp = obj.imp();
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.reset_source_selection.set_title(name.as_str());
imp.reset_source_selection
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.reset_source_selection.get());
let volume = stream.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.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 mut stream = imp.stream.try_borrow();
while stream.is_err() {
stream = imp.stream.try_borrow();
}
let stream = stream.unwrap();
let index = stream.index;
let channels = stream.channels;
{
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some()
&& time.unwrap().elapsed().unwrap() < Duration::from_millis(50)
{
return Propagation::Proceed;
}
*time = Some(SystemTime::now());
}
set_outputstream_volume(value, index, channels, output_box_volume_ref.clone());
Propagation::Proceed
}),
);
{
let list = box_imp.reset_model_list.read().unwrap();
imp.reset_source_selection.set_model(Some(&*list));
let source_list = box_imp.reset_source_list.read().unwrap();
let name = source_list.get(&index);
let index = box_imp.reset_model_index.read().unwrap();
let model_list = box_imp.reset_model_list.read().unwrap();
if let Some(name) = name {
for entry in 0..*index {
if model_list.string(entry) == Some(name.2.clone().into()) {
imp.reset_source_selection.set_selected(entry);
break;
}
}
} else {
let mut name = box_imp.reset_default_source.try_borrow();
while name.is_err() {
name = box_imp.reset_default_source.try_borrow();
}
let name = name.unwrap();
for entry in 0..*index {
if model_list.string(entry) == Some(name.alias.clone().into()) {
imp.reset_source_selection.set_selected(entry);
break;
}
}
}
}
imp.reset_source_selection.connect_selected_notify(
clone!(@weak imp, @weak box_imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
return;
}
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let source = box_imp.reset_source_map.write().unwrap();
let source = source.get(&selected);
if source.is_none() {
return;
}
let mut stream = imp.stream.try_borrow();
while stream.is_err() {
stream = imp.stream.try_borrow();
}
let stream = stream.unwrap();
let source = source.unwrap().0;
set_source_of_output_stream(stream.index, source, output_box_source_ref.clone());
}),
);
imp.reset_source_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.try_borrow_mut();
while stream.is_err() {
stream = imp.stream.try_borrow_mut();
}
let mut stream = stream.unwrap();
stream.muted = !stream.muted;
let muted = stream.muted;
let index = stream.index;
if muted {
imp.reset_source_mute
.set_icon_name("microphone-disabled-symbolic");
} else {
imp.reset_source_mute
.set_icon_name("audio-input-microphone-symbolic");
}
toggle_output_stream_mute(index, muted, output_box_mute_ref.clone());
}));
}
obj
pub fn new(source_box: Arc<SourceBox>, stream: OutputStream) -> Arc<Self> {
new_stream_entry::<
Source,
OutputStream,
SourceEntry,
super::source_entry_impl::SourceEntry,
OutputStreamEntry,
super::output_stream_entry_impl::OutputStreamEntry,
SourceBox,
super::source_box_impl::SourceBox,
>(source_box, stream)
}
}
fn set_outputstream_volume(
value: f64,
index: u32,
channels: u16,
input_box: Arc<SourceBox>,
) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(), Error> = proxy.method_call(
AUDIO,
"SetOutputStreamVolume",
(index, channels, value as u32),
);
if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to set output stream volume");
}
});
true
}
fn toggle_output_stream_mute(index: u32, muted: bool, input_box: Arc<SourceBox>) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(), Error> =
proxy.method_call(AUDIO, "SetOutputStreamMute", (index, muted));
if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to mute output stream");
}
});
true
}
fn set_source_of_output_stream(stream: u32, source: u32, input_box: Arc<SourceBox>) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(bool,), Error> =
proxy.method_call(AUDIO, "SetSourceOfOutputStream", (stream, source));
if res.is_err() {
show_error::<SourceBox>(input_box.clone(), "Failed to set source of output stream");
}
});
true
}
// TODO propagate error from dbus

22
src/components/audio/input/output_stream_entry_impl.rs
View file

@ -5,11 +5,13 @@ use std::cell::RefCell;
use std::sync::Arc;
use std::time::SystemTime;
use crate::components::audio::generic_entry::TAudioStreamImpl;
use crate::components::audio::generic_entry::{AudioIcons, TAudioStreamImpl};
use crate::components::audio::input::output_stream_entry;
use gtk::subclass::prelude::*;
use gtk::{Button, CompositeTemplate, Label, Scale};
use super::source_const::{ICONS, SETSTREAMMUTE, SETSTREAMOBJECT, SETSTREAMVOLUME};
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetOutputStreamEntry.ui")]
pub struct OutputStreamEntry {
@ -76,4 +78,22 @@ impl TAudioStreamImpl<Source, OutputStream> for OutputStreamEntry {
fn volume_time_stamp(&self) -> &RefCell<Option<SystemTime>> {
&self.volume_time_stamp
}
fn set_volume_fn(&self) -> &'static crate::components::audio::generic_entry::DBusFunction {
&SETSTREAMVOLUME
}
fn set_audio_object_fn(
&self,
) -> &'static crate::components::audio::generic_entry::DBusFunction {
&SETSTREAMOBJECT
}
fn set_mute_fn(&self) -> &'static crate::components::audio::generic_entry::DBusFunction {
&SETSTREAMMUTE
}
fn icons(&self) -> &AudioIcons {
&ICONS
}
}

23
src/components/audio/input/source_box.rs
View file

@ -1,3 +1,4 @@
use re_set_lib::audio::audio_structures::Source;
use re_set_lib::signals::{
OutputStreamAdded, OutputStreamChanged, OutputStreamRemoved, SourceAdded, SourceChanged,
SourceRemoved,
@ -15,6 +16,7 @@ use gtk::gio;
use gtk::prelude::ActionableExt;
use crate::components::audio::generic_entry::TAudioBox;
use crate::components::audio::generic_utils::audio_dbus_call;
use crate::components::audio::input::source_box_impl;
use crate::components::base::error::{self};
use crate::components::base::error_impl::ReSetErrorImpl;
@ -27,9 +29,9 @@ use super::source_box_handlers::{
source_added_handler, source_changed_handler, source_removed_handler,
};
use super::source_box_utils::{
get_default_source, get_sources, populate_cards, populate_outputstreams,
populate_source_information,
populate_cards, populate_outputstreams, populate_source_information,
};
use super::source_const::{GETDEFAULT, GETOBJECTS};
glib::wrapper! {
pub struct SourceBox(ObjectSubclass<source_box_impl::SourceBox>)
@ -105,15 +107,24 @@ impl Default for SourceBox {
pub fn populate_sources(source_box: Arc<SourceBox>) {
gio::spawn_blocking(move || {
let sources = get_sources(source_box.clone());
let sources =
audio_dbus_call::<SourceBox, (Vec<Source>,), ()>(source_box.clone(), (), &GETOBJECTS);
if sources.is_none() {
return;
}
let sources = sources.unwrap().0;
{
let source_box_imp = source_box.imp();
let list = source_box_imp.reset_model_list.write().unwrap();
let mut map = source_box_imp.reset_source_map.write().unwrap();
let mut model_index = source_box_imp.reset_model_index.write().unwrap();
source_box_imp
.reset_default_source
.replace(get_default_source(source_box.clone()));
let source =
audio_dbus_call::<SourceBox, (Source,), ()>(source_box.clone(), (), &GETDEFAULT);
if let Some(source) = source {
source_box_imp.reset_default_source.replace(source.0);
}
for source in sources.iter() {
list.append(&source.alias);
map.insert(source.alias.clone(), (source.index, source.name.clone()));

13
src/components/audio/input/source_box_handlers.rs
View file

@ -24,8 +24,8 @@ use crate::components::{audio::generic_utils::audio_dbus_call, base::list_entry:
use super::{
output_stream_entry::OutputStreamEntry,
source_box::SourceBox,
source_box_utils::{get_default_source_name, refresh_default_source},
source_const::{SETDEFAULT, SETMUTE, SETVOLUME},
source_box_utils::refresh_default_source,
source_const::{GETDEFAULTNAME, SETDEFAULT, SETMUTE, SETVOLUME},
source_entry::SourceEntry,
};
@ -114,7 +114,12 @@ pub fn source_removed_handler(source_box: Arc<SourceBox>, ir: SourceRemoved) ->
}
pub fn source_changed_handler(source_box: Arc<SourceBox>, ir: SourceChanged) -> bool {
let default_source = get_default_source_name(source_box.clone());
let source =
audio_dbus_call::<SourceBox, (String,), ()>(source_box.clone(), (), &GETDEFAULTNAME);
if source.is_none() {
return false;
}
let default_source = source.unwrap().0;
glib::spawn_future(async move {
glib::idle_add_once(move || {
let source_box = source_box.clone();
@ -172,7 +177,7 @@ pub fn output_stream_added_handler(source_box: Arc<SourceBox>, ir: OutputStreamA
let source_box_imp = source_box.imp();
let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
let index = ir.stream.index;
let output_stream = Arc::new(OutputStreamEntry::new(source_box.clone(), ir.stream));
let output_stream = OutputStreamEntry::new(source_box.clone(), ir.stream);
let entry = Arc::new(ListEntry::new(&*output_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), output_stream.clone()));

84
src/components/audio/input/source_box_utils.rs
View file

@ -1,7 +1,6 @@
use std::{sync::Arc, time::Duration};
use std::sync::Arc;
use adw::prelude::{ComboRowExt, PreferencesGroupExt};
use dbus::{blocking::Connection, Error};
use glib::subclass::types::ObjectSubclassIsExt;
use gtk::{
gio,
@ -10,14 +9,15 @@ use gtk::{
use re_set_lib::audio::audio_structures::{Card, OutputStream, Source};
use crate::components::{
base::{card_entry::CardEntry, error_impl::show_error, list_entry::ListEntry},
utils::{AUDIO, BASE, DBUS_PATH},
audio::{generic_const::GETCARDS, generic_utils::audio_dbus_call},
base::{card_entry::CardEntry, list_entry::ListEntry},
};
use super::{
output_stream_entry::OutputStreamEntry,
source_box::SourceBox,
source_box_handlers::{dropdown_handler, mute_clicked_handler, volume_slider_handler},
source_const::GETSTREAMS,
source_entry::SourceEntry,
};
@ -136,16 +136,23 @@ pub fn refresh_default_source(new_source: Source, source_box: Arc<SourceBox>, en
pub fn populate_outputstreams(source_box: Arc<SourceBox>) {
let source_box_ref = source_box.clone();
gio::spawn_blocking(move || {
let streams = get_output_streams(source_box.clone());
let streams = audio_dbus_call::<SourceBox, (Vec<OutputStream>,), ()>(
source_box.clone(),
(),
&GETSTREAMS,
);
if streams.is_none() {
return;
}
let streams = streams.unwrap().0;
glib::spawn_future(async move {
glib::idle_add_once(move || {
let source_box_imp = source_box_ref.imp();
let mut list = source_box_imp.reset_output_stream_list.write().unwrap();
for stream in streams {
let index = stream.index;
let input_stream = Arc::new(OutputStreamEntry::new(source_box.clone(), stream));
let input_stream = OutputStreamEntry::new(source_box.clone(), stream);
let input_stream_clone = input_stream.clone();
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
@ -160,7 +167,12 @@ pub fn populate_outputstreams(source_box: Arc<SourceBox>) {
pub fn populate_cards(source_box: Arc<SourceBox>) {
gio::spawn_blocking(move || {
let source_box_ref = source_box.clone();
let cards = get_cards(source_box.clone());
let cards =
audio_dbus_call::<SourceBox, (Vec<Card>,), ()>(source_box.clone(), (), &GETCARDS);
if cards.is_none() {
return;
}
let cards = cards.unwrap().0;
glib::spawn_future(async move {
glib::idle_add_once(move || {
let imp = source_box_ref.imp();
@ -171,59 +183,3 @@ pub fn populate_cards(source_box: Arc<SourceBox>) {
});
});
}
pub fn get_output_streams(source_box: Arc<SourceBox>) -> Vec<OutputStream> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<OutputStream>,), Error> =
proxy.method_call(AUDIO, "ListOutputStreams", ());
if res.is_err() {
show_error::<SourceBox>(source_box.clone(), "Failed to get output streams");
return Vec::new();
}
res.unwrap().0
}
pub fn get_sources(source_box: Arc<SourceBox>) -> Vec<Source> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<Source>,), Error> = proxy.method_call(AUDIO, "ListSources", ());
if res.is_err() {
show_error::<SourceBox>(source_box.clone(), "Failed to get sources");
return Vec::new();
}
res.unwrap().0
}
pub fn get_cards(source_box: Arc<SourceBox>) -> Vec<Card> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Vec<Card>,), Error> = proxy.method_call(AUDIO, "ListCards", ());
if res.is_err() {
show_error::<SourceBox>(source_box.clone(), "Failed to get profiles");
return Vec::new();
}
res.unwrap().0
}
pub fn get_default_source_name(source_box: Arc<SourceBox>) -> String {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(String,), Error> = proxy.method_call(AUDIO, "GetDefaultSourceName", ());
if res.is_err() {
show_error::<SourceBox>(source_box.clone(), "Failed to get default source name");
return String::from("");
}
res.unwrap().0
}
pub fn get_default_source(source_box: Arc<SourceBox>) -> Source {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(Source,), Error> = proxy.method_call(AUDIO, "GetDefaultSource", ());
if res.is_err() {
show_error::<SourceBox>(source_box.clone(), "Failed to get default source");
return Source::default();
}
res.unwrap().0
}

19
src/components/audio/input/source_const.rs
View file

@ -1,8 +1,8 @@
use crate::components::audio::generic_entry::{AudioIcons, DBusFunction};
pub const ICONS: AudioIcons = AudioIcons {
muted: "audio-input-microphone-symbolic",
active: "microphone-disabled-symbolic",
muted: "microphone-disabled-symbolic",
active: "audio-input-microphone-symbolic",
};
pub const SETVOLUME: DBusFunction = DBusFunction {
@ -39,3 +39,18 @@ pub const GETSTREAMS: DBusFunction = DBusFunction {
function: "ListOutputStreams",
error: "Failed to list output streams",
};
pub const SETSTREAMVOLUME: DBusFunction = DBusFunction {
function: "SetOutputStreamVolume",
error: "Failed to set output stream volume",
};
pub const SETSTREAMMUTE: DBusFunction = DBusFunction {
function: "SetOutputStreamMute",
error: "Failed to mute output stream",
};
pub const SETSTREAMOBJECT: DBusFunction = DBusFunction {
function: "SetSourceOfOutputStream",
error: "Failed to set source of output stream",
};

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

@ -8,7 +8,7 @@ use std::time::SystemTime;
use gtk::subclass::prelude::*;
use gtk::{Button, CheckButton, CompositeTemplate, Label, Scale};
use crate::components::audio::generic_entry::{AudioIcons, TAudioEntryImpl, DBusFunction};
use crate::components::audio::generic_entry::{AudioIcons, DBusFunction, TAudioEntryImpl};
use super::source_const::{ICONS, SETDEFAULT, SETMUTE, SETVOLUME};
use super::source_entry;

4
src/components/audio/mod.rs
View file

@ -1,6 +1,6 @@
pub mod generic_audio_functions;
mod generic_const;
pub mod generic_entry;
mod generic_utils;
pub mod input;
pub mod output;
mod generic_const;
mod generic_utils;

203
src/components/audio/output/input_stream_entry.rs
View file

@ -1,26 +1,15 @@
use std::sync::Arc;
use std::time::{Duration, SystemTime};
use crate::components::audio::generic_audio_functions::new_stream_entry;
use crate::components::audio::generic_entry::TAudioStream;
use crate::components::base::error_impl::show_error;
use crate::components::utils::{
create_dropdown_label_factory, set_combo_row_ellipsis, AUDIO, BASE, DBUS_PATH,
};
use adw::glib::Object;
use adw::prelude::{ButtonExt, ComboRowExt, PreferencesRowExt, RangeExt};
use dbus::blocking::Connection;
use dbus::Error;
use glib::prelude::Cast;
use glib::subclass::types::ObjectSubclassIsExt;
use glib::{clone, Propagation};
use gtk::{gio, StringObject};
use re_set_lib::audio::audio_structures::InputStream;
use re_set_lib::audio::audio_structures::{InputStream, Sink};
use super::input_stream_entry_impl;
use super::sink_box::SinkBox;
use super::sink_entry::SinkEntry;
glib::wrapper! {
pub struct InputStreamEntry(ObjectSubclass<input_stream_entry_impl::InputStreamEntry>)
pub struct InputStreamEntry(ObjectSubclass<super::input_stream_entry_impl::InputStreamEntry>)
@extends adw::PreferencesGroup, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
@ -35,178 +24,16 @@ impl TAudioStream<super::input_stream_entry_impl::InputStreamEntry> for InputStr
}
impl InputStreamEntry {
pub fn new(sink_box: Arc<SinkBox>, stream: InputStream) -> Self {
let obj: Self = Object::builder().build();
// TODO use event callback for progress bar -> this is the "im speaking" indicator
let output_box_mute_ref = sink_box.clone();
let output_box_volume_ref = sink_box.clone();
let output_box_sink_ref = sink_box.clone();
{
let index = stream.sink_index;
let box_imp = sink_box.imp();
let imp = obj.imp();
if stream.muted {
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.reset_sink_selection.set_title(name.as_str());
imp.reset_sink_selection
.set_factory(Some(&create_dropdown_label_factory()));
set_combo_row_ellipsis(imp.reset_sink_selection.get());
let volume = stream.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);
{
let sink = box_imp.reset_default_sink.borrow();
imp.associated_sink.replace((sink.index, sink.name.clone()));
}
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 mut stream = imp.stream.try_borrow();
while stream.is_err() {
stream = imp.stream.try_borrow();
}
let stream = stream.unwrap();
let index = stream.index;
let channels = stream.channels;
{
let mut time = imp.volume_time_stamp.borrow_mut();
if time.is_some() && time.unwrap().elapsed().unwrap() < Duration::from_millis(50) {
return Propagation::Proceed;
}
*time = Some(SystemTime::now());
}
set_inputstream_volume(value, index, channels, output_box_volume_ref.clone());
Propagation::Proceed
}),
);
{
let list = box_imp.reset_model_list.read().unwrap();
imp.reset_sink_selection.set_model(Some(&*list));
let sink_list = box_imp.reset_sink_list.read().unwrap();
let name = sink_list.get(&index);
let index = box_imp.reset_model_index.read().unwrap();
let model_list = box_imp.reset_model_list.read().unwrap();
if let Some(name) = name {
for entry in 0..*index {
if model_list.string(entry) == Some(name.2.clone().into()) {
imp.reset_sink_selection.set_selected(entry);
break;
}
}
} else {
let mut name = box_imp.reset_default_sink.try_borrow();
while name.is_err() {
name = box_imp.reset_default_sink.try_borrow();
}
let name = name.unwrap();
for entry in 0..*index {
if model_list.string(entry) == Some(name.alias.clone().into()) {
imp.reset_sink_selection.set_selected(entry);
break;
}
}
}
}
imp.reset_sink_selection.connect_selected_notify(
clone!(@weak imp, @weak box_imp => move |dropdown| {
let selected = dropdown.selected_item();
if selected.is_none() {
return;
}
let selected = selected.unwrap();
let selected = selected.downcast_ref::<StringObject>().unwrap();
let selected = selected.string().to_string();
let sink = box_imp.reset_sink_map.read().unwrap();
// if sink.is_err() {
// return;
// }
// let sink = sink.unwrap();
let sink = sink.get(&selected);
if sink.is_none() {
return;
}
let mut stream = imp.stream.try_borrow();
while stream.is_err() {
stream = imp.stream.try_borrow();
}
let stream = stream.unwrap();
let sink = sink.unwrap().0;
set_sink_of_input_stream(stream.index, sink, output_box_sink_ref.clone());
}),
);
imp.reset_sink_mute
.connect_clicked(clone!(@weak imp => move |_| {
let stream = imp.stream.clone();
let mut stream = stream.try_borrow_mut();
while stream.is_err() {
stream = imp.stream.try_borrow_mut();
}
let mut stream = stream.unwrap();
stream.muted = !stream.muted;
let muted = stream.muted;
let index = stream.index;
if muted {
imp.reset_sink_mute
.set_icon_name("audio-volume-muted-symbolic");
} else {
imp.reset_sink_mute
.set_icon_name("audio-volume-high-symbolic");
}
toggle_input_stream_mute(index, muted, output_box_mute_ref.clone());
}));
}
obj
pub fn new(source_box: Arc<SinkBox>, stream: InputStream) -> Arc<Self> {
new_stream_entry::<
Sink,
InputStream,
SinkEntry,
super::sink_entry_impl::SinkEntry,
InputStreamEntry,
super::input_stream_entry_impl::InputStreamEntry,
SinkBox,
super::sink_box_impl::SinkBox,
>(source_box, stream)
}
}
fn set_inputstream_volume(value: f64, index: u32, channels: u16, output_box: Arc<SinkBox>) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(), Error> = proxy.method_call(
AUDIO,
"SetInputStreamVolume",
(index, channels, value as u32),
);
if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to set input stream volume");
}
});
true
}
fn toggle_input_stream_mute(index: u32, muted: bool, output_box: Arc<SinkBox>) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(), Error> = proxy.method_call(AUDIO, "SetInputStreamMute", (index, muted));
if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to mute input stream");
}
});
true
}
fn set_sink_of_input_stream(stream: u32, sink: u32, output_box: Arc<SinkBox>) -> bool {
gio::spawn_blocking(move || {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(BASE, DBUS_PATH, Duration::from_millis(1000));
let res: Result<(), Error> =
proxy.method_call(AUDIO, "SetSinkOfInputStream", (stream, sink));
if res.is_err() {
show_error::<SinkBox>(output_box.clone(), "Failed to set sink of input stream");
}
});
true
}

21
src/components/audio/output/input_stream_entry_impl.rs
View file

@ -8,9 +8,10 @@ use std::time::SystemTime;
use gtk::subclass::prelude::*;
use gtk::{Button, CompositeTemplate, Label, Scale};
use crate::components::audio::generic_entry::TAudioStreamImpl;
use crate::components::audio::generic_entry::{AudioIcons, TAudioStreamImpl};
use super::input_stream_entry;
use super::sink_const::{ICONS, SETSTREAMMUTE, SETSTREAMOBJECT, SETSTREAMVOLUME};
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetInputStreamEntry.ui")]
@ -78,4 +79,22 @@ impl TAudioStreamImpl<Sink, InputStream> for InputStreamEntry {
fn volume_time_stamp(&self) -> &RefCell<Option<SystemTime>> {
&self.volume_time_stamp
}
fn set_volume_fn(&self) -> &'static crate::components::audio::generic_entry::DBusFunction {
&SETSTREAMVOLUME
}
fn set_audio_object_fn(
&self,
) -> &'static crate::components::audio::generic_entry::DBusFunction {
&SETSTREAMOBJECT
}
fn set_mute_fn(&self) -> &'static crate::components::audio::generic_entry::DBusFunction {
&SETSTREAMMUTE
}
fn icons(&self) -> &AudioIcons {
&ICONS
}
}

2
src/components/audio/output/sink_box_handlers.rs
View file

@ -246,7 +246,7 @@ pub fn input_stream_added_handler(sink_box: Arc<SinkBox>, ir: InputStreamAdded)
let sink_box_imp = sink_box.imp();
let mut list = sink_box_imp.reset_input_stream_list.write().unwrap();
let index = ir.stream.index;
let input_stream = Arc::new(InputStreamEntry::new(sink_box.clone(), ir.stream));
let input_stream = InputStreamEntry::new(sink_box.clone(), ir.stream);
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream.clone()));

2
src/components/audio/output/sink_box_utils.rs
View file

@ -150,7 +150,7 @@ pub fn populate_inputstreams(sink_box: Arc<SinkBox>) {
let mut list = sink_box_imp.reset_input_stream_list.write().unwrap();
for stream in streams {
let index = stream.index;
let input_stream = Arc::new(InputStreamEntry::new(sink_box.clone(), stream));
let input_stream = InputStreamEntry::new(sink_box.clone(), stream);
let entry = Arc::new(ListEntry::new(&*input_stream));
entry.set_activatable(false);
list.insert(index, (entry.clone(), input_stream.clone()));

19
src/components/audio/output/sink_const.rs
View file

@ -1,8 +1,8 @@
use crate::components::audio::generic_entry::{AudioIcons, DBusFunction};
pub const ICONS: AudioIcons = AudioIcons {
muted: "audio-volume-high-symbolic",
active: "audio-volume-muted-symbolic",
muted: "audio-volume-muted-symbolic",
active: "audio-volume-high-symbolic",
};
pub const SETVOLUME: DBusFunction = DBusFunction {
@ -39,3 +39,18 @@ pub const GETSTREAMS: DBusFunction = DBusFunction {
function: "ListInputStreams",
error: "Failed to list input streams",
};
pub const SETSTREAMVOLUME: DBusFunction = DBusFunction {
function: "SetInputStreamVolume",
error: "Failed to set input stream volume",
};
pub const SETSTREAMMUTE: DBusFunction = DBusFunction {
function: "SetInputStreamMute",
error: "Failed to mute input stream",
};
pub const SETSTREAMOBJECT: DBusFunction = DBusFunction {
function: "SetSinkOfInputStream",
error: "Failed to set sink of input stream",
};

2
src/components/audio/output/sink_entry_impl.rs
View file

@ -5,7 +5,7 @@ use std::cell::RefCell;
use std::sync::Arc;
use std::time::SystemTime;
use crate::components::audio::generic_entry::{AudioIcons, TAudioEntryImpl, DBusFunction};
use crate::components::audio::generic_entry::{AudioIcons, DBusFunction, TAudioEntryImpl};
use crate::components::audio::output::sink_entry;
use gtk::subclass::prelude::*;
use gtk::{Button, CheckButton, CompositeTemplate, Label, Scale};