Struct ADB

pub struct ADB {
    pub config: ADBConfig,
    /* private fields */
}

ADB 主结构体

Fields

config: ADBConfig

Implementations

impl ADB

pub fn new(config: Option<ADBConfig>) -> Self

创建新的 ADB 实例

Examples found in repository

examples/screen_capture.rs (line 4)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 截图
    let screenshot_path = "screenshot.png";
    println!("正在截图...");
    adb.take_screenshot_managed(device_id, screenshot_path)?;
    println!("截图已保存到: {}", screenshot_path);

    // 录制屏幕
    let recording_path = "screen_recording.mp4";
    println!("正在录制屏幕 (5 秒)...");
    adb.record_screen_managed(device_id, recording_path, 5, None)?;
    println!("录制已保存到: {}", recording_path);

    Ok(())
}

examples/parallel_operations.rs (line 4)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备", devices.len());

    if devices.len() < 2 {
        println!("此示例需要至少 2 个设备");
        return Ok(());
    }

    // 获取设备 ID 列表
    let device_ids: Vec<&str> = devices.iter().map(|d| d.id.as_str()).collect();

    // 并行执行 shell 命令
    println!("并行执行 shell 命令...");
    let shell_results = adb.parallel_shell(&device_ids, "getprop ro.product.model");

    for (id, result) in &shell_results {
        match result {
            Ok(output) => println!("设备 {}: 型号 = {}", id, output.trim()),
            Err(e) => println!("设备 {}: 错误 = {}", id, e),
        }
    }

    // 检查多个设备是否在线
    println!("检查设备在线状态...");
    let online_devices = adb.filter_online_devices(&device_ids)?;
    println!("在线设备: {}", online_devices.join(", "));

    // 在所有在线设备上获取电池信息
    println!("获取所有设备的电池信息...");
    let battery_results = adb.on_all_online_devices(|device_id| {
        adb.shell(device_id, "dumpsys battery")
    })?;

    for (id, result) in battery_results {
        match result {
            Ok(_) => println!("设备 {}: 已获取电池信息", id),
            Err(e) => println!("设备 {}: 获取电池信息失败 = {}", id, e),
        }
    }

    Ok(())
}

examples/file_transfer.rs (line 5)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

examples/basic_usage.rs (line 8)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

examples/app_management.rs (line 4)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

pub fn adb_path(&self) -> &PathBuf

获取 ADB 路径

impl ADB

pub fn with_retry<F, T>(&self, f: F) -> ADBResult<T>

where F: Fn() -> ADBResult<T>,

使用指数退避策略重试操作

pub fn with_timeout<F, T>(&self, f: F) -> ADBResult<T>

where F: FnOnce() -> ADBResult<T> + Send + 'static, T: Send + 'static,

带超时的操作执行

pub fn check_adb(&self) -> ADBResult<String>

检查 ADB 是否可用并获取版本

Examples found in repository

examples/basic_usage.rs (line 11)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

pub fn list_devices(&self) -> ADBResult<Vec<ADBDevice>>

列出可用设备

Examples found in repository

examples/screen_capture.rs (line 7)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 截图
    let screenshot_path = "screenshot.png";
    println!("正在截图...");
    adb.take_screenshot_managed(device_id, screenshot_path)?;
    println!("截图已保存到: {}", screenshot_path);

    // 录制屏幕
    let recording_path = "screen_recording.mp4";
    println!("正在录制屏幕 (5 秒)...");
    adb.record_screen_managed(device_id, recording_path, 5, None)?;
    println!("录制已保存到: {}", recording_path);

    Ok(())
}

examples/parallel_operations.rs (line 7)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备", devices.len());

    if devices.len() < 2 {
        println!("此示例需要至少 2 个设备");
        return Ok(());
    }

    // 获取设备 ID 列表
    let device_ids: Vec<&str> = devices.iter().map(|d| d.id.as_str()).collect();

    // 并行执行 shell 命令
    println!("并行执行 shell 命令...");
    let shell_results = adb.parallel_shell(&device_ids, "getprop ro.product.model");

    for (id, result) in &shell_results {
        match result {
            Ok(output) => println!("设备 {}: 型号 = {}", id, output.trim()),
            Err(e) => println!("设备 {}: 错误 = {}", id, e),
        }
    }

    // 检查多个设备是否在线
    println!("检查设备在线状态...");
    let online_devices = adb.filter_online_devices(&device_ids)?;
    println!("在线设备: {}", online_devices.join(", "));

    // 在所有在线设备上获取电池信息
    println!("获取所有设备的电池信息...");
    let battery_results = adb.on_all_online_devices(|device_id| {
        adb.shell(device_id, "dumpsys battery")
    })?;

    for (id, result) in battery_results {
        match result {
            Ok(_) => println!("设备 {}: 已获取电池信息", id),
            Err(e) => println!("设备 {}: 获取电池信息失败 = {}", id, e),
        }
    }

    Ok(())
}

