android.ts

import assert from "node:assert/strict";
import fs from "node:fs";
import path from "node:path";

import { Option } from "@commander-js/extra-typings";
import {
  createAndroidLibsDirectory,
  determineAndroidLibsFilename,
  AndroidTriplet,
  isAndroidTriplet,
} from "react-native-node-api";

import type { Platform } from "./types.js";
import { oraPromise } from "ora";
import chalk from "chalk";
import { getWeakNodeApiVariables } from "../weak-node-api.js";
import { toDeclarationArguments } from "../cmake.js";

type Target = `${AndroidTriplet}-reactnative`;

// This should match https://github.com/react-native-community/template/blob/main/template/android/build.gradle#L7
const DEFAULT_NDK_VERSION = "27.1.12297006";
const DEFAULT_ANDROID_SDK_VERSION = "24";

type AndroidArchitecture = "armeabi-v7a" | "arm64-v8a" | "x86" | "x86_64";

export const ANDROID_ARCHITECTURES = {
  "armv7a-linux-androideabi": "armeabi-v7a",
  "aarch64-linux-android": "arm64-v8a",
  "i686-linux-android": "x86",
  "x86_64-linux-android": "x86_64",
} satisfies Record<AndroidTriplet, AndroidArchitecture>;

const ndkVersionOption = new Option(
  "--ndk-version <version>",
  "The NDK version to use for Android builds",
).default(DEFAULT_NDK_VERSION);

const androidSdkVersionOption = new Option(
  "--android-sdk-version <version>",
  "The Android SDK version to use for Android builds",
).default(DEFAULT_ANDROID_SDK_VERSION);

type AndroidOpts = { ndkVersion: string; androidSdkVersion: string };

function tripletFromTarget(target: Target): AndroidTriplet {
  const result = target.replaceAll(/-reactnative$/g, "") as AndroidTriplet;
  assert(isAndroidTriplet(result), `Invalid Android triplet: ${target}`);
  return result;
}

export const platform: Platform<Target[], AndroidOpts> = {
  id: "android",
  name: "Android",
  targets: [
    "aarch64-linux-android-reactnative",
    "armv7a-linux-androideabi-reactnative",
    "i686-linux-android-reactnative",
    "x86_64-linux-android-reactnative",
  ],
  defaultTargets() {
    if (process.arch === "arm64") {
      return ["aarch64-linux-android-reactnative"];
    } else if (process.arch === "x64") {
      return ["x86_64-linux-android-reactnative"];
    } else {
      return [];
    }
  },
  amendCommand(command) {
    return command
      .addOption(ndkVersionOption)
      .addOption(androidSdkVersionOption);
  },
  configureArgs(
    { target },
    { configuration, ndkVersion, androidSdkVersion, weakNodeApiLinkage },
  ) {
    const { ANDROID_HOME } = process.env;
    assert(
      typeof ANDROID_HOME === "string",
      "Missing env variable ANDROID_HOME",
    );
    assert(
      fs.existsSync(ANDROID_HOME),
      `Expected the Android SDK at ${ANDROID_HOME}`,
    );
    const installNdkCommand = `sdkmanager --install "ndk;${ndkVersion}"`;
    const ndkPath = path.resolve(ANDROID_HOME, "ndk", ndkVersion);
    assert(
      fs.existsSync(ndkPath),
      `Missing Android NDK v${ndkVersion} (at ${ndkPath}) - run: ${installNdkCommand}`,
    );

    const toolchainPath = path.join(
      ndkPath,
      "build/cmake/android.toolchain.cmake",
    );

    const triplet = tripletFromTarget(target);

    return [
      "-G",
      "Ninja",
      "--toolchain",
      toolchainPath,
      ...toDeclarationArguments({
        CMAKE_SYSTEM_NAME: "Android",
        CMAKE_MAKE_PROGRAM: "ninja",
        CMAKE_BUILD_TYPE: configuration,
        // "CMAKE_C_COMPILER_LAUNCHER": "ccache",
        // "CMAKE_CXX_COMPILER_LAUNCHER": "ccache",
        ANDROID_NDK: ndkPath,
        ANDROID_ABI: ANDROID_ARCHITECTURES[triplet],
        ANDROID_TOOLCHAIN: "clang",
        ANDROID_PLATFORM: androidSdkVersion,
        // TODO: Make this configurable
        ANDROID_STL: "c++_shared",
        ...(weakNodeApiLinkage ? getWeakNodeApiVariables(triplet) : {}),
      }),
    ];
  },
  buildArgs() {
    return [];
  },
  isSupportedByHost() {
    const { ANDROID_HOME } = process.env;
    return typeof ANDROID_HOME === "string" && fs.existsSync(ANDROID_HOME);
  },
  async postBuild({ outputPath, targets }, { autoLink }) {
    // TODO: Include `configuration` in the output path
    const libraryPathByTriplet = Object.fromEntries(
      await Promise.all(
        targets.map(async ({ target, outputPath }) => {
          assert(
            fs.existsSync(outputPath),
            `Expected a directory at ${outputPath}`,
          );
          // Expect binary file(s), either .node or .so
          const dirents = await fs.promises.readdir(outputPath, {
            withFileTypes: true,
          });
          const result = dirents
            .filter(
              (dirent) =>
                dirent.isFile() &&
                (dirent.name.endsWith(".so") || dirent.name.endsWith(".node")),
            )
            .map((dirent) => path.join(dirent.parentPath, dirent.name));
          assert.equal(result.length, 1, "Expected exactly one library file");
          const triplet = tripletFromTarget(target);
          return [triplet, result[0]] as const;
        }),
      ),
    ) as Record<AndroidTriplet, string>;
    const androidLibsFilename = determineAndroidLibsFilename(
      Object.values(libraryPathByTriplet),
    );
    const androidLibsOutputPath = path.resolve(outputPath, androidLibsFilename);

    await oraPromise(
      createAndroidLibsDirectory({
        outputPath: androidLibsOutputPath,
        libraryPathByTriplet,
        autoLink,
      }),
      {
        text: "Assembling Android libs directory",
        successText: `Android libs directory assembled into ${chalk.dim(
          path.relative(process.cwd(), androidLibsOutputPath),
        )}`,
        failText: ({ message }) =>
          `Failed to assemble Android libs directory: ${message}`,
      },
    );
  },
};