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

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

@@ -12,6 +12,7 @@ import com.facebook.react.utils.detectOSAwareHermesCommand
 import com.facebook.react.utils.moveTo
 import com.facebook.react.utils.windowsAwareCommandLine
 import java.io.File
+import javax.inject.Inject
 import org.gradle.api.DefaultTask
 import org.gradle.api.file.ConfigurableFileTree
 import org.gradle.api.file.DirectoryProperty
@@ -19,6 +20,7 @@ import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
+import org.gradle.process.ExecOperations
 
 abstract class BundleHermesCTask : DefaultTask() {
 
@@ -26,19 +28,21 @@ abstract class BundleHermesCTask : DefaultTask() {
     group = "react"
   }
 
+  @get:Inject abstract val execOperations: ExecOperations
+
   @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/**/*")
+      project.fileTree(root) { fileTree ->
+        fileTree.include("**/*.js")
+        fileTree.include("**/*.jsx")
+        fileTree.include("**/*.ts")
+        fileTree.include("**/*.tsx")
+        fileTree.exclude("**/android/**/*")
+        fileTree.exclude("**/ios/**/*")
+        fileTree.exclude("**/build/**/*")
+        fileTree.exclude("**/node_modules/**/*")
       }
 
   @get:Input abstract val nodeExecutableAndArgs: ListProperty<String>
@@ -107,7 +111,11 @@ abstract class BundleHermesCTask : DefaultTask() {
         val composeScriptFile = File(reactNativeDir, "scripts/compose-source-maps.js")
         val composeSourceMapsCommand =
             getComposeSourceMapsCommand(
-                composeScriptFile, packagerSourceMap, compilerSourceMap, outputSourceMap)
+                composeScriptFile,
+                packagerSourceMap,
+                compilerSourceMap,
+                outputSourceMap,
+            )
         runCommand(composeSourceMapsCommand)
       }
     }
@@ -127,66 +135,67 @@ abstract class BundleHermesCTask : DefaultTask() {
       File(jsIntermediateSourceMapsDir.get().asFile, "$bundleAssetName.compiler.map")
 
   private fun runCommand(command: List<Any>) {
-    val process = ProcessBuilder(command.map { it.toString() })
-        .directory(root.get().asFile)
-        .redirectErrorStream(true)
-        .start()
-    val exitCode = process.waitFor()
-    if (exitCode != 0) {
-        throw org.gradle.api.GradleException("Command failed with exit code $exitCode: $command")
+    execOperations.exec { exec ->
+      exec.workingDir(root.get().asFile)
+      exec.commandLine(command)
     }
   }
 
-  internal fun getBundleCommand(bundleFile: File, sourceMapFile: File): List<Any> =
-      windowsAwareCommandLine(
-          buildList {
-            val rootFile = root.get().asFile
-            addAll(nodeExecutableAndArgs.get())
-            add(cliFile.get().asFile.cliPath(rootFile))
-            add(bundleCommand.get())
-            add("--platform")
-            add("android")
-            add("--dev")
-            add(devEnabled.get().toString())
-            add("--reset-cache")
-            add("--entry-file")
-            add(entryFile.get().asFile.cliPath(rootFile))
-            add("--bundle-output")
-            add(bundleFile.cliPath(rootFile))
-            add("--assets-dest")
-            add(resourcesDir.get().asFile.cliPath(rootFile))
-            add("--sourcemap-output")
-            add(sourceMapFile.cliPath(rootFile))
-            if (bundleConfig.isPresent) {
-              add("--config")
-              add(bundleConfig.get().asFile.cliPath(rootFile))
-            }
-            add("--minify")
-            add(minifyEnabled.get().toString())
-            addAll(extraPackagerArgs.get())
-            add("--verbose")
-          })
+  internal fun getBundleCommand(bundleFile: File, sourceMapFile: File): List<Any> {
+    val rootFile = root.get().asFile
+    val commandLine =
+        mutableListOf<String>().apply {
+          addAll(nodeExecutableAndArgs.get())
+          add(cliFile.get().asFile.cliPath(rootFile))
+          add(bundleCommand.get())
+          add("--platform")
+          add("android")
+          add("--dev")
+          add(devEnabled.get().toString())
+          add("--reset-cache")
+          add("--entry-file")
+          add(entryFile.get().asFile.cliPath(rootFile))
+          add("--bundle-output")
+          add(bundleFile.cliPath(rootFile))
+          add("--assets-dest")
+          add(resourcesDir.get().asFile.cliPath(rootFile))
+          add("--sourcemap-output")
+          add(sourceMapFile.cliPath(rootFile))
+          if (bundleConfig.isPresent) {
+            add("--config")
+            add(bundleConfig.get().asFile.cliPath(rootFile))
+          }
+          add("--minify")
+          add(minifyEnabled.get().toString())
+          addAll(extraPackagerArgs.get())
+          add("--verbose")
+        }
+    return windowsAwareCommandLine(commandLine)
+  }
 
   internal fun getHermescCommand(
       hermesCommand: String,
       bytecodeFile: File,
-      bundleFile: File
+      bundleFile: File,
   ): List<Any> {
     val rootFile = root.get().asFile
     return windowsAwareCommandLine(
         hermesCommand,
+        "-w",
         "-emit-binary",
+        "-max-diagnostic-width=80",
         "-out",
         bytecodeFile.cliPath(rootFile),
         bundleFile.cliPath(rootFile),
-        *hermesFlags.get().toTypedArray())
+        *hermesFlags.get().toTypedArray(),
+    )
   }
 
   internal fun getComposeSourceMapsCommand(
       composeScript: File,
       packagerSourceMap: File,
       compilerSourceMap: File,
-      outputSourceMap: File
+      outputSourceMap: File,
   ): List<Any> {
     val rootFile = root.get().asFile
     return windowsAwareCommandLine(
@@ -195,6 +204,7 @@ abstract class BundleHermesCTask : DefaultTask() {
         packagerSourceMap.cliPath(rootFile),
         compilerSourceMap.cliPath(rootFile),
         "-o",
-        outputSourceMap.cliPath(rootFile))
+        outputSourceMap.cliPath(rootFile),
+    )
   }
 }

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