examples/file_transfer.rs (line 8)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

examples/basic_usage.rs (line 20)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

examples/app_management.rs (line 7)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

pub fn connect(&self, ip: &str, port: u16) -> ADBResult<()>

连接到远程设备

pub fn disconnect(&self, ip: &str, port: Option<u16>) -> ADBResult<()>

断开与远程设备的连接

pub fn disconnect_all(&self) -> ADBResult<()>

断开所有远程连接

pub fn shell(&self, device_id: &str, command: &str) -> ADBResult<String>

在设备上执行 shell 命令

Examples found in repository

examples/parallel_operations.rs (line 37)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备", devices.len());

    if devices.len() < 2 {
        println!("此示例需要至少 2 个设备");
        return Ok(());
    }

    // 获取设备 ID 列表
    let device_ids: Vec<&str> = devices.iter().map(|d| d.id.as_str()).collect();

    // 并行执行 shell 命令
    println!("并行执行 shell 命令...");
    let shell_results = adb.parallel_shell(&device_ids, "getprop ro.product.model");

    for (id, result) in &shell_results {
        match result {
            Ok(output) => println!("设备 {}: 型号 = {}", id, output.trim()),
            Err(e) => println!("设备 {}: 错误 = {}", id, e),
        }
    }

    // 检查多个设备是否在线
    println!("检查设备在线状态...");
    let online_devices = adb.filter_online_devices(&device_ids)?;
    println!("在线设备: {}", online_devices.join(", "));

    // 在所有在线设备上获取电池信息
    println!("获取所有设备的电池信息...");
    let battery_results = adb.on_all_online_devices(|device_id| {
        adb.shell(device_id, "dumpsys battery")
    })?;

    for (id, result) in battery_results {
        match result {
            Ok(_) => println!("设备 {}: 已获取电池信息", id),
            Err(e) => println!("设备 {}: 获取电池信息失败 = {}", id, e),
        }
    }

    Ok(())
}

pub fn shell_no_wait(&self, device_id: &str, command: &str) -> ADBResult<()>

执行 shell 命令但不等待完成

pub fn find_device_by_ip(&self, ip: &str) -> ADBResult<Option<String>>

通过 IP 地址查找设备

pub fn get_prop(&self, device_id: &str, prop_name: &str) -> ADBResult<String>

获取设备属性

Examples found in repository

examples/basic_usage.rs (line 28)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

pub fn set_prop( &self, device_id: &str, prop_name: &str, prop_value: &str, ) -> ADBResult<()>

设置设备属性

pub fn get_all_props( &self, device_id: &str, ) -> ADBResult<HashMap<String, String>>

获取设备所有属性

pub fn is_device_online(&self, device_id: &str) -> ADBResult<bool>

检查设备是否在线

pub fn restart_server(&self) -> ADBResult<()>

重启 ADB 服务器

pub fn run_command(&self, args: &[&str]) -> ADBResult<String>

执行任意 ADB 命令

pub fn wait_for_device( &self, device_id: &str, timeout_ms: Option<u64>, ) -> ADBResult<bool>

等待设备连接

pub fn get_server_version(&self) -> ADBResult<u32>

获取 ADB 服务器版本

pub fn get_pid_optimized( &self, device_id: &str, package_name: &str, ) -> ADBResult<Option<i32>>

优化版的进程 ID 获取

pub fn is_package_running_optimized( &self, device_id: &str, package_name: &str, ) -> ADBResult<(bool, Option<i32>)>

检查包是否运行的优化版本

impl ADB

pub fn get_package_info( &self, device_id: &str, package_name: &str, ) -> ADBResult<PackageInfo>

获取包信息 (增强版本)

Examples found in repository

examples/basic_usage.rs (line 40)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

examples/app_management.rs (line 25)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

