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 basic functionality to all audio usecases

Browse source
This commit is contained in:
Fabio Lenherr / DashieTM 2023-11-14 21:25:39 +01:00
parent 2f1099267a
commit c1984b5b79
32 changed files with 368 additions and 201 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,5 +1,15 @@
use std::cell::RefCell;
use std::sync::Arc;
use std::time::Duration;
use adw::glib;
use adw::glib::Object;
use adw::prelude::RangeExt;
use dbus::blocking::Connection;
use dbus::Error;
use ReSet_Lib::audio::audio::OutputStream;
use glib::{clone, Propagation};
use glib::subclass::types::ObjectSubclassIsExt;
use super::outputStreamEntryImpl;
@ -10,7 +20,51 @@ glib::wrapper! {
}
impl OutputStreamEntry {
pub fn new() -> Self {
Object::builder().build()
pub fn new(stream: OutputStream) -> 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();
let name = stream.application_name.clone() + ": " + stream.name.as_str();
imp.resetSourceName.set_text(name.as_str());
let volume = 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);
imp.stream.replace(stream);
imp.resetVolumeSlider.connect_change_value(
clone!(@weak imp => @default-return Propagation::Stop, move |_, _, value| {
let fraction = (value / 655.36).round();
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
set_outputstream_volume(value, imp.stream.clone());
Propagation::Proceed
}),
);
}
obj
}
}
fn set_outputstream_volume(value: f64, stream: Arc<RefCell<OutputStream>>) -> bool {
let mut stream = stream.borrow_mut().clone();
// let x = stream.volume.iter_mut().map(|_| value as u32);
stream.volume = vec![value as u32; stream.channels as usize];
dbg!(stream.volume.clone());
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> =
proxy.method_call("org.xetibo.ReSet", "SetOutputStreamVolume", (stream,));
if res.is_err() {
return false;
}
res.unwrap().0
}

5
src/components/input/outputStreamEntryImpl.rs
View file

@ -1,4 +1,8 @@
use std::cell::RefCell;
use std::sync::Arc;
use crate::components::input::outputStreamEntry;
use ReSet_Lib::audio::audio::OutputStream;
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, Label, ProgressBar, Scale, DropDown};
@ -18,6 +22,7 @@ pub struct OutputStreamEntry {
pub resetVolumePercentage: TemplateChild<Label>,
#[template_child]
pub resetVolumeMeter: TemplateChild<ProgressBar>,
pub stream: Arc<RefCell<OutputStream>>,
}
#[glib::object_subclass]

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

