Make it work as a runner

Author: bbqsrc

example/basic/.cargo/config.toml

@@ -0,0 +1,2 @@
+[target.aarch64-linux-android]
+runner = "cargo ndk-runner"

example/basic/Cargo.toml

@@ -2,7 +2,7 @@
 name = "example"
 version = "0.1.0"
 authors = ["Brendan Molloy <brendan@bbqsrc.net>"]
-edition = "2018"
+edition = "2024"
 
 [lib]
 # This must contain at least cdylib for Android libraries to be generated.

example/basic/src/lib.rs

@@ -1,4 +1,10 @@
-#[no_mangle]
+/// A simple function to demonstrate a basic Rust library for Android.
+///
+/// ```
+/// use example::example;
+/// example();
+/// ```
+#[unsafe(no_mangle)]
 pub extern "C" fn example() {
     println!("Hello Android!");
 }
@@ -11,4 +17,4 @@ fn test_example() {
 #[test]
 fn failing_test() {
     assert_eq!(1, 2, "This test is supposed to fail");
-}
+}

src/bin/cargo-ndk-runner.rs

@@ -0,0 +1,13 @@
+use std::env;
+use std::process::exit;
+
+fn main() -> anyhow::Result<()> {
+    if env::var("CARGO").is_err() {
+        eprintln!("This binary may only be called via `cargo ndk-runner`.");
+        exit(1);
+    }
+
+    let args = std::env::args().collect::<Vec<_>>();
+
+    cargo_ndk::cli::runner::run(args)
+}

src/cargo.rs

