refactor: use compio-compat (#109)

* feat: adapt to new runtime APIs

* feat(windows): refactor runtime

* feat(windows): remove dep on compio directly

* feat(win32): optimized adapter

* feat: make compio fully optional

* refactor(win32,winui): no global block_on

* feat(appkit): refactor runtime

* fix(appkit): clone run loop directly

* fix(appkit): don't allow edit on ListBox

* feat(qt): refactor runtime

* feat: restore set_app_id

* feat(gtk): refactor runtime

* fix: cleanup meta

* refactor: move `GlobalRuntime` to winio-pollable

* fix(stub): build

* feat: bump compio & cyper

* refactor(win32): move compat.rs

* fix(win32): make `get_message` modern

* feat(win32): use `NtAlertThread` to wake up the thread

* fix(gtk): cleanup comments

* fix(qt): handle callback

Author: Berrysoft

Cargo.toml

@@ -37,9 +37,10 @@ winio-ui-gtk = { path = "winio-ui-gtk", version = "0.5.0" }
 winio-ui-qt = { path = "winio-ui-qt", version = "0.5.0" }
 winio-ui-app-kit = { path = "winio-ui-app-kit", version = "0.5.0" }
 
-compio = { version = "0.19.0-rc.1", default-features = false }
+compio = { version = "0.19.0-rc.2", default-features = false }
 compio-log = "0.1.0"
 
+arrayvec = "0.7"
 bitflags = "2"
 cfg-if = "1"
 futures-util = "0.3"

winio-pollable/Cargo.toml

@@ -8,10 +8,10 @@ license = { workspace = true }
 repository = { workspace = true }
 
 [dependencies]
-compio = { workspace = true, features = ["runtime"] }
+winio-callback = { workspace = true, optional = true }
 
 futures-util = { workspace = true }
 scoped-tls = { workspace = true }
 
-[target.'cfg(target_os = "linux")'.dependencies]
-rustix = { version = "1", features = ["event"] }
+[features]
+callback = ["dep:winio-callback"]

winio-pollable/src/lib.rs

@@ -5,170 +5,63 @@
 
 #![warn(missing_docs)]
 
-#[cfg(target_os = "linux")]
-use std::os::fd::OwnedFd;
 use std::{
     cell::RefCell,
     future::Future,
-    io,
-    ops::{Deref, DerefMut},
     pin::Pin,
-    sync::Arc,
     task::{Context, Poll, Waker},
-    time::Duration,
 };
 
-use compio::{
-    driver::{AsRawFd, RawFd},
-    runtime::OptWaker,
-};
 use futures_util::FutureExt;
 
-/// See [`Runtime`]
-///
-/// [`Runtime`]: compio::runtime::Runtime
-pub struct Runtime {
-    runtime: compio::runtime::Runtime,
-    #[cfg(target_os = "linux")]
-    efd: Option<OwnedFd>,
-}
-
-#[cfg(target_os = "linux")]
-impl Runtime {
-    /// Create [`Runtime`].
-    pub fn new() -> io::Result<Self> {
-        use rustix::event::{EventfdFlags, eventfd};
-        let efd = eventfd(0, EventfdFlags::CLOEXEC | EventfdFlags::NONBLOCK)?;
-        let mut builder = compio::driver::ProactorBuilder::new();
-        builder.register_eventfd(efd.as_raw_fd());
-        let runtime = compio::runtime::RuntimeBuilder::new()
-            .with_proactor(builder)
-            .build()?;
-        let efd = if runtime.driver_type().is_iouring() {
-            Some(efd)
-        } else {
-            None
-        };
-        Ok(Self { runtime, efd })
-    }
-
-    /// Clear the eventfd, if possible.
-    pub(crate) fn clear(&self) -> io::Result<()> {
-        if let Some(efd) = &self.efd {
-            let mut buf = [0u8; 8];
-            rustix::io::read(efd, &mut buf)?;
-        }
-        Ok(())
+/// Run the current task that is blocking on. Returns true if the task has
+/// completed, and false otherwise.
+pub fn run_current_task() -> bool {
+    if MAIN_TASK.is_set() {
+        MAIN_TASK.with(|task| task.poll())
+    } else {
+        false
     }
 }
 
-#[cfg(not(target_os = "linux"))]
-impl Runtime {
-    /// Create [`Runtime`].
-    pub fn new() -> io::Result<Self> {
-        Ok(Self {
-            runtime: compio::runtime::Runtime::new()?,
-        })
-    }
-
-    /// Clear the eventfd, if possible.
-    pub(crate) fn clear(&self) -> io::Result<()> {
-        Ok(())
-    }
+/// Set the current task that is going to be blocked on, and run the provided
+/// function.
+pub fn enter_block_on<F: Future<Output = ()>, T>(
+    future: F,
+    waker: Waker,
+    f: impl FnOnce() -> T,
+) -> T {
+    let task = unsafe { MainTask::new(future, waker) };
+    MAIN_TASK.set(&task, f)
 }
 
-impl Runtime {
-    /// Run the scheduled tasks.
-    pub fn run(&self) -> bool {
-        let main_task_remaining = if MAIN_TASK.is_set() {
-            MAIN_TASK.with(|task| task.poll())
-        } else {
-            false
-        };
-
-        self.runtime.run() | main_task_remaining
-    }
-
-    /// Poll the runtime. Returns the next timeout.
-    pub fn poll_and_run(&self) -> Option<Duration> {
-        self.runtime.poll_with(Some(Duration::ZERO));
-
-        let remaining_tasks = self.run();
-
-        if remaining_tasks {
-            Some(Duration::ZERO)
-        } else {
-            self.runtime.current_timeout()
-        }
-    }
-
-    /// Set the current main task and wait for its completion.
-    pub fn enter_block_on<F: Future<Output = ()>, T>(&self, future: F, f: impl FnOnce() -> T) -> T {
-        let opt_waker = self.runtime.opt_waker();
-        let task = unsafe { MainTask::new(future, opt_waker) };
-        MAIN_TASK.set(&task, f)
-    }
-
-    /// Block on the future till it completes. Users should enter the runtime
-    /// before calling this function, and poll the runtime themselves.
-    pub fn block_on<F: Future>(&self, future: F, poll: impl Fn(Option<Duration>)) -> F::Output {
-        let result = RefCell::new(None);
-
-        self.enter_block_on(
-            async {
-                let res = Some(future.await);
-                result.replace(res);
-            },
-            || {
-                loop {
-                    let timeout = self.poll_and_run();
-
-                    if let Some(result) = result.take() {
-                        break result;
-                    }
-
-                    poll(timeout);
-
-                    self.clear().ok();
+/// Block on a future until it completes, while also running the provided poll
+/// function to drive the runtime.
+pub fn block_on<F: Future>(future: F, waker: Waker, poll: impl Fn()) -> F::Output {
+    let result = RefCell::new(None);
+
+    enter_block_on(
+        async {
+            let res = Some(future.await);
+            result.replace(res);
+        },
+        waker,
+        || {
+            loop {
+                if !run_current_task() {
+                    poll();
                 }
-            },
-        )
-    }
-}
-
-impl Deref for Runtime {
-    type Target = compio::runtime::Runtime;
-
-    fn deref(&self) -> &Self::Target {
-        &self.runtime
-    }
-}
 
-impl DerefMut for Runtime {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.runtime
-    }
-}
-
-impl AsRawFd for Runtime {
-    fn as_raw_fd(&self) -> RawFd {
-        #[cfg(target_os = "linux")]
-        {
-            self.efd
-                .as_ref()
-                .map(|f| f.as_raw_fd())
-                .unwrap_or_else(|| self.runtime.as_raw_fd())
-        }
-        #[cfg(not(target_os = "linux"))]
-        {
-            self.runtime.as_raw_fd()
-        }
-    }
+                if let Some(result) = result.take() {
+                    break result;
+                }
+            }
+        },
+    )
 }
 
 struct MainTask {
     future: RefCell<Pin<Box<dyn Future<Output = ()>>>>,
-    opt_waker: Arc<OptWaker>,
     waker: Waker,
 }
 
@@ -185,13 +78,11 @@ unsafe fn reduce_lifetime<'a>(
 }
 
 impl MainTask {
-    pub unsafe fn new(future: impl Future<Output = ()>, opt_waker: Arc<OptWaker>) -> Self {
-        let waker = Waker::from(opt_waker.clone());
+    pub unsafe fn new(future: impl Future<Output = ()>, waker: Waker) -> Self {
         Self {
             // SAFETY: the future will only be polled within the scope of `enter_block_on`, which
             // guarantees that the future will not outlive the main task.
             future: RefCell::new(unsafe { reduce_lifetime(future.fuse()) }),
-            opt_waker,
             waker,
         }
     }
@@ -204,7 +95,7 @@ impl MainTask {
                 // anymore.
                 true
             } else {
-                self.opt_waker.reset()
+                false
             }
         } else {
             false
@@ -213,3 +104,15 @@ impl MainTask {
 }
 
 scoped_tls::scoped_thread_local!(static MAIN_TASK: MainTask);
+
+/// An adapter for [`winio_callback::Runnable`] that runs the current task.
+#[cfg(feature = "callback")]
+pub struct GlobalRuntime;
+
+#[cfg(feature = "callback")]
+impl winio_callback::Runnable for GlobalRuntime {
+    #[inline]
+    fn run() {
+        run_current_task();
+    }
+}

winio-ui-app-kit/Cargo.toml

@@ -11,15 +11,15 @@ repository = { workspace = true }
 winio-primitive = { workspace = true }
 winio-handle = { workspace = true }
 winio-callback = { workspace = true }
-winio-pollable = { workspace = true }
+winio-pollable = { workspace = true, features = ["callback"] }
 
-compio = { workspace = true, features = ["arrayvec"] }
+compio = { workspace = true, default-features = false, optional = true }
 compio-log = { workspace = true }
 
+arrayvec = { workspace = true }
 inherit-methods-macro = { workspace = true }
 image = { workspace = true }
 local-sync = { workspace = true }
-scoped-tls = { workspace = true }
 thiserror = { workspace = true }
 
 block2 = "0.6"
@@ -43,6 +43,8 @@ objc2-web-kit = { version = "0.3", optional = true }
 media = ["dep:objc2-av-kit", "dep:objc2-av-foundation", "dep:objc2-core-media"]
 webview = ["dep:objc2-web-kit"]
 
+compio-compat = ["compio/runtime", "compio/compat"]
+
 objc-static = [
     "objc2/unstable-static-class-inlined",
     "objc2/unstable-static-sel-inlined",