react-native 0.70.6 → 0.71.0-rc.1

package/ReactAndroid/build.gradle

@@ -14,19 +14,22 @@ buildscript {
 plugins {
     id("com.android.library")
     id("com.facebook.react")
-    id("maven-publish")
     id("de.undercouch.download")
+    id("maven-publish")
 }
 
 import com.facebook.react.tasks.internal.*
+import com.facebook.react.tasks.internal.utils.*
 
 import java.nio.file.Paths
 
+import kotlin.Pair
+
 import de.undercouch.gradle.tasks.download.Download
-import org.apache.tools.ant.taskdefs.condition.Os
-import org.apache.tools.ant.filters.ReplaceTokens
 
-def AAR_OUTPUT_URL = "file://${projectDir}/../android"
+version = VERSION_NAME
+group = "com.facebook.react"
+
 // We download various C++ open-source dependencies into downloads.
 // We then copy both the downloaded code and our custom makefiles and headers into third-party-ndk.
 // After that we build native code from src/main/jni with module path pointing at third-party-ndk.
@@ -48,8 +51,133 @@ def dependenciesPath = System.getenv("REACT_NATIVE_DEPENDENCIES")
 // and the build will use that.
 def boostPath = dependenciesPath ?: System.getenv("REACT_NATIVE_BOOST_PATH")
 
-// Setup build type for NDK, supported values: {debug, release}
-def nativeBuildType = System.getenv("NATIVE_BUILD_TYPE") ?: "release"
+// By setting REACT_NATIVE_SKIP_PREFAB we can skip prefab publishing, to
+// reduce the size of the React Native published .AAR.
+def skipPrefabPublishing = System.getenv("REACT_NATIVE_SKIP_PREFAB") != null
+def prefabHeadersDir = project.file("$buildDir/prefab-headers")
+
+final def preparePrefab = tasks.register("preparePrefab", PreparePrefabHeadersTask) {
+    dependsOn(prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog)
+    dependsOn("generateCodegenArtifactsFromSchema")
+    // To export to a ReactNativePrefabProcessingEntities.kt once all
+    // libraries have been moved. We keep it here for now as it make easier to
+    // migrate one library at a time.
+    it.input.set(
+        [
+            new PrefabPreprocessingEntry(
+                "react_render_debug",
+                new Pair("../ReactCommon/react/renderer/debug/", "react/renderer/debug/")
+            ),
+            new PrefabPreprocessingEntry(
+                "turbomodulejsijni",
+                new Pair("src/main/jni/react/turbomodule", "")
+            ),
+            new PrefabPreprocessingEntry(
+                "runtimeexecutor",
+                new Pair("../ReactCommon/runtimeexecutor/", "")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_codegen_rncore",
+                new Pair(new File(buildDir, "generated/source/codegen/jni/").absolutePath, "")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_debug",
+                new Pair("../ReactCommon/react/debug/", "react/debug/")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_render_componentregistry",
+                new Pair("../ReactCommon/react/renderer/componentregistry/", "react/renderer/componentregistry/")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_newarchdefaults",
+                new Pair("src/main/jni/react/newarchdefaults", "")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_render_core",
+                new Pair("../ReactCommon/react/renderer/core/", "react/renderer/core/")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_render_graphics",
+                [
+                    new Pair("../ReactCommon/react/renderer/graphics/", "react/renderer/graphics/"),
+                    new Pair("../ReactCommon/react/renderer/graphics/platform/cxx/", ""),
+                ]
+            ),
+            new PrefabPreprocessingEntry(
+                "rrc_view",
+                new Pair("../ReactCommon/react/renderer/components/view/", "react/renderer/components/view/")
+            ),
+            new PrefabPreprocessingEntry(
+                "jsi",
+                new Pair("../ReactCommon/jsi/", "")
+            ),
+            new PrefabPreprocessingEntry(
+                "glog",
+                new Pair(new File(buildDir, "third-party-ndk/glog/exported/").absolutePath, "")
+            ),
+            new PrefabPreprocessingEntry(
+                "fabricjni",
+                new Pair("src/main/jni/react/fabric", "")
+            ),
+            new PrefabPreprocessingEntry(
+                "react_render_mapbuffer",
+                new Pair("../ReactCommon/react/renderer/mapbuffer/", "react/renderer/mapbuffer/")
+            ),
+            new PrefabPreprocessingEntry(
+                "yoga",
+                [
+                    new Pair("../ReactCommon/yoga/", ""),
+                    new Pair("src/main/jni/first-party/yogajni/jni", "")
+                ]
+            ),
+            new PrefabPreprocessingEntry(
+                "folly_runtime",
+                [
+                    new Pair(new File(buildDir, "third-party-ndk/folly/").absolutePath, ""),
+                    new Pair(new File(buildDir, "third-party-ndk/boost/boost_1_76_0/").absolutePath, ""),
+                    new Pair(new File(buildDir, "third-party-ndk/double-conversion/").absolutePath, ""),
+                ]
+            ),
+            new PrefabPreprocessingEntry(
+                "react_nativemodule_core",
+                [
+                    new Pair(new File(buildDir, "third-party-ndk/boost/boost_1_76_0/").absolutePath, ""),
+                    new Pair(new File(buildDir, "third-party-ndk/double-conversion/").absolutePath, ""),
+                    new Pair(new File(buildDir, "third-party-ndk/folly/").absolutePath, ""),
+                    new Pair("../ReactCommon/butter/", "butter/"),
+                    new Pair("../ReactCommon/callinvoker/", ""),
+                    new Pair("../ReactCommon/react/bridging/", "react/bridging/"),
+                    new Pair("../ReactCommon/react/config/", "react/config/"),
+                    new Pair("../ReactCommon/react/nativemodule/core/", ""),
+                    new Pair("../ReactCommon/react/nativemodule/core/platform/android/", ""),
+                    new Pair("../ReactCommon/react/renderer/componentregistry/", "react/renderer/componentregistry/"),
+                    new Pair("../ReactCommon/react/renderer/components/root/", "react/renderer/components/root/"),
+                    new Pair("../ReactCommon/react/renderer/leakchecker/", "react/renderer/leakchecker/"),
+                    new Pair("../ReactCommon/react/renderer/mapbuffer/", "react/renderer/mapbuffer/"),
+                    new Pair("../ReactCommon/react/renderer/mounting/", "react/renderer/mounting/"),
+                    new Pair("../ReactCommon/react/renderer/runtimescheduler/", "react/renderer/runtimescheduler/"),
+                    new Pair("../ReactCommon/react/renderer/scheduler/", "react/renderer/scheduler/"),
+                    new Pair("../ReactCommon/react/renderer/telemetry/", "react/renderer/telemetry/"),
+                    new Pair("../ReactCommon/react/renderer/uimanager/", "react/renderer/uimanager/"),
+                    new Pair("../ReactCommon/react/utils/", "react/utils/"),
+                    new Pair("src/main/jni/react/jni", "react/jni/"),
+                ]
+            ),
+            new PrefabPreprocessingEntry(
+                "react_render_imagemanager",
+                [
+                    new Pair("../ReactCommon/react/renderer/imagemanager/", "react/renderer/imagemanager/"),
+                    new Pair("../ReactCommon/react/renderer/imagemanager/platform/cxx/", ""),
+                ]
+            ),
+            new PrefabPreprocessingEntry(
+                "rrc_image",
+                new Pair("../ReactCommon/react/renderer/components/image/", "react/renderer/components/image/")
+            ),
+        ]
+    )
+    it.outputDir.set(prefabHeadersDir)
+}
 
 // We put the publishing version from gradle.properties inside ext. so other
 // subprojects can access it as well.
@@ -84,7 +212,7 @@ task downloadDoubleConversion(dependsOn: createNativeDepsDirectories, type: Down
 task prepareDoubleConversion(dependsOn: dependenciesPath ? [] : [downloadDoubleConversion], type: Copy) {
     from(dependenciesPath ?: tarTree(downloadDoubleConversion.dest))
     from("src/main/jni/third-party/double-conversion/")
-    include("double-conversion-${DOUBLE_CONVERSION_VERSION}/src/**/*", "Android.mk", "CMakeLists.txt")
+    include("double-conversion-${DOUBLE_CONVERSION_VERSION}/src/**/*", "CMakeLists.txt")
     filesMatching("*/src/**/*", { fname -> fname.path = "double-conversion/${fname.name}" })
     includeEmptyDirs = false
     into("$thirdPartyNdkDir/double-conversion")
@@ -100,7 +228,7 @@ task downloadFolly(dependsOn: createNativeDepsDirectories, type: Download) {
 task prepareFolly(dependsOn: dependenciesPath ? [] : [downloadFolly], type: Copy) {
     from(dependenciesPath ?: tarTree(downloadFolly.dest))
     from("src/main/jni/third-party/folly/")
-    include("folly-${FOLLY_VERSION}/folly/**/*", "Android.mk", "CMakeLists.txt")
+    include("folly-${FOLLY_VERSION}/folly/**/*", "CMakeLists.txt")
     eachFile { fname -> fname.path = (fname.path - "folly-${FOLLY_VERSION}/") }
     includeEmptyDirs = false
     into("$thirdPartyNdkDir/folly")
@@ -116,7 +244,7 @@ task downloadFmt(dependsOn: createNativeDepsDirectories, type: Download) {
 task prepareFmt(dependsOn: dependenciesPath ? [] : [downloadFmt], type: Copy) {
     from(dependenciesPath ?: tarTree(downloadFmt.dest))
     from("src/main/jni/third-party/fmt/")
-    include("fmt-${FMT_VERSION}/src/**/*", "fmt-${FMT_VERSION}/include/**/*", "Android.mk", "CMakeLists.txt")
+    include("fmt-${FMT_VERSION}/src/**/*", "fmt-${FMT_VERSION}/include/**/*", "CMakeLists.txt")
     eachFile { fname -> fname.path = (fname.path - "fmt-${FMT_VERSION}/") }
     includeEmptyDirs = false
     into("$thirdPartyNdkDir/fmt")
@@ -153,7 +281,7 @@ final def prepareGlog = tasks.register("prepareGlog", PrepareGlogTask) {
     it.outputDir.set(new File(thirdPartyNdkDir, "glog"))
 }
 
-// Create Android.mk library module based on jsc from npm
+// Create Android native library module based on jsc from npm
 tasks.register('prepareJSC', PrepareJSCTask) {
     it.jscPackagePath.set(findNodeModulePath(projectDir, "jsc-android"))
     it.outputDir = project.layout.buildDirectory.dir("third-party-ndk/jsc")
@@ -221,11 +349,7 @@ def reactNativeArchitectures() {
     return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
-tasks.register("packageReactNdkLibsForBuck") {
-    dependsOn("packageReactNdkDebugLibsForBuck")
-}
-
-tasks.register("packageReactNdkDebugLibsForBuck", Copy) {
+task packageReactNdkLibsForBuck(type: Copy) {
     dependsOn("mergeDebugNativeLibs")
     // Shared libraries (.so) are copied from the merged_native_libs folder instead
     from("$buildDir/intermediates/merged_native_libs/debug/out/lib/")
@@ -234,28 +358,13 @@ tasks.register("packageReactNdkDebugLibsForBuck", Copy) {
     into("src/main/jni/prebuilt/lib")
 }
 
-tasks.register("packageReactNdkReleaseLibsForBuck", Copy) {
-    dependsOn("mergeReleaseNativeLibs")
-    // Shared libraries (.so) are copied from the merged_native_libs folder instead
-    from("$buildDir/intermediates/merged_native_libs/release/out/lib/")
-    exclude("**/libjsc.so")
-    exclude("**/libhermes.so")
-    into("src/main/jni/prebuilt/lib")
-}
-
-final def extractNativeDependencies = tasks.register('extractNativeDependencies', ExtractJniAndHeadersTask) {
-    it.extractHeadersConfiguration.setFrom(configurations.extractHeaders)
-    it.extractJniConfiguration.setFrom(configurations.extractJNI)
-    it.baseOutputDir = project.file("src/main/jni/first-party/")
-}
-
 task installArchives {
     dependsOn("publishAllPublicationsToNpmRepository")
 }
 
 android {
-    buildToolsVersion = "31.0.0"
-    compileSdkVersion 31
+    buildToolsVersion = "33.0.0"
+    compileSdkVersion 33
 
     // Used to override the NDK path/version on internal CI or by allowing
     // users to customize the NDK path/version from their root project (e.g. for M1 support)
@@ -268,7 +377,7 @@ android {
 
     defaultConfig {
         minSdkVersion(21)
-        targetSdkVersion(31)
+        targetSdkVersion(33)
         versionCode(1)
         versionName("1.0")
 
@@ -287,23 +396,41 @@ android {
         externalNativeBuild {
             cmake {
                 arguments "-DREACT_COMMON_DIR=${reactNativeRootDir}/ReactCommon",
-                        "-DREACT_ANDROID_DIR=$projectDir",
-                        "-DREACT_BUILD_DIR=$buildDir",
-                        "-DANDROID_STL=c++_shared",
-                        "-DANDROID_TOOLCHAIN=clang",
-                        "-DANDROID_PLATFORM=android-21"
+                    "-DREACT_ANDROID_DIR=$projectDir",
+                    "-DREACT_BUILD_DIR=$buildDir",
+                    "-DANDROID_STL=c++_shared",
+                    "-DANDROID_TOOLCHAIN=clang",
+                    "-DANDROID_PLATFORM=android-21"
 
                 targets "reactnativejni",
                     "jscexecutor",
                     "jsijniprofiler",
                     "reactnativeblob",
                     "reactperfloggerjni",
+                    // prefab targets
+                    "react_render_debug",
                     "turbomodulejsijni",
-                    "fabricjni"
+                    "runtimeexecutor",
+                    "react_codegen_rncore",
+                    "react_debug",
+                    "react_render_componentregistry",
+                    "react_newarchdefaults",
+                    "react_render_core",
+                    "react_render_graphics",
+                    "rrc_image",
+                    "rrc_view",
+                    "jsi",
+                    "glog",
+                    "fabricjni",
+                    "react_render_mapbuffer",
+                    "yoga",
+                    "folly_runtime",
+                    "react_nativemodule_core",
+                    "react_render_imagemanager"
             }
         }
         ndk {
-            abiFilters (*reactNativeArchitectures())
+            abiFilters(*reactNativeArchitectures())
         }
     }
 
@@ -331,11 +458,11 @@ android {
         }
     }
 
-    preBuild.dependsOn(prepareJSC, prepareBoost, prepareDoubleConversion, prepareFmt, prepareFolly, prepareGlog, prepareLibevent, extractNativeDependencies)
+    preBuild.dependsOn(prepareJSC, prepareBoost, prepareDoubleConversion, prepareFmt, prepareFolly, prepareGlog, prepareLibevent)
     preBuild.dependsOn("generateCodegenArtifactsFromSchema")
+    preBuild.dependsOn(preparePrefab)
 
     sourceSets.main {
-        jni.srcDirs = []
         res.srcDirs = ["src/main/res/devsupport", "src/main/res/shell", "src/main/res/views/modal", "src/main/res/views/uimanager"]
         java {
             srcDirs = ["src/main/java", "src/main/libraries/soloader/java", "src/main/jni/first-party/fb/jni/java"]
@@ -359,19 +486,75 @@ android {
         exclude("**/libjsc.so")
     }
 
-    configurations {
-        extractHeaders
-        extractJNI
-    }
-
     buildFeatures {
         prefab true
+        prefabPublishing !skipPrefabPublishing
+    }
+
+    prefab {
+        react_render_debug {
+            headers(new File(prefabHeadersDir, "react_render_debug").absolutePath)
+        }
+        turbomodulejsijni {
+            headers(new File(prefabHeadersDir, "turbomodulejsijni").absolutePath)
+        }
+        runtimeexecutor {
+            headers(new File(prefabHeadersDir, "runtimeexecutor").absolutePath)
+        }
+        react_codegen_rncore {
+            headers(new File(prefabHeadersDir, "react_codegen_rncore").absolutePath)
+        }
+        react_debug {
+            headers(new File(prefabHeadersDir, "react_debug").absolutePath)
+        }
+        react_render_componentregistry {
+            headers(new File(prefabHeadersDir, "react_render_componentregistry").absolutePath)
+        }
+        react_newarchdefaults {
+            headers(new File(prefabHeadersDir, "react_newarchdefaults").absolutePath)
+        }
+        react_render_core {
+            headers(new File(prefabHeadersDir, "react_render_core").absolutePath)
+        }
+        react_render_graphics {
+            headers(new File(prefabHeadersDir, "react_render_graphics").absolutePath)
+        }
+        rrc_image {
+            headers(new File(prefabHeadersDir, "rrc_image").absolutePath)
+        }
+        rrc_view {
+            headers(new File(prefabHeadersDir, "rrc_view").absolutePath)
+        }
+        jsi {
+            headers(new File(prefabHeadersDir, "jsi").absolutePath)
+        }
+        glog {
+            headers(new File(prefabHeadersDir, "glog").absolutePath)
+        }
+        fabricjni {
+            headers(new File(prefabHeadersDir, "fabricjni").absolutePath)
+        }
+        react_render_mapbuffer {
+            headers(new File(prefabHeadersDir, "react_render_mapbuffer").absolutePath)
+        }
+        yoga {
+            headers(new File(prefabHeadersDir, "yoga").absolutePath)
+        }
+        folly_runtime {
+            headers(new File(prefabHeadersDir, "folly_runtime").absolutePath)
+        }
+        react_nativemodule_core {
+            headers(new File(prefabHeadersDir, "react_nativemodule_core").absolutePath)
+        }
+        react_render_imagemanager {
+            headers(new File(prefabHeadersDir, "react_render_imagemanager").absolutePath)
+        }
     }
 
     publishing {
         multipleVariants {
             withSourcesJar()
-            allVariants()
+            includeBuildTypeValues('debug', 'release')
         }
     }
 }
@@ -381,8 +564,9 @@ dependencies {
     api("androidx.appcompat:appcompat:${ANDROIDX_APPCOMPAT_VERSION}")
     api("androidx.autofill:autofill:${ANDROIDX_AUTOFILL_VERSION}")
     api("androidx.swiperefreshlayout:swiperefreshlayout:${SWIPEREFRESH_LAYOUT_VERSION}")
+    api("androidx.tracing:tracing:${ANDROIDX_TRACING_VERSION}")
 
-    api("com.facebook.fbjni:fbjni-java-only:${FBJNI_VERSION}")
+    api("com.facebook.fbjni:fbjni:${FBJNI_VERSION}")
     api("com.facebook.fresco:fresco:${FRESCO_VERSION}")
     api("com.facebook.fresco:imagepipeline-okhttp3:${FRESCO_VERSION}")
     api("com.facebook.fresco:ui-common:${FRESCO_VERSION}")
@@ -396,9 +580,6 @@ dependencies {
     api("com.squareup.okio:okio:${OKIO_VERSION}")
     api("javax.inject:javax.inject:${JAVAX_INJECT_VERSION}")
 
-    extractHeaders("com.facebook.fbjni:fbjni:${FBJNI_VERSION}:headers")
-    extractJNI("com.facebook.fbjni:fbjni:${FBJNI_VERSION}")
-
     // It's up to the consumer to decide if hermes should be included or not.
     // Therefore hermes-engine is a compileOnly dependency.
     compileOnly(project(":ReactAndroid:hermes-engine"))
@@ -424,69 +605,24 @@ react {
     root = file("..")
     jsRootDir = file("../Libraries")
     reactNativeDir = file("$projectDir/..")
-    useJavaGenerator = System.getenv("USE_CODEGEN_JAVAPOET")?.toBoolean() ?: false
     // We search for the codegen in either one of the `node_modules` folder or in the
     // root packages folder (that's for when we build from source without calling `yarn install`).
     codegenDir = file(findNodeModulePath(projectDir, "react-native-codegen") ?: "../packages/react-native-codegen/")
 }
 
-afterEvaluate {
-    // Needed as some of the native sources needs to be downloaded
-    // before configureNdkBuildDebug could be executed.
-    reactNativeArchitectures().each { architecture ->
-        tasks.findByName("configureCMakeDebug[${architecture}]")?.configure { dependsOn(preBuild) }
-        tasks.findByName("configureCMakeRelWithDebInfo[${architecture}]")?.configure { dependsOn(preBuild) }
-    }
-    configureCMakeDebug.dependsOn(preBuild)
-    configureCMakeRelWithDebInfo.dependsOn(preBuild)
-
-    publishing {
-        publications {
-            release(MavenPublication) {
-                // We do a multi variant release
-                from components.default
-
-                // You can then customize attributes of the publication as shown below.
-                artifactId = POM_ARTIFACT_ID
-                groupId = GROUP
-                version = VERSION_NAME
-
-                pom {
-                    name = POM_NAME
-                    description = "A framework for building native apps with React"
-                    url = "https://github.com/facebook/react-native"
-
-                    developers {
-                        developer {
-                            id = "facebook"
-                            name = "Facebook"
-                        }
-                    }
-
-                    licenses {
-                        license {
-                            name = "MIT License"
-                            url = "https://github.com/facebook/react-native/blob/HEAD/LICENSE"
-                            distribution = "repo"
-                        }
-                    }
-
-                    scm {
-                        url = "https://github.com/facebook/react-native.git"
-                        connection = "scm:git:https://github.com/facebook/react-native.git"
-                        developerConnection = "scm:git:git@github.com:facebook/react-native.git"
-                    }
-                }
-            }
-        }
+apply plugin: "org.jetbrains.kotlin.android"
 
-        repositories {
-            maven {
-                name = "npm"
-                url = AAR_OUTPUT_URL
-            }
+/* Publishing Configuration */
+apply from: "./publish.gradle"
+
+// We need to override the artifact ID as this project is called `ReactAndroid` but
+// the maven coordinates are on `react-android`.
+// Please note that the original coordinates, `react-native`, have been voided
+// as they caused https://github.com/facebook/react-native/issues/35210
+publishing {
+    publications {
+        getByName("release") {
+            artifactId 'react-android'
         }
     }
 }
-
-apply plugin: "org.jetbrains.kotlin.android"

package/ReactAndroid/cmake-utils/ReactNative-application.cmake

@@ -12,11 +12,23 @@
 # - Include all the pre-built libraries in your build graph
 # - Link your library against those prebuilt libraries so you can access JSI, Fabric, etc.
 # - Link your library against any autolinked library.
+# - Make sure ccache is used as part of the compilation process, if you have it installed.
 
 cmake_minimum_required(VERSION 3.13)
 set(CMAKE_VERBOSE_MAKEFILE on)
 
-include(${REACT_ANDROID_DIR}/cmake-utils/Android-prebuilt.cmake)
+include(${CMAKE_CURRENT_LIST_DIR}/folly-flags.cmake)
+
+# We configured the REACT_COMMON_DIR variable as it's commonly used to reference
+# shared C++ code in other targets.
+set(REACT_COMMON_DIR ${REACT_ANDROID_DIR}/../ReactCommon)
+
+# If you have ccache installed, we're going to honor it.
+find_program(CCACHE_FOUND ccache)
+if(CCACHE_FOUND)
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+endif(CCACHE_FOUND)
 
 set(BUILD_DIR ${PROJECT_BUILD_DIR})
 if(CMAKE_HOST_WIN32)
@@ -36,26 +48,72 @@ target_include_directories(${CMAKE_PROJECT_NAME}
 
 target_compile_options(${CMAKE_PROJECT_NAME} PRIVATE -Wall -Werror -fexceptions -frtti -std=c++17 -DWITH_INSPECTOR=1 -DLOG_TAG=\"ReactNative\")
 
+# Prefab packages from React Native
+find_package(ReactAndroid REQUIRED CONFIG)
+add_library(react_render_debug ALIAS ReactAndroid::react_render_debug)
+add_library(turbomodulejsijni ALIAS ReactAndroid::turbomodulejsijni)
+add_library(runtimeexecutor ALIAS ReactAndroid::runtimeexecutor)
+add_library(react_codegen_rncore ALIAS ReactAndroid::react_codegen_rncore)
+add_library(react_debug ALIAS ReactAndroid::react_debug)
+add_library(react_render_componentregistry ALIAS ReactAndroid::react_render_componentregistry)
+add_library(react_newarchdefaults ALIAS ReactAndroid::react_newarchdefaults)
+add_library(react_render_core ALIAS ReactAndroid::react_render_core)
+add_library(react_render_graphics ALIAS ReactAndroid::react_render_graphics)
+add_library(rrc_view ALIAS ReactAndroid::rrc_view)
+add_library(jsi ALIAS ReactAndroid::jsi)
+add_library(glog ALIAS ReactAndroid::glog)
+add_library(fabricjni ALIAS ReactAndroid::fabricjni)
+add_library(react_render_mapbuffer ALIAS ReactAndroid::react_render_mapbuffer)
+add_library(yoga ALIAS ReactAndroid::yoga)
+add_library(folly_runtime ALIAS ReactAndroid::folly_runtime)
+add_library(react_nativemodule_core ALIAS ReactAndroid::react_nativemodule_core)
+add_library(react_render_imagemanager ALIAS ReactAndroid::react_render_imagemanager)
+add_library(rrc_image ALIAS ReactAndroid::rrc_image)
+
+find_package(fbjni REQUIRED CONFIG)
+add_library(fbjni ALIAS fbjni::fbjni)
+
 target_link_libraries(${CMAKE_PROJECT_NAME}
-        fabricjni
-        fbjni
-        folly_runtime
-        glog
-        jsi
-        react_codegen_rncore
-        react_debug
-        react_nativemodule_core
-        react_render_componentregistry
-        react_render_core
-        react_render_debug
-        react_render_graphics
-        rrc_view
-        runtimeexecutor
-        turbomodulejsijni
-        yoga)
+        fabricjni                           # prefab ready
+        fbjni                               # via 3rd party prefab
+        folly_runtime                       # prefab ready
+        glog                                # prefab ready
+        jsi                                 # prefab ready
+        react_codegen_rncore                # prefab ready
+        react_debug                         # prefab ready
+        react_nativemodule_core             # prefab ready
+        react_newarchdefaults               # prefab ready
+        react_render_componentregistry      # prefab ready
+        react_render_core                   # prefab ready
+        react_render_debug                  # prefab ready
+        react_render_graphics               # prefab ready
+        react_render_imagemanager           # prefab ready
+        react_render_mapbuffer              # prefab ready
+        rrc_image                           # prefab ready
+        rrc_view                            # prefab ready
+        runtimeexecutor                     # prefab ready
+        turbomodulejsijni                   # prefab ready
+        yoga)                               # prefab ready
+
+# We use an interface target to propagate flags to all the generated targets
+# such as the folly flags or others.
+add_library(common_flags INTERFACE)
+target_compile_options(common_flags INTERFACE ${folly_FLAGS})
+target_link_libraries(ReactAndroid::react_codegen_rncore INTERFACE common_flags)
 
 # If project is on RN CLI v9, then we can use the following lines to link against the autolinked 3rd party libraries.
 if(EXISTS ${PROJECT_BUILD_DIR}/generated/rncli/src/main/jni/Android-rncli.cmake)
         include(${PROJECT_BUILD_DIR}/generated/rncli/src/main/jni/Android-rncli.cmake)
         target_link_libraries(${CMAKE_PROJECT_NAME} ${AUTOLINKED_LIBRARIES})
+        foreach(autolinked_library ${AUTOLINKED_LIBRARIES})
+            target_link_libraries(${autolinked_library} common_flags)
+        endforeach()
+endif()
+
+# If project is running codegen at the app level, we want to link and build the generated library.
+if(EXISTS ${PROJECT_BUILD_DIR}/generated/source/codegen/jni/CMakeLists.txt)
+        add_subdirectory(${PROJECT_BUILD_DIR}/generated/source/codegen/jni/ codegen_app_build)
+        get_property(APP_CODEGEN_TARGET DIRECTORY ${PROJECT_BUILD_DIR}/generated/source/codegen/jni/ PROPERTY BUILDSYSTEM_TARGETS)
+        target_link_libraries(${CMAKE_PROJECT_NAME} ${APP_CODEGEN_TARGET})
+        target_link_libraries(${APP_CODEGEN_TARGET} common_flags)
 endif()

package/ReactAndroid/cmake-utils/default-app-setup/CMakeLists.txt

@@ -0,0 +1,31 @@
+# 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.
+
+# This CMake file is the default used by apps and is placed inside react-native
+# to encapsulate it from user space (so you won't need to touch C++/Cmake code at all on Android).
+#
+# If you wish to customize it (because you want to manually link a C++ library or pass a custom
+# compilation flag) you can:
+#
+# 1. Copy this CMake file inside the `android/app/src/main/jni` folder of your project
+# 2. Copy the OnLoad.cpp (in this same folder) file inside the same folder as above.
+# 3. Extend your `android/app/build.gradle` as follows
+#
+# android {
+#    // Other config here...
+#    externalNativeBuild {
+#        cmake {
+#            path "src/main/jni/CMakeLists.txt"
+#        }
+#    }
+# }
+
+cmake_minimum_required(VERSION 3.13)
+
+# Define the library name here.
+project(appmodules)
+
+# This file includes all the necessary to let you build your application with the New Architecture.
+include(${REACT_ANDROID_DIR}/cmake-utils/ReactNative-application.cmake)