Best way to handle connecting to nested QObject signals?

[Supreeeme]

So I have a QObject that basically boils down to this:

use std::pin::Pin;
#[cxx_qt::bridge]
pub mod qobject {
    extern "RustQt" {
        #[qobject]
        type Service = super::RustService;
    }
}

struct RustService {
    timer: cxx::UniquePtr<qobject::QTimer>
}

(where I added some bindings for QTimer)
Now, on construction I want to connect the timeout signal to some functionality on the Service. First I tried this:

impl cxx_qt::Initialize for qobject::Service {
    fn initialize(self: Pin<&mut Self>) {
        self.as_mut()
              .rust_mut()
            .timer
            .pin_mut()
            .on_timeout(|_| {
                    self.rust_mut().on_timeout();
            })
            .release();
    }
}

This complains that the QTimer (I think) isn't Send, which is fair, but it's unfortunate when I know that I'm always on the same thread here.

Anyway, then I discovered cxx_qt::Threading, which lead me to do this:

    fn initialize(self: Pin<&mut Self>) {
        let thread = self.qt_thread();
        self.rust_mut()
            .timer
            .pin_mut()
            .on_timeout(move |_| {
                thread
                    .queue(move |this| {
                        this.rust_mut().on_timeout();
                    })
                    .unwrap();
            })
            .release();
    }

Now this works, but the self.qt_thread() feels a little funny when there are no threads involved here. Is there a better way that I'm missing here, or is this the best that can be done for now?