pub fn get_package_info_enhanced( &self, device_id: &str, package_name: &str, ) -> ADBResult<PackageInfo>

获取包信息 (增强版本)

pub fn is_package_running( &self, device_id: &str, package_name: &str, ) -> ADBResult<(bool, Option<i32>)>

检查包是否运行

Examples found in repository

examples/basic_usage.rs (line 48)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

examples/app_management.rs (line 33)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

pub fn get_pid( &self, device_id: &str, package_name: &str, ) -> ADBResult<Option<i32>>

获取进程 ID

pub fn start_app_and_wait( &self, device_id: &str, package_name: &str, activity: Option<&str>, timeout_secs: Option<u64>, ) -> ADBResult<bool>

启动一个应用并等待直到完全启动

pub fn start_app( &self, device_id: &str, package_name: &str, activity: Option<&str>, ) -> ADBResult<bool>

启动应用程序

Examples found in repository

examples/app_management.rs (line 39)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

pub fn stop_app(&self, device_id: &str, package_name: &str) -> ADBResult<()>

强制停止应用程序

Examples found in repository

examples/app_management.rs (line 53)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

pub fn install_app(&self, device_id: &str, apk_path: &str) -> ADBResult<()>

安装应用程序

pub fn uninstall_app( &self, device_id: &str, package_name: &str, ) -> ADBResult<()>

卸载应用程序

pub fn uninstall_app_smart( &self, device_id: &str, package_name: &str, keep_data: bool, ) -> ADBResult<()>

智能卸载应用(清除数据和缓存)

pub fn list_packages( &self, device_id: &str, only_system: bool, only_third_party: bool, ) -> ADBResult<Vec<String>>

获取设备上已安装的应用列表

Examples found in repository

examples/basic_usage.rs (line 32)

fn main() -> ADBResult<()> {
    // 创建配置
    let config = ADBConfig::default();

    // 创建 ADB 实例
    let adb = ADB::new(Some(config));

    // 检查 ADB 是否可用
    match adb.check_adb() {
        Ok(version) => println!("ADB 版本: {}", version),
        Err(e) => {
            eprintln!("ADB 不可用: {}", e);
            return Err(e);
        }
    }

    // 列出连接的设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备:", devices.len());

    for device in &devices {
        println!("  ID: {}, 名称: {}, 状态: {}", device.id, device.name, device.status);

        if device.is_online() {
            // 获取设备属性
            let android_version = adb.get_prop(&device.id, "ro.build.version.release")?;
            println!("  Android 版本: {}", android_version);

            // 列出已安装的第三方应用
            let apps = adb.list_packages(&device.id, false, true)?;
            println!("  已安装的第三方应用数量: {}", apps.len());

            if !apps.is_empty() {
                let app = &apps[0];
                println!("  获取应用信息: {}", app);

                // 获取应用信息
                if let Ok(info) = adb.get_package_info(&device.id, app) {
                    if let Some(version) = &info.version_name {
                        println!("    版本: {}", version);
                    }
                    println!("    权限数量: {}", info.permissions.len());
                }

                // 检查应用是否在运行
                let (running, pid) = adb.is_package_running(&device.id, app)?;
                if running {
                    println!("    应用正在运行, PID: {:?}", pid);
                } else {
                    println!("    应用未运行");
                }
            }
        }
    }

    Ok(())
}

examples/app_management.rs (line 17)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 列出已安装的第三方应用
    let apps = adb.list_packages(device_id, false, true)?;
    println!("已安装的第三方应用数量: {}", apps.len());

    if !apps.is_empty() {
        let app = &apps[0];
        println!("选择应用: {}", app);

        // 获取应用信息
        let info = adb.get_package_info(device_id, app)?;
        println!("应用信息:");
        println!("  版本名称: {:?}", info.version_name);
        println!("  版本代码: {:?}", info.version_code);
        println!("  安装时间: {:?}", info.install_time);
        println!("  权限数量: {}", info.permissions.len());

        // 检查应用是否在运行
        let (running, pid) = adb.is_package_running(device_id, app)?;
        println!("应用运行状态: {}, PID: {:?}", running, pid);

        // 启动应用
        if !running {
            println!("启动应用...");
            let success = adb.start_app(device_id, app, None)?;
            println!("启动结果: {}", success);

            // 等待应用启动
            std::thread::sleep(std::time::Duration::from_secs(2));

            // 再次检查应用是否在运行
            let (running, pid) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}, PID: {:?}", running, pid);
        }

        // 停止应用
        if running {
            println!("停止应用...");
            adb.stop_app(device_id, app)?;

            // 等待应用停止
            std::thread::sleep(std::time::Duration::from_secs(1));

            // 再次检查应用是否在运行
            let (running, _) = adb.is_package_running(device_id, app)?;
            println!("应用运行状态: {}", running);
        }
    }

    Ok(())
}

