irondash_run_loop

This crate provides a consistent, platform independent interface to system run loop.

Getting RunLoop for current thread

let run_loop = RunLoop::current();

If there is no run loop associated with current thread, this will create one. RunLoop is backed by platform specific implementation:

CFRunLoop on iOS nad macOS
ALooper on Android
GMainContext on Linux
HWND message loop on Windows

Calling RunLoop from other threads

RunLoop neither Send, nor Sync. All interaction with must be carried on thread, where the run loop belongs.

To interact with run loop from other threads, use RunLoopSender:

let run_loop = RunLoop::current();
let sender = run_loop.new_sender();

// sender is Sync, Send and Clone
thread::spawn(move||{
    println("Hello from other thread!");
    sender.send(||{
        println!("Back on RunLoop thread");
    });
});

At any point, without needing a RunLoop instance, you can request sender that sends the closure to main thread.

thread::spawn(move||{
    let sender = RunLoop::main_thread_sender();
    sender.send(||{
        println!("Back on main thread");
        // run_loop is main thread run loop
        let run_loop = RunLoop::current();
    });
});

Note that for this to work on Android, the library must be loaded from Java using System.loadLibrary. Otherwise you must call RunLoop::current() on main thread at least once before RunLoop::main_thread_sender() is called.

Scheduling timers

RunLoop can also be used to schedule delayed execution of closures:

let run_loop = RunLoop::current();
let handle = run_loop.schedule(Duration::from_secs(10), || {
    println!("This will be printed after 10 seconds");
});

RunLoop::schedule returns a Handle instance. If handle is dropped before timer executes, timer will be cancelled. If you don't want that, call detach on the handle:

let run_loop = RunLoop::current();
self.run_loop(Duration::from_secs(10), || {
    println!("This will be printed after 10 seconds");
}).detach();

You can also call handle.cancel() to cancel the timer without dropping the handle.

Timers do not repeat. Every scheduled timer will be executed at most once.

Async support

RunLoop can be used as future executor:

RunLoop::current().spawn(async move ||{
    RunLoop::current().wait(Duration::from_secs(10)).await;
    println("After 10 second delay");
});

// or use crate::spawn variant:

spawn(async move ||{
    RunLoop::current().wait(Duration::from_secs(10)).await;
    println("After 10 second delay");
});

Because futures are executed on single thread to which the RunLoop belongs, they do not need to be Send.

What exactly is main tread?

This slightly varies per platform.