Migrate updater LAN and devkit features from old repo

src-tauri/src/devkit/client.rs

@@ -0,0 +1,268 @@
+//! DevKit gRPC Client
+//!
+//! Rust 端作为 gRPC client：
+//! 1. 以 client-streaming 方式推送实时帧（SensorPush.Upload）
+//! 2. 以 unary 方式发送导出文件路径做后处理（ExportProcessor.ProcessFile）
+
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
+use std::sync::Arc;
+
+use tokio::sync::mpsc;
+use tokio::task::JoinHandle;
+use serde::{Deserialize, Serialize};
+
+use super::proto::sensor_push_client::SensorPushClient;
+use super::proto::export_processor_client::ExportProcessorClient;
+use super::proto::{ProcessRequest, SensorFrame};
+
+// ── DevKit 配置 ────────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DevKitConfig {
+    /// 导出过滤抬起：导出 CSV 后自动调用 Python 做梯度过滤
+    pub filter_lift_enabled: bool,
+    /// 以 xlsx 保存：Python 处理后输出 xlsx 并删除源 CSV
+    pub save_as_xlsx: bool,
+}
+
+impl Default for DevKitConfig {
+    fn default() -> Self {
+        Self {
+            filter_lift_enabled: true,
+            save_as_xlsx: false,
+        }
+    }
+}
+
+impl DevKitConfig {
+    fn config_path() -> PathBuf {
+        let base = dirs::config_dir()
+            .or_else(|| dirs::data_dir())
+            .unwrap_or_else(|| PathBuf::from("."));
+        base.join("JE-Skin").join("devkit_config.json")
+    }
+
+    /// 从文件加载配置，失败则返回默认值
+    pub fn load() -> Self {
+        let path = Self::config_path();
+        match std::fs::read_to_string(&path) {
+            Ok(content) => serde_json::from_str(&content).unwrap_or_default(),
+            Err(_) => Self::default(),
+        }
+    }
+
+    /// 保存配置到文件
+    pub fn save(&self) -> Result<(), String> {
+        let path = Self::config_path();
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)
+                .map_err(|e| format!("Failed to create config dir: {e}"))?;
+        }
+        let json = serde_json::to_string_pretty(self)
+            .map_err(|e| format!("Failed to serialize config: {e}"))?;
+        std::fs::write(&path, json)
+            .map_err(|e| format!("Failed to write config: {e}"))?;
+        Ok(())
+    }
+}
+
+// ── 导出处理结果 ───────────────────────────────────────────────────
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExportProcessResult {
+    pub ok: bool,
+    pub output_path: String,
+    pub groups_used: u32,
+    pub mean_value: f64,
+    pub threshold: f64,
+    pub rows_total: u32,
+    pub rows_kept: u32,
+    pub message: String,
+}
+
+// ── Tauri 状态 ─────────────────────────────────────────────────────
+
+/// DevKit 全局状态，由 Tauri manage
+#[derive(Clone)]
+pub struct DevKitState {
+    pub running: Arc<AtomicBool>,
+    pub port: Arc<std::sync::Mutex<u16>>,
+    pub frame_count: Arc<AtomicU32>,
+    pub config: Arc<std::sync::Mutex<DevKitConfig>>,
+    frame_tx: Arc<std::sync::Mutex<Option<mpsc::Sender<SensorFrame>>>>,
+    client_handle: Arc<std::sync::Mutex<Option<JoinHandle<()>>>>,
+}
+
+impl Default for DevKitState {
+    fn default() -> Self {
+        Self {
+            running: Arc::new(AtomicBool::new(false)),
+            port: Arc::new(std::sync::Mutex::new(50051)),
+            frame_count: Arc::new(AtomicU32::new(0)),
+            config: Arc::new(std::sync::Mutex::new(DevKitConfig::load())),
+            frame_tx: Arc::new(std::sync::Mutex::new(None)),
+            client_handle: Arc::new(std::sync::Mutex::new(None)),
+        }
+    }
+}
+
+/// 前端查询到的状态快照
+#[derive(Serialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DevKitStatusSnapshot {
+    pub enabled: bool,
+    pub running: bool,
+    pub port: u16,
+    pub frames_sent: u32,
+    pub config: DevKitConfig,
+}
+
+impl DevKitState {
+    pub fn status(&self) -> DevKitStatusSnapshot {
+        let cfg = self.config.lock().unwrap().clone();
+        DevKitStatusSnapshot {
+            enabled: true,
+            running: self.running.load(Ordering::SeqCst),
+            port: *self.port.lock().unwrap(),
+            frames_sent: self.frame_count.load(Ordering::SeqCst),
+            config: cfg,
+        }
+    }
+
+    /// 获取当前配置
+    pub fn get_config(&self) -> DevKitConfig {
+        self.config.lock().unwrap().clone()
+    }
+
+    /// 更新配置并持久化
+    pub fn set_config(&self, new_config: DevKitConfig) -> Result<(), String> {
+        new_config.save()?;
+        *self.config.lock().unwrap() = new_config;
+        Ok(())
+    }
+
+    /// 启动 gRPC client，连接到 Python server 并开始推送数据
+    pub async fn start(&self, port: u16) -> Result<(), String> {
+        if self.running.load(Ordering::SeqCst) {
+            return Err("AlreadyRunning".into());
+        }
+
+        let addr = format!("http://127.0.0.1:{port}");
+        *self.port.lock().unwrap() = port;
+        self.running.store(true, Ordering::SeqCst);
+        self.frame_count.store(0, Ordering::SeqCst);
+
+        // mpsc channel: 主线程 send 帧 → gRPC task 推送给 Python
+        let (tx, rx) = mpsc::channel::<SensorFrame>(512);
+        *self.frame_tx.lock().unwrap() = Some(tx);
+
+        let running = Arc::clone(&self.running);
+        let frame_count = Arc::clone(&self.frame_count);
+
+        let handle = tokio::spawn(async move {
+            if let Err(e) = run_grpc_upload(addr, rx, frame_count).await {
+                ::log::error!("DevKit gRPC upload error: {e:?}");
+            }
+            running.store(false, Ordering::SeqCst);
+        });
+
+        *self.client_handle.lock().unwrap() = Some(handle);
+        ::log::info!("DevKit gRPC client started, connecting to 127.0.0.1:{port}");
+        Ok(())
+    }
+
+    /// 停止 gRPC client
+    pub async fn stop(&self) -> Result<(), String> {
+        if !self.running.load(Ordering::SeqCst) {
+            return Err("NotRunning".into());
+        }
+
+        *self.frame_tx.lock().unwrap() = None;
+
+        if let Some(handle) = self.client_handle.lock().unwrap().take() {
+            handle.abort();
+        }
+
+        self.running.store(false, Ordering::SeqCst);
+        ::log::info!("DevKit gRPC client stopped");
+        Ok(())
+    }
+
+    /// 推送一帧数据到 gRPC stream（由主线程调用）
+    pub fn push_frame(&self, frame: SensorFrame) {
+        if !self.running.load(Ordering::SeqCst) {
+            return;
+        }
+        if let Some(tx) = self.frame_tx.lock().unwrap().as_ref() {
+            let _ = tx.try_send(frame);
+        }
+    }
+
+    /// 调用 Python ExportProcessor.ProcessFile 做导出后处理（unary）
+    pub async fn process_export(
+        &self,
+        csv_path: &str,
+        save_as_xlsx: bool,
+    ) -> Result<ExportProcessResult, String> {
+        let port = *self.port.lock().unwrap();
+        let addr = format!("http://127.0.0.1:{port}");
+
+        let mut client = ExportProcessorClient::connect(addr)
+            .await
+            .map_err(|e| format!("Failed to connect to DevKit server: {e}"))?;
+
+        let request = ProcessRequest {
+            csv_path: csv_path.to_string(),
+            save_as_xlsx,
+        };
+
+        let response = client
+            .process_file(request)
+            .await
+            .map_err(|e| format!("ProcessFile RPC failed: {e}"))?;
+
+        let resp = response.into_inner();
+        Ok(ExportProcessResult {
+            ok: resp.ok,
+            output_path: resp.output_path,
+            groups_used: resp.groups_used,
+            mean_value: resp.mean_value,
+            threshold: resp.threshold,
+            rows_total: resp.rows_total,
+            rows_kept: resp.rows_kept,
+            message: resp.message,
+        })
+    }
+}
+
+// ── gRPC Upload Client ─────────────────────────────────────────────
+
+async fn run_grpc_upload(
+    addr: String,
+    mut rx: mpsc::Receiver<SensorFrame>,
+    frame_count: Arc<AtomicU32>,
+) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+    let mut client = SensorPushClient::connect(addr.clone()).await?;
+
+    let stream = async_stream::stream! {
+        while let Some(frame) = rx.recv().await {
+            frame_count.fetch_add(1, Ordering::SeqCst);
+            yield frame;
+        }
+    };
+
+    let response = client.upload(stream).await?;
+    let resp = response.into_inner();
+
+    ::log::info!(
+        "DevKit upload complete: ok={}, frames={}, msg={}",
+        resp.ok,
+        resp.frames_received,
+        resp.message
+    );
+
+    Ok(())
+}

src-tauri/src/devkit/mod.rs

@@ -0,0 +1,13 @@
+//! Develop Kit 模块
+//!
+//! 仅在 `devkit` feature 启用时编译。
+//! Rust 端作为 gRPC client，将传感器压力矩阵数据实时推送给 Python gRPC server。
+
+mod client;
+
+pub use client::{DevKitConfig, DevKitState, DevKitStatusSnapshot, ExportProcessResult};
+
+// 导入 tonic 生成的 gRPC 代码
+pub mod proto {
+    tonic::include_proto!("sensor_stream");
+}