下载逻辑完成, ui通知逻辑完成,

src/download_wrapper.rs

@@ -0,0 +1,249 @@
+use crate::download_wrapper::DownloadError::JlinkNotFindError;
+use anyhow::Error;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+pub struct DownloadWrapper {
+    commander_path: PathBuf,
+    bin_path: PathBuf,
+    bootloader_name: String,
+    app_name: String,
+    rail_name: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DownloadType {
+    Bootloader,
+    App,
+    Rail,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DownloadError {
+    JlinkNotFindError,
+    DeviceNotFindError,
+    EraseError,
+    DownloadBootloaderError,
+    DownloadAppError,
+    DownloadRailError,
+}
+
+impl Default for DownloadWrapper {
+    fn default() -> Self {
+        Self {
+            commander_path: PathBuf::from(std::env::current_dir().unwrap())
+                .join("commander/Simplicity Commander/commander.exe"),
+            bin_path: PathBuf::from(std::env::current_dir().unwrap()).join("bin/"),
+            bootloader_name: String::from("RAWM00-2-0-0_silicon-wisun_bootloader_D20241008.s37"),
+            app_name: String::from("RAWM00-2-0-0_silicon-wisun_APP-V1_D20240927.s37"),
+            rail_name: String::from("rail_soc_railtest_sisdk.s37"),
+        }
+    }
+}
+
+impl DownloadWrapper {
+    pub(crate) fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn check_jlink(&self) -> Result<Vec<String>, DownloadError> {
+        let commander_path_str = self.commander_path.to_str().unwrap();
+        let output = Command::new(commander_path_str)
+            .arg("adapter")
+            .arg("list")
+            .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 device_index_str: Vec<String> = result
+                .iter()
+                .filter(|&&str| str.starts_with("deviceCount"))
+                .map(|&str| str.to_string())
+                .collect();
+            if device_index_str.is_empty()
+                || device_index_str[0].split("=").collect::<Vec<&str>>()[1] == "0"
+            {
+                Err(JlinkNotFindError)
+            } else {
+                let device_ids = result
+                    .iter()
+                    .filter(|&&str| str.trim().starts_with("serialNumber"))
+                    .map(|&str| {
+                        let temp = str.to_string();
+                        return temp.split("=").collect::<Vec<&str>>()[1].to_string();
+                    })
+                    .collect::<Vec<String>>();
+                Ok(device_ids)
+            }
+        } else {
+            Err(JlinkNotFindError)
+        }
+    }
+
+    pub fn check_device(&self) -> Result<(), DownloadError> {
+        let commander_path_str = self.commander_path.to_str().unwrap();
+        let output = Command::new(commander_path_str)
+            .arg("device")
+            .arg("info")
+            .arg("--device")
+            .arg("Cortex-M4")
+            .output()
+            .expect("Failed to execute command");
+        let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+        let result = stdout.split("\r\n").collect::<Vec<&str>>();
+        let error_log = result
+            .iter()
+            .filter(|&&str| str.trim().starts_with("ERROR"))
+            .collect::<Vec<&&str>>();
+        if error_log.is_empty() {
+            Ok(())
+        } else {
+            Err(DownloadError::DeviceNotFindError)
+        }
+    }
+
+    pub fn erase(&self) -> Result<(), DownloadError> {
+        let commander_path_str = self.commander_path.to_str().unwrap();
+        let output = Command::new(commander_path_str)
+            .arg("device")
+            .arg("masserase")
+            .arg("--device")
+            .arg("Cortex-M4")
+            .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>>();
+        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()
+        {
+            Err(DownloadError::EraseError)
+        } else {
+            Ok(())
+        }
+    }
+
+    pub fn download(&self, download_type: DownloadType) -> Result<(), DownloadError> {
+        let mut binding: PathBuf;
+        match download_type {
+            DownloadType::Bootloader=> {
+                binding = self.bin_path.join(&self.bootloader_name);
+            }
+            DownloadType::App=>{
+                binding = self.bin_path.join(&self.app_name);
+            }
+            DownloadType::Rail=>{
+                binding = self.bin_path.join(&self.rail_name);
+            }
+        }
+        let bin_path = binding.to_str().unwrap();
+        println!("{:?}", bin_path);
+        let commander_path_str = self.commander_path.to_str().unwrap();
+        let output = Command::new(commander_path_str)
+            .arg("flash")
+            .arg(bin_path)
+            .arg("--device")
+            .arg("Cortex-M4")
+            .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>>();
+        println!("{:?}", result);
+        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()
+        {
+            Err(DownloadError::DownloadBootloaderError)
+        } else {
+            Ok(())
+        }
+    }
+
+    pub fn download_app(&self) -> Result<bool, DownloadError> {
+        todo!()
+    }
+
+    pub fn download_rail(&self) -> Result<bool, DownloadError> {
+        todo!()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::download_wrapper::DownloadWrapper;
+    use crate::download_wrapper::DownloadType;
+
+    #[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_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_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_rail(){
+        let dw = DownloadWrapper::new();
+        let result = dw.download(DownloadType::Rail);
+        assert_eq!(result.is_ok(), true);
+    }
+}