cargo fmt

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,23 +23,19 @@ pub fn load_config() -> AppState {
 
 pub fn save_config(config: &AppState) {
     match toml::to_string(&config) {
-        Ok(toml_str) => {
+        Ok(toml_str) => match File::create("./settings.toml") {
-            match File::create("./settings.toml") {
+            Ok(mut file) => match file.write_all(toml_str.as_bytes()) {
-                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,5 +1,8 @@
-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;
@@ -35,7 +38,12 @@ struct CoordState<'a> {
 }
 
 impl<'a> CoordState<'a> {
-    pub fn new(mec: Pin<&'a mut Receiver<ApplicationEvent>>, to_mec: Sender<ApplicationEvent>, to_gui: Sender<GuiUpdate>, rt: Handle) -> Self {
+    pub fn new(
+        mec: Pin<&'a mut Receiver<ApplicationEvent>>,
+        to_mec: Sender<ApplicationEvent>,
+        to_gui: Sender<GuiUpdate>,
+        rt: Handle,
+    ) -> Self {
         CoordState {
             to_socket: None,
 
@@ -43,7 +51,10 @@ 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,
         }
     }
 
@@ -60,8 +71,9 @@ 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);
 
@@ -73,29 +85,33 @@ impl <'a> CoordState<'a> {
                 socket_sender_rx,
                 self.sck_send_alive.clone(),
                 self.sck_recv_alive.clone(),
-                self.rt.clone()
+                self.rt.clone(),
-            ).await;
+            )
+            .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 {
+        } else if let Err(e) = self.to_gui.send(GuiUpdate::SocketState(true)).await {
-            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");
@@ -116,20 +132,19 @@ 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(
+    let mut state = CoordState::new(mec, to_mec, to_gui, runtime);
-        mec,
-        to_mec,
-        to_gui,
-        runtime
-    );
 
     while let Some(msg) = state.mec.next().await {
-
         state.check_states().await;
 
         match msg {
@@ -171,5 +186,4 @@ pub async fn start_coordinator(mec: Receiver<ApplicationEvent>, to_mec: Sender<A
     }
 
     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::{debug, info, warn};
+use log::{info, warn};
 use std::{
     panic::{self, AssertUnwindSafe},
     sync::{atomic::AtomicBool, Arc},
-    time::Duration
+    time::Duration,
 };
 
 static MAX_SENT_ZEROS: u32 = 10;
@@ -35,10 +35,7 @@ impl FilterFn for UnknownSlayer {
     }
 }
 
-pub async fn joystick_loop(
+pub async fn joystick_loop(tx: Sender<ApplicationEvent>, is_alive: Arc<AtomicBool>) {
-    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);
@@ -95,9 +92,11 @@ pub async fn joystick_loop(
                 Ok(_) => {}
                 Err(async_channel::TrySendError::Closed(_)) => {
                     info!("MEC is closed, stopping Joystick loop");
-                    break 
+                    break;
+                }
+                Err(async_channel::TrySendError::Full(_)) => {
+                    warn!("[joystick loop] The MEC is full!")
                 }
-                Err(async_channel::TrySendError::Full(_)) => {warn!("[joystick loop] The MEC is full!")}
             }
         }
 

src/main.rs

@@ -13,7 +13,6 @@ 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,4 +1,7 @@
-use std::sync::{atomic::{AtomicBool, Ordering}, Arc};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
 
 use async_channel::{Receiver, Sender};
 use futures_util::{
@@ -29,7 +32,7 @@ async fn socket_listen(
                     error!("Websocket error: {:#?}", e);
                 }
             }
-        };
+        }
 
         socket_recv_is_alive.store(false, Ordering::SeqCst);
     }
@@ -69,15 +72,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,7 +9,6 @@ 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,
@@ -38,8 +37,12 @@ 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()
@@ -157,9 +160,7 @@ pub fn build_ui(app: &Application, runtime: Handle) {
         .child(&main_box)
         .build();
 
-    window.connect_close_request(move |_| {
+    window.connect_close_request(move |_| glib::Propagation::Proceed);
-        glib::Propagation::Proceed
-    });
 
     // Present window
     window.present();