@ohos-ports/react-native-gradle-plugin 0.71.19-beta.0 → 0.86.0-beta.0

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/ReactPlugin.kt

@@ -0,0 +1,320 @@
+/*
+ * 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
+
+import com.android.build.api.variant.ApplicationAndroidComponentsExtension
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.gradle.internal.tasks.factory.dependsOn
+import com.facebook.react.internal.PrivateReactExtension
+import com.facebook.react.tasks.GenerateAutolinkingNewArchitecturesFileTask
+import com.facebook.react.tasks.GenerateCodegenArtifactsTask
+import com.facebook.react.tasks.GenerateCodegenSchemaTask
+import com.facebook.react.tasks.GenerateEntryPointTask
+import com.facebook.react.tasks.GeneratePackageListTask
+import com.facebook.react.utils.AgpConfiguratorUtils.configureBuildConfigFieldsForApp
+import com.facebook.react.utils.AgpConfiguratorUtils.configureBuildConfigFieldsForLibraries
+import com.facebook.react.utils.AgpConfiguratorUtils.configureBuildTypesForApp
+import com.facebook.react.utils.AgpConfiguratorUtils.configureDevServerLocation
+import com.facebook.react.utils.AgpConfiguratorUtils.configureNamespaceForLibraries
+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.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.isHermesV1Enabled
+import com.facebook.react.utils.ProjectUtils.needsCodegenFromPackageJson
+import com.facebook.react.utils.findPackageJsonFile
+import java.io.File
+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> {
+  override fun apply(project: Project) {
+    checkJvmVersion(project)
+    val extension = project.extensions.create("react", ReactExtension::class.java, project)
+
+    // We register a private extension on the rootProject so that project wide configs
+    // like codegen config can be propagated from app project to libraries.
+    val rootExtension =
+        project.rootProject.extensions.findByType(PrivateReactExtension::class.java)
+            ?: project.rootProject.extensions.create(
+                "privateReact",
+                PrivateReactExtension::class.java,
+                project,
+            )
+
+    if (!project.rootProject.isHermesV1Enabled) {
+      rootExtension.hermesV1Enabled.set(false)
+    }
+
+    // App Only Configuration
+    project.pluginManager.withPlugin("com.android.application") {
+      // We wire the root extension with the values coming from the app (either user populated or
+      // defaults).
+      rootExtension.root.set(extension.root)
+      rootExtension.reactNativeDir.set(extension.reactNativeDir)
+      rootExtension.codegenDir.set(extension.codegenDir)
+      rootExtension.nodeExecutableAndArgs.set(extension.nodeExecutableAndArgs)
+
+      project.afterEvaluate {
+        val reactNativeDir = extension.reactNativeDir.get().asFile
+        val propertiesFile = File(reactNativeDir, "ReactAndroid/gradle.properties")
+        val hermesVersionPropertiesFile =
+            File(reactNativeDir, "sdks/hermes-engine/version.properties")
+        val versionAndGroupStrings =
+            readVersionAndGroupStrings(project, propertiesFile, hermesVersionPropertiesFile)
+        val hermesV1Enabled = rootExtension.hermesV1Enabled.get()
+        configureDependencies(project, versionAndGroupStrings, hermesV1Enabled)
+        configureRepositories(project, versionAndGroupStrings.isNightly)
+      }
+
+      configureReactNativeNdk(project, extension)
+      configureBuildConfigFieldsForApp(project, extension)
+      configureDevServerLocation(project)
+      configureBackwardCompatibilityReactMap(project)
+      configureJavaToolChains(project)
+
+      project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java).apply {
+        onVariants(selector().all()) { variant ->
+          project.configureReactTasks(variant = variant, config = extension)
+        }
+      }
+      configureAutolinking(project, extension)
+      configureCodegen(project, extension, rootExtension, isLibrary = false)
+      configureResources(project, extension)
+      configureBuildTypesForApp(project)
+    }
+
+    // Library Only Configuration
+    configureBuildConfigFieldsForLibraries(project)
+    configureNamespaceForLibraries(project)
+    project.pluginManager.withPlugin("com.android.library") {
+      configureCodegen(project, extension, rootExtension, isLibrary = true)
+    }
+  }
+
+  private fun checkJvmVersion(project: Project) {
+    val jvmVersion = Jvm.current().javaVersion?.majorVersion
+    if ((jvmVersion?.toIntOrNull() ?: 0) <= 16) {
+      project.logger.error(
+          """
+
+      ********************************************************************************
+
+      ERROR: requires JDK17 or higher.
+      Incompatible major version detected: '$jvmVersion'
+
+      ********************************************************************************
+
+      """
+              .trimIndent()
+      )
+      exitProcess(1)
+    }
+  }
+
+  /** This function configures Android resources - in this case just the bundle */
+  private fun configureResources(project: Project, reactExtension: ReactExtension) {
+    project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java).finalizeDsl {
+        ext ->
+      val bundleFileExtension = reactExtension.bundleAssetName.get().substringAfterLast('.', "")
+      if (!reactExtension.enableBundleCompression.get() && bundleFileExtension.isNotBlank()) {
+        ext.androidResources.noCompress.add(bundleFileExtension)
+      }
+    }
+  }
+
+  /** This function sets up `react-native-codegen` in our Gradle plugin. */
+  @Suppress("UnstableApiUsage")
+  private fun configureCodegen(
+      project: Project,
+      localExtension: ReactExtension,
+      rootExtension: PrivateReactExtension,
+      isLibrary: Boolean,
+  ) {
+    // First, we set up the output dir for the 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)
+    // and the package folder for library (so ../ from the Gradle project)
+    if (isLibrary) {
+      localExtension.jsRootDir.convention(project.layout.projectDirectory.dir("../"))
+    } else {
+      localExtension.jsRootDir.convention(localExtension.root)
+    }
+
+    // We create the task to produce schema from JS files.
+    val generateCodegenSchemaTask =
+        project.tasks.register(
+            "generateCodegenSchemaFromJavaScript",
+            GenerateCodegenSchemaTask::class.java,
+        ) { it ->
+          it.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
+          it.codegenDir.set(rootExtension.codegenDir)
+          it.generatedSrcDir.set(generatedSrcDir)
+          it.nodeWorkingDir.set(project.layout.projectDirectory.asFile.absolutePath)
+
+          // We're reading the package.json at configuration time to properly feed
+          // 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.fromPackageJson(it) }
+
+          val jsSrcsDirInPackageJson = parsedPackageJson?.codegenConfig?.jsSrcsDir
+          val includesGeneratedCode =
+              parsedPackageJson?.codegenConfig?.includesGeneratedCode ?: false
+          if (jsSrcsDirInPackageJson != null) {
+            it.jsRootDir.set(File(packageJson.parentFile, jsSrcsDirInPackageJson))
+          } else {
+            it.jsRootDir.set(localExtension.jsRootDir)
+          }
+          it.jsInputFiles.set(
+              project.fileTree(it.jsRootDir) { tree ->
+                tree.include("**/*.js")
+                tree.include("**/*.jsx")
+                tree.include("**/*.ts")
+                tree.include("**/*.tsx")
+
+                tree.exclude("node_modules/**/*")
+                tree.exclude("**/*.d.ts")
+                // We want to exclude the build directory, to don't pick them up for execution
+                // avoidance.
+                tree.exclude("**/build/**/*")
+              }
+          )
+
+          val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(rootExtension.root)
+          it.onlyIf { (isLibrary || needsCodegenFromPackageJson) && !includesGeneratedCode }
+        }
+
+    // We create the task to generate Java code from schema.
+    val generateCodegenArtifactsTask =
+        project.tasks.register(
+            "generateCodegenArtifactsFromSchema",
+            GenerateCodegenArtifactsTask::class.java,
+        ) { task ->
+          task.dependsOn(generateCodegenSchemaTask)
+          task.reactNativeDir.set(rootExtension.reactNativeDir)
+          task.nodeExecutableAndArgs.set(rootExtension.nodeExecutableAndArgs)
+          task.generatedSrcDir.set(generatedSrcDir)
+          task.packageJsonFile.set(findPackageJsonFile(project, rootExtension.root))
+          task.codegenJavaPackageName.set(localExtension.codegenJavaPackageName)
+          task.libraryName.set(localExtension.libraryName)
+          task.nodeWorkingDir.set(project.layout.projectDirectory.asFile.absolutePath)
+
+          // 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)
+          val packageJson = findPackageJsonFile(project, rootExtension.root)
+          val parsedPackageJson = packageJson?.let { JsonUtils.fromPackageJson(it) }
+          val includesGeneratedCode =
+              parsedPackageJson?.codegenConfig?.includesGeneratedCode ?: false
+          task.onlyIf { (isLibrary || needsCodegenFromPackageJson) && !includesGeneratedCode }
+        }
+
+    // We update the android configuration to include the generated sources.
+    // This equivalent to this DSL:
+    //
+    // android { sourceSets { main { java { srcDirs += "$generatedSrcDir/java" } } } }
+    if (isLibrary) {
+      project.extensions.getByType(LibraryAndroidComponentsExtension::class.java).finalizeDsl { ext
+        ->
+        ext.sourceSets.getByName("main").java.srcDir(generatedSrcDir.get().dir("java").asFile)
+      }
+    } else {
+      project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java).finalizeDsl {
+          ext ->
+        ext.sourceSets.getByName("main").java.srcDir(generatedSrcDir.get().dir("java").asFile)
+      }
+    }
+
+    // `preBuild` is one of the base tasks automatically registered by AGP.
+    // This will invoke the codegen before compiling the entire project.
+    project.tasks.named("preBuild", Task::class.java).dependsOn(generateCodegenArtifactsTask)
+  }
+
+  /** This function sets up Autolinking for App users */
+  private fun configureAutolinking(
+      project: Project,
+      extension: ReactExtension,
+  ) {
+    val generatedAutolinkingJavaDir: Provider<Directory> =
+        project.layout.buildDirectory.dir("generated/autolinking/src/main/java")
+    val generatedAutolinkingJniDir: Provider<Directory> =
+        project.layout.buildDirectory.dir("generated/autolinking/src/main/jni")
+
+    // The autolinking.json file is available in the root build folder as it's generated
+    // by ReactSettingsPlugin.kt
+    val rootGeneratedAutolinkingFile =
+        project.rootProject.layout.buildDirectory.file("generated/autolinking/autolinking.json")
+
+    // We add a task called generateAutolinkingPackageList to do not clash with the existing task
+    // called generatePackageList. This can to be renamed once we unlink the rn <-> cli
+    // dependency.
+    val generatePackageListTask =
+        project.tasks.register(
+            "generateAutolinkingPackageList",
+            GeneratePackageListTask::class.java,
+        ) { task ->
+          task.autolinkInputFile.set(rootGeneratedAutolinkingFile)
+          task.generatedOutputDirectory.set(generatedAutolinkingJavaDir)
+        }
+
+    // We add a task called generateAutolinkingPackageList to do not clash with the existing task
+    // called generatePackageList. This can to be renamed once we unlink the rn <-> cli
+    // dependency.
+    val generateEntryPointTask =
+        project.tasks.register(
+            "generateReactNativeEntryPoint",
+            GenerateEntryPointTask::class.java,
+        ) { task ->
+          task.autolinkInputFile.set(rootGeneratedAutolinkingFile)
+          task.generatedOutputDirectory.set(generatedAutolinkingJavaDir)
+        }
+
+    // We also need to generate code for C++ Autolinking
+    val generateAutolinkingNewArchitectureFilesTask =
+        project.tasks.register(
+            "generateAutolinkingNewArchitectureFiles",
+            GenerateAutolinkingNewArchitecturesFileTask::class.java,
+        ) { task ->
+          task.autolinkInputFile.set(rootGeneratedAutolinkingFile)
+          task.generatedOutputDirectory.set(generatedAutolinkingJniDir)
+        }
+    project.tasks
+        .named("preBuild", Task::class.java)
+        .dependsOn(generateAutolinkingNewArchitectureFilesTask)
+
+    // We let generateAutolinkingPackageList and generateEntryPoint depend on the preBuild task so
+    // it's executed before
+    // everything else.
+    project.tasks
+        .named("preBuild", Task::class.java)
+        .dependsOn(generatePackageListTask, generateEntryPointTask)
+
+    // We tell Android Gradle Plugin that inside /build/generated/autolinking/src/main/java there
+    // are sources to be compiled as well.
+    project.extensions.getByType(ApplicationAndroidComponentsExtension::class.java).apply {
+      onVariants(selector().all()) { variant ->
+        variant.sources.java?.addStaticSourceDirectory(
+            generatedAutolinkingJavaDir.get().asFile.absolutePath
+        )
+      }
+    }
+  }
+}

