Move Cosmic Applets into new Dir & remove old applets

cosmic-applet-audio/src/main.rs

@@ -0,0 +1,372 @@
+use iced::widget::Space;
+
+use cosmic::widget::{icon, toggler, horizontal_rule};
+use cosmic::applet::CosmicAppletHelper;
+use cosmic::Renderer;
+
+use cosmic::iced_native::window::Settings;
+use cosmic::iced_style::application::{self, Appearance};
+use cosmic::iced_style::svg;
+use cosmic::theme::{self, Svg};
+use cosmic::{iced_style, settings, Element, Theme};
+use cosmic::iced::{
+    executor,
+    widget::{button, column, row, text, slider},
+    window, Alignment, Application, Command, Length, Subscription,
+};
+
+use iced_sctk::application::SurfaceIdWrapper;
+use iced_sctk::command::platform_specific::wayland::window::SctkWindowSettings;
+use iced_sctk::commands::popup::{destroy_popup, get_popup};
+use iced_sctk::settings::InitialSurface;
+use iced_sctk::Color;
+use iced_sctk::widget::container;
+
+mod pulse;
+use crate::pulse::DeviceInfo;
+use libpulse_binding::volume::{Volume, VolumeLinear};
+
+pub fn main() -> cosmic::iced::Result {
+    let helper = CosmicAppletHelper::default();
+    Audio::run(helper.window_settings())
+}
+
+#[derive(Default)]
+struct Audio {
+    is_open: IsOpen,
+    current_output: Option<DeviceInfo>,
+    current_input: Option<DeviceInfo>,
+    outputs: Vec<DeviceInfo>,
+    inputs: Vec<DeviceInfo>,
+    pulse_state: PulseState,
+    applet_helper: CosmicAppletHelper,
+    icon_name: String,
+    theme: Theme,
+    popup: Option<window::Id>,
+    id_ctr: u32,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum IsOpen {
+    None,
+    Output,
+    Input,
+}
+
+#[derive(Debug, Clone)]
+enum Message {
+    SetOutputVolume(f64),
+    SetInputVolume(f64),
+    OutputToggle,
+    InputToggle,
+    OutputChanged(String),
+    InputChanged(String),
+    Pulse(pulse::Event),
+    Ignore,
+    TogglePopup,
+}
+
+impl Application for Audio {
+    type Message = Message;
+    type Theme = Theme;
+    type Executor = executor::Default;
+    type Flags = ();
+
+    fn new(_flags: ()) -> (Audio, Command<Message>) {
+        (
+            Audio {
+                is_open: IsOpen::None,
+                current_output: None,
+                current_input: None,
+                outputs: vec![],
+                inputs: vec![],
+                pulse_state: PulseState::Disconnected,
+                icon_name: "audio-volume-high-symbolic".to_string(),
+                ..Default::default()
+            },
+            Command::none(),
+        )
+    }
+
+    fn title(&self) -> String {
+        String::from("Audio")
+    }
+
+    fn theme(&self) -> Theme {   
+        self.theme
+    }
+
+    fn close_requested(&self, _id: iced_sctk::application::SurfaceIdWrapper) -> Self::Message {
+        Message::Ignore
+    }
+
+    fn style(&self) -> <Self::Theme as application::StyleSheet>::Style {
+        <Self::Theme as application::StyleSheet>::Style::Custom(|theme| Appearance {
+            background_color: Color::from_rgba(0.0, 0.0, 0.0, 0.0),
+            text_color: theme.cosmic().on_bg_color().into(),
+        })
+    }
+
+    fn update(&mut self, message: Message) -> Command<Message> {
+        match message {
+            Message::TogglePopup => {
+                if let Some(p) = self.popup.take() {
+                    return destroy_popup(p);
+                } else {
+                    self.id_ctr += 1; 
+                    let new_id = window::Id::new(self.id_ctr);
+                    self.popup.replace(new_id);
+
+                    let popup_settings =
+                        self.applet_helper.get_popup_settings(window::Id::new(0), new_id, (400, 300), None, None);
+                    return get_popup(popup_settings);
+                }
+            }
+            Message::SetOutputVolume(vol) => {
+                self.current_output.as_mut().map(|o| {
+                    o.volume
+                        .set(o.volume.len(), VolumeLinear(vol / 100.0).into())
+                });
+                if let PulseState::Connected(connection) = &mut self.pulse_state {
+                    if let Some(device) = &self.current_output {
+                        if let Some(name) = &device.name {
+                            connection.send(pulse::Message::SetSinkVolumeByName(
+                                name.clone().to_string(),
+                                device.volume,
+                            ))
+                        }
+                    }
+                }
+            }
+            Message::SetInputVolume(vol) => {
+                self.current_input.as_mut().map(|i| {
+                    i.volume
+                        .set(i.volume.len(), VolumeLinear(vol / 100.0).into())
+                });
+                if let PulseState::Connected(connection) = &mut self.pulse_state {
+                    if let Some(device) = &self.current_input {
+                        if let Some(name) = &device.name {
+                            println!("increasing volume of {}", name);
+                            connection.send(pulse::Message::SetSourceVolumeByName(
+                                name.clone().to_string(),
+                                device.volume,
+                            ))
+                        }
+                    }
+                }
+            }
+            Message::OutputChanged(val) => println!("changed output {}", val),
+            Message::InputChanged(val) => println!("changed input {}", val),
+            Message::OutputToggle => {
+                self.is_open = if self.is_open == IsOpen::Output {
+                    IsOpen::None
+                } else {
+                    IsOpen::Output
+                }
+            }
+            Message::InputToggle => {
+                self.is_open = if self.is_open == IsOpen::Input {
+                    IsOpen::None
+                } else {
+                    IsOpen::Input
+                }
+            }
+            Message::Pulse(event) => match event {
+                pulse::Event::Connected(mut connection) => {
+                    connection.send(pulse::Message::GetSinks);
+                    connection.send(pulse::Message::GetSources);
+                    connection.send(pulse::Message::GetDefaultSink);
+                    connection.send(pulse::Message::GetDefaultSource);
+                    self.pulse_state = PulseState::Connected(connection);
+                }
+                pulse::Event::MessageReceived(msg) => {
+                    match msg {
+                        // This is where we match messages from the subscription to app state
+                        pulse::Message::SetSinks(sinks) => self.outputs = sinks,
+                        pulse::Message::SetSources(sources) => {
+                            self.inputs = sources
+                                .into_iter()
+                                .filter(|source| {
+                                    !source
+                                        .name
+                                        .as_ref()
+                                        .unwrap_or(&String::from("Generic"))
+                                        .contains("monitor")
+                                })
+                                .collect()
+                        }
+                        pulse::Message::SetDefaultSink(sink) => {
+                            self.current_output = Some(sink);
+                        }
+                        pulse::Message::SetDefaultSource(source) => {
+                            self.current_input = Some(source)
+                        }
+                        pulse::Message::Disconnected => {
+                            panic!("Subscriton error handling is bad. This should never happen.")
+                        }
+                        _ => {
+                            println!("Received misc message")
+                        }
+                    }
+                }
+                // TODO: view() should gray out buttons/slider when state is disconnected
+                pulse::Event::Disconnected => {
+                    println!("setting state to disconnected");
+                    self.pulse_state = PulseState::Disconnected
+                }
+            },
+            Message::Ignore => {},
+        };
+
+        Command::none()
+    }
+
+    fn subscription(&self) -> Subscription<Message> {
+        pulse::connect().map(Message::Pulse)
+    }
+
+    fn view(&self, id: SurfaceIdWrapper) -> Element<Message> { 
+        match id {
+            SurfaceIdWrapper::LayerSurface(_) => unimplemented!(),
+            SurfaceIdWrapper::Window(_) => self.applet_helper.icon_button(
+                &self.icon_name,
+            )
+            .on_press(Message::TogglePopup)
+            .into(),
+            SurfaceIdWrapper::Popup(_) => {
+                let out_f64 = VolumeLinear::from(
+                    self.current_output
+                        .as_ref()
+                        .map(|o| o.volume.avg())
+                        .unwrap_or(Volume::default()),
+                )
+                .0 * 100.0;
+                let in_f64 = VolumeLinear::from(
+                    self.current_input
+                        .as_ref()
+                        .map(|o| o.volume.avg())
+                        .unwrap_or(Volume::default()),
+                )
+                .0 * 100.0;
+
+                let sink = row![
+                    icon("status/audio-volume-high-symbolic", 24),
+                    slider(0.0..=100.0, out_f64, Message::SetOutputVolume),
+                    text(format!("{}%", out_f64.round()))
+                ]
+                .spacing(10)
+                .padding(10);
+                let source = row![
+                    icon("devices/audio-input-microphone-symbolic", 24),
+                    slider(0.0..=100.0, in_f64, Message::SetInputVolume),
+                    text(format!("{}%", in_f64.round()))
+                ]
+                .spacing(10)
+                .padding(10);
+
+                // TODO change these from helper functions to iced components for improved reusability
+                let output_drop = revealer(
+                    self.is_open == IsOpen::Output,
+                    "Output",
+                    match &self.current_output {
+                        Some(output) => pretty_name(output.description.clone()),
+                        None => String::from("No device selected"),
+                    },
+                    self.outputs
+                        .clone()
+                        .into_iter()
+                        .map(|output| pretty_name(output.description))
+                        .collect(),
+                    Message::OutputToggle,
+                    Message::OutputChanged(String::from("test")),
+                );
+                let input_drop = revealer(
+                    self.is_open == IsOpen::Input,
+                    "Input",
+                    match &self.current_input {
+                        Some(input) => pretty_name(input.description.clone()),
+                        None => String::from("No device selected"),
+                    },
+                    self.inputs
+                        .clone()
+                        .into_iter()
+                        .map(|input| pretty_name(input.description))
+                        .collect(),
+                    Message::InputToggle,
+                    Message::InputChanged(String::from("test")),
+                );
+
+                let content = column![]
+                    .align_items(Alignment::Start)
+                    .spacing(20)
+                    .push(sink)
+                    .push(source)
+                    .push(spacer())
+                    .push(output_drop)
+                    .push(input_drop);
+
+                self.applet_helper.popup_container(
+                    container(content)
+                    ).into()
+            }
+        }
+    }
+}
+
+// TODO: Make this a themeable widget like the mock-ups
+fn spacer() -> iced::widget::Space {
+    Space::with_width(Length::Fill)
+}
+
+fn revealer<'a>(
+    open: bool,
+    title: &'a str,
+    selected: String,
+    options: Vec<String>,
+    toggle: Message,
+    _change: Message,
+) -> iced_sctk::widget::Column<'a, Message, Renderer> {
+    if open {
+        options.iter().fold(
+            column![revealer_head(open, title, selected, toggle)].width(Length::Fill),
+            |col, device| col.push(text(device)),
+        )
+    } else {
+        column![revealer_head(open, title, selected, toggle)]
+    }
+}
+
+fn revealer_head<'a>(
+    _open: bool,
+    title: &'a str,
+    selected: String,
+    toggle: Message,
+) -> iced_sctk::widget::Button<Message, Renderer> {
+    button(row![row![title].width(Length::Fill), text(selected)])
+        .width(Length::Fill)
+        .on_press(toggle)
+}
+
+fn pretty_name(name: Option<String>) -> String {
+    match name {
+        Some(n) => n,
+        None => String::from("Generic"),
+    }
+}
+
+enum PulseState {
+    Disconnected,
+    Connected(pulse::Connection),
+}
+
+impl Default for PulseState {
+    fn default() -> Self {
+        Self::Disconnected
+    }
+}
+
+impl Default for IsOpen {
+    fn default() -> Self {
+        IsOpen::None
+    }
+}

