@granite-js/screen 1.0.0

package/gradle-plugin/src/main/kotlin/run/granite/gradle/tasks/AutolinkingTask.kt

@@ -0,0 +1,431 @@
+package run.granite.gradle.tasks
+
+import com.google.gson.Gson
+import com.google.gson.JsonObject
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+import org.gradle.process.ExecOperations
+import run.granite.gradle.generators.CMakeGenerator
+import run.granite.gradle.generators.CppAutolinkingGenerator
+import run.granite.gradle.generators.EntryPointGenerator
+import run.granite.gradle.models.AutolinkingConfig
+import run.granite.gradle.models.NativeModule
+import run.granite.gradle.utils.AutolinkingParser
+import run.granite.gradle.utils.NodeExecutableFinder
+import java.io.ByteArrayOutputStream
+import java.io.File
+import javax.inject.Inject
+
+/**
+ * Gradle task for React Native autolinking.
+ *
+ * This task:
+ * 1. Executes `react-native config` command to discover native modules
+ * 2. Parses the autolinking configuration JSON
+ * 3. Generates PackageList.kt file with all discovered React Native packages
+ *
+ * The generated PackageList.kt is used by the React Native initialization code
+ * to automatically register all native modules without manual configuration.
+ *
+ * Inputs:
+ * - React Native CLI path
+ * - Node modules directory
+ * - Project root directory
+ *
+ * Outputs:
+ * - PackageList.kt file in build/generated/autolinking/
+ */
+@CacheableTask
+abstract class AutolinkingTask @Inject constructor(
+  private val execOperations: ExecOperations,
+) : DefaultTask() {
+
+  /**
+   * React Native directory containing the CLI.
+   * Marked as Internal to avoid task output overlaps with other modules.
+   */
+  @get:Internal
+  abstract val reactNativeDir: DirectoryProperty
+
+  /**
+   * Node modules directory for dependency resolution.
+   * Marked as Internal to avoid task output overlaps with other modules.
+   */
+  @get:Internal
+  abstract val nodeModulesDir: DirectoryProperty
+
+  /**
+   * Project root directory.
+   * Marked as Internal to avoid task output overlaps with other modules.
+   */
+  @get:Internal
+  abstract val projectDir: DirectoryProperty
+
+  /**
+   * Output directory for generated PackageList.kt.
+   */
+  @get:OutputDirectory
+  abstract val outputDir: DirectoryProperty
+
+  /**
+   * Generated PackageList.kt file.
+   */
+  @get:OutputFile
+  abstract val packageListFile: RegularFileProperty
+
+  /**
+   * Package name for the generated PackageList class.
+   */
+  @get:Input
+  abstract val packageName: Property<String>
+
+  /**
+   * Output directory for generated JNI autolinking files.
+   */
+  @get:OutputDirectory
+  abstract val jniOutputDir: DirectoryProperty
+
+  /**
+   * Generated autolinking.h header file.
+   */
+  @get:OutputFile
+  abstract val autolinkingHeaderFile: RegularFileProperty
+
+  /**
+   * Generated autolinking.cpp implementation file.
+   */
+  @get:OutputFile
+  abstract val autolinkingCppFile: RegularFileProperty
+
+  init {
+    group = "granite"
+    description = "Executes React Native autolinking and generates PackageList.kt"
+  }
+
+  @TaskAction
+  fun execute() {
+    logger.lifecycle("Running React Native autolinking...")
+
+    // Execute react-native config once and reuse results
+    val configJson = executeReactNativeConfig()
+
+    // Parse configuration using AutolinkingParser
+    val autolinkingConfig = try {
+      AutolinkingParser.parse(configJson)
+    } catch (e: IllegalArgumentException) {
+      // Fail-fast with descriptive error message
+      throw IllegalArgumentException(
+        "react-native config: Failed to parse output. ${e.message}",
+        e,
+      )
+    }
+
+    val modules = autolinkingConfig.androidDependencies()
+    val javaModules = autolinkingConfig.javaModules()
+
+    // Generate all autolinking files in a single task execution
+    generatePackageList(javaModules)
+    generateJniAutolinking(modules, autolinkingConfig)
+
+    logger.lifecycle("Autolinking complete. Found ${modules.size} native modules (${javaModules.size} Java, ${autolinkingConfig.cxxModules().size} C++, ${autolinkingConfig.fabricModules().size} Fabric).")
+  }
+
+  /**
+   * Executes `react-native config` command and returns the JSON output.
+   *
+   * Implementation details in corresponding task.
+   */
+  private fun executeReactNativeConfig(): String {
+    val cliPath = reactNativeDir.get().file("cli.js").asFile
+    val nodeExecutable = NodeExecutableFinder.findNodeExecutable()
+
+    if (!cliPath.exists()) {
+      error(
+        """
+                |React Native CLI not found: ${cliPath.absolutePath}
+                |
+                |Solution: Run 'npm install' or 'yarn install' to install React Native
+        """.trimMargin(),
+      )
+    }
+
+    // Execute: node path/to/react-native/cli.js config
+    val command = listOf(
+      nodeExecutable.absolutePath,
+      cliPath.absolutePath,
+      "config",
+    )
+
+    val stdout = ByteArrayOutputStream()
+    val stderr = ByteArrayOutputStream()
+
+    val result = execOperations.exec {
+      workingDir = projectDir.get().asFile
+      commandLine = command
+      standardOutput = stdout
+      errorOutput = stderr
+      isIgnoreExitValue = true
+    }
+
+    if (result.exitValue != 0) {
+      error(
+        """
+                |Failed to execute react-native config command.
+                |
+                |Command: ${command.joinToString(" ")}
+                |Exit code: ${result.exitValue}
+                |Error output:
+                |$stderr
+        """.trimMargin(),
+      )
+    }
+
+    return stdout.toString()
+  }
+
+  /**
+   * Interpolates dynamic values (BuildConfig, R) in package instances.
+   * Replaces non-FQDN references with fully qualified package names.
+   */
+  private fun interpolateDynamicValues(input: String, pkgName: String): String = input.replace(Regex("([^.\\w])(BuildConfig|R)(\\W)")) { match ->
+    val (prefix, className, suffix) = match.destructured
+    "${prefix}$pkgName.${className}$suffix"
+  }
+
+  /**
+   * Composes package import statements from native modules.
+   * Filters out pure C++ dependencies.
+   */
+  private fun composePackageImports(modules: List<run.granite.gradle.models.NativeModule>): String = modules
+    .filter { !it.isPureCxxDependency }
+    .mapNotNull { module ->
+      module.packageImportPath?.let { importPath ->
+        val cleanImportPath = importPath
+          .removePrefix("import ")
+          .removeSuffix(";")
+          .trim()
+        interpolateDynamicValues("import $cleanImportPath;", packageName.get())
+      }
+    }
+    .joinToString("\n")
+
+  /**
+   * Composes package instance code for getPackages() method.
+   * Filters out pure C++ dependencies.
+   */
+  private fun composePackageInstance(modules: List<run.granite.gradle.models.NativeModule>): String = modules
+    .filter { !it.isPureCxxDependency }
+    .mapIndexed { index, module ->
+      val instanceCode = interpolateDynamicValues(
+        module.packageInstance ?: "new UnknownPackage()",
+        packageName.get(),
+      )
+      if (index == 0) ",\n      $instanceCode" else ",\n      $instanceCode"
+    }
+    .joinToString("")
+
+  /**
+   * Generates PackageList.java file from discovered Java packages.
+   */
+  private fun generatePackageList(modules: List<run.granite.gradle.models.NativeModule>) {
+    val outputFile = packageListFile.get().asFile
+    outputFile.parentFile.mkdirs()
+
+    val packageImports = composePackageImports(modules)
+    val packageInstances = composePackageInstance(modules)
+
+    val packageListContent = """
+// Generated by Granite Gradle Plugin - DO NOT EDIT
+// This file is automatically generated during the build process
+package com.facebook.react;
+
+import android.app.Application;
+import android.content.Context;
+import android.content.res.Resources;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.shell.MainPackageConfig;
+import com.facebook.react.shell.MainReactPackage;
+import java.util.Arrays;
+import java.util.ArrayList;
+
+$packageImports
+
+@SuppressWarnings("deprecation")
+public class PackageList {
+  private Application application;
+  private ReactNativeHost reactNativeHost;
+  private MainPackageConfig mConfig;
+
+  public PackageList(ReactNativeHost reactNativeHost) {
+    this(reactNativeHost, null);
+  }
+
+  public PackageList(Application application) {
+    this(application, null);
+  }
+
+  public PackageList(ReactNativeHost reactNativeHost, MainPackageConfig config) {
+    this.reactNativeHost = reactNativeHost;
+    mConfig = config;
+  }
+
+  public PackageList(Application application, MainPackageConfig config) {
+    this.reactNativeHost = null;
+    this.application = application;
+    mConfig = config;
+  }
+
+  private ReactNativeHost getReactNativeHost() {
+    return this.reactNativeHost;
+  }
+
+  private Resources getResources() {
+    return this.getApplication().getResources();
+  }
+
+  private Application getApplication() {
+    if (this.reactNativeHost == null) return this.application;
+    return this.reactNativeHost.getApplication();
+  }
+
+  private Context getApplicationContext() {
+    return this.getApplication().getApplicationContext();
+  }
+
+  public ArrayList<ReactPackage> getPackages() {
+    return new ArrayList<>(Arrays.<ReactPackage>asList(
+      new MainReactPackage(mConfig)$packageInstances
+    ));
+  }
+}
+    """.trimIndent()
+
+    outputFile.writeText(packageListContent)
+    logger.lifecycle("Generated PackageList.java: ${outputFile.absolutePath}")
+  }
+
+  /**
+   * Generates JNI autolinking files (autolinking.h, autolinking.cpp, Android-autolinking.cmake)
+   * and Entry Point (ReactNativeApplicationEntryPoint.java).
+   */
+  private fun generateJniAutolinking(
+    modules: List<NativeModule>,
+    config: AutolinkingConfig,
+  ) {
+    val jniDir = jniOutputDir.get().asFile
+    val javaOutputDir = outputDir.get().asFile
+    val projectRoot = projectDir.get().asFile
+
+    // Generate autolinking.h (header with forward declarations)
+    generateAutolinkingHeader(modules)
+
+    // Generate autolinking.cpp using CppAutolinkingGenerator
+    CppAutolinkingGenerator.generateToFile(modules, jniDir)
+    logger.lifecycle("Generated autolinking.cpp with ${modules.filter { it.needsCppAutolinking }.size} modules")
+
+    // Generate Android-autolinking.cmake using CMakeGenerator
+    val cmakeModules = modules.filter { it.hasCMakeConfiguration }
+    if (cmakeModules.isNotEmpty()) {
+      CMakeGenerator.generateToFile(modules, projectRoot, jniDir)
+      logger.lifecycle("Generated Android-autolinking.cmake with ${cmakeModules.size} CMake modules")
+    } else {
+      logger.lifecycle("Skipped Android-autolinking.cmake generation - no CMake modules found")
+    }
+
+    // Generate ReactNativeApplicationEntryPoint.java using EntryPointGenerator
+    val packageName = config.project.android?.packageName
+    try {
+      EntryPointGenerator.generateToFile(packageName, javaOutputDir)
+      logger.lifecycle("Generated ReactNativeApplicationEntryPoint.java")
+    } catch (e: IllegalStateException) {
+      // Package name validation error
+      logger.warn("Skipped entry point generation: ${e.message}")
+    }
+
+    logger.lifecycle("Generated all autolinking files in: ${jniDir.absolutePath}")
+  }
+
+  /**
+   * Generates autolinking.h header file with forward declarations.
+   */
+  private fun generateAutolinkingHeader(modules: List<run.granite.gradle.models.NativeModule>) {
+    val headerFile = autolinkingHeaderFile.get().asFile
+    headerFile.parentFile.mkdirs()
+
+    val cxxModules = modules.filter { it.hasCxxImplementation }
+    val javaModules = modules.filter { it.hasJavaImplementation }
+
+    val headerContent = buildString {
+      appendLine("// Generated by Granite Gradle Plugin - DO NOT EDIT")
+      appendLine("// This file is automatically generated during the build process")
+      appendLine()
+      appendLine("#pragma once")
+      appendLine()
+      appendLine("#include <memory>")
+      appendLine("#include <string>")
+      appendLine()
+      appendLine("#include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>")
+      appendLine("#include <react/bridging/Bridging.h>")
+      appendLine("#include <ReactCommon/CallInvokerHolder.h>")
+      appendLine("#include <ReactCommon/TurboModule.h>")
+      appendLine("#include <ReactCommon/JavaTurboModule.h>")
+      appendLine()
+      appendLine("namespace facebook::react {")
+      appendLine()
+
+      // Forward declarations for C++ TurboModule providers
+      if (cxxModules.isNotEmpty()) {
+        appendLine("// Forward declarations for C++ TurboModule providers")
+        cxxModules.forEach { module ->
+          module.cxxModuleHeaderName?.let { headerName ->
+            appendLine("class $headerName;")
+          }
+        }
+        appendLine()
+      }
+
+      // Forward declarations for Java TurboModule providers
+      if (javaModules.isNotEmpty()) {
+        appendLine("// Forward declarations for Java TurboModule providers")
+        javaModules.forEach { module ->
+          module.libraryName?.let { libraryName ->
+            appendLine("std::shared_ptr<TurboModule> ${libraryName}_ModuleProvider(")
+            appendLine("    const std::string& moduleName,")
+            appendLine("    const JavaTurboModule::InitParams& params);")
+            appendLine()
+          }
+        }
+      }
+
+      appendLine("/**")
+      appendLine(" * Registers Fabric component providers from autolinked libraries.")
+      appendLine(" */")
+      appendLine("void autolinking_registerProviders(")
+      appendLine("    std::shared_ptr<const ComponentDescriptorProviderRegistry> registry);")
+      appendLine()
+      appendLine("/**")
+      appendLine(" * Provides C++ TurboModule from autolinked libraries.")
+      appendLine(" */")
+      appendLine("std::shared_ptr<TurboModule> autolinking_cxxModuleProvider(")
+      appendLine("    const std::string& name,")
+      appendLine("    const std::shared_ptr<CallInvoker>& jsInvoker);")
+      appendLine()
+      appendLine("/**")
+      appendLine(" * Provides Java TurboModule from autolinked libraries.")
+      appendLine(" */")
+      appendLine("std::shared_ptr<TurboModule> autolinking_ModuleProvider(")
+      appendLine("    const std::string& name,")
+      appendLine("    const JavaTurboModule::InitParams& params);")
+      appendLine()
+      appendLine("} // namespace facebook::react")
+    }
+
+    headerFile.writeText(headerContent)
+    logger.debug("Generated autolinking.h: ${headerFile.absolutePath}")
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/tasks/BundleTask.kt

@@ -0,0 +1,275 @@
+package run.granite.gradle.tasks
+
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.*
+import org.gradle.process.ExecOperations
+import run.granite.gradle.utils.NodeExecutableFinder
+import java.io.ByteArrayOutputStream
+import java.io.File
+import javax.inject.Inject
+
+/**
+ * Gradle task for generating React Native JavaScript bundles.
+ *
+ * This task:
+ * 1. Executes Metro bundler to bundle JavaScript code
+ * 2. Compiles the bundle to Hermes bytecode (always enabled)
+ * 3. Handles dev vs release build configurations
+ * 4. Generates source maps for debugging
+ */
+@CacheableTask
+abstract class BundleTask @Inject constructor(
+  private val execOperations: ExecOperations,
+) : DefaultTask() {
+
+  @get:InputFile
+  @get:PathSensitive(PathSensitivity.RELATIVE)
+  abstract val entryFile: RegularFileProperty
+
+  /**
+   * React Native directory.
+   * Marked as Internal to avoid task output overlaps with other modules.
+   */
+  @get:Internal
+  abstract val reactNativeDir: DirectoryProperty
+
+  /**
+   * Node modules directory.
+   * Marked as Internal to avoid task output overlaps with other modules.
+   */
+  @get:Internal
+  abstract val nodeModulesDir: DirectoryProperty
+
+  /**
+   * Project root directory.
+   * Marked as Internal to avoid task output overlaps with other modules.
+   */
+  @get:Internal
+  abstract val projectDir: DirectoryProperty
+
+  @get:OutputFile
+  abstract val bundleFile: RegularFileProperty
+
+  @get:OutputFile
+  abstract val sourceMapFile: RegularFileProperty
+
+  @get:Input
+  abstract val bundleAssetName: Property<String>
+
+  @get:Input
+  abstract val devMode: Property<Boolean>
+
+  @get:Input
+  abstract val variantName: Property<String>
+
+  init {
+    group = "granite"
+    description = "Generates React Native JavaScript bundle"
+  }
+
+  @TaskAction
+  fun execute() {
+    val variant = variantName.get()
+    logger.lifecycle("Bundling JavaScript for variant: $variant")
+
+    // Validate entry file exists at execution time
+    // This allows flexibility for projects with JS in separate repos during development
+    val entryFileResolved = entryFile.get().asFile
+    if (!entryFileResolved.exists()) {
+      error(
+        """
+                |JavaScript entry file not found: ${entryFileResolved.absolutePath}
+                |
+                |The entry file is required for bundle generation but was not found.
+                |This typically occurs when:
+                |  1. JavaScript source files are in a separate repository
+                |  2. The entry file path is incorrectly configured
+                |  3. Build is running before JS files are available
+                |
+                |Solutions:
+                |  1. Ensure JavaScript files are available before running release builds
+                |  2. Configure the correct entry file path in build.gradle.kts:
+                |     granite {
+                |         entryFile.set("path/to/index.js")
+                |     }
+                |  3. For development, use Metro dev server instead of bundling
+                |
+                |Variant: $variant
+        """.trimMargin(),
+      )
+    }
+
+    val jsBundleFile = generateJavaScriptBundle()
+
+    // Always compile to Hermes bytecode (JSC not supported)
+    compileToHermes(jsBundleFile)
+
+    logger.lifecycle("Bundle generation complete for variant: $variant")
+  }
+
+  private fun generateJavaScriptBundle(): File {
+    logger.lifecycle("Running Metro bundler...")
+
+    val cliPath = reactNativeDir.get().file("cli.js").asFile
+    val nodeExecutable = NodeExecutableFinder.findNodeExecutable()
+
+    if (!cliPath.exists()) {
+      error("React Native CLI not found: ${cliPath.absolutePath}")
+    }
+
+    val tempJsBundle = File(bundleFile.get().asFile.parentFile, "temp_${bundleAssetName.get()}")
+    tempJsBundle.parentFile.mkdirs()
+
+    val command = buildList {
+      add(nodeExecutable.absolutePath)
+      add(cliPath.absolutePath)
+      add("bundle")
+      add("--platform")
+      add("android")
+      add("--entry-file")
+      add(entryFile.get().asFile.absolutePath)
+      add("--bundle-output")
+      add(tempJsBundle.absolutePath)
+      add("--sourcemap-output")
+      add(sourceMapFile.get().asFile.absolutePath)
+      add("--assets-dest")
+      add(bundleFile.get().asFile.parentFile.absolutePath)
+
+      if (devMode.get()) {
+        add("--dev")
+        add("true")
+      } else {
+        add("--dev")
+        add("false")
+        add("--minify")
+        add("true")
+      }
+    }
+
+    val stdout = ByteArrayOutputStream()
+    val stderr = ByteArrayOutputStream()
+
+    val result = execOperations.exec {
+      workingDir = projectDir.get().asFile
+      commandLine = command
+      standardOutput = stdout
+      errorOutput = stderr
+      isIgnoreExitValue = true
+    }
+
+    if (result.exitValue != 0) {
+      error("Failed to bundle JavaScript. Exit code: ${result.exitValue}\n$stderr")
+    }
+
+    logger.lifecycle("Metro bundling complete: ${tempJsBundle.absolutePath}")
+    return tempJsBundle
+  }
+
+  private fun compileToHermes(jsBundleFile: File) {
+    logger.lifecycle("Compiling to Hermes bytecode...")
+
+    val hermesExecutable = findHermesCompiler()
+
+    val command = listOf(
+      hermesExecutable.absolutePath,
+      "-emit-binary",
+      "-out",
+      bundleFile.get().asFile.absolutePath,
+      jsBundleFile.absolutePath,
+    )
+
+    val stdout = ByteArrayOutputStream()
+    val stderr = ByteArrayOutputStream()
+
+    val result = execOperations.exec {
+      commandLine = command
+      standardOutput = stdout
+      errorOutput = stderr
+      isIgnoreExitValue = true
+    }
+
+    if (result.exitValue != 0) {
+      error("Failed to compile to Hermes bytecode. Exit code: ${result.exitValue}\n$stderr")
+    }
+
+    jsBundleFile.delete()
+
+    logger.lifecycle("Hermes compilation complete: ${bundleFile.get().asFile.absolutePath}")
+  }
+
+  private fun findHermesCompiler(): File {
+    // Determine OS-specific binary directory
+    val osBinDir = when {
+      System.getProperty("os.name").startsWith("Windows") -> "win64-bin"
+      System.getProperty("os.name").startsWith("Mac") -> "osx-bin"
+      else -> "linux64-bin"
+    }
+    val hermescName = if (osBinDir == "win64-bin") "hermesc.exe" else "hermesc"
+
+    val nodeModules = nodeModulesDir.get().asFile
+
+    // 1. Check known paths in hermes-engine package
+    val hermesEnginePaths = listOf(
+      File(nodeModules, "hermes-engine/$osBinDir/$hermescName"),
+      File(nodeModules, "hermes-engine/bin/$hermescName"),
+    )
+
+    for (path in hermesEnginePaths) {
+      if (path.exists() && path.canExecute()) {
+        return path
+      }
+    }
+
+    // 2. Check known paths in react-native SDKs
+    val reactNativeSdkPaths = listOf(
+      File(nodeModules, "react-native/sdks/hermesc/$osBinDir/$hermescName"),
+      File(nodeModules, "react-native/sdks/hermes/$osBinDir/$hermescName"),
+    )
+
+    for (path in reactNativeSdkPaths) {
+      if (path.exists() && path.canExecute()) {
+        return path
+      }
+    }
+
+    // 3. Check react-native/android Maven cache (original location)
+    val reactNativeAndroid = File(reactNativeDir.get().asFile, "android")
+    val hermesEngine = File(reactNativeAndroid, "com/facebook/react/hermes-engine")
+
+    if (hermesEngine.exists()) {
+      val hermescExecutables = hermesEngine.walk()
+        .filter { it.name == hermescName }
+        .filter { it.canExecute() }
+        .toList()
+
+      if (hermescExecutables.isNotEmpty()) {
+        return hermescExecutables.first()
+      }
+    }
+
+    // 4. Fallback: targeted search in specific subdirectories only
+    val targetedDirs = listOf(
+      File(nodeModules, "hermes-engine"),
+      File(nodeModules, "react-native/sdks"),
+    )
+
+    for (dir in targetedDirs) {
+      if (dir.exists()) {
+        val found = dir.walk()
+          .maxDepth(5) // Limit depth to prevent excessive traversal
+          .filter { it.name == hermescName }
+          .filter { it.canExecute() }
+          .firstOrNull()
+
+        if (found != null) {
+          return found
+        }
+      }
+    }
+
+    error("Hermes compiler (hermesc) not found. Searched paths: ${hermesEnginePaths + reactNativeSdkPaths}")
+  }
+}