How to Handle Callbacks Across FFI in Rust

Handle callbacks across FFI in Rust by defining a extern function pointer type in Rust, passing it to the foreign code, and invoking it via unsafe blocks while ensuring the foreign side respects Rust's calling conventions.

// Define the callback type matching the foreign signature
pub type CallbackFn = unsafe extern "C" fn(arg1: i32, arg2: i32) -> i32;

// Define the Rust callback implementation
unsafe extern "C" fn my_callback(a: i32, b: i32) -> i32 {
    a + b
}

// Pass the callback to foreign code (example)
extern "C" {
    fn foreign_function(callback: CallbackFn);
}

pub fn call_foreign() {
    unsafe {
        foreign_function(my_callback);
    }
}

Handling callbacks across FFI in Rust lets code written in another language (like C) call back into your Rust functions. You define a specific function shape that both languages agree on, write your Rust function to match that shape, and then pass it safely to the other language. Think of it like handing a specific type of key to a neighbor so they can unlock a door in your house when they need to.