v0.8.0: refactor + new features

- Bug fix: SerialState op_lock concurrency race condition
- Bug fix: CSS dead code and undefined variable
- Refactor: split serial_cmd.rs into encoding_utils + multi_string + serial_cmd
- Refactor: split handle_mcp into dedicated handler functions
- Refactor: ChecksumAlgo enum replaces string-based algorithm selection
- Refactor: unified hex parsing, extracted SerialState::to_port_info()
- Rename: McpBuffer -> ReceiveBuffer, window_helper url -> path
- Feature: multi-string items support per-entry name/note
- Feature: LSB/MSB byte-order switch for CRC16/CRC32 checksum

Author: Martlet-Tech

package.json

@@ -1,7 +1,7 @@
 {
   "name": "zcom",
   "private": true,
-  "version": "0.7.1",
+  "version": "0.8.0",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "zcom"
-version = "0.7.1"
+version = "0.8.0"
 description = "High performance serial debug assistant"
 authors = ["zt"]
 edition = "2021"

src-tauri/Cargo.toml

@@ -1,5 +1,27 @@
 use crc::{Crc, Algorithm};
 use serde::Serialize;
+use std::str::FromStr;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ChecksumAlgo {
+    Crc16,
+    Crc32,
+    Add8,
+    Xor8,
+}
+
+impl FromStr for ChecksumAlgo {
+    type Err = String;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "crc16" => Ok(Self::Crc16),
+            "crc32" => Ok(Self::Crc32),
+            "add8" => Ok(Self::Add8),
+            "xor8" => Ok(Self::Xor8),
+            _ => Err(format!("Unknown checksum algorithm: {}", s)),
+        }
+    }
+}
 
 #[derive(Debug, Serialize)]
 pub struct ChecksumResult {
@@ -29,46 +51,48 @@ const CRC32: Crc<u32> = Crc::<u32>::new(&Algorithm {
     residue: 0xDEBB20E3,
 });
 
-pub fn calc_checksum(data: &[u8], algo: &str) -> ChecksumResult {
+pub fn calc_checksum(data: &[u8], algo: ChecksumAlgo) -> ChecksumResult {
     match algo {
-        "crc16" => {
+        ChecksumAlgo::Crc16 => {
             let digest = CRC16_MODBUS.checksum(data);
             ChecksumResult {
                 value: digest.to_string(),
                 hex: format!("{:04X}", digest),
             }
         }
-        "crc32" => {
+        ChecksumAlgo::Crc32 => {
             let digest = CRC32.checksum(data);
             ChecksumResult {
                 value: digest.to_string(),
                 hex: format!("{:08X}", digest),
             }
         }
-        "add8" => {
+        ChecksumAlgo::Add8 => {
             let sum: u8 = data.iter().fold(0u8, |a, b| a.wrapping_add(*b));
             ChecksumResult {
                 value: sum.to_string(),
                 hex: format!("{:02X}", sum),
             }
         }
-        "xor8" => {
+        ChecksumAlgo::Xor8 => {
             let xor = data.iter().fold(0u8, |a, b| a ^ b);
             ChecksumResult {
                 value: xor.to_string(),
                 hex: format!("{:02X}", xor),
             }
         }
-        _ => ChecksumResult {
-            value: "0".into(),
-            hex: "00".into(),
-        },
     }
 }
 
-pub fn apply_checksum(data: &[u8], algo: &str, position: i32) -> Vec<u8> {
+pub fn apply_checksum(data: &[u8], algo: ChecksumAlgo, position: i32, lsb: bool) -> Vec<u8> {
     let result = calc_checksum(data, algo);
-    let check_bytes = hex_to_bytes(&result.hex);
+    let mut check_bytes: Vec<u8> = (0..result.hex.len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(&result.hex[i..i + 2], 16).unwrap())
+        .collect();
+    if lsb {
+        check_bytes.reverse();
+    }
     let pos = if position >= 0 {
         position as usize
     } else {
@@ -82,12 +106,3 @@ pub fn apply_checksum(data: &[u8], algo: &str, position: i32) -> Vec<u8> {
     out.extend_from_slice(&data[pos..]);
     out
 }
-
-fn hex_to_bytes(s: &str) -> Vec<u8> {
-    let s = s.trim();
-    if s.len() < 2 { return vec![]; }
-    let bytes: Vec<u8> = (0..s.len()).step_by(2)
-        .filter_map(|i| u8::from_str_radix(&s[i..i+2], 16).ok())
-        .collect();
-    bytes
-}

src-tauri/src/checksum.rs

@@ -0,0 +1,95 @@
+fn decode_oem_text(bytes: &[u8]) -> String {
+    #[cfg(windows)]
+    {
+        extern "system" {
+            fn GetOEMCP() -> u32;
+        }
+        let cp = unsafe { GetOEMCP() };
+        match cp {
+            936 => encoding_rs::GBK.decode(bytes).0.into_owned(),
+            932 => encoding_rs::SHIFT_JIS.decode(bytes).0.into_owned(),
+            949 => encoding_rs::EUC_KR.decode(bytes).0.into_owned(),
+            950 => encoding_rs::BIG5.decode(bytes).0.into_owned(),
+            1250 | 1252 | 1254 | 1257 => encoding_rs::WINDOWS_1252.decode(bytes).0.into_owned(),
+            1251 => encoding_rs::WINDOWS_1251.decode(bytes).0.into_owned(),
+            1253 => encoding_rs::ISO_8859_7.decode(bytes).0.into_owned(),
+            1255 => encoding_rs::WINDOWS_1255.decode(bytes).0.into_owned(),
+            1256 => encoding_rs::WINDOWS_1256.decode(bytes).0.into_owned(),
+            1258 => encoding_rs::WINDOWS_1258.decode(bytes).0.into_owned(),
+            _ => String::from_utf8_lossy(bytes).into_owned(),
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        String::from_utf8_lossy(bytes).into_owned()
+    }
+}
+
+pub(crate) fn encode_text(text: &str, encoding: &str) -> Vec<u8> {
+    match encoding {
+        "gbk" => {
+            let (cow, _, _) = encoding_rs::GBK.encode(text);
+            cow.into_owned()
+        }
+        _ => text.as_bytes().to_vec(),
+    }
+}
+
+pub(crate) fn parse_hex_string(s: &str) -> Result<Vec<u8>, String> {
+    let s = s.trim();
+    if s.is_empty() {
+        return Ok(vec![]);
+    }
+    let hex_chars: String = s.chars().filter(|c| !c.is_whitespace()).collect();
+    if hex_chars.len() % 2 != 0 {
+        return Err("Hex string must have even number of characters".into());
+    }
+    let bytes: Result<Vec<u8>, _> = (0..hex_chars.len())
+        .step_by(2)
+        .map(|i| u8::from_str_radix(&hex_chars[i..i + 2], 16))
+        .collect();
+    bytes.map_err(|e| format!("Invalid hex: {}", e))
+}
+
+pub(crate) fn get_port_description(name: &str) -> Option<String> {
+    let mut cmd = std::process::Command::new("wmic");
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        cmd.creation_flags(0x08000000);
+    }
+    let output = cmd
+        .args([
+            "path", "Win32_SerialPort",
+            "where", &format!("DeviceID='{}'", name),
+            "get", "Name", "/format:value",
+        ])
+        .output()
+        .ok()?;
+    let text = decode_oem_text(&output.stdout);
+    for line in text.lines() {
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        if let Some(value) = line.strip_prefix("Name=") {
+            let value: String = value.chars().filter(|c| !c.is_control()).collect();
+            let value = value.trim().trim_matches('"');
+            if !value.is_empty() {
+                return Some(value.to_string());
+            }
+        }
+    }
+    None
+}
+
+#[tauri::command]
+pub async fn decode_bytes(bytes: Vec<u8>, encoding: String) -> Result<String, String> {
+    match encoding.as_str() {
+        "gbk" => {
+            let (cow, _, _) = encoding_rs::GBK.decode(&bytes);
+            Ok(cow.into_owned())
+        }
+        _ => Ok(String::from_utf8_lossy(&bytes).into_owned()),
+    }
+}

src-tauri/src/encoding_utils.rs

@@ -1,11 +1,14 @@
 mod serial_cmd;
 mod checksum;
 mod state;
-mod mcp_buffer;
+mod receive_buffer;
 mod mcp_server;
+mod window_helper;
+mod encoding_utils;
+mod multi_string;
 
 use state::SerialState;
-use mcp_buffer::McpBuffer;
+use receive_buffer::ReceiveBuffer;
 use mcp_server::McpServerHandle;
 use tauri::Manager;
 use tauri::menu::{MenuBuilder, MenuItemBuilder};
@@ -26,7 +29,7 @@ pub fn run() {
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_window_state::Builder::default().build())
         .manage(SerialState::new())
-        .manage(McpBuffer::new())
+        .manage(ReceiveBuffer::new())
         .manage(McpServerHandle::new())
         .invoke_handler(tauri::generate_handler![
             serial_cmd::list_ports,
@@ -37,16 +40,16 @@ pub fn run() {
             serial_cmd::send_raw_bytes,
             serial_cmd::get_port_info,
             serial_cmd::calculate_checksum,
-            serial_cmd::open_multi_string_window,
-            serial_cmd::load_multi_strings,
-            serial_cmd::save_multi_strings,
-            serial_cmd::decode_bytes,
             serial_cmd::set_baud_rate,
+            multi_string::open_multi_string_window,
+            multi_string::load_multi_strings,
+            multi_string::save_multi_strings,
+            encoding_utils::decode_bytes,
             mcp_server::mcp_start,
             mcp_server::mcp_stop,
             mcp_server::mcp_get_status,
-            mcp_buffer::mcp_push_lines,
-            mcp_buffer::mcp_clear_buffer,
+            receive_buffer::mcp_push_lines,
+            receive_buffer::mcp_clear_buffer,
             open_devtools,
         ])
         .setup(|app| {