impl ADB

pub fn pull( &self, device_id: &str, device_path: &str, local_path: &str, options: Option<TransferOptions>, ) -> ADBResult<()>

文件拉取

Examples found in repository

examples/file_transfer.rs (line 48)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

pub fn push( &self, device_id: &str, local_path: &str, device_path: &str, options: Option<TransferOptions>, ) -> ADBResult<()>

文件推送

Examples found in repository

examples/file_transfer.rs (line 33)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

pub fn push_large_file( &self, device_id: &str, local_path: &str, device_path: &str, options: Option<TransferOptions>, ) -> ADBResult<()>

分块推送大文件

pub fn file_exists(&self, device_id: &str, path: &str) -> ADBResult<bool>

文件存在性检查

Examples found in repository

examples/file_transfer.rs (line 36)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

pub fn get_file_size(&self, device_id: &str, path: &str) -> ADBResult<u64>

获取文件/目录大小

Examples found in repository

examples/file_transfer.rs (line 41)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

pub fn create_directory(&self, device_id: &str, path: &str) -> ADBResult<()>

创建目录

pub fn remove_path( &self, device_id: &str, path: &str, recursive: bool, ) -> ADBResult<()>

删除文件或目录

Examples found in repository

examples/file_transfer.rs (line 52)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 推送文件
    let local_file = "test_file.txt";
    let device_path = "/sdcard/test_file.txt";

    // 创建测试文件
    if !Path::new(local_file).exists() {
        std::fs::write(local_file, "这是一个测试文件内容")?;
    }

    // 定义传输选项
    let options = TransferOptions {
        ..Default::default()
    };

    // 推送文件
    println!("推送文件: {} -> {}", local_file, device_path);
    adb.push(device_id, local_file, device_path, Some(options.clone()))?;

    // 检查文件是否存在
    let exists = adb.file_exists(device_id, device_path)?;
    println!("设备上文件存在: {}", exists);

    // 获取文件大小
    if exists {
        let size = adb.get_file_size(device_id, device_path)?;
        println!("文件大小: {} 字节", size);
    }

    // 拉取文件
    let local_output = "downloaded_test_file.txt";
    println!("拉取文件: {} -> {}", device_path, local_output);
    adb.pull(device_id, device_path, local_output, Some(options))?;

    // 删除设备上的文件
    println!("删除设备上的文件: {}", device_path);
    adb.remove_path(device_id, device_path, false)?;

    Ok(())
}

pub fn copy_on_device( &self, device_id: &str, src_path: &str, dst_path: &str, ) -> ADBResult<()>

复制设备上的文件

pub fn move_on_device( &self, device_id: &str, src_path: &str, dst_path: &str, ) -> ADBResult<()>

移动设备上的文件

pub fn list_directory( &self, device_id: &str, path: &str, ) -> ADBResult<Vec<String>>

列出目录内容

pub fn get_file_mtime(&self, device_id: &str, path: &str) -> ADBResult<String>

获取文件最后修改时间

pub fn get_available_space(&self, device_id: &str, path: &str) -> ADBResult<u64>

检查设备上的可用空间

pub fn compute_md5(&self, device_id: &str, path: &str) -> ADBResult<String>

计算文件或目录的 MD5 校验和

pub fn write_text_to_file( &self, device_id: &str, path: &str, content: &str, ) -> ADBResult<()>

写入文本到设备上的文件

pub fn read_text_from_file( &self, device_id: &str, path: &str, ) -> ADBResult<String>

读取设备上文件的文本内容

pub fn compare_files( &self, device_id: &str, local_path: &str, device_path: &str, ) -> ADBResult<bool>

比较本地文件和设备文件是否相同

pub fn sync_directory_to_device( &self, device_id: &str, local_dir: &str, device_dir: &str, exclude_patterns: Option<&[&str]>, ) -> ADBResult<()>

同步目录 (本地到设备)

impl ADB

