feat(build): Android support

This commit introduces build instructions for building the kernel targetting android.

The instructions follows a design that is minimal, counting it will be executed in
the nix environment which will be implemented in the next commits.

We consciously made this decision; Nix runs on most systems where specific implementations
would otherwise be necessary for each one. Nix helps keep these instructions minimal and
reduces the chance of introducing bugs.

Author: jaoleal

libbitcoinkernel-sys/CHANGELOG.md

@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+- Added build support for Android
 
 ## [0.3.0] - 2026-05-20
 

libbitcoinkernel-sys/build.rs

@@ -15,7 +15,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")
@@ -38,7 +39,58 @@ 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_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    let is_android = target_os == "android";
+
+    let ndk = if is_android {
+        Some(
+            env::var("ANDROID_NDK_HOME")
+                .expect("Android target detected but ANDROID_NDK_HOME is not set"),
+        )
+    } else {
+        None
+    };
+
+    if is_android {
+        let ndk = ndk.as_deref().unwrap();
+        let toolchain_file = format!("{ndk}/build/cmake/android.toolchain.cmake");
+
+        // Rust target triple -> NDK ABI name.
+        let abi = match env::var("TARGET").unwrap() {
+            t if t.contains("aarch64") => "arm64-v8a",
+            t if t.contains("armv7") => "armeabi-v7a",
+            t if t.contains("x86_64") => "x86_64",
+            target => panic!("Unsupported Android ABI: {target}"),
+        };
+
+        // API level 24+ is required because Bitcoin Core uses getifaddrs
+        // which was introduced in Android API 24 (Nougat).
+        //
+        // This can be overridden to a higher level by setting ANDROID_API_LEVEL.
+        let api_level = match env::var("ANDROID_API_LEVEL") {
+            Ok(level) => {
+                let n: u32 = level.parse().expect("ANDROID_API_LEVEL must be a number");
+                assert!(n >= 24, "ANDROID_API_LEVEL must be 24+");
+                level
+            }
+            _ => "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_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");
 
@@ -70,19 +122,49 @@ fn main() {
     } else {
         install_dir.join("lib")
     };
+
     println!("cargo:rustc-link-search=native={}", lib_dir.display());
 
     println!("cargo:rustc-link-lib=static=bitcoinkernel");
 
     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");
-    }
+    } else if is_android {
+        // Without these, changing either variable between builds won't trigger a rebuild,
+        // so we could silently end up with a stale binary built against the wrong NDK or API level.
+        println!("cargo:rerun-if-env-changed=ANDROID_NDK_HOME");
+        println!("cargo:rerun-if-env-changed=ANDROID_API_LEVEL");
+        // Android NDK ships libc++_static.a and libc++abi.a in the
+        // per-architecture sysroot directory (not the API-level subdirectory).
+        let ndk = ndk.as_deref().unwrap();
+
+        // Rust target triple -> NDK sysroot lib directory triple.
+        // armv7 differs: Rust says `armv7-linux-androideabi`, NDK says `arm-linux-androideabi`.
+        let ndk_triple = env::var("TARGET")
+            .map(|target| {
+                if target.starts_with("armv7") {
+                    "arm-linux-androideabi".into()
+                } else {
+                    target
+                }
+            })
+            .unwrap();
+
+        let host_tag = match std::env::consts::OS {
+            "macos" => "darwin-x86_64",
+            "linux" => "linux-x86_64",
+            os => panic!("unsupported build host for Android cross-compilation: {os}"),
+        };
 
-    if compiler.is_like_clang() {
+        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 {