Create rog-platform, refactor rogcc ipc-file handling

- Create new rog-platform crate to manage all i/o in a universal way
  + kbd-led handling
  + platform handling (asus-nb-wmi)
  + hidraw
  + usbraw
- Refactor how ROGCC handles IPC for background open, run-in-bg

rog-control-center/src/main.rs

@@ -2,19 +2,14 @@ use rog_aura::layouts::KeyLayout;
 use rog_control_center::{
     config::Config, get_ipc_file, notify::start_notifications, on_tmp_dir_exists,
     page_states::PageDataStates, startup_error::AppErrorShow, RogApp, RogDbusClientBlocking,
-    SHOW_GUI,
+    SHOWING_GUI, SHOW_GUI,
 };
 
 use std::{
     fs::{self, OpenOptions},
-    io::Read,
+    io::{Read, Write},
     path::PathBuf,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
-    thread::spawn,
-    time::Duration,
+    sync::{atomic::AtomicBool, Arc},
 };
 
 #[cfg(not(feature = "mocking"))]
@@ -29,6 +24,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         transparent: false,
         min_window_size: Some(egui::vec2(840.0, 600.0)),
         max_window_size: Some(egui::vec2(840.0, 600.0)),
+        run_and_return: true,
         ..Default::default()
     };
 
@@ -44,7 +40,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Startup
     let mut config = Config::load()?;
-    let start_closed = config.startup_in_background;
+    let mut start_closed = config.startup_in_background;
 
     if config.startup_in_background {
         config.run_in_background = true;
@@ -94,44 +90,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let fans_notified = Arc::new(AtomicBool::new(false));
     let notifs_enabled = Arc::new(AtomicBool::new(config.enable_notifications));
 
-    let states = {
-        let supported = dbus
-            .proxies()
-            .supported()
-            .supported_functions()
-            .map_err(|e| {
-                eframe::run_native(
-                    "ROG Control Center",
-                    native_options.clone(),
-                    Box::new(move |_| Box::new(AppErrorShow::new(e.to_string()))),
-                );
-            })
-            .unwrap();
-        PageDataStates::new(
-            layout,
-            notifs_enabled.clone(),
-            charge_notified.clone(),
-            bios_notified.clone(),
-            aura_notified.clone(),
-            anime_notified.clone(),
-            profiles_notified.clone(),
-            fans_notified.clone(),
-            &supported,
-            &dbus,
-        )? // TODO: if error, show alt GUI containing the error message
-    };
-
-    if config.enable_notifications {
-        start_notifications(
-            charge_notified,
-            bios_notified,
-            aura_notified,
-            anime_notified,
-            profiles_notified,
-            fans_notified,
-            notifs_enabled,
-        )?;
-    }
+    start_notifications(
+        charge_notified.clone(),
+        bios_notified.clone(),
+        aura_notified.clone(),
+        anime_notified.clone(),
+        profiles_notified.clone(),
+        fans_notified.clone(),
+        notifs_enabled.clone(),
+    )?;
 
     // tmp-dir must live to the end of program life
     let _tmp_dir = match tempfile::Builder::new()
@@ -143,25 +110,59 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         Err(_) => on_tmp_dir_exists().unwrap(),
     };
 
-    let should_show_gui = Arc::new(AtomicBool::new(!start_closed));
-    let should = should_show_gui.clone();
-    spawn(move || {
-        // Loop is blocked here until a single byte is read
-        loop {
-            let mut buf = [0u8; 4];
-            if get_ipc_file().unwrap().read(&mut buf).is_ok() && buf[0] == SHOW_GUI {
-                should_show_gui.store(true, Ordering::SeqCst);
-                // Give the starting app a change to read or we'll race it
-                std::thread::sleep(Duration::from_millis(10));
-            }
-        }
-    });
+    loop {
+        let states = {
+            let supported = match dbus.proxies().supported().supported_functions() {
+                Ok(s) => s,
+                Err(e) => {
+                    eframe::run_native(
+                        "ROG Control Center",
+                        native_options.clone(),
+                        Box::new(move |_| Box::new(AppErrorShow::new(e.to_string()))),
+                    );
+                    return Ok(());
+                }
+            };
 
-    eframe::run_native(
-        "ROG Control Center",
-        native_options,
-        Box::new(move |cc| {
-            Box::new(RogApp::new(start_closed, config, should, states, cc).unwrap())
-        }),
-    );
+            PageDataStates::new(
+                layout.clone(),
+                notifs_enabled.clone(),
+                charge_notified.clone(),
+                bios_notified.clone(),
+                aura_notified.clone(),
+                anime_notified.clone(),
+                profiles_notified.clone(),
+                fans_notified.clone(),
+                &supported,
+                &dbus,
+            )?
+        };
+
+        if !start_closed {
+            let mut ipc_file = get_ipc_file().unwrap();
+            ipc_file.write_all(&[SHOWING_GUI]).unwrap();
+            eframe::run_native(
+                "ROG Control Center",
+                native_options.clone(),
+                Box::new(move |cc| {
+                    Box::new(RogApp::new(Config::load().unwrap(), states, cc).unwrap())
+                }),
+            );
+        }
+
+        let config = Config::load().unwrap();
+        if !config.run_in_background {
+            break;
+        }
+
+        let mut buf = [0u8; 4];
+        // blocks until it is read, typically the read will happen after a second
+        // process writes to the IPC (so there is data to actually read)
+        if get_ipc_file().unwrap().read(&mut buf).is_ok() && buf[0] == SHOW_GUI {
+            start_closed = false;
+            continue;
+        }
+        dbg!("asda");
+    }
+    Ok(())
 }