@react-native/gradle-plugin 0.72.2

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

@@ -0,0 +1,163 @@
+/*
+ * 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.AndroidComponentsExtension
+import com.android.build.gradle.internal.tasks.factory.dependsOn
+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
+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.JsonUtils
+import com.facebook.react.utils.NdkConfiguratorUtils.configureReactNativeNdk
+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.internal.jvm.Jvm
+
+class ReactPlugin : Plugin<Project> {
+  override fun apply(project: Project) {
+    checkJvmVersion(project)
+    val extension = project.extensions.create("react", ReactExtension::class.java, project)
+
+    // App Only Configuration
+    project.pluginManager.withPlugin("com.android.application") {
+      project.afterEvaluate {
+        val reactNativeDir = extension.reactNativeDir.get().asFile
+        val propertiesFile = File(reactNativeDir, "ReactAndroid/gradle.properties")
+        val versionString = readVersionString(propertiesFile)
+        configureDependencies(project, versionString)
+        configureRepositories(project, reactNativeDir)
+      }
+
+      configureReactNativeNdk(project, extension)
+      configureBuildConfigFields(project)
+      configureDevPorts(project)
+      configureBackwardCompatibilityReactMap(project)
+
+      project.extensions.getByType(AndroidComponentsExtension::class.java).apply {
+        onVariants(selector().all()) { variant ->
+          project.configureReactTasks(variant = variant, config = extension)
+        }
+      }
+      configureCodegen(project, extension, isLibrary = false)
+    }
+
+    // Library Only Configuration
+    project.pluginManager.withPlugin("com.android.library") {
+      configureCodegen(project, extension, isLibrary = true)
+    }
+  }
+
+  private fun checkJvmVersion(project: Project) {
+    val jvmVersion = Jvm.current()?.javaVersion?.majorVersion
+    if ((jvmVersion?.toIntOrNull() ?: 0) <= 8) {
+      project.logger.error(
+          """
+
+      ********************************************************************************
+
+      ERROR: requires JDK11 or higher.
+      Incompatible major version detected: '$jvmVersion'
+
+      ********************************************************************************
+
+      """
+              .trimIndent())
+      exitProcess(1)
+    }
+  }
+
+  /**
+   * A plugin to enable react-native-codegen in Gradle environment. See the Gradle API docs for more
+   * information: https://docs.gradle.org/current/javadoc/org/gradle/api/Project.html
+   */
+  @Suppress("UnstableApiUsage")
+  private fun configureCodegen(project: Project, extension: ReactExtension, isLibrary: Boolean) {
+    // First, we set up the output dir for the codegen.
+    val generatedSrcDir = File(project.buildDir, "generated/source/codegen")
+
+    val buildCodegenTask =
+        project.tasks.register("buildCodegenCLI", BuildCodegenCLITask::class.java) {
+          it.codegenDir.set(extension.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(extension)
+          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(extension.nodeExecutableAndArgs)
+              it.codegenDir.set(extension.codegenDir)
+              it.generatedSrcDir.set(generatedSrcDir)
+
+              // 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, extension)
+              val parsedPackageJson = packageJson?.let { JsonUtils.fromCodegenJson(it) }
+
+              val jsSrcsDirInPackageJson = parsedPackageJson?.codegenConfig?.jsSrcsDir
+              if (jsSrcsDirInPackageJson != null) {
+                it.jsRootDir.set(File(packageJson.parentFile, jsSrcsDirInPackageJson))
+              } else {
+                it.jsRootDir.set(extension.jsRootDir)
+              }
+              val needsCodegenFromPackageJson = project.needsCodegenFromPackageJson(extension)
+              it.onlyIf { isLibrary || needsCodegenFromPackageJson }
+            }
+
+    // We create the task to generate Java code from schema.
+    val generateCodegenArtifactsTask =
+        project.tasks.register(
+            "generateCodegenArtifactsFromSchema", GenerateCodegenArtifactsTask::class.java) {
+              it.dependsOn(generateCodegenSchemaTask)
+              it.reactNativeDir.set(extension.reactNativeDir)
+              it.nodeExecutableAndArgs.set(extension.nodeExecutableAndArgs)
+              it.generatedSrcDir.set(generatedSrcDir)
+              it.packageJsonFile.set(findPackageJsonFile(project, extension))
+              it.codegenJavaPackageName.set(extension.codegenJavaPackageName)
+              it.libraryName.set(extension.libraryName)
+
+              // 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(extension)
+              it.onlyIf { isLibrary || needsCodegenFromPackageJson }
+            }
+
+    // We update the android configuration to include the generated sources.
+    // This equivalent to this DSL:
+    //
+    // android { sourceSets { main { java { srcDirs += "$generatedSrcDir/java" } } } }
+    project.extensions.getByType(AndroidComponentsExtension::class.java).finalizeDsl { ext ->
+      ext.sourceSets.getByName("main").java.srcDir(File(generatedSrcDir, "java"))
+    }
+
+    // `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)
+  }
+}

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

