@react-native/gradle-plugin 0.73.0 → 0.73.1

package/README.md

@@ -14,3 +14,10 @@ yarn add @react-native/gradle-plugin
 
 [version-badge]: https://img.shields.io/npm/v/@react-native/gradle-plugin?style=flat-square
 [package]: https://www.npmjs.com/package/@react-native/gradle-plugin
+
+## Testing
+
+To run the tests in this package, run the following commands from the React Native root folder:
+
+1. `yarn` to install the dependencies. You just need to run this once
+2. `yarn jest packages/react-native-gradle-plugin`.

package/build.gradle.kts

@@ -11,7 +11,7 @@ import org.gradle.configurationcache.extensions.serviceOf
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-  kotlin("jvm") version "1.7.22"
+  alias(libs.plugins.kotlin.jvm)
   id("java-gradle-plugin")
 }
 
@@ -33,12 +33,17 @@ group = "com.facebook.react"
 
 dependencies {
   implementation(gradleApi())
-  implementation("com.android.tools.build:gradle:7.4.2")
-  implementation("com.google.code.gson:gson:2.8.9")
-  implementation("com.google.guava:guava:31.0.1-jre")
-  implementation("com.squareup:javapoet:1.13.0")
 
-  testImplementation("junit:junit:4.13.2")
+  // The KGP/AGP version is defined by React Native Gradle plugin.
+  // Therefore we specify an implementation dep rather than a compileOnly.
+  implementation(libs.kotlin.gradle.plugin)
+  implementation(libs.android.gradle.plugin)
+
+  implementation(libs.gson)
+  implementation(libs.guava)
+  implementation(libs.javapoet)
+
+  testImplementation(libs.junit)
 
   testRuntimeOnly(
       files(
@@ -49,16 +54,18 @@ dependencies {
               .first()))
 }
 
-java {
-  sourceCompatibility = JavaVersion.VERSION_11
-  targetCompatibility = JavaVersion.VERSION_11
-}
+// We intentionally don't build for Java 17 as users will see a cryptic bytecode version
+// error first. Instead we produce a Java 11-compatible Gradle Plugin, so that AGP can print their
+// nice message showing that JDK 11 (or 17) is required first
+java { targetCompatibility = JavaVersion.VERSION_11 }
+
+kotlin { jvmToolchain(17) }
 
-tasks.withType<KotlinCompile> {
+tasks.withType<KotlinCompile>().configureEach {
   kotlinOptions {
-    jvmTarget = JavaVersion.VERSION_11.majorVersion
     apiVersion = "1.5"
-    languageVersion = "1.5"
+    // See comment above on JDK 11 support
+    jvmTarget = "11"
   }
 }
 

package/gradle/libs.versions.toml

@@ -0,0 +1,18 @@
+[versions]
+agp = "8.1.1"
+gson = "2.8.9"
+guava = "31.0.1-jre"
+javapoet = "1.13.0"
+junit = "4.13.2"
+kotlin = "1.8.0"
+
+[libraries]
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+android-gradle-plugin = { module = "com.android.tools.build:gradle", version.ref = "agp" }
+gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
+guava = { module = "com.google.guava:guava", version.ref = "guava" }
+javapoet = { module = "com.squareup:javapoet", version.ref = "javapoet" }
+junit = {module = "junit:junit", version.ref = "junit" }
+
+[plugins]
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }

package/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-all.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package/gradlew

@@ -55,7 +55,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +80,11 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -133,22 +131,29 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -193,6 +198,10 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
 # Collect all arguments for the java command;
 #   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
 #     shell script including quotes and variable substitutions, so put them in

package/gradlew.bat

@@ -26,6 +26,7 @@ if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
 if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 

package/package.json

@@ -1,19 +1,28 @@
 {
   "name": "@react-native/gradle-plugin",
-  "version": "0.73.0",
-  "description": "⚛️ Gradle Plugin for React Native",
-  "homepage": "https://github.com/facebook/react-native/tree/HEAD/packages/react-native-gradle-plugin",
+  "version": "0.73.1",
+  "description": "Gradle Plugin for React Native",
+  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git@github.com:facebook/react-native.git",
+    "url": "https://github.com/facebook/react-native.git",
     "directory": "packages/react-native-gradle-plugin"
   },
+  "homepage": "https://github.com/facebook/react-native/tree/HEAD/packages/react-native-gradle-plugin#readme",
+  "keywords": [
+    "gradle",
+    "plugin",
+    "react-native"
+  ],
+  "bugs": "https://github.com/facebook/react-native/issues",
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
     "build": "./gradlew build",
     "clean": "./gradlew clean",
     "test": "./gradlew check"
   },
-  "license": "MIT",
   "files": [
     "settings.gradle.kts",
     "build.gradle.kts",

package/settings.gradle.kts

@@ -13,4 +13,6 @@ pluginManagement {
   }
 }
 
