persistency

src-tauri/src/bin/test_usb.rs

@@ -2,7 +2,7 @@ extern crate slidershim;
 
 use std::io;
 
-use slidershim::slider_io::{config::Config, manager::Manager};
+use slidershim::slider_io::{Config, Manager};
 
 fn main() {
   let config = Config::from_str(
@@ -12,7 +12,8 @@ fn main() {
         "ledMode": "reactive-8",
         "keyboardSensitivity": 50
     }"#,
-  );
+  )
+  .unwrap();
 
   let manager = Manager::new(config);
 

src-tauri/src/main.rs

@@ -7,6 +7,8 @@
 
 mod slider_io;
 
+use std::sync::{Arc, Mutex};
+
 use tauri::{
   AppHandle, CustomMenuItem, Event, Manager, Runtime, SystemTray, SystemTrayEvent, SystemTrayMenu,
 };
@@ -24,6 +26,12 @@ fn quit_app() {
 }
 
 fn main() {
+  let config = Arc::new(Mutex::new(Some(slider_io::Config::default())));
+  {
+    println!("Saving");
+    config.lock().unwrap().as_ref().unwrap().save();
+  }
+
   tauri::Builder::default()
     .system_tray(
       SystemTray::new().with_menu(
@@ -54,16 +62,34 @@ fn main() {
       },
       _ => {}
     })
-    .setup(|app| {
-      app.listen_global("setConfig", |event| {
-        let payload = event.payload().unwrap();
-        println!("Setting config to {}", payload);
-        
+    .setup(move |app| {
+      let app_handle = app.handle();
+      let config_clone = Arc::clone(&config);
+      app.listen_global("heartbeat", move |e| {
+        let config_handle = config_clone.lock().unwrap();
+        println!("Heartbeat {}", config_handle.as_ref().unwrap().raw.as_str());
+        app_handle
+          .emit_all(
+            "showConfig",
+            Some(config_handle.as_ref().unwrap().raw.as_str().to_string()),
+          )
+          .unwrap();
       });
 
-      let handle = app.handle();
+      let config_clone = Arc::clone(&config);
+      app.listen_global("setConfig", move |event| {
+        let payload = event.payload().unwrap();
+        println!("Setting config to {}", payload);
+        if let Some(new_config) = slider_io::Config::from_str(payload) {
+          let mut config_handle = config_clone.lock().unwrap();
+          config_handle.replace(new_config);
+          config_handle.as_ref().unwrap().save();
+        }
+      });
+
+      let app_handle = app.handle();
       app.listen_global("hide", move |_| {
-        hide_window(&handle);
+        hide_window(&app_handle);
       });
 
       app.listen_global("quit", |_| {

src-tauri/src/slider_io/config.rs

@@ -1,5 +1,7 @@
+use directories::ProjectDirs;
+use std::{convert::TryFrom, fs, path::PathBuf};
+
 use serde_json::Value;
-use std::convert::TryFrom;
 
 #[derive(Debug, Clone)]
 pub enum DeviceMode {
@@ -59,12 +61,12 @@ pub struct Config {
 }
 
 impl Config {
-  pub fn from_str(s: &str) -> Config {
-    let v: Value = serde_json::from_str(s).unwrap();
+  pub fn from_str(s: &str) -> Option<Config> {
+    let v: Value = serde_json::from_str(s).ok()?;
 
-    Config {
+    Some(Config {
       raw: s.to_string(),
-      device_mode: match v["deviceMode"].as_str().unwrap() {
+      device_mode: match v["deviceMode"].as_str()? {
         "none" => DeviceMode::None,
         "tasoller-one" => DeviceMode::TasollerOne,
         "tasoller-two" => DeviceMode::TasollerTwo,
@@ -77,34 +79,34 @@ impl Config {
         "none" => OutputMode::None,
         "kb-32-tasoller" => OutputMode::Keyboard {
           layout: KeyboardLayout::Tasoller,
-          sensitivity: u8::try_from(v["keyboardSensitivity"].as_i64().unwrap()).unwrap(),
+          sensitivity: u8::try_from(v["keyboardSensitivity"].as_i64()?).ok()?,
         },
         "kb-32-yuancon" => OutputMode::Keyboard {
           layout: KeyboardLayout::Yuancon,
-          sensitivity: u8::try_from(v["keyboardSensitivity"].as_i64().unwrap()).unwrap(),
+          sensitivity: u8::try_from(v["keyboardSensitivity"].as_i64()?).ok()?,
         },
         "kb-6-deemo" => OutputMode::Keyboard {
           layout: KeyboardLayout::Deemo,
-          sensitivity: u8::try_from(v["keyboardSensitivity"].as_i64().unwrap()).unwrap(),
+          sensitivity: u8::try_from(v["keyboardSensitivity"].as_i64()?).ok()?,
         },
         "websocket" => OutputMode::Websocket {
           url: v["outputWebsocketUrl"].to_string(),
         },
         _ => panic!("Invalid output mode"),
       },
-      led_mode: match v["ledMode"].as_str().unwrap() {
+      led_mode: match v["ledMode"].as_str()? {
         "none" => LedMode::None,
         "reactive-4" => LedMode::Reactive {
           layout: ReactiveLayout::Four,
-          sensitivity: u8::try_from(v["ledSensitivity"].as_i64().unwrap()).unwrap(),
+          sensitivity: u8::try_from(v["ledSensitivity"].as_i64()?).ok()?,
         },
         "reactive-8" => LedMode::Reactive {
           layout: ReactiveLayout::Eight,
-          sensitivity: u8::try_from(v["ledSensitivity"].as_i64().unwrap()).unwrap(),
+          sensitivity: u8::try_from(v["ledSensitivity"].as_i64()?).ok()?,
         },
         "reactive-16" => LedMode::Reactive {
           layout: ReactiveLayout::Sixteen,
-          sensitivity: u8::try_from(v["ledSensitivity"].as_i64().unwrap()).unwrap(),
+          sensitivity: u8::try_from(v["ledSensitivity"].as_i64()?).ok()?,
         },
         "attract" => LedMode::Attract,
         "test" => LedMode::Test,
@@ -113,6 +115,56 @@ impl Config {
         },
         _ => panic!("Invalid led mode"),
       },
+    })
+  }
+
+  fn factory() -> Self {
+    Self::from_str(
+      r#"{
+      "deviceMode": "none",
+      "outputMode": "none",
+      "ledMode": "none",
+      "keyboardSensitivity": 20,
+      "outputWebsocketUrl": "localhost:3000",
+      "ledSensitivity": 20,
+      "ledWebsocketUrl": "localhost:3001"
+    }"#,
+    )
+    .unwrap()
+  }
+
+  fn get_saved_path() -> Option<Box<PathBuf>> {
+    let project_dir = ProjectDirs::from("me", "imp.ress", "slidershim").unwrap();
+    let config_dir = project_dir.config_dir();
+    fs::create_dir_all(config_dir);
+
+    let config_path = config_dir.join("config.json");
+
+    return Some(Box::new(config_path));
+  }
+
+  fn load_saved() -> Option<Self> {
+    let config_path = Self::get_saved_path()?;
+    if !config_path.exists() {
+      return None;
     }
+    println!("Found saved");
+    let mut saved_data = fs::read_to_string(config_path.as_path()).ok()?;
+    println!("Loaded saved {}", saved_data);
+    return Self::from_str(saved_data.as_str());
+  }
+
+  pub fn default() -> Self {
+    Self::load_saved()
+      .or_else(|| Some(Self::factory()))
+      .unwrap()
+  }
+
+  pub fn save(&self) -> Option<()> {
+    let config_path = Self::get_saved_path()?;
+    println!("Saving to {:?}", config_path);
+    fs::write(config_path.as_path(), self.raw.as_str()).unwrap();
+
+    Some(())
   }
 }

src-tauri/src/slider_io/mod.rs

@@ -1,4 +1,4 @@
-pub mod config;
+mod config;
 
 mod controller_state;
 mod worker;
@@ -9,4 +9,7 @@ mod device;
 mod led;
 mod output;
 
-pub mod manager;
+mod manager;
+
+pub use config::Config;
+pub use manager::Manager;