@granite-js/screen 1.0.0

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/DependencyCoordinates.kt

@@ -0,0 +1,29 @@
+package run.granite.gradle.config
+
+/**
+ * Dependency coordinate information for React Native and Hermes.
+ *
+ * @property reactVersion React Native version (e.g., "0.84.0-rc.4")
+ * @property hermesVersion Hermes Classic version (e.g., "0.15.0")
+ * @property hermesV1Version Hermes V1 version (e.g., "250829098.0.6")
+ * @property reactGroup React Native Maven group (default: com.facebook.react)
+ * @property hermesGroup Hermes Maven group (default: com.facebook.hermes)
+ */
+data class DependencyCoordinates(
+  val reactVersion: String,
+  val hermesVersion: String,
+  val hermesV1Version: String,
+  val reactGroup: String = DEFAULT_REACT_GROUP,
+  val hermesGroup: String = DEFAULT_HERMES_GROUP,
+) {
+  companion object {
+    const val DEFAULT_REACT_GROUP = "com.facebook.react"
+    const val DEFAULT_HERMES_GROUP = "com.facebook.hermes"
+  }
+
+  /**
+   * Returns the Hermes version to use.
+   * Granite always uses Hermes V1.
+   */
+  fun getEffectiveHermesVersion(): String = if (hermesV1Version.isNotBlank()) hermesV1Version else hermesVersion
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/DevServerResourceConfigurator.kt

@@ -0,0 +1,101 @@
+package run.granite.gradle.config
+
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+import java.io.File
+
+/**
+ * Configurator for development server resource generation.
+ *
+ * Generates Android resources for React Native development server configuration:
+ * - res/values/strings.xml: Dev server host
+ * - res/values/integers.xml: Dev server port
+ *
+ * These resources are used by React Native's DevSupportManager for connecting
+ * to the Metro bundler during development.
+ */
+class DevServerResourceConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+) {
+
+  /**
+   * Generates dev server configuration resources for debug builds.
+   *
+   * Creates:
+   * - src/debug/res/values/strings.xml with react_native_dev_server_host
+   * - src/debug/res/values/integers.xml with react_native_dev_server_port
+   *
+   * Only generates resources if devServerHost and devServerPort are configured.
+   */
+  fun configure() {
+    val devServerHost = extension.devServerHost.orNull
+    val devServerPort = extension.devServerPort.orNull
+
+    if (devServerHost == null && devServerPort == null) {
+      project.logger.debug("Dev server configuration not set, skipping resource generation")
+      return
+    }
+
+    // Generate debug variant resources
+    val debugResDir = project.file("src/debug/res/values")
+    debugResDir.mkdirs()
+
+    if (devServerHost != null) {
+      generateStringsXml(debugResDir, devServerHost)
+    }
+
+    if (devServerPort != null) {
+      generateIntegersXml(debugResDir, devServerPort)
+    }
+
+    project.logger.lifecycle(
+      "Dev server resources generated: host=${devServerHost ?: "default"}, port=${devServerPort ?: "default"}",
+    )
+  }
+
+  /**
+   * Generates strings.xml with dev server host configuration.
+   */
+  private fun generateStringsXml(resDir: File, host: String) {
+    val stringsFile = File(resDir, "strings.xml")
+
+    val content = """
+            <?xml version="1.0" encoding="utf-8"?>
+            <resources>
+                <!-- React Native Metro bundler development server host -->
+                <string name="react_native_dev_server_host" translatable="false">${escapeXml(host)}</string>
+            </resources>
+    """.trimIndent()
+
+    stringsFile.writeText(content)
+    project.logger.debug("Generated ${stringsFile.absolutePath}")
+  }
+
+  /**
+   * Escapes special XML characters to prevent injection vulnerabilities.
+   */
+  private fun escapeXml(value: String): String = value.replace("&", "&amp;")
+    .replace("<", "&lt;")
+    .replace(">", "&gt;")
+    .replace("\"", "&quot;")
+    .replace("'", "&apos;")
+
+  /**
+   * Generates integers.xml with dev server port configuration.
+   */
+  private fun generateIntegersXml(resDir: File, port: Int) {
+    val integersFile = File(resDir, "integers.xml")
+
+    val content = """
+            <?xml version="1.0" encoding="utf-8"?>
+            <resources>
+                <!-- React Native Metro bundler development server port -->
+                <integer name="react_native_dev_server_port">$port</integer>
+            </resources>
+    """.trimIndent()
+
+    integersFile.writeText(content)
+    project.logger.debug("Generated ${integersFile.absolutePath}")
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/JniPackagingConfigurator.kt

@@ -0,0 +1,160 @@
+package run.granite.gradle.config
+
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.api.variant.Variant
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+
+/**
+ * Configures JNI library packaging options for React Native native modules.
+ *
+ * This configurator sets up pickFirst rules to handle duplicate .so files
+ * from various React Native dependencies. Based on React Native Gradle Plugin's
+ * NdkConfiguratorUtils.configureJsEnginePackagingOptions and configureNewArchPackagingOptions.
+ *
+ * Key responsibilities:
+ * - Configure Hermes .so file packaging (libhermes.so, libhermestooling.so)
+ * - Configure fbjni and c++_shared library packaging
+ * - Configure React Native core library packaging (libreactnative.so, libjsi.so)
+ * - Exclude JSC libraries when Hermes is enabled
+ *
+ * Without proper packaging configuration, duplicate .so files from multiple AARs
+ * will cause build failures or runtime crashes.
+ */
+class JniPackagingConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+) {
+
+  /**
+   * Configures JNI packaging options for all build variants.
+   *
+   * Must be called during plugin configuration (typically in apply() or afterEvaluate).
+   */
+  fun configure(androidComponents: LibraryAndroidComponentsExtension) {
+    project.logger.lifecycle("Configuring JNI packaging options for React Native")
+
+    // Configure packaging for each variant
+    androidComponents.onVariants { variant ->
+      val hermesEnabled = true // Hermes is always enabled
+      val newArchEnabled = true // New Architecture is mandatory
+
+      project.logger.debug(
+        "Configuring packaging for variant ${variant.name}: " +
+          "hermesEnabled=$hermesEnabled (mandatory), newArchEnabled=$newArchEnabled (mandatory)",
+      )
+
+      // Configure JS engine packaging (Hermes only)
+      configureJsEnginePackaging(variant, hermesEnabled)
+
+      // Configure New Architecture packaging
+      configureNewArchPackaging(variant, newArchEnabled)
+
+      project.logger.debug("Packaging configuration complete for variant ${variant.name}")
+    }
+  }
+
+  /**
+   * Configures JavaScript engine .so file packaging.
+   *
+   * Based on NdkConfiguratorUtils.configureJsEnginePackagingOptions.
+   *
+   * When Hermes is enabled:
+   * - Exclude JSC libraries (libjsc.so, libjsctooling.so)
+   * - Include Hermes libraries (libhermes.so, libhermestooling.so) as pickFirst
+   *
+   * When JSC is enabled:
+   * - Exclude Hermes libraries
+   * - Include JSC libraries as pickFirst
+   *
+   * @param variant The build variant being configured
+   * @param hermesEnabled Whether Hermes is enabled for this build
+   */
+  private fun configureJsEnginePackaging(
+    variant: com.android.build.api.variant.Variant,
+    hermesEnabled: Boolean,
+  ) {
+    if (hermesEnabled) {
+      // Hermes enabled: exclude JSC, include Hermes
+      variant.packaging.jniLibs.excludes.addAll(
+        listOf(
+          "**/libjsc.so",
+          "**/libjsctooling.so",
+        ),
+      )
+      variant.packaging.jniLibs.pickFirsts.addAll(
+        listOf(
+          "**/libhermes.so",
+          "**/libhermestooling.so",
+        ),
+      )
+
+      project.logger.debug("Configured Hermes packaging: excluding JSC, including Hermes")
+    } else {
+      // JSC enabled (not supported by Granite, but keep for compatibility)
+      variant.packaging.jniLibs.excludes.addAll(
+        listOf(
+          "**/libhermes.so",
+          "**/libhermestooling.so",
+        ),
+      )
+      variant.packaging.jniLibs.pickFirsts.addAll(
+        listOf(
+          "**/libjsc.so",
+          "**/libjsctooling.so",
+        ),
+      )
+
+      project.logger.warn(
+        "JSC packaging configured, but Granite plugin only supports Hermes. " +
+          "This configuration may cause runtime errors.",
+      )
+    }
+  }
+
+  /**
+   * Configures New Architecture .so file packaging.
+   *
+   * Based on NdkConfiguratorUtils.configureNewArchPackagingOptions.
+   *
+   * For Old Architecture:
+   * - pickFirst for fbjni and c++_shared (commonly duplicated)
+   *
+   * For New Architecture:
+   * - pickFirst for fbjni, c++_shared, libreactnative.so, libjsi.so
+   *
+   * @param variant The build variant being configured
+   * @param newArchEnabled Whether New Architecture is enabled
+   */
+  private fun configureNewArchPackaging(
+    variant: com.android.build.api.variant.Variant,
+    newArchEnabled: Boolean,
+  ) {
+    if (!newArchEnabled) {
+      // Old Architecture: basic pickFirst for common duplicates
+      variant.packaging.jniLibs.pickFirsts.addAll(
+        listOf(
+          "**/libfbjni.so",
+          "**/libc++_shared.so",
+        ),
+      )
+
+      project.logger.debug("Configured Old Architecture packaging: basic pickFirsts")
+    } else {
+      // New Architecture: additional React Native core libraries
+      variant.packaging.jniLibs.pickFirsts.addAll(
+        listOf(
+          // FBJNI provided via prefab
+          "**/libfbjni.so",
+          // React Native prefab libraries
+          "**/libreactnative.so",
+          "**/libjsi.so",
+          // C++ standard library
+          "**/libc++_shared.so",
+        ),
+      )
+
+      project.logger.debug("Configured New Architecture packaging: extended pickFirsts")
+    }
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/NdkConfigurator.kt

@@ -0,0 +1,135 @@
+package run.granite.gradle.config
+
+import com.android.build.gradle.LibraryExtension
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+import java.io.File
+
+/**
+ * Configures Android NDK and CMake build settings for React Native native modules.
+ *
+ * This configurator:
+ * - Enables Prefab for consuming native library dependencies
+ * - Configures externalNativeBuild with CMake
+ * - Configures Android ABIs
+ * - Sets up CMake arguments for React Native
+ *
+ * Native libraries (.so files) are built by CMake and packaged in the AAR.
+ * App modules can consume these libraries via Prefab without additional configuration.
+ */
+class NdkConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+  private val androidExtension: LibraryExtension,
+) {
+
+  /**
+   * Configures all NDK and CMake settings.
+   */
+  fun configure() {
+    project.logger.lifecycle("Configuring NDK and CMake for React Native native modules")
+
+    // Enable Prefab
+    configurePrefab()
+
+    // Configure externalNativeBuild with CMake
+    configureCMake()
+
+    // Configure ABIs
+    configureAbis()
+
+    project.logger.lifecycle("NDK configuration complete")
+  }
+
+  /**
+   * Enables Prefab for packaging native libraries.
+   *
+   * Prefab allows the AAR to export native libraries (.so files) that can be
+   * consumed by app modules without manual configuration.
+   *
+   * Implementation details.
+   */
+  private fun configurePrefab() {
+    androidExtension.buildFeatures.prefab = true
+
+    project.logger.debug("Prefab enabled for native library packaging")
+  }
+
+  /**
+   * Configures externalNativeBuild with CMake.
+   *
+   * Sets up CMake configuration for building React Native and custom native modules.
+   *
+   * Implementation details.
+   */
+  private fun configureCMake() {
+    val cmakeListsFile = project.file("CMakeLists.txt")
+
+    if (!cmakeListsFile.exists()) {
+      project.logger.warn(
+        """
+                |CMakeLists.txt not found: ${cmakeListsFile.absolutePath}
+                |
+                |Native module builds will be skipped. If your library has C++ native modules,
+                |create a CMakeLists.txt file at the project root.
+        """.trimMargin(),
+      )
+      return
+    }
+
+    androidExtension.externalNativeBuild.cmake {
+      path = cmakeListsFile
+
+      // CMake version (compatible with React Native 0.81+)
+      version = "3.22.1"
+    }
+
+    androidExtension.defaultConfig.externalNativeBuild.cmake {
+      // Add CMake arguments for React Native
+      val codegenJniDir = project.layout.buildDirectory
+        .dir("generated/codegen/jni")
+        .get().asFile.absolutePath
+
+      val reactNativeDir = extension.getReactNativeDirResolved().absolutePath
+      val nodeModulesDir = extension.getNodeModulesDirResolved().absolutePath
+      // For RN 0.71-0.75, use ReactAndroid; for RN 0.76+, use android
+      val reactAndroidDir = "$reactNativeDir/ReactAndroid"
+      val projectBuildDir = project.layout.buildDirectory.get().asFile.absolutePath
+      val projectRootDir = project.rootDir.absolutePath
+
+      arguments(
+        "-DREACT_NATIVE_DIR=$reactNativeDir",
+        "-DREACT_ANDROID_DIR=$reactAndroidDir",
+        "-DNODE_MODULES_DIR=$nodeModulesDir",
+        "-DCODEGEN_JNI_DIR=$codegenJniDir",
+        "-DPROJECT_BUILD_DIR=$projectBuildDir",
+        "-DPROJECT_ROOT_DIR=$projectRootDir",
+        "-DANDROID_STL=c++_shared",
+      )
+
+      project.logger.debug("CMake configured with React Native arguments")
+    }
+  }
+
+  /**
+   * Configures Android ABIs (architectures) to build.
+   *
+   * By default, builds for all ABIs. Users can customize via GraniteExtension.
+   *
+   * Implementation details.
+   */
+  private fun configureAbis() {
+    val abis = extension.nativeArchitectures.get()
+
+    if (abis.isEmpty()) {
+      project.logger.warn("No ABIs configured - using default (all ABIs)")
+      return
+    }
+
+    androidExtension.defaultConfig.ndk {
+      abiFilters.addAll(abis)
+    }
+
+    project.logger.lifecycle("Configured ABIs: ${abis.joinToString(", ")}")
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/RepositoryConfigurator.kt

@@ -0,0 +1,148 @@
+package run.granite.gradle.config
+
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+import java.io.File
+
+/**
+ * Configures Maven repositories for React Native dependencies.
+ *
+ * This configurator automatically adds required repositories:
+ * - Maven Central (for React Native, Hermes, SoLoader)
+ * - Google Maven (for Android dependencies)
+ * - React Native Maven repository (node_modules/react-native/android)
+ * - JSC/Hermes Maven repository (for JavaScript engines)
+ * - Project-specific repositories (if configured)
+ */
+class RepositoryConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+) {
+
+  /**
+   * Configures all required Maven repositories.
+   *
+   * Called during plugin application to ensure repositories are available
+   * before dependency resolution.
+   *
+   * Adds repositories to all projects (including root) so that third-party modules
+   * can resolve react-native dependencies.
+   */
+  fun configure() {
+    project.logger.lifecycle("Configuring Maven repositories for React Native")
+
+    val reactNativeDir = extension.getReactNativeDirResolved()
+    val nodeModulesDir = extension.getNodeModulesDirResolved()
+
+    // Add repositories to all projects (official RN plugin approach)
+    project.rootProject.allprojects.forEach { eachProject ->
+      // Add standard repositories
+      addStandardRepositories(eachProject)
+
+      // Add React Native Maven repository
+      addReactNativeMavenRepository(eachProject, reactNativeDir)
+
+      // Add Android Maven repository from node_modules
+      addAndroidMavenRepository(eachProject, nodeModulesDir)
+
+      // Add JSC Maven repository (even though we use Hermes, some RN components may reference it)
+      addJscMavenRepository(eachProject, nodeModulesDir)
+    }
+  }
+
+  /**
+   * Adds standard Maven repositories (Google, Maven Central).
+   */
+  private fun addStandardRepositories(targetProject: Project) {
+    targetProject.repositories.apply {
+      // Google Maven for Android dependencies
+      if (findByName("Google") == null) {
+        google()
+        project.logger.debug("[${targetProject.name}] Added repository: Google Maven")
+      }
+
+      // Maven Central for React Native and Hermes
+      if (findByName("MavenRepo") == null) {
+        mavenCentral()
+        project.logger.debug("[${targetProject.name}] Added repository: Maven Central")
+      }
+    }
+  }
+
+  /**
+   * Adds React Native Maven repository from node_modules.
+   *
+   * This repository contains React Native Android artifacts.
+   */
+  private fun addReactNativeMavenRepository(targetProject: Project, reactNativeDir: File) {
+    val reactNativeAndroidDir = reactNativeDir.resolve("ReactAndroid")
+
+    if (!reactNativeAndroidDir.exists()) {
+      project.logger.warn(
+        "React Native Android directory not found: ${reactNativeAndroidDir.absolutePath}",
+      )
+      return
+    }
+
+    // Prevent duplicate additions
+    if (targetProject.repositories.findByName("ReactNative") != null) {
+      return
+    }
+
+    targetProject.repositories.maven {
+      name = "ReactNative"
+      setUrl(reactNativeAndroidDir)
+    }
+
+    project.logger.debug("[${targetProject.name}] Added repository: React Native Maven (${reactNativeAndroidDir.absolutePath})")
+  }
+
+  /**
+   * Adds Android Maven repository from node_modules.
+   *
+   * This repository contains prebuilt React Native Android artifacts.
+   */
+  private fun addAndroidMavenRepository(targetProject: Project, nodeModulesDir: File) {
+    val androidMavenDir = nodeModulesDir.resolve("react-native/android")
+
+    if (androidMavenDir.exists()) {
+      // Prevent duplicate additions
+      if (targetProject.repositories.findByName("ReactNativeAndroid") != null) {
+        return
+      }
+
+      targetProject.repositories.maven {
+        name = "ReactNativeAndroid"
+        setUrl(androidMavenDir)
+      }
+
+      project.logger.debug("[${targetProject.name}] Added repository: React Native Android Maven (${androidMavenDir.absolutePath})")
+    }
+  }
+
+  /**
+   * Adds JSC Maven repository from node_modules.
+   *
+   * Even though Hermes is required, some React Native components may reference JSC.
+   */
+  private fun addJscMavenRepository(targetProject: Project, nodeModulesDir: File) {
+    val jscAndroidDir = nodeModulesDir.resolve("jsc-android/dist")
+
+    if (jscAndroidDir.exists()) {
+      // Prevent duplicate additions
+      if (targetProject.repositories.findByName("JSC") != null) {
+        return
+      }
+
+      targetProject.repositories.maven {
+        name = "JSC"
+        setUrl(jscAndroidDir)
+      }
+
+      project.logger.debug("[${targetProject.name}] Added repository: JSC Maven (${jscAndroidDir.absolutePath})")
+    } else {
+      // JSC may not be installed if using Hermes exclusively
+      project.logger.debug("[${targetProject.name}] JSC Maven repository not found (not required for Hermes builds)")
+    }
+  }
+}

package/gradle-plugin/src/main/kotlin/run/granite/gradle/config/ResourceConfigurator.kt

@@ -0,0 +1,56 @@
+package run.granite.gradle.config
+
+import com.android.build.gradle.LibraryExtension
+import org.gradle.api.Project
+import run.granite.gradle.GraniteExtension
+
+/**
+ * Configurator for Android resource packaging options.
+ *
+ * Configures:
+ * - Bundle compression settings (aaptOptions.noCompress)
+ * - Resource merging behavior
+ * - Asset packaging optimizations
+ */
+class ResourceConfigurator(
+  private val project: Project,
+  private val extension: GraniteExtension,
+) {
+
+  /**
+   * Configures Android resource packaging options.
+   *
+   * Sets up:
+   * 1. Bundle compression control based on extension settings
+   * 2. No-compress patterns for JavaScript bundles
+   */
+  fun configure(androidExtension: LibraryExtension) {
+    configureAaptOptions(androidExtension)
+    project.logger.debug("Resource packaging configured")
+  }
+
+  /**
+   * Configures AAPT options for bundle compression.
+   *
+   * If bundle compression is disabled, adds bundle file patterns to noCompress list
+   * to prevent APK/AAR packaging from compressing already-compressed Hermes bytecode.
+   */
+  private fun configureAaptOptions(androidExtension: LibraryExtension) {
+    androidExtension.packaging {
+      resources {
+        // Don't compress JavaScript bundles if they're already gzip compressed
+        if (!extension.bundleCompressionEnabled.get()) {
+          excludes.add("**/*.bundle")
+          excludes.add("**/*.hbc")
+        }
+
+        // Always exclude .map files from compression
+        excludes.add("**/*.map")
+      }
+    }
+
+    project.logger.lifecycle(
+      "Bundle compression: ${if (extension.bundleCompressionEnabled.get()) "enabled" else "disabled"}",
+    )
+  }
+}