@@ -0,0 +1,76 @@
+/*
+ * 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.Variant
+import com.facebook.react.tasks.BundleHermesCTask
+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.detectedCliFile
+import com.facebook.react.utils.detectedEntryFile
+import java.io.File
+import org.gradle.api.Project
+
+@Suppress("SpreadOperator", "UnstableApiUsage")
+internal fun Project.configureReactTasks(variant: Variant, config: ReactExtension) {
+  val targetName = variant.name.replaceFirstChar { it.uppercase() }
+  val targetPath = variant.name
+
+  // React js bundle directories
+  val resourcesDir = File(buildDir, "generated/res/react/$targetPath")
+  // Bundle: generated/assets/react/path/index.android.bundle
+  val jsBundleDir = File(buildDir, "generated/assets/react/$targetPath")
+  // Sourcemap: generated/sourcemaps/react/path/index.android.bundle.map
+  val jsSourceMapsDir = File(buildDir, "generated/sourcemaps/react/$targetPath")
+  // Intermediate packager: intermediates/sourcemaps/react/path/index.android.bundle.packager.map
+  // Intermediate compiler: intermediates/sourcemaps/react/path/index.android.bundle.compiler.map
+  val jsIntermediateSourceMapsDir = File(buildDir, "intermediates/sourcemaps/react/$targetPath")
+
+  // The location of the cli.js file for React Native
+  val cliFile = detectedCliFile(config)
+
+  val isHermesEnabledInProject = project.isHermesEnabled
+  val isHermesEnabledInThisVariant =
+      if (config.enableHermesOnlyInVariants.get().isNotEmpty()) {
+        config.enableHermesOnlyInVariants.get().contains(variant.name) && isHermesEnabledInProject
+      } else {
+        isHermesEnabledInProject
+      }
+  val isDebuggableVariant =
+      config.debuggableVariants.get().any { it.equals(variant.name, ignoreCase = true) }
+
+  configureNewArchPackagingOptions(project, variant)
+  configureJsEnginePackagingOptions(config, variant, isHermesEnabledInThisVariant)
+
+  if (!isDebuggableVariant) {
+    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))
+          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)
+        }
+    variant.sources.res?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::resourcesDir)
+    variant.sources.assets?.addGeneratedSourceDirectory(bundleTask, BundleHermesCTask::jsBundleDir)
+  }
+}

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

@@ -0,0 +1,15 @@
+/*
+ * 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.model
+
+data class ModelCodegenConfig(
+    val name: String?,
+    val type: String?,
+    val jsSrcsDir: String?,
+    val android: ModelCodegenConfigAndroid?
+)

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

@@ -0,0 +1,10 @@
+/*
+ * 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.model
+
+data class ModelCodegenConfigAndroid(val javaPackageName: String?)

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

@@ -0,0 +1,10 @@
+/*
+ * 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.model
+
+data class ModelPackageJson(val codegenConfig: ModelCodegenConfig?)

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

@@ -0,0 +1,58 @@
+/*
+ * 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.tasks
+
+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.provider.Property
+import org.gradle.api.tasks.*
+
+/**
+ * A Task that will call the `scripts/oss/build.sh` script to trigger the creation of the codegen
+ * lib artifacts.
+ *
+ * NOTE: This task is required when using react-native-codegen from source, instead of npm.
+ */
+abstract class BuildCodegenCLITask : Exec() {
+
+  @get:Internal abstract val codegenDir: DirectoryProperty
+
+  @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
+    }
+  }
+
+  override fun exec() {
+    commandLine(
+        windowsAwareBashCommandLine(
+            codegenDir.asFile.get().canonicalPath.unixifyPath().plus(BUILD_SCRIPT_PATH),
+            bashWindowsHome = bashWindowsHome.orNull,
+        ))
+    super.exec()
+  }
+
+  companion object {
+    private const val BUILD_SCRIPT_PATH = "/scripts/oss/build.sh"
+  }
+}

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