pub fn enable_remote_debugging( &self, device_id: &str, port: u16, ) -> ADBResult<String>

启用设备远程调试

pub fn get_device_architecture(&self, device_id: &str) -> ADBResult<String>

获取设备架构

pub fn start_frida_server( &self, device_id: &str, frida_server_path: &str, port: u16, server_name: Option<&str>, use_root: Option<bool>, ) -> ADBResult<()>

在设备上启动 Frida 服务器

pub fn stop_frida_server( &self, device_id: &str, server_name: Option<&str>, ) -> ADBResult<()>

停止在设备上运行的 Frida 服务器

pub fn reboot(&self, device_id: &str) -> ADBResult<()>

重启设备到正常模式

pub fn reboot_recovery(&self, device_id: &str) -> ADBResult<()>

重启设备到恢复模式

pub fn reboot_bootloader(&self, device_id: &str) -> ADBResult<()>

重启设备到引导加载程序模式

impl ADB

pub fn take_screenshot( &self, device_id: &str, output_path: &str, ) -> ADBResult<()>

从设备截图

pub fn record_screen( &self, device_id: &str, output_path: &str, duration_secs: u32, size: Option<&str>, ) -> ADBResult<()>

录制设备屏幕

参数

• device_id - 设备 ID
• output_path - 本地输出路径
• duration_secs - 录制时长（秒），最大 180 秒
• size - 可选的分辨率，格式 “widthxheight”

pub fn capture_logs( &self, device_id: &str, tag: Option<&str>, priority: &str, ) -> ADBResult<String>

从设备捕获日志

pub fn watch_logs( &self, device_id: &str, tag: Option<&str>, priority: &str, ) -> ADBResult<()>

实时查看日志（返回立即执行的命令）

pub fn clear_logs(&self, device_id: &str) -> ADBResult<()>

清除日志

impl ADB

pub fn forward( &self, device_id: &str, local_port: u16, device_port: u16, ) -> ADBResult<()>

将本地端口转发到设备端口

pub fn remove_forward(&self, local_port: u16) -> ADBResult<()>

移除端口转发

pub fn remove_all_forwards(&self) -> ADBResult<()>

移除所有端口转发

pub fn list_forwards(&self) -> ADBResult<String>

列出所有端口转发

pub fn reverse( &self, device_id: &str, remote_port: u16, local_port: u16, ) -> ADBResult<()>

反向端口转发（设备到主机）

pub fn remove_reverse(&self, device_id: &str, remote_port: u16) -> ADBResult<()>

移除反向端口转发

pub fn remove_all_reverses(&self, device_id: &str) -> ADBResult<()>

移除所有反向端口转发

impl ADB

pub fn create_resource_manager(&self, device_id: &str) -> ResourceManager

创建资源管理器

pub fn with_resources<F, T>(&self, device_id: &str, f: F) -> ADBResult<T>

where F: FnOnce(&mut ResourceManager) -> ADBResult<T>,

使用资源管理器执行操作

pub fn take_screenshot_managed( &self, device_id: &str, output_path: &str, ) -> ADBResult<()>

优化的截图功能（使用资源管理器）

Examples found in repository

examples/screen_capture.rs (line 19)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 截图
    let screenshot_path = "screenshot.png";
    println!("正在截图...");
    adb.take_screenshot_managed(device_id, screenshot_path)?;
    println!("截图已保存到: {}", screenshot_path);

    // 录制屏幕
    let recording_path = "screen_recording.mp4";
    println!("正在录制屏幕 (5 秒)...");
    adb.record_screen_managed(device_id, recording_path, 5, None)?;
    println!("录制已保存到: {}", recording_path);

    Ok(())
}

pub fn record_screen_managed( &self, device_id: &str, output_path: &str, duration_secs: u32, size: Option<&str>, ) -> ADBResult<()>

优化的屏幕录制功能（使用资源管理器）

Examples found in repository

examples/screen_capture.rs (line 25)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    if devices.is_empty() {
        println!("没有连接的设备");
        return Ok(());
    }

    let device_id = &devices[0].id;
    println!("使用设备: {}", device_id);

    // 截图
    let screenshot_path = "screenshot.png";
    println!("正在截图...");
    adb.take_screenshot_managed(device_id, screenshot_path)?;
    println!("截图已保存到: {}", screenshot_path);

    // 录制屏幕
    let recording_path = "screen_recording.mp4";
    println!("正在录制屏幕 (5 秒)...");
    adb.record_screen_managed(device_id, recording_path, 5, None)?;
    println!("录制已保存到: {}", recording_path);

    Ok(())
}

