Rust中如何处理impl方法的静态回调？（rdev库场景）

我使用rdev库获取用户键盘输入，创建了InputManager结构体，其listen方法代码如下：

use rdev;

struct InputManager {}

impl InputManager {
    pub fn new() -> Self {
        InputManager {}
    }

    fn callback(&mut self, event: rdev::Event) {
        println!("My callback {:?}", event);
        match event.name {
            Some(string) => println!("User wrote {:?}", string),
            None => (),
        }
    }

    pub fn listen(&mut self) -> Result<(), ()> {
        match rdev::listen(|event: rdev::Event| self.callback(event)) {
            Ok(_) => Ok(()),
            Err(_) => Err(()),
        };
        Ok(())
    }
}

fn main() {
    let mut input_manager = InputManager::new();
    input_manager.listen();
}

运行时出现错误，提示rdev::listen要求静态回调：

--> src/main.rs:19:15
   |
18 |     pub fn listen(&mut self) -> Result<(), ()> {
   |                   ---------
   |                   |
   |                   `self` is a reference that is only valid in the method body
   |                   let's call the lifetime of this reference `'1`
19 |         match rdev::listen(|event: rdev::Event| self.callback(event)) {
   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |               |
   |               `self` escapes the method body here
   |               argument requires that `'1` must outlive `'static`

请问如何在保留回调方法在结构体内部的前提下修复该问题？

问题核心是rdev::listen要求传入的回调闭包必须拥有'static生命周期，但原代码中&mut self的生命周期仅局限于listen方法体内，无法满足这个要求。以下是两种可行的修复方案：

方案一：使用全局静态变量 + 互斥锁 #

适合单实例场景，通过OnceLock保证全局实例仅初始化一次，Mutex保证线程安全（rdev的回调运行在后台线程）：

use rdev;
use std::sync::{Mutex, OnceLock};

struct InputManager {}

// 全局静态变量存储InputManager实例
static INPUT_MANAGER: OnceLock<Mutex<InputManager>> = OnceLock::new();

impl InputManager {
    pub fn new() -> Self {
        InputManager {}
    }

    fn callback(&mut self, event: rdev::Event) {
        println!("My callback {:?}", event);
        match event.name {
            Some(string) => println!("User wrote {:?}", string),
            None => (),
        }
    }

    pub fn listen() -> Result<(), ()> {
        // 初始化全局实例，失败则返回错误
        INPUT_MANAGER.set(Mutex::new(Self::new())).map_err(|_| ())?;
        
        // 回调中获取全局实例并调用内部方法
        match rdev::listen(|event| {
            if let Some(manager) = INPUT_MANAGER.get() {
                if let Ok(mut inner) = manager.lock() {
                    inner.callback(event);
                }
            }
        }) {
            Ok(_) => Ok(()),
            Err(_) => Err(()),
        }
    }
}

fn main() {
    InputManager::listen();
}

方案二：使用Arc包装实例 #

将结构体实例包装在Arc<Mutex>中，通过克隆Arc让闭包持有实例的所有权，满足'static生命周期要求：

use rdev;
use std::sync::{Arc, Mutex};

struct InputManager {}

impl InputManager {
    pub fn new() -> Self {
        InputManager {}
    }

    fn callback(&mut self, event: rdev::Event) {
        println!("My callback {:?}", event);
        match event.name {
            Some(string) => println!("User wrote {:?}", string),
            None => (),
        }
    }

    pub fn listen(self) -> Result<(), ()> {
        let manager = Arc::new(Mutex::new(self));
        // 克隆Arc到闭包中，保证闭包拥有'static生命周期
        let cloned_manager = Arc::clone(&manager);
        
        match rdev::listen(move |event| {
            if let Ok(mut inner) = cloned_manager.lock() {
                inner.callback(event);
            }
        }) {
            Ok(_) => Ok(()),
            Err(_) => Err(()),
        }
    }
}

fn main() {
    let input_manager = InputManager::new();
    input_manager.listen();
}

方案说明 #

• 方案一适合全局唯一的输入管理器场景，无需传递实例；
• 方案二更灵活，支持多实例（如果需要），通过Arc的引用计数管理实例生命周期，Mutex确保多线程下的安全访问。

内容的提问来源于stack exchange，提问作者fenhax