feat: implement tray in linux

Cargo.lock

@@ -4380,12 +4380,14 @@ dependencies = [
  "flexi_logger",
  "flutter_rust_bridge",
  "flutter_rust_bridge_codegen",
+ "gtk",
  "hbb_common",
  "hound",
  "impersonate_system",
  "include_dir",
  "jni",
  "lazy_static",
+ "libappindicator",
  "libc",
  "libpulse-binding",
  "libpulse-simple-binding",

Cargo.toml

@@ -112,7 +112,8 @@ mouce = { git="https://github.com/fufesou/mouce.git" }
 evdev = { git="https://github.com/fufesou/evdev" }
 dbus = "0.9"
 dbus-crossroads = "0.5"
-
+gtk = "0.15"
+libappindicator = "0.7"
 
 [target.'cfg(target_os = "android")'.dependencies]
 android_logger = "0.11"

flutter/lib/desktop/pages/desktop_home_page.dart

@@ -432,7 +432,8 @@ class _DesktopHomePageState extends State<DesktopHomePage>
       updateUrl = await bind.mainGetSoftwareUpdateUrl();
       if (updateUrl.isNotEmpty) setState(() {});
     });
-    initTray();
+    // disable this tray because we use tray function provided by rust now
+    // initTray();
     trayManager.addListener(this);
     windowManager.addListener(this);
     rustDeskWinManager.setMethodHandler((call, fromWindowId) async {

flutter/lib/models/native_model.dart

@@ -90,10 +90,6 @@ class PlatformFFI {
   /// Init the FFI class, loads the native Rust core library.
   Future<void> init(String appType) async {
     _appType = appType;
-    // if (isDesktop) {
-    //   // TODO
-    //   return;
-    // }
     final dylib = Platform.isAndroid
         ? DynamicLibrary.open('librustdesk.so')
         : Platform.isLinux

src/core_main.rs

@@ -148,7 +148,7 @@ pub fn core_main() -> Option<Vec<String>> {
             return None;
         } else if args[0] == "--server" {
             log::info!("start --server");
-            #[cfg(not(target_os = "macos"))]
+            #[cfg(target_os = "windows")]
             {
                 crate::start_server(true);
                 return None;
@@ -158,6 +158,11 @@ pub fn core_main() -> Option<Vec<String>> {
                 std::thread::spawn(move || crate::start_server(true));
                 // to-do: for flutter, starting tray not ready yet, or we can reuse sciter's tray implementation.
             }
+            #[cfg(all(target_os = "linux", feature = "flutter"))]
+            {
+                std::thread::spawn(move || crate::start_server(true));
+                crate::tray::start_tray(crate::ui_interface::OPTIONS.clone());
+            }
         } else if args[0] == "--import-config" {
             if args.len() == 2 {
                 let filepath;

src/lib.rs

@@ -41,7 +41,7 @@ mod lang;
 mod license;
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
 mod port_forward;
-#[cfg(windows)]
+
 mod tray;
 
 mod ui_cm_interface;

src/tray.rs

@@ -1,11 +1,11 @@
+use hbb_common::log::{debug, error, info};
+use lazy_static::lazy_static;
+#[cfg(target_os = "linux")]
+use libappindicator::AppIndicator;
+use std::env::temp_dir;
 use std::{
     collections::HashMap,
-    sync::{Arc, Mutex},
-};
-use trayicon::{MenuBuilder, TrayIconBuilder};
-use winit::{
-    event::Event,
-    event_loop::{ControlFlow, EventLoop},
+    sync::{Arc, Mutex, RwLock},
 };
 
 #[derive(Clone, Eq, PartialEq, Debug)]
@@ -15,6 +15,7 @@ enum Events {
     StartService,
 }
 
+#[cfg(target_os = "windows")]
 pub fn start_tray(options: Arc<Mutex<HashMap<String, String>>>) {
     let event_loop = EventLoop::<Events>::with_user_event();
     let proxy = event_loop.create_proxy();
@@ -76,3 +77,100 @@ pub fn start_tray(options: Arc<Mutex<HashMap<String, String>>>) {
         }
     });
 }
+
+/// Start a tray icon in Linux
+///
+/// [Block]
+/// This function will block current execution, show the tray icon and handle events.
+#[cfg(target_os = "linux")]
+pub fn start_tray(options: Arc<Mutex<HashMap<String, String>>>) {
+    use std::time::Duration;
+
+    use gtk::traits::{GtkMenuItemExt, MenuShellExt, WidgetExt};
+    info!("configuring tray");
+    // init gtk context
+    if let Err(err) = gtk::init() {
+        error!("Error when starting the tray: {}", err);
+        gtk::main_quit();
+        return;
+    }
+    if let Some(mut appindicator) = get_default_app_indicator() {
+        let mut menu = gtk::Menu::new();
+        let running = get_service_status(options.clone());
+        // start/stop service
+        let label = if !running {
+            crate::client::translate("Start Service".to_owned())
+        } else {
+            crate::client::translate("Stop service".to_owned())
+        };
+        let menu_item_service = gtk::MenuItem::with_label(label.as_str());
+        menu_item_service.connect_activate(move |item| {
+            let lock = crate::ui_interface::SENDER.lock().unwrap();
+            update_tray_service_item(options.clone(), item);
+        });
+        menu.append(&menu_item_service);
+        // show tray item
+        menu.show_all();
+        appindicator.set_menu(&mut menu);
+        // start event loop
+        info!("Setting tray event loop");
+        gtk::main();
+    } else {
+        eprintln!("tray process exit now");
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn update_tray_service_item(options: Arc<Mutex<HashMap<String, String>>>, item: &gtk::MenuItem) {
+    use gtk::{
+        traits::{GtkMenuItemExt, ListBoxRowExt},
+        MenuItem,
+    };
+    if get_service_status(options.clone()) {
+        debug!("Now try to stop service");
+        item.set_label(&crate::client::translate("Start Service".to_owned()));
+        crate::ipc::set_option("stop-service", "Y");
+    } else {
+        debug!("Now try to start service");
+        item.set_label(&crate::client::translate("Stop service".to_owned()));
+        crate::ipc::set_option("stop-service", "");
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn get_default_app_indicator() -> Option<AppIndicator> {
+    use libappindicator::AppIndicatorStatus;
+    use std::io::Write;
+
+    let icon = include_bytes!("../res/icon.png");
+    // appindicator does not support icon buffer, so we write it to tmp folder
+    let mut icon_path = temp_dir();
+    icon_path.push("RustDesk");
+    icon_path.push("rustdesk.png");
+    match std::fs::File::create(icon_path.clone()) {
+        Ok(mut f) => {
+            f.write_all(icon).unwrap();
+        }
+        Err(err) => {
+            error!("Error when writing icon to {:?}: {}", icon_path, err);
+            return None;
+        }
+    }
+    debug!("write temp icon complete");
+    let mut appindicator = AppIndicator::new("RustDesk", icon_path.to_str().unwrap_or("rustdesk"));
+    appindicator.set_label("RustDesk", "A remote control software.");
+    appindicator.set_status(AppIndicatorStatus::Active);
+    Some(appindicator)
+}
+
+/// Get service status
+/// Return [`true`] if service is running, [`false`] otherwise.
+#[inline]
+fn get_service_status(options: Arc<Mutex<HashMap<String, String>>>) -> bool {
+    if let Some(v) = options.lock().unwrap().get("stop-service") {
+        debug!("service stopped: {}", v);
+        v.is_empty()
+    } else {
+        true
+    }
+}