Thread spawn based zenity backend

Cargo.toml

@@ -14,7 +14,7 @@ documentation = "https://docs.rs/rfd"
 default = ["gtk3"]
 file-handle-inner = []
 gtk3 = ["gtk-sys", "glib-sys", "gobject-sys"]
-xdg-portal = ["ashpd", "urlencoding", "pollster", "async-io", "futures-util"]
+xdg-portal = ["ashpd", "urlencoding", "pollster"]
 common-controls-v6 = ["windows-sys/Win32_UI_Controls"]
 
 [dev-dependencies]
@@ -41,10 +41,6 @@ windows-sys = { version = "0.48", features = [
 ] }
 
 [target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))'.dependencies]
-# Make sure that this is in sync with zbus, to avoid duplicated deps
-async-io = { version = "1.3", optional = true }
-futures-util = { version = "0.3", optional = true, default-features = false, features = ["io"] }
-
 # XDG Desktop Portal
 ashpd = { version = "0.6", optional = true }
 urlencoding = { version = "2.1.0", optional = true }

src/backend/linux/async_command.rs

@@ -0,0 +1,55 @@
+use std::{
+    io,
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll, Waker},
+};
+
+struct State {
+    waker: Option<Waker>,
+    data: Option<io::Result<std::process::Output>>,
+}
+
+pub struct AsyncCommand {
+    state: Arc<Mutex<State>>,
+}
+
+impl AsyncCommand {
+    pub fn spawn(mut command: std::process::Command) -> Self {
+        let state = Arc::new(Mutex::new(State {
+            waker: None,
+            data: None,
+        }));
+
+        std::thread::spawn({
+            let state = state.clone();
+            move || {
+                let output = command.output();
+
+                let mut state = state.lock().unwrap();
+                state.data = Some(output);
+
+                if let Some(waker) = state.waker.take() {
+                    waker.wake();
+                }
+            }
+        });
+
+        Self { state }
+    }
+}
+
+impl std::future::Future for AsyncCommand {
+    type Output = io::Result<std::process::Output>;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut state = self.state.lock().unwrap();
+
+        if state.data.is_some() {
+            Poll::Ready(state.data.take().unwrap())
+        } else {
+            state.waker = Some(cx.waker().clone());
+            Poll::Pending
+        }
+    }
+}

src/backend/linux/mod.rs

@@ -1,2 +1,2 @@
-mod child_stdout;
+mod async_command;
 pub(crate) mod zenity;

src/backend/linux/zenity.rs

@@ -1,13 +1,5 @@
-use futures_util::AsyncReadExt;
-use std::{
-    error::Error,
-    fmt::Display,
-    path::PathBuf,
-    process::{Command, Stdio},
-    time::Duration,
-};
+use std::{error::Error, fmt::Display, path::PathBuf, process::Command};
 
-use super::child_stdout::ChildStdout;
 use crate::{
     file_dialog::Filter,
     message_dialog::{MessageButtons, MessageLevel},
@@ -17,7 +9,7 @@ use crate::{
 #[derive(Debug)]
 pub enum ZenityError {
     Io(std::io::Error),
-    StdOutNotFound,
+    FromUtf8Error(std::string::FromUtf8Error),
 }
 
 impl Error for ZenityError {}
@@ -26,7 +18,7 @@ impl Display for ZenityError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ZenityError::Io(io) => write!(f, "{io}"),
-            ZenityError::StdOutNotFound => write!(f, "Stdout not found"),
+            ZenityError::FromUtf8Error(err) => err.fmt(f),
         }
     }
 }
@@ -37,6 +29,12 @@ impl From<std::io::Error> for ZenityError {
     }
 }
 
+impl From<std::string::FromUtf8Error> for ZenityError {
+    fn from(value: std::string::FromUtf8Error) -> Self {
+        Self::FromUtf8Error(value)
+    }
+}
+
 pub type ZenityResult<T> = Result<T, ZenityError>;
 
 fn command() -> Command {
@@ -64,24 +62,11 @@ fn add_filename(command: &mut Command, file_name: &Option<String>) {
     }
 }
 
-async fn run(mut command: Command) -> ZenityResult<Option<String>> {
-    let mut process = command.stdout(Stdio::piped()).spawn()?;
-
-    let stdout = process.stdout.take().ok_or(ZenityError::StdOutNotFound)?;
-    let mut stdout = ChildStdout::new(stdout)?;
-
-    let mut buffer = String::new();
-    stdout.read_to_string(&mut buffer).await?;
-
-    let status = loop {
-        if let Some(status) = process.try_wait()? {
-            break status;
-        }
-
-        async_io::Timer::after(Duration::from_millis(1)).await;
-    };
+async fn run(command: Command) -> ZenityResult<Option<String>> {
+    let res = super::async_command::AsyncCommand::spawn(command).await?;
+    let buffer = String::from_utf8(res.stdout)?;
 
-    Ok((status.success() || !buffer.is_empty()).then_some(buffer))
+    Ok((res.status.success() || !buffer.is_empty()).then_some(buffer))
 }
 
 #[allow(unused)]
@@ -243,21 +228,21 @@ mod tests {
     #[test]
     #[ignore]
     fn message() {
-        async_io::block_on(super::message(
+        pollster::block_on(super::message(
             &crate::message_dialog::MessageLevel::Info,
             &crate::message_dialog::MessageButtons::Ok,
             "hi",
             "me",
         ))
         .unwrap();
-        async_io::block_on(super::message(
+        pollster::block_on(super::message(
             &crate::message_dialog::MessageLevel::Warning,
             &crate::message_dialog::MessageButtons::Ok,
             "hi",
             "me",
         ))
         .unwrap();
-        async_io::block_on(super::message(
+        pollster::block_on(super::message(
             &crate::message_dialog::MessageLevel::Error,
             &crate::message_dialog::MessageButtons::Ok,
             "hi",
@@ -269,13 +254,13 @@ mod tests {
     #[test]
     #[ignore]
     fn question() {
-        async_io::block_on(super::question(
+        pollster::block_on(super::question(
             &crate::message_dialog::MessageButtons::OkCancel,
             "hi",
             "me",
         ))
         .unwrap();
-        async_io::block_on(super::question(
+        pollster::block_on(super::question(
             &crate::message_dialog::MessageButtons::YesNo,
             "hi",
             "me",
@@ -286,28 +271,28 @@ mod tests {
     #[test]
     #[ignore]
     fn pick_file() {
-        let path = async_io::block_on(super::pick_file(&FileDialog::default())).unwrap();
+        let path = pollster::block_on(super::pick_file(&FileDialog::default())).unwrap();
         dbg!(path);
     }
 
     #[test]
     #[ignore]
     fn pick_files() {
-        let path = async_io::block_on(super::pick_files(&FileDialog::default())).unwrap();
+        let path = pollster::block_on(super::pick_files(&FileDialog::default())).unwrap();
         dbg!(path);
     }
 
     #[test]
     #[ignore]
     fn pick_folder() {
-        let path = async_io::block_on(super::pick_folder(&FileDialog::default())).unwrap();
+        let path = pollster::block_on(super::pick_folder(&FileDialog::default())).unwrap();
         dbg!(path);
     }
 
     #[test]
     #[ignore]
     fn save_file() {
-        let path = async_io::block_on(super::save_file(&FileDialog::default())).unwrap();
+        let path = pollster::block_on(super::save_file(&FileDialog::default())).unwrap();
         dbg!(path);
     }
 }