One thread for multiple rust functions?

[Markus43]

Hi! I'm trying to wrap some rust code that calls native windows API's. The API I'm calling wants all the functions on a specific handle to be called from the same thread (at least I believe that). It also seems to require that the thread that created the handle stays alive.

From the documentation I figured that in order to make all rust calls run in the same "worker" thread (which might be a solution here, right? ), I might have to modify FLUTTER_RUST_BRIDGE_HANDLER, but looking at its default implementation ...

flutter_rust_bridge/frb_rust/src/for_generated/boilerplate.rs

Line 209 in b72240e

macro_rules! frb_generated_default_handler {

... I'm a bit puzzled how I could achieve that and if it's even possible ?

Or maybe there's another solution to achieve what I want without fiddling with the default handler?

[fzyzcjy]

There are multiple ways I guess

1. Create a separate brand new thread, and run code there. There are many Rust crates for that. I would imagine the code look like:

// func to be called from Dart
fn my_func() {
  MY_GOOD_THREAD.execute(|| {
    // things that need to use one single thread
  });
}

2. Use #[frb(sync)], then the function is called from Dart main isolate (thread). Drawback: Dart main isolate may change the thread it binds, so check whether this is ok for you. Another drawback: It will block your Dart UI if your Rust function executes for a long time (but is surely ok if it is short).
3. Yes, create a custom handler and you have full control. Or (hackily) make it 1 single worker thread, or use the async feature and force it to have 1 thread, etc.

[Markus43]

Creating a seperate thread in rust that handles all this stuff looks like the most straight-forward thing to do. Thinking about this a bit more, using #[frb(sync)] and wrapping the code in a long-running dart isolate would be another approach - since I've never done multithreading in rust ...
Thanks for the pointers, much appreciated! :-)

[fzyzcjy]

You are welcome!

Btw multithreading in Rust is not hard: If you do anything wrong, Rust compiler should stop you from compiling, so usually no worries about making a mistake (e.g. race condition) and cause hard-to-debug runtime bugs.