integration hell

src-tauri/Cargo.toml

@@ -25,7 +25,7 @@ tauri = { version = "1.0.0-beta.8", features = ["api-all", "system-tray"] }
 futures = "0.3.19"
 futures-util = "0.3.19"
 async-trait = "0.1.52"
-tokio = { version="1.16.1", features=["rt-multi-thread","macros"] }
+tokio = { version="1.16.1", features= ["rt-multi-thread","macros"] }
 tokio-util = "0.6.9"
 
 directories = "4.0.1"
@@ -35,7 +35,7 @@ vigem-client = "0.1.1"
 palette = "0.6.0"
 winapi = "0.3.9"
 
-hyper = { version="0.14.16", features=["server", "http1", "http2", "tcp", "stream", "runtime"] }
+hyper = { version="0.14.16", features= ["server", "http1", "http2", "tcp", "stream", "runtime"] }
 path-clean = "0.1.0"
 tungstenite = { version="0.16.0", default-features=false }
 tokio-tungstenite = "0.16.1"

src-tauri/src/bin/test_brokenithm.rs

@@ -4,16 +4,16 @@ use std::{io, time::Duration};
 
 use tokio::time::sleep;
 
-use slidershim::slider_io::{
-  brokenithm::BrokenithmJob, controller_state::FullState, worker::AsyncWorker,
-};
+// use slidershim::slider_io::{
+//   brokenithm::BrokenithmJob, controller_state::FullState, worker::AsyncWorker,
+// };
 
 fn main() {
   env_logger::Builder::new()
     .filter_level(log::LevelFilter::Debug)
     .init();
 
-  let worker = AsyncWorker::new("brokenithm", BrokenithmJob::new(FullState::new()));
+  // let worker = AsyncWorker::new("brokenithm", BrokenithmJob::new(FullState::new()));
   let mut input = String::new();
   let string = io::stdin().read_line(&mut input).unwrap();
 }

src-tauri/src/main.rs

@@ -29,15 +29,19 @@ fn quit_app() {
 }
 
 fn main() {
-  env_logger::init();
+  env_logger::Builder::new()
+    .filter_level(log::LevelFilter::Debug)
+    .init();
 
   let config = Arc::new(Mutex::new(Some(slider_io::Config::default())));
-  let manager: slider_io::Manager;
+  let manager: Arc<Mutex<Option<slider_io::Manager>>> = Arc::new(Mutex::new(None));
   {
-    let c = config.lock().unwrap();
-    let cr = c.as_ref().unwrap();
-    cr.save();
-    manager = slider_io::Manager::new(cr.clone());
+    let config_handle = config.lock().unwrap();
+    let config_handle_ref = config_handle.as_ref().unwrap();
+    config_handle_ref.save();
+    let mut manager_handle = manager.lock().unwrap();
+    manager_handle.take();
+    manager_handle.replace(slider_io::Manager::new(config_handle_ref.clone()));
   }
 
   tauri::Builder::default()
@@ -85,13 +89,19 @@ fn main() {
       });
 
       let config_clone = Arc::clone(&config);
+      let manager_clone = Arc::clone(&manager);
       app.listen_global("setConfig", move |event| {
         let payload = event.payload().unwrap();
         info!("Config applied {}", payload);
         if let Some(new_config) = slider_io::Config::from_str(payload) {
           let mut config_handle = config_clone.lock().unwrap();
+          config_handle.take();
           config_handle.replace(new_config);
-          config_handle.as_ref().unwrap().save();
+          let config_handle_ref = config_handle.as_ref().unwrap();
+          config_handle_ref.save();
+          let mut manager_handle = manager_clone.lock().unwrap();
+          manager_handle.take();
+          manager_handle.replace(slider_io::Manager::new(config_handle_ref.clone()));
         }
       });
 

src-tauri/src/slider_io/brokenithm.rs

@@ -176,8 +176,10 @@ pub struct BrokenithmJob {
 }
 
 impl BrokenithmJob {
-  pub fn new(state: FullState) -> Self {
-    Self { state }
+  pub fn new(state: &FullState) -> Self {
+    Self {
+      state: state.clone(),
+    }
   }
 }
 

src-tauri/src/slider_io/manager.rs

@@ -1,14 +1,20 @@
 use log::info;
 
 use crate::slider_io::{
-  config::Config, controller_state::FullState, device::HidDeviceJob, led::LedJob,
-  output::OutputJob, worker::ThreadWorker,
+  brokenithm::BrokenithmJob,
+  config::{Config, DeviceMode},
+  controller_state::FullState,
+  device::HidDeviceJob,
+  led::LedJob,
+  output::OutputJob,
+  worker::{AsyncWorker, ThreadWorker},
 };
 
 pub struct Manager {
   state: FullState,
   config: Config,
-  device_worker: ThreadWorker,
+  device_worker: Option<ThreadWorker>,
+  brokenithm_worker: Option<AsyncWorker>,
   output_worker: ThreadWorker,
   led_worker: ThreadWorker,
 }
@@ -21,10 +27,20 @@ impl Manager {
     info!("LED config {:?}", config.led_mode);
 
     let state = FullState::new();
-    let device_worker = ThreadWorker::new(
+
+    let (device_worker, brokenithm_worker) = match &config.device_mode {
+      DeviceMode::Brokenithm { .. } => (
+        None,
+        Some(AsyncWorker::new("brokenithm", BrokenithmJob::new(&state))),
+      ),
+      other => (
+        Some(ThreadWorker::new(
           "device",
-      HidDeviceJob::from_config(&state, &config.device_mode),
-    );
+          HidDeviceJob::from_config(&state, other),
+        )),
+        None,
+      ),
+    };
     let output_worker = ThreadWorker::new("output", OutputJob::new(&state, &config.output_mode));
     let led_worker = ThreadWorker::new("led", LedJob::new(&state, &config.led_mode));
 
@@ -32,6 +48,7 @@ impl Manager {
       state,
       config,
       device_worker,
+      brokenithm_worker,
       output_worker,
       led_worker,
     }

src-tauri/src/slider_io/mod.rs

@@ -1,11 +1,11 @@
 mod config;
 mod utils;
-pub mod worker;
+mod worker;
 
-pub mod controller_state;
+mod controller_state;
 mod voltex;
 
-pub mod brokenithm;
+mod brokenithm;
 mod gamepad;
 mod keyboard;
 

src-tauri/src/slider_io/worker.rs

@@ -115,19 +115,20 @@ impl Drop for AsyncWorker {
 
     if self.stop_signal.is_some() {
       let send_stop = self.stop_signal.take().unwrap();
-      self.runtime.block_on(async move {
       send_stop.send(()).unwrap();
-      });
+      // self.runtime.block_on(async move {
+      //   send_stop.send(()).unwrap();
+      // });
     }
 
     let name = self.name;
 
     if self.task.is_some() {
-      let task = self.task.take().unwrap();
-      self.runtime.block_on(async move {
-        task.await;
-        info!("Async worker stopping internal {}", name);
-      });
+      // let task = self.task.take().unwrap();
+      // self.runtime.block_on(async move {
+      //   task.await;
+      //   info!("Async worker stopping internal {}", name);
+      // });
     }
   }
 }