Skip to main content

Crate radb

Crate radb 

Source
Expand description

§ADB Utils - Android Debug Bridge Utilities for Rust

A comprehensive Rust library for interacting with Android devices through ADB (Android Debug Bridge). This library provides both synchronous and asynchronous interfaces for device management, file operations, shell command execution, and more.

§Features

  • Dual API Support: Both blocking and async/await interfaces
  • Device Management: Connect, disconnect, and manage multiple devices
  • File Operations: Push, pull, list, and manipulate files on devices
  • Shell Commands: Execute shell commands with streaming support
  • Screen Operations: Screenshots, input simulation, and screen control
  • App Management: Install, uninstall, start, and stop applications
  • Network Operations: Port forwarding, reverse forwarding, WiFi control, and network information
  • System Information: Device properties, Android version, hardware info
  • Logging: Logcat streaming and filtering

§Quick Start

§Blocking API

use radb::prelude::*;

fn main() -> AdbResult<()> {
    // Connect to ADB server
    let mut client = AdbClient::connect("127.0.0.1:5037")?;
     
    // Get device list
    let devices = client.list_devices()?;
    let mut device = devices.into_iter().next().unwrap();
     
    // Execute shell command
    let result = device.shell(["echo", "Hello, ADB!"])?;
    println!("Output: {}", result);
     
    // Take screenshot
    let screenshot = device.screenshot()?;
    println!("Screenshot: {}x{}", screenshot.width(), screenshot.height());

    Ok(())
}

§Async API

use radb::prelude::*;
use radb::AdbResult;
#[tokio::main]
async fn main() -> AdbResult<()> {
    // Connect to ADB server
    let mut client = AdbClient::connect("127.0.0.1:5037").await?;
     
    // Get device list
    let devices = client.list_devices().await?;
    let mut device = devices.into_iter().next().unwrap();
     
    // Execute shell command
    let result = device.shell(["echo", "Hello, ADB!"]).await?;
    println!("Output: {}", result);
     
    // Stream logcat
    let mut logcat = Box::pin(device.logcat(true, None).await?);
    while let Some(line) = logcat.as_mut().next().await {
        println!("Log: {}", line?);
    }

    Ok(())
}

§Feature Flags

  • blocking: Enable blocking/synchronous API (default)
  • tokio_async: Enable async/await API with Tokio runtime

blocking and tokio_async share command construction, response parsing, and ADB sync frame handling. The runtime-specific layers only handle connection setup, IO, and await adaptation.

§Error Handling

The library uses a comprehensive error system with specific error types:

use radb::prelude::*;

let result: AdbResult<String> = Err(AdbError::command_failed(
    "shell invalid_command",
    "not found",
));

match result {
    Ok(output) => println!("Success: {}", output),
    Err(AdbError::CommandFailed { command, reason }) => {
        eprintln!("Command '{}' failed: {}", command, reason);
    }
    Err(AdbError::DeviceNotFound { serial }) => {
        eprintln!("Device '{}' not found", serial);
    }
    Err(e) => eprintln!("Other error: {}", e),
}

Re-exports§

pub use client::AdbClient;
pub use client::AdbDevice;
pub use errors::AdbError;
pub use errors::AdbResult;
pub use anyhow;
pub use log;

Modules§

adb
Main ADB namespace with all core functionality
beans
blocking
Blocking/synchronous API
builder
Builder patterns for complex operations
client
errors
info
Library metadata and version information
net
Networking primitives for TCP/UDP communication.
prelude
Common imports for ADB utilities
protocols
sync_protocol
util
Utility functions for ADB operations
utils

Macros§

adb_bail
用于链式错误处理的宏
adb_context
便利宏：将anyhow::Result转换为AdbResult
adb_ensure
用于确保条件的宏
adb_expect_device
adb_shell

Constants§

AUTHORS
DESCRIPTION
VERSION

Type Aliases§

Result