@@ -0,0 +1,190 @@
+/*
+ * 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.tasks
+
+import com.facebook.react.utils.detectOSAwareHermesCommand
+import com.facebook.react.utils.moveTo
+import com.facebook.react.utils.windowsAwareCommandLine
+import java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileTree
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+
+abstract class BundleHermesCTask : DefaultTask() {
+
+  init {
+    group = "react"
+  }
+
+  @get:Internal abstract val root: DirectoryProperty
+
+  @get:InputFiles
+  val sources: ConfigurableFileTree =
+      project.fileTree(root) {
+        it.include("**/*.js")
+        it.include("**/*.jsx")
+        it.include("**/*.ts")
+        it.include("**/*.tsx")
+        it.exclude("**/android/**/*")
+        it.exclude("**/ios/**/*")
+        it.exclude("**/build/**/*")
+        it.exclude("**/node_modules/**/*")
+      }
+
+  @get:Input abstract val nodeExecutableAndArgs: ListProperty<String>
+
+  @get:InputFile abstract val cliFile: RegularFileProperty
+
+  @get:Internal abstract val reactNativeDir: DirectoryProperty
+
+  @get:Input abstract val bundleCommand: Property<String>
+
+  @get:InputFile abstract val entryFile: RegularFileProperty
+
+  @get:InputFile @get:Optional abstract val bundleConfig: RegularFileProperty
+
+  @get:Input abstract val bundleAssetName: Property<String>
+
+  @get:Input abstract val minifyEnabled: Property<Boolean>
+
+  @get:Input abstract val hermesEnabled: Property<Boolean>
+
+  @get:Input abstract val devEnabled: Property<Boolean>
+
+  @get:Input abstract val extraPackagerArgs: ListProperty<String>
+
+  @get:Input abstract val hermesCommand: Property<String>
+
+  @get:Input abstract val hermesFlags: ListProperty<String>
+
+  @get:OutputDirectory abstract val jsBundleDir: DirectoryProperty
+
+  @get:OutputDirectory abstract val resourcesDir: DirectoryProperty
+
+  @get:OutputDirectory abstract val jsIntermediateSourceMapsDir: RegularFileProperty
+
+  @get:OutputDirectory abstract val jsSourceMapsDir: DirectoryProperty
+
+  @TaskAction
+  fun run() {
+    jsBundleDir.get().asFile.mkdirs()
+    resourcesDir.get().asFile.mkdirs()
+    jsIntermediateSourceMapsDir.get().asFile.mkdirs()
+    jsSourceMapsDir.get().asFile.mkdirs()
+    val bundleAssetFilename = bundleAssetName.get()
+
+    val bundleFile = File(jsBundleDir.get().asFile, bundleAssetFilename)
+    val packagerSourceMap = resolvePackagerSourceMapFile(bundleAssetFilename)
+
+    val bundleCommand = getBundleCommand(bundleFile, packagerSourceMap)
+    runCommand(bundleCommand)
+
+    if (hermesEnabled.get()) {
+      val detectedHermesCommand = detectOSAwareHermesCommand(root.get().asFile, hermesCommand.get())
+      val bytecodeFile = File("${bundleFile}.hbc")
+      val outputSourceMap = resolveOutputSourceMap(bundleAssetFilename)
+      val compilerSourceMap = resolveCompilerSourceMap(bundleAssetFilename)
+
+      val hermesCommand = getHermescCommand(detectedHermesCommand, bytecodeFile, bundleFile)
+      runCommand(hermesCommand)
+      bytecodeFile.moveTo(bundleFile)
+
+      if (hermesFlags.get().contains("-output-source-map")) {
+        val hermesTempSourceMapFile = File("$bytecodeFile.map")
+        hermesTempSourceMapFile.moveTo(compilerSourceMap)
+
+        val reactNativeDir = reactNativeDir.get().asFile
+        val composeScriptFile = File(reactNativeDir, "scripts/compose-source-maps.js")
+        val composeSourceMapsCommand =
+            getComposeSourceMapsCommand(
+                composeScriptFile, packagerSourceMap, compilerSourceMap, outputSourceMap)
+        runCommand(composeSourceMapsCommand)
+      }
+    }
+  }
+
+  internal fun resolvePackagerSourceMapFile(bundleAssetName: String) =
+      if (hermesEnabled.get()) {
+        File(jsIntermediateSourceMapsDir.get().asFile, "$bundleAssetName.packager.map")
+      } else {
+        resolveOutputSourceMap(bundleAssetName)
+      }
+
+  internal fun resolveOutputSourceMap(bundleAssetName: String) =
+      File(jsSourceMapsDir.get().asFile, "$bundleAssetName.map")
+
+  internal fun resolveCompilerSourceMap(bundleAssetName: String) =
+      File(jsIntermediateSourceMapsDir.get().asFile, "$bundleAssetName.compiler.map")
+
+  private fun runCommand(command: List<Any>) {
+    project.exec {
+      it.workingDir(root.get().asFile)
+      it.commandLine(command)
+    }
+  }
+
+  internal fun getBundleCommand(bundleFile: File, sourceMapFile: File): List<Any> =
+      windowsAwareCommandLine(
+          buildList {
+            addAll(nodeExecutableAndArgs.get())
+            add(cliFile.get().asFile.absolutePath)
+            add(bundleCommand.get())
+            add("--platform")
+            add("android")
+            add("--dev")
+            add(devEnabled.get().toString())
+            add("--reset-cache")
+            add("--entry-file")
+            add(entryFile.get().asFile.toString())
+            add("--bundle-output")
+            add(bundleFile.toString())
+            add("--assets-dest")
+            add(resourcesDir.get().asFile.toString())
+            add("--sourcemap-output")
+            add(sourceMapFile.toString())
+            if (bundleConfig.isPresent) {
+              add("--config")
+              add(bundleConfig.get().asFile.absolutePath)
+            }
+            add("--minify")
+            add(minifyEnabled.get().toString())
+            addAll(extraPackagerArgs.get())
+            add("--verbose")
+          })
+
+  internal fun getHermescCommand(
+      hermesCommand: String,
+      bytecodeFile: File,
+      bundleFile: File
+  ): List<Any> =
+      windowsAwareCommandLine(
+          hermesCommand,
+          "-emit-binary",
+          "-out",
+          bytecodeFile.absolutePath,
+          bundleFile.absolutePath,
+          *hermesFlags.get().toTypedArray())
+
+  internal fun getComposeSourceMapsCommand(
+      composeScript: File,
+      packagerSourceMap: File,
+      compilerSourceMap: File,
+      outputSourceMap: File
+  ): List<Any> =
+      windowsAwareCommandLine(
+          *nodeExecutableAndArgs.get().toTypedArray(),
+          composeScript.absolutePath,
+          packagerSourceMap.toString(),
+          compilerSourceMap.toString(),
+          "-o",
+          outputSourceMap.toString())
+}

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

