@tauri-native/cli 0.0.2 → 0.1.0

package/README.md

@@ -1,6 +1,6 @@
 # @tauri-native/cli
 
-Experimental CLI for packaging a Tauri microfrontend and its Rust application core for an iOS host.
+Experimental CLI for packaging a Tauri microfrontend and its Rust application core for iOS and Android hosts.
 
 ## Install
 
@@ -8,7 +8,11 @@ Experimental CLI for packaging a Tauri microfrontend and its Rust application co
 npm install --save-dev @tauri-native/cli@experimental
 ```
 
-Node.js 22.12 or newer, Rust with the iOS targets, and Xcode are required.
+Node.js 22.12 or newer and Rust are required. iOS exports require Xcode and the iOS Rust targets. Android exports require the Android NDK and [`cargo-ndk`](https://github.com/bbqsrc/cargo-ndk):
+
+```sh
+cargo install cargo-ndk --locked
+```
 
 Install the package in the Tauri project that owns the frontend and Rust core. React Native and Lynx hosts consume its exported artifacts and do not need the CLI as a dependency.
 
@@ -35,6 +39,28 @@ The output directory contains:
 
 Copy or reference the exported directory from the native host, then add its generated local Pod before installing native dependencies.
 
+## Export for Android
+
+The Rust library must include both mobile crate types:
+
+```toml
+[lib]
+crate-type = ["staticlib", "cdylib"]
+```
+
+Run the Android export from the Tauri project root:
+
+```sh
+npx tauri-native export android
+```
+
+The default output is `src-tauri/gen/tauri-native/android` and contains:
+
+- `jniLibs/<abi>/libtauri_native_core.so` for `arm64-v8a`, `armeabi-v7a`, `x86`, and `x86_64`
+- `assets/tauri-native` containing the unchanged frontend distribution
+
+The React Native Expo config plugin installs these files during Android prebuild. Bare React Native and Lynx hosts can copy both directories into `android/app/src/main` or reference them from the app source set.
+
 ## License
 
 MIT

package/dist/index.mjs

@@ -44,6 +44,93 @@ function run(command, args, options = {}) {
 	});
 }
 //#endregion
+//#region src/commands/export-android.ts
+const ANDROID_ABIS = [
+	"arm64-v8a",
+	"armeabi-v7a",
+	"x86",
+	"x86_64"
+];
+const ANDROID_TARGETS = [
+	"aarch64-linux-android",
+	"armv7-linux-androideabi",
+	"i686-linux-android",
+	"x86_64-linux-android"
+];
+const ANDROID_API_LEVEL = "24";
+const OUTPUT_LIBRARY_NAME = "libtauri_native_core.so";
+function copyAndroidLibraries(cargoOutput, outputDirectory, libraryName) {
+	const jniLibraries = path.join(outputDirectory, "jniLibs");
+	rmSync(jniLibraries, {
+		recursive: true,
+		force: true
+	});
+	for (const abi of ANDROID_ABIS) {
+		const source = path.join(cargoOutput, abi, `lib${libraryName}.so`);
+		requireFile(source);
+		const abiDirectory = path.join(jniLibraries, abi);
+		mkdirSync(abiDirectory, { recursive: true });
+		cpSync(source, path.join(abiDirectory, OUTPUT_LIBRARY_NAME));
+	}
+}
+function exportAndroid(options) {
+	const workingDirectory = process.cwd();
+	const tauriDirectory = path.resolve(workingDirectory, options.tauriDir);
+	const manifest = options.manifest ? path.resolve(workingDirectory, options.manifest) : path.join(tauriDirectory, "crates/app-core/Cargo.toml");
+	const outputDirectory = path.resolve(workingDirectory, options.outputDir ?? path.join(tauriDirectory, "gen/tauri-native/android"));
+	const configPath = path.join(tauriDirectory, "tauri.conf.json");
+	for (const requiredPath of [manifest, configPath]) requireFile(requiredPath);
+	const config = JSON.parse(readFileSync(configPath, "utf8"));
+	const frontendDirectory = path.dirname(tauriDirectory);
+	if (typeof config.build?.beforeBuildCommand === "string") {
+		message(`Building the Tauri microfrontend in ${frontendDirectory}`);
+		execSync(config.build.beforeBuildCommand, {
+			cwd: frontendDirectory,
+			stdio: "inherit"
+		});
+	}
+	if (typeof config.build?.frontendDist !== "string") throw new Error(`${configPath} must define build.frontendDist`);
+	const frontendDist = path.resolve(tauriDirectory, config.build.frontendDist);
+	requireFile(path.join(frontendDist, "index.html"));
+	const libraryName = readLibraryName(manifest);
+	const targetDirectory = path.join(tauriDirectory, "target/tauri-native");
+	const cargoOutput = path.join(targetDirectory, "android-jniLibs");
+	const cargoEnvironment = {
+		...process.env,
+		CARGO_TARGET_DIR: targetDirectory
+	};
+	run("rustup", [
+		"target",
+		"add",
+		...ANDROID_TARGETS
+	]);
+	rmSync(cargoOutput, {
+		recursive: true,
+		force: true
+	});
+	run("cargo", [
+		"ndk",
+		"--platform",
+		ANDROID_API_LEVEL,
+		...ANDROID_ABIS.flatMap((abi) => ["--target", abi]),
+		"--output-dir",
+		cargoOutput,
+		"build",
+		"--manifest-path",
+		manifest,
+		"--release"
+	], { env: cargoEnvironment });
+	mkdirSync(outputDirectory, { recursive: true });
+	copyAndroidLibraries(cargoOutput, outputDirectory, libraryName);
+	const assets = path.join(outputDirectory, "assets/tauri-native");
+	rmSync(assets, {
+		recursive: true,
+		force: true
+	});
+	cpSync(frontendDist, assets, { recursive: true });
+	message(`Created ${path.join(outputDirectory, "jniLibs")}\nCreated ${assets}`, "◆ ");
+}
+//#endregion
 //#region src/commands/export-ios.ts
 const IOS_TARGETS = [
 	"aarch64-apple-ios",
@@ -165,7 +252,9 @@ function exportIos(options) {
 function createProgram() {
 	const program = new Command();
 	program.name("tauri-native").description("Export a Tauri microfrontend for a native host").showHelpAfterError();
-	program.command("export").description("Export Tauri artifacts for a native host").command("ios").description("Export an XCFramework and a Tauri web asset bundle").option("--tauri-dir <path>", "Tauri Rust directory", "src-tauri").option("--manifest <path>", "native core Cargo.toml").option("--header <path>", "C ABI header").option("--output-dir <path>", "generated artifact directory").action((options) => exportIos(options));
+	const exportCommand = program.command("export").description("Export Tauri artifacts for a native host");
+	exportCommand.command("ios").description("Export an XCFramework and a Tauri web asset bundle").option("--tauri-dir <path>", "Tauri Rust directory", "src-tauri").option("--manifest <path>", "native core Cargo.toml").option("--header <path>", "C ABI header").option("--output-dir <path>", "generated artifact directory").action((options) => exportIos(options));
+	exportCommand.command("android").description("Export Android Rust libraries and Tauri web assets").option("--tauri-dir <path>", "Tauri Rust directory", "src-tauri").option("--manifest <path>", "native core Cargo.toml").option("--output-dir <path>", "generated artifact directory").action((options) => exportAndroid(options));
 	return program;
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tauri-native/cli",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "Export a Tauri microfrontend and its Rust core for native hosts",
   "type": "module",
   "bin": {
@@ -26,6 +26,7 @@
     "commander": "^15.0.0"
   },
   "keywords": [
+    "android",
     "ios",
     "react-native",
     "rust",