Struct Controller 

pub struct Controller { /* private fields */ }

Device controller interface.

Handles interaction with the target device, including:

• Input events (click, swipe, key press)
• Screen capture
• App management (start/stop)
• Connection management

See also: AdbControllerBuilder for advanced ADB configuration.

Implementations

impl Controller

pub fn new_adb( adb_path: &str, address: &str, config: &str, agent_path: Option<&str>, ) -> MaaResult<Self>

Create a new ADB controller for Android device control.

Arguments

• adb_path - Path to the ADB executable
• address - Device address (e.g., “127.0.0.1:5555” or “emulator-5554”)
• config - JSON configuration string for advanced options
• agent_path - Optional path to MaaAgentBinary

Examples found in repository

examples/main.rs (lines 259-264)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn new_win32( hwnd: *mut c_void, screencap_method: MaaWin32ScreencapMethod, mouse_method: MaaWin32InputMethod, keyboard_method: MaaWin32InputMethod, ) -> MaaResult<Self>

Create a new Win32 controller for Windows window control.

pub fn new_playcover(address: &str, uuid: &str) -> MaaResult<Self>

Create a new PlayCover controller for iOS app control on macOS.

pub fn new_custom<T: CustomControllerCallback + 'static>( callback: T, ) -> MaaResult<Self>

Create a custom controller with user-defined callbacks.

pub fn post_click(&self, x: i32, y: i32) -> MaaResult<MaaId>

Post a click action at the specified coordinates.

Examples found in repository

examples/main.rs (line 302)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn post_screencap(&self) -> MaaResult<MaaId>

Post a screenshot capture request.

Examples found in repository

examples/main.rs (line 297)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn post_click_v2( &self, x: i32, y: i32, contact: i32, pressure: i32, ) -> MaaResult<MaaId>

Post a click action with contact and pressure parameters.

Arguments

• x, y - Click coordinates
• contact - Contact/finger index (for multi-touch)
• pressure - Touch pressure (1 = normal)

pub fn post_swipe( &self, x1: i32, y1: i32, x2: i32, y2: i32, duration: i32, ) -> MaaResult<MaaId>

Post a swipe action from one point to another.

Arguments

• x1, y1 - Start coordinates
• x2, y2 - End coordinates
• duration - Swipe duration in milliseconds

pub fn post_click_key(&self, keycode: i32) -> MaaResult<MaaId>

Post a key click action.

Arguments

• keycode - Virtual key code (ADB keycode for Android, VK for Win32)

pub fn post_press(&self, keycode: i32) -> MaaResult<MaaId>

👎Deprecated: Use post_click_key instead

Alias for post_click_key.

pub fn post_input_text(&self, text: &str) -> MaaResult<MaaId>

Post a text input action.

Arguments

• text - Text to input

Examples found in repository

examples/main.rs (line 313)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn post_shell(&self, cmd: &str, timeout: i64) -> MaaResult<MaaId>

Post a shell command execution (ADB only).

Arguments

• cmd - Shell command to execute
• timeout - Timeout in milliseconds

pub fn post_touch_down( &self, contact: i32, x: i32, y: i32, pressure: i32, ) -> MaaResult<MaaId>

Post a touch down event.

Arguments

• contact - Contact/finger index
• x, y - Touch coordinates
• pressure - Touch pressure

pub fn post_touch_move( &self, contact: i32, x: i32, y: i32, pressure: i32, ) -> MaaResult<MaaId>

Post a touch move event.

Arguments

• contact - Contact/finger index
• x, y - New touch coordinates
• pressure - Touch pressure

pub fn post_touch_up(&self, contact: i32) -> MaaResult<MaaId>

Post a touch up event.

Arguments

• contact - Contact/finger index to release

pub fn raw(&self) -> *mut MaaController

Returns the underlying raw controller handle.

pub fn post_connection(&self) -> MaaResult<MaaId>

Post a connection request to the device.

Returns a job ID that can be used with wait to block until connected.

Examples found in repository

examples/main.rs (line 292)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn connected(&self) -> bool

Returns true if the controller is connected to the device.

Examples found in repository

examples/main.rs (line 294)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn uuid(&self) -> MaaResult<String>

Gets the unique identifier (UUID) of the connected device.

pub fn resolution(&self) -> MaaResult<(i32, i32)>

Gets the device screen resolution as (width, height).

Examples found in repository

examples/main.rs (line 318)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn post_swipe_v2( &self, x1: i32, y1: i32, x2: i32, y2: i32, duration: i32, contact: i32, pressure: i32, ) -> MaaResult<MaaId>

Post a swipe action with contact and pressure parameters.

Arguments

• x1, y1 - Start coordinates
• x2, y2 - End coordinates
• duration - Swipe duration in milliseconds
• contact - Contact/finger index
• pressure - Touch pressure

pub fn post_key_down(&self, keycode: i32) -> MaaResult<MaaId>

Post a key down event.

pub fn post_key_up(&self, keycode: i32) -> MaaResult<MaaId>

