fix: correct minor mistakes in networker

Author: DASPRiD

README.md

@@ -23,13 +23,14 @@ To have the boop box automatically start when the system boots, create a systemd
 
 ```
 [Unit]
-Description=BoopBox.js
+Description=BoopBox
 After=network.target
 
 [Service]
 Type=simple
 User=pi
-ExecStart=/usr/local/bin/node /home/pi/bin/boop-box
+ExecStart=/home/pi/bin/boop-box
+Environment="RUST_LOG=info"
 WorkingDirectory=/home/pi
 Restart=always
 

src/nfc/reader.rs

@@ -3,7 +3,7 @@ use nfc1::target_info::TargetInfo;
 use nfc1::BaudRate::Baud106;
 use nfc1::Error::Timeout as TimeoutError;
 use nfc1::ModulationType::Iso14443a;
-use nfc1::{Modulation, Timeout};
+use nfc1::{Modulation, Property, Timeout};
 
 use crate::nfc::ndef::{parse_ndef_text_record, NdefMessageParser};
 
@@ -49,6 +49,9 @@ impl<'a> NfcReader<'a> {
     }
 
     pub fn select_target(&mut self) -> Option<Uid> {
+        self.device
+            .set_property_bool(Property::InfiniteSelect, false)
+            .unwrap();
         let result = self.device.initiator_select_passive_target(&Modulation {
             modulation_type: Iso14443a,
             baud_rate: Baud106,

src/nfc/thread.rs

@@ -29,7 +29,7 @@ pub fn start_nfc_listener(mut nfc_rx: mpsc::Receiver<NfcCommand>) {
         let device = context.open().unwrap();
         let mut nfc_reader = NfcReader::new(device);
 
-        while let Some(command) = nfc_rx.blocking_recv() {
+        'command: while let Some(command) = nfc_rx.blocking_recv() {
             use NfcCommand::*;
 
             match command {
@@ -39,7 +39,7 @@ pub fn start_nfc_listener(mut nfc_rx: mpsc::Receiver<NfcCommand>) {
                 } => {
                     let uid = loop {
                         if cancel_rx.try_recv() != Err(TryRecvError::Empty) {
-                            return;
+                            continue 'command;
                         }
 
                         if let Some(uid) = nfc_reader.select_target() {

src/subsystems/controller.rs

@@ -100,11 +100,11 @@ impl Controller {
 
                     match maybe_achievements {
                         Some(achievements) => {
-                            let (done_tx, done_rx) = oneshot::channel();
-                            self.audio_player.send(PlayerCommand::PlayConfirm { done: done_tx }).await?;
-                            done_rx.await?;
-
                             for achievement_id in achievements.iter() {
+                                let (done_tx, done_rx) = oneshot::channel();
+                                self.audio_player.send(PlayerCommand::PlayConfirm { done: done_tx }).await?;
+                                done_rx.await?;
+
                                 let filename = format!("{:x?}.mp3", achievement_id);
                                 let path = self.cache_path.join(&filename);
 

src/subsystems/networker.rs

@@ -110,15 +110,11 @@ impl Networker {
         }
 
         let mut interval = time::interval(Duration::from_secs(3));
+        let mut invalid_credentials = false;
 
         loop {
             tokio::select! {
                 maybe_command = self.rx.recv() => {
-                    let stream = match maybe_stream {
-                        Some(ref mut stream) => stream,
-                        None => continue,
-                    };
-
                     use NetworkerCommand::*;
 
                     match maybe_command {
@@ -127,6 +123,7 @@ impl Networker {
                                 SetConnection { connection_config } => {
                                     maybe_connection_config = Some(connection_config.clone());
                                     maybe_stream = None;
+                                    invalid_credentials = false;
 
                                     let (config_tx, config_rx) = oneshot::channel();
                                     self.config.send(ConfigCommand::SetConnection {
@@ -136,20 +133,32 @@ impl Networker {
                                     config_rx.await?;
                                 },
                                 CheckUid { uid, responder } => {
+                                    let stream = match maybe_stream {
+                                        Some(ref mut stream) => stream,
+                                        None => continue,
+                                    };
+
                                     match self.check_uid(stream, &uid).await {
                                         Ok(achievements) => responder.send(achievements).unwrap(),
                                         Err(_) => {
                                             maybe_stream = None;
                                             self.status_tx.send(NetworkerStatus::Disconnected).await?;
+                                            responder.send(None).unwrap();
                                         },
                                     }
                                 },
                                 GetAudio { id, responder } => {
+                                    let stream = match maybe_stream {
+                                        Some(ref mut stream) => stream,
+                                        None => continue,
+                                    };
+
                                     match self.get_audio(stream, &id).await {
                                         Ok(data) => responder.send(data).unwrap(),
                                         Err(_) => {
                                             maybe_stream = None;
                                             self.status_tx.send(NetworkerStatus::Disconnected).await?;
+                                            responder.send(None).unwrap();
                                         },
                                     }
                                 },
@@ -168,17 +177,25 @@ impl Networker {
                         },
                         None => {
                             if let Some(connection_config) = maybe_connection_config.as_ref() {
+                                if invalid_credentials {
+                                    continue;
+                                }
+
+                                self.status_tx.send(NetworkerStatus::Disconnected).await?;
+
                                 if let Ok(maybe_connected_stream) = self.connect(
                                     &connector,
                                     connection_config
                                 ).await {
                                     match maybe_connected_stream {
                                         Some(connected_stream) => {
                                             maybe_stream = Some(connected_stream);
-                                            self.status_tx.send(NetworkerStatus::Connected).await?
+                                            self.status_tx.send(NetworkerStatus::Connected).await?;
+                                            invalid_credentials = false;
                                         },
                                         None => {
-                                            self.status_tx.send(NetworkerStatus::InvalidCredentials).await?
+                                            self.status_tx.send(NetworkerStatus::InvalidCredentials).await?;
+                                            invalid_credentials = true;
                                         },
                                     }
                                 }
@@ -202,7 +219,7 @@ impl Networker {
 
         let result = stream.read_u8().await?;
 
-        if result == 0x00 {
+        if result == 0x00 || result == 0x02 {
             return Ok(None);
         }
 
@@ -286,7 +303,7 @@ impl Networker {
         stream.write_u8(auth_string.len() as u8).await?;
         stream.write_all(auth_string.as_bytes()).await?;
 
-        Ok(stream.read_u8().await? == 0x00)
+        Ok(stream.read_u8().await? == 0x01)
     }
 }