Help with RustOpaque Sending

[JustSimplyKyle]

    --> src/api/vanilla.rs:484:29
     |
 484 |       let task = tokio::spawn(async move {
     |  _____________________________^
 485 | |         let mut instant = Instant::now();
 486 | |         let mut prev_bytes = 0.0;
 487 | |         while !download_complete_clone.load(Ordering::Acquire) {
 ...   |
 515 | |         sink.close();
 516 | |     });
     | |_____^ future created by async block is not `Send`
     |
     = help: the trait `std::marker::Sync` is not implemented for `std::sync::mpsc::Receiver<api::State>`
 note: captured value is not `Send`
    --> src/api/vanilla.rs:505:18
     |
 505 |             dbg!(recv.recv().unwrap());
     |                  ^^^^ has type `flutter_rust_bridge::RustOpaque<std::sync::mpsc::Receiver<api::State>>` which is not `
 Send`
 note: required by a bound in `tokio::spawn`
    --> /home/kyle/.cargo/registry/src/index.crates.io-6f17d22bba15001f/tokio-1.29.1/src/task/spawn.rs:166:21
     |
 164 |     pub fn spawn<T>(future: T) -> JoinHandle<T::Output>
     |            ----- required by a bound in this function
 165 |     where
 166 |         T: Future + Send + 'static,
     |                     ^^^^ required by this bound in `spawn`

I then tried, let recv = channel.receiver.try_unwrap().unwrap();
which compiles! But it panics with "panicked at 'called Result::unwrap() on an Err value: RustOpaque { ptr: Some(Receiver { .. }) }', src/api/vanilla.rs:480:43"
which I thought only happens when the strong count is above one?(I never did any cloning)
state is a simple enum

#[derive(Debug, Copy, Clone)]
pub enum State {
    Downlaoding,
    Paused,
    ForceCancel,
}

[fzyzcjy]

But it panics with "panicked at 'called Result::unwrap() on an Err value: RustOpaque { ptr: Some(Receiver { .. }) }', src/api/vanilla.rs:480:43"

It may be helpful to provide a bit more details

[fzyzcjy]

Well it would be great to have a complete minimal reproducible sample with code, error logs, full stack traces etc. And would be great to print everything for debugging. e.g. I cannot see which line unwraps.

[JustSimplyKyle]

#[derive(Debug, Copy, Clone)]
pub enum State {
    Downlaoding,
    Paused,
    ForceCancel,
}

pub struct StateChannel {
    pub sender: RustOpaque<Sender<State>>,
    pub receiver: RustOpaque<Receiver<State>>,
}
unsafe impl Send for StateChannel {}
unsafe impl Sync for StateChannel {}

pub fn state_fetch_write(s: State) -> StateChannel {
    let (tx, rx) = mpsc::channel();
    tx.send(s).unwrap();
    let sender = RustOpaque::new(tx);
    let receiver = RustOpaque::new(rx);
    StateChannel { sender, receiver }
}

pub fn state_write(s: State, channel: StateChannel) {
    channel.sender.send(s).unwrap();
}
// will not compile
#[tokio::main(flavor = "current_thread")]
pub async fn not_compile_test(channels: StateChannel) -> anyhow::Result<()> {
    dbg!(channels.receiver.recv());
    while let Ok(recv) = channels.receiver.try_recv() {
        dbg!(recv);
    }
    Ok(())
}
// panic at runtime
#[tokio::main(flavor = "current_thread")]
pub async fn panic_test(channels: StateChannel) -> anyhow::Result<()> {
    let recv = channels.receiver.try_unwrap().unwrap();
    tokio::spawn(async move {
        while let Ok(recv) = recv.try_recv() {
            println!("imafailure");
            dbg!(recv);
        }
    })
    .await?;
    Ok(())
}

dart:
I can't make a complete reproducible example, but it might be that might be I'm just rusty at dart.
pseudo code, doesn't output anything in my testing

  final channel = await api.stateFetchWrite(s: bridge.State.Downlaoding);
  await api.panic_test(channels: channel);

the code that compiles and panics but is out of context

  final channel = await api.stateFetchWrite(s: bridge.State.Downlaoding);
  final vanilla = api.downloadVanilla(channels: channel);
  vanilla.listen((event) async {
    await api.panic_test(channels: channel);
    print("speed");
    print(event.progress?.speed);
});

The actual code in action.
https://github.com/RPMTW/era-connect/tree/stream

[fzyzcjy]

Hmm, so I am surprised async fn even compiles here! async fn is not supported (directly) yet, but it should not be too hard to PR (I remembered saying things about async fn these few days, maybe to another person?). Someone did try using async without modifying FRB -> https://cjycode.com/flutter_rust_bridge/article/async_in_rust.html, but I would suggest PR to frb directly, since that would make code more performant.

[JustSimplyKyle]

That article I did read, it gave me the solution of putting #[tokio::main(flavor = "current_thread")] to make it work.
I've also tried the non async version, which seems not to fix the panic issue
but at the end, I solved the issue!
https://docs.rs/crossbeam/latest/crossbeam/channel/struct.Sender.html
using this crate, I could use a sender that is available to send thru threads safely!(so no weird .try_unwrap().unwrap() needed.
One question, why would using a macro async cause performance issues?

[fzyzcjy]

I have not played with tokio so correct me if I am wrong! IIRC, if we call async from frb, frb will still use one thread per call. As we know, async is used in order to allow multiple calls to happen in one thread.