Post a key up event.

pub fn post_start_app(&self, intent: &str) -> MaaResult<MaaId>

Start an application.

Arguments

• intent - Package name or activity (ADB), app identifier (Win32)

pub fn post_stop_app(&self, intent: &str) -> MaaResult<MaaId>

Stop an application.

Arguments

• intent - Package name (ADB)

pub fn post_scroll(&self, dx: i32, dy: i32) -> MaaResult<MaaId>

Post a scroll action (Win32 only).

Arguments

• dx - Horizontal scroll delta (positive = right)
• dy - Vertical scroll delta (positive = down)

pub fn cached_image(&self) -> MaaResult<MaaImageBuffer>

Gets the most recently captured screenshot.

pub fn shell_output(&self) -> MaaResult<String>

Gets the output from the most recent shell command (ADB only).

pub fn status(&self, ctrl_id: MaaId) -> MaaStatus

Gets the status of a controller operation.

pub fn wait(&self, ctrl_id: MaaId) -> MaaStatus

Blocks until a controller operation completes.

Examples found in repository

examples/main.rs (line 293)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== MaaFramework Rust SDK Demo ===\n");

    // -------------------------------------------------------------------------
    // 1. Initialize Toolkit
    // -------------------------------------------------------------------------
    let user_path = "./";
    Toolkit::init_option(user_path, "{}")?;
    println!("[1] Toolkit initialized with user_path: {}", user_path);

    // -------------------------------------------------------------------------
    // 2. Device Discovery
    // -------------------------------------------------------------------------

    // ADB devices
    println!("\n[2] Scanning for ADB devices...");
    let adb_devices = Toolkit::find_adb_devices()?;
    if adb_devices.is_empty() {
        println!("    No ADB device found.");
    } else {
        for device in &adb_devices {
            println!("    Found: {} ({})", device.name, device.address);
        }
    }

    // Win32 windows (Windows only)
    #[cfg(target_os = "windows")]
    {
        println!("\n    Scanning for desktop windows...");
        match Toolkit::find_desktop_windows() {
            Ok(windows) => {
                if windows.is_empty() {
                    println!("    No window found.");
                } else {
                    for (i, win) in windows.iter().take(3).enumerate() {
                        println!("    [{}] hwnd={:?}, class={}", i, win.hwnd, win.class_name);
                    }
                    if windows.len() > 3 {
                        println!("    ... and {} more", windows.len() - 3);
                    }
                }
            }
            Err(e) => println!("    Failed to find windows: {}", e),
        }
    }

    // -------------------------------------------------------------------------
    // 3. Create Controller (choose one)
    // -------------------------------------------------------------------------
    println!("\n[3] Creating controller...");

    let controller: Option<Controller>;

    // Option A: ADB Controller
    #[cfg(feature = "adb")]
    if let Some(device) = adb_devices.first() {
        println!("    Using ADB device: {}", device.name);
        let config_str = serde_json::to_string(&device.config)?;
        controller = Some(Controller::new_adb(
            device.adb_path.to_str().unwrap(),
            &device.address,
            &config_str,
            None,
        )?);
    } else {
        controller = None;
    }

    #[cfg(not(feature = "adb"))]
    {
        controller = None;
    }

    // Option B: Win32 Controller (uncomment to use)
    // #[cfg(target_os = "windows")]
    // if let Some(window) = windows.first() {
    //     controller = Some(Controller::new_win32(
    //         window.hwnd as isize,
    //         common::Win32ScreencapMethod::FramePool as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //         common::Win32InputMethod::PostMessage as i32,
    //     )?);
    // }

    // -------------------------------------------------------------------------
    // 4. Controller Operations
    // -------------------------------------------------------------------------
    if let Some(ref ctrl) = controller {
        println!("\n[4] Controller operations...");

        // Connect
        let conn_id = ctrl.post_connection()?;
        ctrl.wait(conn_id);
        println!("    Connected: {}", ctrl.connected());

        // Screenshot
        let cap_id = ctrl.post_screencap()?;
        ctrl.wait(cap_id);
        println!("    Screenshot captured");

        // Click (sync)
        let click_id = ctrl.post_click(114, 514)?;
        ctrl.wait(click_id);
        println!("    Clicked at (114, 514)");

        // Click (async) - post now, wait later
        let click_id2 = ctrl.post_click(514, 114)?;
        // ... do other work here ...
        ctrl.wait(click_id2);
        println!("    Async click completed");

        // Input text
        let input_id = ctrl.post_input_text("Hello MAA!")?;
        ctrl.wait(input_id);
        println!("    Text input sent");

        // Get resolution
        if let Ok((w, h)) = ctrl.resolution() {
            println!("    Resolution: {}x{}", w, h);
        }
    } else {
        println!("\n[4] Skipping controller operations (no device available)");
    }

    // -------------------------------------------------------------------------
    // 5. Resource Setup
    // -------------------------------------------------------------------------
    println!("\n[5] Setting up resource...");

    let resource = Resource::new()?;

    // Register custom recognition and action
    resource.register_custom_recognition("MyRecognition", Box::new(MyRecognition))?;
    resource.register_custom_action("MyAction", Box::new(MyAction))?;
    println!("    Registered: MyRecognition, MyAction");

    // List registered components
    let reco_list = resource.custom_recognition_list()?;
    let action_list = resource.custom_action_list()?;
    println!("    Recognition list: {:?}", reco_list);
    println!("    Action list: {:?}", action_list);

    // Load resource bundle
    let resource_path = "sample/resource";
    println!("    Loading resource from: {}", resource_path);
    match resource.post_bundle(resource_path) {
        Ok(job) => {
            let status = job.wait();
            println!("    Load status: {:?}", status);
        }
        Err(e) => println!("    Load failed: {} (OK for demo)", e),
    }

    // Add event sink
    resource.add_sink(|msg, details| {
        println!(
            "    [ResourceEvent] {}: {}",
            msg,
            &details[..details.len().min(50)]
        );
    })?;

    // -------------------------------------------------------------------------
    // 6. Tasker Setup and Execution
    // -------------------------------------------------------------------------
    println!("\n[6] Setting up tasker...");

    let tasker = Tasker::new()?;

    // Bind resource
    tasker.bind_resource(&resource)?;
    println!("    Resource bound");

    // Bind controller (if available)
    if let Some(ref ctrl) = controller {
        tasker.bind_controller(ctrl)?;
        println!("    Controller bound");
    }

    // Check initialization
    if tasker.inited() {
        println!("    Tasker initialized successfully!");

        // Add event sink
        tasker.add_sink(|msg, details| {
            println!(
                "    [TaskerEvent] {}: {}",
                msg,
                &details[..details.len().min(50)]
            );
        })?;

        // Execute task with pipeline override
        let pipeline_override = r#"{
            "MyCustomEntry": {
                "recognition": "Custom",
                "custom_recognition": "MyRecognition",
                "action": "Custom",
                "custom_action": "MyAction"
            }
        }"#;

        println!("\n[7] Executing task...");
        match tasker.post_task("MyCustomEntry", pipeline_override) {
            Ok(job) => {
                let status = job.wait();
                println!("    Task status: {:?}", status);

                if let Ok(Some(detail)) = job.get(false) {
                    println!("    Entry: {}", detail.entry);
                    println!("    Nodes executed: {}", detail.nodes.len());

                    for node_opt in detail.nodes {
                        if let Some(node) = node_opt {
                            if let Some(reco) = node.recognition {
                                println!(
                                    "      Node: {}, Algo: {:?}",
                                    node.node_name, reco.algorithm
                                );
                            }
                        }
                    }
                }
            }
            Err(e) => println!("    Task failed: {}", e),
        }
    } else {
        println!("    Tasker not fully initialized (missing controller binding)");
    }

    // -------------------------------------------------------------------------
    // 8. Cleanup
    // -------------------------------------------------------------------------
    println!("\n[8] Demo completed!");
    println!("    - Toolkit, Controller, Resource, Tasker all demonstrated");
    println!("    - Custom Recognition and Action registered and explained");
    println!("    - Context API documented in custom component implementations");

    Ok(())
}

