feat: android support

Author: jaoleal

flake.nix

@@ -75,7 +75,6 @@
 						]);
 				};
 
-				# -- Stable Rust for checks (MSRV is too old for some vendored crate manifests) --
 				rustStable = fenix.packages.${system}.stable;
 				mkAndroidCheck = { name, rustTarget }:
 					let
@@ -98,6 +97,10 @@
 
 						cargoLock.lockFile = self + "/Cargo-recent.lock";
 
+					postUnpack = ''
+						cp ${./Cargo-recent.lock} $sourceRoot/Cargo.lock
+					'';
+
 						nativeBuildInputs = [
 							pkgs.cmake
 							pkgs.pkg-config

libbitcoinkernel-sys/build.rs

@@ -4,6 +4,35 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
 
+/// Maps Rust target triples to Android ABI names used by the NDK.
+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,
+    }
+}
+
+/// Maps Rust target triples to the NDK sysroot directory names.
+/// These differ from Rust triples for armv7 targets.
+fn android_sysroot_triple(target: &str) -> &str {
+    if target.starts_with("armv7") {
+        "arm-linux-androideabi"
+    } else {
+        target
+    }
+}
+
+/// Detect whether we are cross-compiling for Android and return the NDK home path if so.
+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,12 @@ fn main() {
 
     let build_config = "RelWithDebInfo";
 
-    Command::new("cmake")
+    let target = env::var("TARGET").unwrap();
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let is_android = target_os == "android";
+
+    let mut cmake_configure = Command::new("cmake");
+    cmake_configure
         .arg("-B")
         .arg(&build_dir)
         .arg("-S")
@@ -40,9 +74,33 @@ fn main() {
         .arg("-DBUILD_SHARED_LIBS=OFF")
         .arg("-DCMAKE_INSTALL_LIBDIR=lib")
         .arg("-DENABLE_IPC=OFF")
-        .arg(format!("-DCMAKE_INSTALL_PREFIX={}", install_dir.display()))
-        .status()
-        .unwrap();
+        .arg(format!("-DCMAKE_INSTALL_PREFIX={}", install_dir.display()));
+
+    if is_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");
+        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().unwrap();
 
     let num_jobs = env::var("NUM_JOBS")
         .ok()
@@ -80,10 +138,58 @@ fn main() {
     let include_path = install_dir.join("include");
     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")
+        .clang_arg("-DBITCOINKERNEL_STATIC");
+
+    if is_android {
+        builder = builder.clang_arg(format!("--target={target}"));
+        if let Some(ndk) = android_ndk_home() {
+            let api_level = env::var("ANDROID_API_LEVEL").unwrap_or_else(|_| "24".to_string());
+            let sysroot = format!("{ndk}/toolchains/llvm/prebuilt/linux-x86_64/sysroot");
+            let ndk_triple = android_sysroot_triple(&target);
+
+            // Suppress host system headers so only NDK headers are used.
+            builder = builder.clang_arg("-nostdinc");
+
+            // Add clang builtin headers (stddef.h, stdarg.h, etc.) from the
+            // resource directory. Must come before NDK sysroot includes.
+            if let Ok(libclang) = env::var("LIBCLANG_PATH") {
+                let libclang_path = Path::new(&libclang);
+                let candidates = [
+                    libclang_path.to_path_buf(),
+                    libclang_path
+                        .parent()
+                        .map(|p| p.to_path_buf())
+                        .unwrap_or_default(),
+                ];
+                for base in &candidates {
+                    let clang_dir = base.join("clang");
+                    if let Ok(entries) = std::fs::read_dir(&clang_dir) {
+                        for entry in entries.flatten() {
+                            let resource_dir = entry.path();
+                            if resource_dir.join("include").join("stddef.h").exists() {
+                                builder = builder.clang_arg(format!(
+                                    "-isystem{}",
+                                    resource_dir.join("include").display()
+                                ));
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            builder = builder
+                .clang_arg(format!("--sysroot={sysroot}"))
+                .clang_arg(format!("-isystem{sysroot}/usr/include"))
+                .clang_arg(format!("-isystem{sysroot}/usr/include/{ndk_triple}"))
+                .clang_arg(format!("-D__ANDROID_API__={api_level}"));
+        }
+    }
+
+    #[allow(deprecated)]
+    let bindings = builder
         .rust_target(bindgen::RustTarget::Stable_1_71)
         .rust_edition(RustEdition::Edition2021)
         .generate()
@@ -97,14 +203,22 @@ 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 is_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 ndk_lib_dir =
+                format!("{ndk}/toolchains/llvm/prebuilt/linux-x86_64/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 {