@react-native/gradle-plugin 0.72.2

package/src/main/kotlin/com/facebook/react/utils/NdkConfiguratorUtils.kt

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import com.android.build.api.variant.AndroidComponentsExtension
+import com.android.build.api.variant.Variant
+import com.facebook.react.ReactExtension
+import com.facebook.react.utils.ProjectUtils.isNewArchEnabled
+import java.io.File
+import org.gradle.api.Project
+
+internal object NdkConfiguratorUtils {
+  @Suppress("UnstableApiUsage")
+  fun configureReactNativeNdk(project: Project, extension: ReactExtension) {
+    project.pluginManager.withPlugin("com.android.application") {
+      project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
+        if (!project.isNewArchEnabled) {
+          // For Old Arch, we don't need to setup the NDK
+          return@finalizeDsl
+        }
+        // We enable prefab so users can consume .so/headers from ReactAndroid and hermes-engine
+        // .aar
+        ext.buildFeatures.prefab = true
+
+        // If the user has not provided a CmakeLists.txt path, let's provide
+        // the default one from the framework
+        if (ext.externalNativeBuild.cmake.path == null) {
+          ext.externalNativeBuild.cmake.path =
+              File(
+                  extension.reactNativeDir.get().asFile,
+                  "ReactAndroid/cmake-utils/default-app-setup/CMakeLists.txt")
+        }
+
+        // Parameters should be provided in an additive manner (do not override what
+        // the user provided, but allow for sensible defaults).
+        val cmakeArgs = ext.defaultConfig.externalNativeBuild.cmake.arguments
+        if ("-DPROJECT_BUILD_DIR" !in cmakeArgs) {
+          cmakeArgs.add("-DPROJECT_BUILD_DIR=${project.buildDir}")
+        }
+        if ("-DREACT_ANDROID_DIR" !in cmakeArgs) {
+          cmakeArgs.add(
+              "-DREACT_ANDROID_DIR=${extension.reactNativeDir.file("ReactAndroid").get().asFile}")
+        }
+        if ("-DANDROID_STL" !in cmakeArgs) {
+          cmakeArgs.add("-DANDROID_STL=c++_shared")
+        }
+      }
+    }
+  }
+
+  /**
+   * This method is used to configure the .so Packaging Options for the given variant. It will make
+   * sure we specify the correct .pickFirsts for all the .so files we are producing or that we're
+   * aware of as some of our dependencies are pulling them in.
+   */
+  fun configureNewArchPackagingOptions(
+      project: Project,
+      variant: Variant,
+  ) {
+    if (!project.isNewArchEnabled) {
+      // For Old Arch, we set a pickFirst only on libraries that we know are
+      // clashing with our direct dependencies (FBJNI, Flipper and Hermes).
+      variant.packaging.jniLibs.pickFirsts.addAll(
+          listOf(
+              "**/libfbjni.so",
+              "**/libc++_shared.so",
+          ))
+    } else {
+      // We set some packagingOptions { pickFirst ... } for our users for libraries we own.
+      variant.packaging.jniLibs.pickFirsts.addAll(
+          listOf(
+              // This is the .so provided by FBJNI via prefab
+              "**/libfbjni.so",
+              // Those are prefab libraries we distribute via ReactAndroid
+              // Due to a bug in AGP, they fire a warning on console as both the JNI
+              // and the prefab .so files gets considered. See more on:
+              "**/libfabricjni.so",
+              "**/libfolly_runtime.so",
+              "**/libglog.so",
+              "**/libjsi.so",
+              "**/libreact_codegen_rncore.so",
+              "**/libreact_debug.so",
+              "**/libreact_nativemodule_core.so",
+              "**/libreact_newarchdefaults.so",
+              "**/libreact_render_componentregistry.so",
+              "**/libreact_render_core.so",
+              "**/libreact_render_debug.so",
+              "**/libreact_render_graphics.so",
+              "**/libreact_render_imagemanager.so",
+              "**/libreact_render_mapbuffer.so",
+              "**/librrc_image.so",
+              "**/librrc_view.so",
+              "**/libruntimeexecutor.so",
+              "**/libturbomodulejsijni.so",
+              "**/libyoga.so",
+              // AGP will give priority of libc++_shared coming from App modules.
+              "**/libc++_shared.so",
+          ))
+    }
+  }
+
+  /**
+   * This method is used to configure the .so Cleanup for the given variant. It takes care of
+   * cleaning up the .so files that are not needed for Hermes or JSC, given a specific variant.
+   */
+  fun configureJsEnginePackagingOptions(
+      config: ReactExtension,
+      variant: Variant,
+      hermesEnabled: Boolean,
+  ) {
+    if (config.enableSoCleanup.get()) {
+      val (excludes, includes) = getPackagingOptionsForVariant(hermesEnabled)
+      variant.packaging.jniLibs.excludes.addAll(excludes)
+      variant.packaging.jniLibs.pickFirsts.addAll(includes)
+    }
+  }
+
+  fun getPackagingOptionsForVariant(hermesEnabled: Boolean): Pair<List<String>, List<String>> {
+    val excludes = mutableListOf<String>()
+    val includes = mutableListOf<String>()
+    if (hermesEnabled) {
+      excludes.add("**/libjsc.so")
+      excludes.add("**/libjscexecutor.so")
+      includes.add("**/libhermes.so")
+      includes.add("**/libhermes_executor.so")
+    } else {
+      excludes.add("**/libhermes.so")
+      excludes.add("**/libhermes_executor.so")
+      includes.add("**/libjsc.so")
+      includes.add("**/libjscexecutor.so")
+    }
+    return excludes to includes
+  }
+}

