feat: minimal android support

This commit presents the minimal work needed for this crate to be
able to be compiled for android, this is minimal to avoid bloating
too much the build process, which would make it hard to review and
maintain. The rest of the work will be done on nix side, which
provides better ergonomics for such job.

Author: jaoleal

libbitcoinkernel-sys/CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- Added build support for android
 - New `btck_ConsensusParams` opaque type for holding consensus parameters
 - New `btck_chain_parameters_get_consensus_params` for extracting consensus params from `btck_ChainParameters` (lifetime-bound to the chain parameters object)
 - New `btck_block_check` for context-free block validation (size limits, coinbase structure, sigop limits, with optional POW and merkle-root checks via `btck_BlockCheckFlags`)

libbitcoinkernel-sys/build.rs

@@ -4,6 +4,35 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 
+/// Rust target triple -> NDK ABI name (`arm64-v8a`, `armeabi-v7a`, …).
+fn android_abi(target: &str) -> Option<&'static str> {
+    match target {
+        t if t.contains("aarch64") => Some("arm64-v8a"),
+        t if t.contains("armv7") => Some("armeabi-v7a"),
+        t if t.contains("x86_64") => Some("x86_64"),
+        t if t.contains("i686") => Some("x86"),
+        _ => None,
+    }
+}
+
+/// Rust target triple -> NDK sysroot lib directory triple.
+/// armv7 differs: Rust says `armv7-linux-androideabi`, NDK says `arm-linux-androideabi`.
+fn android_sysroot_triple(target: &str) -> &str {
+    if target.starts_with("armv7") {
+        "arm-linux-androideabi"
+    } else {
+        target
+    }
+}
+
+/// NDK root from `ANDROID_NDK_HOME`, `ANDROID_NDK_ROOT`, or `NDK_HOME`.
+fn android_ndk_home() -> Option<String> {
+    env::var("ANDROID_NDK_HOME")
+        .or_else(|_| env::var("ANDROID_NDK_ROOT"))
+        .or_else(|_| env::var("NDK_HOME"))
+        .ok()
+}
+
 fn main() {
     let bitcoin_dir = Path::new("bitcoin");
     let out_dir = env::var("OUT_DIR").unwrap();
@@ -17,7 +46,8 @@ fn main() {
 
     let build_config = "RelWithDebInfo";
 
-    Command::new("cmake")
+    let mut cmake_configure = Command::new("cmake");
+    cmake_configure
         .arg("-B")
         .arg(&build_dir)
         .arg("-S")
@@ -40,7 +70,42 @@ fn main() {
         .arg("-DBUILD_SHARED_LIBS=OFF")
         .arg("-DCMAKE_INSTALL_LIBDIR=lib")
         .arg("-DENABLE_IPC=OFF")
-        .arg(format!("-DCMAKE_INSTALL_PREFIX={}", install_dir.display()))
+        .arg(format!("-DCMAKE_INSTALL_PREFIX={}", install_dir.display()));
+
+    let target = env::var("TARGET").unwrap();
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+
+    if target_os == "android" {
+        let ndk =
+            android_ndk_home().expect("Android target detected but ANDROID_NDK_HOME is not set");
+        let toolchain_file = format!("{ndk}/build/cmake/android.toolchain.cmake");
+        assert!(
+            Path::new(&toolchain_file).exists(),
+            "Android NDK toolchain file not found at {toolchain_file}. \
+             Check that ANDROID_NDK_HOME points to a valid NDK installation"
+        );
+        let abi =
+            android_abi(&target).unwrap_or_else(|| panic!("unsupported Android target: {target}"));
+
+        // API level 24+ is required because Bitcoin Core uses getifaddrs
+        // which was introduced in Android API 24 (Nougat).
+        let api_level = env::var("ANDROID_API_LEVEL").unwrap_or_else(|_| "24".to_string());
+
+        cmake_configure
+            .arg(format!("-DCMAKE_TOOLCHAIN_FILE={toolchain_file}"))
+            .arg(format!("-DANDROID_ABI={abi}"))
+            .arg(format!("-DANDROID_PLATFORM=android-{api_level}"))
+            .arg("-DCMAKE_SYSTEM_NAME=Android")
+            .arg(format!("-DCMAKE_ANDROID_ARCH_ABI={abi}"))
+            .arg(format!("-DCMAKE_SYSTEM_VERSION={api_level}"))
+            .arg(format!("-DCMAKE_ANDROID_NDK={ndk}"))
+            // The Android NDK toolchain sets CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+            // to ONLY, which prevents cmake from finding host packages via
+            // CMAKE_PREFIX_PATH. Override it so Boost headers can be located.
+            .arg("-DCMAKE_FIND_ROOT_PATH_MODE_PACKAGE=BOTH");
+    }
+
+    cmake_configure
         .status()
         .expect("cmake should be installed and available in PATH");
 
@@ -81,13 +146,45 @@ fn main() {
     let header = include_path.join("bitcoinkernel.h");
 
     #[allow(deprecated)]
-    let bindings = bindgen::Builder::default()
+    let mut builder = bindgen::Builder::default()
         .header(header.to_str().unwrap())
         .clang_arg("-DBITCOINKERNEL_STATIC")
         .rust_target(bindgen::RustTarget::Stable_1_71)
-        .rust_edition(RustEdition::Edition2021)
-        .generate()
-        .expect("Unable to generate bindings");
+        .rust_edition(RustEdition::Edition2021);
+
+    // When cross-compiling for Android, bindgen's host libclang does not
+    // know the NDK sysroot or target triple. Pass them explicitly so
+    // system headers like stddef.h are found.
+    if target_os == "android" {
+        if let Some(ndk) = android_ndk_home() {
+            let host_tag = if cfg!(target_os = "macos") {
+                "darwin-x86_64"
+            } else {
+                "linux-x86_64"
+            };
+            let prebuilt = format!("{ndk}/toolchains/llvm/prebuilt/{host_tag}");
+            let sysroot = format!("{prebuilt}/sysroot");
+            builder = builder
+                .clang_arg(format!("--target={target}"))
+                .clang_arg(format!("--sysroot={sysroot}"));
+
+            // The NDK's clang resource directory contains compiler builtins
+            // (stddef.h, stdarg.h, etc.) that the host libclang may lack for
+            // this target. Add it as a system include path.
+            let clang_include = Path::new(&prebuilt).join("lib").join("clang");
+            if let Ok(entries) = std::fs::read_dir(&clang_include) {
+                for entry in entries.flatten() {
+                    let include = entry.path().join("include");
+                    if include.is_dir() {
+                        builder = builder.clang_arg(format!("-isystem{}", include.display()));
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    let bindings = builder.generate().expect("Unable to generate bindings");
 
     let out_path = PathBuf::from(
         env::var("OUT_DIR").expect("OUT_DIR was not defined by the cargo environment!"),
@@ -97,14 +194,27 @@ fn main() {
         .expect("Couldn't write bindings!");
 
     let compiler = cc::Build::new().get_compiler();
-    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
 
     if target_os == "windows" {
         println!("cargo:rustc-link-lib=bcrypt");
         println!("cargo:rustc-link-lib=shell32");
-    }
-
-    if compiler.is_like_clang() {
+    } else if target_os == "android" {
+        // Android NDK ships libc++_static.a and libc++abi.a in the
+        // per-architecture sysroot directory (not the API-level subdirectory).
+        if let Some(ndk) = android_ndk_home() {
+            let ndk_triple = android_sysroot_triple(&target);
+            let host_tag = if cfg!(target_os = "macos") {
+                "darwin-x86_64"
+            } else {
+                "linux-x86_64"
+            };
+            let ndk_lib_dir =
+                format!("{ndk}/toolchains/llvm/prebuilt/{host_tag}/sysroot/usr/lib/{ndk_triple}");
+            println!("cargo:rustc-link-search=native={ndk_lib_dir}");
+        }
+        println!("cargo:rustc-link-lib=static=c++_static");
+        println!("cargo:rustc-link-lib=static=c++abi");
+    } else if compiler.is_like_clang() {
         if target_os == "macos" {
             println!("cargo:rustc-link-lib=dylib=c++");
         } else {