+plugins { id("org.gradle.toolchains.foojay-resolver-convention").version("0.5.0") }
+
 rootProject.name = "react-native-gradle-plugin"

package/src/main/kotlin/com/facebook/react/ReactPlugin.kt

@@ -10,7 +10,6 @@ package com.facebook.react
 import com.android.build.api.variant.AndroidComponentsExtension
 import com.android.build.gradle.internal.tasks.factory.dependsOn
 import com.facebook.react.internal.PrivateReactExtension
-import com.facebook.react.tasks.BuildCodegenCLITask
 import com.facebook.react.tasks.GenerateCodegenArtifactsTask
 import com.facebook.react.tasks.GenerateCodegenSchemaTask
 import com.facebook.react.utils.AgpConfiguratorUtils.configureBuildConfigFields
@@ -18,7 +17,8 @@ import com.facebook.react.utils.AgpConfiguratorUtils.configureDevPorts
 import com.facebook.react.utils.BackwardCompatUtils.configureBackwardCompatibilityReactMap
 import com.facebook.react.utils.DependencyUtils.configureDependencies
 import com.facebook.react.utils.DependencyUtils.configureRepositories
-import com.facebook.react.utils.DependencyUtils.readVersionString
+import com.facebook.react.utils.DependencyUtils.readVersionAndGroupStrings
+import com.facebook.react.utils.JdkConfiguratorUtils.configureJavaToolChains
 import com.facebook.react.utils.JsonUtils
 import com.facebook.react.utils.NdkConfiguratorUtils.configureReactNativeNdk
 import com.facebook.react.utils.ProjectUtils.needsCodegenFromPackageJson
