Add common server interface

src/controller.rs

@@ -1,8 +1,9 @@
 use crate::config::NanoKeys;
-use crate::config::{Config, KeyMapVariant, MprisAction, PulseAction};
+use crate::config::{Config, KeyMapVariant, MprisAction};
+use crate::interaction_server::InteractionServer;
 use crate::midi_client::KeyEvent;
 use crate::mpris_client;
-use crate::pulse_client::{self, PulseMessage};
+use crate::pulse_controller::{PulseController, PulseMessage};
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use log::{error, info, warn};
 use std::process::{Command, Output};
@@ -11,7 +12,8 @@ use std::thread;
 
 pub fn run(in_channel: Receiver<KeyEvent>, config: Arc<Config>) {
     let (sender, receiver) = unbounded::<PulseMessage>();
-    pulse_client::run(receiver);
+    let pulse = PulseController::new(receiver);
+    pulse.start();
     thread::spawn(move || {
         exec(in_channel, sender, config);
     });

src/interaction_server.rs

@@ -0,0 +1,5 @@
+use std::thread::JoinHandle;
+
+pub trait InteractionServer {
+    fn start(self) -> JoinHandle<()>;
+}

src/main.rs

@@ -1,10 +1,14 @@
 mod config;
 mod controller;
+mod interaction_server;
 mod midi_client;
 mod mpris_client;
-mod pulse_client;
+mod pulse_controller;
+
 use crossbeam_channel::unbounded;
 use directories::ProjectDirs;
+use interaction_server::InteractionServer;
+use midi_client::MidiClient;
 use std::{path::PathBuf, sync::Arc};
 
 fn main() {
@@ -12,7 +16,6 @@ fn main() {
 
     let proj_dirs = ProjectDirs::from("com", "ghoscht", "picoKontroller");
     let path: PathBuf = proj_dirs.unwrap().config_dir().join("config.toml");
-    // let path: &str = "./config.toml";
     let cfg: config::Config = config::init(path);
     let arc_cfg = Arc::new(cfg);
 
@@ -21,6 +24,10 @@ fn main() {
     mpris_client::list_clients();
 
     let (sender, receiver) = unbounded::<midi_client::KeyEvent>();
+    let midi = MidiClient::new(arc_cfg.general.midi_device.clone(), sender);
+
     controller::run(receiver, Arc::clone(&arc_cfg));
-    midi_client::run(&arc_cfg.general.midi_device, sender).unwrap();
+
+    let server = midi.start();
+    let _ = server.join();
 }

src/midi_client.rs

@@ -1,23 +1,40 @@
-use crate::config::NanoKeys;
+use crate::{config::NanoKeys, interaction_server::InteractionServer};
 use crossbeam_channel::Sender;
 use midir::{Ignore, MidiInput};
 use regex::Regex;
-use std::error::Error;
+use std::thread::{self, JoinHandle};
 use std::time;
 
-pub fn list_ports() -> () {
+const CLIENT_NAME: &str = "PicoKontroller";
-    let midi_in = MidiInput::new("PicoKontroller").expect("Creating Midi device failed");
+const PORT_NAME: &str = "PicoController Input";
-    let in_ports = midi_in.ports();
+
-    println!("All available midi devices:");
+pub struct MidiClient {
-    for (_, p) in in_ports.iter().enumerate() {
+    pub device_name: String,
-        println!("{}", midi_in.port_name(p).unwrap());
+    pub out_channel: Sender<KeyEvent>,
+}
+
+pub type KeyEvent = (NanoKeys, u8);
+
+impl InteractionServer for MidiClient {
+    fn start(self) -> JoinHandle<()> {
+        thread::spawn(move || {
+            self.exec();
+        })
     }
 }
 
-pub fn run(port_name: &str, out_channel: Sender<KeyEvent>) -> Result<(), Box<dyn Error>> {
+impl MidiClient {
-    let port_filter = Regex::new(port_name).expect("Creating RegEx failed");
+    pub fn new(device_name: String, out_channel: Sender<KeyEvent>) -> MidiClient {
+        MidiClient {
+            device_name,
+            out_channel,
+        }
+    }
 
-    let mut midi_in = MidiInput::new("PicoKontroller").expect("Creating Midi device failed");
+    fn exec(self) {
+        let port_filter = Regex::new(&self.device_name).expect("Creating RegEx failed");
+
+        let mut midi_in = MidiInput::new(CLIENT_NAME).expect("Creating Midi device failed");
         midi_in.ignore(Ignore::None);
 
         let in_ports = midi_in.ports();
@@ -29,19 +46,27 @@ pub fn run(port_name: &str, out_channel: Sender<KeyEvent>) -> Result<(), Box<dyn
         // _conn_in needs to be a named parameter, because it needs to be kept alive until the end of the scope
         let _conn_in = midi_in.connect(
             in_port,
-        "PicoController Input",
+            PORT_NAME,
             move |_, message, _| {
                 let key = NanoKeys::try_from(message[1]).unwrap();
                 let state = message[2];
-            let _ = out_channel.send((key, state));
+                let _ = self.out_channel.send((key, state));
             },
             (),
-    )?;
+        );
         loop {
             // sleep forever, callback functions happen on separate thread
             // couldn't reuse this thread, since _conn_in needs to be alive in this scope
             std::thread::sleep(time::Duration::from_secs(u64::MAX));
         }
     }
+}
 
-pub type KeyEvent = (NanoKeys, u8);
+pub fn list_ports() -> () {
+    let midi_in = MidiInput::new(CLIENT_NAME).expect("Creating Midi device failed");
+    let in_ports = midi_in.ports();
+    println!("All available midi devices:");
+    for (_, p) in in_ports.iter().enumerate() {
+        println!("{}", midi_in.port_name(p).unwrap());
+    }
+}

src/pulse_controller.rs

@@ -1,8 +1,9 @@
 extern crate libpulse_binding as pulse;
 
-use crate::config::{Config, KeyMapVariant, PulseAction};
+use crate::config::PulseAction;
+use crate::interaction_server::InteractionServer;
 use crossbeam_channel::Receiver;
-use log::{error, info, warn};
+use log::error;
 use pulse::context::{Context, FlagSet as ContextFlagSet};
 use pulse::mainloop::threaded::Mainloop;
 use pulse::proplist::Proplist;
@@ -11,21 +12,36 @@ use regex::Regex;
 use std::cell::RefCell;
 use std::ops::Deref;
 use std::sync::Arc;
-use std::thread;
+use std::thread::{self, JoinHandle};
+
+const APPLICATION_NAME: &str = "picoKontroller";
+const CONTEXT_NAME: &str = "picoKontrollerContext";
 
 pub type PulseMessage = (Arc<Vec<String>>, PulseAction, u8);
 
-pub fn run(in_channel: Receiver<PulseMessage>) {
+pub struct PulseController {
-    thread::spawn(move || {
+    pub in_channel: Receiver<PulseMessage>,
-        exec(in_channel);
-    });
 }
-pub fn exec(in_channel: Receiver<PulseMessage>) {
+
+impl InteractionServer for PulseController {
+    fn start(self) -> JoinHandle<()> {
+        thread::spawn(move || {
+            self.exec();
+        })
+    }
+}
+
+impl PulseController {
+    pub fn new(in_channel: Receiver<PulseMessage>) -> PulseController {
+        PulseController { in_channel }
+    }
+
+    fn exec(&self) {
         let mut proplist = Proplist::new().unwrap();
         proplist
             .set_str(
                 pulse::proplist::properties::APPLICATION_NAME,
-            "picoKontroller",
+                APPLICATION_NAME,
             )
             .unwrap();
 
@@ -34,11 +50,7 @@ pub fn exec(in_channel: Receiver<PulseMessage>) {
         ));
 
         let context = Arc::new(RefCell::new(
-        Context::new_with_proplist(
+            Context::new_with_proplist(mainloop.borrow().deref(), CONTEXT_NAME, &proplist)
-            mainloop.borrow().deref(),
-            "picoKontrollerContext",
-            &proplist,
-        )
                 .expect("Failed to create new context"),
         ));
 
@@ -95,7 +107,7 @@ pub fn exec(in_channel: Receiver<PulseMessage>) {
         loop {
             let ml = Arc::clone(&mainloop);
             let ctx = Arc::clone(&context);
-        let event_in = in_channel.recv();
+            let event_in = self.in_channel.recv();
             match event_in {
                 Ok((ids, action, state)) => {
                     parse_pulse_action(state, ids, &action, ml, ctx);
@@ -106,6 +118,7 @@ pub fn exec(in_channel: Receiver<PulseMessage>) {
             }
         }
     }
+}
 
 fn parse_pulse_action(
     state: u8,
@@ -127,11 +140,7 @@ fn parse_pulse_action(
     }
 }
 
-pub fn set_default_sink(
+fn set_default_sink(mainloop: Arc<RefCell<Mainloop>>, context: Arc<RefCell<Context>>, name: &str) {
-    mainloop: Arc<RefCell<Mainloop>>,
-    context: Arc<RefCell<Context>>,
-    name: &str,
-) {
     mainloop.borrow_mut().lock();
     let sink_filter = Regex::new(name).expect("Creating RegEx failed");
     let callback_context = context.clone();
@@ -185,7 +194,7 @@ fn for_all_sink_inputs(
     mainloop.borrow_mut().unlock();
 }
 
-pub fn mute_sink_input(
+fn mute_sink_input(
     mainloop: Arc<RefCell<Mainloop>>,
     context: Arc<RefCell<Context>>,
     name: &str,
@@ -203,7 +212,7 @@ pub fn mute_sink_input(
     )
 }
 
-pub fn set_volume_sink_input(
+fn set_volume_sink_input(
     mainloop: Arc<RefCell<Mainloop>>,
     context: Arc<RefCell<Context>>,
     name: &str,
@@ -228,7 +237,7 @@ pub fn set_volume_sink_input(
 }
 
 //taken from https://github.com/jantap/rsmixer
-pub fn percent_to_volume(target_percent: u8) -> u32 {
+fn percent_to_volume(target_percent: u8) -> u32 {
     let base_delta = (volume::Volume::NORMAL.0 as f32 - volume::Volume::MUTED.0 as f32) / 100.0;
 
     if target_percent == 100 {