react-native-reanimated 2.9.1 → 2.11.0

package/android/build.gradle

@@ -1,10 +1,7 @@
-import java.nio.file.Paths
+import com.android.Version
 import org.apache.tools.ant.filters.ReplaceTokens
 
-import java.util.regex.Matcher
-import java.util.regex.Pattern
-import groovy.json.JsonSlurper
-import java.util.zip.ZipFile
+import java.nio.file.Paths
 
 /**
  * Finds the path of the installed npm package with the given name using Node's
@@ -45,22 +42,27 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
-def getCurrentFlavor() {
-    String taskRequestName = getGradle().getStartParameter().getTaskRequests().toString()
-    Pattern pattern = Pattern.compile("(assemble|bundle|install|generate)(\\w*)(Release|Debug)")
-    Matcher matcher = pattern.matcher(taskRequestName)
-
-    if (matcher.find()) {
-        return matcher.group(2)
+def safeAppExtGet(prop, fallback) {
+    def appProject = null
+    try {
+        appProject = project(":app")
+    } catch(Exception e) {
+        return fallback
     }
-
-    return "NOT-FOUND"
+    appProject?.ext?.has(prop) ? appProject.ext.get(prop) : fallback
 }
 
 def resolveBuildType() {
-    def buildType = System.getenv("CLIENT_SIDE_BUILD")
-    if (buildType != null) {
-        return buildType == "True"
+    Gradle gradle = getGradle()
+    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
+    
+    return tskReqStr.contains('Release') ? 'release' : 'debug'
+}
+
+def resolveClientSideBuild() {
+    def clientSideBuild = System.getenv("CLIENT_SIDE_BUILD")
+    if (clientSideBuild != null) {
+        return clientSideBuild == "True"
     }
 
     if (hasProperty("clientSideBuild")) {
@@ -76,62 +78,174 @@ def resolveBuildType() {
 
 def isDeveloperMode() {
     // developer mode, to run Example app
-    return file("$projectDir/../node_modules/react-native/package.json").exists()
+    return safeAppExtGet("isReanimatedExampleApp", false) || System.getenv("REANIMATED_PACKAGE_BUILD") == "1"
+}
+
+def isNewArchitectureEnabled() {
+    // To opt-in for the New Architecture, you can either:
+    // - Set `newArchEnabled` to true inside the `gradle.properties` file
+    // - Invoke gradle with `-newArchEnabled=true`
+    // - Set an environment variable `ORG_GRADLE_PROJECT_newArchEnabled=true`
+    return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
 }
 
 def resolveReactNativeDirectory() {
+    def reactNativeLocation = safeAppExtGet("REACT_NATIVE_NODE_MODULES_DIR", null)
+    if (reactNativeLocation != null) {
+        return file(reactNativeLocation)
+    }
+
     if (isDeveloperMode()) {
-        return file("$projectDir/../node_modules/react-native")
-    }
-    return file("$projectDir/../../react-native")
-}
-
-abstract class replaceSoTask extends DefaultTask {
-    public static String appName = ":app"
-    public static String buildDir = "../../../android/app/build"
-    public static String fbjniVersion = "0.3.0"
-
-    @TaskAction
-    def run() {
-        def libSoDir = new File("${buildDir}/tmp/libSo")
-        if (!libSoDir.exists()) {
-            libSoDir.mkdirs()
-            def fbjniUrl = "https://repo1.maven.org/maven2/com/facebook/fbjni/fbjni/${fbjniVersion}/fbjni-${fbjniVersion}.aar"
-            def aarFile = new File("${libSoDir.path}/fbjni-${fbjniVersion}.aar")
-            aarFile.createNewFile()
-            aarFile.withOutputStream { out ->
-                def url = new URL(fbjniUrl).openConnection()
-                out << url.inputStream
-            }
-            if (!aarFile.exists()) {
-                println("Unable to find ${libSoDir.path}/fbjni-${fbjniVersion}.aar")
-                return
-            }
-            def zipFile = new ZipFile(new File("${libSoDir.path}/fbjni-${fbjniVersion}.aar"))
-            zipFile.entries().each {
-                def zipIt = it
-                if (zipIt.name.contains("libfbjni.so")) {
-                    new File("${libSoDir.path}/" + zipIt.name.replace("/libfbjni.so", "")).mkdirs()
-                    new File("${libSoDir.path}/" + zipIt.name).withOutputStream{
-                        it << zipFile.getInputStream(zipIt)
-                    }
-                }
-            }
-        }
-        for(def abiVersion in ["x86", "x86_64", "armeabi-v7a", "arm64-v8a"]) {
-            ant.sequential {
-                copy(
-                        tofile: "${buildDir}/intermediates/merged_native_libs/debug/out/lib/${abiVersion}/libfbjni.so",
-                        file: "${buildDir}/tmp/libSo/jni/${abiVersion}/libfbjni.so",
-                        overwrite: true
-                )
+        return file("$projectDir/../${getPlaygroundAppName()}/node_modules/react-native")
+    }
+
+    // monorepo workaround
+    // react-native can be hoisted or in project's own node_modules
+    def reactNativeFromProjectNodeModules = file("${rootProject.projectDir}/../node_modules/react-native")
+    if (reactNativeFromProjectNodeModules.exists()) {
+        return reactNativeFromProjectNodeModules
+    }
+    
+    def reactNativeFromNodeModulesWithReanimated = file("${projectDir}/../../react-native")
+    if (reactNativeFromNodeModulesWithReanimated.exists()) {
+        return reactNativeFromNodeModulesWithReanimated
+    }
+
+    throw new Exception(
+        "[Reanimated] Unable to resolve react-native location in " +
+        "node_modules. You should project extension property (in app/build.gradle) " +
+        "`REACT_NATIVE_NODE_MODULES_DIR` with path to react-native."
+    )
+}
+
+def getPlaygroundAppName() { // only for the development
+    String playgroundAppName = ""
+    try {
+        rootProject.getSubprojects().forEach({project ->
+            if (project.plugins.hasPlugin("com.android.application")) {
+                var projectCatalogAbsolutePath = project.projectDir.toString().replace("/android/app", "")
+                var slashPosition = projectCatalogAbsolutePath.lastIndexOf("/")
+                playgroundAppName = projectCatalogAbsolutePath.substring(slashPosition + 1)
             }
+        })
+    } catch(_) {
+        return "NOT_FOUND"
+    }
+    return playgroundAppName
+}
+
+def shouldAssertNoMultipleInstances() {
+  if (rootProject.hasProperty("disableMultipleInstancesCheck")) {
+    return rootProject.property("disableMultipleInstancesCheck") != "true"
+  } else {
+    return true
+  }
+}
+
+def findReanimatedInstancesForPath(String path) {
+    return fileTree(path) {
+        include "**/react-native-reanimated/package.json"
+        exclude "**/.yarn/**"
+        exclude {{ file, attr -> attr.isSymbolicLink() }}
+    }.files
+}
+
+def assertNoMultipleInstances() {
+    // Assert there are no multiple installations of Reanimated
+    Set<File> files
+    if (projectDir.path.contains(rootDir.parent)) {
+        // standard app
+        files = findReanimatedInstancesForPath(rootDir.parent + "/node_modules")
+    } else {
+        // monorepo
+        files = findReanimatedInstancesForPath(rootDir.parent + "/node_modules")
+        files.addAll(
+            findReanimatedInstancesForPath(file(projectDir.parent).parent)
+        )
+    }
+    if (files.size() > 1) {
+        String parsedLocation = files.stream().map({
+            File file -> "- " + file.toString().replace("/package.json", "")
+        }).collect().join("\n")
+        String exceptionMessage = "\nMultiple versions of Reanimated were detected. Only one " +
+            "instance of react-native-reanimated can be installed in a project. You need to " +
+            "resolve the conflict manually. Check out the documentation: " +
+            "https://docs.swmansion.com/react-native-reanimated/docs/fundamentals/" +
+            "troubleshooting#multiple-versions-of-reanimated-were-detected \n\nConflict " +
+            "between: \n" + parsedLocation + "\n";
+        throw new Exception(exceptionMessage)
+    }
+}
+
+boolean CLIENT_SIDE_BUILD = resolveClientSideBuild()
+if (CLIENT_SIDE_BUILD) {
+    configurations.maybeCreate("default")
+}
+
+def reactNativeRootDir = resolveReactNativeDirectory()
+
+def reactProperties = new Properties()
+file("$reactNativeRootDir/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
+
+def BOOST_VERSION = reactProperties.getProperty("BOOST_VERSION")
+def DOUBLE_CONVERSION_VERSION = reactProperties.getProperty("DOUBLE_CONVERSION_VERSION")
+def FOLLY_VERSION = reactProperties.getProperty("FOLLY_VERSION")
+def GLOG_VERSION = reactProperties.getProperty("GLOG_VERSION")
+def REACT_NATIVE_VERSION = reactProperties.getProperty("VERSION_NAME")
+def REACT_NATIVE_MINOR_VERSION = REACT_NATIVE_VERSION.split("\\.")[1].toInteger()
+def FBJNI_VERSION = "0.3.0"
+def REANIMATED_PACKAGE_BUILD = System.getenv("REANIMATED_PACKAGE_BUILD")
+
+// 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.
+
+def customDownloadsDir = System.getenv("REACT_NATIVE_DOWNLOADS_DIR")
+def downloadsDir = customDownloadsDir ? new File(customDownloadsDir) : new File("$buildDir/downloads")
+def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
+
+def reactNativeThirdParty = new File("$reactNativeRootDir/ReactAndroid/src/main/jni/third-party")
+def reactNativeAndroidDownloadDir = new File("$reactNativeRootDir/ReactAndroid/build/downloads")
+
+def _stackProtectorFlag = true
+
+def JS_RUNTIME = {
+    // Returns the js runtime explicitly requested in the environment variable
+    if (System.getenv("JS_RUNTIME")) {
+        return System.getenv("JS_RUNTIME")
+    }
+
+    // Detect js runtime from project setup
+    def defaultRuntimeType = "jsc";
+    def v8Project = rootProject.getSubprojects().find { project -> project.name == "react-native-v8" }
+    if (v8Project != null) {
+        return "v8"
+    }
+    def appProject = findProject(":app") ? project(":app") : null
+    return appProject?.ext?.react?.enableHermes ? "hermes" : defaultRuntimeType
+}.call()
+
+def jsRuntimeDir = {
+    if (JS_RUNTIME == "hermes") {
+        if (REACT_NATIVE_MINOR_VERSION >= 69) {
+            return Paths.get(reactNativeRootDir.path, "sdks", "hermes")
+        } else {
+            return Paths.get(reactNativeRootDir.path, "..", "hermes-engine")
         }
+    } else if (JS_RUNTIME == "v8") {
+        return findProject(":react-native-v8").getProjectDir().getParent()
+    } else {
+        return Paths.get(reactNativeRootDir.path, "ReactCommon", "jsi")
     }
+}.call()
+
+def reactNativeArchitectures() {
+    def value = project.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
 }
 
-def detectAAR(minor, engine) {
-    def rnMinorVersionCopy = Integer.parseInt(minor)
+def detectAAR(Integer rnMinorVersion, String engine) { // Reanimated2 only
+    def rnMinorVersionCopy = rnMinorVersion
     def aar = file("react-native-reanimated-${rnMinorVersionCopy}-${engine}.aar")
 
     if (aar.exists()) {
@@ -163,25 +277,13 @@ def detectAAR(minor, engine) {
     return null
 }
 
-def detectJsRuntime() {
-    def runtimeType = "jsc"
-    rootProject.getSubprojects().forEach({project ->
-        if (project.plugins.hasPlugin("com.android.application")) {
-            if (project.ext.react.enableHermes) {
-                runtimeType = "hermes"
-            }
-        }
-    })
-    return runtimeType
-}
-
-def detectReanimatedConfig() {
+def isUserDemandToBuildFromSource() { // Reanimated2 only
     def buildFromSourceConf = false
     rootProject.getSubprojects().forEach({project ->
         if (project.plugins.hasPlugin("com.android.application")) {
             if (
-                project.ext.has("reanimated")
-                && project.ext.reanimated.buildFromSource
+            project.ext.has("reanimated")
+                    && project.ext.reanimated.buildFromSource
             ) {
                 buildFromSourceConf = true
             }
@@ -190,12 +292,15 @@ def detectReanimatedConfig() {
     return buildFromSourceConf
 }
 
-def shouldBuildFromSource(aar) {
-    if (isDeveloperMode()) {
+def shouldBuildFromSource(aar, jsRuntimeName) { // Reanimated2 only
+    if (jsRuntimeName == "v8") {
+        return true
+    }
+    else if (isDeveloperMode()) {
         // Example app
         return true
     }
-    else if (detectReanimatedConfig()) {
+    else if (isUserDemandToBuildFromSource()) {
         // on user demand
         return true
     }
@@ -207,21 +312,13 @@ def shouldBuildFromSource(aar) {
     return true
 }
 
-boolean CLIENT_SIDE_BUILD = resolveBuildType()
-if (CLIENT_SIDE_BUILD) {
-    configurations.maybeCreate("default")
-}
-def reactNative = resolveReactNativeDirectory()
-def reactNativeManifest = file("$reactNative/package.json")
-def reactNativeManifestAsJson = new JsonSlurper().parseText(reactNativeManifest.text)
-def reactNativeVersion = reactNativeManifestAsJson.version as String
-def (major, minor, patch) = reactNativeVersion.tokenize('.')
-def rnMinorVersion = Integer.parseInt(minor)
-def engine = detectJsRuntime()
-def aar = detectAAR(minor, engine)
-boolean BUILD_FROM_SOURCE = shouldBuildFromSource(aar)
-
-def getTaskByPath(project, String appName, String secondPart, String flavorString, String lastPart) {
+def getTaskByPath(
+        project,
+        String appName,
+        String secondPart,
+        String flavorString,
+        String lastPart
+) {  // Reanimated2 only
     String pathName = "${appName}:${secondPart}${flavorString}${lastPart}"
     Task task = project.getTasks().findByPath(pathName)
     if (task != null) {
@@ -231,8 +328,11 @@ def getTaskByPath(project, String appName, String secondPart, String flavorStrin
     return project.getTasks().findByPath(pathName)
 }
 
-if (!BUILD_FROM_SOURCE) {
-    if (rnMinorVersion < 65) {
+def aar = detectAAR(REACT_NATIVE_MINOR_VERSION, JS_RUNTIME)
+boolean BUILD_FROM_SOURCE = shouldBuildFromSource(aar, JS_RUNTIME)
+
+if (!BUILD_FROM_SOURCE && !isNewArchitectureEnabled()) { // Reanimated2 only
+    if (REACT_NATIVE_MINOR_VERSION < 65) {
         tasks.register("replaceSoTaskDebug", replaceSoTask)
         tasks.register("replaceSoTaskRelease", replaceSoTask)
         Task replaceSoTaskDebug = project.getTasks().findByPath(":react-native-reanimated:replaceSoTaskDebug")
@@ -246,8 +346,8 @@ if (!BUILD_FROM_SOURCE) {
                     def reanimatedConf = projectProperties.get("reanimated")
 
                     if (
-                        flavorString != "NOT-FOUND"
-                        && (!reanimatedConf || (reanimatedConf && !reanimatedConf.get("enablePackagingOptions")))
+                    flavorString != "NOT-FOUND"
+                            && (!reanimatedConf || (reanimatedConf && !reanimatedConf.get("enablePackagingOptions")))
                     ) {
                         replaceSoTask.appName = projectProperties.path
                         replaceSoTask.buildDir = projectProperties.buildDir
@@ -261,9 +361,9 @@ if (!BUILD_FROM_SOURCE) {
                         Task releaseTask = getTaskByPath(project, appName, "package", flavorString, "Release")
 
                         if (
-                            debugNativeLibsTask != null && debugDebugSymbolsTask != null
-                            && releaseNativeLibsTask != null && releaseDebugSymbolsTask != null
-                            && debugTask != null && releaseTask != null
+                        debugNativeLibsTask != null && debugDebugSymbolsTask != null
+                                && releaseNativeLibsTask != null && releaseDebugSymbolsTask != null
+                                && debugTask != null && releaseTask != null
                         ) {
                             replaceSoTaskDebug.dependsOn(debugNativeLibsTask, debugDebugSymbolsTask)
                             debugTask.dependsOn(replaceSoTaskDebug)
@@ -280,48 +380,9 @@ if (!BUILD_FROM_SOURCE) {
 }
 
 // end if already loaded aar
-if (!BUILD_FROM_SOURCE) return
-
-def localProps = new Properties()
-def localPropertiesFile = file("local.properties")
-if (localPropertiesFile.exists()) {
-    localProps.load(new InputStreamReader(new FileInputStream(localPropertiesFile), "UTF-8"))
-}
-
-def debugNativeLibraries = localProps.getProperty('NATIVE_DEBUG_ON', 'FALSE').toBoolean()
-def reactProperties = new Properties()
-file("$reactNative/ReactAndroid/gradle.properties").withInputStream { reactProperties.load(it) }
-
-def BOOST_VERSION = reactProperties.getProperty("BOOST_VERSION")
-def DOUBLE_CONVERSION_VERSION = reactProperties.getProperty("DOUBLE_CONVERSION_VERSION")
-def FOLLY_VERSION = reactProperties.getProperty("FOLLY_VERSION")
-def GLOG_VERSION = reactProperties.getProperty("GLOG_VERSION")
-def REACT_VERSION = reactProperties.getProperty("VERSION_NAME").split("\\.")[1].toInteger()
-def FBJNI_VERSION = "0.3.0"
-
-// 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.
-
-def downloadsDir = new File("$buildDir/downloads")
-def thirdPartyNdkDir = new File("$buildDir/third-party-ndk")
-
-def reactNativeThirdParty = new File("$reactNative/ReactAndroid/src/main/jni/third-party")
-
-def _stackProtectorFlag = true
-def FOR_HERMES = ""
-
-if (findProject(":app")) {
-    FOR_HERMES = project(":app").ext.react.enableHermes;
-} else {
-    FOR_HERMES = System.getenv("FOR_HERMES") == "True";
-}
-
-def reactNativeArchitectures() {
-    def value = project.getProperties().get("reactNativeArchitectures")
-    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+if (!BUILD_FROM_SOURCE) {
+    return
 }
-
 // You need to have following folders in this directory:
 //   - boost_1_63_0
 //   - double-conversion-1.1.6
@@ -351,9 +412,9 @@ buildscript {
         }
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:7.1.1"
+        classpath "com.android.tools.build:gradle:7.3.0"
         classpath "de.undercouch:gradle-download-task:5.0.1"
-        classpath "com.diffplug.spotless:spotless-plugin-gradle:5.15.0"
+        classpath "com.diffplug.spotless:spotless-plugin-gradle:6.11.0"
     }
 }
 
@@ -372,16 +433,20 @@ android {
         targetSdkVersion safeExtGet("targetSdkVersion", 30)
         versionCode 1
         versionName "1.0"
+        buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
         externalNativeBuild {
             cmake {
                 arguments "-DANDROID_STL=c++_shared",
-                        "-DNATIVE_DEBUG=${debugNativeLibraries}",
-                        "-DREACT_NATIVE_TARGET_VERSION=${REACT_VERSION}",
+                        "-DREACT_NATIVE_MINOR_VERSION=${REACT_NATIVE_MINOR_VERSION}",
                         "-DANDROID_TOOLCHAIN=clang",
                         "-DBOOST_VERSION=${BOOST_VERSION}",
-                        "-DBUILD_DIR=${buildDir}",
-                        "-DFOR_HERMES=${FOR_HERMES}",
-                        "-DCLIENT_SIDE_BUILD=${CLIENT_SIDE_BUILD}"
+                        "-DREACT_NATIVE_DIR=${reactNativeRootDir.path}",
+                        "-DJS_RUNTIME=${JS_RUNTIME}",
+                        "-DJS_RUNTIME_DIR=${jsRuntimeDir}",
+                        "-DCLIENT_SIDE_BUILD=${CLIENT_SIDE_BUILD}",
+                        "-DIS_NEW_ARCHITECTURE_ENABLED=${isNewArchitectureEnabled()}",
+                        "-DPLAYGROUND_APP_NAME=${getPlaygroundAppName()}",
+                        "-DREANIMATED_PACKAGE_BUILD=${REANIMATED_PACKAGE_BUILD}"
                 abiFilters (*reactNativeArchitectures())
                 _stackProtectorFlag ? (cppFlags("-fstack-protector-all")) : null
             }
@@ -389,19 +454,41 @@ android {
 
         buildConfigField("boolean", "IS_INTERNAL_BUILD", "false")
         buildConfigField("int", "EXOPACKAGE_FLAGS", "0")
+        buildConfigField("int", "REACT_NATIVE_MINOR_VERSION", REACT_NATIVE_MINOR_VERSION.toString())
     }
     externalNativeBuild {
         cmake {
             path "CMakeLists.txt"
         }
     }
+    buildTypes {
+        debug {
+            externalNativeBuild {
+                cmake {
+                    if (JS_RUNTIME == "hermes") {
+                        arguments "-DHERMES_ENABLE_DEBUGGER=1"
+                    } else {
+                        arguments "-DHERMES_ENABLE_DEBUGGER=0"
+                    }
+                }
+            }
+        }
+        release {
+            externalNativeBuild {
+                cmake {
+                    arguments "-DHERMES_ENABLE_DEBUGGER=0"
+                }
+            }
+        }
+    }
     lintOptions {
         abortOnError false
     }
     packagingOptions {
-        println "Native libs debug enabled: ${debugNativeLibraries}"
-        doNotStrip debugNativeLibraries ? "**/**/*.so" : ''
+        doNotStrip resolveBuildType() == 'debug' ? "**/**/*.so" : ''
         excludes = [
+                "META-INF",
+                "META-INF/**",
                 "**/libc++_shared.so",
                 "**/libfbjni.so",
                 "**/libjsi.so",
@@ -409,8 +496,10 @@ android {
                 "**/libfolly_runtime.so",
                 "**/libglog.so",
                 "**/libhermes.so",
+                "**/libhermes-executor-debug.so",
                 "**/libreactnativejni.so",
                 "**/libjscexecutor.so",
+                "**/libv8executor.so",
         ]
     }
     tasks.withType(JavaCompile) {
@@ -425,6 +514,38 @@ android {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
+    packagingOptions {
+        // For some reason gradle only complains about the duplicated version of librrc_root and libreact_render libraries
+        // while there are more libraries copied in intermediates folder of the lib build directory, we exclude
+        // only the ones that make the build fail (ideally we should only include libreanimated but we
+        // are only allowed to specify exlude patterns)
+        exclude "**/libreact_render*.so"
+        exclude "**/librrc_root.so"
+    }
+    sourceSets.main {
+        java {
+            if (isNewArchitectureEnabled()) {
+                srcDirs += [
+                        "src/fabric/java",
+                ]
+            } else {
+                srcDirs += [
+                        "src/paper/java",
+                ]
+            }
+        }
+    }
+}
+
+def assertionTask = task assertNoMultipleInstancesTask {
+    onlyIf { shouldAssertNoMultipleInstances() && CLIENT_SIDE_BUILD }
+    doFirst {
+        assertNoMultipleInstances()
+    }
+}
+
+tasks.preBuild {
+    dependsOn assertionTask
 }
 
 task cleanCmakeCache() {
@@ -435,7 +556,7 @@ task cleanCmakeCache() {
 }
 
 task printVersions {
-    println "Android gradle plugin: ${com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION}"
+    println "Android gradle plugin: ${Version.ANDROID_GRADLE_PLUGIN_VERSION}"
     println "Gradle: ${project.gradle.gradleVersion}"
 }
 
@@ -444,7 +565,7 @@ task Log {
 }
 
 task applyJavaPatches(type: Copy) {
-    def patchDirectory = file("${projectDir}/rnVersionPatch/${rnMinorVersion}")
+    def patchDirectory = file("${projectDir}/rnVersionPatch/${REACT_NATIVE_MINOR_VERSION}")
     if (patchDirectory.exists()) {
         from ("${patchDirectory}") {
             include "**/*.java"
@@ -458,16 +579,70 @@ task createNativeDepsDirectories(dependsOn: applyJavaPatches) {
     thirdPartyNdkDir.mkdirs()
 }
 
-task downloadBoost(dependsOn: createNativeDepsDirectories, type: Download) {
+def resolveTaskFactory(String taskName, String artifactLocalName, File reactNativeAndroidDownloadDir, File reanimatedDownloadDir) {
+    return tasks.create(name: taskName, dependsOn: createNativeDepsDirectories, type: Copy) {
+        from reactNativeAndroidDownloadDir
+        include artifactLocalName
+        into reanimatedDownloadDir
+
+        onlyIf {
+            // First we check whether the file is already in our download directory
+            if (file("$reanimatedDownloadDir/$artifactLocalName").isFile()) {
+                return false
+            }
+
+            // If it is not the case we check whether it was downloaded by ReactAndroid project
+            if (file("$reactNativeAndroidDownloadDir/$artifactLocalName").isFile()) {
+                return true
+            }
+
+            return false
+        }
+    }
+}
+
+Task resolveBoost = resolveTaskFactory("resolveBoost", "boost_${BOOST_VERSION}.tar.gz", reactNativeAndroidDownloadDir, downloadsDir)
+Task resolveDoubleConversion = resolveTaskFactory(
+    "resolveDoubleConversion",
+    "double-conversion-${DOUBLE_CONVERSION_VERSION}.tar.gz",
+    reactNativeAndroidDownloadDir,
+    downloadsDir
+)
+Task resolveFolly = resolveTaskFactory("resolveFolly", "folly-${FOLLY_VERSION}.tar.gz", reactNativeAndroidDownloadDir, downloadsDir)
+Task resolveGlog = resolveTaskFactory("resolveGlog", "glog-${GLOG_VERSION}.tar.gz", reactNativeAndroidDownloadDir, downloadsDir)
+
+if (isNewArchitectureEnabled()) {
+    def reactNativeAndroidProject = findProject(":ReactAndroid")
+    if (reactNativeAndroidProject != null) {
+        reactNativeAndroidProject.afterEvaluate {
+            def resolveTasks = [resolveBoost, resolveGlog, resolveDoubleConversion, resolveFolly]
+            resolveTasks.forEach({ task ->
+                String reactAndroidDownloadTaskName = "download" + task.name.replace("resolve", "")
+                def reactAndroidDownloadTask = reactNativeAndroidProject.getTasks().findByName(reactAndroidDownloadTaskName)
+                if (reactAndroidDownloadTask != null) {
+                    task.dependsOn(reactAndroidDownloadTask)
+                } else {
+                    logger.warn("[Reanimated] Failed to find task named `$reactAndroidDownloadTaskName` in `:ReactAndroid` project." +
+                            " Explicit dependency between it and $task.name task can not be set.")
+                }
+            })
+        }
+    } else {
+        throw new GradleScriptException("[Reanimated] Failed to find `:ReactAndroid` project. Explicit dependency between download tasks can not be set.")
+    }
+}
+
+task downloadBoost(dependsOn: resolveBoost, type: Download) {
     def transformedVersion = BOOST_VERSION.replace("_", ".")
+    def artifactLocalName = "boost_${BOOST_VERSION}.tar.gz"
     def srcUrl = "https://boostorg.jfrog.io/artifactory/main/release/${transformedVersion}/source/boost_${BOOST_VERSION}.tar.gz"
-    if (rnMinorVersion < 69) {
+    if (REACT_NATIVE_MINOR_VERSION < 69) {
         srcUrl = "https://github.com/react-native-community/boost-for-react-native/releases/download/v${transformedVersion}-0/boost_${BOOST_VERSION}.tar.gz"
     }
     src(srcUrl)
     onlyIfNewer(true)
     overwrite(false)
-    dest(new File(downloadsDir, "boost_${BOOST_VERSION}.tar.gz"))
+    dest(new File(downloadsDir, artifactLocalName))
 }
 
 task prepareBoost(dependsOn: boostPath ? [] : [downloadBoost], type: Copy) {
@@ -481,7 +656,7 @@ task prepareBoost(dependsOn: boostPath ? [] : [downloadBoost], type: Copy) {
     }
 }
 
-task downloadDoubleConversion(dependsOn: createNativeDepsDirectories, type: Download) {
+task downloadDoubleConversion(dependsOn: resolveDoubleConversion, type: Download) {
     src("https://github.com/google/double-conversion/archive/v${DOUBLE_CONVERSION_VERSION}.tar.gz")
     onlyIfNewer(true)
     overwrite(false)
@@ -497,7 +672,7 @@ task prepareDoubleConversion(dependsOn: dependenciesPath ? [] : [downloadDoubleC
     into("$thirdPartyNdkDir/double-conversion")
 }
 
-task downloadFolly(dependsOn: createNativeDepsDirectories, type: Download) {
+task downloadFolly(dependsOn: resolveFolly, type: Download) {
     src("https://github.com/facebook/folly/archive/v${FOLLY_VERSION}.tar.gz")
     onlyIfNewer(true)
     overwrite(false)
@@ -516,7 +691,7 @@ task prepareFolly(dependsOn: dependenciesPath ? [] : [downloadFolly], type: Copy
     into("$thirdPartyNdkDir/folly")
 }
 
-task downloadGlog(dependsOn: createNativeDepsDirectories, type: Download) {
+task downloadGlog(dependsOn: resolveGlog, type: Download) {
     src("https://github.com/google/glog/archive/v${GLOG_VERSION}.tar.gz")
     onlyIfNewer(true)
     overwrite(false)
@@ -562,23 +737,97 @@ task prepareGlog(dependsOn: dependenciesPath ? [] : [downloadGlog], type: Copy)
     }
 }
 
-task prepareHermes() {
-    def hermesPackagePath = findNodeModulePath(projectDir, "hermes-engine")
-    if (!hermesPackagePath) {
-        throw new GradleScriptException("Could not find the hermes-engine npm package", null)
+/*
+Reanimated includes "hermes/hermes.h" header file in `NativeProxy.cpp`.
+Previously, we used header files from `hermes-engine` package in `node_modules`.
+Starting from React Native 0.69, Hermes is no longer distributed as package on NPM.
+On the new architecture, Hermes is downloaded from GitHub and then compiled from sources.
+However, on the old architecture, we need to download Hermes header files on our own
+as well as unzip Hermes AAR in order to obtain `libhermes.so` shared library.
+For more details, see https://reactnative.dev/architecture/bundled-hermes
+or https://github.com/reactwg/react-native-new-architecture/discussions/4
+*/
+if (REACT_NATIVE_MINOR_VERSION >= 69 && !isNewArchitectureEnabled()) {
+    // copied from `react-native/ReactAndroid/hermes-engine/build.gradle`
+
+    def downloadDir = customDownloadsDir ? new File(customDownloadsDir) : new File(reactNativeRootDir, "sdks/download")
+
+    // By default we are going to download and unzip hermes inside the /sdks/hermes folder
+    // but you can provide an override for where the hermes source code is located.
+    def hermesDir = System.getenv("REACT_NATIVE_OVERRIDE_HERMES_DIR") ?: new File(reactNativeRootDir, "sdks/hermes")
+
+    def hermesVersion = "main"
+    def hermesVersionFile = new File(reactNativeRootDir, "sdks/.hermesversion")
+    if (hermesVersionFile.exists()) {
+        hermesVersion = hermesVersionFile.text
     }
 
-    def hermesAAR = file("$hermesPackagePath/android/hermes-debug.aar")
-    if (!hermesAAR.exists()) {
-        throw new GradleScriptException("The hermes-engine npm package is missing \"android/hermes-debug.aar\"", null)
+    task downloadHermes(type: Download) {
+        src("https://github.com/facebook/hermes/tarball/${hermesVersion}")
+        onlyIfNewer(true)
+        overwrite(false)
+        dest(new File(downloadDir, "hermes.tar.gz"))
     }
 
-    def soFiles = zipTree(hermesAAR).matching({ it.include "**/*.so" })
+    task unzipHermes(dependsOn: downloadHermes, type: Copy) {
+        from(tarTree(downloadHermes.dest)) {
+            eachFile { file ->
+                // We flatten the unzip as the tarball contains a `facebook-hermes-<SHA>`
+                // folder at the top level.
+                if (file.relativePath.segments.size() > 1) {
+                    file.relativePath = new RelativePath(!file.isDirectory(), file.relativePath.segments.drop(1))
+                }
+            }
+        }
+        into(hermesDir)
+    }
+}
 
-    copy {
-        from soFiles
-        from "$reactNative/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
-        into "$thirdPartyNdkDir/hermes"
+task prepareHermes() {
+    if (REACT_NATIVE_MINOR_VERSION >= 69) {
+        if (!isNewArchitectureEnabled()) {
+            dependsOn(unzipHermes)
+        }
+
+        doLast {
+            // e.g. hermes-engine-0.70.0-rc.1-debug.aar
+            def hermesAAR = file(
+                "$reactNativeRootDir/android/com/facebook/react/hermes-engine/" +
+                "${REACT_NATIVE_VERSION}/hermes-engine-${REACT_NATIVE_VERSION}-" +
+                "${resolveBuildType()}.aar"
+            )
+            if (!hermesAAR.exists()) {
+                throw new GradleScriptException("Could not find hermes-engine AAR", null)
+            }
+
+            def soFiles = zipTree(hermesAAR).matching({ it.include "**/*.so" })
+
+            copy {
+                from soFiles
+                from "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
+                into "$thirdPartyNdkDir/hermes"
+            }
+        }
+    } else {
+        doLast {
+            def hermesPackagePath = findNodeModulePath(projectDir, "hermes-engine")
+            if (!hermesPackagePath) {
+                throw new GradleScriptException("Could not find the hermes-engine npm package", null)
+            }
+
+            def hermesAAR = file("$hermesPackagePath/android/hermes-${resolveBuildType()}.aar") // e.g. hermes-debug.aar
+            if (!hermesAAR.exists()) {
+                throw new GradleScriptException("The hermes-engine npm package is missing \"android/hermes-${resolveBuildType()}.aar\"", null)
+            }
+
+            def soFiles = zipTree(hermesAAR).matching({ it.include "**/*.so" })
+
+            copy {
+                from soFiles
+                from "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/hermes/Android.mk"
+                into "$thirdPartyNdkDir/hermes"
+            }
+        }
     }
 }
 
@@ -602,7 +851,7 @@ task prepareJSC {
         copy {
             from(soFiles)
             from(headerFiles)
-            from("$reactNative/ReactAndroid/src/main/jni/third-party/jsc/Android.mk")
+            from("$reactNativeRootDir/ReactAndroid/src/main/jni/third-party/jsc/Android.mk")
 
             filesMatching("**/*.h", { it.path = "JavaScriptCore/${it.name}" })
 
@@ -619,7 +868,7 @@ task extractAARHeaders {
             def packageName = file.name.tokenize('-')[0]
             copy {
                 from zipTree(file)
-                into "$reactNative/ReactAndroid/src/main/jni/first-party/$packageName/headers"
+                into "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/$packageName/headers"
                 include "**/*.h"
             }
         }
@@ -633,7 +882,7 @@ task extractSOFiles {
             def packageName = file.name.tokenize('-')[0]
             copy {
                 from zipTree(file)
-                into "$reactNative/ReactAndroid/src/main/jni/first-party/$packageName/"
+                into "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/$packageName/"
                 include "jni/**/*.so"
             }
         }
@@ -643,7 +892,7 @@ task extractSOFiles {
 task packageNdkLibs(type: Copy) {
     from("$buildDir/reanimated-ndk/all")
     include("**/libreanimated.so")
-    if(REACT_VERSION < 64) {
+    if(REACT_NATIVE_MINOR_VERSION < 64) {
         include("**/libturbomodulejsijni.so")
     }
     into("$projectDir/src/main/jniLibs")
@@ -654,11 +903,11 @@ repositories {
     mavenLocal()
     maven {
         // All of React Native (JS, Obj-C sources, Android binaries) is installed from npm
-        url "$reactNative/android"
+        url "$reactNativeRootDir/android"
     }
     maven {
         // Android JSC is installed from npm
-        url "$reactNative/../jsc-android/dist"
+        url "$reactNativeRootDir/../jsc-android/dist"
     }
     google()
 }
@@ -666,7 +915,7 @@ repositories {
 dependencies {
     // noinspection GradleDynamicVersion
     implementation "com.facebook.yoga:proguard-annotations:1.19.0"
-    if (isDeveloperMode()) {
+    if (isDeveloperMode() && !isNewArchitectureEnabled()) {
         implementation "com.facebook.fbjni:fbjni:" + FBJNI_VERSION
     }
     else {
@@ -674,22 +923,29 @@ dependencies {
     }
     implementation "com.facebook.react:react-native:+" // From node_modules
     implementation "androidx.transition:transition:1.1.0"
+    implementation "androidx.core:core:1.6.0"
+    
     extractHeaders("com.facebook.fbjni:fbjni:" + FBJNI_VERSION + ":headers")
     extractSO("com.facebook.fbjni:fbjni:" + FBJNI_VERSION)
 
-    def buildType = "debug"
-    tasks.all({ task ->
-        if (task.name == "buildCMakeRelease") {
-            buildType = "release"
-        }
-    })
+    def jscAAR = fileTree("$reactNativeRootDir/../jsc-android/dist/org/webkit/android-jsc").matching({ it.include "**/**/*.aar" }).singleFile
+    extractSO(files(jscAAR))
+}
+
+task unpackReactNativeAAR {
+    def buildType = resolveBuildType()
     def rnAarMatcher = "**/react-native/**/*${buildType}.aar"
-    if (rnMinorVersion < 69) {
+    if (REACT_NATIVE_MINOR_VERSION < 69) {
         rnAarMatcher = "**/**/*.aar"
     }
-    def rnAAR = fileTree("$reactNative/android").matching({ it.include rnAarMatcher }).singleFile
-    def jscAAR = fileTree("$reactNative/../jsc-android/dist/org/webkit/android-jsc").matching({ it.include "**/**/*.aar" }).singleFile
-    extractSO(files(rnAAR, jscAAR))
+    def rnAAR = fileTree("$reactNativeRootDir/android").matching({ it.include rnAarMatcher }).singleFile
+    def file = rnAAR.absoluteFile
+    def packageName = file.name.tokenize('-')[0]
+    copy {
+        from zipTree(file)
+        into "$reactNativeRootDir/ReactAndroid/src/main/jni/first-party/$packageName/"
+        include "jni/**/*.so"
+    }
 }
 
 task downloadNdkBuildDependencies {
@@ -701,8 +957,14 @@ task downloadNdkBuildDependencies {
     dependsOn(downloadGlog)
 }
 
-task prepareThirdPartyNdkHeaders(dependsOn:[downloadNdkBuildDependencies, prepareBoost, prepareDoubleConversion, prepareFolly, prepareGlog]) {
-}
+task prepareThirdPartyNdkHeaders(dependsOn:[
+    downloadNdkBuildDependencies,
+    prepareBoost,
+    prepareDoubleConversion,
+    prepareFolly,
+    prepareGlog,
+    unpackReactNativeAAR]
+) {}
 
 def nativeBuildDependsOn(dependsOnTask) {
     def buildTasks = tasks.findAll({ task ->
@@ -717,13 +979,36 @@ afterEvaluate {
     nativeBuildDependsOn(prepareThirdPartyNdkHeaders)
     nativeBuildDependsOn(extractAARHeaders)
     nativeBuildDependsOn(extractSOFiles)
+
+    tasks.forEach({ task ->
+        if (task.name.contains("JniLibFolders")) {
+            task.dependsOn(packageNdkLibs)
+        }
+    })
+
+    if (JS_RUNTIME == "hermes") {
+      extractAARHeaders.dependsOn(prepareHermes)
+      extractSOFiles.dependsOn(prepareHermes)
+    } else if (JS_RUNTIME == "v8") {
+        def buildTasks = tasks.findAll({ task ->
+            !task.name.contains("Clean") && (task.name.contains("externalNative") || task.name.contains("CMake") || task.name.startsWith("generateJsonModel")) })
+        buildTasks.forEach { task ->
+            def buildType = task.name.endsWith('Debug') ? 'Debug' : 'Release'
+            task.dependsOn(":react-native-v8:copy${buildType}JniLibsProjectOnly")
+        }
+    } else if (JS_RUNTIME == "jsc") {
+      extractAARHeaders.dependsOn(prepareJSC)
+      extractSOFiles.dependsOn(prepareJSC)
+    } else {
+      throw GradleScriptException("Unknown JS runtime ${JS_RUNTIME}.")
+    }
 }
 
 if (CLIENT_SIDE_BUILD) {
     def aarDir = "${buildDir}/outputs"
-    aar = file("${aarDir}/android-debug.aar")
+    aar = file("${aarDir}/android-${resolveBuildType()}.aar") // e.g. android-debug.aar
     if (aar == null) {
         throw GradleScriptException("AAR build failed. No AAR found in ${aarDir}.")
     }
     artifacts.add("default", aar)
-}
+}