pub fn set_screenshot_target_long_side(&self, long_side: i32) -> MaaResult<()>

Sets the target long side for screenshot scaling.

pub fn set_screenshot_target_short_side(&self, short_side: i32) -> MaaResult<()>

Sets the target short side for screenshot scaling.

pub fn set_screenshot_use_raw_size(&self, enable: bool) -> MaaResult<()>

Sets whether to use raw (unscaled) screenshot resolution.

pub fn new_dbg( read_path: &str, write_path: &str, dbg_type: MaaDbgControllerType, config: &str, ) -> MaaResult<Self>

pub fn new_gamepad( hwnd: *mut c_void, gamepad_type: GamepadType, screencap_method: Win32ScreencapMethod, ) -> MaaResult<Self>

Create a virtual gamepad controller (Windows only).

pub fn add_sink<F>(&self, callback: F) -> MaaResult<MaaSinkId>

where F: Fn(&str, &str) + Send + Sync + 'static,

Returns sink_id for later removal. Callback lifetime managed by caller.

pub fn add_event_sink(&self, sink: Box<dyn EventSink>) -> MaaResult<MaaSinkId>

Register a strongly-typed event sink.

This method registers an implementation of the EventSink trait to receive structured notifications from this controller.

Arguments

• sink - The event sink implementation (must be boxed).

Returns

A MaaSinkId which can be used to manually remove the sink later via remove_sink. The sink will be automatically unregistered and dropped when the Controller is dropped.

pub fn remove_sink(&self, sink_id: MaaSinkId)

pub fn clear_sinks(&self)

Trait Implementations

impl Clone for Controller

fn clone(&self) -> Controller

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Controller

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Send for Controller

impl Sync for Controller