@@ -28,6 +28,8 @@ import kotlin.system.exitProcess
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.file.Directory
+import org.gradle.api.provider.Provider
 import org.gradle.internal.jvm.Jvm
 
 class ReactPlugin : Plugin<Project> {
@@ -54,13 +56,15 @@ class ReactPlugin : Plugin<Project> {
       project.afterEvaluate {
         val reactNativeDir = extension.reactNativeDir.get().asFile
         val propertiesFile = File(reactNativeDir, "ReactAndroid/gradle.properties")
-        val versionString = readVersionString(propertiesFile)
-        configureDependencies(project, versionString)
+        val versionAndGroupStrings = readVersionAndGroupStrings(propertiesFile)
+        val versionString = versionAndGroupStrings.first
+        val groupString = versionAndGroupStrings.second
+        configureDependencies(project, versionString, groupString)
         configureRepositories(project, reactNativeDir)
       }
 
       configureReactNativeNdk(project, extension)
-      configureBuildConfigFields(project)
+      configureBuildConfigFields(project, extension)
       configureDevPorts(project)
       configureBackwardCompatibilityReactMap(project)
 
@@ -76,17 +80,20 @@ class ReactPlugin : Plugin<Project> {
     project.pluginManager.withPlugin("com.android.library") {
       configureCodegen(project, extension, rootExtension, isLibrary = true)
     }
+
+    // Library and App Configurations
+    configureJavaToolChains(project)
   }
 
   private fun checkJvmVersion(project: Project) {
     val jvmVersion = Jvm.current()?.javaVersion?.majorVersion
-    if ((jvmVersion?.toIntOrNull() ?: 0) <= 8) {
+    if ((jvmVersion?.toIntOrNull() ?: 0) <= 16) {
       project.logger.error(
           """
 
       ********************************************************************************
 
-      ERROR: requires JDK11 or higher.
+      ERROR: requires JDK17 or higher.
       Incompatible major version detected: '$jvmVersion'
 
       ********************************************************************************
@@ -106,7 +113,8 @@ class ReactPlugin : Plugin<Project> {
       isLibrary: Boolean
   ) {
     // First, we set up the output dir for the codegen.
-    val generatedSrcDir = File(project.buildDir, "generated/source/codegen")
+    val generatedSrcDir: Provider<Directory> =
+        project.layout.buildDirectory.dir("generated/source/codegen")
 
     // We specify the default value (convention) for jsRootDir.
     // It's the root folder for apps (so ../../ from the Gradle project)
@@ -117,24 +125,10 @@ class ReactPlugin : Plugin<Project> {
       localExtension.jsRootDir.convention(localExtension.root)
     }
 
-    val buildCodegenTask =
-        project.tasks.register("buildCodegenCLI", BuildCodegenCLITask::class.java) {
-          it.codegenDir.set(rootExtension.codegenDir)
-          val bashWindowsHome = project.findProperty("REACT_WINDOWS_BASH") as String?
-          it.bashWindowsHome.set(bashWindowsHome)
-
-          // Please note that appNeedsCodegen is triggering a read of the package.json at
-          // configuration time as we need to feed the onlyIf condition of this task.
-          // Therefore, the appNeedsCodegen needs to be invoked inside this lambda.
-          val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(rootExtension.root)
-          it.onlyIf { isLibrary || needsCodegenFromPackageJson }
-        }
-
     // We create the task to produce schema from JS files.
     val generateCodegenSchemaTask =
         project.tasks.register(
             "generateCodegenSchemaFromJavaScript", GenerateCodegenSchemaTask::class.java) { it ->
-              it.dependsOn(buildCodegenTask)
               it.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
               it.codegenDir.set(rootExtension.codegenDir)
               it.generatedSrcDir.set(generatedSrcDir)
@@ -143,7 +137,7 @@ class ReactPlugin : Plugin<Project> {
               // the `jsRootDir` @Input property of this task & the onlyIf. Therefore, the
               // parsePackageJson should be invoked inside this lambda.
               val packageJson = findPackageJsonFile(project, rootExtension.root)
-              val parsedPackageJson = packageJson?.let { JsonUtils.fromCodegenJson(it) }
+              val parsedPackageJson = packageJson?.let { JsonUtils.fromPackageJson(it) }
 
               val jsSrcsDirInPackageJson = parsedPackageJson?.codegenConfig?.jsSrcsDir
               if (jsSrcsDirInPackageJson != null) {
@@ -181,7 +175,7 @@ class ReactPlugin : Plugin<Project> {
     //
     // android { sourceSets { main { java { srcDirs += "$generatedSrcDir/java" } } } }
     project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
-      ext.sourceSets.getByName("main").java.srcDir(File(generatedSrcDir, "java"))
+      ext.sourceSets.getByName("main").java.srcDir(generatedSrcDir.get().dir("java").asFile)
     }
 
     // `preBuild` is one of the base tasks automatically registered by AGP.

package/src/main/kotlin/com/facebook/react/TaskConfiguration.kt

@@ -48,7 +48,7 @@ internal fun Project.configureReactTasks(variant: Variant, config: ReactExtensio
   val isDebuggableVariant =
       config.debuggableVariants.get().any { it.equals(variant.name, ignoreCase = true) }
 
-  configureNewArchPackagingOptions(project, variant)
+  configureNewArchPackagingOptions(project, config, variant)
   configureJsEnginePackagingOptions(config, variant, isHermesEnabledInThisVariant)
 
   if (!isDebuggableVariant) {

package/src/main/kotlin/com/facebook/react/internal/PrivateReactExtension.kt

@@ -30,7 +30,7 @@ abstract class PrivateReactExtension @Inject constructor(project: Project) {
           .directoryProperty()
           .convention(
               // This is the default for the project root if the users hasn't specified anything.
-              // If the project is called "react-native-github"
+              // If the project is called "react-native-github" or "react-native-build-from-source"
               //   - We're inside the Github Repo -> root is defined by RN Tester (so no default
               // needed)
               //   - We're inside an includedBuild as we're performing a build from source
@@ -39,7 +39,8 @@ abstract class PrivateReactExtension @Inject constructor(project: Project) {
               //   - We're inside a user project, so inside the ./android folder. Default should be
               // ../
               // User can always override this default by setting a `root =` inside the template.
-              if (project.rootProject.name == "react-native-github") {
+              if (project.rootProject.name == "react-native-github" ||
+                  project.rootProject.name == "react-native-build-from-source") {
                 project.rootProject.layout.projectDirectory.dir("../../")
               } else {
                 project.rootProject.layout.projectDirectory.dir("../")

package/src/main/kotlin/com/facebook/react/model/ModelPackageJson.kt

@@ -7,4 +7,4 @@
 
 package com.facebook.react.model
 
-data class ModelPackageJson(val codegenConfig: ModelCodegenConfig?)
+data class ModelPackageJson(val version: String, val codegenConfig: ModelCodegenConfig?)

package/src/main/kotlin/com/facebook/react/tasks/BundleHermesCTask.kt

@@ -174,6 +174,7 @@ abstract class BundleHermesCTask : DefaultTask() {
     return windowsAwareCommandLine(
         hermesCommand,
         "-emit-binary",
+        "-max-diagnostic-width=80",
         "-out",
         bytecodeFile.cliPath(rootFile),
         bundleFile.cliPath(rootFile),

package/src/main/kotlin/com/facebook/react/tasks/GenerateCodegenArtifactsTask.kt

@@ -53,7 +53,7 @@ abstract class GenerateCodegenArtifactsTask : Exec() {
   internal fun resolveTaskParameters(): Pair<String, String> {
     val parsedPackageJson =
         if (packageJsonFile.isPresent && packageJsonFile.get().asFile.exists()) {
-          JsonUtils.fromCodegenJson(packageJsonFile.get().asFile)
+          JsonUtils.fromPackageJson(packageJsonFile.get().asFile)
         } else {
           null
         }

package/src/main/kotlin/com/facebook/react/tasks/GenerateCodegenSchemaTask.kt

@@ -35,13 +35,8 @@ abstract class GenerateCodegenSchemaTask : Exec() {
       project.fileTree(jsRootDir) {
         it.include("**/*.js")
         it.include("**/*.ts")
-        // Those are known build paths where the source map or other
-        // .js files could be stored/generated. We want to make sure we don't pick them up
-        // for execution avoidance.
-        it.exclude("**/build/ASSETS/**/*")
-        it.exclude("**/build/RES/**/*")
-        it.exclude("**/build/generated/**/*")
-        it.exclude("**/build/intermediates/**/*")
+        // We want to exclude the build directory, to don't pick them up for execution avoidance.
+        it.exclude("**/build/**/*")
       }
 
   @get:OutputFile

package/src/main/kotlin/com/facebook/react/tasks/{BuildCodegenCLITask.kt → internal/BuildCodegenCLITask.kt}

@@ -5,12 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.tasks
+package com.facebook.react.tasks.internal
 
 import com.facebook.react.utils.Os.unixifyPath
 import com.facebook.react.utils.windowsAwareBashCommandLine
 import org.gradle.api.file.DirectoryProperty
-import org.gradle.api.file.FileCollection
+import org.gradle.api.file.FileTree
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 
@@ -27,21 +27,14 @@ abstract class BuildCodegenCLITask : Exec() {
   @get:Internal abstract val bashWindowsHome: Property<String>
 
   @get:InputFiles
-  val input: FileCollection by lazy {
-    codegenDir.get().files("scripts", "src", "package.json", ".babelrc", ".prettierrc")
-  }
-
-  @get:OutputDirectories
-  val output: FileCollection by lazy { codegenDir.get().files("lib", "node_modules") }
-
-  init {
-    // We need this condition as we want a single instance of BuildCodegenCLITask to execute
-    // per project. Therefore we can safely skip the task if the lib/cli/ folder is available.
-    onlyIf {
-      val cliDir = codegenDir.file("lib/cli/").get().asFile
-      !cliDir.exists() || cliDir.listFiles()?.size == 0
-    }
-  }
+  val inputFiles: FileTree = project.fileTree(codegenDir) { it.include("src/**/*.js") }
+
+  @get:OutputFiles
+  val outputFiles: FileTree =
+      project.fileTree(codegenDir) {
+        it.include("lib/**/*.js")
+        it.include("lib/**/*.js.flow")
+      }
 
   override fun exec() {
     commandLine(

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

@@ -8,6 +8,7 @@
 package com.facebook.react.utils
 
 import com.android.build.api.variant.AndroidComponentsExtension
+import com.facebook.react.ReactExtension
 import com.facebook.react.utils.ProjectUtils.isHermesEnabled
 import com.facebook.react.utils.ProjectUtils.isNewArchEnabled
 import org.gradle.api.Action
@@ -17,12 +18,15 @@ import org.gradle.api.plugins.AppliedPlugin
 @Suppress("UnstableApiUsage")
 internal object AgpConfiguratorUtils {
 
-  fun configureBuildConfigFields(project: Project) {
+  fun configureBuildConfigFields(project: Project, extension: ReactExtension) {
     val action =
         Action<AppliedPlugin> {
           project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
+            ext.buildFeatures.buildConfig = true
             ext.defaultConfig.buildConfigField(
-                "boolean", "IS_NEW_ARCHITECTURE_ENABLED", project.isNewArchEnabled.toString())
+                "boolean",
+                "IS_NEW_ARCHITECTURE_ENABLED",
+                project.isNewArchEnabled(extension).toString())
             ext.defaultConfig.buildConfigField(
                 "boolean", "IS_HERMES_ENABLED", project.isHermesEnabled.toString())
           }

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

@@ -7,6 +7,11 @@
 
 package com.facebook.react.utils
 
+import com.facebook.react.utils.PropertyUtils.DEFAULT_INTERNAL_PUBLISHING_GROUP
+import com.facebook.react.utils.PropertyUtils.INTERNAL_PUBLISHING_GROUP
+import com.facebook.react.utils.PropertyUtils.INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO
+import com.facebook.react.utils.PropertyUtils.INTERNAL_USE_HERMES_NIGHTLY
+import com.facebook.react.utils.PropertyUtils.INTERNAL_VERSION_NAME
 import java.io.File
 import java.net.URI
 import java.util.*
@@ -22,8 +27,8 @@ internal object DependencyUtils {
   fun configureRepositories(project: Project, reactNativeDir: File) {
     project.rootProject.allprojects { eachProject ->
       with(eachProject) {
-        if (hasProperty("REACT_NATIVE_MAVEN_LOCAL_REPO")) {
-          val mavenLocalRepoPath = property("REACT_NATIVE_MAVEN_LOCAL_REPO") as String
+        if (hasProperty(INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO)) {
+          val mavenLocalRepoPath = property(INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO) as String
           mavenRepoFromURI(File(mavenLocalRepoPath).toURI())
         }
         // We add the snapshot for users on nightlies.
@@ -43,10 +48,15 @@ internal object DependencyUtils {
   /**
    * This method takes care of configuring the resolution strategy for both the app and all the 3rd
    * party libraries which are auto-linked. Specifically it takes care of:
-   * - Forcing the react-android/hermes-android version to the one specified in the package.json
+   * - Forcing the react-android/hermes-android/flipper-integration version to the one specified in
+   *   the package.json
    * - Substituting `react-native` with `react-android` and `hermes-engine` with `hermes-android`.
    */
-  fun configureDependencies(project: Project, versionString: String) {
+  fun configureDependencies(
+      project: Project,
+      versionString: String,
+      groupString: String = DEFAULT_INTERNAL_PUBLISHING_GROUP
+  ) {
     if (versionString.isBlank()) return
     project.rootProject.allprojects { eachProject ->
       eachProject.configurations.all { configuration ->
@@ -55,33 +65,69 @@ internal object DependencyUtils {
         // This allows users to import libraries that are still using
         // implementation("com.facebook.react:react-native:+") and resolve the right dependency.
         configuration.resolutionStrategy.dependencySubstitution {
-          it.substitute(it.module("com.facebook.react:react-native"))
-              .using(it.module("com.facebook.react:react-android:${versionString}"))
-              .because(
-                  "The react-native artifact was deprecated in favor of react-android due to https://github.com/facebook/react-native/issues/35210.")
-          it.substitute(it.module("com.facebook.react:hermes-engine"))
-              .using(it.module("com.facebook.react:hermes-android:${versionString}"))
-              .because(
-                  "The hermes-engine artifact was deprecated in favor of hermes-android due to https://github.com/facebook/react-native/issues/35210.")
+          getDependencySubstitutions(versionString, groupString).forEach { (module, dest, reason) ->
+            it.substitute(it.module(module)).using(it.module(dest)).because(reason)
+          }
         }
         configuration.resolutionStrategy.force(
-            "com.facebook.react:react-android:${versionString}",
-            "com.facebook.react:hermes-android:${versionString}",
+            "${groupString}:react-android:${versionString}",
+            "${groupString}:flipper-integration:${versionString}",
         )
+        if (!(eachProject.findProperty(INTERNAL_USE_HERMES_NIGHTLY) as? String).toBoolean()) {
+          // Contributors only: The hermes-engine version is forced only if the user has
+          // not opted into using nightlies for local development.
+          configuration.resolutionStrategy.force("${groupString}:hermes-android:${versionString}")
+        }
       }
     }
   }
 
-  fun readVersionString(propertiesFile: File): String {
+  internal fun getDependencySubstitutions(
+      versionString: String,
+      groupString: String = DEFAULT_INTERNAL_PUBLISHING_GROUP
+  ): List<Triple<String, String, String>> {
+    val dependencySubstitution = mutableListOf<Triple<String, String, String>>()
+    dependencySubstitution.add(
+        Triple(
+            "com.facebook.react:react-native",
+            "${groupString}:react-android:${versionString}",
+            "The react-native artifact was deprecated in favor of react-android due to https://github.com/facebook/react-native/issues/35210."))
+    dependencySubstitution.add(
+        Triple(
+            "com.facebook.react:hermes-engine",
+            "${groupString}:hermes-android:${versionString}",
+            "The hermes-engine artifact was deprecated in favor of hermes-android due to https://github.com/facebook/react-native/issues/35210."))
+    if (groupString != DEFAULT_INTERNAL_PUBLISHING_GROUP) {
+      dependencySubstitution.add(
+          Triple(
+              "com.facebook.react:react-android",
+              "${groupString}:react-android:${versionString}",
+              "The react-android dependency was modified to use the correct Maven group."))
+      dependencySubstitution.add(
+          Triple(
+              "com.facebook.react:hermes-android",
+              "${groupString}:hermes-android:${versionString}",
+              "The hermes-android dependency was modified to use the correct Maven group."))
+    }
+    return dependencySubstitution
+  }
+
+  fun readVersionAndGroupStrings(propertiesFile: File): Pair<String, String> {
     val reactAndroidProperties = Properties()
     propertiesFile.inputStream().use { reactAndroidProperties.load(it) }
-    val versionString = reactAndroidProperties["VERSION_NAME"] as? String ?: ""
+    val versionStringFromFile = reactAndroidProperties[INTERNAL_VERSION_NAME] as? String ?: ""
     // If on a nightly, we need to fetch the -SNAPSHOT artifact from Sonatype.
-    return if (versionString.startsWith("0.0.0")) {
-      "$versionString-SNAPSHOT"
-    } else {
-      versionString
-    }
+    val versionString =
+        if (versionStringFromFile.startsWith("0.0.0") || "-nightly-" in versionStringFromFile) {
+          "$versionStringFromFile-SNAPSHOT"
+        } else {
+          versionStringFromFile
+        }
+    // Returns Maven group for repos using different group for Maven artifacts
+    val groupString =
+        reactAndroidProperties[INTERNAL_PUBLISHING_GROUP] as? String
+            ?: DEFAULT_INTERNAL_PUBLISHING_GROUP
+    return Pair(versionString, groupString)
   }
 
   fun Project.mavenRepoFromUrl(url: String): MavenArtifactRepository =

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

@@ -0,0 +1,52 @@
+/*
+ * 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.facebook.react.utils.PropertyUtils.INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT
+import org.gradle.api.Action
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import org.gradle.api.plugins.AppliedPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinTopLevelExtension
+
+internal object JdkConfiguratorUtils {
+  /**
+   * Function that takes care of configuring the JDK toolchain for all the projects projects. As we
+   * do decide the JDK version based on the AGP version that RNGP brings over, here we can safely
+   * configure the toolchain to 17.
+   */
+  fun configureJavaToolChains(input: Project) {
+    // Check at the app level if react.internal.disableJavaVersionAlignment is set.
+    if (input.hasProperty(INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT)) {
+      return
+    }
+    input.rootProject.allprojects { project ->
+      // Allows every single module to set react.internal.disableJavaVersionAlignment also.
+      if (project.hasProperty(INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT)) {
+        return@allprojects
+      }
+      val action =
+          Action<AppliedPlugin> {
+            project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext
+              ->
+              ext.compileOptions.sourceCompatibility = JavaVersion.VERSION_17
+              ext.compileOptions.targetCompatibility = JavaVersion.VERSION_17
+            }
+          }
+      project.pluginManager.withPlugin("com.android.application", action)
+      project.pluginManager.withPlugin("com.android.library", action)
+      project.pluginManager.withPlugin("org.jetbrains.kotlin.android") {
+        project.extensions.getByType(KotlinTopLevelExtension::class.java).jvmToolchain(17)
+      }
+      project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+        project.extensions.getByType(KotlinTopLevelExtension::class.java).jvmToolchain(17)
+      }
+    }
+  }
+}

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

@@ -14,7 +14,7 @@ import java.io.File
 object JsonUtils {
   private val gsonConverter = Gson()
 
-  fun fromCodegenJson(input: File): ModelPackageJson? =
+  fun fromPackageJson(input: File): ModelPackageJson? =
       input.bufferedReader().use {
         runCatching { gsonConverter.fromJson(it, ModelPackageJson::class.java) }.getOrNull()
       }

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

@@ -20,7 +20,7 @@ internal object NdkConfiguratorUtils {
   fun configureReactNativeNdk(project: Project, extension: ReactExtension) {
     project.pluginManager.withPlugin("com.android.application") {
       project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
-        if (!project.isNewArchEnabled) {
+        if (!project.isNewArchEnabled(extension)) {
           // For Old Arch, we don't need to setup the NDK
           return@finalizeDsl
         }
@@ -40,16 +40,22 @@ internal object NdkConfiguratorUtils {
         // 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 (cmakeArgs.none { it.startsWith("-DPROJECT_BUILD_DIR") }) {
+          cmakeArgs.add("-DPROJECT_BUILD_DIR=${project.layout.buildDirectory.get().asFile}")
         }
-        if ("-DREACT_ANDROID_DIR" !in cmakeArgs) {
+        if (cmakeArgs.none { it.startsWith("-DREACT_ANDROID_DIR") }) {
           cmakeArgs.add(
               "-DREACT_ANDROID_DIR=${extension.reactNativeDir.file("ReactAndroid").get().asFile}")
         }
-        if ("-DANDROID_STL" !in cmakeArgs) {
+        if (cmakeArgs.none { it.startsWith("-DANDROID_STL") }) {
           cmakeArgs.add("-DANDROID_STL=c++_shared")
         }
+        // Due to the new NDK toolchain file, the C++ flags gets overridden between compilation
+        // units. This is causing some libraries to don't be compiled with -DANDROID and other
+        // crucial flags. This can be revisited once we bump to NDK 25/26
+        if (cmakeArgs.none { it.startsWith("-DANDROID_USE_LEGACY_TOOLCHAIN_FILE") }) {
+          cmakeArgs.add("-DANDROID_USE_LEGACY_TOOLCHAIN_FILE=ON")
+        }
 
         val architectures = project.getReactNativeArchitectures()
         // abiFilters are split ABI are not compatible each other, so we set the abiFilters
@@ -68,11 +74,12 @@ internal object NdkConfiguratorUtils {
    */
   fun configureNewArchPackagingOptions(
       project: Project,
-      variant: Variant,
+      extension: ReactExtension,
+      variant: Variant
   ) {
-    if (!project.isNewArchEnabled) {
+    if (!project.isNewArchEnabled(extension)) {
       // For Old Arch, we set a pickFirst only on libraries that we know are
-      // clashing with our direct dependencies (FBJNI, Flipper and Hermes).
+      // clashing with our direct dependencies (mainly FBJNI and Hermes).
       variant.packaging.jniLibs.pickFirsts.addAll(
           listOf(
               "**/libfbjni.so",
@@ -101,6 +108,7 @@ internal object NdkConfiguratorUtils {
               "**/libreact_render_graphics.so",
               "**/libreact_render_imagemanager.so",
               "**/libreact_render_mapbuffer.so",
+              "**/libreact_utils.so",
               "**/librrc_image.so",
               "**/librrc_legacyviewmanagerinterop.so",
               "**/librrc_view.so",

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

@@ -103,8 +103,8 @@ private fun detectCliFile(reactNativeRoot: File, preconfiguredCliFile: File?): F
   error(
       """
       Couldn't determine CLI location!
-      
-      Please set `react { cliFile = file(...) }` inside your 
+
+      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`
     """
@@ -224,7 +224,7 @@ internal fun readPackageJsonFile(
     rootProperty: DirectoryProperty
 ): ModelPackageJson? {
   val packageJson = findPackageJsonFile(project, rootProperty)
-  return packageJson?.let { JsonUtils.fromCodegenJson(it) }
+  return packageJson?.let { JsonUtils.fromPackageJson(it) }
 }
 
 private const val HERMESC_IN_REACT_NATIVE_DIR = "node_modules/react-native/sdks/hermesc/%OS-BIN%/"

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

@@ -7,29 +7,46 @@
 
 package com.facebook.react.utils
 
+import com.facebook.react.ReactExtension
 import com.facebook.react.model.ModelPackageJson
 import com.facebook.react.utils.KotlinStdlibCompatUtils.lowercaseCompat
 import com.facebook.react.utils.KotlinStdlibCompatUtils.toBooleanStrictOrNullCompat
+import com.facebook.react.utils.PropertyUtils.HERMES_ENABLED
+import com.facebook.react.utils.PropertyUtils.NEW_ARCH_ENABLED
+import com.facebook.react.utils.PropertyUtils.REACT_NATIVE_ARCHITECTURES
+import com.facebook.react.utils.PropertyUtils.SCOPED_HERMES_ENABLED
+import com.facebook.react.utils.PropertyUtils.SCOPED_NEW_ARCH_ENABLED
+import com.facebook.react.utils.PropertyUtils.SCOPED_REACT_NATIVE_ARCHITECTURES
+import java.io.File
 import org.gradle.api.Project
 import org.gradle.api.file.DirectoryProperty
 
 internal object ProjectUtils {
-  internal val Project.isNewArchEnabled: Boolean
-    get() =
-        project.hasProperty("newArchEnabled") &&
-            project.property("newArchEnabled").toString().toBoolean()
 
   const val HERMES_FALLBACK = true
 
+  internal fun Project.isNewArchEnabled(extension: ReactExtension): Boolean {
+    return (project.hasProperty(NEW_ARCH_ENABLED) &&
+        project.property(NEW_ARCH_ENABLED).toString().toBoolean()) ||
+        (project.hasProperty(SCOPED_NEW_ARCH_ENABLED) &&
+            project.property(SCOPED_NEW_ARCH_ENABLED).toString().toBoolean()) ||
+        shouldEnableNewArchForReactNativeVersion(project.reactNativeDir(extension))
+  }
+
   internal val Project.isHermesEnabled: Boolean
     get() =
-        if (project.hasProperty("hermesEnabled")) {
+        if (project.hasProperty(HERMES_ENABLED) || project.hasProperty(SCOPED_HERMES_ENABLED)) {
+          val propertyString =
+              if (project.hasProperty(HERMES_ENABLED)) {
+                HERMES_ENABLED
+              } else {
+                SCOPED_HERMES_ENABLED
+              }
           project
-              .property("hermesEnabled")
+              .property(propertyString)
               .toString()
               .lowercaseCompat()
-              .toBooleanStrictOrNullCompat()
-              ?: true
+              .toBooleanStrictOrNullCompat() ?: true
         } else if (project.extensions.extraProperties.has("react")) {
           @Suppress("UNCHECKED_CAST")
           val reactMap = project.extensions.extraProperties.get("react") as? Map<String, Any?>
@@ -53,10 +70,48 @@ internal object ProjectUtils {
 
   internal fun Project.getReactNativeArchitectures(): List<String> {
     val architectures = mutableListOf<String>()
-    if (project.hasProperty("reactNativeArchitectures")) {
-      val architecturesString = project.property("reactNativeArchitectures").toString()
+    if (project.hasProperty(REACT_NATIVE_ARCHITECTURES)) {
+      val architecturesString = project.property(REACT_NATIVE_ARCHITECTURES).toString()
+      architectures.addAll(architecturesString.split(",").filter { it.isNotBlank() })
+    } else if (project.hasProperty(SCOPED_REACT_NATIVE_ARCHITECTURES)) {
+      val architecturesString = project.property(SCOPED_REACT_NATIVE_ARCHITECTURES).toString()
       architectures.addAll(architecturesString.split(",").filter { it.isNotBlank() })
     }
     return architectures
   }
+
+  internal fun Project.reactNativeDir(extension: ReactExtension): String =
+      extension.reactNativeDir.get().asFile.absolutePath
+
+  internal fun shouldEnableNewArchForReactNativeVersion(reactNativeDir: String): Boolean {
+    val packageJsonFile = File(reactNativeDir, "package.json")
+    if (!packageJsonFile.exists()) {
+      return false
+    }
+
+    val rnPackageJson = JsonUtils.fromPackageJson(packageJsonFile)
+    if (rnPackageJson == null) {
+      return false
+    }
+
+    // This regex describe the version syntax for React Native in the shape of
+    // major.minor.patch[-<prerelease>[[-.]k]]
+    // Where
+    // major is a number
+    // minor is a number
+    // patch is a number
+    // <prerelease>[-.]k is optional, but if present is preceeded by a `-`
+    // the <prerelease> tag is a string.
+    // it can be followed by `-` or `.` and k is a number.
+    val regex = """^(\d+)\.(\d+)\.(\d+)(?:-(\w+(?:[-.]\d+)?))?$""".toRegex()
+
+    val matchResult = regex.find(rnPackageJson.version)
+
+    if (matchResult == null) {
+      return false
+    }
+
+    val major = matchResult.groupValues[1].toInt()
+    return major > 0 && major < 1000
+  }
 }

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

@@ -0,0 +1,55 @@
+/*
+ * 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
+
+/** Collection of all the Gradle Properties that are accepted by React Native Gradle Plugin. */
+object PropertyUtils {
+
+  /** Public property that toggles the New Architecture */
+  const val NEW_ARCH_ENABLED = "newArchEnabled"
+  const val SCOPED_NEW_ARCH_ENABLED = "react.newArchEnabled"
+
+  /** Public property that toggles the New Architecture */
+  const val HERMES_ENABLED = "hermesEnabled"
+  const val SCOPED_HERMES_ENABLED = "react.hermesEnabled"
+
+  /** Public property that allows to control which architectures to build for React Native. */
+  const val REACT_NATIVE_ARCHITECTURES = "reactNativeArchitectures"
+  const val SCOPED_REACT_NATIVE_ARCHITECTURES = "react.nativeArchitectures"
+
+  /**
+   * Internal Property that acts as a killswitch to configure the JDK version and align it for app
+   * and all the libraries.
+   */
+  const val INTERNAL_DISABLE_JAVA_VERSION_ALIGNMENT = "react.internal.disableJavaVersionAlignment"
+
+  /**
+   * Internal Property that allows to specify a local Maven repository to use for React Native
+   * artifacts It's used on CI to test templates against a version of React Native built on the fly.
+   */
+  const val INTERNAL_REACT_NATIVE_MAVEN_LOCAL_REPO = "react.internal.mavenLocalRepo"
+
+  /**
+   * Internal property used to specify where the Windows Bash executable is located. This is useful
+   * for contributors who are running Windows on their machine.
+   */
+  const val INTERNAL_REACT_WINDOWS_BASH = "react.internal.windowsBashPath"
+
+  /**
+   * Internal property to force the build to use Hermes from the latest nightly. This speeds up the
+   * build at the cost of not testing the latest integration against Hermes.
+   */
+  const val INTERNAL_USE_HERMES_NIGHTLY = "react.internal.useHermesNightly"
+
+  /** Internal property used to override the publishing group for the React Native artifacts. */
+  const val INTERNAL_PUBLISHING_GROUP = "react.internal.publishingGroup"
+  const val DEFAULT_INTERNAL_PUBLISHING_GROUP = "com.facebook.react"
+
+  /** Internal property used to control the version name of React Native */
+  const val INTERNAL_VERSION_NAME = "VERSION_NAME"
+}