CXX-Qt + async Rust = ?

[Tmpod]

Hello!

I've been interested in Qt+Rust as a way to develop good cross-platform applications for a while, because Qt is a very complete and mature framework, with QML as a great UI language, and of course Rust is a great language with lots of interesting features and a very active community.

Async/await is becoming ever more prevalent, with many new API wrappers and the likes being published exclusively as async crates. One particular example I'm interested on, is the great matrix-rust-sdk, which is now powering clients such as Element X iOS (Rust+SwiftUI), Element X Android (Rust+Jetpack Compose) and Fractal (Rust+GTK4). I'd like to play around with making a client with Rust+Qt :)

I've seen some other efforts like qmetaobject-rs (and an experimental async compatibility crate, qmeta-async, from the SailfishOS folks), and I wanted to know how CXX-Qt does it (if at all).

Thank you!

[ahayzen-kdab]

Async is curious as Qt / QML isn't expecting things to be async, so what I tend to do so far is use async in a background thread or block_on a result from an invokable.

If you main function is in Rust then you can use tokio as normal, eg the following works

#[tokio::main]
async fn main() {
    let mut app = QGuiApplication::new();
    let mut engine = QQmlApplicationEngine::new();
    ...

This then allows you to use tokio::spawn inside QML invokables / constructor in Rust, where you could then trigger signals in the background (as CxxQtThread can be moved between threads https://docs.rs/cxx-qt/latest/cxx_qt/struct.CxxQtThread.html ) to update the state of QML.

There is also a cxx-async crate and https://cxx.rs/async.html but we have yet to explore how we could integrate those and use them better in CXX-Qt. (eg maybe we could have a QFuture returned ? but QML doesn't really understand these so we would need to explore where they are useful)

[Tmpod]

Oh I see, hadn't noticed CxxQtThread was Send. Is there some public code I can take a look at, to see that in practice?
cxx-async looks interesting.

Thanks!

[ahayzen-kdab]

We have a basic example of how to do threading in qml_features
https://github.com/KDAB/cxx-qt/blob/main/examples/qml_features/rust/src/threading.rs#L107

There is a more complicated threading example in demo_threading
https://github.com/KDAB/cxx-qt/blob/main/examples/demo_threading/rust/src/lib.rs#L151

Then i have an old personal project that is using async for websocket communication but with CXX-Qt 0.5, however things should still be relevant enough
https://gitlab.com/ahayzen/home-dash-alpha-g1/-/blob/main/src/dashboard/src/backend/weathercontroller.rs?ref_type=heads#L32

The general concept is

// A method on the Qt / C++ context
fn method(self: Pin<&mut T>) {
   let qt_thread = self.qt_thread();  // get a qt thread instance

   spawn(async move || {  // spawn your thread / async thing, as long as it moves
      // do work
      ...

      // when you want to update something back on the Qt / C++ context you queue a closure onto it
      qt_thread.queue(|qobject| {
          // we are now running back in the Qt / C++ context
          // so qobject here is the same as self above
          qobject.set_property_value(new_value);  // we could update a property
          qobject.invokable_method();  // we could call an invokable or emit a signal or connect to one etc as usual
      });
   });
}

Note that if this is a long running async thing you might want to do this in the Initialiser of the constructor in the rust side, see https://docs.rs/cxx-qt/latest/cxx_qt/trait.Initialize.html

And also note for this to work you'll need to have told CXX-Qt to implement threading support for the QObject, see https://docs.rs/cxx-qt/latest/cxx_qt/trait.Threading.html which also has a mini example of using qt_thread.

[Tmpod]

Dang, so many examples and links, thank you! That doesn't seem that bad, specially with a couple functions/macros to abstract away some boilerplate.

Will be exploring this in the near future :D