@granite-js/screen 1.0.0

package/gradle-plugin/src/main/kotlin/run/granite/gradle/generators/CMakeGenerator.kt

@@ -0,0 +1,105 @@
+package run.granite.gradle.generators
+
+import run.granite.gradle.models.NativeModule
+import java.io.File
+import java.util.logging.Logger
+
+/**
+ * Generates Android-autolinking.cmake configuration file for React Native native modules.
+ *
+ * This generator creates a CMake configuration file that:
+ * - Adds subdirectories for each native module
+ * - Sets REACTNATIVE_MERGED_SO=true for React Native 0.76+
+ * - Sanitizes paths (escape spaces, remove CMakeLists.txt)
+ * - Creates unique build directory names ({libraryName}_autolinked_build)
+ * - Handles both standard and cxxModule CMakeLists.txt
+ * - Generates AUTOLINKED_LIBRARIES list with react_codegen_* prefixes
+ */
+object CMakeGenerator {
+  private val logger = Logger.getLogger(CMakeGenerator::class.java.name)
+
+  /**
+   * Generates Android-autolinking.cmake file content.
+   *
+   * @param modules List of all native modules
+   * @param projectRoot Root directory of the project for path resolution
+   * @return Generated CMake code as string
+   */
+  fun generate(modules: List<NativeModule>, projectRoot: File): String {
+    // Filter out brick-module as it uses a special codegen pattern
+    val cmakeModules = modules.filter { it.hasCMakeConfiguration }
+
+    if (cmakeModules.isEmpty()) {
+      // Skip CMake generation if no modules with native code
+      return generateEmptyFile()
+    }
+
+    // Collect all CMake entries from modules
+    val allEntries = cmakeModules.flatMap { it.cmakeEntries() }
+
+    // Filter entries to only include directories that actually exist
+    val existingEntries = allEntries.filter { entry ->
+      val sanitizedPath = entry.sanitizedPath(projectRoot)
+      File(sanitizedPath).exists().also { exists ->
+        if (!exists) {
+          logger.warning("Skipping non-existent CMake directory: $sanitizedPath")
+        }
+      }
+    }
+
+    val allLibraryTargets = existingEntries.flatMap { it.libraryTargets }
+
+    return buildString {
+      appendLine("# Generated by Granite Gradle Plugin - DO NOT EDIT")
+      appendLine("# This file is automatically generated during the build process")
+      appendLine()
+
+      // Set REACTNATIVE_MERGED_SO=true for React Native 0.76+
+      appendLine("# Enable merged shared object model for React Native 0.76+")
+      appendLine("set(REACTNATIVE_MERGED_SO true)")
+      appendLine()
+
+      if (existingEntries.isNotEmpty()) {
+        appendLine("# Add native module directories")
+        existingEntries.forEach { entry ->
+          appendLine(entry.toCMakeCommand(projectRoot))
+        }
+        appendLine()
+      }
+
+      // Initialize empty AUTOLINKED_LIBRARIES and conditionally append targets
+      // This ensures clean works even when codegen directories don't exist
+      appendLine("# Autolinked library targets (conditionally added based on existence)")
+      appendLine("set(AUTOLINKED_LIBRARIES \"\")")
+      existingEntries.forEach { entry ->
+        entry.libraryTargets.forEach { target ->
+          appendLine("if(TARGET $target)")
+          appendLine("  list(APPEND AUTOLINKED_LIBRARIES $target)")
+          appendLine("endif()")
+        }
+      }
+    }
+  }
+
+  /**
+   * Generates an empty CMake file with explanatory comment.
+   */
+  private fun generateEmptyFile(): String = buildString {
+    appendLine("# Generated by Granite Gradle Plugin - DO NOT EDIT")
+    appendLine("# This file is automatically generated during the build process")
+    appendLine()
+    appendLine("# No native modules with CMake configuration found")
+    appendLine("set(REACTNATIVE_MERGED_SO true)")
+    appendLine("set(AUTOLINKED_LIBRARIES)")
+  }
+
+  /**
+   * Writes Android-autolinking.cmake to the specified output directory.
+   */
+  fun generateToFile(modules: List<NativeModule>, projectRoot: File, outputDir: File) {
+    val content = generate(modules, projectRoot)
+    val outputFile = File(outputDir, "Android-autolinking.cmake")
+    outputFile.parentFile.mkdirs()
+    outputFile.writeText(content)
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/generators/CppAutolinkingGenerator.kt

@@ -0,0 +1,152 @@
+package run.granite.gradle.generators
+
+import run.granite.gradle.models.NativeModule
+import java.io.File
+
+/**
+ * Generates autolinking.cpp with concrete implementations of autolinking functions.
+ *
+ * This generator creates C++ code that:
+ * - Implements autolinking_ModuleProvider for Java TurboModules
+ * - Implements autolinking_cxxModuleProvider for C++ TurboModules
+ * - Includes proper headers for C++ TurboModules
+ * - Returns nullptr when no match is found (early-return pattern)
+ * - Sanitizes C++ identifiers
+ */
+object CppAutolinkingGenerator {
+  /**
+   * Generates autolinking.cpp file content.
+   *
+   * @param modules List of all native modules
+   * @return Generated C++ code as string
+   */
+  fun generate(modules: List<NativeModule>): String {
+    val cxxModules = modules.filter { it.hasCxxImplementation }
+    val javaModules = modules.filter { it.hasJavaImplementation }
+    val fabricLibraries =
+      modules
+        .filter { it.hasFabricComponents }
+        .mapNotNull { module ->
+          val libraryName = module.libraryName ?: return@mapNotNull null
+          libraryName to module.componentDescriptors
+        }
+        .groupBy({ it.first }, { it.second })
+        .mapValues { (_, descriptorLists) -> descriptorLists.flatten().distinct() }
+        .toSortedMap()
+
+    return buildString {
+      appendLine("// Generated by Granite Gradle Plugin - DO NOT EDIT")
+      appendLine("// This file is automatically generated during the build process")
+      appendLine()
+      appendLine("#include <autolinking.h>")
+      appendLine()
+
+      // C++ TurboModule headers
+      if (cxxModules.isNotEmpty()) {
+        appendLine("// C++ TurboModule headers")
+        cxxModules.forEach { module ->
+          module.cxxModuleHeaderName?.let { headerName ->
+            appendLine("#include <$headerName.h>")
+          }
+        }
+        appendLine()
+      }
+
+      // Fabric component descriptor headers
+      if (fabricLibraries.isNotEmpty()) {
+        appendLine("// Fabric component descriptor headers")
+        fabricLibraries.forEach { (libraryName, componentDescriptors) ->
+          appendLine("#if defined(__has_include) && __has_include(<react/renderer/components/$libraryName/ComponentDescriptors.h>)")
+          appendLine("#include <react/renderer/components/$libraryName/ComponentDescriptors.h>")
+          appendLine("#endif")
+          componentDescriptors.forEach { descriptor ->
+            appendLine("#if defined(__has_include) && __has_include(<react/renderer/components/$libraryName/$descriptor.h>)")
+            appendLine("#include <react/renderer/components/$libraryName/$descriptor.h>")
+            appendLine("#endif")
+          }
+        }
+        appendLine()
+      }
+
+      appendLine("namespace facebook::react {")
+      appendLine()
+
+      // autolinking_registerProviders function
+      appendLine("void autolinking_registerProviders(")
+      appendLine("    std::shared_ptr<const ComponentDescriptorProviderRegistry> registry) {")
+      if (fabricLibraries.isNotEmpty()) {
+        appendLine("  // Register Fabric component descriptors from autolinked libraries")
+        fabricLibraries.forEach { (libraryName, componentDescriptors) ->
+          appendLine("#if defined(__has_include) && __has_include(<react/renderer/components/$libraryName/ComponentDescriptors.h>)")
+          appendLine("  ${libraryName}_registerComponentDescriptorsFromCodegen(registry);")
+          appendLine("#endif")
+          componentDescriptors.forEach { descriptor ->
+            appendLine("#if defined(__has_include) && __has_include(<react/renderer/components/$libraryName/$descriptor.h>)")
+            appendLine("  registry->add(concreteComponentDescriptorProvider<$descriptor>());")
+            appendLine("#endif")
+          }
+        }
+      } else {
+        appendLine("  // No autolinked Fabric components found")
+      }
+      appendLine("}")
+      appendLine()
+
+      // autolinking_cxxModuleProvider function
+      appendLine("std::shared_ptr<TurboModule> autolinking_cxxModuleProvider(")
+      appendLine("    const std::string& moduleName,")
+      appendLine("    const std::shared_ptr<CallInvoker>& jsInvoker) {")
+      if (cxxModules.isNotEmpty()) {
+        appendLine("  // Check C++ TurboModules (early-return pattern)")
+        cxxModules.forEach { module ->
+          module.cxxModuleHeaderName?.let { headerName ->
+            appendLine("  if (moduleName == $headerName::kModuleName) {")
+            appendLine("    return std::make_shared<$headerName>(jsInvoker);")
+            appendLine("  }")
+          }
+        }
+      } else {
+        appendLine("  // No autolinked C++ TurboModules found")
+      }
+      appendLine()
+      appendLine("  return nullptr;")
+      appendLine("}")
+      appendLine()
+
+      // autolinking_ModuleProvider function
+      appendLine("std::shared_ptr<TurboModule> autolinking_ModuleProvider(")
+      appendLine("    const std::string& moduleName,")
+      appendLine("    const JavaTurboModule::InitParams& params) {")
+      if (javaModules.isNotEmpty()) {
+        appendLine("  // Delegate to Java TurboModule providers (early-return pattern)")
+        javaModules.forEach { module ->
+          module.libraryName?.let { libraryName ->
+            val sanitized = module.sanitizedName()
+            appendLine("  auto module_$sanitized = ${libraryName}_ModuleProvider(moduleName, params);")
+            appendLine("  if (module_$sanitized != nullptr) {")
+            appendLine("    return module_$sanitized;")
+            appendLine("  }")
+          }
+        }
+      } else {
+        appendLine("  // No autolinked Java TurboModules found")
+      }
+      appendLine()
+      appendLine("  return nullptr;")
+      appendLine("}")
+      appendLine()
+
+      appendLine("} // namespace facebook::react")
+    }
+  }
+
+  /**
+   * Writes autolinking.cpp to the specified output directory.
+   */
+  fun generateToFile(modules: List<NativeModule>, outputDir: File) {
+    val content = generate(modules)
+    val outputFile = File(outputDir, "autolinking.cpp")
+    outputFile.parentFile.mkdirs()
+    outputFile.writeText(content)
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/generators/EntryPointGenerator.kt

@@ -0,0 +1,100 @@
+package run.granite.gradle.generators
+
+import java.io.File
+
+/**
+ * Generates ReactNativeApplicationEntryPoint.java for SoLoader initialization
+ * and New Architecture loading.
+ *
+ * This generator creates Java code that:
+ * - Provides ReactNativeApplicationEntryPoint class with static loadReactNative method
+ * - Initializes SoLoader with OpenSourceMergedSoMapping
+ * - Conditionally loads New Architecture components
+ * - Conditionally enables edge-to-edge UI
+ * - Places generated code in com.facebook.react package
+ * - Throws RuntimeException on SoLoader failure
+ */
+object EntryPointGenerator {
+  /**
+   * Generates ReactNativeApplicationEntryPoint.java file content.
+   *
+   * @param packageName The Android package name from project configuration
+   * @return Generated Java code as string
+   * @throws IllegalStateException if packageName is null
+   */
+  fun generate(packageName: String?): String {
+    // Validate package name is present
+    requireNotNull(packageName) {
+      "Android package name not found in react-native config. " +
+        "Ensure project has valid android configuration."
+    }
+
+    return buildString {
+      appendLine("// Generated by Granite Gradle Plugin - DO NOT EDIT")
+      appendLine("// This file is automatically generated during the build process")
+      appendLine()
+      appendLine("package com.facebook.react;")
+      appendLine()
+      appendLine("import android.content.Context;")
+      appendLine("import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint;")
+      appendLine("import com.facebook.react.soloader.OpenSourceMergedSoMapping;")
+      appendLine("import com.facebook.react.views.view.WindowUtilKt;")
+      appendLine("import com.facebook.soloader.SoLoader;")
+      appendLine()
+      appendLine("/**")
+      appendLine(" * ReactNativeApplicationEntryPoint provides static initialization for React Native runtime.")
+      appendLine(" * This class handles SoLoader initialization and New Architecture component loading.")
+      appendLine(" */")
+      appendLine("public class ReactNativeApplicationEntryPoint {")
+      appendLine()
+      appendLine("  /**")
+      appendLine("   * Loads the React Native runtime with proper SoLoader and New Architecture initialization.")
+      appendLine("   *")
+      appendLine("   * @param context Application context for SoLoader initialization")
+      appendLine("   * @throws RuntimeException if SoLoader initialization fails")
+      appendLine("   */")
+      appendLine("  public static void loadReactNative(Context context) {")
+      appendLine("    // Initialize SoLoader with merged shared object mapping")
+      appendLine("    try {")
+      appendLine("      SoLoader.init(context, OpenSourceMergedSoMapping.INSTANCE);")
+      appendLine("    } catch (Exception e) {")
+      appendLine("      throw new RuntimeException(\"Failed to initialize SoLoader\", e);")
+      appendLine("    }")
+      appendLine()
+      appendLine("    // Load New Architecture components if enabled")
+      appendLine("    // if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {")
+      appendLine("    DefaultNewArchitectureEntryPoint.load();")
+      appendLine("    WindowUtilKt.setEdgeToEdgeFeatureFlagOn();")
+      appendLine("    // }")
+      appendLine()
+      appendLine("    // Enable edge-to-edge UI if configured")
+      appendLine("    // if (BuildConfig.IS_EDGE_TO_EDGE_ENABLED) {")
+      appendLine("      // Edge-to-edge feature flag is set in BuildConfig")
+      appendLine("    // }")
+      appendLine("  }")
+      appendLine()
+      appendLine("  private ReactNativeApplicationEntryPoint() {")
+      appendLine("    // Utility class - prevent instantiation")
+      appendLine("  }")
+      appendLine("}")
+    }
+  }
+
+  /**
+   * Writes ReactNativeApplicationEntryPoint.java to the specified output directory.
+   *
+   * @param packageName Android package name from project configuration
+   * @param outputDir Output directory for Java source files
+   * @throws IllegalStateException if packageName is null
+   */
+  fun generateToFile(packageName: String?, outputDir: File) {
+    val content = generate(packageName)
+
+    // Create package directory structure: com/facebook/react/
+    val packageDir = File(outputDir, "src/main/java/com/facebook/react")
+    packageDir.mkdirs()
+
+    val outputFile = File(packageDir, "ReactNativeApplicationEntryPoint.java")
+    outputFile.writeText(content)
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/models/AndroidDependencyConfig.kt

@@ -0,0 +1,23 @@
+package run.granite.gradle.models
+
+/**
+ * Complete Android-specific configuration for a native module.
+ * Maps directly to the "platforms.android" JSON structure from react-native config.
+ *
+ * All fields are nullable as they may be absent in the JSON configuration.
+ * Missing fields are treated identically to null fields.
+ */
+data class AndroidDependencyConfig(
+  val sourceDir: String?,
+  val packageImportPath: String?,
+  val packageInstance: String?,
+  val dependencyConfiguration: String?,
+  val buildTypes: List<String>?,
+  val libraryName: String?,
+  val componentDescriptors: List<String>?,
+  val cmakeListsPath: String?,
+  val cxxModuleCMakeListsPath: String?,
+  val cxxModuleCMakeListsModuleName: String?,
+  val cxxModuleHeaderName: String?,
+  val isPureCxxDependency: Boolean?,
+)

package/gradle-plugin/src/main/kotlin/run/granite/gradle/models/AutolinkingConfig.kt

@@ -0,0 +1,89 @@
+package run.granite.gradle.models
+
+/**
+ * Root configuration object parsed from `react-native config` JSON output.
+ *
+ * Provides filtered views of dependencies for different code generation purposes:
+ * - androidDependencies(): All modules with Android native code
+ * - javaModules(): Modules with Java TurboModule implementations
+ * - cxxModules(): Modules with C++ TurboModule implementations
+ * - fabricModules(): Modules with Fabric components
+ * - cmakeModules(): Modules with CMake configuration
+ */
+data class AutolinkingConfig(
+  val project: ProjectInfo,
+  val dependencies: Map<String, DependencyConfig>,
+) {
+  /**
+   * Filters dependencies to only those with Android native code.
+   * Excludes JavaScript-only packages.
+   * Reads each module's package.json to check for includesGeneratedCode flag.
+   */
+  fun androidDependencies(): List<NativeModule> = dependencies.mapNotNull { (name, config) ->
+    config.platforms?.android?.let { androidConfig ->
+      NativeModule.from(name, androidConfig, config.root)
+    }
+  }
+
+  /**
+   * Returns modules that have Java TurboModule implementations.
+   * Identified by non-null packageImportPath and packageInstance.
+   */
+  fun javaModules(): List<NativeModule> = androidDependencies().filter { it.hasJavaImplementation }
+
+  /**
+   * Returns modules that have C++ TurboModule implementations.
+   * Identified by non-null cxxModuleHeaderName.
+   */
+  fun cxxModules(): List<NativeModule> = androidDependencies().filter { it.hasCxxImplementation }
+
+  /**
+   * Returns modules that have Fabric components.
+   * Identified by non-empty componentDescriptors array.
+   */
+  fun fabricModules(): List<NativeModule> = androidDependencies().filter { it.hasFabricComponents }
+
+  /**
+   * Returns modules that have CMake configuration.
+   * Identified by non-null cmakeListsPath or cxxModuleCMakeListsPath.
+   */
+  fun cmakeModules(): List<NativeModule> = androidDependencies().filter { it.hasCMakeConfiguration }
+}
+
+/**
+ * Metadata about the React Native project itself.
+ * Used for entry point generation.
+ */
+data class ProjectInfo(
+  val name: String?,
+  val version: String?,
+  val ios: Map<String, Any>?,
+  val android: AndroidProjectConfig?,
+)
+
+/**
+ * Android project configuration extracted from react-native config.
+ * packageName is required for entry point generation.
+ */
+data class AndroidProjectConfig(
+  val sourceDir: String?,
+  val manifestPath: String?,
+  val packageName: String?,
+)
+
+/**
+ * Top-level configuration for a single dependency.
+ */
+data class DependencyConfig(
+  val name: String,
+  val root: String,
+  val platforms: PlatformConfig?,
+)
+
+/**
+ * Platform-specific configuration container.
+ */
+data class PlatformConfig(
+  val ios: Map<String, Any>?,
+  val android: AndroidDependencyConfig?,
+)

package/gradle-plugin/src/main/kotlin/run/granite/gradle/models/CMakeEntry.kt

@@ -0,0 +1,47 @@
+package run.granite.gradle.models
+
+import java.io.File
+
+/**
+ * Represents a single add_subdirectory entry in Android-autolinking.cmake.
+ *
+ * Each CMake entry includes:
+ * - sourcePath: Path to the directory containing CMakeLists.txt
+ * - buildDirName: Unique build directory name for this module
+ * - libraryTargets: List of CMake library targets to be linked
+ */
+data class CMakeEntry(
+  val sourcePath: String,
+  val buildDirName: String,
+  val libraryTargets: List<String>,
+) {
+  /**
+   * Sanitizes the source path for CMake.
+   * - Removes trailing /CMakeLists.txt or \CMakeLists.txt
+   * - Converts to absolute path if relative
+   * - Replaces backslashes with forward slashes
+   */
+  fun sanitizedPath(moduleRoot: File): String {
+    var path = sourcePath.removeSuffix("/CMakeLists.txt")
+      .removeSuffix("\\CMakeLists.txt")
+
+    val file = File(path)
+    if (!file.isAbsolute) {
+      path = File(moduleRoot, path).canonicalPath
+    }
+
+    return path.replace('\\', '/')
+  }
+
+  /**
+   * Generates the add_subdirectory command line with existence check.
+   * Wraps with if(EXISTS ...) to prevent CMake errors during clean
+   * when codegen directories don't exist yet.
+   */
+  fun toCMakeCommand(moduleRoot: File): String {
+    val sanitized = sanitizedPath(moduleRoot)
+    return """if(EXISTS "$sanitized")
+  add_subdirectory("$sanitized" $buildDirName)
+endif()"""
+  }
+}