I found a way to let it works, put the fn keycode_to_string into main thead:

clone enigo to your libs, need to change code, I use tag v0.3.0
add dispatch to enigo Cargo.toml

[target.'cfg(target_os = "macos")'.dependencies]
dispatch = "0.2.0"

add a fn to src/macos/macos_impl.rs

//add a fn let the code run in main thread, because the TIS* fns can't run in sub thread.
fn run_on_main_thread_blocking<F, R>(f: F) -> R
where
    F: FnOnce() -> R + Send + 'static,
    R: Send + 'static,
{
    let pair = Arc::new((Mutex::new(None), Condvar::new()));
    let pair_clone = pair.clone();

    Queue::main().exec_async(move || {
        let result = f();
        let (lock, cvar) = &*pair_clone;
        *lock.lock().unwrap() = Some(result);
        cvar.notify_one();
    });

    // Blocking wait for the main thread to complete execution.
    let (lock, cvar) = &*pair;
    let mut guard = lock.lock().unwrap();
    while guard.is_none() {
        guard = cvar.wait(guard).unwrap();
    }
    guard.take().unwrap()
}

put the keycode_to_string calling into run_on_main_thread_blocking

// line: 985 
fn get_layoutdependent_keycode(string: &str) -> CGKeyCode {
    let mut pressed_keycode = 0;

    // loop through every keycode (0 - 127)
    for keycode in 0..128 {
        // no modifier

        if let Ok(key_string) =
            run_on_main_thread_blocking(move || keycode_to_string(keycode, 0x100)) // here change
        {
            // debug!("{:?}", string);
            if string == key_string {
                pressed_keycode = keycode;
            }
        }

        // shift modifier
        if let Ok(key_string) =
            run_on_main_thread_blocking(move || keycode_to_string(keycode, 0x20102)) //here change
        {
            // debug!("{:?}", string);
            if string == key_string {
                pressed_keycode = keycode;
            }
        }

        // alt modifier
        // if let Some(string) = keycode_to_string(keycode, 0x80120) {
        //     debug!("{:?}", string);
        // }
        // alt + shift modifier
        // if let Some(string) = keycode_to_string(keycode, 0xa0122) {
        //     debug!("{:?}", string);
        // }
    }

    pressed_keycode
}

use it in your own project like this:

use enigo::{
    agent::{Agent, Token},
    Axis::{Horizontal, Vertical},
    Button,
    Coordinate::{Abs, Rel},
    Direction::{Click, Press, Release},
    Enigo, Key, Keyboard, Settings,
};
use std::sync::RwLock;
use std::{sync::LazyLock, thread};
use crossbeam_channel::{unbounded, Sender};

static INPUT_SENDER: LazyLock<Sender<Token>> = LazyLock::new(|| {
    let (tx, rv) = unbounded::<Token>();
    thread::spawn(move || {
        let mut enigo = Enigo::new(&Settings::default()).unwrap(); //only new once
        while let Ok(token) = rv.recv() {
            dbg!(&token);
            match enigo.execute(&token) {
                Ok(_) => {}
                Err(error) => {
                    dbg!(error);
                }
            }
            dbg!("done");
        }
    });
    tx
});

fn click_key(key: Key) {
        let token = Token::Key(key, Click);
        INPUT_SENDER.send(token);
}

A temporary way to run enigo in sub-thread on macos, like build a app of tauri or etc... #436

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions