Bump up dependecies and added non blocking barcode reader

.gitignore

@@ -1,3 +1,5 @@
 /target
 /src-tauri
 /dist
+/cache
+/.zed

Cargo.toml

@@ -9,4 +9,10 @@ serial = "0.4.0"
 reqwest = { version = "0.12.23", features = ["json"] }
 serde_json = "1.0.145"
 tokio = { version = "1.47.1", features = ["full"] }
-serde = { version = "1.0.227", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
+eframe = "0.32.3"
+egui_extras = { version = "0.32.3", features = ["all_loaders"] }
+log = "0.4.28"
+env_logger = "0.11.8"
+image = "0.25.8"
+egui_commonmark = "0.21.1"

src/image.rs

@@ -0,0 +1,14 @@
+use image::ImageFormat;
+use image::ImageReader;
+use log::debug;
+
+pub fn convert_to_webp(img_name: String) {
+  debug!("The img_name is: {img_name}");
+  let img = ImageReader::open(format!("cache/{img_name}.jpeg"))
+    .unwrap()
+    .decode()
+    .unwrap();
+  img
+    .save_with_format(format!("src/cache/img_name.webp"), ImageFormat::WebP)
+    .unwrap();
+}

src/main.rs

@@ -1,12 +1,20 @@
+use eframe::egui;
+use log::*;
 use reqwest::Client;
 use serde::Deserialize;
 use serial::prelude::*;
-use std::env;
+use std::fs::File;
-use std::io;
+use std::io::Read;
+use std::io::{Cursor, copy};
 use std::str::from_utf8;
+use std::sync::mpsc::{self, Receiver, Sender};
 use std::time::Duration;
+use std::{env, fs};
+use tokio;
+use tokio::runtime::Runtime;
+pub mod image;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 struct BookData {
     title: String,
     authors: Vec<String>,
@@ -42,52 +50,61 @@ struct ImageLinks {
     smallThumbnail: Option<String>,
 }
 
-#[tokio::main]
+fn main() -> eframe::Result<()> {
-async fn main() {
+    env_logger::init();
+    let options = eframe::NativeOptions {
+        viewport: egui::ViewportBuilder::default().with_inner_size([320.0, 880.0]),
+        ..Default::default()
+    };
+    eframe::run_native(
+        "Barcode Scanner",
+        options,
+        Box::new(|cc| {
+            egui_extras::install_image_loaders(&cc.egui_ctx);
+            Ok(Box::<BarcodeScanner>::default())
+        }),
+    )
+}
+
+fn get_ean13_data() -> String {
     let args: Vec<String> = env::args().collect();
     let path_to_scanner = &args[1];
     let mut port = serial::open(path_to_scanner).unwrap();
-  interact(&mut port).await.unwrap();
+    interact(&mut port).to_string()
 }
-
+fn interact<T: SerialPort>(port: &mut T) -> String {
-async fn interact<T: SerialPort>(port: &mut T) -> io::Result<()> {
     port.reconfigure(&|settings| {
-    settings.set_baud_rate(serial::Baud9600)?;
+        settings.set_baud_rate(serial::Baud9600).unwrap();
         settings.set_char_size(serial::Bits8);
         settings.set_parity(serial::ParityNone);
         settings.set_stop_bits(serial::Stop1);
         settings.set_flow_control(serial::FlowNone);
         Ok(())
-  })?;
+    })
-
+    .unwrap();
-  port.set_timeout(Duration::from_millis(1000000000))?;
+    port.set_timeout(Duration::from_millis(1000000000)).unwrap();
-  loop {
     let buf: &mut [u8; 14] = &mut [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
     port.read_exact(buf).unwrap();
     let barcode_id = from_utf8(buf).unwrap();
-    println!("{}", &barcode_id);
+    debug!("{}", &barcode_id);
-    if barcode_id.starts_with("978") {
+    barcode_id.to_string()
-      get_book_data(barcode_id.to_string()).await;
-    }
-  }
 }
 
-async fn get_book_data(isbn: String) {
+fn get_book_data(isbn: String) -> BookData {
+    let runtime = tokio::runtime::Runtime::new().unwrap();
     let lookup_url = format!(
         "https://www.googleapis.com/books/v1/volumes?q=isbn:{}",
         isbn
     );
     let cleint = Client::new();
-  let book_data = cleint
+    let book_data = runtime
-    .get(lookup_url)
+        .block_on(cleint.get(lookup_url).send())
-    .send()
-    .await
         .unwrap()
-    .json::<BookRoot>()
+        .json::<BookRoot>();
-    .await
+    let book_data = runtime.block_on(book_data).unwrap();
-    .unwrap();
     let book_metadata: Vec<BookData> = book_data.items.into_iter().map(BookData::from).collect();
     println!("{}", &book_metadata[0]);
+    return book_metadata[0].clone();
 }
 
 impl From<Item> for BookData {
@@ -106,6 +123,16 @@ impl From<Item> for BookData {
         }
     }
 }
+impl BookData {
+    fn new() -> BookData {
+        BookData {
+            title: "Unknown".to_string(),
+            authors: vec!["Unknown".to_string()],
+            thumbnail: "https://www.rust-lang.org/logos/rust-logo-512x512.png".to_string(),
+            description: "No description available".to_string(),
+        }
+    }
+}
 
 impl std::fmt::Display for BookData {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -127,3 +154,92 @@ impl std::fmt::Display for BookData {
         )
     }
 }
+fn get_thumbnail(url: String, isbn: String) {
+    let runtime = Runtime::new().unwrap();
+    let url = if url.is_empty() {
+        "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Ftse1.mm.bing.net%2Fth%2Fid%2FOIP.pluN_8e5GuVyqRmW8xWs1gHaET%3Fcb%3D12%26pid%3DApi&f=1&ipt=bf48e49e5df83d58cdee7752f4e2095f5b0ad37e5122d447ff774631db3de4a9&ipo=images".to_string()
+    } else {
+        url
+    };
+    debug!("The isbn of the img is: {isbn}");
+    let isbn = isbn.trim().to_string();
+    fs::create_dir_all("cache").unwrap();
+    let mut dest = File::create(format!("cache/{isbn}.jpeg")).unwrap();
+    let image = runtime.block_on(reqwest::get(url)).unwrap();
+    let bytes = runtime.block_on(image.bytes()).unwrap();
+    let mut output = Cursor::new(bytes);
+    copy(&mut output, &mut dest).unwrap();
+    image::convert_to_webp(isbn);
+}
+
+struct BarcodeScanner {
+    barcode_rx: Receiver<String>,
+    last_barcode: Option<String>,
+}
+
+impl eframe::App for BarcodeScanner {
+    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) -> () {
+        egui_extras::install_image_loaders(ctx);
+        if let Ok(code) = self.barcode_rx.try_recv() {
+            self.last_barcode = Some(code);
+        }
+        egui::CentralPanel::default().show(ctx, |ui| {
+            ui.heading("Barcode Scanner");
+            ui.group(|ui| {
+                //loop {
+                let barcode = get_ean13_data();
+                ui.label(format!("EAN13: {}", barcode));
+                let book_metadata = if barcode.starts_with("978") {
+                    get_book_data(barcode.clone())
+                } else {
+                    BookData::new()
+                };
+                get_thumbnail(book_metadata.thumbnail.clone(), barcode);
+                ui.label(format!("Title: {}", book_metadata.title));
+                ui.label(format!("Description: {}", book_metadata.description));
+                ui.label(format!("Authors: {:?}", book_metadata.authors));
+                ui.image(egui::include_image!("cache/img_name.webp"))
+                    .on_hover_text_at_pointer("WebP");
+                //}
+            })
+        });
+        ctx.request_repaint_after(Duration::from_millis(100));
+    }
+}
+impl Default for BarcodeScanner {
+    fn default() -> Self {
+        let (tx, rx) = mpsc::channel();
+
+        std::thread::spawn(move || {
+            let mut port = serial::open("/dev/ttyACM0").unwrap();
+            port.reconfigure(&|settings| {
+                settings.set_baud_rate(serial::Baud9600)?;
+                settings.set_char_size(serial::Bits8);
+                settings.set_parity(serial::ParityNone);
+                settings.set_stop_bits(serial::Stop1);
+                settings.set_flow_control(serial::FlowNone);
+                Ok(())
+            })
+            .unwrap();
+
+            port.set_timeout(Duration::from_millis(1000)).unwrap();
+
+            loop {
+                let mut buf = [0u8; 14];
+                if let Ok(_) = port.read_exact(&mut buf) {
+                    if let Ok(code) = std::str::from_utf8(&buf) {
+                        let barcode = code.trim().to_string();
+                        if !barcode.is_empty() {
+                            let _ = tx.send(barcode);
+                        }
+                    }
+                }
+            }
+        });
+
+        Self {
+            barcode_rx: rx,
+            last_barcode: None,
+        }
+    }
+}