@ -1,9 +1,23 @@
use std::sync::Arc;
use std::time::Duration;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::utils::Listeners;
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 dbus::blocking::Connection;
use dbus::Error;
use glib::subclass::prelude::ObjectSubclassIsExt;
use glib::Variant;
use glib::{Propagation, Variant};
use gtk::gio;
use gtk::prelude::ActionableExt;
use ReSet_Lib::audio::audio::{OutputStream, Source};
use super::outputStreamEntry::OutputStreamEntry;
use super::sourceEntry::SourceEntry;
glib::wrapper! {
pub struct SourceBox(ObjectSubclass<sourceBoxImpl::SourceBox>)
@ -11,6 +25,9 @@ glib::wrapper! {
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
unsafe impl Send for SourceBox {}
unsafe impl Sync for SourceBox {}
impl SourceBox {
pub fn new() -> Self {
Object::builder().build()
@ -18,9 +35,124 @@ impl SourceBox {
pub fn setupCallbacks(&self) {
let selfImp = self.imp();
selfImp.resetSourceRow.set_action_name(Some("navigation.push"));
selfImp.resetSourceRow.set_action_target_value(Some(&Variant::from("sources")));
selfImp
.resetSourceRow
.set_action_name(Some("navigation.push"));
selfImp
.resetSourceRow
.set_action_target_value(Some(&Variant::from("sources")));
selfImp.resetOutputStreamButton.set_action_name(Some("navigation.pop"));
selfImp
.resetOutputStreamButton
.set_action_name(Some("navigation.pop"));
}
}
pub fn populate_sources(output_box: Arc<SourceBox>) {
gio::spawn_blocking(move || {
let output_box_imp = output_box.imp();
let sinks = get_sources();
output_box_imp
.resetDefaultSource
.replace(get_default_source());
glib::spawn_future(async move {
glib::idle_add_once(move || {
// TODO handle default mapping
let output_box_ref_slider = output_box.clone();
let output_box_ref = output_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 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);
for stream in sinks {
let entry = ListEntry::new(&SourceEntry::new(stream));
entry.set_activatable(false);
output_box_imp.resetSources.append(&entry);
}
}
output_box_ref
.imp()
.resetVolumeSlider
.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);
set_source_volume(value, imp.resetDefaultSource.clone());
Propagation::Proceed
});
});
});
});
}
pub fn populate_outputstreams(listeners: Arc<Listeners>, output_box: Arc<SourceBox>) {
// TODO add listener
let output_box_ref = output_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();
for stream in streams {
let entry = ListEntry::new(&OutputStreamEntry::new(stream));
entry.set_activatable(false);
output_box_imp.resetOutputStreams.append(&entry);
}
});
});
});
}
fn get_output_streams() -> Vec<OutputStream> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(1000),
);
let res: Result<(Vec<OutputStream>,), Error> =
proxy.method_call("org.xetibo.ReSet", "ListOutputStreams", ());
if res.is_err() {
return Vec::new();
}
res.unwrap().0
}
fn get_sources() -> Vec<Source> {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(1000),
);
let res: Result<(Vec<Source>,), Error> =
proxy.method_call("org.xetibo.ReSet", "ListSources", ());
if res.is_err() {
return Vec::new();
}
res.unwrap().0
}
fn get_default_source() -> Source {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(1000),
);
let res: Result<(Source,), Error> =
proxy.method_call("org.xetibo.ReSet", "GetDefaultSource", ());
if res.is_err() {
return Source::default();
}
res.unwrap().0
}

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