package/src/main/kotlin/com/facebook/react/utils/Os.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+object Os {
+
+  fun isWindows(): Boolean =
+      System.getProperty("os.name")?.lowercase()?.contains("windows") ?: false
+
+  fun isMac(): Boolean = System.getProperty("os.name")?.lowercase()?.contains("mac") ?: false
+
+  fun isLinuxAmd64(): Boolean {
+    val osNameMatch = System.getProperty("os.name")?.lowercase()?.contains("linux") ?: false
+    val archMatch = System.getProperty("os.arch")?.lowercase()?.contains("amd64") ?: false
+    return osNameMatch && archMatch
+  }
+
+  fun String.unixifyPath() =
+      this.replace('\\', '/').replace(":", "").let {
+        if (!it.startsWith("/")) {
+          "/$it"
+        } else {
+          it
+        }
+      }
+}

package/src/main/kotlin/com/facebook/react/utils/PathUtils.kt

@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+@file:JvmName("PathUtils")
+
+package com.facebook.react.utils
+
+import com.facebook.react.ReactExtension
+import com.facebook.react.model.ModelPackageJson
+import java.io.File
+import org.gradle.api.Project
+
+/**
+ * Computes the entry file for React Native. The Algo follows this order:
+ * 1. The file pointed by the ENTRY_FILE env variable, if set.
+ * 2. The file provided by the `entryFile` config in the `reactApp` Gradle extension
+ * 3. The `index.android.js` file, if available.
+ * 4. Fallback to the `index.js` file.
+ *
+ * @param config The [ReactExtension] configured for this project
+ */
+internal fun detectedEntryFile(config: ReactExtension): File =
+    detectEntryFile(
+        entryFile = config.entryFile.orNull?.asFile, reactRoot = config.root.get().asFile)
+
+/**
+ * Computes the CLI file for React Native. The Algo follows this order:
+ * 1. The path provided by the `cliFile` config in the `react {}` Gradle extension
+ * 2. The output of `node --print "require.resolve('react-native/cli');"` if not failing.
+ * 3. The `node_modules/react-native/cli.js` file if exists
+ * 4. Fails otherwise
+ */
+internal fun detectedCliFile(config: ReactExtension): File =
+    detectCliFile(
+        reactNativeRoot = config.root.get().asFile,
+        preconfiguredCliFile = config.cliFile.asFile.orNull)
+
+/**
+ * Computes the `hermesc` command location. The Algo follows this order:
+ * 1. The path provided by the `hermesCommand` config in the `react` Gradle extension
+ * 2. The file located in `node_modules/react-native/sdks/hermes/build/bin/hermesc`. This will be
+ * used if the user is building Hermes from source.
+ * 3. The file located in `node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc` where `%OS-BIN%`
+ * is substituted with the correct OS arch. This will be used if the user is using a precompiled
+ * hermes-engine package.
+ * 4. Fails otherwise
+ */
+internal fun detectedHermesCommand(config: ReactExtension): String =
+    detectOSAwareHermesCommand(config.root.get().asFile, config.hermesCommand.get())
+
+private fun detectEntryFile(entryFile: File?, reactRoot: File): File =
+    when {
+      System.getenv("ENTRY_FILE") != null -> File(System.getenv("ENTRY_FILE"))
+      entryFile != null -> entryFile
+      File(reactRoot, "index.android.js").exists() -> File(reactRoot, "index.android.js")
+      else -> File(reactRoot, "index.js")
+    }
+
+private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): File {
+  // 1. preconfigured path
+  if (preconfiguredCliFile != null) {
+    if (preconfiguredCliFile.exists()) {
+      return preconfiguredCliFile
+    }
+  }
+
+  // 2. node module path
+  val nodeProcess =
+      Runtime.getRuntime()
+          .exec(
+              arrayOf("node", "--print", "require.resolve('react-native/cli');"),
+              emptyArray(),
+              reactNativeRoot)
+
+  val nodeProcessOutput = nodeProcess.inputStream.use { it.bufferedReader().readText().trim() }
+
+  if (nodeProcessOutput.isNotEmpty()) {
+    val nodeModuleCliJs = File(nodeProcessOutput)
+    if (nodeModuleCliJs.exists()) {
+      return nodeModuleCliJs
+    }
+  }
+
+  // 3. cli.js in the root folder
+  val rootCliJs = File(reactNativeRoot, "node_modules/react-native/cli.js")
+  if (rootCliJs.exists()) {
+    return rootCliJs
+  }
+
+  error(
+      """
+      Couldn't determine CLI location!
+      
+      Please set `react { cliFile = file(...) }` inside your 
+      build.gradle to the path of the react-native cli.js file.
+      This file typically resides in `node_modules/react-native/cli.js`
+    """
+          .trimIndent())
+}
+
+/**
+ * Computes the `hermesc` command location. The Algo follows this order:
+ * 1. The path provided by the `hermesCommand` config in the `react` Gradle extension
+ * 2. The file located in `node_modules/react-native/sdks/hermes/build/bin/hermesc`. This will be
+ * used if the user is building Hermes from source.
+ * 3. The file located in `node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc` where `%OS-BIN%`
+ * is substituted with the correct OS arch. This will be used if the user is using a precompiled
+ * hermes-engine package.
+ * 4. Fails otherwise
+ */
+internal fun detectOSAwareHermesCommand(projectRoot: File, hermesCommand: String): String {
+  // 1. If the project specifies a Hermes command, don't second guess it.
+  if (hermesCommand.isNotBlank()) {
+    val osSpecificHermesCommand =
+        if ("%OS-BIN%" in hermesCommand) {
+          hermesCommand.replace("%OS-BIN%", getHermesOSBin())
+        } else {
+          hermesCommand
+        }
+    return osSpecificHermesCommand
+        // Execution on Windows fails with / as separator
+        .replace('/', File.separatorChar)
+  }
+
+  // 2. If the project is building hermes-engine from source, use hermesc from there
+  val builtHermesc =
+      getBuiltHermescFile(projectRoot, System.getenv("REACT_NATIVE_OVERRIDE_HERMES_DIR"))
+  if (builtHermesc.exists()) {
+    return builtHermesc.absolutePath
+  }
+
+  // 3. If the react-native contains a pre-built hermesc, use it.
+  val prebuiltHermesPath =
+      HERMESC_IN_REACT_NATIVE_DIR.plus(getHermesCBin())
+          .replace("%OS-BIN%", getHermesOSBin())
+          // Execution on Windows fails with / as separator
+          .replace('/', File.separatorChar)
+
+  val prebuiltHermes = File(projectRoot, prebuiltHermesPath)
+  if (prebuiltHermes.exists()) {
+    return prebuiltHermes.absolutePath
+  }
+
+  error(
+      "Couldn't determine Hermesc location. " +
+          "Please set `react.hermesCommand` to the path of the hermesc binary file. " +
+          "node_modules/react-native/sdks/hermesc/%OS-BIN%/hermesc")
+}
+
+/**
+ * Gets the location where Hermesc should be. If nothing is specified, built hermesc is assumed to
+ * be inside [HERMESC_BUILT_FROM_SOURCE_DIR]. Otherwise user can specify an override with
+ * [pathOverride], which is assumed to be an absolute path where Hermes source code is
+ * provided/built.
+ *
+ * @param projectRoot The root of the Project.
+ */
+internal fun getBuiltHermescFile(projectRoot: File, pathOverride: String?) =
+    if (!pathOverride.isNullOrBlank()) {
+      File(pathOverride, "build/bin/${getHermesCBin()}")
+    } else {
+      File(projectRoot, HERMESC_BUILT_FROM_SOURCE_DIR.plus(getHermesCBin()))
+    }
+
+internal fun getHermesCBin() = if (Os.isWindows()) "hermesc.exe" else "hermesc"
+
+internal fun getHermesOSBin(): String {
+  if (Os.isWindows()) return "win64-bin"
+  if (Os.isMac()) return "osx-bin"
+  if (Os.isLinuxAmd64()) return "linux64-bin"
+  error(
+      "OS not recognized. Please set project.react.hermesCommand " +
+          "to the path of a working Hermes compiler.")
+}
+
+internal fun projectPathToLibraryName(projectPath: String): String =
+    projectPath
+        .split(':', '-', '_', '.')
+        .joinToString("") { token -> token.replaceFirstChar { it.uppercase() } }
+        .plus("Spec")
+
+/**
+ * Function to look for the relevant `package.json`. We first look in the parent folder of this
+ * Gradle module (generally the case for library projects) or we fallback to looking into the `root`
+ * folder of a React Native project (generally the case for app projects).
+ */
+internal fun findPackageJsonFile(project: Project, extension: ReactExtension): File? {
+  val inParent = project.file("../package.json")
+  if (inParent.exists()) {
+    return inParent
+  }
+
+  val fromExtension = extension.root.file("package.json").orNull?.asFile
+  if (fromExtension?.exists() == true) {
+    return fromExtension
+  }
+
+  return null
+}
+
+/**
+ * Function to look for the `package.json` and parse it. It returns a [ModelPackageJson] if found or
+ * null others.
+ *
+ * Please note that this function access the [ReactExtension] field properties and calls .get() on
+ * them, so calling this during apply() of the ReactPlugin is not recommended. It should be invoked
+ * inside lazy lambdas or at execution time.
+ */
+internal fun readPackageJsonFile(project: Project, extension: ReactExtension): ModelPackageJson? {
+  val packageJson = findPackageJsonFile(project, extension)
+  return packageJson?.let { JsonUtils.fromCodegenJson(it) }
+}
+
+private const val HERMESC_IN_REACT_NATIVE_DIR = "node_modules/react-native/sdks/hermesc/%OS-BIN%/"
+private const val HERMESC_BUILT_FROM_SOURCE_DIR =
+    "node_modules/react-native/ReactAndroid/hermes-engine/build/hermes/bin/"

