When I try to trigger an asynchronous task in a c callback function using a global handle's lock, what should I do

[Linruanyu]

static GLOBAL_WS_SENDER: Lazy<Arc<Mutex<Option<futures_util::stream::SplitSink<WebSocketStream<TcpStream>, Message>>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(None))
});
static GLOBAL_RUNTIME_HANDLE: Lazy<Arc<Mutex<Option<Handle>>>> = Lazy::new(|| {
    Arc::new(Mutex::new(None))
});
async fn main() {
  
    let addr = "127.0.0.1:9000";
    let listener = TcpListener::bind(addr).await.expect("Failed to bind");
    println!("WebSocket server running on: ws://{}", addr);
    while let Ok((stream, _)) = listener.accept().await {
        tokio::spawn(handle_connection(stream));
    }
    let handle = tokio::runtime::Handle::current();
    let mut global_handle_lock = GLOBAL_RUNTIME_HANDLE.lock().await;
    *global_handle_lock = Some(handle.clone());

}
extern "C"  fn my_cbf_stm(_l_data: *mut c_void,_l_paramm: *mut c_void) -> c_int{
    let frame_header = unsafe { &*(_l_data as *const Frame) };
    let data_size = (frame_header.width as usize) * (frame_header.height as usize);
    let data_ptr = unsafe { (_l_data.add(std::mem::size_of::<Frame>()) as *const u8) };
    let index_data = unsafe { slice::from_raw_parts(data_ptr, data_size) };
    let mut img: RgbImage = ImageBuffer::new(frame_header.width as u32, frame_header.height as u32);
    for (i, &index) in index_data.iter().enumerate() {
        let x = (i % frame_header.width as usize) as u32;
        let y = (i / frame_header.width as usize) as u32;
        let color = COLOR_PALETTE[index as usize];
        img.put_pixel(x, y, image::Rgb([color.0, color.1, color.2]));
    }
    let base64_data = encode_image_to_base64(img);
    let handle = GLOBAL_RUNTIME_HANDLE.lock().block_on().unwrap();
    if let Some(handle) = handle.as_ref() {
        handle.spawn(async {
            send_global_message(base64_data).await;
        });
    } else {
        eprintln!("Tokio runtime handle is not available.");
    }
0 
}
async fn send_global_message(message: String) {
    let sender = GLOBAL_WS_SENDER.clone();
    let mut lock = sender.lock().await;
    if let Some(ref mut write) = *lock {
        if let Err(e) = write.send(Message::Text(message)).await {
            eprintln!("Error sending global message: {}", e);
        }
    } else {
        eprintln!("WebSocket sender not available.");
    }
}