问如何按生锈的‘`enigo`’键？

EN

use anyhow::Result;
use delay_timer::prelude::*;
use enigo::*;
use serde_json::{Result as SResult, Value};
use smol::Timer;
use std::fs::File;
use std::io::BufReader;
use std::thread;
use std::time::Duration;

fn main() -> Result<()> {
    let delay_timer = DelayTimerBuilder::default().build();
    // Create the task
    // A chain of task instances.
    let task_instance_chain = delay_timer
        .insert_task(build_task_async_print().unwrap())
        .unwrap();

    // Get the running instance of task 1.
    let task_instance = task_instance_chain.next_with_wait().unwrap();

    // This while loop avoids removing the task before it completes
    while task_instance.get_state() != delay_timer::prelude::instance::COMPLETED {}

    // Remove task which id is 1.
    delay_timer.remove_task(1).unwrap();
    Ok(())
}

fn build_task_async_print() -> Result<Task, TaskError> {
    let mut task_builder = TaskBuilder::default();

    let body = create_async_fn_body!({
        //Here is my code start
        let json_data = get_json().unwrap();

        for element in json_data.as_array().unwrap().iter() {
            Timer::after(Duration::from_millis(element[0].as_f64().unwrap() as u64)).await;
            println!("the value is: {}", element[0]);

            //How to complete the code that uses enigo to press the corresponding keys?
            let mut enigo = Enigo::new();
            enigo.key_down(Key::Layout(((element[2].as_u64().unwrap() + 96) as u8) as char));
            thread::sleep(Duration::from_millis(element[1].as_f64().unwrap() as u64));
            enigo.key_up(Key::Layout(((element[2].as_u64().unwrap() + 96) as u8) as char));
        }
        //Here is my code end
    });

    // Build the task and assign 1 to it
    task_builder.set_task_id(1).spawn(body)
}

//Get json data from json file
fn get_json() -> SResult<Value> {
    let file = File::open("test.json").expect("file should open read only");
    let reader = BufReader::new(file);
    let mut v: Value = serde_json::from_reader(reader)?;
    Ok(v.take())
}

[
    {
        "startTime": 1000,
        "duration": 800,
        "key": "a"
    },
    {
        "startTime": 1500,
        "duration": 0,
        "key": "b"
    },
    {
        "startTime": 1600,
        "duration": 0,
        "key": "c"
    },
    {
        "startTime": 2500,
        "duration": 300,
        "key": "d"
    }
]

use anyhow::Result;
use delay_timer::prelude::*;
use enigo::*;
use serde::Deserialize;
use smol::Timer;
use std::thread;
use std::time::Duration;

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct EnigoCommand {
    pub start_time: u64,
    pub duration: u64,
    pub key: char
}

fn main() -> Result<()> {
    let delay_timer = DelayTimerBuilder::default().build();

    let task_instance_chain = delay_timer
        .insert_task(build_task_async_print().unwrap())
        .unwrap();
    let task_instance = task_instance_chain.next_with_wait().unwrap();

    while task_instance.get_state() != delay_timer::prelude::instance::COMPLETED {}

    delay_timer.remove_task(1).unwrap();
    Ok(())
}

fn build_task_async_print() -> Result<Task, TaskError> {
    let mut task_builder = TaskBuilder::default();

    let body = create_async_fn_body!({
        let commands = get_commands().expect("Failed to read commands from json file.");

        for command in commands.iter() {
            Timer::after(Duration::from_millis(command.start_time)).await;

            let mut enigo = Enigo::new();
            enigo.key_down(Key::Layout(command.key));
            thread::sleep(Duration::from_millis(command.duration));
            enigo.key_up(Key::Layout(command.key));
        }
    });
    task_builder.set_task_id(1).spawn(body)
}

fn get_commands() -> Result<Vec<EnigoCommand>, Box<dyn std::error::Error>> {
    let file = std::fs::read_to_string("test.json")?;
    let commands: Vec<EnigoCommand> = serde_json::from_str(file.as_str())?;
    Ok(commands)
}

[dependencies]
delay_timer = "0.10.1"
enigo = "0.0.14"
serde={version = "1.0", features = ["derive"] }
serde_json = "1.0"
anyhow = "1.0.51"
smol = "1.2.5"