@@ -0,0 +1,81 @@
+/*
+ * 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.tasks
+
+import com.facebook.react.utils.JsonUtils
+import com.facebook.react.utils.windowsAwareCommandLine
+import org.gradle.api.file.Directory
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFile
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.Exec
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.Internal
+import org.gradle.api.tasks.OutputDirectory
+
+abstract class GenerateCodegenArtifactsTask : Exec() {
+
+  @get:Internal abstract val reactNativeDir: DirectoryProperty
+
+  @get:Internal abstract val generatedSrcDir: DirectoryProperty
+
+  @get:InputFile abstract val packageJsonFile: RegularFileProperty
+
+  @get:Input abstract val nodeExecutableAndArgs: ListProperty<String>
+
+  @get:Input abstract val codegenJavaPackageName: Property<String>
+
+  @get:Input abstract val libraryName: Property<String>
+
+  @get:InputFile
+  val generatedSchemaFile: Provider<RegularFile> = generatedSrcDir.file("schema.json")
+
+  @get:OutputDirectory val generatedJavaFiles: Provider<Directory> = generatedSrcDir.dir("java")
+
+  @get:OutputDirectory val generatedJniFiles: Provider<Directory> = generatedSrcDir.dir("jni")
+
+  override fun exec() {
+    val (resolvedLibraryName, resolvedCodegenJavaPackageName) = resolveTaskParameters()
+    setupCommandLine(resolvedLibraryName, resolvedCodegenJavaPackageName)
+    super.exec()
+  }
+
+  internal fun resolveTaskParameters(): Pair<String, String> {
+    val parsedPackageJson =
+        if (packageJsonFile.isPresent && packageJsonFile.get().asFile.exists()) {
+          JsonUtils.fromCodegenJson(packageJsonFile.get().asFile)
+        } else {
+          null
+        }
+    val resolvedLibraryName = parsedPackageJson?.codegenConfig?.name ?: libraryName.get()
+    val resolvedCodegenJavaPackageName =
+        parsedPackageJson?.codegenConfig?.android?.javaPackageName ?: codegenJavaPackageName.get()
+    return resolvedLibraryName to resolvedCodegenJavaPackageName
+  }
+
+  internal fun setupCommandLine(libraryName: String, codegenJavaPackageName: String) {
+    commandLine(
+        windowsAwareCommandLine(
+            *nodeExecutableAndArgs.get().toTypedArray(),
+            reactNativeDir.file("scripts/generate-specs-cli.js").get().asFile.absolutePath,
+            "--platform",
+            "android",
+            "--schemaPath",
+            generatedSchemaFile.get().asFile.absolutePath,
+            "--outputDir",
+            generatedSrcDir.get().asFile.absolutePath,
+            "--libraryName",
+            libraryName,
+            "--javaPackageName",
+            codegenJavaPackageName))
+  }
+}

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

@@ -0,0 +1,80 @@
+/*
+ * 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.tasks
+
+import com.facebook.react.utils.windowsAwareCommandLine
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFile
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Provider
+import org.gradle.api.tasks.*
+
+/**
+ * A task that will collect all the *.js files inside the provided [jsRootDir] and will run the
+ * `combine-js-to-schema-cli.js` on top of it (from `react-native-codegen`). The output is a
+ * `schema.json` file that contains an intermediate representation of the code to be generated.
+ */
+abstract class GenerateCodegenSchemaTask : Exec() {
+
+  @get:Internal abstract val jsRootDir: DirectoryProperty
+
+  @get:Internal abstract val codegenDir: DirectoryProperty
+
+  @get:Internal abstract val generatedSrcDir: DirectoryProperty
+
+  @get:Input abstract val nodeExecutableAndArgs: ListProperty<String>
+
+  @get:InputFiles
+  val jsInputFiles =
+      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("**/generated/source/codegen/**/*")
+        it.exclude("**/build/ASSETS/**/*")
+        it.exclude("**/build/RES/**/*")
+        it.exclude("**/build/generated/assets/react/**/*")
+        it.exclude("**/build/generated/res/react/**/*")
+        it.exclude("**/build/generated/sourcemaps/react/**/*")
+        it.exclude("**/build/intermediates/sourcemaps/react/**/*")
+      }
+
+  @get:OutputFile
+  val generatedSchemaFile: Provider<RegularFile> = generatedSrcDir.file("schema.json")
+
+  override fun exec() {
+    wipeOutputDir()
+    setupCommandLine()
+    super.exec()
+  }
+
+  internal fun wipeOutputDir() {
+    generatedSrcDir.asFile.get().apply {
+      deleteRecursively()
+      mkdirs()
+    }
+  }
+
+  internal fun setupCommandLine() {
+    commandLine(
+        windowsAwareCommandLine(
+            *nodeExecutableAndArgs.get().toTypedArray(),
+            codegenDir
+                .file("lib/cli/combine/combine-js-to-schema-cli.js")
+                .get()
+                .asFile
+                .absolutePath,
+            "--platform",
+            "android",
+            generatedSchemaFile.get().asFile.absolutePath,
+            jsRootDir.asFile.get().absolutePath,
+        ))
+  }
+}