cosmic-applet-audio/src/pulse.rs

@@ -0,0 +1,521 @@
+use iced_native::subscription::{self, Subscription};
+use std::cell::RefCell;
+use std::{rc::Rc, thread};
+
+extern crate libpulse_binding as pulse;
+//use futures::channel::mpsc;
+use libpulse_binding::{
+    callbacks::ListResult,
+    context::{
+        introspect::{Introspector, SinkInfo, SourceInfo},
+        subscribe::{Facility, InterestMaskSet, Operation},
+        Context,
+    },
+    error::PAErr,
+    mainloop::standard::{IterateResult, Mainloop},
+    proplist::Proplist,
+    volume::ChannelVolumes,
+};
+pub fn connect() -> Subscription<Event> {
+    struct Connect;
+
+    subscription::unfold(
+        std::any::TypeId::of::<Connect>(),
+        State::Disconnected,
+        |state| async move {
+            match state {
+                // if app just started, or we are re-trying match here. Returns coenncting
+                // message. We should store this in our app's state, but it isn't safe to
+                // send messages until we get a conencted message. Which will be received
+                // by the `State::Connecting` message below
+                State::Disconnected => match PulseHandle::create() {
+                    Ok(pulse_handle) => (None, State::Connecting(pulse_handle)),
+                    Err(_) => (Some(Event::Disconnected), State::Disconnected),
+                },
+                // Just a buffer to make sure the GUI doesn't send messages until pulse is ready
+                // The GUI doesn't have to monitor this state, as it is never sent to the GUI
+                State::Connecting(mut pulse_handle) => {
+                        match pulse_handle.from_pulse.recv().await {
+                            Some(Message::Connected) => {(
+                                    Some(Event::Connected(Connection(pulse_handle.to_pulse))),
+                                    State::Connected(pulse_handle.from_pulse),
+                            )}
+                            Some(Message::Disconnected) => (Some(Event::Disconnected), State::Disconnected),
+                            _ => panic!("Pulse subscription logic is faulty as the PulseServer shouldn't send unique messages until connection is successful")
+                        }
+                },
+                State::Connected(mut from_pulse) => {
+                    // This is where we match messages from the pulse server to pass to the gui
+                        match from_pulse.recv().await {
+                            Some(Message::SetSinks(sinks)) => (Some(Event::MessageReceived(Message::SetSinks(sinks))), State::Connected(from_pulse)),
+                            Some(Message::SetSources(sources)) => (Some(Event::MessageReceived(Message::SetSources(sources))), State::Connected(from_pulse)),
+                            Some(Message::SetDefaultSink(sink)) => (Some(Event::MessageReceived(Message::SetDefaultSink(sink))), State::Connected(from_pulse)),
+                            Some(Message::SetDefaultSource(source)) => (Some(Event::MessageReceived(Message::SetDefaultSource(source))), State::Connected(from_pulse)),
+                            Some(Message::Disconnected) => (Some(Event::Disconnected), State::Disconnected),
+                            None => (Some(Event::Disconnected), State::Disconnected),
+                            _ => (None, State::Connected(from_pulse)),
+                        }
+                }
+            }
+        },
+    )
+}
+
+// #[derive(Debug)]
+enum State {
+    Disconnected,
+    Connecting(PulseHandle),
+    Connected(tokio::sync::mpsc::Receiver<Message>),
+}
+
+#[derive(Debug, Clone)]
+pub enum Event {
+    Connected(Connection),
+    Disconnected,
+    MessageReceived(Message),
+}
+
+#[derive(Debug, Clone)]
+pub struct Connection(tokio::sync::mpsc::Sender<Message>);
+
+impl Connection {
+    pub fn send(&mut self, message: Message) {
+        let _ = self
+            .0
+            .try_send(message)
+            .expect("Send message to PulseAudio server");
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Message {
+    Connected,
+    Disconnected,
+    GetSinks,
+    GetSources,
+    SetSinks(Vec<DeviceInfo>),
+    SetSources(Vec<DeviceInfo>),
+    GetDefaultSink,
+    GetDefaultSource,
+    SetDefaultSink(DeviceInfo),
+    SetDefaultSource(DeviceInfo),
+    SetSinkVolumeByName(String, ChannelVolumes),
+    SetSourceVolumeByName(String, ChannelVolumes),
+}
+
+struct PulseHandle {
+    to_pulse: tokio::sync::mpsc::Sender<Message>,
+    from_pulse: tokio::sync::mpsc::Receiver<Message>,
+}
+
+impl PulseHandle {
+    // Create pulse server thread, and bidirectional comms
+    pub fn create() -> Result<PulseHandle, PAErr> {
+        let (to_pulse, mut to_pulse_recv) = tokio::sync::mpsc::channel(10);
+        let (mut from_pulse_send, from_pulse) = tokio::sync::mpsc::channel(10);
+        //let from_pulse = Arc::new(Mutex::new(vec![]));
+        //let mut from_pulse2 = from_pulse.clone();
+        // this thread should complete by pushing a completed message,
+        // or fail message. This should never complete/fail without pushing
+        // a message. This lets the iced subscription go to sleep while init
+        // finishes. TLDR: be very careful with error handling
+        thread::spawn(move || {
+            if let Ok(mut server) = PulseServer::connect().and_then(|server| server.init()) {
+                PulseHandle::blocking_send_connected(&mut from_pulse_send);
+
+                // take `PulseServer` and handle reciver into async context
+                // to listen for messages that need to be passed to the pulseserver
+                // this lets us put the thread to sleep, but keep hold a single
+                // thread, because pulse audio's API is not multithreaded... at all
+                let rt = tokio::runtime::Builder::new_current_thread()
+                    .enable_all()
+                    .build()
+                    .unwrap();
+
+                rt.block_on(async {
+                    loop {
+                        // This is where the we match messages from the GUI to pass to the pulse server
+                        if let Some(msg) = to_pulse_recv.recv().await {
+                            match msg {
+                                Message::GetDefaultSink => match server.get_default_sink() {
+                                    Ok(sink) => from_pulse_send
+                                        .send(Message::SetDefaultSink(sink))
+                                        .await
+                                        .unwrap(),
+                                    Err(_) => {
+                                        PulseHandle::send_disconnected(&mut from_pulse_send).await
+                                    }
+                                },
+                                Message::GetDefaultSource => match server.get_default_source() {
+                                    Ok(source) => from_pulse_send
+                                        .send(Message::SetDefaultSource(source))
+                                        .await
+                                        .unwrap(),
+                                    Err(e) => {
+                                        println!("ERROR! {:?}", e);
+                                        PulseHandle::send_disconnected(&mut from_pulse_send).await;
+                                    }
+                                },
+                                Message::GetSinks => match server.get_sinks() {
+                                    Ok(sinks) => from_pulse_send
+                                        .send(Message::SetSinks(sinks))
+                                        .await
+                                        .unwrap(),
+                                    Err(_) => {
+                                        PulseHandle::send_disconnected(&mut from_pulse_send).await
+                                    }
+                                },
+                                Message::GetSources => match server.get_sources() {
+                                    Ok(sinks) => from_pulse_send
+                                        .send(Message::SetSources(sinks))
+                                        .await
+                                        .unwrap(),
+                                    Err(_) => {
+                                        PulseHandle::send_disconnected(&mut from_pulse_send).await
+                                    }
+                                },
+                                Message::SetSinkVolumeByName(name, channel_volumes) => {
+                                    server.set_sink_volume_by_name(&name, &channel_volumes)
+                                }
+                                Message::SetSourceVolumeByName(name, channel_volumes) => {
+                                    server.set_source_volume_by_name(&name, &channel_volumes)
+                                }
+                                _ => {
+                                    println!("message doesn't match")
+                                }
+                            }
+                        }
+                    }
+                });
+            }
+            // Always report that server is disconnected
+            PulseHandle::blocking_send_disconnected(&mut from_pulse_send);
+        });
+        Ok(PulseHandle {
+            to_pulse,
+            from_pulse,
+        })
+    }
+
+    fn blocking_send_disconnected(sender: &mut tokio::sync::mpsc::Sender<Message>) {
+        sender.blocking_send(Message::Disconnected);
+    }
+
+    fn blocking_send_connected(sender: &mut tokio::sync::mpsc::Sender<Message>) {
+        sender.blocking_send(Message::Connected).unwrap()
+    }
+
+    async fn send_disconnected(sender: &mut tokio::sync::mpsc::Sender<Message>) {
+        sender.send(Message::Disconnected).await.unwrap()
+    }
+
+    async fn send_connected(sender: &mut tokio::sync::mpsc::Sender<Message>) {
+        sender.send(Message::Connected).await.unwrap()
+    }
+}
+
+struct PulseServer {
+    mainloop: Rc<RefCell<Mainloop>>,
+    context: Rc<RefCell<Context>>,
+    introspector: Introspector,
+}
+
+#[derive(Clone, Debug)]
+enum PulseServerError<'a> {
+    IterateErr(IterateResult),
+    ContextErr(pulse::context::State),
+    OperationErr(pulse::operation::State),
+    PAErr(PAErr),
+    Connect,
+    Misc(&'a str),
+}
+
+// `PulseServer` code is heavily inspired by Dave Patrick Caberto's pulsectl-rs (SeaDve)
+// https://crates.io/crates/pulsectl-rs
+impl PulseServer {
+    // connect() requires init() to be run after
+    pub fn connect() -> Result<PulseServer, PulseServerError<'static>> {
+        // TODO: fix app name, should be variable
+        let mut proplist = Proplist::new().unwrap();
+        proplist
+            .set_str(
+                pulse::proplist::properties::APPLICATION_NAME,
+                "com.system76",
+            )
+            .or(Err(PulseServerError::Connect))?;
+
+        let mainloop = Rc::new(RefCell::new(
+            pulse::mainloop::standard::Mainloop::new().ok_or(PulseServerError::Connect)?,
+        ));
+
+        let context = Rc::new(RefCell::new(
+            Context::new_with_proplist(&*mainloop.borrow(), "MainConn", &proplist)
+                .ok_or(PulseServerError::Connect)?,
+        ));
+
+        let introspector = context.borrow_mut().introspect();
+
+        context
+            .borrow_mut()
+            .connect(None, pulse::context::FlagSet::NOFLAGS, None)
+            .map_err(|e| PulseServerError::PAErr(e))?;
+
+        Ok(PulseServer {
+            mainloop,
+            context,
+            introspector,
+        })
+    }
+
+    // Wait for pulse audio connection to complete
+    pub fn init(self) -> Result<Self, PulseServerError<'static>> {
+        loop {
+            match self.mainloop.borrow_mut().iterate(false) {
+                IterateResult::Success(_) => {}
+                IterateResult::Err(e) => {
+                    return Err(PulseServerError::IterateErr(IterateResult::Err(e)))
+                }
+                IterateResult::Quit(e) => {
+                    return Err(PulseServerError::IterateErr(IterateResult::Quit(e)))
+                }
+            }
+
+            match self.context.borrow().get_state() {
+                pulse::context::State::Ready => break,
+                pulse::context::State::Failed => {
+                    return Err(PulseServerError::ContextErr(pulse::context::State::Failed))
+                }
+                pulse::context::State::Terminated => {
+                    return Err(PulseServerError::ContextErr(
+                        pulse::context::State::Terminated,
+                    ))
+                }
+                _ => {}
+            }
+        }
+        Ok(self)
+    }
+
+    // Get a list of output devices
+    pub fn get_sinks(&self) -> Result<Vec<DeviceInfo>, PulseServerError> {
+        let list: Rc<RefCell<Option<Vec<DeviceInfo>>>> = Rc::new(RefCell::new(Some(Vec::new())));
+        let list_ref = list.clone();
+
+        let operation = self.introspector.get_sink_info_list(
+            move |sink_list: ListResult<&pulse::context::introspect::SinkInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    list_ref.borrow_mut().as_mut().unwrap().push(item.into());
+                }
+            },
+        );
+        self.wait_for_result(operation)
+            .and_then(|_| {
+                list.borrow_mut().take().ok_or(PulseServerError::Misc(
+                    "get_sinks(): failed to wait for operation",
+                ))
+            })
+            .and_then(|result| Ok(result))
+    }
+
+    // Get a list of input devices
+    pub fn get_sources(&self) -> Result<Vec<DeviceInfo>, PulseServerError> {
+        let list: Rc<RefCell<Option<Vec<DeviceInfo>>>> = Rc::new(RefCell::new(Some(Vec::new())));
+        let list_ref = list.clone();
+
+        let operation = self.introspector.get_source_info_list(
+            move |sink_list: ListResult<&pulse::context::introspect::SourceInfo>| {
+                if let ListResult::Item(item) = sink_list {
+                    list_ref.borrow_mut().as_mut().unwrap().push(item.into());
+                }
+            },
+        );
+        self.wait_for_result(operation)
+            .and_then(|_| {
+                list.borrow_mut().take().ok_or(PulseServerError::Misc(
+                    "get_sources(): Failed to wait for operation",
+                ))
+            })
+            .and_then(|result| Ok(result))
+    }
+
+    pub fn get_server_info(&mut self) -> Result<ServerInfo, PulseServerError> {
+        let info = Rc::new(RefCell::new(Some(None)));
+        let info_ref = info.clone();
+
+        let op = self.introspector.get_server_info(move |res| {
+            info_ref.borrow_mut().as_mut().unwrap().replace(res.into());
+        });
+        self.wait_for_result(op)?;
+        info.take()
+            .flatten()
+            .ok_or(PulseServerError::Misc("get_server_info(): failed"))
+    }
+
+    fn get_default_sink(&mut self) -> Result<DeviceInfo, PulseServerError> {
+        let server_info = self.get_server_info();
+        match server_info {
+            Ok(info) => {
+                let name = &info.default_sink_name.unwrap_or(String::new());
+                let device = Rc::new(RefCell::new(Some(None)));
+                let dev_ref = device.clone();
+                let op = self.introspector.get_sink_info_by_name(
+                    name,
+                    move |sink_list: ListResult<&SinkInfo>| {
+                        if let ListResult::Item(item) = sink_list {
+                            dev_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                        }
+                    },
+                );
+                self.wait_for_result(op)?;
+                let mut result = device.borrow_mut();
+                result.take().unwrap().ok_or_else(|| {
+                    PulseServerError::Misc("get_default_sink(): Error getting requested device")
+                })
+            }
+            Err(_) => Err(PulseServerError::Misc("get_default_sink() failed")),
+        }
+    }
+
+    fn get_default_source(&mut self) -> Result<DeviceInfo, PulseServerError> {
+        let server_info = self.get_server_info();
+        match server_info {
+            Ok(info) => {
+                let name = &info.default_source_name.unwrap_or(String::new());
+                let device = Rc::new(RefCell::new(Some(None)));
+                let dev_ref = device.clone();
+                let op = self.introspector.get_source_info_by_name(
+                    name,
+                    move |sink_list: ListResult<&SourceInfo>| {
+                        if let ListResult::Item(item) = sink_list {
+                            dev_ref.borrow_mut().as_mut().unwrap().replace(item.into());
+                        }
+                    },
+                );
+                self.wait_for_result(op)?;
+                let mut result = device.borrow_mut();
+                result.take().unwrap().ok_or_else(|| {
+                    PulseServerError::Misc("get_default_source(): Error getting requested device")
+                })
+            }
+            Err(_) => Err(PulseServerError::Misc("get_default_source() failed")),
+        }
+    }
+
+    fn set_sink_volume_by_name(&mut self, name: &str, volume: &ChannelVolumes) {
+        let op = self
+            .introspector
+            .set_sink_volume_by_name(name, volume, None);
+        self.wait_for_result(op).ok();
+    }
+
+    fn set_source_volume_by_name(&mut self, name: &str, volume: &ChannelVolumes) {
+        let op = self
+            .introspector
+            .set_source_volume_by_name(name, volume, None);
+        self.wait_for_result(op).ok();
+    }
+
+    // after building an operation such as get_devices() we need to keep polling
+    // the pulse audio server to "wait" for the operation to complete
+    fn wait_for_result<G: ?Sized>(
+        &self,
+        operation: pulse::operation::Operation<G>,
+    ) -> Result<(), PulseServerError> {
+        // TODO: make this loop async. It is already in an async context, so
+        // we could make this thread sleep while waiting for the pulse server's
+        // response.
+        loop {
+            match self.mainloop.borrow_mut().iterate(false) {
+                IterateResult::Err(e) => {
+                    return Err(PulseServerError::IterateErr(IterateResult::Err(e)))
+                }
+                IterateResult::Quit(e) => {
+                    return Err(PulseServerError::IterateErr(IterateResult::Quit(e)))
+                }
+                IterateResult::Success(_) => {}
+            }
+            match operation.get_state() {
+                pulse::operation::State::Done => return Ok(()),
+                pulse::operation::State::Running => {}
+                pulse::operation::State::Cancelled => {
+                    return Err(PulseServerError::OperationErr(
+                        pulse::operation::State::Cancelled,
+                    ))
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct DeviceInfo {
+    pub name: Option<String>,
+    pub description: Option<String>,
+    pub volume: ChannelVolumes,
+    pub mute: bool,
+    pub index: u32,
+}
+
+impl<'a> From<&SinkInfo<'a>> for DeviceInfo {
+    fn from(info: &SinkInfo<'a>) -> Self {
+        Self {
+            name: info.name.clone().map(|x| x.into_owned()),
+            description: info.description.clone().map(|x| x.into_owned()),
+            volume: info.volume,
+            mute: info.mute,
+            index: info.index,
+        }
+    }
+}
+
+impl<'a> From<&SourceInfo<'a>> for DeviceInfo {
+    fn from(info: &SourceInfo<'a>) -> Self {
+        Self {
+            name: info.name.clone().map(|x| x.into_owned()),
+            description: info.description.clone().map(|x| x.into_owned()),
+            volume: info.volume,
+            mute: info.mute,
+            index: info.index,
+        }
+    }
+}
+
+impl Eq for DeviceInfo {}
+
+#[derive(Debug)]
+pub struct ServerInfo {
+    /// User name of the daemon process.
+    pub user_name: Option<String>,
+    /// Host name the daemon is running on.
+    pub host_name: Option<String>,
+    /// Version string of the daemon.
+    pub server_version: Option<String>,
+    /// Server package name (usually “pulseaudio”).
+    pub server_name: Option<String>,
+    // Default sample specification.
+    //pub sample_spec: sample::Spec,
+    /// Name of default sink.
+    pub default_sink_name: Option<String>,
+    /// Name of default source.
+    pub default_source_name: Option<String>,
+    /// A random cookie for identifying this instance of PulseAudio.
+    pub cookie: u32,
+    // Default channel map.
+    //pub channel_map: channelmap::Map,
+}
+
+impl<'a> From<&'a pulse::context::introspect::ServerInfo<'a>> for ServerInfo {
+    fn from(info: &'a pulse::context::introspect::ServerInfo<'a>) -> Self {
+        ServerInfo {
+            user_name: info.user_name.as_ref().map(|cow| cow.to_string()),
+            host_name: info.host_name.as_ref().map(|cow| cow.to_string()),
+            server_version: info.server_version.as_ref().map(|cow| cow.to_string()),
+            server_name: info.server_name.as_ref().map(|cow| cow.to_string()),
+            //sample_spec: info.sample_spec,
+            default_sink_name: info.default_sink_name.as_ref().map(|cow| cow.to_string()),
+            default_source_name: info.default_source_name.as_ref().map(|cow| cow.to_string()),
+            cookie: info.cookie,
+            //channel_map: info.channel_map,
+        }
+    }
+}