package/react-native-gradle-plugin/src/main/kotlin/com/facebook/react/ReactRootProjectPlugin.kt

@@ -0,0 +1,86 @@
+/*
+ * 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
+
+import com.facebook.react.utils.PropertyUtils
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.jetbrains.kotlin.gradle.plugin.extraProperties
+
+/**
+ * Gradle plugin applied to the `android/build.gradle` file.
+ *
+ * This plugin allows to specify project wide configurations that can be applied to both apps and
+ * libraries before they're evaluated.
+ */
+class ReactRootProjectPlugin : Plugin<Project> {
+  override fun apply(project: Project) {
+    checkLegacyArchProperty(project)
+    project.subprojects { subproject ->
+      // As the :app project (i.e. ReactPlugin) configures both namespaces and JVM toolchains
+      // for libraries, its evaluation must happen before the libraries' evaluation.
+      // Eventually the configuration of namespace/JVM toolchain can be moved inside this plugin.
+      if (subproject.path != ":app") {
+        subproject.evaluationDependsOn(":app")
+      }
+      // We set the New Architecture properties to true for all subprojects. So that
+      // libraries don't need to be modified and can keep on using the isNewArchEnabled()
+      // function to check if property is set.
+      if (subproject.hasProperty(PropertyUtils.SCOPED_NEW_ARCH_ENABLED)) {
+        subproject.setProperty(PropertyUtils.SCOPED_NEW_ARCH_ENABLED, "true")
+      }
+      if (subproject.hasProperty(PropertyUtils.NEW_ARCH_ENABLED)) {
+        subproject.setProperty(PropertyUtils.NEW_ARCH_ENABLED, "true")
+      }
+      subproject.extraProperties.set(PropertyUtils.NEW_ARCH_ENABLED, "true")
+      subproject.extraProperties.set(PropertyUtils.SCOPED_NEW_ARCH_ENABLED, "true")
+    }
+    // We need to make sure that `:app:preBuild` task depends on all other subprojects' preBuild
+    // tasks. This is necessary in order to have all the codegen generated code before the CMake
+    // configuration build kicks in.
+    project.gradle.projectsEvaluated {
+      val appProject = project.rootProject.subprojects.find { it.name == "app" }
+      val appPreBuild = appProject?.tasks?.findByName("preBuild")
+      if (appPreBuild != null) {
+        // Find all other subprojects' preBuild tasks
+        val otherPreBuildTasks =
+            project.rootProject.subprojects
+                .filter { it != appProject }
+                .mapNotNull { it.tasks.findByName("preBuild") }
+        // Make :app:preBuild depend on all others
+        appPreBuild.dependsOn(otherPreBuildTasks)
+      }
+    }
+  }
+
+  private fun checkLegacyArchProperty(project: Project) {
+    if (
+        (project.hasProperty(PropertyUtils.NEW_ARCH_ENABLED) &&
+            !project.property(PropertyUtils.NEW_ARCH_ENABLED).toString().toBoolean()) ||
+            (project.hasProperty(PropertyUtils.SCOPED_NEW_ARCH_ENABLED) &&
+                !project.property(PropertyUtils.SCOPED_NEW_ARCH_ENABLED).toString().toBoolean())
+    ) {
+      project.logger.error(
+          """
+          ********************************************************************************
+
+          WARNING: Setting `newArchEnabled=false` in your `gradle.properties` file is not
+          supported anymore since React Native 0.82.
+
+          You can remove the line from your `gradle.properties` file.
+
+          The application will run with the New Architecture enabled by default.
+
+          ********************************************************************************
+
+          """
+              .trimIndent()
+      )
+    }
+  }
+}

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/TaskConfiguration.kt

