bootloader与app下载合并, 保存原始日志与ui日志

src/download_wrapper.rs

@@ -1,7 +1,9 @@
 use crate::download_wrapper::DownloadError::JlinkNotFindError;
 use anyhow::Error;
+use std::fs;
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::io::Write;
 
 pub struct DownloadWrapper {
     commander_path: PathBuf,
@@ -36,6 +38,7 @@ pub enum DownloadError {
     DownloadBootloaderError,
     DownloadAppError,
     DownloadRailError,
+    NoLabel,
 }
 
 impl Default for DownloadWrapper {
@@ -64,10 +67,8 @@ impl DownloadWrapper {
             .output()
             .expect("Failed to execute command");
         if output.status.success() {
-            let result_str  = String::from_utf8_lossy(&output.stdout).to_string();
-            let result = result_str
-                .split("\r\n")
-                .collect::<Vec<&str>>();
+            let result_str = String::from_utf8_lossy(&output.stdout).to_string();
+            let result = result_str.split("\r\n").collect::<Vec<&str>>();
             let device_index_str: Vec<String> = result
                 .iter()
                 .filter(|&&str| str.starts_with("deviceCount"))
@@ -115,7 +116,7 @@ impl DownloadWrapper {
         }
     }
 
-    pub fn erase(&self) -> Result<(), DownloadError> {
+    pub fn erase(&self, label: Option<String>) -> Result<String, DownloadError> {
         let commander_path_str = self.commander_path.to_str().unwrap();
         let output = Command::new(commander_path_str)
             .arg("device")
@@ -125,36 +126,42 @@ impl DownloadWrapper {
             .output()
             .expect("Failed to execute command");
         let result_str = String::from_utf8_lossy(&output.stdout).to_string();
-        let result = result_str
-            .split("\r\n")
-            .collect::<Vec<&str>>();
+        let result = result_str.split("\r\n").collect::<Vec<&str>>();
         if !result
             .iter()
             .filter(|&&str| str.trim().starts_with("ERROR"))
             .collect::<Vec<&&str>>()
             .is_empty()
             || result
-                .iter()
-                .filter(|&&str| str.trim().contains("successfully"))
-                .collect::<Vec<&&str>>()
-                .is_empty()
+            .iter()
+            .filter(|&&str| str.trim().contains("successfully"))
+            .collect::<Vec<&&str>>()
+            .is_empty()
         {
             Err(DownloadError::EraseError)
         } else {
-            Ok(())
+            let Some(label) = label else { return Err(DownloadError::NoLabel) };
+            match self.save_log(label, result_str.clone()) {
+                Ok(res) => {
+                    Ok(result_str)
+                }
+                Err(e) => {
+                    Err(DownloadError::DownloadBootloaderError)
+                }
+            }
         }
     }
 
-    pub fn download(&self, download_type: DownloadType) -> Result<(), DownloadError> {
+    pub fn download(&self, download_type: DownloadType, label: Option<String>) -> Result<String, DownloadError> {
         let mut binding: PathBuf;
         match download_type {
-            DownloadType::Bootloader=> {
+            DownloadType::Bootloader => {
                 binding = self.bin_path.join(&self.bootloader_name);
             }
-            DownloadType::App=>{
+            DownloadType::App => {
                 binding = self.bin_path.join(&self.app_name);
             }
-            DownloadType::Rail=>{
+            DownloadType::Rail => {
                 binding = self.bin_path.join(&self.rail_name);
             }
         }
@@ -169,9 +176,7 @@ impl DownloadWrapper {
             .output()
             .expect("Failed to execute command");
         let result_str = String::from_utf8_lossy(&output.stdout).to_string();
-        let result = result_str
-            .split("\r\n")
-            .collect::<Vec<&str>>();
+        let result = result_str.split("\r\n").collect::<Vec<&str>>();
         println!("{:?}", result);
         if !result
             .iter()
@@ -186,74 +191,87 @@ impl DownloadWrapper {
         {
             Err(DownloadError::DownloadBootloaderError)
         } else {
-            Ok(())
+            let Some(label) = label else { return Err(DownloadError::NoLabel) };
+            match self.save_log(label, result_str.clone()) {
+                Ok(res) => {
+                    Ok(result_str)
+                }
+                Err(e) => {
+                    Err(DownloadError::DownloadBootloaderError)
+                }
+            }
         }
     }
 
-    pub fn download_app(&self) -> Result<bool, DownloadError> {
-        todo!()
-    }
-
-    pub fn download_rail(&self) -> Result<bool, DownloadError> {
-        todo!()
+    fn save_log(& self, label: String, log: String) -> Result<bool, DownloadError> {
+        if !fs::exists("./log") {
+            fs::create_dir("./log").expect("Cant Create Log Folder");
+        }
+        let mut file = fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(format!("./log/{label}.txt"))
+            .expect("file not found");
+        writeln!(file, "{}",log).expect("write failed");
+        Ok(true)
     }
 }
 
 #[cfg(test)]
-mod test {
-    use crate::download_wrapper::DownloadWrapper;
-    use crate::download_wrapper::DownloadType;
+        mod test {
+            use crate::download_wrapper::DownloadType;
+            use crate::download_wrapper::DownloadWrapper;
 
-    #[test]
-    fn test_download_wrapper() {
-        let dw = DownloadWrapper::new();
-        println!("{:?}", dw.commander_path);
-        println!("{:?}", dw.bin_path);
-        println!("{:?}", dw.bootloader_name);
-        println!("{:?}", dw.app_name);
-        println!("{:?}", dw.rail_name);
-    }
+            #[test]
+            fn test_download_wrapper() {
+                let dw = DownloadWrapper::new();
+                println!("{:?}", dw.commander_path);
+                println!("{:?}", dw.bin_path);
+                println!("{:?}", dw.bootloader_name);
+                println!("{:?}", dw.app_name);
+                println!("{:?}", dw.rail_name);
+            }
 
-    #[test]
-    fn test_check_jlink() {
-        let dw = DownloadWrapper::new();
-        let result = dw.check_jlink();
-        assert_eq!(result.is_ok(), true);
-        println!("ids:{:?}", result.unwrap());
-    }
+            #[test]
+            fn test_check_jlink() {
+                let dw = DownloadWrapper::new();
+                let result = dw.check_jlink();
+                assert_eq!(result.is_ok(), true);
+                println!("ids:{:?}", result.unwrap());
+            }
 
-    #[test]
-    fn test_check_device() {
-        let dw = DownloadWrapper::new();
-        let result = dw.check_device();
-        assert_eq!(result.is_ok(), true);
-    }
+            #[test]
+            fn test_check_device() {
+                let dw = DownloadWrapper::new();
+                let result = dw.check_device();
+                assert_eq!(result.is_ok(), true);
+            }
 
-    #[test]
-    fn test_erase_device() {
-        let dw = DownloadWrapper::new();
-        let result = dw.erase();
-        assert_eq!(result.is_ok(), true);
-    }
+            #[test]
+            fn test_erase_device() {
+                let dw = DownloadWrapper::new();
+                let result = dw.erase();
+                assert_eq!(result.is_ok(), true);
+            }
 
-    #[test]
-    fn test_download_bootloader(){
-        let dw = DownloadWrapper::new();
-        let result = dw.download(DownloadType::Bootloader);
-        assert_eq!(result.is_ok(), true);
-    }
+            #[test]
+            fn test_download_bootloader() {
+                let dw = DownloadWrapper::new();
+                let result = dw.download(DownloadType::Bootloader);
+                assert_eq!(result.is_ok(), true);
+            }
 
-    #[test]
-    fn test_download_app(){
-        let dw = DownloadWrapper::new();
-        let result = dw.download(DownloadType::App);
-        assert_eq!(result.is_ok(), true);
-    }
+            #[test]
+            fn test_download_app() {
+                let dw = DownloadWrapper::new();
+                let result = dw.download(DownloadType::App);
+                assert_eq!(result.is_ok(), true);
+            }
 
-    #[test]
-    fn test_download_rail(){
-        let dw = DownloadWrapper::new();
-        let result = dw.download(DownloadType::Rail);
-        assert_eq!(result.is_ok(), true);
-    }
-}
+            #[test]
+            fn test_download_rail() {
+                let dw = DownloadWrapper::new();
+                let result = dw.download(DownloadType::Rail);
+                assert_eq!(result.is_ok(), true);
+            }
+        }