@@ -96,11 +96,16 @@ pub(crate) fn build_env(
     clang_target: &str,
     link_builtins: bool,
 ) -> BTreeMap<String, OsString> {
-    let self_path = dunce::canonicalize(env::args().next().unwrap())
+    let cargo_ndk_path = dunce::canonicalize(env::args().next().unwrap())
         .expect("Failed to canonicalize absolute path to cargo-ndk")
         .parent()
         .unwrap()
         .join("cargo-ndk");
+    let cargo_ndk_runner_path = dunce::canonicalize(env::args().next().unwrap())
+        .expect("Failed to canonicalize absolute path to cargo-ndk-runner")
+        .parent()
+        .unwrap()
+        .join("cargo-ndk-runner");
 
     // Environment variables for the `cc` crate
     let (cc_key, _) = cc_env("CC", triple);
@@ -113,6 +118,7 @@ pub(crate) fn build_env(
     // Environment variables for cargo
     let cargo_ar_key = cargo_env_target_cfg(triple, "ar");
     let cargo_linker_key = cargo_env_target_cfg(triple, "linker");
+    let cargo_runner_key = cargo_env_target_cfg(triple, "runner");
     let bindgen_clang_args_key = format!("BINDGEN_EXTRA_CLANG_ARGS_{}", &triple.replace('-', "_"));
 
     let target_cc = ndk_home.join(ndk_tool(ARCH, "clang"));
@@ -133,7 +139,6 @@ pub(crate) fn build_env(
         .join(cargo_ndk_sysroot_target);
     let target_ar = ndk_home.join(ndk_tool(ARCH, "llvm-ar"));
     let target_ranlib = ndk_home.join(ndk_tool(ARCH, "llvm-ranlib"));
-    let target_linker = self_path;
 
     let extra_include = format!(
         "{}/usr/include/{}",
@@ -149,7 +154,8 @@ pub(crate) fn build_env(
         (ar_key, target_ar.clone().into()),
         (ranlib_key, target_ranlib.into_os_string()),
         (cargo_ar_key, target_ar.into_os_string()),
-        (cargo_linker_key, target_linker.into_os_string()),
+        (cargo_linker_key, cargo_ndk_path.into_os_string()),
+        (cargo_runner_key, cargo_ndk_runner_path.into_os_string()),
         (
             CARGO_NDK_SYSROOT_PATH_KEY.to_string(),
             cargo_ndk_sysroot_path.clone().into_os_string(),

src/cli/mod.rs

@@ -1,4 +1,5 @@
 pub mod env;
+pub mod runner;
 pub mod test;
 
 use std::{

src/cli/runner.rs

@@ -0,0 +1,136 @@
+use std::{path::PathBuf, process::Command};
+
+use clap::Parser;
+
+use crate::{
+    cli::{CommandExt as _, derive_adb_path},
+    shell::{Shell, Verbosity},
+};
+
+#[derive(Debug, Parser, Clone)]
+struct RunnerArgs {
+    #[arg(long, env = "CARGO_NDK_ADB_SERIAL")]
+    /// "Serial number" of the device to use for testing (e.g. "emulator-5554" or "0123456789ABCDEF")
+    ///
+    /// You can find the serial number of your device by running `adb devices`.
+    ///
+    /// If not set, the first available device will be used.
+    adb_serial: Option<String>,
+
+    #[arg(short)]
+    /// Enable verbose output
+    verbose: bool,
+
+    #[arg(short)]
+    /// Enable quiet output (no output except errors)
+    quiet: bool,
+
+    /// Path to the binary to run on the device
+    executable: PathBuf,
+
+    #[arg(allow_hyphen_values = true)]
+    /// Arguments to be run
+    runner_args: Vec<String>,
+}
+
+pub fn run(args: Vec<String>) -> anyhow::Result<()> {
+    let mut shell = Shell::new();
+
+    let args = RunnerArgs::try_parse_from(args).unwrap_or_else(|e| {
+        shell.error(e).unwrap();
+        std::process::exit(2);
+    });
+
+    let adb_serial = args.adb_serial.as_deref();
+    let verbosity = if args.verbose {
+        Verbosity::Verbose
+    } else if args.quiet {
+        Verbosity::Quiet
+    } else {
+        Verbosity::Normal
+    };
+
+    shell.set_verbosity(verbosity);
+
+    // Get adb path
+    let adb_path = match derive_adb_path(&mut shell) {
+        Ok(path) => path,
+        Err(e) => {
+            shell.error(e)?;
+            std::process::exit(1);
+        }
+    };
+
+    // Push binary to device
+    let device_path = format!(
+        "/data/local/tmp/{}",
+        args.executable.file_name().unwrap().to_string_lossy()
+    );
+
+    // Ugly but works
+    shell.verbose(|shell| {
+        shell.status_header("Pushing")?;
+        shell.reset_err()?;
+        shell
+            .err()
+            .write_fmt(format_args!("binary to device: {device_path}\r"))?;
+        shell.set_needs_clear(true);
+        Ok(())
+    })?;
+
+    let push_status = Command::new(&adb_path)
+        .with_serial(adb_serial.as_deref())
+        .arg("push")
+        .arg(&args.executable)
+        .arg(&device_path)
+        .output()?;
+
+    if !push_status.status.success() {
+        shell.error("Failed to push test binary to device")?;
+        eprintln!("{}", std::str::from_utf8(&push_status.stderr)?.trim());
+        shell.note("If multiple devices, use --adb-serial to specify one.")?;
+        shell.note("Run `adb devices` to see connected devices.")?;
+        std::process::exit(push_status.status.code().unwrap_or(1));
+    }
+
+    shell.verbose(|shell| shell.status("Pushing", format!("binary to device ({device_path})")))?;
+
+    // Make binary executable
+    let chmod_status = Command::new(&adb_path)
+        .with_serial(adb_serial.as_deref())
+        .arg("shell")
+        .arg("chmod")
+        .arg("755")
+        .arg(&device_path)
+        .status()?;
+
+    if !chmod_status.success() {
+        shell.error("Failed to make binary executable")?;
+        std::process::exit(chmod_status.code().unwrap_or(1));
+    }
+
+    shell.reset_err()?;
+
+    let verbosity_arg = match verbosity {
+        Verbosity::Quiet => "-q",
+        _ => "",
+    };
+
+    let run_status = Command::new(&adb_path)
+        .with_serial(adb_serial.as_deref())
+        .arg("shell")
+        .arg(&device_path)
+        .arg(verbosity_arg)
+        .args(&args.runner_args)
+        .status()?;
+
+    // Clean up the binary from device
+    let _ = Command::new(&adb_path)
+        .with_serial(adb_serial.as_deref())
+        .arg("shell")
+        .arg("rm")
+        .arg(&device_path)
+        .status();
+
+    std::process::exit(run_status.code().unwrap_or(1))
+}