@@ -9,9 +9,12 @@ package com.facebook.react
 
 import com.android.build.api.variant.Variant
 import com.facebook.react.tasks.BundleHermesCTask
+import com.facebook.react.utils.BackwardCompatUtils.showJSCRemovalMessage
+import com.facebook.react.utils.KotlinStdlibCompatUtils.capitalizeCompat
 import com.facebook.react.utils.NdkConfiguratorUtils.configureJsEnginePackagingOptions
 import com.facebook.react.utils.NdkConfiguratorUtils.configureNewArchPackagingOptions
 import com.facebook.react.utils.ProjectUtils.isHermesEnabled
+import com.facebook.react.utils.ProjectUtils.useThirdPartyJSC
 import com.facebook.react.utils.detectedCliFile
 import com.facebook.react.utils.detectedEntryFile
 import java.io.File
@@ -19,9 +22,10 @@ import org.gradle.api.Project
 
 @Suppress("SpreadOperator", "UnstableApiUsage")
 internal fun Project.configureReactTasks(variant: Variant, config: ReactExtension) {
-  val targetName = variant.name.replaceFirstChar { it.uppercase() }
+  val targetName = variant.name.capitalizeCompat()
   val targetPath = variant.name
 
+  val buildDir = layout.buildDirectory.get().asFile
   // Resources: generated/assets/react/<variant>/index.android.bundle
   val resourcesDir = File(buildDir, "generated/res/react/$targetPath")
   // Bundle: generated/assets/react/<variant>/index.android.bundle
@@ -46,36 +50,43 @@ internal fun Project.configureReactTasks(variant: Variant, config: ReactExtensio
       }
   val isDebuggableVariant =
       config.debuggableVariants.get().any { it.equals(variant.name, ignoreCase = true) }
+  val useThirdPartyJSC = project.useThirdPartyJSC
 
-  configureNewArchPackagingOptions(project, variant)
-  configureJsEnginePackagingOptions(config, variant, isHermesEnabledInThisVariant)
+  configureNewArchPackagingOptions(project, config, variant)
+  configureJsEnginePackagingOptions(config, variant, isHermesEnabledInThisVariant, useThirdPartyJSC)
+  if (
+      !isHermesEnabledInThisVariant &&
+          !useThirdPartyJSC &&
+          rootProject.name != "react-native-github"
+  ) {
+    showJSCRemovalMessage(project)
+  }
 
   if (!isDebuggableVariant) {
     val entryFileEnvVariable = System.getenv("ENTRY_FILE")
     val bundleTask =
-        tasks.register("createBundle${targetName}JsAndAssets", BundleHermesCTask::class.java) {
-          it.root.set(config.root)
-          it.nodeExecutableAndArgs.set(config.nodeExecutableAndArgs)
-          it.cliFile.set(cliFile)
-          it.bundleCommand.set(config.bundleCommand)
-          it.entryFile.set(detectedEntryFile(config, entryFileEnvVariable))
-          it.extraPackagerArgs.set(config.extraPackagerArgs)
-          it.bundleConfig.set(config.bundleConfig)
-          it.bundleAssetName.set(config.bundleAssetName)
-          it.jsBundleDir.set(jsBundleDir)
-          it.resourcesDir.set(resourcesDir)
-          it.hermesEnabled.set(isHermesEnabledInThisVariant)
-          it.minifyEnabled.set(!isHermesEnabledInThisVariant)
-          it.devEnabled.set(false)
-          it.jsIntermediateSourceMapsDir.set(jsIntermediateSourceMapsDir)
-          it.jsSourceMapsDir.set(jsSourceMapsDir)
-          it.hermesCommand.set(config.hermesCommand)
-          it.hermesFlags.set(config.hermesFlags)
-          it.reactNativeDir.set(config.reactNativeDir)
+        tasks.register("createBundle${targetName}JsAndAssets", BundleHermesCTask::class.java) { task
+          ->
+          task.root.set(config.root)
+          task.nodeExecutableAndArgs.set(config.nodeExecutableAndArgs)
+          task.cliFile.set(cliFile)
+          task.bundleCommand.set(config.bundleCommand)
+          task.entryFile.set(detectedEntryFile(config, entryFileEnvVariable))
+          task.extraPackagerArgs.set(config.extraPackagerArgs)
+          task.bundleConfig.set(config.bundleConfig)
+          task.bundleAssetName.set(config.bundleAssetName)
+          task.jsBundleDir.set(jsBundleDir)
+          task.resourcesDir.set(resourcesDir)
+          task.hermesEnabled.set(isHermesEnabledInThisVariant)
+          task.minifyEnabled.set(!isHermesEnabledInThisVariant)
+          task.devEnabled.set(false)
+          task.jsIntermediateSourceMapsDir.set(jsIntermediateSourceMapsDir)
+          task.jsSourceMapsDir.set(jsSourceMapsDir)
+          task.hermesCommand.set(config.hermesCommand)
+          task.hermesFlags.set(config.hermesFlags)
+          task.reactNativeDir.set(config.reactNativeDir)
         }
-    // Currently broken inside AGP 7.3 We need to wait for a release of AGP 7.4 in order to use
-    // the addGeneratedSourceDirectory API.
-    // variant.sources.res?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::resourcesDir)
+    variant.sources.res?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::resourcesDir)
     variant.sources.assets?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::jsBundleDir)
   }
 }

package/{src → react-native-gradle-plugin/src}/main/kotlin/com/facebook/react/internal/PrivateReactExtension.kt

@@ -11,6 +11,7 @@ import javax.inject.Inject
 import org.gradle.api.Project
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
 
 /**
  * A private extension we set on the rootProject to make easier to share values at execution time
@@ -30,7 +31,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,11 +40,15 @@ 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("../")
-              })
+              }
+          )
 
   val reactNativeDir: DirectoryProperty =
       objects.directoryProperty().convention(root.dir("node_modules/react-native"))
@@ -52,5 +57,7 @@ abstract class PrivateReactExtension @Inject constructor(project: Project) {
       objects.listProperty(String::class.java).convention(listOf("node"))
 
   val codegenDir: DirectoryProperty =
-      objects.directoryProperty().convention(root.dir("node_modules/react-native-codegen"))
+      objects.directoryProperty().convention(root.dir("node_modules/@react-native/codegen"))
+
+  val hermesV1Enabled: Property<Boolean> = objects.property(Boolean::class.java).convention(true)
 }