逻辑修改, 日志服务添加

src/services/excel_service.rs

@@ -52,6 +52,11 @@ impl ExcelService {
         current_line
     }
 
+    pub fn set_current_line(&mut self, line: usize)->Result<(), String>{
+        self.current_line = line;
+        Ok(())
+    }
+
     pub fn get_next_work_model(&mut self) -> Result<WorkModel, String> {
         let mut work_model = WorkModel::default();
         if let Some(imei) = self.sheet.get((self.current_line, 0)) {

src/services/log_service.rs

@@ -0,0 +1,51 @@
+use log::{Record, Level, Metadata, SetLoggerError};
+use std::sync::{Arc, Mutex};
+use chrono::Local;
+use lazy_static::lazy_static;
+
+type LogCallback = Box<dyn Fn(&str) + Send + Sync>;
+
+pub struct FltkLogger {
+    callback: Arc<Mutex<Option<LogCallback>>>,
+}
+
+impl FltkLogger {
+    pub fn new() -> Self {
+        FltkLogger {
+            callback: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    pub fn set_callback<F>(&self, callback: F)
+    where
+        F: Fn(&str) + 'static + Send + Sync,
+    {
+        let mut cb = self.callback.lock().unwrap();
+        *cb = Some(Box::new(callback));
+    }
+}
+
+impl log::Log for FltkLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= Level::Info
+    }
+
+    fn log(&self, record: &Record) {
+        if self.enabled(record.metadata()) {
+            if let Some(callback) = self.callback.lock().unwrap().as_ref() {
+                callback(&format!("{}: {} - {}\r\n",Local::now().format("%Y-%m-%d %H:%M:%S"), record.level(), record.args()));
+            }
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+lazy_static! {
+   pub static ref LOGGER: FltkLogger = FltkLogger::new();
+}
+
+pub fn init_logger() -> Result<(), SetLoggerError> {
+    log::set_logger(&*LOGGER)
+        .map(|()| log::set_max_level(log::LevelFilter::Info))
+}

src/services/serial_service.rs

@@ -10,7 +10,7 @@ pub struct SerialService {
 
 impl SerialService {
     pub fn new(port_name: &str) -> Result<Box<Self>> {
-        let port = serialport::new(port_name, 115_200)
+        let port = new(port_name, 115_200)
             .timeout(Duration::from_millis(200))
             .open()?;
         Ok(Box::new(SerialService { port }))
@@ -54,6 +54,10 @@ impl SerialService {
             Err(err) => Err(err)
         };
     }
+
+    pub fn close_serial(&mut self)->Result<()>{
+        todo!()
+    }
 }
 
 #[test]

src/services/ui_service.rs

@@ -1,17 +1,18 @@
 use std::cell::RefCell;
 use std::rc::Rc;
-use fltk::prelude::{InputExt, WidgetExt};
+use std::sync::{Arc, Mutex};
-use crate::models::work_model::WorkModel;
+use fltk::prelude::{DisplayExt, InputExt, WidgetBase, WidgetExt};
-use crate::services::excel_service::ExcelService;
+use fltk::text::TextBuffer;
-use crate::services::serial_service::SerialService;
 use crate::services::work_service::WorkService;
 use crate::ui::main_ui;
 use crate::ui::main_ui::*;
+use crate::services::log_service::LOGGER;
+
 
 pub(crate) struct UiService {
     ui: Rc<RefCell<UserInterface>>,
     work_service: Rc<RefCell<WorkService>>,
-    current_com: String
+    current_com: String,
 }
 
 impl UiService {
@@ -23,9 +24,35 @@ impl UiService {
     pub(crate) fn init_components(&mut self) {
         self.init_excel();
         self.init_start_btn();
+        self.init_set_line_btn();
+        self.init_log();
     }
 
-    pub fn init_start_btn(&mut self) {
+    fn init_set_line_btn(&mut self) {
+        let ui_rc = Rc::clone(&self.ui);
+        let ui_rc_clone = Rc::clone(&ui_rc);
+        let work_service_rc = Rc::clone(&self.work_service);
+        ui_rc.borrow_mut().set_lines_btn.set_callback(move |_| {
+            let mut work_service = work_service_rc.borrow_mut();
+            let mut ui_clone = ui_rc_clone.clone();
+            let mut set_dialog = UserInterface1::make_set_line_window();
+            let work_service_rc_clone = work_service_rc.clone();
+            set_dialog.ok_btn.set_callback(move |_| {
+                if let Ok(line) = set_dialog.line_textbox.value().parse::<usize>(){
+                    match work_service_rc_clone.borrow_mut().set_current_line(line) {
+                        Ok(_) => {
+                            ui_clone.borrow_mut().current_line_textbox.set_value(&line.to_string())
+                        }
+                        Err(msg) => fltk::dialog::message_default(&msg)
+                    }
+                }else{
+                    fltk::dialog::message_default(&"Only Support Number")
+                }
+            })
+        });
+    }
+
+    fn init_start_btn(&mut self) {
         let ui_rc = Rc::clone(&self.ui);
         let ui_rc_clone = Rc::clone(&ui_rc);
         let work_service_rc = Rc::clone(&self.work_service);
@@ -47,15 +74,30 @@ impl UiService {
             if let Some(mut model) = work_service.get_next_work_model() {
                 ui.current_write_model.set_value(&format!("{}: {}_{}", &model.line_number, &model.imei, &model.sn));
                 match work_service.write_and_check(model) {
-                    Ok(_) => {}
+                    Ok(_) => {
+                        let current_line = &work_service.get_current_line().to_string();
+                        ui.current_line_textbox.set_value(current_line);
+                    }
                     Err(msg) => { fltk::dialog::message_default(&msg) }
                 }
             }
         });
     }
 
+    fn init_log(&mut self){
+        let ui_rc = Rc::clone(&self.ui);
+        let text_buffer = TextBuffer::default();
+        ui_rc.borrow_mut().log_content.set_buffer(text_buffer.clone());
+        let text_buffer_arc = Arc::new(Mutex::new(text_buffer));
+        LOGGER.set_callback(move |msg| {
+            let mut text_buffer = text_buffer_arc.lock().unwrap();
+            text_buffer.append(&msg);
+        });
+
+    }
+
     fn init_excel(&mut self) {
-        let ui_rc = Rc::new(&self.ui);
+        let ui_rc = Rc::clone(&self.ui);
         let ui_clone = Rc::clone(&self.ui);
         let work_service_clone = Rc::clone(&self.work_service);
         ui_rc.borrow_mut().select_file_btn.set_callback(move |_| {

src/services/work_service.rs

@@ -1,6 +1,8 @@
 use std::ptr::null;
+use log::Log;
 use crate::models::work_model::WorkModel;
 use crate::services::{serial_service::SerialService, sqlite_service::SqliteService, excel_service::ExcelService};
+use crate::services::log_service::{FltkLogger, init_logger, LOGGER};
 
 pub struct WorkService {
     pub(crate) serial_service: Option<SerialService>,
@@ -10,6 +12,7 @@ pub struct WorkService {
 
 impl WorkService {
     pub fn new() -> Self {
+        init_logger().unwrap();
         WorkService {
             serial_service: Option::None,
             sqlite_service: SqliteService::new("data.db".to_string()).unwrap(),
@@ -31,7 +34,9 @@ impl WorkService {
     }
 
     pub fn write_and_check(&mut self, model: WorkModel) -> Result<bool, String> {
-        fltk::dialog::message_default(&format!("{}:{}:{}", model.imei, model.sn, model.line_number));
+        let msg = &format!("{}:{}:{}", model.imei, model.sn, model.line_number);
+        log::info!("Start Write:{}", msg);
+        self.serial_service = None;
         Ok(true)
     }
 
@@ -42,6 +47,15 @@ impl WorkService {
         return 0;
     }
 
+    pub fn set_current_line(&mut self, line: usize)->Result<(), String>{
+        if let Some(service) = &mut self.excel_service{
+            return service.set_current_line(line);
+        }else{
+            Err("Cant Set Line".to_string())
+        }
+
+    }
+
     pub fn get_next_work_model(&mut self) -> Option<WorkModel> {
         if let Some(service) = &mut self.excel_service {
             if let Ok(model) = service.get_next_work_model() {