package/src/main/kotlin/com/facebook/react/utils/ProjectUtils.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+import com.facebook.react.ReactExtension
+import com.facebook.react.model.ModelPackageJson
+import org.gradle.api.Project
+
+internal object ProjectUtils {
+  internal val Project.isNewArchEnabled: Boolean
+    get() =
+        project.hasProperty("newArchEnabled") &&
+            project.property("newArchEnabled").toString().toBoolean()
+
+  const val HERMES_FALLBACK = true
+
+  internal val Project.isHermesEnabled: Boolean
+    get() =
+        if (project.hasProperty("hermesEnabled")) {
+          project.property("hermesEnabled").toString().lowercase().toBooleanStrictOrNull() ?: true
+        } else if (project.extensions.extraProperties.has("react")) {
+          @Suppress("UNCHECKED_CAST")
+          val reactMap = project.extensions.extraProperties.get("react") as? Map<String, Any?>
+          when (val enableHermesKey = reactMap?.get("enableHermes")) {
+            is Boolean -> enableHermesKey
+            is String -> enableHermesKey.lowercase().toBooleanStrictOrNull() ?: true
+            else -> HERMES_FALLBACK
+          }
+        } else {
+          HERMES_FALLBACK
+        }
+
+  internal fun Project.needsCodegenFromPackageJson(extension: ReactExtension): Boolean {
+    val parsedPackageJson = readPackageJsonFile(this, extension)
+    return needsCodegenFromPackageJson(parsedPackageJson)
+  }
+
+  internal fun Project.needsCodegenFromPackageJson(model: ModelPackageJson?): Boolean {
+    return model?.codegenConfig != null
+  }
+}

package/src/main/kotlin/com/facebook/react/utils/TaskUtils.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.utils
+
+internal fun windowsAwareCommandLine(vararg args: Any): List<Any> =
+    windowsAwareCommandLine(args.toList())
+
+internal fun windowsAwareCommandLine(args: List<Any>): List<Any> =
+    if (Os.isWindows()) {
+      listOf("cmd", "/c") + args
+    } else {
+      args
+    }
+
+internal fun windowsAwareBashCommandLine(
+    vararg args: String,
+    bashWindowsHome: String? = null
+): List<String> =
+    if (Os.isWindows()) {
+      listOf(bashWindowsHome ?: "bash", "-c") + args
+    } else {
+      args.toList()
+    }