src/config.rs

@@ -1,7 +1,7 @@
 use config::{Config, FileFormat};
-use log::{error, info};
 use std::fs::File;
 use std::io::Write;
+use log::{error, info};
 
 use crate::ui_code::AppState;
 
@@ -23,19 +23,23 @@ pub fn load_config() -> AppState {
 
 pub fn save_config(config: &AppState) {
     match toml::to_string(&config) {
-        Ok(toml_str) => match File::create("./settings.toml") {
-            Ok(mut file) => match file.write_all(toml_str.as_bytes()) {
+        Ok(toml_str) => {
+            match File::create("./settings.toml") {
+                Ok(mut file) => {
+                    match file.write_all(toml_str.as_bytes()) {
                         Ok(_) => {
                             info!("Config file saved succesfully");
                         }
                         Err(e) => {
                             error!("Couldn't write config file contents to open file: {e}");
                         }
-            },
+                    }
+                }
                 Err(e) => {
                     error!("Couldn't open settings file: {e}");
                 }
-        },
+            }
+        }
         Err(e) => {
             error!("Could not serialize app state: {e}");
         }

src/coordinator.rs

@@ -1,8 +1,5 @@
+use std::sync::{atomic::{AtomicBool, Ordering}, Arc};
 use std::pin::{pin, Pin};
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
 
 use async_channel::{Receiver, Sender};
 use futures_util::stream::StreamExt;
@@ -37,13 +34,8 @@ struct CoordState<'a> {
     pub rt: Handle,
 }
 
-impl<'a> CoordState<'a> {
-    pub fn new(
-        mec: Pin<&'a mut Receiver<ApplicationEvent>>,
-        to_mec: Sender<ApplicationEvent>,
-        to_gui: Sender<GuiUpdate>,
-        rt: Handle,
-    ) -> Self {
+impl <'a> CoordState<'a> {
+    pub fn new(mec: Pin<&'a mut Receiver<ApplicationEvent>>, to_mec: Sender<ApplicationEvent>, to_gui: Sender<GuiUpdate>, rt: Handle) -> Self {
         CoordState {
             to_socket: None,
 
@@ -51,10 +43,7 @@ impl<'a> CoordState<'a> {
             sck_recv_alive: Arc::new(AtomicBool::new(false)),
             joystick_loop_alive: Arc::new(AtomicBool::new(false)),
 
-            mec,
-            to_mec,
-            to_gui,
-            rt,
+            mec, to_mec, to_gui, rt
         }
     }
 
@@ -71,9 +60,8 @@ impl<'a> CoordState<'a> {
     }
 
     pub async fn socket_start(&mut self, conn: String) {
-        if !(self.sck_recv_alive.load(Ordering::SeqCst)
-            && self.sck_send_alive.load(Ordering::SeqCst))
-        {
+        if !(self.sck_recv_alive.load(Ordering::SeqCst) && !self.sck_send_alive.load(Ordering::SeqCst)) {
+
             info!("Starting socket");
             let (to_socket, socket_sender_rx) = async_channel::bounded::<Message>(10);
 
@@ -85,33 +73,29 @@ impl<'a> CoordState<'a> {
                 socket_sender_rx,
                 self.sck_send_alive.clone(),
                 self.sck_recv_alive.clone(),
-                self.rt.clone(),
-            )
-            .await;
+                self.rt.clone()
+            ).await;
         }
     }
 
     pub async fn check_states(&mut self) {
         if !self.joystick_loop_alive.load(Ordering::SeqCst) {
-            self.rt.spawn(joystick_loop(
-                self.to_mec.clone(),
-                self.joystick_loop_alive.clone(),
-            ));
+            self.rt.spawn(joystick_loop(self.to_mec.clone(), self.joystick_loop_alive.clone()));
         }
 
-        if !self.sck_recv_alive.load(Ordering::SeqCst)
-            || !self.sck_send_alive.load(Ordering::SeqCst)
-        {
+        if !self.sck_recv_alive.load(Ordering::SeqCst) || !self.sck_send_alive.load(Ordering::SeqCst) {
             self.socket_close().await;
 
             if let Err(e) = self.to_gui.send(GuiUpdate::SocketState(false)).await {
                 error!("Cannot send message to gui thread: {e}");
             }
-        } else if let Err(e) = self.to_gui.send(GuiUpdate::SocketState(true)).await {
+        } else {
+            if let Err(e) = self.to_gui.send(GuiUpdate::SocketState(true)).await {
                 error!("Cannot send message to gui thread: {e}");
                 self.close().await;
             }
         }
+    }
 
     pub async fn close(&mut self) {
         info!("closing coord state");
@@ -132,19 +116,20 @@ impl<'a> CoordState<'a> {
 }
 
 //                      Main_Event_Channel
-pub async fn start_coordinator(
-    mec: Receiver<ApplicationEvent>,
-    to_mec: Sender<ApplicationEvent>,
-    to_gui: Sender<GuiUpdate>,
-    runtime: Handle,
-) {
+pub async fn start_coordinator(mec: Receiver<ApplicationEvent>, to_mec: Sender<ApplicationEvent>, to_gui: Sender<GuiUpdate>, runtime: Handle) {
     info!("Starting coordinator!"); 
 
     let mec = pin!(mec);
 
-    let mut state = CoordState::new(mec, to_mec, to_gui, runtime);
+    let mut state = CoordState::new(
+        mec,
+        to_mec,
+        to_gui,
+        runtime
+    );
 
     while let Some(msg) = state.mec.next().await {
+
         state.check_states().await;
 
         match msg {
@@ -186,4 +171,5 @@ pub async fn start_coordinator(
     }
 
     info!("Stopping Coordinator");
+
 }

src/joystick_loop.rs

@@ -2,11 +2,11 @@ use crate::coordinator::{ApplicationEvent, MoveEvent};
 
 use async_channel::Sender;
 use gilrs::{ev::filter::FilterFn, Axis, Button, Event, EventType, Filter, Gilrs, GilrsBuilder};
-use log::{info, warn};
+use log::{debug, info, warn};
 use std::{
     panic::{self, AssertUnwindSafe},
     sync::{atomic::AtomicBool, Arc},
-    time::Duration,
+    time::Duration
 };
 
 static MAX_SENT_ZEROS: u32 = 10;
@@ -35,7 +35,10 @@ impl FilterFn for UnknownSlayer {
     }
 }
 
-pub async fn joystick_loop(tx: Sender<ApplicationEvent>, is_alive: Arc<AtomicBool>) {
+pub async fn joystick_loop(
+    tx: Sender<ApplicationEvent>,
+    is_alive: Arc<AtomicBool>
+) {
     let mut gilrs = GilrsBuilder::new().set_update_state(false).build().unwrap();
 
     is_alive.store(true, std::sync::atomic::Ordering::SeqCst);
@@ -92,11 +95,9 @@ pub async fn joystick_loop(tx: Sender<ApplicationEvent>, is_alive: Arc<AtomicBoo
                 Ok(_) => {}
                 Err(async_channel::TrySendError::Closed(_)) => {
                     info!("MEC is closed, stopping Joystick loop");
-                    break;
-                }
-                Err(async_channel::TrySendError::Full(_)) => {
-                    warn!("[joystick loop] The MEC is full!")
+                    break 
                 }
+                Err(async_channel::TrySendError::Full(_)) => {warn!("[joystick loop] The MEC is full!")}
             }
         }
 

src/main.rs

@@ -13,6 +13,7 @@ mod socket_loop;
 mod ui_code;
 const APP_ID: &str = "net.nickiel.joystick-controller-client";
 
+
 fn main() -> glib::ExitCode {
     env::set_var("gtk_csd", "0");
 

src/socket_loop.rs

@@ -1,7 +1,4 @@
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
+use std::sync::{atomic::{AtomicBool, Ordering}, Arc};
 
 use async_channel::{Receiver, Sender};
 use futures_util::{
@@ -32,7 +29,7 @@ async fn socket_listen(
                     error!("Websocket error: {:#?}", e);
                 }
             }
-        }
+        };
 
         socket_recv_is_alive.store(false, Ordering::SeqCst);
     }
@@ -72,15 +69,15 @@ pub async fn socket_loop(
     send_to_socket: Receiver<Message>,
     socket_send_is_alive: Arc<AtomicBool>,
     socket_recv_is_alive: Arc<AtomicBool>,
-    rt: Handle,
+    rt: Handle
 ) {
     info!("Starting Socket Loop");
     
+
     socket_send_is_alive.store(true, Ordering::SeqCst);
     socket_recv_is_alive.store(true, Ordering::SeqCst);
 
-    let socket: Option<WebSocketStream<MaybeTlsStream<TcpStream>>> =
-        match connect_async(connection_string).await {
+    let socket: Option<WebSocketStream<MaybeTlsStream<TcpStream>>> = match connect_async(connection_string).await {
         Ok((val, _)) => {
             info!("Socket connection made successfully");
             Some(val)

src/ui_code.rs

@@ -9,6 +9,7 @@ use crate::config::{load_config, save_config};
 // use crate::{joystick_loop, JoystickThreadUpdate};
 use crate::coordinator::{start_coordinator, ApplicationEvent, MoveEvent};
 
+
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct AppState {
     pub ip: String,
@@ -37,12 +38,8 @@ pub fn build_ui(app: &Application, runtime: Handle) {
     let (to_mec, mec) = async_channel::unbounded::<ApplicationEvent>();
     let (to_gui, gui_recv) = async_channel::bounded::<GuiUpdate>(10);
 
-    runtime.spawn(start_coordinator(
-        mec,
-        to_mec.clone(),
-        to_gui,
-        runtime.clone(),
-    ));
+    runtime.spawn(start_coordinator(mec, to_mec.clone(), to_gui, runtime.clone()));
+
 
     // let conn_status_label = Label::new(Some(&"No Connection".to_string()));
     let conn_status_label = Label::builder()
@@ -160,7 +157,9 @@ pub fn build_ui(app: &Application, runtime: Handle) {
         .child(&main_box)
         .build();
 
-    window.connect_close_request(move |_| glib::Propagation::Proceed);
+    window.connect_close_request(move |_| {
+        glib::Propagation::Proceed
+    });
 
     // Present window
     window.present();