@@ -0,0 +1,252 @@
+/*
+ * 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.model.ModelAutolinkingConfigJson
+import com.facebook.react.model.ModelAutolinkingDependenciesPlatformAndroidJson
+import com.facebook.react.utils.JsonUtils
+import java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+
+abstract class GenerateAutolinkingNewArchitecturesFileTask : DefaultTask() {
+
+  init {
+    group = "react"
+  }
+
+  @get:InputFile abstract val autolinkInputFile: RegularFileProperty
+
+  @get:OutputDirectory abstract val generatedOutputDirectory: DirectoryProperty
+
+  @TaskAction
+  fun taskAction() {
+    val model = JsonUtils.fromAutolinkingConfigJson(autolinkInputFile.get().asFile)
+
+    val packages = filterAndroidPackages(model)
+    val cmakeFileContent = generateCmakeFileContent(packages)
+    val cppFileContent = generateCppFileContent(packages)
+
+    val outputDir = generatedOutputDirectory.get().asFile
+    outputDir.mkdirs()
+    File(outputDir, CMAKE_FILENAME).apply { writeText(cmakeFileContent) }
+    File(outputDir, CPP_FILENAME).apply { writeText(cppFileContent) }
+    File(outputDir, H_FILENAME).apply { writeText(hTemplate) }
+  }
+
+  internal fun filterAndroidPackages(
+      model: ModelAutolinkingConfigJson?
+  ): List<ModelAutolinkingDependenciesPlatformAndroidJson> =
+      model?.dependencies?.values?.mapNotNull { it.platforms?.android } ?: emptyList()
+
+  internal fun generateCmakeFileContent(
+      packages: List<ModelAutolinkingDependenciesPlatformAndroidJson>
+  ): String {
+    val libraryIncludes =
+        packages.joinToString("\n") { dep ->
+          var addDirectoryString = ""
+          val libraryName = dep.libraryName
+          val cmakeListsPath = dep.cmakeListsPath
+          val cxxModuleCMakeListsPath = dep.cxxModuleCMakeListsPath
+          if (libraryName != null && cmakeListsPath != null) {
+            // If user provided a custom cmakeListsPath, let's honor it.
+            val nativeFolderPath = sanitizeCmakeListsPath(cmakeListsPath)
+            addDirectoryString +=
+                "add_subdirectory(\"$nativeFolderPath\" ${libraryName}_autolinked_build)"
+          }
+          if (cxxModuleCMakeListsPath != null) {
+            // If user provided a custom cxxModuleCMakeListsPath, let's honor it.
+            val nativeFolderPath = sanitizeCmakeListsPath(cxxModuleCMakeListsPath)
+            addDirectoryString +=
+                "\nadd_subdirectory(\"$nativeFolderPath\" ${libraryName}_cxxmodule_autolinked_build)"
+          }
+          addDirectoryString
+        }
+
+    val libraryModules =
+        packages.joinToString("\n  ") { dep ->
+          var autolinkedLibraries = ""
+          if (dep.libraryName != null) {
+            autolinkedLibraries += "$CODEGEN_LIB_PREFIX${dep.libraryName}"
+          }
+          if (dep.cxxModuleCMakeListsModuleName != null) {
+            autolinkedLibraries += "\n${dep.cxxModuleCMakeListsModuleName}"
+          }
+          autolinkedLibraries
+        }
+
+    return CMAKE_TEMPLATE.replace("{{ libraryIncludes }}", libraryIncludes)
+        .replace("{{ libraryModules }}", libraryModules)
+  }
+
+  internal fun generateCppFileContent(
+      packages: List<ModelAutolinkingDependenciesPlatformAndroidJson>
+  ): String {
+    val packagesWithLibraryNames = packages.filter { android -> android.libraryName != null }
+
+    val cppIncludes =
+        packagesWithLibraryNames.joinToString("\n") { dep ->
+          var include = "#include <${dep.libraryName}.h>"
+          if (dep.componentDescriptors.isNotEmpty()) {
+            include +=
+                "\n#include <${COMPONENT_INCLUDE_PATH}/${dep.libraryName}/${COMPONENT_DESCRIPTOR_FILENAME}>"
+          }
+          if (dep.cxxModuleHeaderName != null) {
+            include += "\n#include <${dep.cxxModuleHeaderName}.h>"
+          }
+          include
+        }
+
+    val cppTurboModuleJavaProviders =
+        packagesWithLibraryNames.joinToString("\n") { dep ->
+          val libraryName = dep.libraryName
+          // language=cpp
+          """  
+      auto module_$libraryName = ${libraryName}_ModuleProvider(moduleName, params);
+      if (module_$libraryName != nullptr) {
+      return module_$libraryName;
+      }
+      """
+              .trimIndent()
+        }
+
+    val cppTurboModuleCxxProviders =
+        packagesWithLibraryNames
+            .filter { it.cxxModuleHeaderName != null }
+            .joinToString("\n") { dep ->
+              val cxxModuleHeaderName = dep.cxxModuleHeaderName
+              // language=cpp
+              """
+      if (moduleName == $cxxModuleHeaderName::kModuleName) {
+      return std::make_shared<$cxxModuleHeaderName>(jsInvoker);
+      }
+      """
+                  .trimIndent()
+            }
+
+    val cppComponentDescriptors =
+        packagesWithLibraryNames
+            .filter { it.componentDescriptors.isNotEmpty() }
+            .joinToString("\n") {
+              it.componentDescriptors.joinToString("\n") {
+                "providerRegistry->add(concreteComponentDescriptorProvider<$it>());"
+              }
+            }
+
+    return CPP_TEMPLATE.replace("{{ autolinkingCppIncludes }}", cppIncludes)
+        .replace("{{ autolinkingCppTurboModuleJavaProviders }}", cppTurboModuleJavaProviders)
+        .replace("{{ autolinkingCppTurboModuleCxxProviders }}", cppTurboModuleCxxProviders)
+        .replace("{{ autolinkingCppComponentDescriptors }}", cppComponentDescriptors)
+  }
+
+  companion object {
+    const val CMAKE_FILENAME = "Android-autolinking.cmake"
+
+    const val H_FILENAME = "autolinking.h"
+    const val CPP_FILENAME = "autolinking.cpp"
+
+    const val CODEGEN_LIB_PREFIX = "react_codegen_"
+
+    const val COMPONENT_DESCRIPTOR_FILENAME = "ComponentDescriptors.h"
+    const val COMPONENT_INCLUDE_PATH = "react/renderer/components"
+
+    internal fun sanitizeCmakeListsPath(cmakeListsPath: String): String =
+        cmakeListsPath.replace("CMakeLists.txt", "").replace(" ", "\\ ")
+
+    // language=cmake
+    val CMAKE_TEMPLATE =
+        """
+        # This code was generated by [React Native](https://www.npmjs.com/package/@react-native/gradle-plugin)
+        cmake_minimum_required(VERSION 3.13)
+        set(CMAKE_VERBOSE_MAKEFILE on)
+
+        # We set REACTNATIVE_MERGED_SO so libraries/apps can selectively decide to depend on either libreactnative.so
+        # or link against a old prefab target (this is needed for React Native 0.76 on).
+        set(REACTNATIVE_MERGED_SO true)
+
+        {{ libraryIncludes }}
+
+        set(AUTOLINKED_LIBRARIES
+          {{ libraryModules }}
+        )
+        """
+            .trimIndent()
+
+    // language=cpp
+    val CPP_TEMPLATE =
+        """
+        /**
+         * This code was generated by [React Native](https://www.npmjs.com/package/@react-native/gradle-plugin).
+         *
+         * Do not edit this file as changes may cause incorrect behavior and will be lost
+         * once the code is regenerated.
+         *
+         */
+
+        #include "autolinking.h"
+        {{ autolinkingCppIncludes }}
+
+        namespace facebook {
+        namespace react {
+
+        std::shared_ptr<TurboModule> autolinking_ModuleProvider(const std::string moduleName, const JavaTurboModule::InitParams &params) {
+        {{ autolinkingCppTurboModuleJavaProviders }}
+          return nullptr;
+        }
+
+        std::shared_ptr<TurboModule> autolinking_cxxModuleProvider(const std::string moduleName, const std::shared_ptr<CallInvoker>& jsInvoker) {
+        {{ autolinkingCppTurboModuleCxxProviders }}
+          return nullptr;
+        }
+
+        void autolinking_registerProviders(std::shared_ptr<ComponentDescriptorProviderRegistry const> providerRegistry) {
+        {{ autolinkingCppComponentDescriptors }}
+          return;
+        }
+
+        } // namespace react
+        } // namespace facebook
+        """
+            .trimIndent()
+
+    // language=cpp
+    val hTemplate =
+        """
+        /**
+         * This code was generated by [React Native](https://www.npmjs.com/package/@react-native/gradle-plugin).
+         *
+         * Do not edit this file as changes may cause incorrect behavior and will be lost
+         * once the code is regenerated.
+         *
+         */
+
+        #pragma once
+
+        #include <ReactCommon/CallInvoker.h>
+        #include <ReactCommon/JavaTurboModule.h>
+        #include <ReactCommon/TurboModule.h>
+        #include <jsi/jsi.h>
+        #include <react/renderer/componentregistry/ComponentDescriptorProviderRegistry.h>
+
+        namespace facebook {
+        namespace react {
+
+        std::shared_ptr<TurboModule> autolinking_ModuleProvider(const std::string moduleName, const JavaTurboModule::InitParams &params);
+        std::shared_ptr<TurboModule> autolinking_cxxModuleProvider(const std::string moduleName, const std::shared_ptr<CallInvoker>& jsInvoker);
+        void autolinking_registerProviders(std::shared_ptr<ComponentDescriptorProviderRegistry const> providerRegistry);
+
+        } // namespace react
+        } // namespace facebook
+        """
+            .trimIndent()
+  }
+}

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

@@ -10,6 +10,7 @@ package com.facebook.react.tasks
 import com.facebook.react.utils.JsonUtils
 import com.facebook.react.utils.Os.cliPath
 import com.facebook.react.utils.windowsAwareCommandLine
+import java.io.File
 import org.gradle.api.file.Directory
 import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.file.RegularFile
@@ -31,6 +32,8 @@ abstract class GenerateCodegenArtifactsTask : Exec() {
 
   @get:InputFile abstract val packageJsonFile: RegularFileProperty
 
+  @get:Input abstract val nodeWorkingDir: Property<String>
+
   @get:Input abstract val nodeExecutableAndArgs: ListProperty<String>
 
   @get:Input abstract val codegenJavaPackageName: Property<String>
@@ -53,7 +56,7 @@ abstract class GenerateCodegenArtifactsTask : Exec() {
   internal fun resolveTaskParameters(): Pair<String, String> {
     val parsedPackageJson =
         if (packageJsonFile.isPresent && packageJsonFile.get().asFile.exists()) {
-          JsonUtils.fromCodegenJson(packageJsonFile.get().asFile)
+          JsonUtils.fromPackageJson(packageJsonFile.get().asFile)
         } else {
           null
         }
@@ -64,7 +67,7 @@ abstract class GenerateCodegenArtifactsTask : Exec() {
   }
 
   internal fun setupCommandLine(libraryName: String, codegenJavaPackageName: String) {
-    val workingDir = project.projectDir
+    val workingDir = File(nodeWorkingDir.get())
     commandLine(
         windowsAwareCommandLine(
             *nodeExecutableAndArgs.get().toTypedArray(),
@@ -78,6 +81,8 @@ abstract class GenerateCodegenArtifactsTask : Exec() {
             "--libraryName",
             libraryName,
             "--javaPackageName",
-            codegenJavaPackageName))
+            codegenJavaPackageName,
+        )
+    )
   }
 }

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

@@ -9,9 +9,12 @@ package com.facebook.react.tasks
 
 import com.facebook.react.utils.Os.cliPath
 import com.facebook.react.utils.windowsAwareCommandLine
+import java.io.File
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.FileTree
 import org.gradle.api.file.RegularFile
 import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.*
 
@@ -28,24 +31,11 @@ abstract class GenerateCodegenSchemaTask : Exec() {
 
   @get:Internal abstract val generatedSrcDir: DirectoryProperty
 
+  @get:Input abstract val nodeWorkingDir: Property<String>
+
   @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:InputFiles abstract val jsInputFiles: Property<FileTree>
 
   @get:OutputFile
   val generatedSchemaFile: Provider<RegularFile> = generatedSrcDir.file("schema.json")
@@ -64,7 +54,7 @@ abstract class GenerateCodegenSchemaTask : Exec() {
   }
 
   internal fun setupCommandLine() {
-    val workingDir = project.projectDir
+    val workingDir = File(nodeWorkingDir.get())
     commandLine(
         windowsAwareCommandLine(
             *nodeExecutableAndArgs.get().toTypedArray(),
@@ -75,8 +65,11 @@ abstract class GenerateCodegenSchemaTask : Exec() {
                 .cliPath(workingDir),
             "--platform",
             "android",
+            "--exclude",
+            "NativeSampleTurboModule",
             generatedSchemaFile.get().asFile.cliPath(workingDir),
             jsRootDir.asFile.get().cliPath(workingDir),
-        ))
+        )
+    )
   }
 }

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

@@ -0,0 +1,108 @@
+/*
+ * 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 java.io.File
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+
+abstract class GenerateEntryPointTask : DefaultTask() {
+
+  init {
+    group = "react"
+  }
+
+  @get:InputFile abstract val autolinkInputFile: RegularFileProperty
+
+  @get:OutputDirectory abstract val generatedOutputDirectory: DirectoryProperty
+
+  @TaskAction
+  fun taskAction() {
+    val model =
+        JsonUtils.fromAutolinkingConfigJson(autolinkInputFile.get().asFile)
+            ?: error(
+                """
+                  RNGP - Autolinking: Could not parse autolinking config file:
+                  ${autolinkInputFile.get().asFile.absolutePath}
+                  
+                  The file is either missing or not containing valid JSON so the build won't succeed. 
+                """
+                    .trimIndent()
+            )
+
+    val packageName =
+        model.project?.android?.packageName
+            ?: error(
+                "RNGP - Autolinking: Could not find project.android.packageName in react-native config output! Could not autolink packages without this field."
+            )
+    val generatedFileContents = composeFileContent(packageName)
+
+    val outputDir = generatedOutputDirectory.get().asFile
+    outputDir.mkdirs()
+    File(outputDir, GENERATED_FILENAME).apply {
+      parentFile.mkdirs()
+      writeText(generatedFileContents)
+    }
+  }
+
+  internal fun composeFileContent(packageName: String): String =
+      generatedFileContentsTemplate.replace("{{packageName}}", packageName)
+
+  companion object {
+    const val GENERATED_FILENAME = "com/facebook/react/ReactNativeApplicationEntryPoint.java"
+
+    // language=java
+    val generatedFileContentsTemplate =
+        """
+        package com.facebook.react;
+
+        import android.app.Application;
+        import android.content.Context;
+        import android.content.res.Resources;
+
+        import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint;
+        import com.facebook.react.common.annotations.internal.LegacyArchitectureLogger;
+        import com.facebook.react.views.view.WindowUtilKt;
+        import com.facebook.react.soloader.OpenSourceMergedSoMapping;
+        import com.facebook.soloader.SoLoader;
+
+        import java.io.IOException;
+
+        /**
+          * This class is the entry point for loading React Native using the configuration
+          * that the users specifies in their .gradle files.
+          *
+          * The `loadReactNative(this)` method invocation should be called inside the
+          * application onCreate otherwise the app won't load correctly.            
+          */
+        public class ReactNativeApplicationEntryPoint {
+          public static void loadReactNative(Context context) {
+            try {
+               SoLoader.init(context, OpenSourceMergedSoMapping.INSTANCE);
+            } catch (IOException error) {
+              throw new RuntimeException(error);
+            }
+            
+            if ({{packageName}}.BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
+              DefaultNewArchitectureEntryPoint.load();
+            }
+            
+            if ({{packageName}}.BuildConfig.IS_EDGE_TO_EDGE_ENABLED) {
+              WindowUtilKt.setEdgeToEdgeFeatureFlagOn();
+            }
+          }
+        }
+        """
+            .trimIndent()
+  }
+}