feat: 前端显示 mdns 搜索到的板子连接信息。

src-tauri/src/main.rs

@@ -11,7 +11,7 @@ mod screenshot_manager;
 use ambient_light::{Border, ColorCalibration, LedStripConfig, LedStripConfigGroup};
 use display_info::DisplayInfo;
 use paris::{error, info, warn};
-use rpc::{MqttRpc, UdpRpc};
+use rpc::{BoardInfo, MqttRpc, UdpRpc};
 use screenshot::Screenshot;
 use screenshot_manager::ScreenshotManager;
 use serde::{Deserialize, Serialize};
@@ -188,6 +188,21 @@ async fn read_config() -> ambient_light::LedStripConfigGroup {
     config_manager.configs().await
 }
 
+#[tauri::command]
+async fn get_boards() -> Result<Vec<BoardInfo>, String> {
+    let udp_rpc = UdpRpc::global().await;
+
+    if let Err(e) = udp_rpc {
+        return Err(format!("can not ping: {}", e));
+    }
+
+    let udp_rpc = udp_rpc.as_ref().unwrap();
+
+    let boards = udp_rpc.get_boards().await;
+    let boards = boards.into_iter().collect::<Vec<_>>();
+    Ok(boards)
+}
+
 #[tokio::main]
 async fn main() {
     env_logger::init();
@@ -200,8 +215,6 @@ async fn main() {
 
     let _mqtt = MqttRpc::global().await;
 
-    let _udp = UdpRpc::global().await;
-
     tauri::Builder::default()
         .invoke_handler(tauri::generate_handler![
             greet,
@@ -216,6 +229,7 @@ async fn main() {
             reverse_led_strip_part,
             set_color_calibration,
             read_config,
+            get_boards,
         ])
         .register_uri_scheme_protocol("ambient-light", move |_app, request| {
             let response = ResponseBuilder::new().header("Access-Control-Allow-Origin", "*");
@@ -400,6 +414,33 @@ async fn main() {
                 }
             });
 
+            let app_handle = app.handle().clone();
+            tokio::spawn(async move {
+                loop {
+                    match UdpRpc::global().await {
+                        Ok(udp_rpc) => {
+                            let mut receiver = udp_rpc.clone_boards_change_receiver().await;
+                            loop {
+                                if let Err(err) = receiver.changed().await {
+                                    error!("boards change receiver changed error: {}", err);
+                                    return;
+                                }
+
+                                let boards = receiver.borrow().clone();
+
+                                let boards = boards.into_iter().collect::<Vec<_>>();
+
+                                app_handle.emit_all("boards_changed", boards).unwrap();
+                            }
+                        }
+                        Err(err) => {
+                            error!("udp rpc error: {}", err);
+                            return;
+                        }
+                    }
+                }
+            });
+
             Ok(())
         })
         .run(tauri::generate_context!())

src-tauri/src/rpc/board_info.rs

@@ -1,6 +1,8 @@
 use std::net::{Ipv4Addr};
 
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub struct BoardInfo {
     pub name: String,
     pub address: Ipv4Addr,

src-tauri/src/rpc/udp.rs

@@ -4,7 +4,7 @@ use mdns_sd::{ServiceDaemon, ServiceEvent};
 use paris::{error, info, warn};
 use tokio::{
     net::UdpSocket,
-    sync::{Mutex, OnceCell},
+    sync::{watch, Mutex, OnceCell},
 };
 
 use super::BoardInfo;
@@ -13,6 +13,8 @@ use super::BoardInfo;
 pub struct UdpRpc {
     socket: Arc<Mutex<UdpSocket>>,
     boards: Arc<Mutex<HashSet<BoardInfo>>>,
+    boards_change_sender: Arc<Mutex<watch::Sender<HashSet<BoardInfo>>>>,
+    boards_change_receiver: Arc<Mutex<watch::Receiver<HashSet<BoardInfo>>>>,
 }
 
 impl UdpRpc {
@@ -32,7 +34,15 @@ impl UdpRpc {
         let socket = UdpSocket::bind("0.0.0.0:0").await?;
         let socket = Arc::new(Mutex::new(socket));
         let boards = Arc::new(Mutex::new(HashSet::new()));
-        Ok(Self { socket, boards })
+        let (boards_change_sender, boards_change_receiver) = watch::channel(HashSet::new());
+        let boards_change_sender = Arc::new(Mutex::new(boards_change_sender));
+        let boards_change_receiver = Arc::new(Mutex::new(boards_change_receiver));
+        Ok(Self {
+            socket,
+            boards,
+            boards_change_sender,
+            boards_change_receiver,
+        })
     }
 
     async fn initialize(&self) {
@@ -52,12 +62,10 @@ impl UdpRpc {
         });
     }
 
-    pub async fn search_boards(&self) -> anyhow::Result<()> {
+    async fn search_boards(&self) -> anyhow::Result<()> {
+        let service_type = "_ambient_light._udp.local.";
         let mdns = ServiceDaemon::new()?;
         let shared_self = Arc::new(Mutex::new(self.clone()));
-
-        let service_type = "_ambient_light._udp.local.";
-
         let receiver = mdns.browse(&service_type).map_err(|e| {
             warn!("Failed to browse for {:?}: {:?}", service_type, e);
             e
@@ -87,6 +95,9 @@ impl UdpRpc {
                     if boards.insert(board.clone()) {
                         info!("added board {:?}", board);
                     }
+
+                    let sender = self.boards_change_sender.clone().lock_owned().await;
+                    sender.send(boards.clone())?;
                 }
                 other_event => {
                     warn!("{:?}", &other_event);
@@ -96,4 +107,16 @@ impl UdpRpc {
 
         Ok(())
     }
+
+    pub async fn clone_boards_change_receiver(
+        &self,
+    ) -> watch::Receiver<HashSet<BoardInfo>> {
+        let boards_change_receiver = self.boards_change_receiver.clone().lock_owned().await;
+        boards_change_receiver.clone()
+    }
+
+    pub async fn get_boards(&self) -> HashSet<BoardInfo> {
+        let boards = self.boards.clone().lock_owned().await;
+        boards.clone()
+    }
 }