pub fn with_temp_file<F, T>( &self, device_id: &str, prefix: &str, suffix: &str, f: F, ) -> ADBResult<T>

where F: FnOnce(&str) -> ADBResult<T>,

使用临时文件执行操作

impl ADB

pub fn parallel_shell( &self, device_ids: &[&str], command: &str, ) -> HashMap<String, ADBResult<String>>

在多个设备上并行执行 shell 命令

参数

• device_ids - 设备 ID 列表
• command - 要执行的 shell 命令

返回值

返回一个 HashMap，键为设备 ID，值为命令执行结果

Examples found in repository

examples/parallel_operations.rs (line 20)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备", devices.len());

    if devices.len() < 2 {
        println!("此示例需要至少 2 个设备");
        return Ok(());
    }

    // 获取设备 ID 列表
    let device_ids: Vec<&str> = devices.iter().map(|d| d.id.as_str()).collect();

    // 并行执行 shell 命令
    println!("并行执行 shell 命令...");
    let shell_results = adb.parallel_shell(&device_ids, "getprop ro.product.model");

    for (id, result) in &shell_results {
        match result {
            Ok(output) => println!("设备 {}: 型号 = {}", id, output.trim()),
            Err(e) => println!("设备 {}: 错误 = {}", id, e),
        }
    }

    // 检查多个设备是否在线
    println!("检查设备在线状态...");
    let online_devices = adb.filter_online_devices(&device_ids)?;
    println!("在线设备: {}", online_devices.join(", "));

    // 在所有在线设备上获取电池信息
    println!("获取所有设备的电池信息...");
    let battery_results = adb.on_all_online_devices(|device_id| {
        adb.shell(device_id, "dumpsys battery")
    })?;

    for (id, result) in battery_results {
        match result {
            Ok(_) => println!("设备 {}: 已获取电池信息", id),
            Err(e) => println!("设备 {}: 获取电池信息失败 = {}", id, e),
        }
    }

    Ok(())
}

pub fn parallel_install_app( &self, device_ids: &[&str], apk_path: &str, ) -> HashMap<String, ADBResult<()>>

在多个设备上并行安装应用

参数

• device_ids - 设备 ID 列表
• apk_path - APK 文件路径

返回值

返回一个 HashMap，键为设备 ID，值为安装结果

pub fn parallel_uninstall_app( &self, device_ids: &[&str], package_name: &str, ) -> HashMap<String, ADBResult<()>>

在多个设备上并行卸载应用

参数

• device_ids - 设备 ID 列表
• package_name - 包名

返回值

返回一个 HashMap，键为设备 ID，值为卸载结果

pub fn parallel_start_app( &self, device_ids: &[&str], package_name: &str, activity: Option<&str>, ) -> HashMap<String, ADBResult<bool>>

在多个设备上并行启动应用

参数

• device_ids - 设备 ID 列表
• package_name - 包名
• activity - 可选的 Activity 名称

返回值

返回一个 HashMap，键为设备 ID，值为启动结果

pub fn parallel_stop_app( &self, device_ids: &[&str], package_name: &str, ) -> HashMap<String, ADBResult<()>>

在多个设备上并行停止应用

参数

• device_ids - 设备 ID 列表
• package_name - 包名

返回值

返回一个 HashMap，键为设备 ID，值为停止结果

pub fn parallel_get_package_info( &self, device_ids: &[&str], package_name: &str, ) -> HashMap<String, ADBResult<PackageInfo>>

在多个设备上并行获取包信息

参数

• device_ids - 设备 ID 列表
• package_name - 包名

返回值

返回一个 HashMap，键为设备 ID，值为包信息

pub fn parallel_push( &self, device_ids: &[&str], local_path: &str, device_path: &str, ) -> HashMap<String, ADBResult<()>>

在多个设备上并行执行推送文件操作

参数

• device_ids - 设备 ID 列表
• local_path - 本地文件路径
• device_path - 设备上的目标路径

返回值

返回一个 HashMap，键为设备 ID，值为推送结果

pub fn parallel_pull( &self, operations: &[(String, String, String)], ) -> HashMap<String, ADBResult<()>>

在多个设备上并行执行拉取文件操作

参数

