flutter_desktop_connection_2: debug lan

Signed-off-by: fufesou <shuanglongchen@yeah.net>

src/flutter_ffi.rs

@@ -7,11 +7,11 @@ use std::{
 use flutter_rust_bridge::{StreamSink, SyncReturn, ZeroCopyBuffer};
 use serde_json::{json, Number, Value};
 
-use hbb_common::{ResultType, password_security};
 use hbb_common::{
     config::{self, Config, LocalConfig, PeerConfig, ONLINE},
     fs, log,
 };
+use hbb_common::{password_security, ResultType};
 
 use crate::client::file_trait::FileManager;
 use crate::common::make_fd_to_json;
@@ -20,7 +20,7 @@ use crate::flutter::{self, Session, SESSIONS};
 use crate::start_server;
 use crate::ui_interface;
 use crate::ui_interface::{
-    change_id, check_connect_status, forget_password, get_api_server, get_app_name,
+    change_id, check_connect_status, discover, forget_password, get_api_server, get_app_name,
     get_async_job_status, get_connect_status, get_fav, get_id, get_lan_peers, get_license,
     get_local_option, get_options, get_peer, get_peer_option, get_socks, get_sound_inputs,
     get_uuid, get_version, has_rendezvous_service, is_ok_change_id, post_request, set_local_option,
@@ -469,6 +469,10 @@ pub fn main_is_using_public_server() -> bool {
     using_public_server()
 }
 
+pub fn main_discover() {
+    discover();
+}
+
 pub fn main_has_rendezvous_service() -> bool {
     has_rendezvous_service()
 }
@@ -509,6 +513,61 @@ pub fn main_forget_password(id: String) {
     forget_password(id)
 }
 
+pub fn main_load_recent_peers() {
+    if !config::APP_DIR.read().unwrap().is_empty() {
+        let peers: Vec<(String, config::PeerInfoSerde)> = PeerConfig::peers()
+            .drain(..)
+            .map(|(id, _, p)| (id, p.info))
+            .collect();
+        if let Some(s) = flutter::GLOBAL_EVENT_STREAM.read().unwrap().as_ref() {
+            let data = HashMap::from([
+                ("name", "load_recent_peers".to_owned()),
+                (
+                    "peers",
+                    serde_json::ser::to_string(&peers).unwrap_or("".to_owned()),
+                ),
+            ]);
+            s.add(serde_json::ser::to_string(&data).unwrap_or("".to_owned()));
+        };
+    }
+}
+
+pub fn main_load_fav_peers() {
+    if !config::APP_DIR.read().unwrap().is_empty() {
+        let favs = get_fav();
+        let peers: Vec<(String, config::PeerInfoSerde)> = PeerConfig::peers()
+            .into_iter()
+            .filter_map(|(id, _, peer)| {
+                if favs.contains(&id) {
+                    Some((id, peer.info))
+                } else {
+                    None
+                }
+            })
+            .collect();
+        if let Some(s) = flutter::GLOBAL_EVENT_STREAM.read().unwrap().as_ref() {
+            let data = HashMap::from([
+                ("name", "load_fav_peers".to_owned()),
+                (
+                    "peers",
+                    serde_json::ser::to_string(&peers).unwrap_or("".to_owned()),
+                ),
+            ]);
+            s.add(serde_json::ser::to_string(&data).unwrap_or("".to_owned()));
+        };
+    }
+}
+
+pub fn main_load_lan_peers() {
+    if let Some(s) = flutter::GLOBAL_EVENT_STREAM.read().unwrap().as_ref() {
+        let data = HashMap::from([
+            ("name", "load_lan_peers".to_owned()),
+            ("peers", get_lan_peers()),
+        ]);
+        s.add(serde_json::ser::to_string(&data).unwrap_or("".to_owned()));
+    };
+}
+
 /// FFI for **get** commands which are idempotent.
 /// Return result in c string.
 ///

src/lan.rs

@@ -277,6 +277,9 @@ async fn handle_received_peers(mut rx: UnboundedReceiver<config::DiscoveryPeer>)
                     if last_write_time.elapsed().as_millis() > 300 {
                         config::LanPeers::store(&peers);
                         last_write_time = Instant::now();
+
+                        #[cfg(feature = "flutter")]
+                        crate::flutter_ffi::main_load_lan_peers();
                     }
                 }
                 None => {

src/rendezvous_mediator.rs

@@ -604,68 +604,6 @@ fn lan_discovery() -> ResultType<()> {
     }
 }
 
-pub fn discover() -> ResultType<()> {
-    let addr = SocketAddr::from(([0, 0, 0, 0], 0));
-    let socket = std::net::UdpSocket::bind(addr)?;
-    socket.set_broadcast(true)?;
-    let mut msg_out = Message::new();
-    let peer = PeerDiscovery {
-        cmd: "ping".to_owned(),
-        ..Default::default()
-    };
-    msg_out.set_peer_discovery(peer);
-    let maddr = SocketAddr::from(([255, 255, 255, 255], get_broadcast_port()));
-    socket.send_to(&msg_out.write_to_bytes()?, maddr)?;
-    log::info!("discover ping sent");
-    let mut last_recv_time = Instant::now();
-    let mut last_write_time = Instant::now();
-    let mut last_write_n = 0;
-    // to-do: load saved peers, and update incrementally (then we can see offline)
-    let mut peers = Vec::new();
-    let mac = get_mac();
-    socket.set_read_timeout(Some(std::time::Duration::from_millis(10)))?;
-    loop {
-        let mut buf = [0; 2048];
-        if let Ok((len, _)) = socket.recv_from(&mut buf) {
-            if let Ok(msg_in) = Message::parse_from_bytes(&buf[0..len]) {
-                match msg_in.union {
-                    Some(rendezvous_message::Union::PeerDiscovery(p)) => {
-                        last_recv_time = Instant::now();
-                        if p.cmd == "pong" {
-                            if p.mac != mac {
-                                let dp = DiscoveryPeer {
-                                    id: "".to_string(),
-                                    ip_mac: HashMap::from([
-                                        // TODO: addr ip
-                                        (addr.ip().to_string(), p.mac.clone()),
-                                    ]),
-                                    username: p.username,
-                                    hostname: p.hostname,
-                                    platform: p.platform,
-                                    online: true,
-                                };
-                                peers.push(dp);
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-            }
-        }
-        if last_write_time.elapsed().as_millis() > 300 && last_write_n != peers.len() {
-            config::LanPeers::store(&peers);
-            last_write_time = Instant::now();
-            last_write_n = peers.len();
-        }
-        if last_recv_time.elapsed().as_millis() > 3_000 {
-            break;
-        }
-    }
-    log::info!("discover ping done");
-    config::LanPeers::store(&peers);
-    Ok(())
-}
-
 #[tokio::main(flavor = "current_thread")]
 pub async fn query_online_states<F: FnOnce(Vec<String>, Vec<String>)>(ids: Vec<String>, f: F) {
     let test = false;

src/ui.rs

@@ -20,6 +20,7 @@ use hbb_common::{
 };
 
 use crate::common::{get_app_name, SOFTWARE_UPDATE_URL};
+use crate::ipc;
 use crate::ui_interface::{
     check_mouse_time, closing, create_shortcut, current_is_wayland, fix_login_wayland,
     forget_password, get_api_server, get_async_job_status, get_connect_status, get_error, get_fav,
@@ -35,7 +36,6 @@ use crate::ui_interface::{
     show_run_without_install, store_fav, t, temporary_password, test_if_valid_server, update_me,
     update_temporary_password, using_public_server,
 };
-use crate::{discover, ipc};
 
 mod cm;
 #[cfg(feature = "inline")]
@@ -493,7 +493,9 @@ impl UI {
     }
 
     fn discover(&self) {
-        discover();
+        std::thread::spawn(move || {
+            allow_err!(crate::lan::discover());
+        });
     }
 
     fn get_lan_peers(&self) -> String {

src/ui_interface.rs

@@ -9,12 +9,12 @@ use hbb_common::{
     allow_err,
     config::{self, Config, LocalConfig, PeerConfig, RENDEZVOUS_PORT, RENDEZVOUS_TIMEOUT},
     futures::future::join_all,
-    log,
+    log, password_security,
     protobuf::Message as _,
     rendezvous_proto::*,
     sleep,
     tcp::FramedStream,
-    tokio::{self, sync::mpsc, time}, password_security,
+    tokio::{self, sync::mpsc, time},
 };
 
 use crate::common::SOFTWARE_UPDATE_URL;
@@ -538,12 +538,26 @@ pub fn create_shortcut(_id: String) {
 
 pub fn discover() {
     std::thread::spawn(move || {
-        allow_err!(crate::rendezvous_mediator::discover());
+        allow_err!(crate::lan::discover());
     });
 }
 
 pub fn get_lan_peers() -> String {
-    serde_json::to_string(&config::LanPeers::load().peers).unwrap_or_default()
+    let peers: Vec<(String, config::PeerInfoSerde)> = config::LanPeers::load()
+        .peers
+        .iter()
+        .map(|peer| {
+            (
+                peer.id.clone(),
+                config::PeerInfoSerde {
+                    username: peer.username.clone(),
+                    hostname: peer.hostname.clone(),
+                    platform: peer.platform.clone(),
+                },
+            )
+        })
+        .collect();
+    serde_json::to_string(&peers).unwrap_or_default()
 }
 
 pub fn get_uuid() -> String {