@ -9,6 +9,7 @@ use gtk::{prelude::*, Button, Label, ProgressBar, Scale};
use ReSet_Lib::audio::audio::{OutputStream, Source};
use super::outputStreamEntry::OutputStreamEntry;
use super::sourceEntry::SourceEntry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
@ -32,7 +33,7 @@ pub struct SourceBox {
pub resetOutputStreamButton: TemplateChild<ListEntry>,
#[template_child]
pub resetOutputStreams: TemplateChild<gtk::Box>,
pub resetDefaultSource: RefCell<Option<Source>>,
pub resetDefaultSource: Arc<RefCell<Source>>,
pub resetSourceList: Arc<Mutex<Vec<Source>>>,
pub resetOutputStreamList: Arc<Mutex<Vec<OutputStream>>>,
}
@ -45,6 +46,7 @@ impl ObjectSubclass for SourceBox {
fn class_init(klass: &mut Self::Class) {
OutputStreamEntry::ensure_type();
SourceEntry::ensure_type();
ListEntry::ensure_type();
klass.bind_template();
}

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

@ -42,7 +42,7 @@ impl SourceEntry {
println!("{fraction}");
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
set_inputstream_volume(value, imp.stream.clone());
set_source_volume(value, imp.stream.clone());
Propagation::Proceed
}),
);
@ -51,7 +51,7 @@ impl SourceEntry {
}
}
fn set_inputstream_volume(value: f64, stream: Arc<RefCell<Source>>) -> bool {
pub fn set_source_volume(value: f64, stream: Arc<RefCell<Source>>) -> bool {
let mut stream = stream.borrow_mut().clone();
// let x = stream.volume.iter_mut().map(|_| value as u32);
stream.volume = vec![value as u32; stream.channels as usize];
@ -61,7 +61,7 @@ fn set_inputstream_volume(value: f64, stream: Arc<RefCell<Source>>) -> bool {
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(100),
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> =
proxy.method_call("org.xetibo.ReSet", "SetSourceVolume", (stream,));

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

@ -2,7 +2,7 @@ use std::cell::RefCell;
use std::sync::Arc;
use gtk::subclass::prelude::*;
use gtk::{glib, Button, CompositeTemplate, DropDown, Label, ProgressBar, Scale, CheckButton};
use gtk::{glib, Button, CompositeTemplate, Label, ProgressBar, Scale, CheckButton};
use ReSet_Lib::audio::audio::Source;
use super::sourceEntry;

8
src/components/output/inputStreamEntry.rs
View file

@ -23,13 +23,12 @@ 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 the slider to volume
// TODO properly use volume fraction
// TODO map mute to callback
// TODO map dropdown
{
let imp = obj.imp();
imp.resetSinkName.set_text(stream.name.clone().as_str());
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));
let fraction = (*volume as f64 / 655.36).round();
let percentage = (fraction).to_string() + "%";
@ -39,7 +38,6 @@ impl InputStreamEntry {
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);
set_inputstream_volume(value, imp.stream.clone());
@ -61,7 +59,7 @@ fn set_inputstream_volume(value: f64, stream: Arc<RefCell<InputStream>>) -> bool
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(100),
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> =
proxy.method_call("org.xetibo.ReSet", "SetInputStreamVolume", (stream,));

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

@ -1,6 +1,6 @@
#![allow(non_snake_case)]
pub mod audioBox;
pub mod audioBoxImpl;
pub mod sinkBox;
pub mod sinkBoxImpl;
pub mod inputStreamEntry;
pub mod inputStreamEntryImpl;
pub mod sinkEntry;

70
src/components/output/audioBox.rs → src/components/output/sinkBox.rs
View file

@ -3,31 +3,32 @@ use std::time::Duration;
use crate::components::base::listEntry::ListEntry;
use crate::components::base::utils::Listeners;
use crate::components::output::audioBoxImpl;
use crate::components::output::sinkEntry::set_sink_volume;
use adw::glib::Object;
use adw::prelude::BoxExt;
use adw::prelude::{BoxExt, RangeExt};
use adw::{glib, prelude::ListBoxRowExt};
use dbus::blocking::Connection;
use dbus::Error;
use glib::subclass::prelude::ObjectSubclassIsExt;
use glib::Variant;
use glib::{clone, Propagation, Variant};
use gtk::gio;
use gtk::prelude::ActionableExt;
use ReSet_Lib::audio::audio::{InputStream, Sink};
use super::inputStreamEntry::InputStreamEntry;
use super::sinkBoxImpl;
use super::sinkEntry::SinkEntry;
glib::wrapper! {
pub struct AudioBox(ObjectSubclass<audioBoxImpl::AudioBox>)
pub struct SinkBox(ObjectSubclass<sinkBoxImpl::SinkBox>)
@extends gtk::Box, gtk::Widget,
@implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable;
}
unsafe impl Send for AudioBox {}
unsafe impl Sync for AudioBox {}
unsafe impl Send for SinkBox {}
unsafe impl Sync for SinkBox {}
impl AudioBox {
impl SinkBox {
pub fn new() -> Self {
Object::builder().build()
}
@ -47,30 +48,53 @@ impl AudioBox {
}
}
pub fn populate_sinks(output_box: Arc<AudioBox>) {
let output_box_ref = output_box.clone();
pub fn populate_sinks(output_box: Arc<SinkBox>) {
gio::spawn_blocking(move || {
let output_box_imp = output_box.imp();
let output_box_ref = output_box.clone();
{
let output_box_imp = output_box.imp();
output_box_imp.resetDefaultSink.replace(get_default_sink());
}
let sinks = get_sinks();
output_box_imp.resetDefaultSink.replace(get_default_sink());
glib::spawn_future(async move {
glib::idle_add_once(move || {
let output_box_imp = output_box_ref.imp();
// TODO handle default mapping
// output_box_imp.resetVolumePercentage.set_text();
// output_box_imp.resetVolumeSlider.let
for stream in sinks {
// TODO create sink handler -> currently only allows input streams
let entry = ListEntry::new(&SinkEntry::new(stream));
entry.set_activatable(false);
output_box_imp.resetSinks.append(&entry);
let output_box_ref_slider = output_box.clone();
{
let output_box_imp = output_box_ref.imp();
let default_sink = output_box_imp.resetDefaultSink.clone(); // Clone outside closure
let sink = default_sink.borrow(); //
let volume = sink.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);
for stream in sinks {
// TODO create sink handler -> currently only allows input streams
let entry = ListEntry::new(&SinkEntry::new(stream));
entry.set_activatable(false);
output_box_imp.resetSinks.append(&entry);
}
}
output_box_ref
.imp()
.resetVolumeSlider
.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);
set_sink_volume(value, imp.resetDefaultSink.clone());
Propagation::Proceed
});
});
});
});
}
pub fn populate_streams(listeners: Arc<Listeners>, output_box: Arc<AudioBox>) {
pub fn populate_inputstreams(listeners: Arc<Listeners>, output_box: Arc<SinkBox>) {
// TODO add listener
let output_box_ref = output_box.clone();
// let output_box_ref_listener = output_box.clone();
@ -122,7 +146,7 @@ fn get_sinks() -> Vec<Sink> {
res.unwrap().0
}
fn get_default_sink() -> Option<Sink> {
fn get_default_sink() -> Sink {
let conn = Connection::new_session().unwrap();
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
@ -131,7 +155,7 @@ fn get_default_sink() -> Option<Sink> {
);
let res: Result<(Sink,), Error> = proxy.method_call("org.xetibo.ReSet", "GetDefaultSink", ());
if res.is_err() {
return None;
return Sink::default();
}
Some(res.unwrap().0)
res.unwrap().0
}

22
src/components/output/audioBoxImpl.rs → src/components/output/sinkBoxImpl.rs
View file

@ -2,19 +2,19 @@ use std::cell::RefCell;
use std::sync::{Arc, Mutex};
use crate::components::base::listEntry::ListEntry;
use crate::components::output::audioBox;
use crate::components::output::inputStreamEntry::InputStreamEntry;
use gtk::subclass::prelude::*;
use gtk::{glib, Box, Button, CompositeTemplate, DropDown, Label, TemplateChild};
use gtk::{prelude::*, ProgressBar, Scale};
use ReSet_Lib::audio::audio::{InputStream, Sink};
use super::sinkBox;
use super::sinkEntry::SinkEntry;
#[allow(non_snake_case)]
#[derive(Default, CompositeTemplate)]
#[template(resource = "/org/Xetibo/ReSet/resetAudioOutput.ui")]
pub struct AudioBox {
pub struct SinkBox {
#[template_child]
pub resetSinksRow: TemplateChild<ListEntry>,
#[template_child]
@ -33,15 +33,15 @@ pub struct AudioBox {
pub resetInputStreamButton: TemplateChild<ListEntry>,
#[template_child]
pub resetInputStreams: TemplateChild<Box>,
pub resetDefaultSink: RefCell<Option<Sink>>,
pub resetDefaultSink: Arc<RefCell<Sink>>,
pub resetSinkList: Arc<Mutex<Vec<Sink>>>,
pub resetInputStreamList: Arc<Mutex<Vec<InputStream>>>,
}
#[glib::object_subclass]
impl ObjectSubclass for AudioBox {
impl ObjectSubclass for SinkBox {
const NAME: &'static str = "resetAudioOutput";
type Type = audioBox::AudioBox;
type Type = sinkBox::SinkBox;
type ParentType = gtk::Box;
fn class_init(klass: &mut Self::Class) {
@ -56,19 +56,19 @@ impl ObjectSubclass for AudioBox {
}
}
impl BoxImpl for AudioBox {}
impl BoxImpl for SinkBox {}
impl ObjectImpl for AudioBox {
impl ObjectImpl for SinkBox {
fn constructed(&self) {
let obj = self.obj();
obj.setupCallbacks();
}
}
impl ListBoxRowImpl for AudioBox {}
impl ListBoxRowImpl for SinkBox {}
impl WidgetImpl for AudioBox {}
impl WidgetImpl for SinkBox {}
impl WindowImpl for AudioBox {}
impl WindowImpl for SinkBox {}
impl ApplicationWindowImpl for AudioBox {}
impl ApplicationWindowImpl for SinkBox {}

6
src/components/output/sinkEntry.rs
View file

@ -42,7 +42,7 @@ impl SinkEntry {
println!("{fraction}");
let percentage = (fraction).to_string() + "%";
imp.resetVolumePercentage.set_text(&percentage);
set_inputstream_volume(value, imp.stream.clone());
set_sink_volume(value, imp.stream.clone());
Propagation::Proceed
}),
);
@ -51,7 +51,7 @@ impl SinkEntry {
}
}
fn set_inputstream_volume(value: f64, stream: Arc<RefCell<Sink>>) -> bool {
pub fn set_sink_volume(value: f64, stream: Arc<RefCell<Sink>>) -> bool {
let mut stream = stream.borrow_mut().clone();
// let x = stream.volume.iter_mut().map(|_| value as u32);
stream.volume = vec![value as u32; stream.channels as usize];
@ -61,7 +61,7 @@ fn set_inputstream_volume(value: f64, stream: Arc<RefCell<Sink>>) -> bool {
let proxy = conn.with_proxy(
"org.xetibo.ReSet",
"/org/xetibo/ReSet",
Duration::from_millis(100),
Duration::from_millis(1000),
);
let res: Result<(bool,), Error> =
proxy.method_call("org.xetibo.ReSet", "SetSinkVolume", (stream,));

22
src/components/window/handleSidebarClick.rs
View file

@ -5,8 +5,8 @@ use std::sync::Arc;
use crate::components::base::settingBox::SettingBox;
use crate::components::base::utils::Listeners;
use crate::components::bluetooth::bluetoothBox::BluetoothBox;
use crate::components::input::sourceBox::SourceBox;
use crate::components::output::audioBox::{populate_streams, AudioBox, populate_sinks};
use crate::components::input::sourceBox::{SourceBox, populate_outputstreams, populate_sources};
use crate::components::output::sinkBox::{SinkBox, populate_inputstreams, populate_sinks};
use crate::components::wifi::wifiBox::{scanForWifi, show_stored_connections, WifiBox};
use gtk::prelude::WidgetExt;
use gtk::{FlowBox, Frame, Label};
@ -63,11 +63,14 @@ pub const HANDLE_AUDIO_CLICK: fn(Arc<Listeners>, FlowBox) =
listeners.stop_network_listener();
listeners.bluetooth_listener.store(false, Ordering::SeqCst);
listeners.pulse_listener.store(true, Ordering::SeqCst);
let audioOutput = Arc::new(AudioBox::new());
populate_streams(listeners.clone(), audioOutput.clone());
let audioOutput = Arc::new(SinkBox::new());
populate_inputstreams(listeners.clone(), audioOutput.clone());
populate_sinks(audioOutput.clone());
let audioFrame = wrapInFrame(SettingBox::new(&*audioOutput));
let sourceFrame = wrapInFrame(SettingBox::new(&SourceBox::new()));
let audioInput = Arc::new(SourceBox::new());
populate_outputstreams(listeners.clone(), audioInput.clone());
populate_sources(audioInput.clone());
let sourceFrame = wrapInFrame(SettingBox::new(&*audioInput));
resetMain.remove_all();
resetMain.insert(&audioFrame, -1);
resetMain.insert(&sourceFrame, -1);
@ -79,8 +82,8 @@ pub const HANDLE_VOLUME_CLICK: fn(Arc<Listeners>, FlowBox) =
listeners.stop_network_listener();
listeners.bluetooth_listener.store(false, Ordering::SeqCst);
listeners.pulse_listener.store(false, Ordering::SeqCst);
let audioOutput = Arc::new(AudioBox::new());
populate_streams(listeners.clone(), audioOutput.clone());
let audioOutput = Arc::new(SinkBox::new());
populate_inputstreams(listeners.clone(), audioOutput.clone());
populate_sinks(audioOutput.clone());
let audioFrame = wrapInFrame(SettingBox::new(&*audioOutput));
resetMain.remove_all();
@ -93,7 +96,10 @@ pub const HANDLE_MICROPHONE_CLICK: fn(Arc<Listeners>, FlowBox) =
listeners.stop_network_listener();
listeners.bluetooth_listener.store(false, Ordering::SeqCst);
listeners.pulse_listener.store(false, Ordering::SeqCst);
let sourceFrame = wrapInFrame(SettingBox::new(&SourceBox::new()));
let audioInput = Arc::new(SourceBox::new());
populate_outputstreams(listeners.clone(), audioInput.clone());
populate_sources(audioInput.clone());
let sourceFrame = wrapInFrame(SettingBox::new(&*audioInput));
resetMain.remove_all();
resetMain.insert(&sourceFrame, -1);
resetMain.set_max_children_per_line(1);