• operations - 设备 ID 和文件路径的组合列表，每项包含(设备 ID, 设备文件路径, 本地目标路径)

返回值

返回一个 HashMap，键为设备 ID，值为拉取结果

pub fn filter_online_devices( &self, device_ids: &[&str], ) -> ADBResult<Vec<String>>

检查多个设备是否在线

参数

• device_ids - 设备 ID 列表

返回值

返回在线设备的列表

Examples found in repository

examples/parallel_operations.rs (line 31)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备", devices.len());

    if devices.len() < 2 {
        println!("此示例需要至少 2 个设备");
        return Ok(());
    }

    // 获取设备 ID 列表
    let device_ids: Vec<&str> = devices.iter().map(|d| d.id.as_str()).collect();

    // 并行执行 shell 命令
    println!("并行执行 shell 命令...");
    let shell_results = adb.parallel_shell(&device_ids, "getprop ro.product.model");

    for (id, result) in &shell_results {
        match result {
            Ok(output) => println!("设备 {}: 型号 = {}", id, output.trim()),
            Err(e) => println!("设备 {}: 错误 = {}", id, e),
        }
    }

    // 检查多个设备是否在线
    println!("检查设备在线状态...");
    let online_devices = adb.filter_online_devices(&device_ids)?;
    println!("在线设备: {}", online_devices.join(", "));

    // 在所有在线设备上获取电池信息
    println!("获取所有设备的电池信息...");
    let battery_results = adb.on_all_online_devices(|device_id| {
        adb.shell(device_id, "dumpsys battery")
    })?;

    for (id, result) in battery_results {
        match result {
            Ok(_) => println!("设备 {}: 已获取电池信息", id),
            Err(e) => println!("设备 {}: 获取电池信息失败 = {}", id, e),
        }
    }

    Ok(())
}

pub fn on_all_online_devices<F, T>( &self, operation: F, ) -> ADBResult<HashMap<String, ADBResult<T>>>

where F: Fn(&str) -> ADBResult<T> + Send + Sync, T: Send,

在所有在线设备上执行操作

参数

• operation - 要执行的操作闭包

返回值

返回在线设备的操作结果

Examples found in repository

examples/parallel_operations.rs (lines 36-38)

fn main() -> ADBResult<()> {
    let adb = ADB::new(None);

    // 列出设备
    let devices = adb.list_devices()?;
    println!("发现 {} 个设备", devices.len());

    if devices.len() < 2 {
        println!("此示例需要至少 2 个设备");
        return Ok(());
    }

    // 获取设备 ID 列表
    let device_ids: Vec<&str> = devices.iter().map(|d| d.id.as_str()).collect();

    // 并行执行 shell 命令
    println!("并行执行 shell 命令...");
    let shell_results = adb.parallel_shell(&device_ids, "getprop ro.product.model");

    for (id, result) in &shell_results {
        match result {
            Ok(output) => println!("设备 {}: 型号 = {}", id, output.trim()),
            Err(e) => println!("设备 {}: 错误 = {}", id, e),
        }
    }

    // 检查多个设备是否在线
    println!("检查设备在线状态...");
    let online_devices = adb.filter_online_devices(&device_ids)?;
    println!("在线设备: {}", online_devices.join(", "));

    // 在所有在线设备上获取电池信息
    println!("获取所有设备的电池信息...");
    let battery_results = adb.on_all_online_devices(|device_id| {
        adb.shell(device_id, "dumpsys battery")
    })?;

    for (id, result) in battery_results {
        match result {
            Ok(_) => println!("设备 {}: 已获取电池信息", id),
            Err(e) => println!("设备 {}: 获取电池信息失败 = {}", id, e),
        }
    }

    Ok(())
}

pub fn parallel_commands( &self, device_ids: &[&str], commands: &[&str], ) -> HashMap<String, Vec<ADBResult<String>>>

在所有指定设备上并行执行多个命令

pub fn start_app_on_all_devices( &self, package_name: &str, activity: Option<&str>, ) -> ADBResult<HashMap<String, ADBResult<bool>>>

在所有在线设备上启动同一应用

pub fn stop_app_on_all_devices( &self, package_name: &str, ) -> ADBResult<HashMap<String, ADBResult<()>>>

在所有在线设备上停止同一应用

Trait Implementations

impl Clone for ADB

fn clone(&self) -> ADB

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ADB

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

Formats the value using the given formatter.